/*************************************************************************
* 版权所有：
* 文件版本： V1.00
* 文件名称： reclose.c
* 生成日期： 2007年10月15日
* 作     者： 保护部 MWD
* 功     能： 重合闸模块
             包含:  重合闸数据准备、
                    检同期数据准备、
                    抽取电压数据判别、
                    闭锁重合闸判别、
                    充电、
                    重合闸启动、
                    重合闸检定、
                    重合逻辑
**************************************************************************/
#define __RECLOSE_C
#include "head.h"

/**********************************************************************
定义全局变量
***********************************************************************/
/*------------------------------ 函数声明 -------------------------------------
 */
static void AR_DataSet(int sw);
static void AR_Recharge(int sw, DWORD dStep);
static void AR_Disable(int sw);
static void AR_Start(int sw, DWORD dStep);
static void AR_Logic(int sw, DWORD dStep);
static void AR_Reset(int sw, DWORD dStep);
static void ARTQ_DataSet(int sw);

/**************************************************************************
函数名称: AutoReclose
函数版本：1.00
作者：    硬件部
创建日期：2010.4.28

函数功能说明：重合闸功能块

输入参数：
输出参数：
返回值：
***************************************************************************/
void AutoReclose(int sw, DWORD dStep)
{
    AR_DataSet(sw); // 重合闸数据准备
    ARTQ_DataSet(sw);
    AR_Recharge(sw, dStep); // 重合闸充电
    AR_Disable(sw);         // 重合闸闭锁
    AR_Start(sw, dStep);    // 重合闸启动
    AR_Logic(sw, dStep);    // 重合闸逻辑
    AR_Reset(sw, dStep);    // 重合闸复归
    return;
}

