修复 : 测试常规保护遇到的问题;

README.md

@@ -70,4 +70,5 @@
 08. 合并 : 零压、零流突变录波逻辑;
 09. 修改 : 录波逻辑为开关录波;
 10. 修复 : 初始化软、硬件错误计数时会将已设置的错误计数清零的问题;
-11. 修复 : 直流量2没有对应采样通道遥测也有很大零漂的问题;
+11. 修复 : 直流量2没有对应采样通道遥测也有很大零漂的问题;
+12. 修复 : 测试常规保护遇到的问题;

app_public/fuxi_public/fuxi_bsp/include/debug_print.h

@@ -35,17 +35,17 @@
 #define dp_info_h_s(fmt, args...) \
     printf(DP_COLOR_WATHET "[INFO] " DP_COLOR_NONE fmt "\r\n", ##args)
 #define dp_info_h_c(fmt, args...) \
-    printf(DP_COLOR_WATHET "[INFO][%s:%d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_WATHET "[INFO][%20s : %5d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
 
 #define dp_info_n_s(fmt, args...) \
     printf(DP_COLOR_WATHET "[INFO] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_info_n_c(fmt, args...) \
-    printf(DP_COLOR_WATHET "[INFO][%s:%d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_WATHET "[INFO][%20s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 #define dp_info_a_s(fmt, args...) \
     printf(DP_COLOR_WATHET "[INFO] " fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_info_a_c(fmt, args...) \
-    printf(DP_COLOR_WATHET "[INFO][%s:%d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_WATHET "[INFO][%20s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 /* 错误提示 nt整行不带[tag] h只有[tag]显示红色 n[tag]显示为红色内容为蓝色 a[tag]整行为红色 */
 #define dp_err_nt(fmt, args...) \
@@ -54,35 +54,35 @@
 #define dp_err_h_s(fmt, args...) \
     printf(DP_COLOR_RED "[ERR] " DP_COLOR_NONE fmt "\r\n", ##args)
 #define dp_err_h_c(fmt, args...) \
-    printf(DP_COLOR_RED "[ERR][%s:%d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_RED "[ERR][%20s : %5d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
     
 #define dp_err_n_s(fmt, args...) \
     printf(DP_COLOR_RED "[ERR] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_n_c(fmt, args...) \
-    printf(DP_COLOR_RED "[ERR][%s:%d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_RED "[ERR][%20s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
     
 #define dp_err_a_s(fmt, args...) \
     printf(DP_COLOR_RED "[ERR] " fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_a_c(fmt, args...) \
-    printf(DP_COLOR_RED "[ERR][%s:%d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_RED "[ERR][%20s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 
 #define dp_info_nt_rt(fmt, args...) \
-    rt_printf(DP_COLOR_WATHET fmt DP_COLOR_NONE "\r\n", ##args)
+    rt_printf(DP_COLOR_WATHET "[%20s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 #define dp_err_nt_rt(fmt, args...) \
-    rt_printf(DP_COLOR_RED fmt DP_COLOR_NONE "\r\n", ##args)
+    rt_printf(DP_COLOR_RED "[%20s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 #define dp_err_n_s_rt(fmt, args...) \
     rt_printf(DP_COLOR_RED "[ERR] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_n_c_rt(fmt, args...) \
-    rt_printf(DP_COLOR_RED "[ERR][%s:%d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    rt_printf(DP_COLOR_RED "[ERR][%20s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
     
 #define dp_info_nt_pk(fmt, args...) \
-    printk(DP_COLOR_WATHET fmt DP_COLOR_NONE "\r\n", ##args)
+    printk(DP_COLOR_WATHET "[%20s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 #define dp_err_n_s_pk(fmt, args...) \
     printk(DP_COLOR_RED "[ERR] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_n_c_pk(fmt, args...) \
-    printk(DP_COLOR_RED "[ERR][%s:%d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printk(DP_COLOR_RED "[ERR][%20s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 /***** 头文件 *****/
 

dtu/dtu_main_t536/app/FA.h

@@ -75,19 +75,19 @@ typedef union UVOT_U
     {
         WORD bQD : 1;  // 失压启动
         WORD bQD1 : 1; // 失压启动
-        WORD bTz : 1;  // 动作
-        WORD bHz : 1;
+        WORD bTz : 1;  // 跳闸动作
+        WORD bHz : 1;  // 合闸动作
 
         WORD bLock : 1; // 合后故障闭锁失压分闸标志
         WORD bGL : 1;   // 合后故障闭锁失压分闸标志
         WORD bJD : 1;   // 合后接地故障闭锁失压分闸标志
 
-        WORD bGLQD : 1;
-        WORD bStartLock : 1; //
-        WORD bDISENDZ : 1;   // 保护退出
-        WORD bDISENBS : 1;   // 保护退出
+        WORD bGLQD : 1;      // 过流启动 暂时没用
+        WORD bStartLock : 1; // 暂时没用
+        WORD bDISENDZ : 1;   // 暂时没用
+        WORD bDISENBS : 1;   // 暂时没用
 
-        WORD bEvent : 1;
+        WORD bEvent : 1; // 事件记录
         WORD bFault : 1; // 计数完成
         WORD bTz1 : 1;   // 计数完成
         WORD bSHWY : 1;  // 手合无压标志
@@ -97,13 +97,13 @@ typedef union UVOT_U
 
 typedef struct TLOSTVOT_T
 {
-    UVOT_U uLostVot;        // 失压标志
-    TIMERELAY tLostVotTime; // 失压跳闸时间继电器
-    TIMERELAY tCYY25ms0ms;  // 曾有压标志
-    TIMERELAY tLostVLockTime;
-    bool bLostVotLed;
-    WORD losttimes; // 失压次数
-    WORD wfFlagsave;
+    UVOT_U uLostVot;          // 失压标志
+    TIMERELAY tLostVotTime;   // 失压跳闸时间继电器
+    TIMERELAY tCYY25ms0ms;    // 曾有压标志
+    TIMERELAY tLostVLockTime; // 闭锁分闸复归时间
+    bool bLostVotLed;         // 失压跳闸
+    WORD losttimes;           // 失压次数
+    WORD wfFlagsave;          // 暂时没用
 } TLOSTVOT_T;
 
 typedef struct TTQHZ_T
@@ -119,16 +119,16 @@ typedef union UU0_U
     WORD wfFlag;
     struct
     {
-        WORD bQD : 1; // 失压启动
-        WORD bTz : 1; // 告警动作
-        WORD bEvent : 1;
-        WORD bLock : 1; // 合后故障闭锁失压分闸标志
-        WORD bGJQD : 1; // 失压启动
-        WORD bGJ : 1;   // 告警动作
-        WORD bU0Ov : 1; // 合后故障闭锁失压分闸标志
-        WORD bGJEvent : 1;
+        WORD bQD : 1;      // 失压启动
+        WORD bTz : 1;      // 告警动作
+        WORD bEvent : 1;   // 事件记录
+        WORD bLock : 1;    // 合后故障闭锁失压分闸标志
+        WORD bGJQD : 1;    // 失压启动
+        WORD bGJ : 1;      // 告警动作
+        WORD bU0Ov : 1;    // 合后故障闭锁失压分闸标志
+        WORD bGJEvent : 1; // 告警事件记录
         WORD bDISENGJ : 1; // 保护退出
-        WORD bDISENDZ : 1;
+        WORD bDISENDZ : 1; // 暂时没用
     } bFlag;
 } UU0_U;
 
@@ -137,8 +137,8 @@ typedef struct TU0_T //
     UU0_U uZOV;          // 零序过压标志
     TIMERELAY tZOVTime;  // 零序过压跳闸时间继电器
     TIMERELAY tU0TzTime; // 零序过压跳闸时间继电器
-    bool bU0Led;
-    bool bU0GjLed;
+    bool bU0Led;         // 零压跳闸led
+    bool bU0GjLed;       // 零压告警led
 } TU0_T;
 
 typedef union USDHZ_U
@@ -146,10 +146,10 @@ typedef union USDHZ_U
     DDWORD wfFlag;
     struct
     {
-        DDWORD bUABYY : 1; // UAB有压标志
-        DDWORD bUBCYY : 1; // UBC有压标志
-        DDWORD bUABFlash : 1;
-        DDWORD bUBCFlash : 1;
+        DDWORD bUABYY : 1;    // UAB有压标志
+        DDWORD bUBCYY : 1;    // UBC有压标志
+        DDWORD bUABFlash : 1; // 1
+        DDWORD bUBCFlash : 1; // 2
 
         DDWORD bPower : 1;    // 上电记录标志 Uab1侧，电源侧
         DDWORD bYY : 1;       // 有压标志
@@ -198,14 +198,14 @@ typedef union USDHZ_U
 
 typedef struct TSDHZ_T
 {
-    USDHZ_U uSdhz_S; // 分段开关上电合闸标志
-    USDHZ_U uSdhz_L; // 联络开关上电合闸标志
+    USDHZ_U uSdhz_S; // 分段开关标志
+    USDHZ_U uSdhz_L; // 联络开关标志
 
     WORD S_Status; // 分段开关运行中的状态标志
     WORD L_Status; // 联络开关运行中的状态标志
 
-    DWORD s_flag_save;
-    DWORD l_flag_save;
+    DWORD s_flag_save; // 分段关标志备份
+    DWORD l_flag_save; // 联络标志备份
 
     WORD S_Status_save; // 分段开关运行中的状态标志
     WORD L_Status_save; // 联络开关运行中的状态标志
@@ -213,9 +213,9 @@ typedef struct TSDHZ_T
     WORD fa_oc_count;         // 过流次数
     TIMERELAY tFaOcCountTime; // 过流脉冲复归继电器
 #endif
-    bool bDL_Tz;
-    bool bDL_Hz;
-    bool bInitUF;
+    bool bDL_Tz;  // 手分闭锁标志
+    bool bDL_Hz;  // 手合标志
+    bool bInitUF; // 瞬压标志
 
     bool bSDHZinit; // 上电合闸初始化:无压后启动S上电合闸 1--初始化,0--未初始化
 
@@ -233,32 +233,32 @@ typedef struct TSDHZ_T
     TIMERELAY tOnY_JSTime;     // 正向闭锁后，反向来电合闸双侧有压时间继电器，中山局要求3S
     TIMERELAY tOnBSTZTime;     // 合闸成功闭锁跳闸时间
     TIMERELAY tOnHW_FA_JSTime; // 合位直接解锁时间 默认1s
-    TIMERELAY tUABS25ms;
-    TIMERELAY tUBCS25ms;
+    TIMERELAY tUABS25ms;       // AB有压
+    TIMERELAY tUBCS25ms;       // BC有压
 #ifdef FUNC_NYY_NWY
-    TIMERELAY tUABS_NYY_NWY_50ms;
-    TIMERELAY tUBCS_NYY_NWY_50ms;
-    TIMERELAY tUABL_NYY_NWY_50ms;
-    TIMERELAY tUBCL_NYY_NWY_50ms;
+    TIMERELAY tUABS_NYY_NWY_50ms; // 两个有压
+    TIMERELAY tUBCS_NYY_NWY_50ms; // 两个有压
+    TIMERELAY tUABL_NYY_NWY_50ms; // 两个有压
+    TIMERELAY tUBCL_NYY_NWY_50ms; // 两个有压
 #endif
 
-    TIMERELAY tUDBS100ms;
+    TIMERELAY tUDBS100ms; // 暂时没用
 
-    TIMERELAY tUFABL80ms;
-    TIMERELAY tUFBCL80ms;
-    TIMERELAY tUFDBTime; // 瞬压判断时间
+    TIMERELAY tUFABL80ms; // 残压
+    TIMERELAY tUFBCL80ms; // 残压
+    TIMERELAY tUFDBTime;  // 瞬压判断时间
 
-    TIMERELAY tUABL25ms;
-    TIMERELAY tUBCL25ms;
+    TIMERELAY tUABL25ms; // 电压计时器
+    TIMERELAY tUBCL25ms; // 电压计时器
 
-    TIMERELAY tUFABS80ms;
-    TIMERELAY tUFBCS80ms;
+    TIMERELAY tUFABS80ms; // 计时器
+    TIMERELAY tUFBCS80ms; // 计时器
 
-    TIMERELAY tUFABS25ms;
-    TIMERELAY tUFBCS25ms;
+    TIMERELAY tUFABS25ms; // 计时器
+    TIMERELAY tUFBCS25ms; // 计时器
 
-    TIMERELAY tUFABL25ms;
-    TIMERELAY tUFBCL25ms;
+    TIMERELAY tUFABL25ms; // 计时器
+    TIMERELAY tUFBCL25ms; // 计时器
 
     TIMERELAY tFREQAB25ms_SCY; // 用于S模式电源侧残压的频率判断
     TIMERELAY tFREQBC25ms_SCY; // 用于S模式线路侧残压的频率判断
@@ -269,12 +269,12 @@ typedef struct TSDHZ_T
     TIMERELAY tFREQLAB25ms;    // 用于L模式电源侧得电合闸的频率判断
     TIMERELAY tFREQLBC25ms;    // 用于L模式线路侧得电合闸的频率判断
 
-    TIMERELAY tL_RELAYONL3s;
-    TIMERELAY tHzS100ms;
-    TIMERELAY tTSDHzHJS; // 上电合闸后加速延时
+    TIMERELAY tL_RELAYONL3s; // 合闸确认
+    TIMERELAY tHzS100ms;     // 合闸
+    TIMERELAY tTSDHzHJS;     // 上电合闸后加速延时
 
-    TIMERELAY tOpsiteYY100ms;
-    TIMERELAY tPowerYY100ms;
+    TIMERELAY tOpsiteYY100ms; // 对侧来电计时器
+    TIMERELAY tPowerYY100ms;  // 上电侧来电计时器
 
     TIMERELAY tGZJYRstGL_II_Time; // 故障记忆复归时间
 
@@ -284,14 +284,15 @@ typedef struct TSDHZ_T
     TIMERELAY tGZJYRstGL2Time; // 故障记忆复归时间
     TIMERELAY tGZJYRstJD2Time; // 故障记忆复归时间
 
-    TIMERELAY tHw100ms100ms;
-    TIMERELAY tTw100ms100ms;
-    TIMERELAY tHz0ms1s;
-    TIMERELAY tTz0ms1s;
-    TIMERELAY tHz0ms2s;
-    TIMERELAY tTz0ms2s;
-    bool bS_BSLed;
-    bool bL_BSLed;
+    TIMERELAY tHw100ms100ms; // 合位计时器
+    TIMERELAY tTw100ms100ms; // 跳位计时器
+    TIMERELAY tHz0ms1s;      // 合闸
+    TIMERELAY tTz0ms1s;      // 跳闸
+    TIMERELAY tHz0ms2s;      // 合闸
+    TIMERELAY tTz0ms2s;      // 跳闸
+    bool bS_BSLed;           // 分段闭锁led
+    bool bL_BSLed;           // 联络闭锁led
+
 #ifdef FUNC_REBOOT_BS_HA_JS_3S
     TIMERELAY tHW_JS_HA_3STime; // 合位解锁手分/遥分闭锁时间 默认3S
 #endif

dtu/dtu_main_t536/app/Sys.c

@@ -552,6 +552,7 @@ void Delayms(DWORD dT, DWORD count)
     {
     }
 }
+
 // 复归合位状态下允许点亮的LED灯，eg：重合灯动作灯、告警灯
 void ResetHzLed(int rstsw)
 {

dtu/dtu_main_t536/app/UnitsLib.c

@@ -154,19 +154,18 @@ void ProtectRelayInit(void)
         }
 
         // 重合闸
-        InitTR(&pR->tCHZ.tTCHQDHW0ms50ms, 0, T_10ms * 5);         // 合闸位置下降沿展宽50ms
-        InitTR(&pR->tCHZ.tTCHQD0ms50ms, 0, T_10ms * 5);           // 跳闸开出下降沿展宽50ms
-        InitTR(&pR->tCHZ.tTCHJD_0ms30ms, 0, T_10ms * 3);          // 弹簧未储能下降沿展宽30ms
+        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.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,			T_1s);		// zwg20151019,后加速有效展宽,从200ms改为1s，方便测试
-        InitTR(&pR->tCHZ.tTCHJD_HJS, 0, T_300ms);          // 2020-07-23 分位持续检测时间改为1s，按照广东标准2020 手合开放检测时间，将3s时间改为0.3s，即分闸持续1S以上，手合0.3秒内可启动后加速
-        InitTR(&pR->tCHZ.tTCHJBSTime, 0, pSet->dT_chz_ok); // 重合闭锁时间
-        InitTR(&pR->tCHZ.tTCHJBSHw, T_100ms, 0);           // 开关合位100ms确认
+        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); // 零序电压重合闭锁延时
@@ -557,7 +556,7 @@ void ProtectRelayInit1(void)
         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.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); // 零序电压重合闭锁延时
@@ -902,6 +901,7 @@ long CalcAngSub(long Real1, long Imag1, long Real2, long Imag2)
 
     return (lTmp);
 }
+
 /**************************************************************************
 函数名称：SynJudge
 函数版本：1.00
@@ -933,6 +933,7 @@ bool SynJudge(long lANG1, long lANG2, DWORD dANGSET) // 同
     }
     return (bStatus);
 }
+
 /**************************************************************************
 函数名称：PowerDirectionalRelay
 函数版本：1.00

dtu/dtu_main_t536/app/defineSys.h

@@ -28,6 +28,7 @@
 #define BHFA_YB_YK                     // 遥控保护和FA软压板投退
 #define EV_GL_STATR                    // 过流启动SOE
 #define DISP_CHZOKCHR_2_SW             // 重合闸确认时间+充电时间移到开关定值
+#define FUNC_CHZ_CHARGE_TIME		   // 重合闸充电通用一个定值，不管几次重合闸
 #define YX_DI_ERROR                    // 遥信硬件自检错误
 #define HISTORY_DB                     // 历史文件数据库
 #define DO_KOUT_CHECK                  // 开出反校
@@ -154,11 +155,12 @@
     #define FUNC_DRIVE        // 不停电传动功能
     #define FUNC_MORE_PREREAD // 支持遥调时多次读取
     #define FUNC_MORE_PRESET  // 支持遥调时多次预置,固化
-    #define YB_AUTO_SELECT	  // 在没配置硬压板的时自动选择软压板执行
+    #define YB_AUTO_SELECT    // 在没配置硬压板的时自动选择软压板执行
     #define IEC_QDS_HAVE
-    #define YK_FA_S_L_ENBLE 	        //分段联络遥控
-    #define DC_OLLECT_NOT_156US_LOOPC   //DC采样在非156us循环中使用
-	#define SW_FAIL_SINGLE_OUT		    //开关失灵
+    #define YK_FA_S_L_ENBLE           // 分段联络遥控
+    #define DC_OLLECT_NOT_156US_LOOPC // DC采样在非156us循环中使用
+    #define SW_FAIL_SINGLE_OUT        // 开关失灵
+    #define FUNC_CHZ_CHARGE_TIME      // 重合闸充电通用一个定值，不管几次重合闸
 
 #elif defined GD_AREA_ZHONGSHAN	//中山局要求
  	#ifdef __IEC61850_GOOSE_FUNC__

dtu/dtu_main_t536/app/main.c

@@ -154,7 +154,7 @@ int app_main(void *unused)
               "app_main_loop", (int)getpid(), (int)syscall(SYS_gettid));
 #endif
 
-#if (0) /* 打印信息测试函数 */
+#if (1) /* 打印信息测试函数 */
     dp_info_nt("最大定值个数 MAX_SET_NUMBER = %d", MAX_SET_NUMBER);
     dp_info_nt("装置参数 EQUIP_PARA_NUMBER = %d, PARA_NUM = %d", EQUIP_PARA_NUMBER, PARA_NUM);
     dp_info_nt("保护定值 SW_SET_NUMBER = %d, SW_SET_NUMBER = %d", SW_SET_NUMBER, SW_SET_NUMBER);
@@ -195,12 +195,9 @@ int app_main(void *unused)
     dp_err_nt_rt("CHZ_ALL_EN(0) = %d", CHZ_ALL_EN(0));
     dp_err_nt_rt("TYTQ_ALL_EN(0) = %d", TYTQ_ALL_EN(0));
     dp_err_nt_rt("JL_ALL_EN(0) = %d", JL_ALL_EN(0));
-    dp_err_nt_rt("pRunSet->dTBLValue[0] = %d", pRunSet->dTBLValue[0]);
-    dp_err_nt_rt("pRunSet->dYC_num = %d", pRunSet->dYC_num);
-    dp_err_nt_rt("toc[BH_GL1].dI = %d", pRunSet->tSwSet[0].toc[BH_GL1].dI);
-    dp_err_nt_rt("toc[BH_GL1].dT = %d", pRunSet->tSwSet[0].toc[BH_GL1].dT);
     dp_err_nt_rt("tRunPara.dTBatBegin = %d", tRunPara.dTBatBegin);
     dp_err_nt_rt("tRunPara.dTBatInterval = %d", tRunPara.dTBatInterval);
+    dp_err_nt_rt("pRunSet->tSwSet[0].d_chz_times = %d", pRunSet->tSwSet[0].d_chz_times);
 #endif
 
     {

dtu/dtu_main_t536/app/oc.c

@@ -521,7 +521,6 @@ void Pro_OC(int sw, u32 dStep, int oc, int soe_no)
     // 告警记录及出口
     if (poc->sta.bFlag.bGjEvent)
     {
-
         gl_soe_set_clr(1, sw, soeno + 1, pSet->dI, BH_WAVETIME_EN(pSet->dT)); // 大于150毫秒，出口也启动录波
         if (poc->sta.bFlag.bDzLed == false)
         {
@@ -627,7 +626,7 @@ void Pro_LX(int sw, u32 dStep, int oc, int soe_no)
             I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
             U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);
             soe_record_ev(soeno, 1, I0, U0, 0);
-            //			rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
+            // rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
         }
 
         if (soe_check(EV_LX_FAULT + sw * EV_SW_NUM) == false) // 零序总
@@ -1224,6 +1223,7 @@ int gl_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set, bool bfault)
         }
     }
     break;
+
     case 0:
     {
         if (soe_check(soe_no) == true)
@@ -1296,6 +1296,7 @@ int gz_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set)
         }
     }
     break;
+
     case 0:
     {
         if (soe_check(soe_no) == true)
@@ -1317,6 +1318,19 @@ int gz_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set)
     return 0;
 }
 
+/**
+ * @brief          计算二次谐波含量是否超过设定值
+ * @param[in/out]  {int} sw 开关号
+ * @param[in/out]  {int} index 电流索引
+ * @param[in/out]  {DWORD} xBcoe 谐波占比%
+ * @param[in/out]  {DWORD} bQD 使能计算
+ * @return         true 二次谐波含量超过设定值
+ * @return         false  二次谐波含量没有超过设定值
+ * @retval         none
+ * 
+ * @warning        none
+ * @note           none
+ */
 bool XBCalc(int sw, int index, DWORD xBcoe, bool bQD)
 {
     if (bQD)

dtu/dtu_main_t536/app/oc.h

@@ -25,12 +25,12 @@ typedef union UOCFLAG
     DWORD wfFlag;
     struct
     {
-        DWORD bIaQD : 1; // 启动
-        DWORD bIbQD : 1; // 启动
-        DWORD bIcQD : 1; // 启动
-        DWORD bIaxb : 1; // 启动
-        DWORD bIbxb : 1; // 启动
-        DWORD bIcxb : 1; // 启动
+        DWORD bIaQD : 1; // A相过流启动
+        DWORD bIbQD : 1; // B相过流启动
+        DWORD bIcQD : 1; // C相过流启动
+        DWORD bIaxb : 1; // A相谐波闭锁启动
+        DWORD bIbxb : 1; // B相谐波闭锁启动
+        DWORD bIcxb : 1; // C相谐波闭锁启动
 
         DWORD bQD : 1;      // 启动
         DWORD bGj : 1;      // 告警
@@ -39,14 +39,14 @@ typedef union UOCFLAG
         DWORD bBSCH : 1;    // 闭锁重合
         DWORD bCYL : 1;     // 曾有流
         DWORD bTripBak : 1; // 跳闸动作备份
-        DWORD bTzhold : 1;
-        DWORD bJSBC : 1;   // 加速保持
-        DWORD bDzLed : 1;  // 动作灯
-        DWORD bGjLed : 1;  // 告警灯
-        DWORD bQDWave : 1; // 幅值启动时，启动录波标志
-        DWORD bddyQD : 1;  // 低电压启动
-        DWORD bGjEvent : 1;
-        DWORD bTzEvent : 1; //
+        DWORD bTzhold : 1;  // 暂时没使用
+        DWORD bJSBC : 1;    // 加速保持
+        DWORD bDzLed : 1;   // 动作灯
+        DWORD bGjLed : 1;   // 告警灯
+        DWORD bQDWave : 1;  // 幅值启动时，启动录波标志
+        DWORD bddyQD : 1;   // 低电压启动
+        DWORD bGjEvent : 1; // 告警记录及led
+        DWORD bTzEvent : 1; // 跳闸记录及led
     } bFlag;
 } UOCFLAG;
 
@@ -79,12 +79,12 @@ enum
 
 typedef struct TOC_T
 {
-    UOCFLAG sta;       // 动作标志字
-    TIMERELAY tFz25ms; // 幅值启动25ms
-    TIMERELAY tQDTime; // 时间继电器
-    TIMERELAY tXBTime; // dXB_T;				// 谐波动作时间
-    TIMERELAY tXBQD25ms;
-    TIMERELAY tQD25ms; // 启动25ms,防干扰时间继电器,用于速断和零序加速，防止误出口
+    UOCFLAG sta;         // 动作标志字
+    TIMERELAY tFz25ms;   // 幅值启动25ms
+    TIMERELAY tQDTime;   // 时间继电器
+    TIMERELAY tXBTime;   // 谐波动作时间
+    TIMERELAY tXBQD25ms; // 谐波启动25ms
+    TIMERELAY tQD25ms;   // 启动25ms,防干扰时间继电器,用于速断和零序加速，防止误出口
 #ifdef YX_RESET_TIME
     TIMERELAY tGjEvRstTime; // 故障遥信保持时间
     TIMERELAY tTzEvRstTime; // 告警遥信保持时间

dtu/dtu_main_t536/app/protect.c

@@ -440,10 +440,12 @@ int protect_polling(void)
             case CXLC_BHCL:
                 _protect_gzcl_process();
                 break;
+
             // 整组复归
             case CXLC_ZZFG:
                 _protect_zzfg();
                 break;
+
             default:
                 watchdog_reset_cpu(51);
                 break;
@@ -546,7 +548,7 @@ int protect_tbl_qd(void)
                 if (wIQdCnt[sw][i] >= TBLQDDSMK)
                 {
                     pR->uBHQD.bFlag.bTBQD = true;
-                    dp_info_nt_rt("protect_tbl_qd:i = %d, daaa = %d, dTBLValue = %d. sw = %d", i, daaa, pRunSet->dTBLValue[sw], sw);
+                    dp_info_nt_rt("开关%d突变量启动:i = %d, daaa = %d, dTBLValue = %d.", sw, i, daaa, pRunSet->dTBLValue[sw]);
                     break;
                 }
             }
@@ -894,7 +896,7 @@ static int _protect_amp_qd(u32 dStep)
         {
             rt_stat_in(&pR->fz_stat, ustimer_get_duration(pR->us_fz) / USTIMER_US);
         }
-        dp_info_nt_rt("开关%d辐值启动(bFZJS = %d)\r\n", sw, bFZJS);
+        dp_info_nt_rt("开关%d辐值启动(bFZJS = %d)", sw, bFZJS);
     }
     return 0;
 }
@@ -2126,92 +2128,6 @@ static bool _protect_check_fault(int sw)
     return false;
 }
 
-/*------------------------------ 测试函数 -------------------------------------
-一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
-进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
-*/
-int protect_stat_reset(void)
-{
-    int sw;
-
-    for (sw = 0; sw < SWITCH_NUM_MAX; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-
-        rt_stat_init(&pR->tbl_stat, "突变量");
-        rt_stat_init(&pR->tbldz_stat, "突变量动作");
-        rt_stat_init(&pR->tblzzdz_stat, "突变量整组动作");
-        rt_stat_init(&pR->fz_stat, "幅值");
-        rt_stat_init(&pR->fzdz_stat, "幅值动作");
-        rt_stat_init(&pR->fzzzdz_stat, "幅值整组动作");
-    }
-
-    return 0;
-}
-
-int protect_printf_process(void)
-{
-    int sw;
-
-    rt_printf("[突变量启动耗时(us):]\r\n");
-    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
-    for (sw = 0; sw < g_sw_num; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-        rt_printf("%d\t", sw);
-        rt_stat_printf(&pR->tbl_stat);
-    }
-
-    rt_printf("\r\n[突变量动作耗时(us):]\r\n");
-    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
-    for (sw = 0; sw < g_sw_num; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-        rt_printf("%d\t", sw);
-        rt_stat_printf(&pR->tbldz_stat);
-    }
-
-    rt_printf("\r\n[突变量整组动作耗时(us):]\r\n");
-    rt_printf("[需用分闸继电器输入分位开入,防抖为0s]\r\n");
-    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
-    for (sw = 0; sw < g_sw_num; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-        rt_printf("%d\t", sw);
-        rt_stat_printf(&pR->tblzzdz_stat);
-    }
-
-    rt_printf("\r\n[幅值启动耗时(us):]\r\n");
-    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
-    for (sw = 0; sw < g_sw_num; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-        rt_printf("%d\t", sw);
-        rt_stat_printf(&pR->fz_stat);
-    }
-
-    rt_printf("\r\n[幅值动作耗时(us):]\r\n");
-    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
-    for (sw = 0; sw < g_sw_num; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-        rt_printf("%d\t", sw);
-        rt_stat_printf(&pR->fzdz_stat);
-    }
-
-    rt_printf("\r\n[幅值整组动作耗时(us):]\r\n");
-    rt_printf("[需用分闸继电器输入分位开入,防抖为0s]\r\n");
-    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
-    for (sw = 0; sw < g_sw_num; sw++)
-    {
-        TRELAY_T *pR = &g_tRelay[sw];
-        rt_printf("%d\t", sw);
-        rt_stat_printf(&pR->fzzzdz_stat);
-    }
-
-    return 0;
-}
-
 #ifdef YB_AUTO_SELECT
 bool fa_yb_enable(int sw)
 {
@@ -2312,5 +2228,91 @@ bool fa_fun_true(int sw)
 }
 #endif
 
+/*------------------------------ 测试函数 -------------------------------------
+一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
+进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
+*/
+int protect_stat_reset(void)
+{
+    int sw;
+
+    for (sw = 0; sw < SWITCH_NUM_MAX; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+
+        rt_stat_init(&pR->tbl_stat, "突变量");
+        rt_stat_init(&pR->tbldz_stat, "突变量动作");
+        rt_stat_init(&pR->tblzzdz_stat, "突变量整组动作");
+        rt_stat_init(&pR->fz_stat, "幅值");
+        rt_stat_init(&pR->fzdz_stat, "幅值动作");
+        rt_stat_init(&pR->fzzzdz_stat, "幅值整组动作");
+    }
+
+    return 0;
+}
+
+int protect_printf_process(void)
+{
+    int sw;
+
+    rt_printf("[突变量启动耗时(us):]\r\n");
+    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
+    for (sw = 0; sw < g_sw_num; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+        rt_printf("%d\t", sw);
+        rt_stat_printf(&pR->tbl_stat);
+    }
+
+    rt_printf("\r\n[突变量动作耗时(us):]\r\n");
+    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
+    for (sw = 0; sw < g_sw_num; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+        rt_printf("%d\t", sw);
+        rt_stat_printf(&pR->tbldz_stat);
+    }
+
+    rt_printf("\r\n[突变量整组动作耗时(us):]\r\n");
+    rt_printf("[需用分闸继电器输入分位开入,防抖为0s]\r\n");
+    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
+    for (sw = 0; sw < g_sw_num; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+        rt_printf("%d\t", sw);
+        rt_stat_printf(&pR->tblzzdz_stat);
+    }
+
+    rt_printf("\r\n[幅值启动耗时(us):]\r\n");
+    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
+    for (sw = 0; sw < g_sw_num; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+        rt_printf("%d\t", sw);
+        rt_stat_printf(&pR->fz_stat);
+    }
+
+    rt_printf("\r\n[幅值动作耗时(us):]\r\n");
+    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
+    for (sw = 0; sw < g_sw_num; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+        rt_printf("%d\t", sw);
+        rt_stat_printf(&pR->fzdz_stat);
+    }
+
+    rt_printf("\r\n[幅值整组动作耗时(us):]\r\n");
+    rt_printf("[需用分闸继电器输入分位开入,防抖为0s]\r\n");
+    rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
+    for (sw = 0; sw < g_sw_num; sw++)
+    {
+        TRELAY_T *pR = &g_tRelay[sw];
+        rt_printf("%d\t", sw);
+        rt_stat_printf(&pR->fzzzdz_stat);
+    }
+
+    return 0;
+}
+
 /*------------------------------ 文件结束 -------------------------------------
  */

dtu/dtu_main_t536/app/protect.h

@@ -172,11 +172,11 @@ typedef struct URMTSW
     bool bSwTz; // 开关本体分闸
 #endif
     bool bTQHz; // 同期合闸标志
-    bool bYHExecute_fa;
-    bool bYTExecute_fa;
+    bool bYHExecute_fa; // FA遥控合闸标志
+    bool bYTExecute_fa; // FA遥控分闸标志
     bool bHandHz_fa;    // 手动合闸
     bool bHandTz_fa;    // 手动分闸
-    bool bYH_fajs_flag; //	遥控合闸解锁标志
+    bool bYH_fajs_flag; // 遥控合闸解锁标志
     bool bTz_Doing;     // 合闸
     bool bHz_Doing;     // 分闸
 #ifdef FUNC_REBOOT_BS_HA_JS_3S
@@ -204,7 +204,7 @@ typedef struct TRELAY_T //
 
     bool bARSTFLT; // 开关自动复归事故总202004
 
-    TFDL_T tFdl[6];
+    TFDL_T tFdl[6];         // 非电量
     TOC_T tOC[BHOC_NUMBER]; // 过流保护相关
     TCH_T tCHZ;             // 重合闸
 
@@ -229,13 +229,13 @@ typedef struct TRELAY_T //
 
     TGOC_T tgoc; // 方向过流goose
     TSWST tSWST; // 开关运行状态识别
-    RUN_STU_SW run_stu;
+    RUN_STU_SW run_stu; // 位置、功能状态
 
-    UBHQD uBHQD;   // 保护启动标志字
-    UBHDZ uBHDZ;   // 保护动作标志字
-    URMTSW uRmtSW; // 遥控分、合闸
-    THZBS_T thzbs;
-    TIMERELAY tMb_yuk_time;
+    UBHQD uBHQD;             // 保护启动标志字
+    UBHDZ uBHDZ;             // 保护动作标志字
+    URMTSW uRmtSW;           // 遥控分、合闸
+    THZBS_T thzbs;           // 连续分闸闭锁合闸
+    TIMERELAY tMb_yuk_time;  // 面板预控
     TIMERELAY tTZZFG_5S0ms;  // 无故障延时5s
     TIMERELAY tTrip_BHT40MS; // 跳闸脉冲计时器,跳闸开出最短时间40MS
     TIMERELAY tTripfail_2s;  // 跳闸脉冲计时器,跳闸开出最短时间100MS
@@ -254,7 +254,7 @@ typedef struct TRELAY_T //
 #ifdef FUN_JDXX
     JDXX_DEF tJD; // 小电流接地
 #endif
-    YC_REFRESH_EN bYcRefresh;
+    YC_REFRESH_EN bYcRefresh; // 用于故障启动记录动作值标志
 } TRELAY_T;
 
 extern TRELAY_T g_tRelay[];

dtu/dtu_main_t536/app/reclose.c

@@ -53,6 +53,7 @@ void AutoReclose(int sw, DWORD dStep)
     AR_Reset(sw, dStep);    // 重合闸复归
     return;
 }
+
 void ARTQ_DataSet(int sw)
 {
 
@@ -137,10 +138,17 @@ void ARTQ_DataSet(int sw)
         if (!pSW->sta.bFlag.bTQMZ && (print_flag++ % (1 * 200)) == 0) // 1S
         {
             if ((!bDa) && (pSet->bTT_chz_tq))
-                rt_printf("角差不满足 pt1=%d pt2=%d ang2=%d      角差=%d 相位补偿后角差=%d        dz=%d pt2vol=%d\r\n", (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);
+                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))
-                rt_printf("压差不满足\r\n");
+                dp_info_nt_rt("压差不满足");
 #endif
         }
     }
@@ -233,6 +241,7 @@ static void AR_Recharge(int sw, DWORD dStep)
     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); // 有零序电压且跳位
@@ -253,7 +262,7 @@ static void AR_Recharge(int sw, DWORD dStep)
             || pR->uRmtSW.bYTExecute                                   // 遥控跳闸
             || pR->uBHDZ.bFlag.bTZSB                                   // 跳闸失败
             || pR->tSWST.uSWST.bFlag.bTWYL                             // 跳位有流
-            || (pR->tSWST.uSWST.bFlag.bWCN && (!pSW->sta.bFlag.bCHQD)) // 弹簧未储能告警 正超广州样机重合闸启动后，收到弹簧未储能信号，重合闸不放电
+            || (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断线重合闸放电
@@ -275,6 +284,7 @@ static void AR_Recharge(int sw, DWORD dStep)
                            || gb_drive.b_bh_reclose
 #endif
         ;
+
     // 放电清开放时间
     if (pSW->sta.bFlag.bFDBZ)
     {
@@ -433,7 +443,7 @@ static void AR_Start(int sw, DWORD dStep)
     {
         pSW->sta.wfFlag = 0;
         pR->tCHZ.wAR_ActTimes = 0;
-        rt_printf("重合闸开放时间到:整组复归!\r\n");
+        dp_info_nt_rt("重合闸开放时间到:整组复归!");
         ResetTR(&pR->tCHZ.tTCHJD_ARDelay); // 延时
         ResetTR(&pR->tCHZ.tTCHJD_HJS);     // 后加速延时
         ResetTR(&pSW->tTCHFAIL_TW);        // 重合失败
@@ -580,6 +590,13 @@ static void AR_Logic(int sw, DWORD dStep)
             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;			//每次重合出口后，清重合复归标志  修改时注意，此处需对标志字特殊处理
 
@@ -688,15 +705,18 @@ static void AR_Reset(int sw, DWORD dStep)
     }
 
     // 复归
-    //  重合出口后，经过重合闸确认时间，无保护动作，即复归，完成该次重合过程202004
-    //  如果在确认时间内，重合闭锁时间外，有保护动作，即进入下一计数重合
-    pSW->sta.bFlag.bCK = ((!pR->uBHDZ.bFlag.bBHT) && (pSW->sta.bFlag.bCHCK || pSW->sta.bFlag.bCK)); // 重合出口及自保持
+    // 重合出口后，经过重合闸确认时间，无保护动作，即复归，完成该次重合过程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);
@@ -705,6 +725,15 @@ static void AR_Reset(int sw, DWORD dStep)
         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                          // 闭锁

dtu/dtu_main_t536/app/reclose.h

@@ -31,7 +31,7 @@ typedef union UCHFLAG
         DWORD bCHBS : 1;   // 重合闸闭锁
         DWORD bCK : 1;     // 放电条件1
         DWORD bCHZLed : 1; // 动作灯
-        DWORD bEvent : 1;
+        DWORD bEvent : 1;  // 事件记录
 
         DWORD bMxYY : 1; // 母线有压
         DWORD bMxWY : 1; // 母线无压

dtu/dtu_main_t536/app/set.c

@@ -860,14 +860,15 @@ const TSETTABLE tSwSetTable[] = // min 	 max 		     default
     {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x501A, FLOAT_R, "过流Ⅱ段时间"},
     {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "过流Ⅲ段定值"},
     {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "过流Ⅲ段时间"},
-    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x501B, FLOAT_R, "零序过流Ⅰ段定值"},
-    {SETTYPE_F,     SET_S,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x501C, FLOAT_R, "零序过流Ⅰ段时间"},
-    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x501D, FLOAT_R, "零序过流Ⅱ段定值"},
-    {SETTYPE_F,     SET_S,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x501E, FLOAT_R, "零序过流Ⅱ段时间"},
-    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "零序过流Ⅲ段定值"},
-    {SETTYPE_F,     SET_S,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "零序过流Ⅲ段时间"},
+    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x501B, FLOAT_R, "零序过流Ⅰ段定值"},
+    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x501C, FLOAT_R, "零序过流Ⅰ段时间"},
+    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x501D, FLOAT_R, "零序过流Ⅱ段定值"},
+    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x501E, FLOAT_R, "零序过流Ⅱ段时间"},
+    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "零序过流Ⅲ段定值"},
+    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "零序过流Ⅲ段时间"},
     {SETTYPE_F,     SET_U,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "零序过电压保护定值"},
     {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "零序过电压保护时间"},
