T536_DTU/dtu/dtu_main_t536/app/UnitsLib.c

/*************************************************************************
 * 版权所有：
 * 文件版本： V1.00
 * 文件名称： DILogic.c
 * 生成日期： 2008年11月15日
 * 作    者：
 * 功    能： 开入逻辑功能
 * 更新信息：
 * 更新日志1：
 * 日期：
 * 修改者：
 * 修改内容：
 * 修改原因：
 * 更新日志2：
 **************************************************************************/
#include "head.h"

/******************************************************************************
函数名称：	ProtectRelayInit
函数版本：	01.01
创建作者：
创建日期：	2013-08-08
函数说明：	上电时初始化保护相关的定时器，包括定值设置的、固定的
参数说明：
返回值：
修改记录：
*/
void ProtectRelayInit(void)
{
    int sw, i;

    for (sw = 0; sw < g_sw_num; sw++)
    {
        TRELAY_T *pR = &g_tRelay[sw];
        TSETSW *pSet = &pRunSet->tSwSet[sw];
        int i;

#ifdef CUSTOMIZE_BZT // 备自投
        BztTimerInit(sw);
#endif
        for (i = 0; i < BHOC_NUMBER; i++)
        {
            TOC_T *poc = &pR->tOC[i];

#ifdef YX_RESET_TIME
            InitTR(&poc->tTzEvRstTime, tRunPara.dTEventRst, 0); // 遥信复归时间
            InitTR(&poc->tGjEvRstTime, tRunPara.dTEventRst, 0); // 遥信复归时间
#endif

            InitTR(&poc->tQDTime, pSet->toc[i].dT, PRO_RET_TIME); // CorrectTR(&poc->tQDTime);
            InitTR(&poc->tXBTime, T_20ms, 0);
            InitTR(&poc->tXBQD25ms, T_25ms * 2, 0);
            InitTR(&poc->tFz25ms, T_25ms, 0);
            if (i >= BH_OVI)
            {
                InitTR(&poc->tQDTime, pSet->toc[i].dT, WRN_RET_TIME); // 过载及重载，返回时间为1秒
            }
        }
        {
            TGOC_T *poc = &pR->tgoc;
            GOC_SET *pgset = &pSet->tGocSet;
            DWORD dTsytime;

            dTsytime = ((pgset->dTgzgl > pgset->dTsdlost) ? pgset->dTgzgl : pgset->dTsdlost) + T_300ms;
            if (pRunSet->bTT_goose_send_after)
            {
                InitTR(&poc->tTZX_300ms, pgset->dTgl, pRunSet->dT_sendext); //
                InitTR(&poc->tTFX_300ms, pgset->dTgl, pRunSet->dT_sendext); //
                InitTR(&poc->tTWX_300ms, pgset->dTgl, pRunSet->dT_sendext); //
                InitTR(&poc->tTLX_300ms, pgset->dTlx, pRunSet->dT_sendext); //
            }
            else
            {
                InitTR(&poc->tTZX_300ms, T_5ms, pRunSet->dT_sendext); //
                InitTR(&poc->tTFX_300ms, T_5ms, pRunSet->dT_sendext); //
                InitTR(&poc->tTWX_300ms, T_5ms, pRunSet->dT_sendext); //
                InitTR(&poc->tTLX_300ms, T_5ms, pRunSet->dT_sendext); //
            }
            InitTR(&poc->tTGLBS_300ms, T_5ms, pRunSet->dT_sendext); //
            InitTR(&poc->tglFz25ms, T_25ms, 0);
            InitTR(&poc->tlxFz25ms, T_25ms, 0);
            InitTR(&poc->tglQD25ms, T_25ms, 0);
            InitTR(&poc->tlxQD25ms, T_25ms, 0);
            InitTR(&poc->tTHz1s, T_1s, 0);

            InitTR(&poc->tgoose15ms_gzgl, pRunSet->dT_goosecheck, 0); //

            InitTR(&poc->tqccd.tCDTime, pRunSet->dT_cd, 0);
            InitTR(&poc->tqccd.tWYTime, pRunSet->dT_glfd, 0);
            InitTR(&poc->tglcd.tCDTime, pRunSet->dT_cd, 0);
            InitTR(&poc->tglcd.tWYTime, pRunSet->dT_glfd, 0);
            if (pRunSet->dT_cd == 0)
            {
                InitTR(&poc->tllcd.tCDTime, T_1s * 15, 0);
            }
            else
            {
                InitTR(&poc->tllcd.tCDTime, pRunSet->dT_cd, 0);
            }
            InitTR(&poc->tllcd.tWYTime, pRunSet->dT_llfd, 0);

            if (pRunSet->bTT_goose_send_after)
            {
                InitTR(&poc->tglQDTime, pgset->dTgl + pRunSet->dT_goosecheck, PRO_RET_TIME); //
                InitTR(&poc->tlxQDTime, pgset->dTlx + pRunSet->dT_goosecheck, PRO_RET_TIME); //
            }
            else
            {
                InitTR(&poc->tglQDTime, ((pgset->dTgl > pRunSet->dT_goosecheck) ? pgset->dTgl : pRunSet->dT_goosecheck), PRO_RET_TIME); //
                InitTR(&poc->tlxQDTime, ((pgset->dTlx > pRunSet->dT_goosecheck) ? pgset->dTlx : pRunSet->dT_goosecheck), PRO_RET_TIME); //
            }
            InitTR(&poc->tgzglTime, pgset->dTgzgl, 0);                                                                              //
            InitTR(&poc->tsdlostTime, pgset->dTsdlost, 0);                                                                          //
            InitTR(&poc->terrlostTime, pgset->dTgzgl, 0);                                                                           //
            InitTR(&poc->tllhzTime, pgset->dTll, 0);                                                                                //
            InitTR(&poc->tllQdTime, pgset->dTll + ((pgset->dTgzgl > pgset->dTsdlost) ? pgset->dTgzgl : pgset->dTsdlost) + T_1s, 0); //

            InitTR(&poc->tglslowTime, 0, pgset->dTgl + T_1s); //
            InitTR(&poc->tlxslowTime, 0, pgset->dTlx + T_1s); //

#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
            InitTR(&poc->tgl2Fz25ms, T_25ms, 0);
            InitTR(&poc->tgl2QD25ms, T_25ms, 0);
            InitTR(&poc->tgl2slowTime, 0, pgset->dTgl2 + T_1s); // #ifdef GD_AREA_GDDKY_TEST
            if (pRunSet->bTT_goose_send_after)
            {
                InitTR(&poc->tgl2QDTime, pgset->dTgl2 + pRunSet->dT_goosecheck, PRO_RET_TIME); //
                InitTR(&poc->tTZX2_300ms, pgset->dTgl2, pRunSet->dT_sendext);                  //
                InitTR(&poc->tTFX2_300ms, pgset->dTgl2, pRunSet->dT_sendext);                  //
                InitTR(&poc->tTWX2_300ms, pgset->dTgl2, pRunSet->dT_sendext);                  //
            }
            else
            {
                InitTR(&poc->tgl2QDTime, ((pgset->dTgl2 > pRunSet->dT_goosecheck) ? pgset->dTgl2 : pRunSet->dT_goosecheck), PRO_RET_TIME); //
                InitTR(&poc->tTZX2_300ms, T_5ms, pRunSet->dT_sendext);                                                                     //
                InitTR(&poc->tTFX2_300ms, T_5ms, pRunSet->dT_sendext);                                                                     //
                InitTR(&poc->tTWX2_300ms, T_5ms, pRunSet->dT_sendext);                                                                     //
            }
#endif
            InitTR(&poc->tTzcheckTime, pRunSet->dT_TZSB, 0); // 开关失灵判断时间
            InitTR(&poc->tHzcheckTime, pRunSet->dT_HZSB, 0); // 开关失灵判断时间

            InitTR(&poc->ttzsbextTime, 0, pRunSet->dT_sendext);     //  跳闸失败(开关失灵)展宽时间
            InitTR(&poc->tgzglokextTime, 0, pRunSet->dT_sendext);   // 发送展宽 300毫秒
            InitTR(&poc->tgzglokForbitTime, 0, pRunSet->dT_frobit); // 发送故障隔离成功后闭锁时间
            InitTR(&poc->tCYY3sdelayms, T_1s * 3, dTsytime);
            InitTR(&poc->tgoosedelayms_ll, dTsytime + pRunSet->dT_TZSB * 2, 0);

            InitTR(&poc->tllWY1Time, T_100ms, T_100ms);
            InitTR(&poc->tllWY2Time, T_100ms, T_100ms);
            InitTR(&poc->tllYY1Time, T_100ms, T_100ms + T_20ms);
            InitTR(&poc->tllYY2Time, T_100ms, T_100ms + T_20ms);
            InitTR(&poc->textbsTime, 0, pRunSet->dT_sendext + T_100ms);
        }

        // 重合闸
        InitTR(&pR->tCHZ.tTCHQDHW0ms50ms, 0, T_10ms * 5);         // 合闸位置下降沿展宽
        InitTR(&pR->tCHZ.tTCHQD0ms50ms, 0, T_10ms * 5);           // 跳闸开出下降沿展宽
        InitTR(&pR->tCHZ.tTCHJD_0ms30ms, 0, T_10ms * 3);          // 弹簧未储能下降沿展宽
        InitTR(&pR->tCHZ.tTCHJD_200ms0ms, T_200ms, 0);            // 重合开出宽度
        InitTR(&pR->tCHZ.tTCHCD15s0s, pSet->dT_chz_cd, 0);        // 重合充电
        InitTR(&pR->tCHZ.tTCHJD_ARDelay, pSet->dT_chz[0], 0);     // 重合闸延时
        InitTR(&pR->tCHZ.tTCHFAIL_TW, pSet->dT_chz[0] + T_1s, 0); // 三相跳位延时: 重合失败返回时间
        InitTR(&pR->tCHZ.tTCHBSDelay, pSet->dT_chz_bs, 0);        // 重合闭锁延时
        InitTR(&pR->tCHZ.tTCHOKTime, pSet->dT_chz_ok, 0);         // 重合成功
        InitTR(&pR->tCHZ.tTCHJD_HJS, 0, pSet->dT_SpeedUp_Open);   // 后加速开放时间
        InitTR(&pR->tCHZ.tTCHJBSTime, 0, pSet->dT_chz_ok);        // 重合闭锁时间
        InitTR(&pR->tCHZ.tTCHJBSHw, T_100ms, 0);                  // 开关合位100ms确认

#ifdef PRO_UZ_START_REC
        InitTR(&pR->tCHZ.tTCH_UO_BS, T_100ms, 0); // 零序电压重合闭锁延时
#endif
        InitTR(&pR->tCHZ.tTCHOPENTime, pSet->dT_chz_Topen, 0); // 重合开放时间

#ifdef SELF_OPEN_RELEASE
        InitTR(&pR->tTripBHTKeep, 0, tRunPara.wYXFD * T_5ms / 5 + T_40ms);
#endif
        // 保护跳闸脉宽
        InitTR(&pR->tTrip_BHT40MS, 0, T_40ms); // 跳闸脉冲最短时间40ms ,以前为100ms，在做多次重合闸是，若时间整定为100ms左右，会有异常

        // 配网功能定值
        InitTR(&pR->tSDHZ.tOnXSTime, pSet->dT_X, 0);
        InitTR(&pR->tSDHZ.tOnYSTime, pSet->dT_Y, 0);
        InitTR(&pR->tSDHZ.tOnZSTime, T_100ms * 35, 0); //  3.5秒
        InitTR(&pR->tSDHZ.tOnXLTime, pSet->dT_XL, 0);
        InitTR(&pR->tSDHZ.tOnYLTime, pSet->dT_Y, 0);
#ifdef GD_AREA_ZHONGSHAN_2020
        InitTR(&pR->tSDHZ.tOnLLCDYLTime, pSet->dT_LL_CD, 0);
#endif

        InitTR(&pR->tSDHZ.tOnBSTZTime, pSet->dT_fa_bsTz, 0);
        InitTR(&pR->tSDHZ.tOnZLTime, T_100ms * 35, 0); //  3.5秒
        InitTR(&pR->tSDHZ.tOnOCingTime, pSet->dT_fa_ocing, pSet->dT_Y);
        InitTR(&pR->tSDHZ.tOnLXingTime, pSet->dT_fa_lxing, pSet->dT_Y);
        InitTR(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0); ////初始化单侧来电解锁计时器
#ifdef GD_AREA_ZHONGSHAN_2020
        InitTR(&pR->tSDHZ.tOnY_JSTime, 0, 0);
#elif defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
        InitTR(&pR->tSDHZ.tOnY_JSTime, T_1s * 6, 0);
#else
        InitTR(&pR->tSDHZ.tOnY_JSTime, T_1s * 3, 0);
#endif

#if defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
#if defined GD_AREA_ECZD_2020
#if defined FUNC_SET_FA_JS
        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, pRunSet->dT_FA_JS, 0);
#else
        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, 5 * T_10ms, 0);