void ARTQ_DataSet(int sw)
{

    TCH_T *pSW = &g_tRelay[sw].tCHZ;
    TSETSW *pSet = &pRunSet->tSwSet[sw];
    bool bDa = false;
    bool bDu = false;
    long deltaA;
    qs16 ang2 = 0;
    TRELAY_T *pR = &g_tRelay[sw];
    static int print_flag = 0;

    if (pRunSet->pt2vol == PUB_AC_UAB1)
        ang2 = 0;
    else if (pRunSet->pt2vol == PUB_AC_UBC1)
        ang2 = -120 * 65536;
    else if (pRunSet->pt2vol == PUB_AC_UCA1)
        ang2 = 120 * 65536;
    else if (pRunSet->pt2vol == PUB_AC_UAB2)
        ang2 = 0;
    else if (pRunSet->pt2vol == PUB_AC_UBC2)
        ang2 = -120 * 65536;
    else if (pRunSet->pt2vol == PUB_AC_UCA2)
        ang2 = 120 * 65536;

    pSW->sta.bFlag.bMxYY = OverRelay(g_ui[PUB_AC_UAB1].m2[0], pSet->dU_chz_yy, pSet->dU_chz_yy, false);
    pSW->sta.bFlag.bMxWY = LowRelay(g_ui[PUB_AC_UAB1].m2[0], pSet->dU_chz_wy, pSet->dU_chz_wy, false);
    pSW->sta.bFlag.bUxYY = OverRelay(g_ui[pRunSet->pt2vol].m2[0], pSet->dU_chz_yy, pSet->dU_chz_yy, false);
    pSW->sta.bFlag.bUxWY = LowRelay(g_ui[pRunSet->pt2vol].m2[0], pSet->dU_chz_wy, pSet->dU_chz_wy, false);

    deltaA = CalcAngSub(g_ui[PUB_AC_UAB1].ri.r, g_ui[PUB_AC_UAB1].ri.i, g_ui[pRunSet->pt2vol].ri.r, g_ui[pRunSet->pt2vol].ri.i);
    // deltaA = _AbsL(deltaA+ang2);//
    // deltaA = _AbsL((g_ui[PUB_AC_UAB1].p -ang1)- (g_ui[pRunSet->pt2vol].p-ang2));

    // bDa=((_AbsL(deltaA)  < pSet->dA_chz_deltaAng)?true:false)&&pSW->sta.bFlag.bMxYY&&pSW->sta.bFlag.bUxYY; //角差满足要求
    bDa = ((_AbsL(deltaA + ang2) < pSet->dA_chz_deltaAng) ? true : false) && pSW->sta.bFlag.bMxYY && pSW->sta.bFlag.bUxYY; // 角差满足要求

    bDu = (_AbsL(g_ui[PUB_AC_UAB1].fz - g_ui[pRunSet->pt2vol].fz) < pSet->dU_chz_deltaU) ? true : false; // 压差满足要求

    pSW->sta.bFlag.bTQMZ =
#ifdef CHZ_JWY_LM
        (pSet->bTT_chz_tq || pSet->bTT_chz_mwy || pSet->bTT_chz_lwy) // 同期合闸
#else
        (pSet->bTT_chz_tq || pSet->bTT_chz_wy) // 同期合闸
#endif
        && pSW->sta.bFlag.bMxYY     // 母线有压
        && pSW->sta.bFlag.bUxYY     // 线路有压
        && bDu                      // 压差满足
        && bDa                      // 角差满足
        && !tPT.uPT1DX.bFlag.bPTYC  // 无PT 异常
        && !tPT.uPT2DX.bFlag.bPTYC; // 无PT 异常

    pSW->sta.bFlag.bMWYMZ =
#ifdef CHZ_JWY_LM
        (pSet->bTT_chz_mwy && pSW->sta.bFlag.bMxWY && pSW->sta.bFlag.bUxYY) // 母线无压&&线路有压
#else
        (pSet->bTT_chz_wy) // 无压合闸
#endif
        && pSW->sta.bFlag.bMxWY     // 母线有压
        && !tPT.uPT1DX.bFlag.bPTYC; // 无PT 异常

    pSW->sta.bFlag.bUWYMZ =
#ifdef CHZ_JWY_LM
        (pSet->bTT_chz_lwy && pSW->sta.bFlag.bUxWY && pSW->sta.bFlag.bMxYY) // 线路无压&&母线有压
#else
        (pSet->bTT_chz_wy) // 无压合闸
#endif
        && pSW->sta.bFlag.bUxWY     // 线路无压
        && !tPT.uPT2DX.bFlag.bPTYC; // 无PT 异常

    pSW->sta.bFlag.bCHMZ = pSW->sta.bFlag.bTQMZ     // 同期满足
                           || pSW->sta.bFlag.bMWYMZ // 母线无压满足
                           || pSW->sta.bFlag.bUWYMZ // 线路无压满足
#ifdef CHZ_JWY_LM
                           || ((!pSet->bTT_chz_tq) && (!pSet->bTT_chz_mwy) && (!pSet->bTT_chz_lwy))
#else
                           || ((!pSet->bTT_chz_tq) && (!pSet->bTT_chz_wy))
#endif
        ;
    if (pR->tCHZ.sta.bFlag.bCHQD)
    {
        if (!pSW->sta.bFlag.bTQMZ && (print_flag++ % (1 * 200)) == 0) // 1S
        {
            if ((!bDa) && (pSet->bTT_chz_tq))
                dp_info_nt_rt("角差不满足 pt1=%d pt2=%d ang2=%d      角差=%d 相位补偿后角差=%d        dz=%d pt2vol=%d",
                              (g_ui[PUB_AC_UAB1].p) / 65536,
                              (g_ui[pRunSet->pt2vol].p) / 65536,
                              ang2 / 65536,
                              deltaA / 65536,
                              _AbsL(deltaA + ang2) / 65536,
                              pSet->dA_chz_deltaAng / 65536,
                              pRunSet->pt2vol);
#ifndef CHZ_JWY_LM
            if ((!bDu) && (pSet->bTT_chz_wy))
                dp_info_nt_rt("压差不满足");
#endif
        }
    }
}

/**************************************************************************
函数名称：AR_DataSet
函数版本：1.00
函数版本：1.00
作者：    硬件部
创建日期：2010.4.28

函数功能说明：重合闸数据准备

输入参数：无

输出参数：

返回值： 无
***************************************************************************/
static void AR_DataSet(int sw)
{
    u16 wNo;
    TRELAY_T *pR = &g_tRelay[sw];
    TCH_T *pSW = &pR->tCHZ;
    TSETSW *pSet = &pRunSet->tSwSet[sw];

    wNo = 0;
    if (pSW->wAR_ActTimes < MAX_AR_TIMES) // 根据重合次数，设置时间继电器
    {
        wNo = pSW->wAR_ActTimes;
    }
    InitTR_Time(&pSW->tTCHJD_ARDelay, pSet->dT_chz[wNo], 0);     // 重合闸延时
    InitTR_Time(&pSW->tTCHFAIL_TW, pSet->dT_chz[wNo] + T_1s, 0); // 重合闸延时
}