+    {SETTYPE_F,     SET_S,      0,      600.0,              600.0,  0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "加速段保护开放时间"},
     {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速过流保护定值"},
     {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速过流保护时间"},
     {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速零序电流保护定值"},
@@ -901,7 +902,7 @@ const TSETTABLE tSwSetTable[] = // min 	 max 		     default
     {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "三次重合闸时间"},
 #endif
 #ifdef DISP_CHZOKCHR_2_SW
-    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "重合充电时间"},
+    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "tou多次重合充电时间"},
     {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "重合闸确认时间"},
 #endif
     {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_CHZDZ,        0x501F, FLOAT_R, "大电流闭锁重合闸定值"},
@@ -2292,8 +2293,6 @@ void check_shmdata_change(void)
     static uint8_t suc_freq_track = 0xff;
     struct t_shmdata_cvalue t_cvale = {0};
 
-    printf("check_shmdata_change\r\n");
-
     if (suc_freq_track != pRunSet->bTT_FREQ)
     {
         t_cvale.uc_freq_track = pRunSet->bTT_FREQ;
@@ -2472,7 +2471,7 @@ bool MakeRunSet(bool bFirst)
 
     // 瞬压检出
     ptSet->bTT_SY_Board = ((WORD)psetbuf[CSTSET_SYBOARD_TT].ff == 1) ? true : false; // 零压闭锁零流
-                                                                                     // ptSet->dT_XCY =	GetSetTIME(0.05);  //残压检出时间默认50毫秒
+    // ptSet->dT_XCY =	GetSetTIME(0.05);  //残压检出时间默认50毫秒
 #ifdef GD_AREA_ECZD_2020                                                             // 25V/30ms
     ptSet->dT_XCY = GetSetTIME(0.02);                                                // 残压检出时间默认20毫秒
 #else
@@ -2817,7 +2816,7 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值
 
             poc = &ptSet->tSwSet[sw].toc[BH_GL2]; // 过流2段
-            poc->bTz = (((WORD)psetbuf[SET_GL2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
+            poc->bTz = (((WORD)psetbuf[SET_GL2_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
             poc->bGj = (((WORD)psetbuf[SET_GL2_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true);
             poc->bDir = (((WORD)psetbuf[SET_GL2_DIR + sw * SW_SET_NUMBER].ff == 1) ? true : false);
             poc->dT = GetSetTIME(psetbuf[SET_GL2_T + sw * SW_SET_NUMBER].ff);
@@ -2825,7 +2824,7 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值
 
             poc = &ptSet->tSwSet[sw].toc[BH_GL3]; // 过流3段
-            poc->bTz = (((WORD)psetbuf[SET_GL3_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
+            poc->bTz = (((WORD)psetbuf[SET_GL3_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
             poc->bGj = (((WORD)psetbuf[SET_GL3_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true);
             poc->bDir = (((WORD)psetbuf[SET_GL3_DIR + sw * SW_SET_NUMBER].ff == 1) ? true : false);
             poc->dT = GetSetTIME(psetbuf[SET_GL3_T + sw * SW_SET_NUMBER].ff);
@@ -2833,7 +2832,7 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值
 
             poc = &ptSet->tSwSet[sw].toc[BH_LX1]; // 零序1段
-            poc->bTz = (((WORD)psetbuf[SET_LX1_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
+            poc->bTz = (((WORD)psetbuf[SET_LX1_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
             poc->bGj = (((WORD)psetbuf[SET_LX1_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true);
             poc->bDir = false;
             poc->dT = GetSetTIME(psetbuf[SET_LX1_T + sw * SW_SET_NUMBER].ff);
@@ -2841,7 +2840,7 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100);
 
             poc = &ptSet->tSwSet[sw].toc[BH_LX2]; // 零序2段
-            poc->bTz = (((WORD)psetbuf[SET_LX2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
+            poc->bTz = (((WORD)psetbuf[SET_LX2_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
             poc->bGj = (((WORD)psetbuf[SET_LX2_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true);
             poc->bDir = false;
             poc->dT = GetSetTIME(psetbuf[SET_LX2_T + sw * SW_SET_NUMBER].ff);
@@ -2849,7 +2848,7 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100);
 
             poc = &ptSet->tSwSet[sw].toc[BH_LX3]; // 零序3段
-            poc->bTz = (((WORD)psetbuf[SET_LX3_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
+            poc->bTz = (((WORD)psetbuf[SET_LX3_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
             poc->bGj = (((WORD)psetbuf[SET_LX3_TT + sw * SW_SET_NUMBER].ff == 0) ? true : false);
             poc->bDir = false;
             poc->dT = GetSetTIME(psetbuf[SET_LX3_T + sw * SW_SET_NUMBER].ff);
@@ -2872,6 +2871,7 @@ bool MakeRunSet(bool bFirst)
             else
                 poc->dI = GetSetSQR(psetbuf[SET_GL1_I + sw * SW_SET_NUMBER].ff, fKI);
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100);
+            ptSet->tSwSet[sw].dT_SpeedUp_Open = GetSetTIME(psetbuf[SET_JSOPEN_T + sw * SW_SET_NUMBER].ff);; // 加速段保护开放时间
 
             poc = &ptSet->tSwSet[sw].toc[BH_LXJS]; // 零序加速段
             poc->bTz = (((WORD)psetbuf[SET_GLJS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
@@ -2917,6 +2917,15 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值
         }
 
+        // 零序过电压投入
+        {
+            ptSet->tSwSet[sw].bTT_3U0Tz = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
+            ptSet->tSwSet[sw].bTT_3U0Gj = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true);
+            ptSet->tSwSet[sw].dBHOverU0 = GetSetSQR(psetbuf[SET_U0_U + sw * SW_SET_NUMBER].ff, fKU[PUB_AC_U01]);
+            ptSet->tSwSet[sw].dBHOverU0_fh = _Mul_Div_U(ptSet->tSwSet[sw].dBHOverU0, 96, 100); // 0.96=0.98*0.98
+            ptSet->tSwSet[sw].dBHTOverU0 = GetSetTIME(psetbuf[SET_U0_T + sw * SW_SET_NUMBER].ff);
+        }
+
         // 智能分布式定值
         {
             GOC_SET *poc = &ptSet->tSwSet[sw].tGocSet;
@@ -2960,8 +2969,8 @@ bool MakeRunSet(bool bFirst)
 
             poc->bTT_ll = (((WORD)psetbuf[SET_GOOSE_LL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 联络合闸
             poc->dTll = GetSetTIME(psetbuf[SET_GOOSET_LL_T + sw * SW_SET_NUMBER].ff);                     // 联络合闸时间
-                                                                                                          // poc->bTT_DIR = (((WORD)psetbuf[SET_GOOSET_DIR_TT+sw*SW_SET_NUMBER ].ff == 1 )?true:false); // 合环运行
-                                                                                                          // poc->bTT_mxTfz = (((WORD)psetbuf[SET_GOOSET_MXTFZ_TT+sw*SW_SET_NUMBER ].ff == 1 )?true:false); // 母线故障跳分支
+            // poc->bTT_DIR = (((WORD)psetbuf[SET_GOOSET_DIR_TT+sw*SW_SET_NUMBER ].ff == 1 )?true:false); // 合环运行
+            // poc->bTT_mxTfz = (((WORD)psetbuf[SET_GOOSET_MXTFZ_TT+sw*SW_SET_NUMBER ].ff == 1 )?true:false); // 母线故障跳分支
 
 #else
             poc->bTT_gooseFA = (((WORD)psetbuf[SET_GOOSE_FA_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 智能分布式投退
@@ -3034,12 +3043,18 @@ bool MakeRunSet(bool bFirst)
 #ifdef DISP_CHZOKCHR_2_SW
             ptSet->tSwSet[sw].dT_chz_cd = GetSetTIME(psetbuf[SET_CHZCD_2 + sw * SW_SET_NUMBER].ff);
             ptSet->tSwSet[sw].dT_chz_ok = GetSetTIME(psetbuf[SET_CHZ_OK + sw * SW_SET_NUMBER].ff);
-#else
+#else /* DISP_CHZOKCHR_2_SW */
+#ifdef FUNC_CHZ_CHARGE_TIME
             ptSet->tSwSet[sw].dT_chz_cd = GetSetTIME(psetbuf[SET_CHZCD + sw * SW_SET_NUMBER].ff); // 重合闸充电时间
-#endif
+#else /* FUNC_CHZ_CHARGE_TIME */
+            ptSet->tSwSet[sw].dT_chz_cd = (bch2 || bch3) ? ptSet->dT_chzcd_2 : T_1s * 15; // 投一次重合闸，充电时间15秒，投二次重合闸，充电180秒
+#endif /* FUNC_CHZ_CHARGE_TIME */
+#endif /* DISP_CHZOKCHR_2_SW */
 
             ptSet->tSwSet[sw].dT_chz_bs = GetSetTIME(psetbuf[SET_CHBS_T + sw * SW_SET_NUMBER].ff);
             ptSet->tSwSet[sw].dT_chz_ok = (bch2 || bch3) ? ptSet->tSwSet[sw].dT_chz_ok : T_1s * 15; // 只投一次重合闸的时候，重合闸确认时间强制为15S 2020-7-25
+            dp_info_nt_rt("ptSet->tSwSet[sw].dT_chz_cd = %d", ptSet->tSwSet[sw].dT_chz_cd);
+            dp_info_nt_rt("ptSet->tSwSet[sw].dT_chz_ok = %d", ptSet->tSwSet[sw].dT_chz_ok);
             if (bch3)
                 ptSet->tSwSet[sw].d_chz_times = 3;
             else if (bch2)
@@ -3196,7 +3211,7 @@ bool MakeRunSet(bool bFirst)
             ptSet->tSwSet[sw].bTT_fa_cybs = ((DWORD)psetbuf[SET_CYBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false;
             ptSet->tSwSet[sw].bTT_fa_xbbs = ((DWORD)psetbuf[SET_FA_XBBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false;
             ptSet->tSwSet[sw].bTT_fa_U0Tz = ((DWORD)psetbuf[SET_U0TZ_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false;
-            ptSet->tSwSet[sw].bTT_fa_U0Gj = ((DWORD)psetbuf[SET_U0TZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false;
+            ptSet->tSwSet[sw].bTT_fa_U0Gj = ((DWORD)psetbuf[SET_U0TZ_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true;
             ptSet->tSwSet[sw].bTT_fa_ptdx = ((DWORD)psetbuf[SET_FA_PTDX + sw * SW_SET_NUMBER].ff == 1) ? true : false;
             ptSet->tSwSet[sw].bTT_hzbs = (((DWORD)psetbuf[SET_HZBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
             ptSet->tSwSet[sw].dU_fa_YY = GetSetSQR(psetbuf[SET_FA_YY_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 0.4 倍的额定值
@@ -3350,25 +3365,6 @@ bool MakeRunSet(bool bFirst)
             poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值
         }
 
-        // 零序过电压投入
-        {
-#if defined GD_AREA_ECZD_2020 // be modified by Jack.Liu on 2020/07/23--14:4:47
-#if defined GD_AREA_ECZD_YUNFU_2021_2021
-            ptSet->tSwSet[sw].bTT_3U0Tz = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
-            ptSet->tSwSet[sw].bTT_3U0Gj = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
-#else
-            ptSet->tSwSet[sw].bTT_3U0Tz = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
-            ptSet->tSwSet[sw].bTT_3U0Gj = 0;
-#endif
-#else
-            ptSet->tSwSet[sw].bTT_3U0Tz = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false);
-            ptSet->tSwSet[sw].bTT_3U0Gj = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false);
-#endif
-            ptSet->tSwSet[sw].dBHOverU0 = GetSetSQR(psetbuf[SET_U0_U + sw * SW_SET_NUMBER].ff, fKU[PUB_AC_U01]);
-            ptSet->tSwSet[sw].dBHOverU0_fh = _Mul_Div_U(ptSet->tSwSet[sw].dBHOverU0, 96, 100); // 0.96=0.98*0.98
-            ptSet->tSwSet[sw].dBHTOverU0 = GetSetTIME(psetbuf[SET_U0_T + sw * SW_SET_NUMBER].ff);
-        }
-
 #ifdef GD_AREA_ZHONGSHAN_2020                                                   // 中山智能分布式手合故障处理
         ptSet->tSwSet[sw].tGocSet.tOc[FAG_GL1] = ptSet->tSwSet[sw].toc[FA_GL];  // 使用相间故障1段定值
         ptSet->tSwSet[sw].tGocSet.tOc[FAG_GL2] = ptSet->tSwSet[sw].toc[FA_GL2]; // 使用相间故障2段定值

dtu/dtu_main_t536/app/set.h

@@ -385,6 +385,7 @@ enum
     SET_LX3_T,      // 零序过流Ⅲ段时间
     SET_U0_U,       // 零序过电压保护定值
     SET_U0_T,       // 零序过电压保护时间
+    SET_JSOPEN_T,   // 加速段保护开放时间
     SET_GLJS_I,     // 后加速过流保护定值
     SET_GLJS_T,     // 后加速过流保护时间
     SET_LXJS_I,     // 后加速零序电流保护定值
@@ -418,7 +419,7 @@ enum
     SET_CH_T3, // 三次重合闸时间
 #endif
 #ifdef DISP_CHZOKCHR_2_SW
-    SET_CHZCD_2, // 重合充电时间 二次
+    SET_CHZCD_2, // 投多次重合充电时间
     SET_CHZ_OK,  // 重合闸确认时间
 #endif
     SET_CH_DLBS_I, // 大电流闭锁重合闸定值
@@ -1199,13 +1200,14 @@ typedef struct TSETSW
 
     OC_SET toc[BHOC_NUMBER]; // 过量保护
     GOC_SET tGocSet;         // goose 过流
+    DWORD dT_SpeedUp_Open; // 后加速开放时间
 
     DWORD dT_ch_gl_tt; // 过流重合默认投入
     DWORD dT_ch_jd_tt; // 接地重合默认投入
 
     DWORD dT_chz[MAX_AR_TIMES]; // 重合时间
     DWORD dT_chz_bs;            // 重合闸闭锁时间
-    DWORD dT_chz_ok;            // 重合闸确认时间
+    DWORD dT_chz_ok;            // 重合闸确认时间 用于判断重合闸闭锁
     DWORD dT_chz_cd;            // 重合闸充电时间，一次重合闸15秒，二次重合闸180秒
     DWORD dT_chz_Topen;         // 重合闸开放时间
     DWORD d_chz_times;          // 重合闸次数
@@ -1329,10 +1331,10 @@ typedef struct TSETSW
     DWORD dT_XL;    // X时间
     DWORD dT_Z;     // 失压 时间
 
-    DWORD dT_fa_bsTz; // 过流闭锁失压
-    DWORD dT_fa_ocing;
-    DWORD dT_fa_lxing;
-    DWORD d_fa_xbcoe; // 谐波系数
+    DWORD dT_fa_bsTz;  // 闭锁分闸复归时间
+    DWORD dT_fa_ocing; // 相间故障电流II段时间
+    DWORD dT_fa_lxing; // 接地故障时间定值
+    DWORD d_fa_xbcoe;  // 谐波系数
 
     DWORD dU_OverU0; // 合后零压,固定为额定值20%
     DWORD dU_OverU0_fh;
@@ -1530,7 +1532,7 @@ typedef struct TSET
     DWORD dT_ZZFG;                   // 整组复归时间
     DWORD dT_TZSB;                   // 跳闸失败时间
     DWORD dT_HZSB;                   // 合闸失败时间
-    DWORD dT_chzcd_2;                // 二次充电时间
+    DWORD dT_chzcd_2;                // 投多次重合充电时间
     bool bTT_U0BS;                   // 零压闭锁零流
     bool bTT_DDYBS;                  // 低电压闭锁
     DWORD dU_U0BS;                   // 零压闭锁零流定值

dtu/dtu_main_t536/app/timer.c

@@ -147,7 +147,6 @@ void ResetTR(TIMERELAY *pTimeRelay)
 ***************************************************************************/
 void RunTR(TIMERELAY *pTimeRelay, bool boolInput, DWORD dTime)
 {
-
     if (!pTimeRelay->boolTrip) // 时间继电器延时后输出没动作
     {
         if (boolInput) // 输入启动状态