#endif
#else
        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s * 6, 0);
#endif
#else
        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s, 0);
#endif
#ifdef FA_OC_COUNT
        InitTR(&pR->tSDHZ.tFaOcCountTime, pSet->fa_oc_conut_time, 0);
#endif

        if (pSet->toc[FA_GL].dT > T_FA_TZ_MIN_TIME)
        {
            InitTR(&pR->tSDHZ.tGZJYRstGLTime, pSet->toc[FA_GL].dT, pSet->dT_Y);
        }
        else
        {
            InitTR(&pR->tSDHZ.tGZJYRstGLTime, T_FA_TZ_MIN_TIME, pSet->dT_Y);
        }
        if (pSet->toc[FA_GL_II].dT > T_FA_TZ_MIN_TIME)
        {
            InitTR(&pR->tSDHZ.tGZJYRstGL_II_Time, pSet->toc[FA_GL_II].dT, pSet->dT_Y);
        }
        else
        {
            InitTR(&pR->tSDHZ.tGZJYRstGL_II_Time, T_FA_TZ_MIN_TIME, pSet->dT_Y);
        }

        if (pSet->toc[FA_GL2].dT > T_FA_TZ_MIN_TIME)
            InitTR(&pR->tSDHZ.tGZJYRstGL2Time, pSet->toc[FA_GL2].dT, T_20ms);
        else
            InitTR(&pR->tSDHZ.tGZJYRstGL2Time, T_FA_TZ_MIN_TIME, T_20ms);

        if (pSet->toc[FA_LX].dT > T_FA_TZ_MIN_TIME)
        {
            InitTR(&pR->tSDHZ.tGZJYRstJDTime, pSet->toc[FA_LX].dT, pSet->dT_Y);
        }
        else
        {
            InitTR(&pR->tSDHZ.tGZJYRstJDTime, T_FA_TZ_MIN_TIME, pSet->dT_Y);
        }

        if (pSet->toc[FA_LX2].dT > T_FA_TZ_MIN_TIME)
            InitTR(&pR->tSDHZ.tGZJYRstJD2Time, pSet->toc[FA_LX2].dT, pSet->dT_Y);
        else
            InitTR(&pR->tSDHZ.tGZJYRstJD2Time, T_FA_TZ_MIN_TIME, pSet->dT_Y);

        InitTR(&pR->tSDHZ.tL_RELAYONL3s, pSet->dT_Y, 0);
        InitTR(&pR->tSDHZ.tHzS100ms, 0, T_200ms);
        InitTR(&pR->tSDHZ.tUDBS100ms, T_100ms, 0);
        InitTR(&pR->tSDHZ.tUABS25ms, pSet->dT_fa_YY, T_25ms * 2);
        InitTR(&pR->tSDHZ.tUBCS25ms, pSet->dT_fa_YY, T_25ms * 2);