/**************************************************************************
函数名称: AR_Disable
函数版本：1.00
作者：    保护产品部
创建日期：2007.10.11

函数功能说明：重合闸闭锁判别，刷新"闭锁重合闸"标

输入参数：
输出参数：
返回值：
***************************************************************************/
static void AR_Disable(int sw)
{
    TRELAY_T *pR = &g_tRelay[sw];
    TCH_T *pSW = &pR->tCHZ;
    pSW->sta.bFlag.bBSCH = pR->tOC[BH_GL1].sta.bFlag.bBSCH    // 过流闭锁重合闸
                           || pR->tOC[BH_GL2].sta.bFlag.bBSCH //
                           || pR->tOC[BH_GL3].sta.bFlag.bBSCH //
                           || pR->tOC[BH_LX1].sta.bFlag.bBSCH //
                           || pR->tOC[BH_LX2].sta.bFlag.bBSCH //
                           || pR->tOC[BH_LX3].sta.bFlag.bBSCH //
                           || pR->tLostVot.uLostVot.bFlag.bTz // 失压跳闸闭锁重合
                           || pR->tXXTZ.uZOV.bFlag.bTz
#ifdef PRO_AL_LOCK_HZ
                           || (pR->tDYJL.sta.bFlag.bTz && pRunSet->bTT_JLlockCHZ) || (pR->tPLJL.sta.bFlag.bTz && pRunSet->bTT_JLlockCHZ)
#else
                           || pR->tDYJL.sta.bFlag.bTz || pR->tPLJL.sta.bFlag.bTz
#endif
                           || pR->run_stu.bsch
#ifndef PRO_UZ_START_REC // 云浮要求零序电压能启动重合闸
                           || pR->tOVER_U0TZ.uZOV.bFlag.bTz
#endif
                           || pR->tU0TZ.uZOV.bFlag.bTz //;			// 零压分闸闭锁重合
                           || pR->run_stu.chzbs;       // 二次闭锁202004
}