#ifdef FUNC_NYY_NWY
        InitTR(&pR->tSDHZ.tUABS_NYY_NWY_50ms, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tUBCS_NYY_NWY_50ms, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tUABL_NYY_NWY_50ms, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tUBCL_NYY_NWY_50ms, T_25ms * 2, T_25ms * 2);
#endif
        InitTR(&pR->tSDHZ.tUFABL80ms, pRunSet->dT_XCY, pSet->dT_Y - T_1s);
        InitTR(&pR->tSDHZ.tUFBCL80ms, pRunSet->dT_XCY, pSet->dT_Y - T_1s);
        InitTR(&pR->tSDHZ.tUFDBTime, pRunSet->dT_XCY, 0);
        InitTR(&pR->tSDHZ.tUABL25ms, pSet->dT_fa_YY, T_25ms * 2);
        InitTR(&pR->tSDHZ.tUBCL25ms, pSet->dT_fa_YY, T_25ms * 2);
        InitTR(&pR->tSDHZ.tUFABS80ms, pRunSet->dT_XCY, pSet->dT_Y - T_1s);
        InitTR(&pR->tSDHZ.tUFBCS80ms, pRunSet->dT_XCY, pSet->dT_Y - T_1s);
        InitTR(&pR->tSDHZ.tUFABS25ms, T_25ms, pRunSet->dT_XCY + T_1s);
        InitTR(&pR->tSDHZ.tUFBCS25ms, T_25ms, pRunSet->dT_XCY + T_1s);
        InitTR(&pR->tSDHZ.tUFABL25ms, T_25ms, pRunSet->dT_XCY + T_1s);
        InitTR(&pR->tSDHZ.tUFBCL25ms, T_25ms, pRunSet->dT_XCY + T_1s);

#ifdef FA_PL_PJ
        InitTR(&pR->tSDHZ.tFREQAB25ms_SCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQBC25ms_SCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQAB25ms_LCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQBC25ms_LCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQSAB25ms, T_25ms, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQSBC25ms, T_25ms, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQLAB25ms, T_25ms, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQLBC25ms, T_25ms, T_25ms * 2);
#endif

        InitTR(&pR->tSDHZ.tOpsiteYY100ms, 0, 0);
        InitTR(&pR->tSDHZ.tPowerYY100ms, 0, 0);
        InitTR(&pR->tSDHZ.tHw100ms100ms, T_100ms, T_100ms);
        InitTR(&pR->tSDHZ.tTw100ms100ms, T_100ms, T_100ms);
        InitTR(&pR->tSDHZ.tHz0ms1s, 0, tRunPara.wFAHZT * T_5ms / 5 + T_1s);
        InitTR(&pR->tSDHZ.tTz0ms1s, 0, tRunPara.wFAFZT * T_5ms / 5 + T_1s);
        InitTR(&pR->tSDHZ.tHz0ms2s, pRunSet->dT_HZSB, 0);
        InitTR(&pR->tSDHZ.tTz0ms2s, pRunSet->dT_TZSB, 0);
        InitTR(&pR->tSDHZ.tTSDHzHJS, 0, pSet->dT_Y); // 上电合闸加速判断

        InitTR(&pR->tU0TZ.tZOVTime, pSet->dT_OverU0, T_20ms);
        InitTR(&pR->tOVER_U0TZ.tZOVTime, pSet->dBHTOverU0, T_20ms);

        // InitTR(&pR->tGdy.tQDTime,  pSet->dT_gy, T_20ms);

        InitTR(&pR->tLostVot.tCYY25ms0ms, T_25ms, 0);
        InitTR(&pR->tLostVot.tLostVotTime, pSet->dT_Z, T_20ms);
        InitTR(&pR->tLostVot.tLostVLockTime, 0, pSet->dT_fa_bsTz);
        InitTR(&pR->tTQHz.tTQTime, pSet->dT_tq, 0); // 同期
        InitTR(&pR->tTQHz.tTQQDTime, 0, pRunSet->dT_tq_fh);
        // 解列
        InitTR(&pR->tDYJL.tDdyTime, pSet->dT_jl_ddy, T_20ms);   // CorrectTR(&pR->tDYJL.tDdyTime);  CorrectTR(&pR->tDYJL.tDdyTime);
        InitTR(&pR->tDYJL.tGdyTime, pSet->dT_jl_gdy, T_20ms);   // CorrectTR(&pR->tDYJL.tGdyTime);  CorrectTR(&pR->tDYJL.tGdyTime);
        InitTR(&pR->tDYJL.tHighTime, pSet->dT_jl_ggdy, T_20ms); // CorrectTR(&pR->tDYJL.tHighTime); CorrectTR(&pR->tDYJL.tHighTime);
        InitTR(&pR->tDYJL.tLowTime, pSet->dT_jl_gddy, T_20ms);

        InitTR(&pR->tPLJL.tDhzTime, pSet->dT_jl_dhz, T_40ms);   // CorrectTR(&pR->tPLJL.tDhzTime);   CorrectTR(&pR->tPLJL.tDhzTime);
        InitTR(&pR->tPLJL.tHighTime, pSet->dT_jl_ghz, T_40ms);  // CorrectTR(&pR->tPLJL.tHighTime);  CorrectTR(&pR->tPLJL.tHighTime);
        InitTR(&pR->tPLJL.tLowTime, pSet->dT_jl_lowhz, T_40ms); // CorrectTR(&pR->tPLJL.tLowTime);   CorrectTR(&pR->tPLJL.tLowTime);

        InitTR(&pR->tDYJL.thcbs1_0ms_100ms, 0, T_100ms); // 滑差闭锁延迟返回继电器
        InitTR(&pR->tDYJL.thcbs2_0ms_100ms, 0, T_100ms);
        InitTR(&pR->tPLJL.thcbs1_0ms_100ms, 0, T_100ms);
        InitTR(&pR->tPLJL.thcbs2_0ms_100ms, 0, T_100ms);

        // 手合加速
        InitTR(&pR->tSWST.tTRunST_20s1s, T_1s, T_300ms); // 2020-07-23 分位持续检测时间改为1s，按照广东标准2020 手合开放检测时间，将3s时间改为0.3s，即分闸持续1S以上，手合0.3秒内可启动后加速
#if defined GD_AREA_ECZD_2020
        InitTR(&pR->tSWST.tSHz3s10ms, T_1s, T_10ms);
#else
        InitTR(&pR->tSWST.tSHz3s10ms, T_1s * 3, T_10ms);
#endif
        InitTR(&pR->tSWST.tSTz3s10ms, T_1s * 3, T_10ms);
        InitTR(&pR->tSWST.tSf3s, T_1s * 3, 0);
        InitTR(&pR->tSWST.tTTWYL_10S1S, T_1s * 10, T_1s);
        InitTR(&pR->tSWST.tTWCNGJ1s, pRunSet->dWCN_T, WRN_RET_TIME);
        InitTR(&pR->tSWST.tTKZHLGJ1s, T_1s * 10, WRN_RET_TIME);
        InitTR(&pR->tSWST.tIBSCHZ, T_25ms, WRN_RET_TIME); //	T_1s
        InitTR(&pR->tTripfail_2s, pRunSet->dT_TZSB, 0);   // 跳闸失败时间继电器
        InitTR(&pR->tTripfail_hz, 0, pRunSet->dT_TZSB);   // 跳闸失败时间继电器

        InitTR(&pR->tSWST.tCTXXYC, T_1s * 3, WRN_RET_TIME); // CT相序异常
        InitTR(&pR->tSWST.tCTYC, T_1s * 10, WRN_RET_TIME);  // CT断线
        InitTR(&pR->tSWST.tBatChk, T_1s * 3, WRN_RET_TIME); // 电池电压低
        InitTR(&pR->tSWST.tBatOver, T_1s * 3, WRN_RET_TIME);
        InitTR(&pR->tMb_yuk_time, T_1s * 5, 0);
        InitTR(&pR->tTZZFG_5S0ms, pRunSet->dT_ZZFG, 0);      // 无故障延时5s
        InitTR(&pR->thzbs.tBSHZTime, pSet->dT_hzbs, T_20ms); // 分闸次数过多，闭锁合闸
        InitTR(&pR->thzbs.tTw100ms100ms, T_100ms, T_100ms);
        for (i = 0; i < 8; i++)
        {
            if (pRunSet->bTT_FDLTz[i])
            {
                InitTR(&pR->tFdl[i].tFdlTime, pRunSet->dTFDL[i], PRO_RET_TIME);
            }

            else
            {
                InitTR(&pR->tFdl[i].tFdlTime, pRunSet->dTFDL[i], WRN_RET_TIME);
            }
        }
        fresh_set_soe(EV_TYPE_S, !g_tRelay[sw].run_stu.fa_ls, true, sw);
        fresh_set_soe(EV_TYPE_L, g_tRelay[sw].run_stu.fa_ls, true, sw);

        fresh_set_soe(EV_BH_YB, FUN_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_BH_YBTT, BH_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_CHZ_YB, CHZ_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_FA_YBTT, FA_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_GOOSE_YBTT, BH_GOOSE_EN(sw), true, sw);
        fresh_set_soe(EV_JZS_YBTT, JZS_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_TQ_YBTT, TYTQ_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_JL_YBTT, JL_ALL_EN(sw), true, sw);
        fresh_set_soe(EV_XDLJD_YBTT, pRunSet->tSwSet[sw].btt_gnyb_xdljd, true, sw);
        fresh_set_soe(EV_XLDXGJ_YBTT, pRunSet->tSwSet[sw].btt_gnyb_xldxgj, true, sw);
        fresh_set_soe(EV_BTDCD_YBTT, pRunSet->tSwSet[sw].btt_gnyb_btdcd, true, sw);

        fresh_set_soe(EV_KZ_YB, pRunSet->tSwSet[sw].btt_yxyb_gnzck, true, sw);
        fresh_set_soe(EV_EDIT_YB, pRunSet->bTT_EDIT_YB, true, sw);

#ifdef FUNC_DRIVE_JY
        InitTR(&gb_drive.tDriveUa1Time, pSet->dT_drive_ua1, 0);
        InitTR(&gb_drive.tDriveUa2Time, pSet->dT_drive_ua2, 0);
        InitTR(&gb_drive.tDriveU0Time, pSet->dT_drive_u0, 0);
        InitTR(&gb_drive.tDriveITime, pSet->dT_drive_i, 0);
        InitTR(&gb_drive.tDriveI0Time, pSet->dT_drive_i0, 0);
        InitTR(&gb_drive.tDriveAgainTime, pSet->dT_drive_again, 0);
        InitTR(&gb_drive.tDriveFaBSTime, T_25ms * 2, 0);
#endif

#ifdef FUNC_DRIVE
        InitTR(&gb_drive.tQDTime_hz, pRunSet->tSwSet[sw].dT_Drive_hz, 0);
        InitTR(&gb_drive.tQDTime_fz, pRunSet->tSwSet[sw].dT_Drive_fz, 0);
        InitTR(&gb_drive.tQDTime_fz_end, pRunSet->tSwSet[sw].dT_fz_end, 0);
        InitTR(&gb_drive.tQDTime_hz_end, pRunSet->tSwSet[sw].dT_hz_end, 0);
#endif

#ifdef FUNC_REBOOT_BS_HA_JS_3S
        InitTR(&pR->tSDHZ.tHW_JS_HA_3STime, T_1s * 3, 0);