/**************************************************************************
函数名称: AR_Recharge
函数版本：1.00
函数版本：1.00
作者：    硬件部
创建日期：2010.4.28

函数功能说明：重合闸充电，刷新"重合闸充电完成"标

输入参数：
输出参数：
返回值：
***************************************************************************/
static void AR_Recharge(int sw, DWORD dStep)
{
    TRELAY_T *pR = &g_tRelay[sw];
    TCH_T *pSW = &pR->tCHZ;
    TSETSW *pSet = &pRunSet->tSwSet[sw];
    bool bHCD1, bHCD2, bHCD3, bHCD4;

#ifdef PRO_UZ_START_REC // 云浮要求零序电压能启动重合闸
    bool bHCD5 = false;
    RunTR(&pSW->tTCH_UO_BS, pR->tOVER_U0TZ.uZOV.bFlag.bQD && pSet->bTT_3U0Tz && pR->tSWST.uSWST.bFlag.bTZWZ, dStep); // 有零序电压且跳位
    bHCD5 = pSW->tTCH_UO_BS.boolTrip;
#endif

    // 放电条件
    RunTR(&pSW->tTCHFAIL_TW, pR->tSWST.uSWST.bFlag.bTZWZ, dStep); // 三相跳位延时
    bHCD1 = pSW->tTCHFAIL_TW.boolTrip;                            // 放电标志1:三相跳位时间到

    bHCD2 = (pR->tSWST.uSWST.bFlag.bTZWZ || pR->uBHDZ.bFlag.bBHT) // 此处保护跳标志，是有100ms保持的信号
            && (!pSW->sta.bFlag.bCDWC);                           // 放电标志2:充电未完成，跳位或保护动作

    bHCD3 = pR->uRmtSW.bHandTz // 手动跳闸
#ifdef SELF_OPEN_RELEASE
            || pR->uRmtSW.bSwTz // 开关拉杆跳闸
#endif
            || pR->uRmtSW.bYTExecute                                   // 遥控跳闸
            || pR->uBHDZ.bFlag.bTZSB                                   // 跳闸失败
            || pR->tSWST.uSWST.bFlag.bTWYL                             // 跳位有流
            || (pR->tSWST.uSWST.bFlag.bWCN && (!pSW->sta.bFlag.bCHQD)) // 弹簧未储能告警 重合闸启动后，收到弹簧未储能信号，重合闸不放电
            || pSW->sta.bFlag.bBSCH                                    // 重合闸闭锁条件
#ifdef GD_AREA_ECZD_2020
            || (pSet->bTT_chz_wy && (tPT.uPT1DX.bFlag.bPTYC || tPT.uPT2DX.bFlag.bPTYC)) // 无PT 异常; //检无压投入时，PT断线重合闸放电
#endif
            || pR->tSWST.uSWST.bFlag.bIBSCHZ // 大电流重合闸闭锁
            || pR->tSWST.uSWST.bFlag.bKZHL;  // 控制回路断线检查
    //|| pSW->sta.bFlag.bCHFD;                  // 重合闸动作放电202004

    pSW->sta.bFlag.bFDBZ = (!BH_ALL_EN(sw))                         // 总保护未投入
                           || (!KZ_OUT_ALL_EN(sw))                  // 控制出口未投入
                           || (!pSet->bTT_CHZ)                      // 软压板: 重合闸未投入
                           || (!pRunSet->tSwSet[sw].btt_gnyb_zdchz) // 重合闸软压板未投入
                           || (!pR->run_stu.chzyb)                  // 重合闸硬压板未投入
                           || bHCD1 || bHCD2 || bHCD3
#ifdef PRO_UZ_START_REC
                           || bHCD5
#endif
#ifdef FUNC_DRIVE_JY
                           || gb_drive.b_bh_reclose
#endif
        ;

    // 放电清开放时间
    if (pSW->sta.bFlag.bFDBZ)
    {
        pSW->sta.bFlag.bCHZOP = false;
        ResetTR(&pSW->tTCHOPENTime);
    }

    if (pR->tSWST.uSWST.bFlag.bIBSCHZ && pSW->sta.bFlag.bCDWC)
    {
        if (soe_check(EV_HI_CHZ_LOCK + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_HI_CHZ_LOCK + sw * EV_SW_NUM, 1, 0, 0, 0); // 重合闸闭锁
        }
    }
    else
    {
        if (!pR->tSWST.uSWST.bFlag.bIBSCHZ)
        {
            if (soe_check(EV_HI_CHZ_LOCK + sw * EV_SW_NUM) == true)
            {
                soe_record_ev(EV_HI_CHZ_LOCK + sw * EV_SW_NUM, 0, 0, 0, 0); // 重合闸闭锁
            }
        }
    }

    // 充电条件
    bHCD4 = !pSW->sta.bFlag.bFDBZ                                        // 重合放电标
            && (((!pR->uBHQD.bFlag.bZQD) && pR->tSWST.uSWST.bFlag.bHZWZ) // 非保护启动 && 合闸位置
                || pSW->sta.bFlag.bCDWC);                                // 充电完成自保持

    RunTR(&pSW->tTCHCD15s0s, bHCD4, dStep); // 充电15秒
    pSW->sta.bFlag.bCDWC = pSW->tTCHCD15s0s.boolTrip;

    if (pSW->sta.bFlag.bCDWC)
    {
        g_run_stu.cd |= (1 << sw);
        if (pSW->wAR_ActTimes >= pSet->d_chz_times)
        {
            g_run_stu.cd &= ~(1 << sw);
        }

        if (soe_check(EV_ARCD + sw * EV_SW_NUM) == false) // 充电标志
        {
            soe_record_ev(EV_ARCD + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
        // 终止重合返回
        if (soe_check(EV_CHZ_TOPEN + sw * EV_SW_NUM) == true)
        {
            soe_record_ev(EV_CHZ_TOPEN + sw * EV_SW_NUM, 0, 0, 0, 0); // 终止重合闸过程
        }
    }
    else
    {
#ifdef FUNC_DRIVE_JY
        if (BH_ALL_EN(sw))
        {
            gb_drive.b_drive_success = false; // 充电未完成时,传动分后手合不允许报传动成功
        }
#endif
        g_run_stu.cd &= ~(1 << sw);
        if (soe_check(EV_ARCD + sw * EV_SW_NUM) == true) // // 充电标志
        {
            soe_record_ev(EV_ARCD + sw * EV_SW_NUM, 0, 0, 0, 0);
        }
    }
}

/**************************************************************************
函数名称: AR_Start
函数版本：1.00
函数版本：1.00
作者：    硬件部
创建日期：2010.4.28

函数功能说明：重合闸启动，刷新"三相偷跳启动重合闸"和"三跳启动重合闸"标

输入参数：
输出参数：
返回值：
***************************************************************************/
static void AR_Start(int sw, DWORD dStep)
{
    bool bCHQD_CHQD; // 三相启动重合闸
    TRELAY_T *pR = &g_tRelay[sw];
    TCH_T *pSW = &pR->tCHZ;
    TSETSW *pSet = &pRunSet->tSwSet[sw];
    bool bCQD1, bCQD2, bCQD3, bCQD4, bCQD5, bCQD6;

    // 不对应启动
    // 开关位置从合闸位置切换至分闸位置完成后，保留50ms展宽
    RunTR(&pSW->tTCHQDHW0ms50ms, pR->tSWST.uSWST.bFlag.bHZWZ, dStep);
    bCQD1 = pSW->tTCHQDHW0ms50ms.boolTrip;

    // 偷跳条件准备
    bCQD2 = pSet->bTT_TTCH_TT && bCQD1 && (!pR->tSWST.uSWST.bFlag.bHZWZ);

    // 保护启动
    // 保护动作后至保护动作返回，保留50ms展宽
    RunTR(&pSW->tTCHQD0ms50ms, pR->uBHDZ.bFlag.bBHTrip, dStep);
    bCQD3 = pSW->tTCHQD0ms50ms.boolTrip;

    // 重合已启动或保护启动，用于闭锁不对应启动
    bCQD4 = pSW->sta.bFlag.bCHQD || bCQD3;

    // 此处保护跳信号，是实时信号，即保护已返回
    bCQD5 = bCQD3 && (!pR->uBHDZ.bFlag.bBHTrip);

    // 重合启动自保持
    // 重合闸出口条件，用于防止重合闸合闸过程中，TWJ没有返回时，再次误发启动重合闸报文。
    bCQD6 = pSW->sta.bFlag.bCDWC        // 重合充电完成
            && pSW->sta.bFlag.bCHQD     // 三相启动重合闸
            && (!pSW->sta.bFlag.bCHCK); // 重合闸出口，取反

    // 偷跳启动重合闸
    pSW->sta.bFlag.bTTQD = pSW->sta.bFlag.bCDWC // 重合闸充电完成
                           && bCQD2             // 偷跳判断完成
                           && (!bCQD4);         // 重合未启动，无保护跳过程

    // 三跳启动重合闸
    pSW->sta.bFlag.bTLQD = pSW->sta.bFlag.bCDWC        // 重合闸充电完成
                           && bCQD5                    // 有保护跳过程，而且保护已经返回，即故障已经解除
                           && (!pSW->sta.bFlag.bCHQD); // 三相启动重合闸未启动

    // 三相启动重合闸
    bCHQD_CHQD = (((pSW->wAR_ActTimes < pSet->d_chz_times) && // 重合次数未满 202004
                   (pSW->sta.bFlag.bTTQD                      // 偷跳启动重合闸
                    || pSW->sta.bFlag.bTLQD                   // 三跳启动重合闸
                    || bCQD6))                                // 三相启动重合闸
#ifdef FUNC_DRIVE_JY
                  || gb_drive.b_bh_reclose
#endif
    );

    if (bCHQD_CHQD)
    {
        if (!pSW->sta.bFlag.bCHQD) // 重合开出标尚未置位
        {
            pSW->sta.bFlag.bCHQD = true;                             // 此标志会一直维持到重合闸出口或充电标志放电
            pSW->sta.bFlag.bQDFG = true;                             // 整组复归时有效202004
            soe_record_ev(EV_AR_START + sw * EV_SW_NUM, 1, 0, 0, 0); // 重合启动SOE
            // rcd_start(sw,RECORD_TYPE_CHZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
        }
    }
    else
    {
        if (pSW->sta.bFlag.bCHQD)
        {
            pSW->sta.bFlag.bCHQD = false;
            soe_record_ev(EV_AR_START + sw * EV_SW_NUM, 0, 0, 0, 0);
        }
    }
    // 重合开放计时
    pSW->sta.bFlag.bCHZOP = bCHQD_CHQD || pSW->sta.bFlag.bCHZOP;
    RunTR(&pSW->tTCHOPENTime, pSW->sta.bFlag.bCHZOP, dStep); // 重合开放延时
    if (pSW->tTCHOPENTime.boolTrip)                          // 重合闸开放时间到复归
    {
        pSW->sta.wfFlag = 0;
        pR->tCHZ.wAR_ActTimes = 0;
        dp_info_nt_rt("重合闸开放时间到:整组复归!");
        ResetTR(&pR->tCHZ.tTCHJD_ARDelay); // 延时
        ResetTR(&pR->tCHZ.tTCHJD_HJS);     // 后加速延时
        ResetTR(&pSW->tTCHFAIL_TW);        // 重合失败
        ResetTR(&pSW->tTCHOKTime);         // 重合成功
        ResetTR(&pSW->tTCHBSDelay);        // 重合闭锁延时
        ResetTR(&pSW->tTCHJBSTime);        // 重合闭锁时间
        ResetTR(&pSW->tTCHCD15s0s);        // 重合充电时间
#ifdef PRO_UZ_START_REC
        ResetTR(&pSW->tTCH_UO_BS); // U0闭锁确认
#endif
        // soe
        if (soe_check(EV_CHZ_TOPEN + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_CHZ_TOPEN + sw * EV_SW_NUM, 1, 0, 0, 0); // 终止重合闸过程
        }
    }
}

/**************************************************************************
函数名称: AR_Logic
函数版本：1.00
函数版本：1.00
作者：    硬件部
创建日期：2010.4.28

函数功能说明：重合闸逻辑判断

输入参数：
输出参数：
返回值：
***************************************************************************/
static void AR_Logic(int sw, DWORD dStep)
{
    bool bWCN;
    TRELAY_T *pR = &g_tRelay[sw];
    TCH_T *pSW = &pR->tCHZ;
    TSETSW *pSet = &pRunSet->tSwSet[sw];

    bool bHZL1, bHZL2, bHZL3, bHZL4, bHZL5, bHZL6, bHZL8;

#ifdef PRO_AL_LOCK_HZ
    bool bYYOK, bFreqOK;
    DWORD freq0, freq1;
    bool bVABL_OK, bVABH_OK, bVBCL_OK, bVBCH_OK;
#endif

    // 重合闸条件准备
    bHZL1 = (BH_ALL_EN(sw)                         // 总投退
             && pSet->bTT_CHZ                      // 软压板: 重合闸投
             && pRunSet->tSwSet[sw].btt_gnyb_zdchz // 软压板: 重合闸投
             && pR->run_stu.chzyb                  // 重合闸硬压板投入
             && ((pSW->sta.bFlag.bCHQD             // 三相启动重合闸
                  && pSW->sta.bFlag.bCDWC)         // 重合闸充电完成
#ifdef FUNC_DRIVE_JY
                 || gb_drive.b_bh_reclose
#endif
                 ));

#ifdef PRO_AL_LOCK_HZ
    if (pRunSet->bTT_StartCHZ_judgeVolt)
    {
        bVABL_OK = OverRelay(g_sw_pub.m2_max[2], pSet->dU_jl_ddy, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVABLOK);
        bVABH_OK = LowRelay(g_sw_pub.m2_max[2], pSet->dU_jl_gdy, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVABHOK);
        pSW->CHZ_Judge_V_F.bVABLOK = bVABL_OK;
        pSW->CHZ_Judge_V_F.bVABHOK = bVABH_OK;

        bVBCL_OK = OverRelay(g_sw_pub.m2_max[3], pSet->dU_jl_ddy, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVBCLOK);
        bVBCH_OK = LowRelay(g_sw_pub.m2_max[3], pSet->dU_jl_gdy, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVBCHOK);
        pSW->CHZ_Judge_V_F.bVBCLOK = bVBCL_OK;
        pSW->CHZ_Judge_V_F.bVBCHOK = bVBCH_OK;

        if ((bVABL_OK && bVABH_OK) && (bVBCL_OK && bVBCH_OK)) // 需双侧电压均满足条件才允许重合闸
        {
            bYYOK = true;
        }
        else
        {
            bYYOK = false;
        }
    }
    else
    {
        bYYOK = true;
    }

    if (pRunSet->bTT_StartCHZ_judgeFreq)
    {
        freq0 = freq_get(0) * 65536;
        freq1 = freq_get(1) * 65536;

        if (((freq0 >= pRunSet->tSwSet[sw].dU_jl_dhz) && (freq0 <= pRunSet->tSwSet[sw].dU_jl_ghz)) && ((freq1 >= pRunSet->tSwSet[sw].dU_jl_dhz) && (freq1 <= pRunSet->tSwSet[sw].dU_jl_ghz))) // 需双侧频率均满足条件才允许重合闸
        {
            bFreqOK = true;
        }
        else
        {
            bFreqOK = false;
        }
    }
    else
    {
        bFreqOK = true;
    }

    RunTR(&pSW->tTCHJD_ARDelay, bHZL1 && bYYOK && bFreqOK, dStep); // 重合延时
#else
    RunTR(&pSW->tTCHJD_ARDelay, bHZL1, dStep); // 重合延时
#endif
    bHZL2 = pSW->tTCHJD_ARDelay.boolTrip && pSW->sta.bFlag.bCHMZ;

    // 弹簧未储能下降沿展宽30ms
    bWCN = pR->run_stu.wcn && pSet->bTT_WCN;
    RunTR(&pSW->tTCHJD_0ms30ms, bWCN, dStep);
    bHZL3 = pSW->tTCHJD_0ms30ms.boolTrip;

    // 重合闸条件准备好，弹簧储能OK，重合闸出口
    pSW->sta.bFlag.bCHCK = (!bHZL3) && bHZL2;

    // 重合闸开出自保持
    bHZL4 = pSW->sta.bFlag.bHz || pSW->sta.bFlag.bCHCK;

    // 重合开出持续200ms
    RunTR(&pSW->tTCHJD_200ms0ms, bHZL4, dStep);
    bHZL5 = pSW->tTCHJD_200ms0ms.boolTrip;

    // 重合闸开出,经过200ms后开出解除
    pSW->sta.bFlag.bHz = bHZL4 && (!bHZL5);

    // 重合闸指令发出后，且开关已经跳闸完成
    bHZL6 = pSW->sta.bFlag.bHz || pSW->sta.bFlag.bHZL7;
    pSW->sta.bFlag.bHZL7 = pR->tSWST.uSWST.bFlag.bTZWZ && bHZL6;

    // 开放后加速允许有效延时200ms展宽
    RunTR(&pSW->tTCHJD_HJS, pSW->sta.bFlag.bHZL7, dStep);
    bHZL8 = pSW->tTCHJD_HJS.boolTrip;
    pSW->sta.bFlag.bCHJS = pSW->tTCHJD_HJS.boolTrip && (!pR->tSWST.uSWST.bFlag.bTZWZ);

    // 出口及发信
    if (pSW->sta.bFlag.bHz)
    {
        if (!pSW->sta.bFlag.bEvent) // 重合开出标尚未置位
        {
            // 亮重合动作灯
            pSW->sta.bFlag.bCHZLed = true;

            pSW->wAR_ActTimes++; // 重合动作次数
            if (g_run_stu.yf)
            {
                dp_info_nt_rt("bHZL4 = %d", bHZL4);
                dp_info_nt_rt("bHZL5 = %d", bHZL5);
                dp_info_nt_rt("pSW->sta.bFlag.bHz = %d", pSW->sta.bFlag.bHz);
                dp_info_nt_rt("pR->tCHZ.wAR_ActTimes = %d", pR->tCHZ.wAR_ActTimes);
            }
            pSW->sta.bFlag.bEvent = true;
            // pSW->uCHFG.wfFlag=0;			//每次重合出口后，清重合复归标志  修改时注意，此处需对标志字特殊处理

            pSW->sta.bFlag.bCHDZ = false; // 重合闸动作
            pSW->sta.bFlag.bBYSD = false; // 重合闸闭锁时间到
            pSW->sta.bFlag.bCHFD = false; // 重合闸动作放电
            pSW->sta.bFlag.bCHBS = false; // 重合闸闭锁
            pSW->sta.bFlag.bCK = false;   // 放电条件1

            if (pSW->wAR_ActTimes == 1)
            {
                soe_record_ev(EV_AR1 + sw * EV_SW_NUM, 1, 0, 0, 0); // 重合动作SOE
            }
            else if (pSW->wAR_ActTimes == 2)
            {
                soe_record_ev(EV_AR2 + sw * EV_SW_NUM, 1, 0, 0, 0); // 重合动作SOE
            }
            else if (pSW->wAR_ActTimes == 3)
            {
                soe_record_ev(EV_AR3 + sw * EV_SW_NUM, 1, 0, 0, 0); // 重合动作SOE
            }

            rcd_start(sw, RECORD_TYPE_CHZ, RECORD_LEN_TZQD);
            ResetTR(&pSW->tTCHFAIL_TW); // 重合出口后,重新复归时间继电器
            ResetTR(&pSW->tTCHOKTime);  // 重合成功时间继电器，在重合出口后重新计数
            ResetTR(&pSW->tTCHBSDelay); // 闭锁重合延时继电器重新计数
            ResetTR(&pSW->tTCHJBSTime); // 闭锁重合延时继电器重新计数
            // RunTR(&pSW->tTCHJBSTime, 1, 1);  //重合闸动作后，该计时器计时，在确认时间内有保护动作，置重合闸闭锁标志

#ifdef FUNC_DRIVE_JY
            gb_drive.b_bh_reclose = false;
#endif
        }
    }
    else
    {
        if (pSW->sta.bFlag.bEvent) // 重合开出标尚未置位
        {
            pSW->sta.bFlag.bEvent = false;

            if (soe_check(EV_AR1 + sw * EV_SW_NUM))
            {
                soe_record_ev(EV_AR1 + sw * EV_SW_NUM, 0, 0, 0, 0); // 重合1动作SOE返回
            }
            if (soe_check(EV_AR2 + sw * EV_SW_NUM))
            {
                soe_record_ev(EV_AR2 + sw * EV_SW_NUM, 0, 0, 0, 0); // 重合2动作SOE返回
            }
            if (soe_check(EV_AR3 + sw * EV_SW_NUM))
            {
                soe_record_ev(EV_AR3 + sw * EV_SW_NUM, 0, 0, 0, 0); // 重合2动作SOE返回
            }
        }
    }
}

/**************************************************************************
函数名称: AR_Reset
函数版本：1.00
函数版本：1.00
作者：    硬件部
创建日期：2010.4.28

函数功能说明：重合闸复归逻辑

输入参数：
输出参数：
返回值：
***************************************************************************/
static void AR_Reset(int sw, DWORD dStep)
{
    TRELAY_T *pR = &g_tRelay[sw];
    TCH_T *pSW = &pR->tCHZ;
    TSETSW *pSet = &pRunSet->tSwSet[sw];
    bool bFD1, bCHBS1, bCHBS2;

    // 重合闸出口自锁202004
    pSW->sta.bFlag.bCHDZ = (pSW->sta.bFlag.bCHCK || pSW->sta.bFlag.bCHDZ);
    // 二次重合闭锁(未到最后一次重合) 202004
    RunTR(&pSW->tTCHBSDelay, (pSW->sta.bFlag.bCHDZ && pSW->wAR_ActTimes < pSet->d_chz_times), dStep);
    pSW->sta.bFlag.bBYSD = pSW->tTCHBSDelay.boolTrip;

    bCHBS1 = (pSW->sta.bFlag.bCHDZ && pSW->wAR_ActTimes < pSet->d_chz_times) && (!pSW->sta.bFlag.bBYSD); // 重合闸闭锁时间未到
    // 重合闭锁(最后一次)
    // 重合闸动作后，该计时器计时，在确认时间内有保护动作，置重合闸闭锁标志
    RunTR(&pSW->tTCHJBSTime, (pSW->sta.bFlag.bCHDZ && pSW->wAR_ActTimes >= pSet->d_chz_times), dStep);

    bCHBS2 = pSW->tTCHJBSTime.boolTrip;

    // 重合闸闭锁
    pSW->sta.bFlag.bCHBS = pR->uBHDZ.bFlag.bBHT && (bCHBS1 || bCHBS2);

    if (pSW->sta.bFlag.bCHBS)
    {
        if (soe_check(EV_ARBS + sw * EV_SW_NUM) == false)
        {
            led_set_sw(sw, SW_LED_CHZBS, LED_ON);                // 重合闸闭锁灯与充电灯功能相反
            soe_record_ev(EV_ARBS + sw * EV_SW_NUM, 1, 0, 0, 0); // 重合闸闭锁
            g_tRelay[sw].run_stu.chzbs = true;
        }
        ResetTR(&pSW->tTCHJBSHw);
        ResetTR(&pSW->tTCHJBSTime);
        ResetTR(&pSW->tTCHOKTime);
        ResetTR(&pSW->tTCHBSDelay);
        pSW->sta.bFlag.bCHDZ = false;
    }

    // 复归
    // 重合出口后，经过重合闸确认时间，无保护动作，即复归，完成该次重合过程202004
    // 如果在确认时间内，重合闭锁时间外，有保护动作，即进入下一计数重合
    pSW->sta.bFlag.bCK = ((!pR->uBHDZ.bFlag.bBHT) && (pSW->sta.bFlag.bCHCK || pSW->sta.bFlag.bCK)); // 重合出口及自保持
    RunTR(&pSW->tTCHOKTime, pSW->sta.bFlag.bCK, dStep);
    bFD1 = pSW->tTCHOKTime.boolTrip;
    if (bFD1)
    {
        if (pR->tCHZ.wAR_ActTimes)
        {
            rt_printf_time("重合闸复归\r\n");
            dp_info_nt_rt("[%s:%d]pR->tCHZ.wAR_ActTimes = %d", __func__, __LINE__, pR->tCHZ.wAR_ActTimes);
        }
        pSW->sta.bFlag.bCHDZ = false;
        pR->tCHZ.wAR_ActTimes = 0;
        ResetTR(&pR->tCHZ.tTCHJD_HJS);
        ResetTR(&pSW->tTCHOKTime);
        ResetTR(&pSW->tTCHBSDelay);
        ResetTR(&pSW->tTCHJBSTime); // 重合成功时间继电器，在重合出口后重新计数
        pSW->sta.bFlag.bCHZOP = false;
        ResetTR(&pSW->tTCHOPENTime);

        if (g_run_stu.yf)
        {
            rt_printf_time("bFD1 = %d, pSW->sta.bFlag.bCK = %d, pR->uBHDZ.bFlag.bBHT = %d, pSW->sta.bFlag.bCHCK = %d\r\n",
                        bFD1,
                        pSW->sta.bFlag.bCK,
                        pR->uBHDZ.bFlag.bBHT,
                        pSW->sta.bFlag.bCHCK);
        }
    }
    // 手动/自动复归条件:(1)重合闸闭锁(2)重合已启动，但充电标志已清零
    if (g_tRelay[sw].run_stu.chzbs                          // 闭锁
        || (!pSW->sta.bFlag.bCDWC && pSW->sta.bFlag.bQDFG)) // 已启动重合计时,又被放电
    {
        pSW->sta.bFlag.bQDFG = false;
    }
    // pSW->sta.bFlag.bCK = false;   // 放电条件1
}

/***************************************endfile**********************************************************/