#endif
    }

    for (i = 0; i < VOL_NUMBER; i++)
    {
        InitTR(&g_tVol[i].tQDTime, pRunSet->tVolSet[i].dTVol, WRN_RET_TIME);
        InitTR(&g_tVol[i].tCYYTime, T_40ms, 0);
        InitTR(&g_tVol[i].tWaveYYTime, T_40ms, 0);
    }

    InitTR(&g_rmt_op.tTULK3STime, T_1s * 3, 0);
    InitTR(&g_tJLSDTime, pRunSet->dSDYX_T, T_1s * 5);

    InitTR(&tPT.tTPT1DXTime, T_1s * 10, WRN_RET_TIME);
    InitTR(&tPT.tTPT2DXTime, T_1s * 10, WRN_RET_TIME);
    SetTR_TRTT(&tPT.tTPT1DXTime, WRN_RET_TIME);
    SetTR_TRTT(&tPT.tTPT2DXTime, WRN_RET_TIME);
    InitTR(&tPT.tBatOnTime, T_1s * 2, WRN_RET_TIME);
    InitTR(&tPT.tTPT1XXYC, T_1s * 3, WRN_RET_TIME);
    InitTR(&tPT.tTPT2XXYC, T_1s * 3, WRN_RET_TIME);

#ifdef IEC_NOLINK_NO_CALLYX
    InitTR(&g_link_comm.tLinkBreak, T_1s * 60 * 3, 0);
#endif

#ifdef FUN_JDXX
    jdxx_relayinit();
#endif
}

/******************************************************************************
函数名称：	ProtectRelayInit1
函数版本：	01.01
创建作者：
创建日期：	2013-08-08
函数说明：	在保护巡检时有定值修改，重新初始化与保护相关的定时器，使修改后的延时有效
参数说明：
返回值：
修改记录：
*/
void ProtectRelayInit1(void)
{
    int sw, i;

    for (sw = 0; sw < g_sw_num; sw++)
    {
        TRELAY_T *pR = &g_tRelay[sw];
        TSETSW *pSet = &pRunSet->tSwSet[sw];
        int i;

#ifdef CUSTOMIZE_BZT // 备自投
        BztTimerChange(sw);
#endif
        for (i = 0; i < BHOC_NUMBER; i++)
        {
            TOC_T *poc = &pR->tOC[i];

#ifdef YX_RESET_TIME
            InitTR(&poc->tTzEvRstTime, tRunPara.dTEventRst, 0); // 遥信复归时间
            InitTR(&poc->tGjEvRstTime, tRunPara.dTEventRst, 0); // 遥信复归时间
#endif

            InitTR_Time(&poc->tQDTime, pSet->toc[i].dT, PRO_RET_TIME);
            InitTR_Time(&poc->tXBTime, pSet->toc[i].dT, PRO_RET_TIME);
            InitTR(&poc->tXBQD25ms, T_25ms * 2, 0);
            if (i >= BH_OVI)
            {
                InitTR_Time(&poc->tQDTime, pSet->toc[i].dT, WRN_RET_TIME); // 过载及重载，返回时间为1秒
            }
        }
        {
            TGOC_T *poc = &pR->tgoc;
            GOC_SET *pgset = &pSet->tGocSet;
            DWORD dTsytime;

            dTsytime = ((pgset->dTgzgl > pgset->dTsdlost) ? pgset->dTgzgl : pgset->dTsdlost) + T_300ms;
            if (pRunSet->bTT_goose_send_after)
            {
                InitTR_Time(&poc->tTZX_300ms, pgset->dTgl, pRunSet->dT_sendext); //
                InitTR_Time(&poc->tTFX_300ms, pgset->dTgl, pRunSet->dT_sendext); //
                InitTR_Time(&poc->tTWX_300ms, pgset->dTgl, pRunSet->dT_sendext); //
                InitTR_Time(&poc->tTLX_300ms, pgset->dTlx, pRunSet->dT_sendext); //
            }
            else
            {
                InitTR_Time(&poc->tTZX_300ms, T_5ms, pRunSet->dT_sendext); //
                InitTR_Time(&poc->tTFX_300ms, T_5ms, pRunSet->dT_sendext); //
                InitTR_Time(&poc->tTWX_300ms, T_5ms, pRunSet->dT_sendext); //
                InitTR_Time(&poc->tTLX_300ms, T_5ms, pRunSet->dT_sendext); //
            }
            InitTR_Time(&poc->tTGLBS_300ms, T_5ms, pRunSet->dT_sendext);   //
            InitTR_Time(&poc->tgoose15ms_gzgl, pRunSet->dT_goosecheck, 0); //

            InitTR_Time(&poc->tqccd.tCDTime, pRunSet->dT_cd, 0);
            InitTR_Time(&poc->tqccd.tWYTime, pRunSet->dT_glfd, 0);
            InitTR_Time(&poc->tglcd.tCDTime, pRunSet->dT_cd, 0);
            InitTR_Time(&poc->tglcd.tWYTime, pRunSet->dT_glfd, 0);
            if (pRunSet->dT_cd == 0)
            {
                InitTR_Time(&poc->tllcd.tCDTime, T_1s * 15, 0);
            }
            else
            {
                InitTR_Time(&poc->tllcd.tCDTime, pRunSet->dT_cd, 0);
            }

            InitTR_Time(&poc->tllcd.tWYTime, pRunSet->dT_llfd, 0);
            if (pRunSet->bTT_goose_send_after)
            {
                InitTR_Time(&poc->tglQDTime, pgset->dTgl + pRunSet->dT_goosecheck, PRO_RET_TIME); //
                InitTR_Time(&poc->tlxQDTime, pgset->dTlx + pRunSet->dT_goosecheck, PRO_RET_TIME); //
            }
            else
            {
                InitTR_Time(&poc->tglQDTime, ((pgset->dTgl > pRunSet->dT_goosecheck) ? pgset->dTgl : pRunSet->dT_goosecheck), PRO_RET_TIME); //
                InitTR_Time(&poc->tlxQDTime, ((pgset->dTlx > pRunSet->dT_goosecheck) ? pgset->dTlx : pRunSet->dT_goosecheck), PRO_RET_TIME); //
            }

            InitTR_Time(&poc->tgzglTime, pgset->dTgzgl, 0);                                                                              //
            InitTR_Time(&poc->tsdlostTime, pgset->dTsdlost, 0);                                                                          //
            InitTR_Time(&poc->terrlostTime, pgset->dTgzgl, 0);                                                                           //
            InitTR_Time(&poc->tllhzTime, pgset->dTll, 0);                                                                                //
            InitTR_Time(&poc->tllQdTime, pgset->dTll + ((pgset->dTgzgl > pgset->dTsdlost) ? pgset->dTgzgl : pgset->dTsdlost) + T_1s, 0); //

            InitTR_Time(&poc->tglslowTime, 0, pgset->dTgl + T_1s); //
            InitTR_Time(&poc->tlxslowTime, 0, pgset->dTlx + T_1s); //

#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
            if (pRunSet->bTT_goose_send_after)
            {
                InitTR_Time(&poc->tgl2QDTime, pgset->dTgl2 + pRunSet->dT_goosecheck, PRO_RET_TIME); //
                InitTR_Time(&poc->tTZX2_300ms, pgset->dTgl2, pRunSet->dT_sendext);                  //
                InitTR_Time(&poc->tTFX2_300ms, pgset->dTgl2, pRunSet->dT_sendext);                  //
                InitTR_Time(&poc->tTWX2_300ms, pgset->dTgl2, pRunSet->dT_sendext);                  //
            }
            else
            {
                InitTR_Time(&poc->tgl2QDTime, ((pgset->dTgl2 > pRunSet->dT_goosecheck) ? pgset->dTgl2 : pRunSet->dT_goosecheck), PRO_RET_TIME); //
                InitTR_Time(&poc->tTZX2_300ms, T_5ms, pRunSet->dT_sendext);                                                                     //
                InitTR_Time(&poc->tTFX2_300ms, T_5ms, pRunSet->dT_sendext);                                                                     //
                InitTR_Time(&poc->tTWX2_300ms, T_5ms, pRunSet->dT_sendext);                                                                     //
            }
            InitTR_Time(&poc->tglslowTime, 0, pgset->dTgl2 + T_1s); //
#endif
            InitTR_Time(&poc->tTzcheckTime, pRunSet->dT_TZSB, 0); // 开关失灵判断时间
            InitTR_Time(&poc->tHzcheckTime, pRunSet->dT_HZSB, 0); // 开关失灵判断时间

            InitTR_Time(&poc->ttzsbextTime, 0, pRunSet->dT_sendext);     //  跳闸失败(开关失灵)展宽时间
            InitTR_Time(&poc->tgzglokextTime, 0, pRunSet->dT_sendext);   // 发送展宽 300毫秒
            InitTR_Time(&poc->tgzglokForbitTime, 0, pRunSet->dT_frobit); // 发送故障隔离成功后闭锁时间
            InitTR_Time(&poc->tCYY3sdelayms, T_1s * 3, dTsytime);
            InitTR_Time(&poc->tgoosedelayms_ll, dTsytime + pRunSet->dT_TZSB * 2, 0);
            InitTR_Time(&poc->textbsTime, 0, pRunSet->dT_sendext + T_100ms);
        }

        // 重合闸
        InitTR_Time(&pR->tCHZ.tTCHCD15s0s, pSet->dT_chz_cd, 0);        // 充电１５秒
        InitTR_Time(&pR->tCHZ.tTCHJD_ARDelay, pSet->dT_chz[0], 0);     // 重合闸延时
        InitTR_Time(&pR->tCHZ.tTCHFAIL_TW, pSet->dT_chz[0] + T_1s, 0); // 三相跳位延时: 重合失败返回时间
        InitTR_Time(&pR->tCHZ.tTCHBSDelay, pSet->dT_chz_bs, 0);        // 重合闭锁延时
        InitTR_Time(&pR->tCHZ.tTCHOKTime, pSet->dT_chz_ok, 0);         // 重合成功
        InitTR_Time(&pR->tCHZ.tTCHJBSTime, 0, pSet->dT_chz_ok);        // 重合闭锁时间
#ifdef PRO_UZ_START_REC
        InitTR(&pR->tCHZ.tTCH_UO_BS, T_100ms, 0); // 零序电压重合闭锁延时
#endif
        InitTR(&pR->tCHZ.tTCHOPENTime, pSet->dT_chz_Topen, 0); // 重合开放时间

        // 配网功能定值
        InitTR_Time(&pR->tSDHZ.tOnXSTime, pSet->dT_X, 0);
        InitTR_Time(&pR->tSDHZ.tOnYSTime, pSet->dT_Y, 0);
        InitTR_Time(&pR->tSDHZ.tOnXLTime, pSet->dT_XL, 0);
        InitTR_Time(&pR->tSDHZ.tOnYLTime, pSet->dT_Y, 0);
#ifdef GD_AREA_ZHONGSHAN_2020
        InitTR_Time(&pR->tSDHZ.tOnLLCDYLTime, pSet->dT_LL_CD, 0);
#endif

        InitTR_Time(&pR->tSDHZ.tOnBSTZTime, pSet->dT_fa_bsTz, 0);
        InitTR_Time(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0); ////初始化单侧来电解锁计时器
#if defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
#if defined GD_AREA_ECZD_2020
#if defined FUNC_SET_FA_JS
        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, pRunSet->dT_FA_JS, 0);
#else
        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, 5 * T_10ms, 0);
#endif
#else
        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s * 6, 0);
#endif
#else
        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s, 0);
#endif
        InitTR_Time(&pR->tSDHZ.tOnOCingTime, pSet->dT_fa_ocing, pSet->dT_Y);
        InitTR_Time(&pR->tSDHZ.tOnLXingTime, pSet->dT_fa_lxing, pSet->dT_Y);
#ifdef GD_AREA_ZHONGSHAN_2020
        InitTR_Time(&pR->tSDHZ.tOnY_JSTime, 0, 0);
#elif defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
        InitTR_Time(&pR->tSDHZ.tOnY_JSTime, T_1s * 6, 0);
#else
        InitTR_Time(&pR->tSDHZ.tOnY_JSTime, T_1s * 3, 0);
#endif
#ifdef FA_OC_COUNT
        InitTR_Time(&pR->tSDHZ.tFaOcCountTime, pSet->fa_oc_conut_time, 0);
#endif

#if 0
		if(pSet->toc[FA_GL].dT>T_10ms*3)
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime,pSet->toc[FA_GL].dT-T_10ms*3,pSet->dT_Y);
		}
		else
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime,0,pSet->dT_Y);
		}
		if(pSet->toc[FA_GL2].dT>T_10ms*3)
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time,pSet->toc[FA_GL2].dT-T_10ms*3,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time,0,pSet->dT_Y);


		if(pSet->toc[FA_LX].dT>T_10ms*3)
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime,pSet->toc[FA_LX].dT-T_10ms*3,pSet->dT_Y);
		}
		else
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime,0,pSet->dT_Y);
		}
		if(pSet->toc[FA_LX2].dT>T_10ms*3)
			InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time,pSet->toc[FA_LX2].dT-T_10ms*3,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time,0,pSet->dT_Y);
#else
        if (pSet->toc[FA_GL].dT > T_FA_TZ_MIN_TIME)
            InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime, pSet->toc[FA_GL].dT, pSet->dT_Y);
        else
            InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime, T_FA_TZ_MIN_TIME, pSet->dT_Y);

        if (pSet->toc[FA_GL_II].dT > T_FA_TZ_MIN_TIME)
            InitTR_Time(&pR->tSDHZ.tGZJYRstGL_II_Time, pSet->toc[FA_GL_II].dT, pSet->dT_Y);
        else
            InitTR_Time(&pR->tSDHZ.tGZJYRstGL_II_Time, T_FA_TZ_MIN_TIME, pSet->dT_Y);

        if (pSet->toc[FA_GL2].dT > T_FA_TZ_MIN_TIME)
            InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time, pSet->toc[FA_GL2].dT, T_20ms);
        else
            InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time, T_FA_TZ_MIN_TIME, T_20ms);

        if (pSet->toc[FA_LX].dT > T_FA_TZ_MIN_TIME)
            InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime, pSet->toc[FA_LX].dT, pSet->dT_Y);
        else
            InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime, T_FA_TZ_MIN_TIME, pSet->dT_Y);

        if (pSet->toc[FA_LX2].dT > T_FA_TZ_MIN_TIME)
            InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time, pSet->toc[FA_LX2].dT, pSet->dT_Y);
        else
            InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time, T_FA_TZ_MIN_TIME, pSet->dT_Y);
#endif

        InitTR_Time(&pR->tSDHZ.tUABS25ms, pSet->dT_fa_YY, T_25ms * 2);
        InitTR_Time(&pR->tSDHZ.tUBCS25ms, pSet->dT_fa_YY, T_25ms * 2);

        InitTR_Time(&pR->tSDHZ.tUABL25ms, pSet->dT_fa_YY, T_25ms * 2);
        InitTR_Time(&pR->tSDHZ.tUBCL25ms, pSet->dT_fa_YY, T_25ms * 2);

        InitTR_Time(&pR->tSDHZ.tL_RELAYONL3s, pSet->dT_Y, 0);
        InitTR_Time(&pR->tSDHZ.tUFABL80ms, pRunSet->dT_XCY, pSet->dT_Y - T_1s);
        InitTR_Time(&pR->tSDHZ.tUFBCL80ms, pRunSet->dT_XCY, pSet->dT_Y - T_1s);
        InitTR_Time(&pR->tSDHZ.tUFDBTime, pRunSet->dT_XCY, 0);
        InitTR_Time(&pR->tSDHZ.tUFABS80ms, pRunSet->dT_XCY, pSet->dT_X);
        InitTR_Time(&pR->tSDHZ.tUFBCS80ms, pRunSet->dT_XCY, pSet->dT_X);
        InitTR_Time(&pR->tSDHZ.tUFABS25ms, T_25ms, pRunSet->dT_XCY + T_1s);
        InitTR_Time(&pR->tSDHZ.tUFBCS25ms, T_25ms, pRunSet->dT_XCY + T_1s);
        InitTR_Time(&pR->tSDHZ.tUFABL25ms, T_25ms, pRunSet->dT_XCY + T_1s);
        InitTR_Time(&pR->tSDHZ.tUFBCL25ms, T_25ms, pRunSet->dT_XCY + T_1s);

#ifdef FA_PL_PJ
        InitTR(&pR->tSDHZ.tFREQAB25ms_SCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQBC25ms_SCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQAB25ms_LCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQBC25ms_LCY, T_25ms * 2, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQSAB25ms, T_25ms, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQSBC25ms, T_25ms, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQLAB25ms, T_25ms, T_25ms * 2);
        InitTR(&pR->tSDHZ.tFREQLBC25ms, T_25ms, T_25ms * 2);
#endif

        InitTR_Time(&pR->tSDHZ.tHz0ms1s, 0, tRunPara.wFAHZT * T_5ms / 5 + T_1s);
        InitTR_Time(&pR->tSDHZ.tTz0ms1s, 0, tRunPara.wFAFZT * T_5ms / 5 + T_1s);
        InitTR_Time(&pR->tSDHZ.tHz0ms2s, pRunSet->dT_HZSB, 0);
        InitTR_Time(&pR->tSDHZ.tTz0ms2s, pRunSet->dT_TZSB, 0);

        InitTR_Time(&pR->tSDHZ.tTSDHzHJS, 0, pSet->dT_Y); // 上电合闸加速判断

        InitTR_Time(&pR->tU0TZ.tZOVTime, pSet->dT_OverU0, T_20ms);
        InitTR_Time(&pR->tOVER_U0TZ.tZOVTime, pSet->dBHTOverU0, T_20ms);

        // 解列

        InitTR_Time(&pR->tDYJL.tDdyTime, pSet->dT_jl_ddy, T_20ms);
        InitTR_Time(&pR->tDYJL.tGdyTime, pSet->dT_jl_gdy, T_20ms);
        InitTR_Time(&pR->tDYJL.tHighTime, pSet->dT_jl_ggdy, T_20ms);
        InitTR_Time(&pR->tDYJL.tLowTime, pSet->dT_jl_gddy, T_20ms);

        InitTR_Time(&pR->tPLJL.tDhzTime, pSet->dT_jl_dhz, T_40ms);
        InitTR_Time(&pR->tPLJL.tHighTime, pSet->dT_jl_ghz, T_40ms);
        InitTR_Time(&pR->tPLJL.tLowTime, pSet->dT_jl_lowhz, T_40ms);

        InitTR_Time(&pR->tLostVot.tLostVotTime, pSet->dT_Z, T_20ms);
        InitTR_Time(&pR->tLostVot.tLostVLockTime, 0, pSet->dT_fa_bsTz);
        InitTR_Time(&pR->tTQHz.tTQTime, pSet->dT_tq, 0); // 同期

        InitTR_Time(&pR->tSWST.tTWCNGJ1s, pRunSet->dWCN_T, WRN_RET_TIME);
        InitTR_Time(&pR->tSWST.tTKZHLGJ1s, T_1s * 10, WRN_RET_TIME);
        InitTR_Time(&pR->tTripfail_2s, pRunSet->dT_TZSB, 0); // 跳闸失败时间继电器
        InitTR_Time(&pR->tTripfail_hz, 0, pRunSet->dT_TZSB); // 跳闸失败时间继电器

        InitTR_Time(&pR->tSWST.tCTXXYC, T_1s * 3, WRN_RET_TIME); // CT相序异常
        InitTR_Time(&pR->tSWST.tCTYC, T_1s * 10, WRN_RET_TIME);  // CT断线
        InitTR_Time(&pR->tTZZFG_5S0ms, pRunSet->dT_ZZFG, 0);     // 无故障延时5s

        for (i = 0; i < 8; i++)
        {
            if (pRunSet->bTT_FDLTz[i])
            {
                InitTR_Time(&pR->tFdl[i].tFdlTime, pRunSet->dTFDL[i], PRO_RET_TIME);
            }

            else
            {
                InitTR_Time(&pR->tFdl[i].tFdlTime, pRunSet->dTFDL[i], WRN_RET_TIME);
            }
        }

#ifdef FUNC_DRIVE_JY
        InitTR(&gb_drive.tDriveUa1Time, pSet->dT_drive_ua1, 0);
        InitTR(&gb_drive.tDriveUa2Time, pSet->dT_drive_ua2, 0);
        InitTR(&gb_drive.tDriveU0Time, pSet->dT_drive_u0, 0);
        InitTR(&gb_drive.tDriveITime, pSet->dT_drive_i, 0);
        InitTR(&gb_drive.tDriveI0Time, pSet->dT_drive_i0, 0);
        InitTR(&gb_drive.tDriveAgainTime, pSet->dT_drive_again, 0);
        InitTR(&gb_drive.tDriveFaBSTime, T_25ms * 2, 0);
#endif
#ifdef FUNC_DRIVE
        InitTR(&gb_drive.tQDTime_hz, pRunSet->tSwSet[sw].dT_Drive_hz, 0);
        InitTR(&gb_drive.tQDTime_fz, pRunSet->tSwSet[sw].dT_Drive_fz, 0);
        InitTR(&gb_drive.tQDTime_fz_end, pRunSet->tSwSet[sw].dT_fz_end, 0);
        InitTR(&gb_drive.tQDTime_hz_end, pRunSet->tSwSet[sw].dT_hz_end, 0);
#endif
    }

    for (i = 0; i < VOL_NUMBER; i++)
    {
        InitTR_Time(&g_tVol[i].tQDTime, pRunSet->tVolSet[i].dTVol, WRN_RET_TIME);
    }
    InitTR_Time(&g_tJLSDTime, pRunSet->dSDYX_T, T_1s * 5);
    InitTR_Time(&tFAg.tRstTime, pRunSet->dT_sendext * 10, 0);

#ifdef FUN_JDXX
    jdxx_relayinit();
#endif
}

/**************************************************************************
函数名称：ValueOverRelay
函数版本：1.00
作者：    mwd
创建日期：2007.9.29
函数功能说明：过量继电器

输入参数：dI、dIdz 相比较
          CONST_FHXISHU: 返回系数，常数
          bEN: 1--返回系数有效，0－返回系数无效
其他输入:
输出参数?
返回值：?I>dIdz,返回true ,否则，返回false
***************************************************************************/
bool OverRelay(DWORD dI, DWORD dIdz, DWORD dfhdz, bool bEN)
{
    if (bEN)
    {
        if (dI > dfhdz)
        {
            return (true);
        }
        else
        {
            return (false);
        }
    }
    else
    {
        if (dI > dIdz)
        {
            return (true);
        }
        else
        {
            return (false);
        }
    }
}

/**************************************************************************
函数名称：ValueLowRelay
函数版本：1.00
作者：
创建日期：2007.9.29
函数功能说明：欠量继电器

输入参数：dI、dIdz 相比较
          CONST_FHXISHU: 返回系数，常数
          bEN: 1--返回系数有效，0－返回系数无效
其他输入:
输出参数?
返回值：?I>dIdz,返回true ,否则，返回false
***************************************************************************/
bool LowRelay(DWORD dI, DWORD dIdz, DWORD dfhdz, bool bEN)
{
    if (bEN)
    {
        if (dI < dfhdz)
        {
            return (true);
        }
        else
        {
            return (false);
        }
    }
    else
    {
        if (dI < dIdz)
        {
            return (true);
        }
        else
        {
            return (false);
        }
    }
}

/**************************************************************************
函数名称：SelectFrom
函数版本：1.00
作者：    MWD
创建日期：2007.9.29
函数功能说明：二选一函数

输入参数：DWORD A: 待选数
          DWORD B: 待选数
          bool  bSelect

输出参数：
返回值：  bSelect=0 时，返回 A; bSelect=1 时，返回 B;
**************************************************************************/
DWORD SelectMax(DWORD A, DWORD B, DWORD C)
{
    DWORD max;
    max = A;
    if (B > max)
    {
        max = B;
    }
    if (C > max)
    {
        max = C;
    }

    return (max);
}

/**************************************************************************
函数名称：CalcAngSub
函数版本：1.00
作者：    MWD
创建日期：2007.9.29
函数功能说明：计算向量角差，并转换至 0~360之间

输入参数：long Real1,
          long Imag1,
          long Imag2,
          long Imag2

输出参数：
返回值：  long 角差;
**************************************************************************/
long CalcAngSub(long Real1, long Imag1, long Real2, long Imag2)
{
    long lTmp;

    lTmp = _AngPQ(Real1, Imag1) - _AngPQ(Real2, Imag2);

    // 规格化在0 ~ 360之间
    if (lTmp < 0)
    {
        lTmp += ANGLE_P360;
    }
    if (lTmp > ANGLE_P180) // 转换为-180 ~180
    {
        lTmp -= ANGLE_P360;
    }

    return (lTmp);
}

/**************************************************************************
函数名称：SynJudge
函数版本：1.00
作者：    保护组 MWD
创建日期：2007.10.13
函数功能说明：同期判别

输入参数：long ANG1:    UX与UA角差
          long ANG2:    UX与UA角差记忆值
          DWORD ANGSET: 同期角度定值
输出参数：
返回值：  TRUE－－－同期满足，
          FALSE－－同期不满足
**************************************************************************/
bool SynJudge(long lANG1, long lANG2, DWORD dANGSET) // 同期判别
{
    bool bStatus;
    long lTemp;

    lTemp = lAbs(lANG1 - lANG2);

    if (((long)dANGSET > lTemp) || (lTemp > (ANGLE_P360 - (long)dANGSET)))
    {
        bStatus = 1;
    }
    else
    {
        bStatus = 0;
    }
    return (bStatus);
}

/**************************************************************************
函数名称：PowerDirectionalRelay
函数版本：1.00
作者：    Chenlei
创建日期：2007.11.4
函数功能说明：输入电压、电流和阻抗角定值以及电压门槛定值，判断测量阻抗是否
              落在动作特性区内，并输出动作标志。
输入参数：Ur -- 电压实部
          Ui -- 电压虚部
          U  -- 电压幅值
　　　　　Ir -- 电流实部
          Ii -- 电流虚部
          I  -- 电流幅值
          Umk -- 电压门槛
          Imk -- 电流门槛
          Ang1 -- 灵敏角1
          Ang2 -- 灵敏角2

输出参数：管脚10_动作标志

返回值：  false-不动作；true-动作
**************************************************************************/
bool PowerDirectionalRelay(long Ur, long Ui, DWORD U, long Ir, long Ii, DWORD I, DWORD Umk, DWORD Imk, long sina1, long cosa1, long sina2, long cosa2)
{
    bool bDIRB;

    long lTemp;  // 中间变量
    long lTemp1; // 中间变量
    long lTemp2; // 中间变量

    bDIRB = false;
    if ((U > Umk) && (I > Imk)) // 电压、电流均大于门槛，进行方向判断；否则，返回
    {

        lTemp1 = _MulFac_S(Ur, (Ir * cosa1 - Ii * sina1));
        lTemp2 = _MulFac_S(Ui, (Ii * cosa1 + Ir * sina1));
        lTemp = lTemp1 + lTemp2;

        if (lTemp > 0)
        {
            lTemp1 = _MulFac_S(Ur, (Ir * cosa2 - Ii * sina2));
            lTemp2 = _MulFac_S(Ui, (Ii * cosa2 + Ir * sina2));
            lTemp = lTemp1 + lTemp2;

            if (lTemp > 0)
            {
                bDIRB = true;
            }
        }
    }
    return (bDIRB);
}

/******************************end*****************************************/