修改 : 南网定值；

README.md

@@ -42,4 +42,7 @@
 01. 修改: 修改系统时钟获取API。
 
 # 202512(08-14)
-01. 修改 : 网口的个数和对应的定值；
+01. 修改 : 网口的个数和对应的定值；
+   
+# 202512(15-21)
+01. 修改 : 南网定值；

app_public/xdljd/jdxx.c

@@ -119,7 +119,7 @@ void  jdxx_qd_rst(int sw)  //
 	ResetTR(&pR->tJD.tJDXXTripTime);
 	ResetTR(&pR->tJD.tJDXXAlarmTime);
 	//soe
-	pro_rst_event(sw,EV_JDXX_QD);			 
+	pro_rst_event(sw,EV_LX_XDL_QD);			 
 	pro_rst_event(sw,EV_JDXX_JWGZ);
   #ifdef FUN_JDXX_JXJD
 	pro_rst_event(sw,EV_JDXX_SWIN_GJ);	
@@ -1068,9 +1068,9 @@ void jdxx_qd(int sw)
 					pR->tJD.tc_result=1;	//Æô¶¯
 					pR->tJD.adPoints=0;
 					pR->tJD.jd_step=JD_STEP_SSFAULT;
-					if(soe_check(EV_JDXX_QD+sw*EV_SW_NUM)==false)
+					if(soe_check(EV_LX_XDL_QD+sw*EV_SW_NUM)==false)
 					{
-						soe_record_ev( EV_JDXX_QD+sw*EV_SW_NUM,1, 0,0,0 ); 
+						soe_record_ev( EV_LX_XDL_QD+sw*EV_SW_NUM,1, 0,0,0 ); 
 					}	
 
 				#ifdef XDL_PRINT
@@ -1095,9 +1095,9 @@ void jdxx_qd(int sw)
 					{
 						pR->tJD.adPoints=0;
 						pR->tJD.jd_step=JD_STEP_SSFAULT;
-						if(soe_check(EV_JDXX_QD+sw*EV_SW_NUM)==false)
+						if(soe_check(EV_LX_XDL_QD+sw*EV_SW_NUM)==false)
 						{
-							soe_record_ev( EV_JDXX_QD+sw*EV_SW_NUM,1, 0,0,0 ); 
+							soe_record_ev( EV_LX_XDL_QD+sw*EV_SW_NUM,1, 0,0,0 ); 
 						}	
 
 					#ifdef XDL_PRINT
@@ -1804,7 +1804,7 @@ void jdxx_pro(int sw,DWORD  dStep)  //
 	//}
 	
 	//U01¹ÊÕÏ´¦Àí
-	soeno = EV_JDXX_U01GJ+sw*EV_SW_NUM;
+	soeno = EV_XDL_U0GJ1+sw*EV_SW_NUM;
 	if(pR->tJD.tJDXXU01Time.boolTrip) 
 	{
 			
@@ -1859,7 +1859,7 @@ void jdxx_pro(int sw,DWORD  dStep)  //
 		}
 	} 
 	//U02
-	soeno = EV_JDXX_U02GJ+sw*EV_SW_NUM;
+	soeno = EV_XDL_U0GJ2+sw*EV_SW_NUM;
 	if(pR->tJD.tJDXXU02Time.boolTrip) 
 	{
 		

dtu/dtu_main_t536/app/Appconfig.c

@@ -139,214 +139,178 @@ const SOE_DEF tAllSOE[]=
 /*    代码         类型          参数1    参数2    参数3        名称            */
 /*保护专用事件*/
 	// 开关事件
-	{0x04,		{0,			0,					0},				"保护动作总"},
-	{0x04,		{0,			0,					0},				"故障总"},
-	{0x04,		{0,			0,					0},				"短路故障"},
-	{0x04,		{0,			0,					0},				"接地故障"},
-  	{0x14,		{EV_PARA_Ia,	0,					0},         "A相短路故障"},
-  	{0x14,		{EV_PARA_Ib,	0,					0},         "B相短路故障"},
- 	{0x14,		{EV_PARA_Ic,	0,					0},         "C相短路故障"},
-	{0x14,		{EV_PARA_Ia,	EV_PARA_Ib,			0},         "AB相短路故障"},
-  	{0x14,		{EV_PARA_Ib,	EV_PARA_Ic,			0},         "BC相短路故障"},
- 	{0x14,		{EV_PARA_Ia,	EV_PARA_Ic,			0},         "AC相短路故障"},
- 	{0x14,		{EV_PARA_Ia,	EV_PARA_Ib,	EV_PARA_Ic},        "ABC相短路故障"},
- 	
-	{0x04,		{0,			0,					0},				"分段模式"},
-	{0x04,		{0,			0,					0},				"联络模式"},
-
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流I段动作"},
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流I段告警"},
-	#ifdef EV_GL_STATR
-		{0x04,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"过流I段启动"},
-	#endif
+	{0x04,		{0,        0,        0},				"保护动作总"},
+	{0x04,		{0,        0,        0},				"故障总"},
+	{0x04,		{0,        0,        0},				"短路故障"},
+	{0x04,		{0,        0,        0},				"接地故障"},
+  	{0x14,		{EV_PARA_Ia,	0,					0}, "A相短路故障"},
+  	{0x14,		{EV_PARA_Ib,	0,					0}, "B相短路故障"},
+ 	{0x14,		{EV_PARA_Ic,	0,					0}, "C相短路故障"},
+	{0x14,		{EV_PARA_Ia,	EV_PARA_Ib,			0}, "AB相短路故障"},
+  	{0x14,		{EV_PARA_Ib,	EV_PARA_Ic,			0}, "BC相短路故障"},
+ 	{0x14,		{EV_PARA_Ia,	EV_PARA_Ic,			0}, "AC相短路故障"},
+ 	{0x14,		{EV_PARA_Ia,	EV_PARA_Ib,	EV_PARA_Ic},"ABC相短路故障"},
+	{0x04,		{0,        0,        0},				"分段模式"},
+	{0x04,		{0,        0,        0},				"联络模式"},
+
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic},   "过流I段动作"},
+	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流I段告警"},
+#ifdef EV_GL_STATR
+    {0x04,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "过流I段启动"},
+#endif
     {0x14,		{EV_PARA_Ia,	0,					0},				"过流I段A相短路故障"},
     {0x14,		{EV_PARA_Ib,	0,					0},				"过流I段B相短路故障"},
     {0x14,		{EV_PARA_Ic,	0,					0},				"过流I段C相短路故障"},
 
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流II段动作"},
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流II段告警"},
-	#ifdef EV_GL_STATR
-		{0x04,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"过流II段启动"},
-	#endif
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流II段动作"},
+	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流II段告警"},
+#ifdef EV_GL_STATR
+    {0x04,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "过流II段启动"},
+#endif
     {0x14,		{EV_PARA_Ia,	0,					0},				"过流II段A相短路故障"},
     {0x14,		{EV_PARA_Ib,	0,					0},				"过流II段B相短路故障"},
     {0x14,		{EV_PARA_Ic,	0,					0},				"过流II段C相短路故障"},
 	
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流Ⅲ段动作"},
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流Ⅲ段告警"},
-	#ifdef EV_GL_STATR
-		{0x04,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"过流Ⅲ段启动"},
-	#endif
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流Ⅲ段动作"},
+	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流Ⅲ段告警"},
+#ifdef EV_GL_STATR
+    {0x04,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "过流Ⅲ段启动"},
+#endif
     {0x14,		{EV_PARA_Ia,	0,					0},				"过流Ⅲ段A相短路故障"},
     {0x14,		{EV_PARA_Ib,	0,					0},				"过流Ⅲ段B相短路故障"},
     {0x14,		{EV_PARA_Ic,	0,					0},				"过流Ⅲ段C相短路故障"},
 	
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_I0,	EV_PARA_U0,	0},				"零流I段动作"},
-	{0xD4,		{EV_PARA_I0,	EV_PARA_U0,	0},				"零流I段告警"},
-	#ifdef EV_GL_STATR
-		{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"零流I段启动"},
-	#endif
-	
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_I0,	EV_PARA_U0,	0},				"零流II段动作"},
-	{0xD4,		{EV_PARA_I0,	EV_PARA_U0,	0},				"零流II段告警"},
-	#ifdef EV_GL_STATR
-		{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"零流II段启动"},
-	#endif
-
-	#ifdef DISP_SET_LX3
-		{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_I0,	EV_PARA_U0, 0}, 			"零流III段动作"},
-		{0xD4,		{EV_PARA_I0,	EV_PARA_U0, 0}, 			"零流III段告警"},
-		#ifdef EV_GL_STATR
-			{0x04,		{EV_PARA_U0,EV_PARA_I0,	 0}, 			"零流III段启动"},
-		#endif
-	#endif	
-
-#if defined FUN_JDXX ||defined XDL_ZT
-	{0x84,		{EV_PARA_U0, 0, 0}, "小电流接地零压1告警"},	 
-	{0x84,		{EV_PARA_U0, 0, 0}, "小电流接地零压2告警"},
-	{0x84,		{0, 0, 0},			"小电流接地启动"},
-	{0xC4,		{0, 0, 0},			"小电流接地区内告警"},	
-	{0xC4,		{0, 0, 0},			"小电流接地区内跳闸"},
-	{0x84,		{0, 0, 0},			"小电流接地区外故障"},
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0},				"接地故障总"},
-	{0x0,		{EV_PARA_Ia,	0,			0},				"A相接地故障"}, 
-	{0x0,		{EV_PARA_Ib,	0,			0},				"B相接地故障"},
-	{0x0,		{EV_PARA_Ic,	0,			0},				"C相接地故障"},
-#endif	
-	
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"过流加速动作"},	
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_I0,	EV_PARA_U0,	0},				"零序加速动作"},
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_I0,	EV_PARA_U0,	0},				"零压加速动作"},
-
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"反时限过流动作"},
-#if defined GD_AREA_ECZD_2020   // 合后电流两段处理		
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"合后故障过流I段动作"},	
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"合后故障过流II段动作"},
-#else
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"合后故障过流动作"},	
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},     "零流I段动作"},
+	{0xD4,		                {EV_PARA_I0,	EV_PARA_U0,	0},     "零流I段告警"},
+#ifdef EV_GL_STATR
+    {0x04,		                {EV_PARA_U0,EV_PARA_I0,		0},     "零流I段启动"},
 #endif
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_I0,	EV_PARA_U0,	0},				"合后故障零序动作"},
-	{0x94,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"相间过流告警"},
-	{0x94,		{EV_PARA_I0,	EV_PARA_U0, 0}, 			"接地告警"},
+	
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},     "零流II段动作"},
+	{0xD4,		                {EV_PARA_I0,	EV_PARA_U0,	0},     "零流II段告警"},
 #ifdef EV_GL_STATR
-	{0x04,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"相间I段启动"},	
-	#ifdef GD_AREA_ECZD_2020 	
-		{0x04,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"相间II段启动"},	
-	#endif
-	{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"接地过流启动"},
+    {0x04,		                {EV_PARA_U0,EV_PARA_I0,		0},     "零流II段启动"},
 #endif
 
-	{0x00,		{0,				0,			0},				"重合闸启动"},
-	{0x44|SOE_TYPE_DELAY_FHZ,		{0,				0,			0},				"一次重合动作"},
-	{0x44|SOE_TYPE_DELAY_FHZ,		{0,				0,			0},				"二次重合动作"},
-	{0x44|SOE_TYPE_DELAY_FHZ,		{0,				0,			0},				"三次重合动作"},
-	{0x44,		{0,				0,			0},				"重合闸闭锁"},	
+    {0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0, 0},     "零流III段动作"},
+    {0xD4,		                {EV_PARA_I0,	EV_PARA_U0, 0},     "零流III段告警"},
+#ifdef EV_GL_STATR
+    {0x04,		                {EV_PARA_U0,EV_PARA_I0,	 0},        "零流III段启动"},
+#endif
 	
-	{0x44,		{0, 			0,			0}, 			"大电流闭锁重合闸"},	
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流加速动作"},	
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},         "零序加速动作"},
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},         "零压加速动作"},
 
-	{0x04,		{0,				0,			0},				"重合闸充电完成"},
-#ifdef FUN_CHZ_TOPEN
-	{0x04,		{0, 			0,			0}, 			"终止重合闸过程"}, 
+	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "反时限过流动作"},
+
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "合后故障过流I段动作"},	
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "合后故障过流II段动作"},
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},         "合后故障零序动作"},
+	{0x94,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "相间过流告警"},
+	{0x94,		                {EV_PARA_I0,	EV_PARA_U0, 0},         "接地告警"},
+#ifdef EV_GL_STATR
+	{0x04,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"相间I段启动"},	
+    {0x04,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"相间II段启动"},
+	{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"接地过流启动"},
 #endif
 
-	{0xD4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_U0,	EV_PARA_I0,	0},				"零序电压跳闸"},	
-	{0xD4,		{EV_PARA_U0,	EV_PARA_I0,	0},				"零序电压告警"},	
-	#ifdef EV_GL_STATR
-		{0x04,		{EV_PARA_U0,	EV_PARA_I0,	0},				"零序电压启动"},	
-	#endif
-	
-	{0x44,		{0,				0,			0},				"涌流谐波闭锁"},
-	{0x44,		{0,				0,			0},				"闭锁合闸"},
-
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},				"母线侧有压"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},				"线路侧有压"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},				"双侧失压"},
-    {0x44,		{0,				0,			0},				"母线侧X闭锁"},
-    {0x44,		{0,				0,			0},				"线路侧X闭锁"},
-    {0x44,		{0,				0,			0},				"母线侧Y闭锁"},
-    {0x44,		{0,				0,			0},				"线路侧Y闭锁"},
-    {0x44,		{0,				0,			0},				"母线侧残压闭锁"},
-    {0x44,		{0,				0,			0},				"线路侧残压闭锁"},
-
-	{0x54|SOE_TYPE_DELAY_FHZ,		{EV_PARA_U0,	EV_PARA_I0,	0},				"合后零压动作"},
-	{0x44,		{EV_PARA_U0,				0,			0},				"合前零压闭锁"},
-	{0x04,		{EV_PARA_U0,				0,			0},				"合前零压"},
+	{0x00,		                {0,        0,        0}, "重合闸启动"},
+	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "一次重合动作"},
+	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "二次重合动作"},
+	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "三次重合动作"},
+	{0x44,		                {0,        0,        0}, "重合闸闭锁"},
+	{0x44,		                {0,        0,        0}, "大电流闭锁重合闸"},
+	{0x04,		                {0,        0,        0}, "重合闸充电完成"},
+	{0x04,		                {0,        0,        0}, "终止重合闸过程"},
+
+	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_U0,	EV_PARA_I0,	0}, "零序电压跳闸"},	
+	{0xD4,		                {EV_PARA_U0,	EV_PARA_I0,	0}, "零序电压告警"},	
 #ifdef EV_GL_STATR
-	{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"FA电压启动"},	
+    {0x04,		                {EV_PARA_U0,	EV_PARA_I0,	0}, "零序电压启动"},	
 #endif
-	{0x44|SOE_TYPE_DELAY_FHZ,		{0,				0,			0},				"手分/遥分闭锁合闸"},
-	{0x44,		{0,				0,			0},				"手合/遥合闭锁失压分"},
-	{0x44,		{0,				0,			0},				"双电源闭锁合闸"},	
-	{0x04|SOE_TYPE_DELAY_FHZ,		{0,				0,			0},				"合后故障"},	
-
-    {0x44,		{0,				0,			0},			"母线侧合后故障"},	
-    {0x44,		{0,				0,			0},			"线路侧合后故障"},	
-
-	{0x44,		{0,				0,			0},				"闭锁失压分闸"},	
-
-	{0x04,		{0,				0,			0},				"合闸解锁"},
-	{0x04,		{0,				0,			0},				"人工解锁"},
-	{0x04,		{0,				0,			0},				"单侧来电解锁"},
-	{0x04,		{0,				0,			0},				"联络有压解锁"},
-	{0x04,		{0,			0,				0},				"联络单侧失压时间到"},
-    {0x04,		{0,			0,				0},				"联络A侧失压告警"},
-    {0x04,		{0,			0,				0},				"联络B侧失压告警"},
-    {0x04,		{0,			0,				0},				"联络A侧失压合闸"},
-    {0x04,		{0,			0,				0},				"联络B侧失压合闸"},
-	{0x44|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0},				"得电合闸"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 			"母线侧得电合闸"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},				"线路侧得电合闸"},
-
-	{0xC4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 			"联络合闸"},
-	{0xC4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 			"失电分闸"},
-
-	{0x44,		{0, 			0,			0}, 			"联络充电完成"},
-	{0x44,		{0, 		0,				0}, 			"联络合闸成功"},
-	{0x44,		{0, 		0,				0}, 			"联络合闸失败"},
-	{0x44,		{0, 			0,			0}, 			"联络开关充电完成"},
-#ifdef GD_AREA_ZHONGSHAN_2020
-	{0x44,		{0, 		0,				0}, 			"电压电流型转供电成功"},
-	{0x44,		{0, 		0,				0}, 			"电压电流型转供电失败"},	
+	{0x44,		{0,        0,        0},				"涌流谐波闭锁"},
+
+	{0x44,		{0,        0,        0},				"闭锁合闸"},
+	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},         "母线侧有压"},
+	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},         "线路侧有压"},
+	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},         "双侧失压"},
+    {0x44,		{0,        0,        0},				"母线侧X闭锁"},
+    {0x44,		{0,        0,        0},				"线路侧X闭锁"},
+    {0x44,		{0,        0,        0},				"母线侧Y闭锁"},
+    {0x44,		{0,        0,        0},				"线路侧Y闭锁"},
+    {0x44,		{0,        0,        0},				"母线侧残压闭锁"},
+    {0x44,		{0,        0,        0},				"线路侧残压闭锁"},
+
+	{0x54|SOE_TYPE_DELAY_FHZ,   {EV_PARA_U0, EV_PARA_I0, 0},    "合后零压动作"},
+	{0x44,		                {EV_PARA_U0, 0, 0},				"合前零压闭锁"},
+	{0x04,		                {EV_PARA_U0, 0, 0},				"合前零压"},
+#ifdef EV_GL_STATR
+	{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"FA零压启动"},	
 #endif
-
-	{0x44,		{0,			0,				0},				"手动合闸"},
-	{0x44,		{0,			0,				0},				"手动分闸"},
-	{0x44,		{0,			0,				0},				"开关就地合闸"},
-	{0x44,		{0,			0,				0},				"开关就地分闸"},
-	{0x44,		{0,			0,				0},				"遥控合闸"},
-	{0x44|SOE_TYPE_DELAY_FHZ,		{0,			0,				0},				"遥控分闸"},
-
-	{0x44,		{0,			0,				0},				"多次分闸闭锁合闸"},
-	{0x44,		{0, 		0,				0}, 					"上电拒合"},
+	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "手分/遥分闭锁合闸"},
+	{0x44,		                {0,        0,        0}, "手合/遥合闭锁失压分"},
+	{0x44,		                {0,        0,        0}, "双电源闭锁合闸"},	
+	{0x04|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "合后故障"},	
+    {0x44,		                {0,        0,        0}, "母线侧合后故障"},	
+    {0x44,		{0,        0,        0}, "线路侧合后故障"},	
+	{0x44,		{0,        0,        0}, "闭锁失压分闸"},	
+	{0x04,		{0,        0,        0}, "合闸解锁"},
+	{0x04,		{0,        0,        0}, "人工解锁"},
+	{0x04,		{0,        0,        0}, "对侧来电解锁"},
+	{0x04,		{0,        0,        0}, "联络有压解锁"},
+	{0x04,		{0,        0,        0}, "联络单侧失压时间到"},
+    {0x04,		{0,        0,        0}, "联络A侧失压告警"},
+    {0x04,		{0,        0,        0}, "联络B侧失压告警"},
+    {0x04,		{0,        0,        0}, "联络A侧失压合闸"},
+    {0x04,		{0,        0,        0}, "联络B侧失压合闸"},
+	{0x44|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, "得电合闸"},
+	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 			        "母线侧得电合闸"},
+	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},				        "线路侧得电合闸"},
+	{0xC4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, "联络合闸"},
+	{0xC4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, "失电分闸"},
+	{0x44,		{0,        0,        0},    "联络合闸成功"},
+	{0x44,		{0,        0,        0},    "联络合闸失败"},
+	{0x44,		{0,        0,        0},            "联络开关充电完成"},
+	{0x44,		{0,        0,        0},            "手动合闸"},
+	{0x44,		{0,        0,        0},            "手动分闸"},
+	{0x44,		{0,        0,        0},            "开关就地合闸"},
+	{0x44,		{0,        0,        0},            "开关就地分闸"},
+	{0x44,		{0,        0,        0},            "遥控合闸"},
+	{0x44|SOE_TYPE_DELAY_FHZ, {0,        0,        0},              "遥控分闸"},
+
+	{0x44,		{0,        0,        0},    "多次分闸闭锁合闸"},
+	{0x44,		{0,        0,        0},    "上电拒合"},
 
 #ifdef YK_FA_ENBLE
-	{0x44,		{0,			0,				0},				"遥控闭锁FA"},	
+	{0x44,		{0,        0,        0},    "遥控闭锁FA"},	
 #endif
 
 #ifdef	FA_OC_COUNT
-	{0x44,		{0, 		0,				0}, 					"过流脉冲计数闭锁"},				//
+	{0x44,		{0,        0,        0},    "过流脉冲计数闭锁"},
 #endif
 
-	{0x44,		{0,				0,			0},				"同期合闸"},
+	{0x44,		{0,        0,        0},    "同期合闸"},
 
 //
-	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"电压过高解列"},
 	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"电压过低解列"},
-	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"高电压自动解列"},
 	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"低电压自动解列"},
+	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"高电压自动解列"},
+	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"电压过高解列"},
 	{0xD4,		{EV_PARA_f,	0,0},						"频率过低解列"},
-	{0xD4,		{EV_PARA_f,	0,0},						"高频自动解列"},
 	{0xD4,		{EV_PARA_f,	0,0},						"低频自动解列"},
-
-	{0xC4,		{0,0,	0},								"智能分布式切除动作"},
-	{0xC4,		{0,0,	0},								"智能分布式切除成功"},
-	{0xC4,		{0,0,	0},								"智能分布式切除失败"},
-	{0xC4,		{0,	0,0},								"分布式故障隔离动作"},	
-	{0xC4,		{0,	0,0},								"分布式故障隔离成功"},
-	{0xC4,		{0,	0,0},								"分布式故障隔离失败"},
-	{0xC4,		{0,	0,0},								"分布式供电恢复动作"},	
-	{0xC4,		{0,	0,0},								"分布式供电恢复成功"},
-	{0xC4,		{0,	0,0},								"分布式供电恢复失败"},
+	{0xD4,		{EV_PARA_f,	0,0},						"高频自动解列"},
+	{0xD4,		{EV_PARA_f,	0,0},						"频率过高解列"},
+
+	{0xC4,		{0,        0,        0},    "智能分布式切除动作"},
+	{0xC4,		{0,        0,        0},    "智能分布式切除成功"},
+	{0xC4,		{0,        0,        0},    "智能分布式切除失败"},
+	{0xC4,		{0,        0,        0},    "分布式故障隔离动作"},	
+	{0xC4,		{0,        0,        0},    "分布式故障隔离成功"},
+	{0xC4,		{0,        0,        0},    "分布式故障隔离失败"},
+	{0xC4,		{0,        0,        0},    "分布式供电恢复动作"},	
+	{0xC4,		{0,        0,        0},    "分布式供电恢复成功"},
+	{0xC4,		{0,        0,        0},    "分布式供电恢复失败"},
 
 #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
 	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"分布式过流I段跳闸"},
@@ -355,10 +319,10 @@ const SOE_DEF tAllSOE[]=
 	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"分布式过流跳闸"},
 #endif
 	
-	{0xD4,		{EV_PARA_I0,	0,0},						"分布式零序跳闸"},
-	{0x44,		{0,	0,0},								"首端失压分闸"},
-	{0x44,		{0,	0,0},								"通信异常失压分闸"},
-	{0x44,		{0,	0,	0},								"装置越级跳闸"},
+	{0xD4,		{EV_PARA_I0,	0,0},       "分布式零序跳闸"},
+	{0x44,		{0,        0,        0},    "首开关失压分闸"},
+	{0x44,		{0,        0,        0},    "通信异常失压分闸"},
+	{0x44,		{0,        0,        0},    "装置越级跳闸"},
 
 #ifdef GD_AREA_ZHONGSHAN_2020
 	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"分布式合后I段跳闸"},
@@ -366,222 +330,216 @@ const SOE_DEF tAllSOE[]=
 	{0xD4,		{EV_PARA_I0,	0,0},						"分布式合后零序跳闸"},
 #endif
 	
-	
 	{0x44,		{EV_PARA_Ia,	EV_PARA_Ib,	EV_PARA_Ic},		"遮断电流闭锁"},
-
-#ifdef DISP_SET_DLYX
 	{0x84,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"电流重载告警"},
-//	{0x04,		{EV_PARA_Ia,	0,			0}, 			"Ia重载告警"}, 
-//	{0x04,		{EV_PARA_Ib,	0,			0}, 			"Ib重载告警"}, 
-//	{0x04,		{EV_PARA_Ic,	0,			0}, 			"Ic重载告警"}, 
+	// {0x04,		{EV_PARA_Ia,	0,			0},    "Ia重载告警"}, 
+	// {0x04,		{EV_PARA_Ib,	0,			0},    "Ib重载告警"}, 
+	// {0x04,		{EV_PARA_Ic,	0,			0},    "Ic重载告警"}, 
 
 	{0x84,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"电流过载告警"},
-//	{0x04,		{EV_PARA_Ia,	0,			0}, 			"Ia过载告警"}, 
-//	{0x04,		{EV_PARA_Ib,	0,			0}, 			"Ib过载告警"}, 
-//	{0x04,		{EV_PARA_Ic,	0,			0}, 			"Ic过载告警"}, 
+	// {0x04,		{EV_PARA_Ia,	0,			0},    "Ia过载告警"}, 
+	// {0x04,		{EV_PARA_Ib,	0,			0},    "Ib过载告警"}, 
+	// {0x04,		{EV_PARA_Ic,	0,			0},    "Ic过载告警"}, 
 
 	{0x84,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"负荷越限告警"},
-//	{0x04,		{EV_PARA_Ia,	0,			0}, 			"Ia越限告警"}, 
-//	{0x04,		{EV_PARA_Ib,	0,			0}, 			"Ib越限告警"}, 
-//	{0x04,		{EV_PARA_Ic,	0,			0}, 			"Ic越限告警"}, 
-#else
-	{0x84,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"电流越限告警"},
-	{0x04,		{EV_PARA_Ia,	0,			0},				"Ia越限告警"}, 
-	{0x04,		{EV_PARA_Ib,	0,			0},				"Ib越限告警"}, 
-	{0x04,		{EV_PARA_Ic,	0,			0},				"Ic越限告警"}, 
-#endif
+	// {0x04,		{EV_PARA_Ia,	0,			0},    "Ia越限告警"}, 
+	// {0x04,		{EV_PARA_Ib,	0,			0},    "Ib越限告警"}, 
+	// {0x04,		{EV_PARA_Ic,	0,			0},    "Ic越限告警"}, 
 	{0x84,		{EV_PARA_I0,0,	0},						"零序电流越限告警"},
 
-	{0x44,		{0,				0,			0},			"跳闸失败"},
-	{0x44,		{0,				0,			0},			"合闸失败"},
-	{0x44,		{0,				0,			0},			"开关拒动"},
-	
-#ifdef	CUSTOMIZE_BZT //备自投
-	{0x44,	{0,	0,	0}, 			"1#开关自投跳闸"	},
-	{0x44,	{0,	0,	0}, 			"2#开关自投跳闸"	},
-	{0x44,	{0,	0,	0}, 			"3#开关自投跳闸"	},
-
-	{0x44,	{0,	0,	0}, 			"1#开关自投合闸"	},
-	{0x44,	{0,	0,	0}, 			"2#开关自投合闸"	},
-	{0x44,	{0,	0,	0}, 			"3#开关自投合闸"	},
-
-	{0x44,	{0,	0,	0}, 			"1#开关跳闸失败"	},
-	{0x44,	{0,	0,	0}, 			"2#开关跳闸失败"	},
-	{0x44,	{0,	0,	0}, 			"3#开关跳闸失败"	},
-	
-	{0x44,	{0,	0,	0}, 			"1#开关合闸失败"	},
-	{0x44,	{0,	0,	0}, 			"2#开关合闸失败"	},
-	{0x44,	{0,	0,	0}, 			"3#开关合闸失败"	},
-#endif	
-
-	{0x04,		{0,				0,			0},			"跳位有流告警"},
-
-	{0x07,		{0,	0,	0},								"保护投入软压板"},
-
-#if defined GD_AREA_ECZD_2020
-	{0x07,		{0, 0,	0}, 							"重合闸投入软压板"},
-#else
-	{0x07,		{0, 0,	0}, 							"停用重合闸软压板"},
-#endif	
-
-	{0x07,		{0,	0,	0},								"保护出口投入软压板"},
-	
-#if defined GD_AREA_ZHONGSHAN	|| defined GD_AREA_ZHONGSHAN_2020	
-	{0x07,		{0, 0,	0}, 							"远方修改定值软压板"},
-#else
-	{0x07,		{0,	0,	0},								"远方投入软压板"},
-#endif	
-
-	{0x07,		{0,	0,	0},								"智能分布式软压板"},
-	{0x07,		{0,	0,	0},								"电压电流型软压板"},
-	{0x07,		{0,	0,	0},								"电流型软压板"},
-	{0x07,		{0, 0,	0}, 							"集中式软压板"},
-    {0x07,		{0, 0,	0}, 							"同期合闸软压板"},
-	{0x07,		{0, 0,	0}, 							"自动解列软压板"},
-
-#ifdef XDL_ZT
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0},				"小电流接地启动"},
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0},				"小电流接地动作"},
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0},				"小电流接地告警"},
-	
-	{0x05,		{EV_PARA_U0,	0,			0},				"小电流零压1告警"},	
-	{0x05,		{EV_PARA_U0,	0,			0},				"小电流零压2告警"},	
+	{0x44,		{0,        0,        0},    "跳闸失败"},
+	{0x44,		{0,        0,        0},    "合闸失败"},
+	{0x44,		{0,        0,        0},    "开关拒动"},
+
+	{0x04,		{0,        0,        0},    "跳位有流告警"},
+
+	{0x07,		{0,        0,        0},    "保护投入软压板"},
+	{0x07,		{0,        0,        0},    "常规保护投入"},
+	{0x07,		{0,        0,        0},    "自动重合闸投入"},
+	{0x07,		{0,        0,        0},    "就地型馈线自动化投入"},
+	{0x07,		{0,        0,        0},    "智能分布式投入"},
+	{0x07,		{0,        0,        0},    "集中式投入"},
+    {0x07,		{0,        0,        0},    "同期合闸投入"},
+	{0x07,		{0,        0,        0},    "自动解列投入"},
+	{0x07,		{0,        0,        0},    "小电流接地保护投入"},
+	{0x07,		{0,        0,        0},    "线路断线告警投入"},
+	{0x07,		{0,        0,        0},    "不停电传动投入"},
+
+	{0x07,		{0,        0,        0},    "保护出口投入软压板"},
+	{0x07,		{0,        0,        0},    "远程运维软压板"},
+
+	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "小电流接地启动"},
+	{0x05,		{EV_PARA_U0,	0,			0}, "小电流零压1告警"},	
+	{0x05,		{EV_PARA_U0,	0,			0}, "小电流零压2告警"},	
+	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "接地故障总"},
+	{0x0,		{EV_PARA_Ia,	0,			0}, "A相接地故障"}, 
+	{0x0,		{EV_PARA_Ib,	0,			0}, "B相接地故障"},
+	{0x0,		{EV_PARA_Ic,	0,			0}, "C相接地故障"},
+#if defined FUN_JDXX
+	{0xC4,		{0, 0, 0}, "小电流接地区内告警"},	
+	{0xC4,		{0, 0, 0}, "小电流接地区内跳闸"},
+	{0x84,		{0, 0, 0}, "小电流接地区外故障"},
+#elif defined XDL_ZT
+	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "小电流接地动作"},
+	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "小电流接地告警"},
 #endif
 
 #ifdef YB_STHD_CHECK
-	{0x47,		{0, 0,	0}, 							"功能总压板不一致"},    
-	{0x47,		{0, 0,	0}, 							"重合闸压板不一致"},	
-	{0x47,		{0, 0,	0}, 							"分布式压板不一致"},
-	{0x47,		{0, 0,	0}, 							"就地FA压板不一致"},
-	{0x47,		{0, 0,	0}, 							"电流型压板不一致"},
+	{0x47,		{0,        0,        0},    "功能总压板不一致"},    
+	{0x47,		{0,        0,        0},    "重合闸压板不一致"},	
+	{0x47,		{0,        0,        0},    "分布式压板不一致"},
+	{0x47,		{0,        0,        0},    "就地FA压板不一致"},
+	{0x47,		{0,        0,        0},    "常规保护压板不一致"},
 #endif
 
-	{0x05,		{0,				0,			0},			"未储能告警"},
-	{0x45,		{0,			0,			0},				"控制回路异常"},
-	{0x05,		{0,	0,	0},			"M侧节点故障01"},
-	{0x05,		{0,	0,	0},			"M侧节点故障02"},
-	{0x05,		{0,	0,	0},			"M侧节点故障03"},
-	{0x05,		{0,	0,	0},			"M侧节点故障04"},
-	{0x05,		{0,	0,	0},			"M侧节点故障05"},
-	{0x05,		{0,	0,	0},			"M侧节点故障06"},
-	{0x05,		{0,	0,	0},			"M侧节点故障07"},
-	{0x05,		{0,	0,	0},			"M侧节点故障08"},
-
-	{0x05,		{0,	0,	0},			"N侧节点故障01"},
-	{0x05,		{0,	0,	0},			"N侧节点故障02"},
-	{0x05,		{0,	0,	0},			"N侧节点故障03"},
-	{0x05,		{0,	0,	0},			"N侧节点故障04"},
-
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功01"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功02"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功03"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功04"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功05"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功06"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功07"},
-	{0x05,		{0,	0,	0},			"M侧故障隔离成功08"},
-	{0x05,		{0,	0,	0},			"N侧故障隔离成功01"},
-	{0x05,		{0,	0,	0},			"N侧故障隔离成功02"},
-	{0x05,		{0,	0,	0},			"N侧故障隔离成功03"},
-	{0x05,		{0,	0,	0},			"N侧故障隔离成功04"},
+	{0x05,		{0,        0,        0},    "未储能告警"},
+	{0x45,		{0,        0,        0},    "控制回路异常"},
+
+	{0x05,		{0,        0,        0},    "M侧节点故障01"},
+	{0x05,		{0,        0,        0},    "M侧节点故障02"},
+	{0x05,		{0,        0,        0},    "M侧节点故障03"},
+	{0x05,		{0,        0,        0},    "M侧节点故障04"},
+	{0x05,		{0,        0,        0},    "M侧节点故障05"},
+	{0x05,		{0,        0,        0},    "M侧节点故障06"},
+	{0x05,		{0,        0,        0},    "M侧节点故障07"},
+	{0x05,		{0,        0,        0},    "M侧节点故障08"},
+
+	{0x05,		{0,        0,        0},    "N侧节点故障01"},
+	{0x05,		{0,        0,        0},    "N侧节点故障02"},
+	{0x05,		{0,        0,        0},    "N侧节点故障03"},
+	{0x05,		{0,        0,        0},    "N侧节点故障04"},
+
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功01"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功02"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功03"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功04"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功05"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功06"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功07"},
+	{0x05,		{0,        0,        0},    "M侧故障隔离成功08"},
+	{0x05,		{0,        0,        0},    "N侧故障隔离成功01"},
+	{0x05,		{0,        0,        0},    "N侧故障隔离成功02"},
+	{0x05,		{0,        0,        0},    "N侧故障隔离成功03"},
+	{0x05,		{0,        0,        0},    "N侧故障隔离成功04"},
 	
-	{0x05,		{0,	0,	0},			"M侧开关拒跳01"},
-	{0x05,		{0,	0,	0},			"M侧开关拒跳02"},
-	{0x05,		{0,	0,	0},			"M侧开关拒跳03"},
-	{0x05,		{0,	0,	0},			"M侧开关拒跳04"},
-	{0x05,		{0,	0,	0},			"M侧开关拒跳05"},
-	{0x05,		{0,	0,	0},			"馈线开关拒跳01"},
-	{0x05,		{0,	0,	0},			"馈线开关拒跳02"},
-	{0x05,		{0,	0,	0},			"馈线开关拒跳03"},
-	{0x05,		{0,	0,	0},			"N侧开关拒跳01"},
-	{0x05,		{0,	0,	0},			"N侧开关拒跳02"},
-	{0x05,		{0,	0,	0},			"N侧开关拒跳03"},
-	{0x05,		{0,	0,	0},			"馈线开关拒跳04"},
+	{0x05,		{0,        0,        0},    "M侧开关拒跳01"},
+	{0x05,		{0,        0,        0},    "M侧开关拒跳02"},
+	{0x05,		{0,        0,        0},    "M侧开关拒跳03"},
+	{0x05,		{0,        0,        0},    "M侧开关拒跳04"},
+	{0x05,		{0,        0,        0},    "M侧开关拒跳05"},
+	{0x05,		{0,        0,        0},    "馈线开关拒跳01"},
+	{0x05,		{0,        0,        0},    "馈线开关拒跳02"},
+	{0x05,		{0,        0,        0},    "馈线开关拒跳03"},
+	{0x05,		{0,        0,        0},    "N侧开关拒跳01"},
+	{0x05,		{0,        0,        0},    "N侧开关拒跳02"},
+	{0x05,		{0,        0,        0},    "N侧开关拒跳03"},
+	{0x05,		{0,        0,        0},    "馈线开关拒跳04"},
 	
 
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁01"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁02"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁03"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁04"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁05"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁06"},	
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁07"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁08"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁09"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁10"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁11"},
-	{0x05,		{0,	0,	0},			"馈线开关过流闭锁12"},	
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁01"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁02"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁03"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁04"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁05"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁06"},	
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁07"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁08"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁09"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁10"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁11"},
+	{0x05,		{0,        0,        0},    "馈线开关过流闭锁12"},	
 	
-	{0x85,		{0,			0,			0},					"CT断线"},
-	{0x85,		{0,			0,			0},					"CT相序异常"},
-
-	{0x44,		{0, 			0,			0}, 					"自转电功能投入"},
-	{0x44,		{0, 			0,			0}, 					"分布式供电恢复未满足"},
-	{0x44,		{0, 			0,			0}, 					"分布式故障闭锁合闸"},
-	{0x44,		{0, 			0,			0}, 					"分布式分闸闭锁合闸"},
-	{0xC4,		{EV_PARA_U0,	EV_PARA_I0,	0},				"合后零序电压告警"},
+	{0x85,		{0,        0,        0},    "CT断线"},
+	{0x85,		{0,        0,        0},    "CT相序异常"},
+
+	{0x44,		{0,        0,        0},    "自转电功能投入"},
+	{0x44,		{0,        0,        0},    "分布式供电恢复未满足"},
+	{0x44,		{0,        0,        0},    "分布式故障闭锁合闸"},
+	{0x44,		{0,        0,        0},    "分布式分闸闭锁合闸"},
+	{0xC4,		{EV_PARA_U0,	EV_PARA_I0,	0}, "合后零序电压告警"},
+
 #ifdef FUNC_DRIVE
-	{0x04,		{0, 		0,			0}, 				"不停电传动软压板"},
-	{0x04,		{0, 		0,			0}, 				"传动开始"},
-	{0x04,		{0, 		0,			0}, 				"传动跳闸失败"},
-	{0x04,		{0, 		0,			0}, 				"传动合闸失败"},
+	{0x04,		{0,        0,        0},    "不停电传动软压板"},
+	{0x04,		{0,        0,        0},    "传动开始"},
+	{0x04,		{0,        0,        0},    "传动跳闸失败"},
+	{0x04,		{0,        0,        0},    "传动合闸失败"},
 #endif
 
 #ifdef FUNC_DRIVE_JY
-	{0x04,		{0, 		0,			0}, 				"不停电传动启动失败"},
-	{0x04,		{0, 		0,			0}, 				"不停电传动成功"},
-	{0x04,		{0, 		0,			0}, 				"不停电传动开关拒分"},
-	{0x04,		{0, 		0,			0}, 				"不停电传动开关拒合"},
-	{0x04,		{0, 		0,			0}, 				"不停电传动投退异常"},
-	{0x04,		{0, 		0,			0}, 				"传动补发合闸"},
-	{0x04,		{0, 		0,			0}, 				"不停电传动结束"},
+	{0x04,		{0,        0,        0},    "不停电传动启动失败"},
+	{0x04,		{0,        0,        0},    "不停电传动成功"},
+	{0x04,		{0,        0,        0},    "不停电传动开关拒分"},
+	{0x04,		{0,        0,        0},    "不停电传动开关拒合"},
+	{0x04,		{0,        0,        0},    "不停电传动投退异常"},
+	{0x04,		{0,        0,        0},    "传动补发合闸"},
+	{0x04,		{0,        0,        0},    "不停电传动结束"},
 #endif
 #ifdef FUNC_YL_FZ_SOE
-	{0x44,		{0, 			0,			0}, 			"联络Y闭锁"},
+	{0x44,		{0,        0,        0},    "联络Y闭锁"},
 #endif
-	// 公共事件
+	
+#ifdef	CUSTOMIZE_BZT //备自投
+	{0x44,		{0,        0,        0},    "1#开关自投跳闸"	},
+	{0x44,		{0,        0,        0},    "2#开关自投跳闸"	},
+	{0x44,		{0,        0,        0},    "3#开关自投跳闸"	},
 
-	{0x04,		{EV_PARA_Uab,	0,			0},				"Uab1过电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0},				"Ubc1过电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0},				"Uca1过电压告警"},
-	{0x04,		{EV_PARA_Uab,	0,			0},				"Uab1低电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0},				"Ubc1低电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0},				"Uca1低电压告警"},	
-	{0x04,		{EV_PARA_Uab,	0,			0},				"Uab2过电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0},				"Ubc2过电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0},				"Uca2过电压告警"},
-	{0x04,		{EV_PARA_Uab,	0,			0},				"Uab2低电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0},				"Ubc2低电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0},				"Uca2低电压告警"},
-    {0x04,		{EV_PARA_Us1,	0,			0}, 			"A侧有压"},
-    {0x04,		{EV_PARA_Us2,	0,			0}, 			"B侧有压"}, 
-    {0x04,		{EV_PARA_Us1,	0,			0}, 			"A侧无压"},
-    {0x04,		{EV_PARA_Us2,	0,			0}, 			"B侧无压"},
-
-	{0x85,		{0,			0,			0},					"电源模块状态"},	
+	{0x44,		{0,        0,        0},    "1#开关自投合闸"	},
+	{0x44,		{0,        0,        0},    "2#开关自投合闸"	},
+	{0x44,		{0,        0,        0},    "3#开关自投合闸"	},
+
+	{0x44,		{0,        0,        0},    "1#开关跳闸失败"	},
+	{0x44,		{0,        0,        0},    "2#开关跳闸失败"	},
+	{0x44,		{0,        0,        0},    "3#开关跳闸失败"	},
+	
+	{0x44,		{0,        0,        0},    "1#开关合闸失败"	},
+	{0x44,		{0,        0,        0},    "2#开关合闸失败"	},
+	{0x44,		{0,        0,        0},    "3#开关合闸失败"	},
+#endif	
+
+
+
+	// 公共事件
+	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab1过电压告警"},
+	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc1过电压告警"},
+	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca1过电压告警"},
+	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab1低电压告警"},
+	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc1低电压告警"},
+	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca1低电压告警"},	
+	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab2过电压告警"},
+	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc2过电压告警"},
+	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca2过电压告警"},
+	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab2低电压告警"},
+	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc2低电压告警"},
+	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca2低电压告警"},
+    {0x04,		{EV_PARA_Us1,	0,			0}, "A侧有压"},
+    {0x04,		{EV_PARA_Us2,	0,			0}, "B侧有压"}, 
+    {0x04,		{EV_PARA_Us1,	0,			0}, "A侧无压"},
+    {0x04,		{EV_PARA_Us2,	0,			0}, "B侧无压"},
+
+	{0x85,		{0,        0,        0},        "电源模块状态"},	
 #ifdef BATTERY_WITH_COMM
 	#ifdef FUNC_SEL_BAT_MODULE	
-		{0x04,		{0, 		0,			0}, 				"电池过压告警"},	
-		{0x04,		{0, 		0,			0}, 				"电池离线告警"},
-		{0x04,		{0, 		0,			0}, 				"电池反接告警"},	
-		{0x04,		{0, 		0,			0}, 				"备用输入交流失电"},
-		{0x04,		{0, 		0,			0}, 				"电池容量故障"},	
+		{0x04,		{0,        0,        0}, 				"电池过压告警"},	
+		{0x04,		{0,        0,        0}, 				"电池离线告警"},
+		{0x04,		{0,        0,        0}, 				"电池反接告警"},	
+		{0x04,		{0,        0,        0}, 				"备用输入交流失电"},
+		{0x04,		{0,        0,        0}, 				"电池容量故障"},	
 	#endif
-	{0x04,		{0,			0,			0},					"电池活化状态"},
-	{0x04,		{0,			0,			0},					"交流失电信号"},
+	{0x04,		{0,        0,        0},    "电池活化状态"},
+	{0x04,		{0,        0,        0},    "交流失电信号"},
 #endif
+
 	{0x44,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"PT1断线"},
 	{0x44,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"PT2断线"},
-
 	{0x04,		{0,	0,			0},				"PT1相序异常"},
 	{0x04,		{0,	0,			0},				"PT2相序异常"},
 
-	{0x04,		{0,	0,0},			"电池电压低"},
-	{0x04,		{0, 0,0},			"电池电压高"},
-	{0x04,		{0,	0,0},			"DC1低电压告警"},
-	{0x04,		{0,	0,0},			"DC2低电压告警"},
+	{0x04,		{0,        0,        0},    "电池电压低"},
+	{0x04,		{0,        0,        0},    "电池电压高"},
+	{0x04,		{0,        0,        0},    "DC1低电压告警"},
+	{0x04,		{0,        0,        0},    "DC2低电压告警"},
 #ifdef	CUSTOMIZE_BZT //备自投	
-		{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 		"备自投失电分闸"},
+    {0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 		"备自投失电分闸"},
 #endif
 
 #ifdef METERING_ENERGY
@@ -589,87 +547,81 @@ const SOE_DEF tAllSOE[]=
 	{0x04,		{EV_PARA_DD,	EV_PARA_DIR_NUM|0x20,	0}, 	"潮流变化"},
 #endif
 
-	{0x05,		{0,	0,	0},			"板卡故障"},
-	{0x05,		{0,	0,	0},			"板卡通信异常"},
-	{0x05,		{0,	0,	0},			"面板通信异常"},
+	{0x05,		{0,        0,        0},    "板卡故障"},
+	{0x05,		{0,        0,        0},    "板卡通信异常"},
+	{0x05,		{0,        0,        0},    "面板通信异常"},
 
 #if defined CAN_SLAVE_BOARD && defined METERING_ENERGY
 	{0x05,		{EV_PARA_CAN_SLOT|0x20, 	0,	0}, 	"线损板通信异常"},
 #endif
 
-	{0x04,		{0,	0,	0},			"装置硬件故障"},
-	{0x04,		{0,	0,	0},			"装置软件故障"},
-	{0x45,		{0,	0,	0},			"本机goose通信异常"},
-	{0x05,		{0,	0,	0},			"goose数据异常"},
-
-	{0x45,		{0,	0,	0},			"goose系统通信异常"},
-	
-	{0x05,		{0,	0,	0},			"61850平台库异常"},
+	{0x04,		{0,        0,        0},    "装置硬件故障"},
+	{0x04,		{0,        0,        0},    "装置软件故障"},
+	{0x45,		{0,        0,        0},    "本机goose通信异常"},
+	{0x05,		{0,        0,        0},    "goose数据异常"},
+	{0x45,		{0,        0,        0},    "goose系统通信异常"},
+	{0x05,		{0,        0,        0},    "61850平台库异常"},
 #ifdef GOOSE_NETTYPE_SET
-	{0x45,		{0, 0,	0}, 		"单网通讯异常NET1"},
-	{0x45,		{0,	0,	0},			"单网通讯异常NET2"},
-	{0x45,		{0,	0,	0},			"N侧通讯异常"},
-	{0x45,		{0,	0,	0},			"M侧通讯异常"},
-	{0x45,		{0,	0,	0},			"Goose网络类型错误"},
+	{0x45,		{0,        0,        0},    "单网通讯异常NET1"},
+	{0x45,		{0,        0,        0},    "单网通讯异常NET2"},
+	{0x45,		{0,        0,        0},    "N侧通讯异常"},
+	{0x45,		{0,        0,        0},    "M侧通讯异常"},
+	{0x45,		{0,        0,        0},    "Goose网络类型错误"},
 #endif
 #if defined GD_AREA_ZHONGSHAN_2020
-	{0x05,		{0, 0,	0}, 		"分布式配置异常"},
+	{0x05,		{0,        0,        0},    "分布式配置异常"},
 #endif
 
-	{0x00,		{0,	0,	0},			"事故总"},
-	{0x04,		{0,			0,			0},					"电池自动活化投退"},
-	{0x04,		{0,			0,			0},					"备用电源投入"},
-	{0x04,		{0,			0,			0},					"非电量1跳闸"},
-	{0x04,		{0,			0,			0},					"非电量2跳闸"},
-	{0x04,		{0,			0,			0},					"非电量3跳闸"},
-	{0x04,		{0,			0,			0},					"非电量4跳闸"},
-	{0x04,		{0,			0,			0},					"非电量5跳闸"},
-	{0x04,		{0,			0,			0},					"非电量6跳闸"},
-	{0x04,		{0,			0,			0},					"非电量7跳闸"},
-	{0x04,		{0,			0,			0},					"非电量8跳闸"},
-	{0x04,		{0,			0,			0},					"非电量1告警"},
-	{0x04,		{0,			0,			0},					"非电量2告警"},
-	{0x04,		{0,			0,			0},					"非电量3告警"},
-	{0x04,		{0,			0,			0},					"非电量4告警"},	
-	{0x04,		{0,			0,			0},					"非电量5告警"},
-	{0x04,		{0,			0,			0},					"非电量6告警"},
-	{0x04,		{0,			0,			0},					"非电量7告警"},
-	{0x04,		{0,			0,			0},					"非电量8告警"},
-	{0x04,		{0,			0,			0},					"串口1通信异常"},
-	{0x04,		{0,			0,			0},					"串口2通信异常"},
-	{0x04,		{0,			0,			0},					"串口3通信异常"},
-	{0x04,		{0,			0,			0},					"串口4通信异常"},
-	{0x04,		{0,			0,			0},					"串口5通信异常"},
-	{0x04,		{0,			0,			0},					"串口6通信异常"},
-	{0x04,		{0,			0,			0},					"网络1通信异常"},
-	{0x04,		{0,			0,			0},					"网络2通信异常"},
-
-	{0x04,		{0,			0,			0},					"级联装置1异常"},
-	{0x04,		{0,			0,			0},					"级联装置2异常"},
-	{0x04,		{0,			0,			0},					"级联装置3异常"},
-	{0x04,		{0,			0,			0},					"级联装置4异常"},
-	{0x04,		{0,			0,			0},					"级联装置5异常"},
-	{0x04,		{0,			0,			0},					"级联装置6异常"},
-	{0x04,		{0, 		0,			0}, 				"级联装置7异常"},
-	{0x04,		{0, 		0,			0}, 				"级联装置8异常"},
-	{0x04,		{0, 		0,			0}, 				"级联装置9异常"},
-	{0x04,		{0, 		0,			0}, 				"级联装置10异常"},
-	{0x04,		{0,			0,			0},					"面板合闸"},
-	{0x04,		{0,			0,			0},					"面板分闸"},
+	{0x00,		{0,        0,        0},    "事故总"},
+	{0x04,		{0,        0,        0},    "电池自动活化投退"},
+	{0x04,		{0,        0,        0},    "备用电源投入"},
+	{0x04,		{0,        0,        0},    "非电量1跳闸"},
+	{0x04,		{0,        0,        0},    "非电量2跳闸"},
+	{0x04,		{0,        0,        0},    "非电量3跳闸"},
+	{0x04,		{0,        0,        0},    "非电量4跳闸"},
+	{0x04,		{0,        0,        0},    "非电量5跳闸"},
+	{0x04,		{0,        0,        0},    "非电量6跳闸"},
+	{0x04,		{0,        0,        0},    "非电量1告警"},
+	{0x04,		{0,        0,        0},    "非电量2告警"},
+	{0x04,		{0,        0,        0},    "非电量3告警"},
+	{0x04,		{0,        0,        0},    "非电量4告警"},	
+	{0x04,		{0,        0,        0},    "非电量5告警"},
+	{0x04,		{0,        0,        0},    "非电量6告警"},
+	{0x04,		{0,        0,        0},    "串口1通信异常"},
+	{0x04,		{0,        0,        0},    "串口2通信异常"},
+	{0x04,		{0,        0,        0},    "串口3通信异常"},
+	{0x04,		{0,        0,        0},    "串口4通信异常"},
+	{0x04,		{0,        0,        0},    "串口5通信异常"},
+	{0x04,		{0,        0,        0},    "串口6通信异常"},
+	{0x04,		{0,        0,        0},    "网络1通信异常"},
+	{0x04,		{0,        0,        0},    "网络2通信异常"},
+
+	{0x04,		{0,        0,        0},    "级联装置1异常"},
+	{0x04,		{0,        0,        0},    "级联装置2异常"},
+	{0x04,		{0,        0,        0},    "级联装置3异常"},
+	{0x04,		{0,        0,        0},    "级联装置4异常"},
+	{0x04,		{0,        0,        0},    "级联装置5异常"},
+	{0x04,		{0,        0,        0},    "级联装置6异常"},
+	{0x04,		{0,        0,        0},    "级联装置7异常"},
+	{0x04,		{0,        0,        0},    "级联装置8异常"},
+	{0x04,		{0,        0,        0},    "级联装置9异常"},
+	{0x04,		{0,        0,        0},    "级联装置10异常"},
+	{0x04,		{0,        0,        0},    "面板合闸"},
+	{0x04,		{0,        0,        0},    "面板分闸"},
 
 
 	
 /*下面不需要上送后台的操作或提示类的信息*/
 
-	{0x00,		{0,	0,	0},		"装置上电"},
+	{0x00,		{0,        0,        0},    "装置上电"},
 	/*装置状态切换*/
-	{0x00,		{0,	0,	0},		"进入测试模式"},
-	{0x00,		{0,	0,	0},		"进入运行模式"},
+	{0x00,		{0,        0,        0},    "进入测试模式"},
+	{0x00,		{0,        0,        0},    "进入运行模式"},
 
 	/*通道校正记录*/
-	{0x00,		{0,	0,	0},		"幅值手校成功"},
-	{0x00,		{0,	0,	0},		"角度手校成功"},
-	{0x00,		{0,	0,	0},		"通道自校成功"},
+	{0x00,		{0,        0,        0},    "幅值手校成功"},
+	{0x00,		{0,        0,        0},    "角度手校成功"},
+	{0x00,		{0,        0,        0},    "通道自校成功"},
 
 	/*遥控操作类*/
 	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸预置成功"},
@@ -689,44 +641,42 @@ const SOE_DEF tAllSOE[]=
 	{0x00,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"PLC合"},
 	{0x00,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"PLC分"},
 
-	{0x04,		{0,	0,	0},		"手动合闸"},
-	{0x04,		{0,	0,	0},		"手动分闸"},
-	{0x04,		{0,	0,	0},		"无线遥控合闸"},
-	{0x04,		{0,	0,	0},		"无线遥控分闸"},
-	{0x04,		{0,	0,	0},		"PDA遥控合闸"},
-	{0x04,		{0,	0,	0},		"PDA遥控分闸"},
-	{0x04,		{0,	0,	0},		"短信合闸"},
-	{0x04,		{0,	0,	0},		"短信分闸"},
+	{0x04,		{0,        0,        0},    "手动合闸"},
+	{0x04,		{0,        0,        0},    "手动分闸"},
+	{0x04,		{0,        0,        0},    "无线遥控合闸"},
+	{0x04,		{0,        0,        0},    "无线遥控分闸"},
+	{0x04,		{0,        0,        0},    "PDA遥控合闸"},
+	{0x04,		{0,        0,        0},    "PDA遥控分闸"},
+	{0x04,		{0,        0,        0},    "短信合闸"},
+	{0x04,		{0,        0,        0},    "短信分闸"},
 
-	{0x04,		{0,	0,	0},		"电池自动活化"},
-	{0x04,		{0,	0,	0},		"电池活化启动"},
-	{0x04,		{0,	0,	0},		"电池活化退出"},
-	{0x04,		{0,	0,	0},		"电池手动退出"},
+	{0x04,		{0,        0,        0},    "电池自动活化"},
+	{0x04,		{0,        0,        0},    "电池活化启动"},
+	{0x04,		{0,        0,        0},    "电池活化退出"},
+	{0x04,		{0,        0,        0},    "电池手动退出"},
 
 	/*定值操作类*/
-	{0x00,		{0,	0,	0},		"定值整定成功"},
-	{0x00,		{0,	0,	0},		"定值整定失败"},
-	{0x00,		{0,	0,	0},		"公共定值整定成功"},
-	{0x00,		{0,	0,	0},		"公共定值整定失败"},
-	{0x00,		{0,	0,	0},		"软压板整定成功"},
-	{0x00,		{0,	0,	0},		"软压板整定失败"},
-
-	/*内部定值操作类*/
-	{0x00,		{0,	0,	0},		"内部定值成功"},
-	{0x00,		{0,	0,	0},		"内部定值失败"},
-
-	{0x00,		{0,	0,	0},		"RTC内存初始化"},
+	{0x00,		{0,        0,        0},    "定值整定成功"},
+	{0x00,		{0,        0,        0},    "定值整定失败"},
+	{0x00,		{0,        0,        0},    "公共定值整定成功"},
+	{0x00,		{0,        0,        0},    "公共定值整定失败"},
+	{0x00,		{0,        0,        0},    "软压板整定成功"},
+	{0x00,		{0,        0,        0},    "软压板整定失败"},
+	{0x00,		{0,        0,        0},    "内部定值成功"},
+	{0x00,		{0,        0,        0},    "内部定值失败"},
+
+	{0x00,		{0,        0,        0},    "RTC内存初始化"},
 	/*参数操作*/
-	{0x00,		{0,	0,	0},		"参数整定成功"},
-	{0x00,		{0,	0,	0},		"参数整定失败"},
-	{0x00,		{0,	0,	0},		"信号复归"},
-	{0x00,		{0,	0,	0},		"事件记录清除"},
-	{0x00,		{0,	0,	0},		"操作记录清除"},
-	{0x00,		{0,	0,	0},		"恢复出厂设置"},
-	{0x00,		{0,	0,	0},		"录波溢出"},
-	{0x00,		{0, 0,	0}, 	"定值修改"},
+	{0x00,		{0,        0,        0},    "参数整定成功"},
+	{0x00,		{0,        0,        0},    "参数整定失败"},
+	{0x00,		{0,        0,        0},    "信号复归"},
+	{0x00,		{0,        0,        0},    "事件记录清除"},
+	{0x00,		{0,        0,        0},    "操作记录清除"},
+	{0x00,		{0,        0,        0},    "恢复出厂设置"},
+	{0x00,		{0,        0,        0},    "录波溢出"},
+	{0x00,		{0,        0,        0}, 	"定值修改"},
 #if defined(CPU_AM335X) 
-	{0x00,		{0, 0,	0}, 	"恢复APP分区"},
+	{0x00,		{0,        0,        0}, 	"恢复APP分区"},
 #endif	
 };
 

dtu/dtu_main_t536/app/Appconfig.h

@@ -128,507 +128,480 @@ extern struct unit g_unit[UNIT_NUM];
 
 enum
 {
-
-	EV_BH_FAULT=0,				// 保护总
-	EV_ALL_FAULT,				// 线路故障总
-
-	EV_GL_FAULT,				// 线路短路故障
-	EV_LX_FAULT,				// 线路零序故障
-
-	EV_IA_GL,					//A相故障
-	EV_IB_GL,					//B相故障
-	EV_IC_GL,					//C相故障
-	EV_IAB_GL,					//AB相故障
-	EV_IBC_GL,					//BC相故障
-	EV_ICA_GL,					//CA相故障
-	EV_IABC_GL,					//ABC相故障
-	EV_TYPE_S,					//分段模式
-	EV_TYPE_L,					//联络模式
-
-
-	EV_GL1TZ,			// 过流1动作
-	EV_GL1GJ,	
+    EV_BH_FAULT = 0, // 保护动作总
+    EV_ALL_FAULT,    // 故障总
+    EV_GL_FAULT,     // 短路故障
+    EV_LX_FAULT,     // 接地故障
+    EV_IA_GL,        // A相短路故障
+    EV_IB_GL,        // B相短路故障
+    EV_IC_GL,        // C相短路故障
+    EV_IAB_GL,       // AB相短路故障
+    EV_IBC_GL,       // BC相短路故障
+    EV_ICA_GL,       // CA相短路故障
+    EV_IABC_GL,      // ABC相短路故障
+    EV_TYPE_S,       // 分段模式
+    EV_TYPE_L,       // 联络模式
+
+    EV_GL1TZ, // 过流I段动作
+    EV_GL1GJ, // 过流I段告警
 #ifdef EV_GL_STATR
-	EV_GL1_START,
+    EV_GL1_START, // 过流I段启动
 #endif
-    EV_GL1_IA,                  //过流1 A相故障
-    EV_GL1_IB,                  //过流1 B相故障
-    EV_GL1_IC,                  //过流1 C相故障
-
-    EV_GL2TZ,           // 过流2动作
-    EV_GL2GJ,
-#ifdef EV_GL_STATR
-	EV_GL2_START,
+    EV_GL1_IA, // 过流I段A相故障
+    EV_GL1_IB, // 过流I段B相故障
+    EV_GL1_IC, // 过流I段C相故障
+
+    EV_GL2TZ,      // 过流II段动作
+    EV_GL2GJ,      // 过流II段告警
+#ifdef EV_GL_STATR // 过流II段启动
+    EV_GL2_START,  //
 #endif
-	EV_GL2_IA,					//过流2 A相故障
-	EV_GL2_IB,					//过流2 B相故障
-	EV_GL2_IC,					//过流2 C相故障
+    EV_GL2_IA, // 过流II段A相短路故障
+    EV_GL2_IB, // 过流II段B相短路故障
+    EV_GL2_IC, // 过流II段C相短路故障
 
-    EV_GL3TZ,           // 过流2动作
-    EV_GL3GJ,
+    EV_GL3TZ, // 过流Ⅲ段动作
+    EV_GL3GJ, // 过流Ⅲ段告警
 #ifdef EV_GL_STATR
-    EV_GL3_START,
+    EV_GL3_START, // 过流Ⅲ段启动
 #endif
-	EV_GL3_IA,					//过流3 A相故障
-	EV_GL3_IB,					//过流3 B相故障
-	EV_GL3_IC,					//过流3 C相故障
-
+    EV_GL3_IA, // 过流Ⅲ段A相短路故障
+    EV_GL3_IB, // 过流Ⅲ段B相短路故障
+    EV_GL3_IC, // 过流Ⅲ段C相短路故障
 
-    EV_LX1TZ,
-    EV_LX1GJ,
-#ifdef EV_GL_STATR
-	EV_LX1_START,
-#endif	
-	EV_LX2TZ,			
-	EV_LX2GJ,
+    EV_LX1TZ, // 零流I段动作
+    EV_LX1GJ, // 零流I段告警
 #ifdef EV_GL_STATR
-	EV_LX2_START,
+    EV_LX1_START, // 零流I段启动
 #endif
-
-#ifdef DISP_SET_LX3
-	EV_LX3TZ,			
-	EV_LX3GJ,
-  #ifdef EV_GL_STATR
-	EV_LX3_START,
-  #endif
+    EV_LX2TZ, // 零流II段动作
+    EV_LX2GJ, // 零流II段告警
+#ifdef EV_GL_STATR
+    EV_LX2_START, // 零流II段启动
 #endif
 
-#if defined FUN_JDXX ||defined XDL_ZT
-		EV_JDXX_U01GJ,			// 小电流零压告警1
-		EV_JDXX_U02GJ,			// 小电流零压告警2
-		EV_JDXX_QD, 
-		EV_JDXX_GJ,
-		EV_JDXX_TZ,
-		EV_JDXX_JWGZ,
-
-        EV_ABC_JDTZ,				// 接地故障总
-        EV_A_JDTZ,					// A项接地
-        EV_B_JDTZ,					// B项接地
-        EV_C_JDTZ,					// C项接地
-#endif	
-
-	EV_GLJS,					// IA过流加速
-	EV_LXJS,					// 零序加速
-	EV_U0JS,
-	EV_FSXGL,
-	EV_FA_GL_TZ,	
-#if defined GD_AREA_ECZD_2020
-	EV_FA_GL_TZ2,
-#endif	
-	EV_FA_LX_TZ,
-	
-	EV_FA_GL_GJ,    //相间过流告警
-
-	EV_FA_LX_GJ,
+    EV_LX3TZ, // 零流III段动作
+    EV_LX3GJ, // 零流III段告警
 #ifdef EV_GL_STATR
-	EV_FA_GL_START,
-#ifdef GD_AREA_ECZD_2020 	
-	EV_FA_GL2_START,
-#endif	
-	EV_FA_LX_START,
+    EV_LX3_START, // 零流III段启动
 #endif
 
-	EV_AR_START,				// 重合闸启动
-	EV_AR1,						// 重合闸动作1
-	EV_AR2,						// 重合闸动作2
-	EV_AR3,						// 重合闸动作3
-	EV_ARBS,					// 重合闸闭锁
-	EV_HI_CHZ_LOCK,				// 大电流闭锁重合闸
-	EV_ARCD,					// 重合闸充电标志
-#ifdef FUN_CHZ_TOPEN
-    EV_CHZ_TOPEN,              //重合闸开放时间到
+    EV_GLJS,      // 过流加速动作
+    EV_LXJS,      // 零序加速动作
+    EV_U0JS,      // 零压加速动作
+    EV_FSXGL,     // 反时限过流动作
+    EV_FA_GL_TZ,  // 合后故障过流I段动作
+    EV_FA_GL_TZ2, // 合后故障过流II段动作
+    EV_FA_LX_TZ,  // 合后故障零序动作
+    EV_FA_GL_GJ,  // 相间过流告警
+    EV_FA_LX_GJ,  // 接地告警
+#ifdef EV_GL_STATR
+    EV_FA_GL_START,  // 相间I段启动
+    EV_FA_GL2_START, // 相间II段启动
+    EV_FA_LX_START,  // 接地过流启动
 #endif
 
-	EV_U0TZ,					// 零序电压跳闸
-	EV_U0GJ,					// 零序电压告警
+    EV_AR_START,    // 重合闸启动
+    EV_AR1,         // 一次重合动作
+    EV_AR2,         // 二次重合动作
+    EV_AR3,         // 三次重合动作
+    EV_ARBS,        // 重合闸闭锁
+    EV_HI_CHZ_LOCK, // 大电流闭锁重合闸
+    EV_ARCD,        // 重合闸充电完成
+    EV_CHZ_TOPEN,   // 终止重合闸过程
+
+    EV_U0TZ, // 零序电压跳闸
+    EV_U0GJ, // 零序电压告警
 #ifdef EV_GL_STATR
-	EV_U0_STATR,
-#endif	
-	EV_XBBS,					// 谐波闭锁
-	
-	EV_BS_ALL,					// 闭锁合闸
-	EV_YY_P,					// 电源侧有压
-	EV_YY_L,					// 负荷侧有压
-	EV_Z_TIME,					// Z停电
-	EV_BS_X_P,					// 电源侧X闭锁
-	EV_BS_X_L,					// 负荷侧X闭锁
-	EV_BS_Y_P,					// 电源侧Y闭锁,
-	EV_BS_Y_L,					// 负荷侧Y闭锁
-	EV_BS_UF_P,					// 电源侧残压闭锁合闸
-	EV_BS_UF_L,					// 负荷侧残压闭锁合闸
-	EV_BS_U0,					// 合后零压闭锁合闸
-	EV_BSBE_U0,					// 合前零压闭锁合闸
-	EV_BE_UO,					// 合前零压
+    EV_U0_STATR, // 零序电压启动
+#endif
+    EV_XBBS, // 谐波闭锁
+
+    EV_BS_ALL,  // 闭锁合闸
+    EV_YY_P,    // 母线侧有压
+    EV_YY_L,    // 线路侧有压
+    EV_Z_TIME,  // 双侧失压
+    EV_BS_X_P,  // 母线侧X闭锁
+    EV_BS_X_L,  // 线路侧X闭锁
+    EV_BS_Y_P,  // 母线侧Y闭锁,
+    EV_BS_Y_L,  // 线路侧Y闭锁
+    EV_BS_UF_P, // 母线侧残压闭锁
+    EV_BS_UF_L, // 线路侧残压闭锁
+    EV_BS_U0,   // 合后零压动作
+    EV_BSBE_U0, // 合前零压闭锁
+    EV_BE_UO,   // 合前零压
 #ifdef EV_GL_STATR
-	EV_FA_U0_STATR,
+    EV_FA_U0_STATR, // FA零压启动
 #endif
-	EV_BS_HA,					// 手分闭锁合闸 手分/遥分闭锁合闸
-	EV_SH_BSFZ,					// 手合/遥合闭锁失压分
-	EV_BS_DB,					// 双电源闭锁合闸
-	EV_HHGZ,	 				// 合后故障
-	EV_HHGZ_P,	 				// 电源侧合后故障
-	EV_HHGZ_L,	 				// 负荷侧合后故障
-	EV_BSTZ_FA,	 				// 合后无故障闭锁失压分闸
-	
-	EV_JS_HZ,					// 人工合闸解锁
-	EV_JS_HA,					// 就地按钮解锁
-	EV_JS_POWER,				// 对侧来电解锁
-	EV_JS_L,						// 联络有压解锁
-	EV_L_LST_T,					//联络单侧失压时间到
-	EV_L_A_LST_ALA,             // 联络A侧失压告警
-	EV_L_B_LST_ALA,				// 联络B侧失压告警
-	EV_L_A_LST_HZ,				// 联络A侧失压合闸
-	EV_L_B_LST_HZ,     			// 联络B侧失压合闸
-	EV_FA_HZ,					// 得电合闸	
-	EV_FA_HZ_L,					// 电源侧得电合闸	
-	EV_FA_HZ_P,					// 负荷侧得电合闸
-	EV_FA_LL_HZ,					// 得电合闸	
-	EV_FA_FZ,					// 失电分闸
-	EV_FA_HZ_OK,			//联络合闸成功
-	EV_FA_HZ_FAIL,		   //联络合闸失败 
-	EV_FA_LL_CD,			//联络充电
-
-	EV_HA_HZ,					// 手动合闸	
-	EV_HA_FZ,					// 手动分闸
-	EV_DL_HZ,						// 开关就地合闸	
-	EV_DL_FZ,						// 开关就地分闸
-	EV_YK_HZ,						// 遥控合闸
-	EV_YK_FZ,						// 遥控分闸
-	EV_BS_FZMORE,				//多次分闸，闭锁合闸
-	EV_X_SWFAIL,				//上电拒合
+    EV_BS_HA,       // 手分/遥分闭锁合闸
+    EV_SH_BSFZ,     // 手合/遥合闭锁失压分
+    EV_BS_DB,       // 双电源闭锁合闸
+    EV_HHGZ,        // 合后故障
+    EV_HHGZ_P,      // 母线侧合后故障
+    EV_HHGZ_L,      // 线路侧合后故障
+    EV_BSTZ_FA,     // 闭锁失压分闸
+    EV_JS_HZ,       // 合闸解锁
+    EV_JS_HA,       // 人工解锁
+    EV_JS_POWER,    // 对侧来电解锁
+    EV_JS_L,        // 联络有压解锁
+    EV_L_LST_T,     // 联络单侧失压时间到
+    EV_L_A_LST_ALA, // 联络A侧失压告警
+    EV_L_B_LST_ALA, // 联络B侧失压告警
+    EV_L_A_LST_HZ,  // 联络A侧失压合闸
+    EV_L_B_LST_HZ,  // 联络B侧失压合闸
+    EV_FA_HZ,       // 得电合闸
+    EV_FA_HZ_L,     // 母线侧得电合闸
+    EV_FA_HZ_P,     // 线路侧得电合闸
+    EV_FA_LL_HZ,    // 联络合闸
+    EV_FA_FZ,       // 失电分闸
+    EV_FA_HZ_OK,    // 联络合闸成功
+    EV_FA_HZ_FAIL,  // 联络合闸失败
+    EV_FA_LL_CD,    // 联络开关充电完成
+
+    EV_HA_HZ,     // 手动合闸
+    EV_HA_FZ,     // 手动分闸
+    EV_DL_HZ,     // 开关就地合闸
+    EV_DL_FZ,     // 开关就地分闸
+    EV_YK_HZ,     // 遥控合闸
+    EV_YK_FZ,     // 遥控分闸
+    EV_BS_FZMORE, // 多次分闸闭锁合闸
+    EV_X_SWFAIL,  // 上电拒合
 
 #ifdef YK_FA_ENBLE
-	EV_YK_BS_FA,				//遥控闭锁FA
+    EV_YK_BS_FA, // 遥控闭锁FA
 #endif
 
-#ifdef	FA_OC_COUNT
-	EV_BS_OC_COUNT,				//过流脉冲计数闭锁
+#ifdef FA_OC_COUNT
+    EV_BS_OC_COUNT, // 过流脉冲计数闭锁
 #endif
-	EV_TQHZ,					// 合环
-	
-	EV_GGDY_TZ,			//电压过高解列
-
-	EV_GDDY_TZ,			//电压过低解列
-	
-	EV_GDY_TZ,			//电压高解列
-	EV_DDY_TZ,			//电压低解列
-	EV_LOWPL_TZ,			//频率过低解列
-	EV_GPL_TZ,			//高频解列
-	EV_DPL_TZ,			//低频解列
-
-	EV_GOOSE_QC_QD,		// 故障切除
-	EV_GOOSE_QC_OK,		// 故障切除成功
-	EV_GOOSE_QC_FAIL,		// 故障切除失败
-	
-	EV_GOOSE_GL_QD,		// 故障隔离
-	EV_GOOSE_GL_OK,		// 故障隔离成功
-	EV_GOOSE_GL_FAIL,		// 故障隔离失败
-
-	EV_GOOSE_HZ_QD,		// 供电恢复动作
-	EV_GOOSE_HZ_OK,		// 供电恢复成功
-	EV_GOOSE_HZ_FAIL,		// 供电恢复失败
-	EV_GOOSE_GL_TZ,			// 过流跳闸
+    EV_TQHZ, // 同期合闸
+
+    EV_GDDY_TZ,   // 电压过低解列
+    EV_DDY_TZ,    // 电压低解列
+    EV_GDY_TZ,    // 电压高解列
+    EV_GGDY_TZ,   // 电压过高解列
+    EV_LOWPL_TZ,  // 频率过低解列
+    EV_DPL_TZ,    // 低频解列
+    EV_GPL_TZ,    // 高频解列
+    EV_HIGHPL_TZ, // 频率过高解列
+
+    EV_GOOSE_QC_QD,   // 智能分布式切除动作
+    EV_GOOSE_QC_OK,   // 智能分布式切除成功
+    EV_GOOSE_QC_FAIL, // 智能分布式切除失败
+    EV_GOOSE_GL_QD,   // 分布式故障隔离动作
+    EV_GOOSE_GL_OK,   // 分布式故障隔离成功
+    EV_GOOSE_GL_FAIL, // 分布式故障隔离失败
+    EV_GOOSE_HZ_QD,   // 分布式供电恢复动作
+    EV_GOOSE_HZ_OK,   // 分布式供电恢复成功
+    EV_GOOSE_HZ_FAIL, // 分布式供电恢复失败
+    EV_GOOSE_GL_TZ,   // 分布式过流跳闸
 #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
-	EV_GOOSE_GL2_TZ, 		// 过流2段跳闸
+    EV_GOOSE_GL2_TZ, // 分布式过流II段跳闸
 #endif
-	EV_GOOSE_LX_TZ,			// 过流跳闸
-	EV_GOOSE_SDLOST_TZ,			// 首端失压
-	EV_GOOSE_ERRLOST_TZ,			// 通信异常失压
-	EV_GOOSE_EXT_TZ,				// 系统越级跳闸
+    EV_GOOSE_LX_TZ,      // 分布式零序跳闸
+    EV_GOOSE_SDLOST_TZ,  // 首开关失压分闸
+    EV_GOOSE_ERRLOST_TZ, // 通信异常失压分闸
+    EV_GOOSE_EXT_TZ,     // 装置越级跳闸
 #ifdef GD_AREA_ZHONGSHAN_2020
-	EV_GOOSE_HZ_GL1,		// 合后过流1段跳闸
-	EV_GOOSE_HZ_GL2,		// 合后过流1段跳闸
-	EV_GOOSE_HZ_LX,		// 合后零序跳闸
-#endif
-	
-	EV_BSTZ,					// 大电流闭锁分闸
-#ifdef DISP_SET_DLYX
-	EV_DLZZ,				// 电流重载
-//	EV_IAZZ,					// IA电流重载
-//	EV_IBZZ,					// IB电流重载
-//	EV_ICZZ,					// IC电流重载
-	EV_DLGZ,					// 电流过载
-//	EV_IAGZ,					// IA电流过载
-//	EV_IBGZ,					// IB电流过载
-//	EV_ICGZ,					// IC电流过载
-	EV_DLYX,					// 电流越限
-//	EV_IAYX,					// IA电流越限
-//	EV_IBYX,					// IB电流越限
-//	EV_ICYX,					// IC电流越限
-#else
-	EV_DLYX,					// 电流越限
-	EV_IAYX,					// IA电流越限
-	EV_IBYX,					// IB电流越限
-	EV_ICYX,					// IC电流越限
-#endif
-	EV_I0YX,					// 零序电流越限	
-	EV_TZFAIL,					// 跳闸失败
-	EV_HZFAIL,					// 合闸失败
-	EV_SWFAIL,					// 开关拒动	
-	
-#ifdef	CUSTOMIZE_BZT //备自投
-	EV_ZT_TZ1,					//1#开关自投跳闸
-	EV_ZT_TZ2,					//2#开关自投跳闸	
-	EV_ZT_TZ3,					//3#开关自投跳闸	
-
-	EV_ZT_HZ1,					//1#开关自投合闸		
-	EV_ZT_HZ2,					//2#开关自投合闸		
-	EV_ZT_HZ3,					//3#开关自投合闸		
-
-	EV_BZT_TZ1_FAIL,			//1#开关跳闸失败	
-	EV_BZT_TZ2_FAIL,			//2#开关跳闸失败
-	EV_BZT_TZ3_FAIL,			//3#开关跳闸失败
-
-	EV_BZT_HZ1_FAIL,			//1#开关合闸失败	
-	EV_BZT_HZ2_FAIL,			//2#开关合闸失败		
-	EV_BZT_HZ3_FAIL,			//3#开关合闸失败	
+    EV_GOOSE_HZ_GL1, // 分布式合后I段跳闸
+    EV_GOOSE_HZ_GL2, // 分布式合后II段跳闸
+    EV_GOOSE_HZ_LX,  // 分布式合后零序跳闸
 #endif
 
-	EV_TWYL,					// 跳位有流
-	EV_BH_YB,					// 压板状态
-	EV_CHZ_YB,					// 压板状态
-	EV_KZ_YB,					// 压板状态
-	EV_EDIT_YB,					// 远方定值整定压板
-
-	EV_GOOSE_YBTT,				// 智能分布式软压板
-	EV_FA_YBTT,					// 电压电流型软压板
-	EV_BH_YBTT,					// 电流型软压板
-	EV_JZS_YBTT,				// 集中式软压板
-	EV_TQ_YBTT,				    // 同期合闸软压板
-	EV_JL_YBTT,					// 自动解列软压板
-
-#ifdef XDL_ZT	
-	EV_LX_XDL_QD,		// 零序小电流启动		
-	EV_LX_XDL_TZ,		// 零序小电流跳闸		
-	EV_LX_XDL_GJ,		// 零序小电流告警
-	EV_XDL_U0GJ1,		// 小电流零压告警1
-	EV_XDL_U0GJ2,		// 小电流零压告警2
+    EV_BSTZ, // 遮断电流闭锁
+    EV_DLZZ, // 电流重载告警
+    // EV_IAZZ,					// Ia重载告警
+    // EV_IBZZ,					// Ib重载告警
+    // EV_ICZZ,					// Ic重载告警
+    EV_DLGZ, // 电流过载告警
+    // EV_IAGZ,					// Ia过载告警
+    // EV_IBGZ,					// Ib过载告警
+    // EV_ICGZ,					// Ic过载告警
+    EV_DLYX, // 负荷越限告警
+    // EV_IAYX,					// Ia越限告警
+    // EV_IBYX,					// Ib越限告警
+    // EV_ICYX,					// ic越限告警
+    EV_I0YX,   // 零序电流越限告警
+    EV_TZFAIL, // 跳闸失败
+    EV_HZFAIL, // 合闸失败
+    EV_SWFAIL, // 开关拒动
+
+    EV_TWYL, // 跳位有流告警
+
+    EV_BH_YB,       // 保护投入软压板
+    EV_BH_YBTT,     // 常规保护投入
+    EV_CHZ_YB,      // 自动重合闸投入
+    EV_FA_YBTT,     // 就地型馈线自动化投入
+    EV_GOOSE_YBTT,  // 智能分布式投入
+    EV_JZS_YBTT,    // 集中式投入
+    EV_TQ_YBTT,     // 同期合闸投入
+    EV_JL_YBTT,     // 自动解列投入
+    EV_XDLJD_YBTT,  // 小电流接地保护投入
+    EV_XLDXGJ_YBTT, // 线路断线告警投入
+    EV_BTDCD_YBTT,  // 不停电传动投入
+
+    EV_KZ_YB,   // 保护出口投入软压板
+    EV_EDIT_YB, // 远程运维软压板
+
+    EV_LX_XDL_QD, // 小电流接地启动
+    EV_XDL_U0GJ1, // 小电流零压1告警
+    EV_XDL_U0GJ2, // 小电流零压2告警
+    EV_ABC_JDTZ,  // 接地故障总
+    EV_A_JDTZ,    // A项接地
+    EV_B_JDTZ,    // B项接地
+    EV_C_JDTZ,    // C项接地
+#if defined FUN_JDXX
+    EV_JDXX_GJ,   // 小电流接地区内告警
+    EV_JDXX_TZ,   // 小电流接地区内跳闸
+    EV_JDXX_JWGZ, // 小电流接地区外故障
+#elif defined XDL_ZT
+    EV_LX_XDL_TZ, // 小电流接地动作
+    EV_LX_XDL_GJ, // 小电流接地告警
 #endif
 
 #ifdef YB_STHD_CHECK
-    EV_FUNALL_CHECK,            //功能总
-    EV_CHZ_CHECK,               //重合闸
-    EV_GOOSE_CHECK,             //分布式
-    EV_FA_CHECK,                //FA
-    EV_BH_CHECK,                //保护
+    EV_FUNALL_CHECK, // 功能总压板不一致
+    EV_CHZ_CHECK,    // 重合闸压板不一致
+    EV_GOOSE_CHECK,  // 分布式压板不一致
+    EV_FA_CHECK,     // 就地FA压板不一致
+    EV_BH_CHECK,     // 常规保护压板不一致
 #endif
-	EV_TH_WCN,					// 弹簧未储能
-	EV_KZHL,					// 控制回路异常
-	EV_GOOSE_BGN,			// 从goose 来的故障信息
-	EV_GOOSE_END=EV_GOOSE_BGN+GOOSE_RECV_LOGIC_NUM,  //
-	EV_CTYC,					//CT状态
-	EV_CTXXYC,					//CT 相序异常
-
-	EV_FA_LL_EN,				//自转电功能投入
-	EV_GOOSE_LL_UNOK,
-	EV_GOOSE_GZBS_FA,
-	EV_GOOSE_TZBS_FA,
-	EV_FA_U0GJ,					// FA零序电压告警
+
+    EV_TH_WCN,                                          // 未储能告警
+    EV_KZHL,                                            // 控制回路异常
+    EV_GOOSE_BGN,                                       // 从goose 来的故障信息
+    EV_GOOSE_END = EV_GOOSE_BGN + GOOSE_RECV_LOGIC_NUM, // 从goose 来的故障信息
+
+    EV_CTYC,   // CT断线
+    EV_CTXXYC, // CT相序异常
+
+    EV_FA_LL_EN,      // 自转电功能投入
+    EV_GOOSE_LL_UNOK, // 分布式供电恢复未满足
+    EV_GOOSE_GZBS_FA, // 分布式故障闭锁合闸
+    EV_GOOSE_TZBS_FA, // 分布式分闸闭锁合闸
+    EV_FA_U0GJ,       // 合后零序电压告警
 #ifdef FUNC_DRIVE
-	EV_DRIVE,		//不停电传动功能软压板
-	EV_DRIVE_BEGIN, 	//不停电传动开始
-	EV_DRIVE_TZ_FAIL,		//不停电传动跳闸失败
-	EV_DRIVE_HZ_FAIL,		//不停电传动合闸失败
+    EV_DRIVE,         // 不停电传动功能软压板
+    EV_DRIVE_BEGIN,   // 不停电传动开始
+    EV_DRIVE_TZ_FAIL, // 不停电传动跳闸失败
+    EV_DRIVE_HZ_FAIL, // 不停电传动合闸失败
 #endif
 
 #ifdef FUNC_DRIVE_JY
-	EV_DRIVE_FAIL,		//不停电传动启动失败
-	EV_DRIVE_SUCESS,	//不停电传动成功
-	EV_DRIVE_TZ_FAIL,		//不停电传动开关拒分
-	EV_DRIVE_HZ_FAIL,		//不停电传动开关拒合
-	EV_DRIVE_TT_ERR,		//不停电传动投退异常
-	EV_DRIVE_ADD_HZ,		//传动补发合闸
-	EV_DRIVE_END,		//不停电传动结束
+    EV_DRIVE_FAIL,    // 不停电传动启动失败
+    EV_DRIVE_SUCESS,  // 不停电传动成功
+    EV_DRIVE_TZ_FAIL, // 不停电传动开关拒分
+    EV_DRIVE_HZ_FAIL, // 不停电传动开关拒合
+    EV_DRIVE_TT_ERR,  // 不停电传动投退异常
+    EV_DRIVE_ADD_HZ,  // 传动补发合闸
+    EV_DRIVE_END,     // 不停电传动结束
 #endif
 #ifdef FUNC_YL_FZ_SOE
-	EV_YL_FZ,		//联络Y闭锁
+    EV_YL_FZ, // 联络Y闭锁
 #endif
-	EV_SW_NUM,					//
-};  
+
+#ifdef CUSTOMIZE_BZT // 备自投
+    EV_ZT_TZ1,       // 1#开关自投跳闸
+    EV_ZT_TZ2,       // 2#开关自投跳闸
+    EV_ZT_TZ3,       // 3#开关自投跳闸
+
+    EV_ZT_HZ1, // 1#开关自投合闸
+    EV_ZT_HZ2, // 2#开关自投合闸
+    EV_ZT_HZ3, // 3#开关自投合闸
+
+    EV_BZT_TZ1_FAIL, // 1#开关跳闸失败
+    EV_BZT_TZ2_FAIL, // 2#开关跳闸失败
+    EV_BZT_TZ3_FAIL, // 3#开关跳闸失败
+
+    EV_BZT_HZ1_FAIL, // 1#开关合闸失败
+    EV_BZT_HZ2_FAIL, // 2#开关合闸失败
+    EV_BZT_HZ3_FAIL, // 3#开关合闸失败
+#endif
+
+    EV_SW_NUM, //
+};
 enum
 {
-	EV_PUB_START=EV_SW_NUM*SWITCH_NUM_MAX,
-	EV_UAB1GDY=EV_PUB_START,	// UAB1越上限
-	EV_UBC1GDY,				// UBC1越上限
-	EV_UCA1GDY,				// UCA1越上限
-	EV_UAB1DDY,				// UAB1越下限
-	EV_UBC1DDY,				// UBC1越下限
-	EV_UCA1DDY,				// UCA1越下限
-	EV_UAB2GDY,				// UAB2越上限
-	EV_UBC2GDY,				// UBC2越上限
-	EV_UCA2GDY,				// UCA2越上限
-	EV_UAB2DDY,				// UAB2越下限
-	EV_UBC2DDY,				// UBC2越下限
-	EV_UCA2DDY,				// UCA2越下限
-	EV_POW1YY,				// PT1有压
-	EV_POW2YY,				// PT2有压
-	EV_POW1WY,			    // PT1无压
-	EV_POW2WY,			    // PT2无压
-	EV_DYSTATUS,				//电源模块状态
+    EV_PUB_START = EV_SW_NUM * SWITCH_NUM_MAX,
+    EV_UAB1GDY = EV_PUB_START, // Uab1过电压告警
+    EV_UBC1GDY,                // UBC1过电压告警
+    EV_UCA1GDY,                // UCA1过电压告警
+    EV_UAB1DDY,                // UAB1低电压告警
+    EV_UBC1DDY,                // UBC1低电压告警
+    EV_UCA1DDY,                // UCA1低电压告警
+    EV_UAB2GDY,                // UAB2过电压告警
+    EV_UBC2GDY,                // UBC2过电压告警
+    EV_UCA2GDY,                // UCA2过电压告警
+    EV_UAB2DDY,                // UAB2低电压告警
+    EV_UBC2DDY,                // UBC2低电压告警
+    EV_UCA2DDY,                // UCA2低电压告警
+    EV_POW1YY,                 // A侧有压
+    EV_POW2YY,                 // B侧有压
+    EV_POW1WY,                 // A侧无压
+    EV_POW2WY,                 // B侧无压
+
+    EV_DYSTATUS, // 电源模块状态
 #ifdef BATTERY_WITH_COMM
-	#ifdef FUNC_SEL_BAT_MODULE	
-		EV_BAT_OVER_GJ,				// 电池过压告警	
-		EV_BAT_OFFLINE, 				//电池离线告警	
-		EV_BAT_REVERSE, 				//电池反接告警		
-		EV_AC_BACKLOST, 				// 备用输入交流失电    
-		EV_RL_ERR,						//电池容量故障
-	#endif
-	EV_BAT_ACT,					// 电池活化状态	
-	EV_AC_LOST,					// 输入交流失电信号
+    #ifdef FUNC_SEL_BAT_MODULE
+    EV_BAT_OVER_GJ, // 电池过压告警
+    EV_BAT_OFFLINE, // 电池离线告警
+    EV_BAT_REVERSE, // 电池反接告警
+    EV_AC_BACKLOST, // 备用输入交流失电
+    EV_RL_ERR,      // 电池容量故障
+    #endif
+    EV_BAT_ACT, // 电池活化状态
+    EV_AC_LOST, // 输入交流失电信号
 #endif
-	EV_PT1ERR,
-	EV_PT2ERR,	
-	EV_PT1XXYC,
-	EV_PT2XXYC,	
-	EV_BATERR,					// 电池异常告警，电池欠压
-	EV_BAT_OVER,				// 电池过压
-	EV_DC1DDY,				// DC1低电压
-	EV_DC2DDY,				// DC2低电压
-#ifdef	CUSTOMIZE_BZT //备自投	
-	EV_SYTZ,				//公共失压分闸
+    EV_PT1ERR,  // PT1断线
+    EV_PT2ERR,  // PT2断线
+    EV_PT1XXYC, // PT1相序异常
+    EV_PT2XXYC, // PT2相序异常
+
+    EV_BATERR,       // 电池电压低
+    EV_BAT_OVER,     // 电池电压高
+    EV_DC1DDY,       // DC1低电压告警
+    EV_DC2DDY,       // DC2低电压告警
+#ifdef CUSTOMIZE_BZT // 备自投
+    EV_SYTZ,         // 公共失压分闸
 #endif
 
 #ifdef METERING_ENERGY
-	EV_DD_CLR,				// 电度清零
-	EV_DD_DIR,				// 潮流改变次数
+    EV_DD_CLR, // 电度清零
+    EV_DD_DIR, // 潮流改变次数
 #endif
 
-	EV_BOARDERR,				// 分板错误报警
-	EV_BOARDCOMM,				// 分板通信异常
-
-	EV_HMIERR,					// 面板通信错误
+    EV_BOARDERR,  // 板卡故障
+    EV_BOARDCOMM, // 板卡通信异常
+    EV_HMIERR,    // 面板通信异常
 
 #if defined CAN_SLAVE_BOARD && defined METERING_ENERGY
-	EV_CAN_METERING_ERR,		// 线损通信异常
+    EV_CAN_METERING_ERR, // 线损通信异常
 #endif
 
-	EV_EQU_ERR_HW,				// 装置硬件故障
-	EV_EQU_ERR_SW,				// 装置软件故障
-	EV_GOOSE_ERR,			// 系统通信异常	
-	EV_GOOSE_DECODE,			// goose 解码错误
-	EV_SYS_GOOSE_ERR,			// 系统通信异常	
-	EV_61850_ERR,			//  61850平台库异常
+    EV_EQU_ERR_HW,    // 装置硬件故障
+    EV_EQU_ERR_SW,    // 装置软件故障
+    EV_GOOSE_ERR,     // 系统通信异常
+    EV_GOOSE_DECODE,  // 本机goose通信异常
+    EV_SYS_GOOSE_ERR, // goose数据异常
+    EV_61850_ERR,     // 61850平台库异常
 #ifdef GOOSE_NETTYPE_SET
-	EV_NET1_DOWN,			//单网通讯异常NET1
-	EV_NET2_DOWN,			//单网通讯异常NET2
-	EV_GOOSE_ERR_N,			//N侧通讯异常
-	EV_GOOSE_ERR_M,			//M侧通讯异常
-	EV_GOOSE_NETTYPE_ERR,       //Goose网络类型设置错误
+    EV_NET1_DOWN,         // 单网通讯异常NET1
+    EV_NET2_DOWN,         // 单网通讯异常NET2
+    EV_GOOSE_ERR_N,       // N侧通讯异常
+    EV_GOOSE_ERR_M,       // M侧通讯异常
+    EV_GOOSE_NETTYPE_ERR, // Goose网络类型设置错误
 #endif
+
 #ifdef GD_AREA_ZHONGSHAN_2020
-	EV_GOOSE_CONFIG_ERR, 		// goose 配置异常
+    EV_GO
+        OSE_CONFIG_ERR, // goose 配置异常
 #endif
-	FAULT_ALL,					//事故总
-	EV_TT_BAT,				//电池自动活化
-	EV_BAT_ON,				//电池投入
-	EV_FDL1_TZ,
-	EV_FDL2_TZ,
-	EV_FDL3_TZ,
-	EV_FDL4_TZ,
-	EV_FDL5_TZ,
-	EV_FDL6_TZ,
-	EV_FDL7_TZ,
-	EV_FDL8_TZ,
-	EV_FDL1_GJ,
-	EV_FDL2_GJ,
-	EV_FDL3_GJ,
-	EV_FDL4_GJ,
-	EV_FDL5_GJ,
-	EV_FDL6_GJ,
-	EV_FDL7_GJ,
-	EV_FDL8_GJ,
-	EV_COMM1_ERR,			//通信端口1异常
-	EV_COMM2_ERR,
-	EV_COMM3_ERR,
-	EV_COMM4_ERR,
-	EV_COMM5_ERR,			
-	EV_COMM6_ERR,			
-	EX_NET1_ERR,			//网口1通信异常
-	EX_NET2_ERR,			//网口2通信异常
-	EV_LINK_EQU1,
-	EV_LINK_EQU2,
-	EV_LINK_EQU3,
-	EV_LINK_EQU4,
-	EV_LINK_EQU5,
-	EV_LINK_EQU6,	
-	EV_LINK_EQU7,
-	EV_LINK_EQU8,
-	EV_LINK_EQU9,
-	EV_LINK_EQU10,			//CFG_LONK_EQU_SOE_NUM
-	EV_MB_HZ,
-	EV_MB_TZ,
-	EV_PUB_END,
-
-/*下面不需要上送后台的操作或提示类的信息*/
-
-	EV_POWER=EV_PUB_END,	//	装置上电
-	/*装置状态切换*/
-	EV_TEST,				//进入装置测试模式
-	EV_RUN,					//进入装置运行模式
-
-	/*通道校正记录*/
-	EV_CHNSJS,				//	通道手校成功
-	EV_ANGSJS,				//	角度手校成功
-	EV_CHNZJS,				//	幅值自校成功
-	/*遥控操作类*/
-	EV_YH_SELECT,			//遥控合闸选择成功
-	EV_YH_SELFAIL,          //遥控合闸选择失败
-	EV_YH_SELTOUT,			//遥控合闸选择超时
-	EV_YH_EXECT,			//遥控合闸执行成功
-	EV_YH_EXFAIL,			//遥控合闸执行失败
-	EV_YH_EXCANCEL,         //遥控合闸执行取消
-		
-	EV_YT_SELECT,			//遥控跳闸选择成功
-	EV_YT_SELFAIL,			//遥控跳闸选择失败
-	EV_YT_SELTOUT,			//遥控跳闸选择超时
-	EV_YT_EXECT,			//遥控跳闸执行成功
-	EV_YT_EXFAIL,			//遥控跳闸执行失败
-	EV_YT_EXCANCEL,         //遥控跳闸执行取消
-
-	EV_PLC_HZ,				// PLC 合输出
-	EV_PLC_TZ,				// PLC 跳输出
-	
-	EV_HAND_HZ,
-	EV_HAND_TZ,
-	EV_433M_HZ,
-	EV_433M_TZ,
-	EV_PDA_HZ,
-	EV_PDA_TZ,	
-	EV_MSG_HZ,
-	EV_MSG_TZ,
-
-	EV_BAT_AUTOACTIVE,
-	EV_BAT_HANDACTIVE,
-	EV_BAT_HANDACTOFF,	
-	EV_BAT_HANDOFF,
-	
-	/*定值操作类*/
-	EV_SET_OK,				//	定值整定成功
-	EV_SET_FAIL,			//	定值整定失败
-
-	EV_PUBSET_OK,				//	定值整定成功
-	EV_PUBSET_FAIL,			//	定值整定失败
-	EV_YBSET_OK,				//	定值整定成功
-	EV_YBSET_FAIL,			//	定值整定失败
-
-
-	/*内部定值操作类*/
-	EV_CSTSET_OK,			//	内部定值整定成功
-	EV_CSTSET_FAIL,		//	内部定值整定失败
-	EV_RTC_INIT,					//	RTC内存初始化
-	/*参数操作*/
-	EV_EQUPARA_OK,		//装置参数整定成功
-	EV_EQUPARA_FAIL,		//装置参数整定失败
-	EV_SIG_RESET,			//信号复归
-	EV_CLEAR_SOE,			//事件记录清除
-	EV_CLEAR_OPE,			//操作记录清除
-	EV_INIT_EQUIP,			//出场设置
-	EV_WAVE_OV	,
-	EV_SET_CHANGE_PARA,
-#if defined(CPU_AM335X) 
-	EV_APP_FOLDER_RECOVER,		//恢复APP分区
+    FAULT_ALL,     // 事故总
+    EV_TT_BAT,     // 电池自动活化
+    EV_BAT_ON,     // 电池投入
+    EV_FDL1_TZ,    // 非电量1跳闸
+    EV_FDL2_TZ,    // 非电量2跳闸
+    EV_FDL3_TZ,    // 非电量3跳闸
+    EV_FDL4_TZ,    // 非电量4跳闸
+    EV_FDL5_TZ,    // 非电量5跳闸
+    EV_FDL6_TZ,    // 非电量6跳闸
+    EV_FDL1_GJ,    // 非电量1告警
+    EV_FDL2_GJ,    // 非电量2告警
+    EV_FDL3_GJ,    // 非电量3告警
+    EV_FDL4_GJ,    // 非电量4告警
+    EV_FDL5_GJ,    // 非电量5告警
+    EV_FDL6_GJ,    // 非电量6告警
+    EV_COMM1_ERR,  // 串口1通信异常
+    EV_COMM2_ERR,  // 串口2通信异常
+    EV_COMM3_ERR,  // 串口3通信异常
+    EV_COMM4_ERR,  // 串口4通信异常
+    EV_COMM5_ERR,  // 串口5通信异常
+    EV_COMM6_ERR,  // 串口6通信异常
+    EX_NET1_ERR,   // 网口1通信异常
+    EX_NET2_ERR,   // 网口2通信异常
+    EV_LINK_EQU1,  // 级联装置1异常
+    EV_LINK_EQU2,  // 级联装置2异常
+    EV_LINK_EQU3,  // 级联装置3异常
+    EV_LINK_EQU4,  // 级联装置4异常
+    EV_LINK_EQU5,  // 级联装置5异常
+    EV_LINK_EQU6,  // 级联装置6异常
+    EV_LINK_EQU7,  // 级联装置7异常
+    EV_LINK_EQU8,  // 级联装置8异常
+    EV_LINK_EQU9,  // 级联装置9异常
+    EV_LINK_EQU10, // 级联装置10异常
+    EV_MB_HZ,      // 面板合闸
+    EV_MB_TZ,      // 面板分闸
+    EV_PUB_END,
+
+
+    /*下面不需要上送后台的操作或提示类的信息*/
+
+    EV_POWER = EV_PUB_END, // 装置上电
+    /*装置状态切换*/
+    EV_TEST, // 进入测试模式
+    EV_RUN,  // 进入运行模式
+
+    /*通道校正记录*/
+    EV_CHNSJS, // 通道手校成功
+    EV_ANGSJS, // 角度手校成功
+    EV_CHNZJS, // 幅值自校成功
+
+    /*遥控操作类*/
+    EV_YH_SELECT,   // 遥控合闸预置成功
+    EV_YH_SELFAIL,  // 遥控合闸预置失败
+    EV_YH_SELTOUT,  // 遥控合闸预置超时
+    EV_YH_EXECT,    // 遥控合闸执行成功
+    EV_YH_EXFAIL,   // 遥控合闸执行失败
+    EV_YH_EXCANCEL, // 遥控合闸终止
+
+    EV_YT_SELECT,   // 遥控跳闸预置成功
+    EV_YT_SELFAIL,  // 遥控跳闸预置失败
+    EV_YT_SELTOUT,  // 遥控跳闸预置超时
+    EV_YT_EXECT,    // 遥控跳闸执行成功
+    EV_YT_EXFAIL,   // 遥控跳闸执行失败
+    EV_YT_EXCANCEL, // 遥控分闸终止
+
+    EV_PLC_HZ, // PLC合
+    EV_PLC_TZ, // PLC跳
+
+    EV_HAND_HZ, // 手动合闸
+    EV_HAND_TZ, // 手动分闸
+    EV_433M_HZ, // 无线遥控合闸
+    EV_433M_TZ, // 无线遥控分闸
+    EV_PDA_HZ,  // PDA遥控合闸
+    EV_PDA_TZ,  // PDA遥控分闸
+    EV_MSG_HZ,  // 短信合闸
+    EV_MSG_TZ,  // 短信分闸
+
+    EV_BAT_AUTOACTIVE, // 电池自动活化
+    EV_BAT_HANDACTIVE, // 电池活化启动
+    EV_BAT_HANDACTOFF, // 电池活化退出
+    EV_BAT_HANDOFF,    // 电池手动退出
+
+    /*定值操作类*/
+    EV_SET_OK,      // 定值整定成功
+    EV_SET_FAIL,    // 定值整定失败
+    EV_PUBSET_OK,   // 公共定值整定成功
+    EV_PUBSET_FAIL, // 公共定值整定失败
+    EV_YBSET_OK,    // 软压板整定成功
+    EV_YBSET_FAIL,  // 软压板整定失败
+    EV_CSTSET_OK,   // 内部定值整定成功
+    EV_CSTSET_FAIL, // 内部定值整定失败
+
+    EV_RTC_INIT, // RTC内存初始化
+    /*参数操作*/
+    EV_EQUPARA_OK,      // 装置参数整定成功
+    EV_EQUPARA_FAIL,    // 装置参数整定失败
+    EV_SIG_RESET,       // 信号复归
+    EV_CLEAR_SOE,       // 事件记录清除
+    EV_CLEAR_OPE,       // 操作记录清除
+    EV_INIT_EQUIP,      // 恢复出厂设置
+    EV_WAVE_OV,         // 录波溢出
+    EV_SET_CHANGE_PARA, // 定值修改
+#if defined(CPU_AM335X)
+    EV_APP_FOLDER_RECOVER, // 恢复APP分区
 #endif
-	EV_NUMBER
+    EV_NUMBER
 };
 #define EV_NUMBER_WORDS (EV_NUMBER/32+1)
 

dtu/dtu_main_t536/app/FA.c

@@ -860,8 +860,8 @@ void fa_s_Dataset(int sw, DWORD  dStep)
 	RunTR(&pSW->tGZJYRstGL_II_Time, bgl&&!xbQD2,dStep);  //跳闸位置、超过故障记忆过流复归时间，清跳闸次数
 	pSW->uSdhz_S.bFlag.bGL_II=pSW->uSdhz_L.bFlag.bGL_II = pSW->tGZJYRstGL_II_Time.boolTrip && !xbQD2;//时间&&谐波含量
 	pR->tOC[FA_GL_II].sta.bFlag.bQD = bgl;	// add xxxxxx 20220705 需要置上启动标志，否则会启动后马上进入整组复归
-#ifdef GD_AREA_ECZD_2020
-		gl_start_soe_set( bgl,sw,EV_FA_GL2_START);
+#ifdef EV_GL_STATR
+    gl_start_soe_set( bgl,sw,EV_FA_GL2_START);
 #endif
 #else
 	pSW->uSdhz_S.bFlag.bGL_II=pSW->uSdhz_L.bFlag.bGL_II=0;

dtu/dtu_main_t536/app/IEC101.c

@@ -1010,11 +1010,11 @@ static bool IEC101_GetYc(IEC101_DEF *pt)
 				{
 					if((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
 					{
-						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt1_two;
+						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->a_pt_two;
 					}
 					else if((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
 					{
-						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt2_two;
+						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->b_pt_two;
 					}
 				}
 			}
@@ -1624,11 +1624,11 @@ static void IEC101_CallAll(IEC101_DEF *pt,u8 QOI)		//ȷ
 					{
 						if((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
 						{
-							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt1_two;
+							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->a_pt_two;
 						}
 						else if((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
 						{
-							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt2_two;
+							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->b_pt_two;
 						}
 					}
 				}

dtu/dtu_main_t536/app/IEC101_FILE.c

@@ -107,13 +107,9 @@ struct file_item g_file_item[] =
 	{"F308_HMI.bin",	"/tmp/", 		ATTR_UP|ATTR_DOWN,	FILETYPE_F308_HMI, 	_file_save_app},
 	{"DTU-DIDO.elf.bin",	"/tmp/", 	ATTR_UP|ATTR_DOWN,	FILETYPE_CHILDPRO, 	_file_save_app},	
 	{"changelog.txt", 	"/app/", 		ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app},
-#ifdef CPU_AM335X
-	{"335x_m", 			"/app/", 		ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app},
-#else
 	{"m", 				"/app/", 		ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app},
-#endif
-//	{"acfactor.bin", 	"/app/data/", 	ATTR_UP,			FILETYPE_OTHER, 	_file_save_app},
-//	{"dcfactor.bin", 	"/app/data/", 	ATTR_UP,			FILETYPE_OTHER, 	_file_save_app},
+	// {"acfactor.bin", 	"/app/data/", 	ATTR_UP,			FILETYPE_OTHER, 	_file_save_app},
+	// {"dcfactor.bin", 	"/app/data/", 	ATTR_UP,			FILETYPE_OTHER, 	_file_save_app},
 	{"hzk.bin", 		"/app/data/", 	ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app},
 	{"vol_status.bin", 	"/app/data/", 	ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app},
 	{"sm2key0.bin", 	"/app/data/", 	ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app},

dtu/dtu_main_t536/app/IEC104.c

@@ -1348,11 +1348,11 @@ static void IEC104_CallAll(IEC104_DEF *pt104,BYTE QOI)
 					{
 						if((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
 						{
-							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt1_two;
+							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->a_pt_two;
 						}
 						else if((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
 						{
-							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt2_two;
+							ff.ff=((float)lmeaval)/f_65536*10/pRunSet->b_pt_two;
 						}
 					}
 				}
@@ -2225,11 +2225,11 @@ void IEC104_SendYC(IEC104_DEF *pt104)
 				{
 					if((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
 					{
-						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt1_two;
+						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->a_pt_two;
 					}
 					else if((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
 					{
-						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->pt2_two;
+						ff.ff=((float)lmeaval)/f_65536*10/pRunSet->b_pt_two;
 					}
 				}
 			}

dtu/dtu_main_t536/app/IECComm.c

@@ -372,6 +372,7 @@ void IEC_CommInit(void)                     //
 		{
 			IEC104_Init_RS((IEC104_DEF *)g_tRsComm[i].ptBuf,i);
 		}
+#if !defined CPU_FUXI
 		else if(tRunPara.tUartPara[i].wProtocol == PROTOCOL_HMI)  // 面板规约
 		{
 			uart_comm_init((UART_COMM_STRUCT *)g_tRsComm[i].ptBuf, i);
@@ -380,6 +381,7 @@ void IEC_CommInit(void)                     //
 		{
 			FaultComm_Init((IEC101_DEF *)g_tRsComm[i].ptBuf,i);
 		}
+#endif
 		else if(tRunPara.tUartPara[i].wProtocol==PROTOCOL_MODBUS) //  modbus主站规约
 		{
 			modbus_Init((MODBUS_DEF *)g_tRsComm[i].ptBuf,i);
@@ -455,12 +457,14 @@ void IEC_CommInit(void)                     //
 #endif		
 		}
 
+#if !defined CPU_FUXI
 		//串口打开后，再初始化
 		if(tRunPara.tUartPara[i].wProtocol == PROTOCOL_HMI)  // 面板规约
 		{
 			g_h_boj[0].fd = UART_CHANNEL[i];
 			user_conf_init(); //用户配置初始化(面板)
 		}
+#endif
 	}
 	
 	//回调函数
@@ -509,10 +513,12 @@ static void IEC_Recv(BYTE cDat,BYTE chnl)
 	{
 		IEC104_Recv((IEC104_DEF *)g_tRsComm[chnl].ptBuf,cDat);
 	}	
+#if !defined CPU_FUXI
 	else if(tRunPara.tUartPara[chnl].wProtocol==PROTOCOL_FAULT) // 状态板
 	{
 		FaultComm_Recv((IEC101_DEF *)g_tRsComm[chnl].ptBuf,cDat);
 	}		
+#endif
 	else if(tRunPara.tUartPara[chnl].wProtocol==PROTOCOL_MODBUS) //modbus主站规约
 	{
 		modbus_Recv((MODBUS_DEF *)g_tRsComm[chnl].ptBuf,cDat);
@@ -678,6 +684,7 @@ void IECCommTask(void)
 				commErrTab[i] = false;
 			}
 		}
+#if !defined CPU_FUXI
 		else if(tRunPara.tUartPara[i].wProtocol==PROTOCOL_HMI)  // 面板规约
 		{
 			Uart_Comm_Recv();
@@ -696,6 +703,7 @@ void IECCommTask(void)
 		{
 			FaultComm_Applay((IEC101_DEF *)g_tRsComm[i].ptBuf);		
 		}
+#endif
 		else if(tRunPara.tUartPara[i].wProtocol==PROTOCOL_MODBUS)  // modbus主站规约
 		{
 			modbus_Applay((MODBUS_DEF *)g_tRsComm[i].ptBuf);	
@@ -1752,7 +1760,7 @@ static int uart_isr_thread(void *arg)
 		}
 #endif
  
- 
+#if !defined CPU_FUXI
 		 //面板做特殊处理
 		 if(tRunPara.tUartPara[ch].wProtocol==PROTOCOL_HMI)
 		 {
@@ -1760,6 +1768,7 @@ static int uart_isr_thread(void *arg)
 			 protocol_proc_task(ch);
 			 continue;	 
 		 }
+#endif
  
 #if 1	
  //接收 start
@@ -2139,10 +2148,12 @@ static int uart_isr_thread(void *arg)
 					prc->nSendCnt = 0;
 					send_len = 0;
 					RS_Recv_Enable(ch);
+#if !defined CPU_FUXI
 					if(tRunPara.tUartPara[ch].wProtocol==PROTOCOL_HMI)
 					{
 						Reset_Uart_Link((UART_COMM_STRUCT *)g_tRsComm[ch].ptBuf);
 					}
+#endif
 					mainloop_wakeup();
 					prc->us0_send = ustimer_get_origin();//记录发送数据的时间戳	
 
@@ -2987,19 +2998,6 @@ bool selectRunParId(WORD sw, WORD parId, BYTE *pbuf)
 		//if(parTable > 0 && parTable < SW_SET_NUMBER)
 		{	
 			rt_printf("%s BhType=%d %d i=%d\r\n",tSwSetTable[parTable].szName,parId,SETGROUP_TYPE_BH,parTable);
-		#ifdef BH_FA_INONE_SW
-			if(0 == strcmp(tSwSetTable[parTable].szName,"保护/FA"))
-			{//判断“保护/FA”时需对主站送过来的值作减1运算以满足实际列表BHorFA_List里的值
-				if(((value-1)<=tSwSetTable[parTable].fMax) && ((value-1)>=tSwSetTable[parTable].fMin))
-					return true;
-				else
-				{
-					rt_printf("预置参数超范围，失败 par=%f parTable=%d			max=%f min%f\r\n",value,parTable,tSwSetTable[parTable].fMax,tSwSetTable[parTable].fMin);	
-					return false;
-				}
-			}
-			else
-		#endif
 			{
 				if(value<=tSwSetTable[parTable].fMax && value>=tSwSetTable[parTable].fMin)
 					return true;
@@ -3132,14 +3130,6 @@ bool wirteRunParId(WORD sw, WORD parId, BYTE *pbuf,u8 ti)
 			//if(parTable > 0 && parTable < SW_SET_NUMBER)
 			{
 				//rt_printf("%s ID=%x  i=%d\r\n",tSwSetTable[parTable].szName,parId,parTable);
-			#ifdef BH_FA_INONE_SW
-				if(0 == strcmp(tSwSetTable[parTable].szName,"保护/FA"))
-				{//判断“保护/FA”时需对主站送过来的值作减1运算以满足实际列表BHorFA_List里的值
-					parBuf[sw*parTable+PUB_SET_NUMBER].ff = (IECbuf2Foat(pbuf)-1);
-					rt_printf("wirteRunParId=%02x i=%d %f\r\n",parId,parTable,parBuf[sw*parTable+PUB_SET_NUMBER].ff);
-				}
-				else
-			#endif
 				{
 					parBuf[sw*parTable+PUB_SET_NUMBER].ff = IECbuf2Foat(pbuf);
 					rt_printf("wirteRunParId=%02x i=%d %f\r\n",parId,parTable,parBuf[sw*parTable+PUB_SET_NUMBER].ff);
@@ -3440,14 +3430,6 @@ bool readRunParId(WORD sw, WORD parId, BYTE *pbuf)
 		{
 			rt_printf("%s Type=%d %d i=%d\r\n",tSwSetTable[parTable].szName,parId,SETGROUP_TYPE_BH,parTable);
 			rt_printf("ReadRunParId=%02x swOffset=%d ,offset=%d par=%f\r\n",parId,parTable,parTable*sw+PUB_SET_NUMBER+PUB_SET_NUMBER,parBuf[parTable*sw+PUB_SET_NUMBER].ff);
-
-		#ifdef BH_FA_INONE_SW
-			if(0 == strcmp(tSwSetTable[parTable].szName,"保护/FA"))
-			{//5001 保护/FA定值上送时需主动加1，因为列表值是0/1/2，需送值为1/2/3
-				float2IECbuf(pbuf,(parBuf[sw*parTable+PUB_SET_NUMBER].ff) + (float)1);
-			}
-			else
-		#endif
 			{
 				float2IECbuf(pbuf,parBuf[sw*parTable+PUB_SET_NUMBER].ff);
 			}

dtu/dtu_main_t536/app/IECLINK.c

@@ -3846,13 +3846,8 @@ void lnk_test_file_trans(IECLINK_DEF *pt)
 	{
 		u8 dat[128];
 		int num=0;
-	#if defined(CPU_AM335X)	
-		char* ko_path ="/app/data/335x_dftu.ko";
-		char *filename="335x_dftu.ko";
-	#else
 		char* ko_path ="/app/data/dftu.ko"; 	
 		char *filename="dftu.ko";
-	#endif
 		int namelen=strlen(filename);
 		struct file *handle;
 		loff_t pos;

dtu/dtu_main_t536/app/LcdComm.c

@@ -309,6 +309,7 @@ void lcdcomm_init(void)
 	}
 }
 
+#if !defined CPU_FUXI
 /**************************************************************************
 函数名称：HMI_Comm_App
 函数版本：1.00 
@@ -417,6 +418,7 @@ void HMI_Comm_App(void)  /*10
 	_hmi_comm_send();	
 	#endif
 }
+#endif
 
 /**************************************************************************
 函数名称：Add_Continue_Data
@@ -1154,7 +1156,6 @@ static void _hmi_comm_send(void)
 			int i;
 			if(ustimer_delay_origin2(&us0_led,USTIMER_SEC/8))
 			{
-
 				for(i=0;i<CFG_UART_NUM_MAX*2+CFG_ETH_NUM_MAX;i++)
 				{
 					if(g_run_stu.led[i])  // 232 1TX

dtu/dtu_main_t536/app/Maintain.c

@@ -405,14 +405,9 @@ void Maintain_Applay(void)
 	{
 		alive_us1 = ustimer_get_origin();
 
-#if defined (CPU_AM335X) || (defined CPU_FUXI)	
 		//noted by sunxi: 目前维护工具为每30秒发1条心跳，如果漏1条，就已经是60秒了。
 		//这样很容易出问题，应该是发3条心跳，1条都没有收到才被认为有问题才合理。100秒可有3条心跳了。
-		//需要这里加了宏CPU_AM335X，但是所有平台都应该改为100秒。
 		if(alive_us1 - alive_us0 > 100*USTIMER_SEC) //   100秒循环检查
-#else		
-		if(alive_us1 - alive_us0 > 60*USTIMER_SEC)
-#endif
 		{			
 			bMaintain=false;
 		}

dtu/dtu_main_t536/app/MmiData.c

@@ -412,24 +412,12 @@ bool mmd_checkset_yb(u8 index)  //
 		{
 			return g_tRelay[sw].run_stu.bhtt||yb_fa_g;
 		}
-	}	
-	if(yb==SET_HYB_JL)
-	{
-		if(group_sub == GROUP_SET_DYJL)
-		{
-			return (g_tRelay[sw].run_stu.bhtt)||yb_fa_g;
-		}
-		else
-		{
-			return g_tRelay[sw].run_stu.bhtt||yb_fa_g;
-		}
 	}
 #endif
 
 	if(yb==SET_HYB_BH)
 	{
-		if((group_sub == GROUP_SET_DYJL)
-			||(group_sub == GROUP_SET_PLJL))
+		if (group_sub == GROUP_SET_JLTT)
 		{
 			return g_tRelay[sw].run_stu.bhtt||yb_fa_g;
 		}
@@ -1915,12 +1903,12 @@ int mmd_ChangeYBSet(const TSETTABLE *pSet,int num,SET_VALUE *setbuf) //ext为
 		if (pSet[i].wType != SETTYPE_LABEL) 
 		{
 			//xj 2019.10.21
-			if(pSet[i].group==GROUP_SET_YB&&(g_tRelay[sw].run_stu.bhtt==1 ||g_tRelay[sw].run_stu.fatt ||g_tRelay[sw].run_stu.fa_g_tt)&&(bPubSetMenuShow[i]>0))  // 定值分类组为0 或显示定制为1
-			{
-				g_set_disp.no[g_set_disp.num] = i;
-				g_set_disp.num++;
-			}
-		}		
+            if (pSet[i].group == GROUP_SET_YB_GN && (g_tRelay[sw].run_stu.bhtt == 1 || g_tRelay[sw].run_stu.fatt || g_tRelay[sw].run_stu.fa_g_tt) && (bPubSetMenuShow[i] > 0)) // 定值分类组为0 或显示定制为1
+            {
+                g_set_disp.no[g_set_disp.num] = i;
+                g_set_disp.num++;
+            }
+        }		
 	}
 	return g_set_disp.num;
 }
@@ -4176,8 +4164,8 @@ static void mmd_GetFtuMeaValue(int index,DATA_FIELD_DEF *pF)
 				case UNIT_Var:
 				case UNIT_kW:
 				case UNIT_kVar:
-					if(pRunSet->pt1_two)
-						lValue=(long)((float)lMeaVal[i]*(pRunSet->ct_one/pRunSet->ct_two*pRunSet->pt_rate/pRunSet->pt1_two));
+					if(pRunSet->a_pt_two)
+						lValue=(long)((float)lMeaVal[i]*(pRunSet->ct_one/pRunSet->ct_two*pRunSet->pt_rate/pRunSet->a_pt_two));
 					break;
 				default:
 					break;	
@@ -4191,12 +4179,10 @@ static void mmd_GetFtuMeaValue(int index,DATA_FIELD_DEF *pF)
 				case UNIT_V220:
 				case UNIT_kV:
 					//判断PT变比电源侧&&母线侧&&零序电压
-					if (strstr(g_pub_ac_desc[i].name,"U0"))
-						pt = pRunSet->pt_3U0;
-					else if(strchr(g_pub_ac_desc[i-SW_AC_MENU_NUM].name,'2'))
-						pt = pRunSet->pt2_two;
+					if(strchr(g_pub_ac_desc[i-SW_AC_MENU_NUM].name,'2'))
+						pt = pRunSet->b_pt_two;
 					else
-						pt = pRunSet->pt1_two;
+						pt = pRunSet->a_pt_two;
 					if(pt)
 						lValue=(long)((float)lMeaVal[i]*(pRunSet->pt_rate/pt));
 					break;
@@ -4407,7 +4393,7 @@ static void mmd_GetFtuYxValue(int i,DATA_FIELD_DEF *pF)
 	    (ecd->owner!=0 && (!TQ_ALL_EN(0))))//同期压板	
 		strcpy(tmpstr,YX_F);	
 
-    #if defined BHFAGS_YB_YK || defined GD_AREA_ZHONGSHAN || defined GD_AREA_ECZD_2020
+    #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ECZD_2020
 		if((SW_DI_BHTT+1==ecd->type && ecd->owner!=0 && (!BH_ALL_EN(0)))||//常规保护压板
 			(SW_DI_FA_TT+1==ecd->type && ecd->owner!=0 && (!FA_ALL_EN(0)))||//FA压板
 			(SW_DI_FA_GOOSE+1==ecd->type && ecd->owner!=0 && (!BH_GOOSE_EN(0))))//智能分布式压板	
@@ -6318,11 +6304,11 @@ double GetYdYcValue(int i)
 			{
 				if((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
 				{
-					ff=((double)lmeaval)/f_65536*10/pRunSet->pt1_two;
+					ff=((double)lmeaval)/f_65536*10/pRunSet->a_pt_two;
 				}
 				else if((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
 				{
-					ff=((double)lmeaval)/f_65536*10/pRunSet->pt2_two;
+					ff=((double)lmeaval)/f_65536*10/pRunSet->b_pt_two;
 				}
 			}
 		}

dtu/dtu_main_t536/app/SOE.c

@@ -37,9 +37,7 @@ static EVENT_SAVE g_soe_sbuf[SOE_SAVE_BUF_NUM]; // SOE
 #ifdef ADD_DEBUG_RECORD_AUTO_SHOW_FUN
 const u16 ExecuteEventIdTbl[]={EV_GL1TZ,EV_GL2TZ,EV_GL3TZ,
                                EV_LX1TZ,EV_LX2TZ,
-                            #ifdef DISP_SET_LX3
-	                           EV_LX3TZ,			
-                            #endif
+	                           EV_LX3TZ,
                                EV_GLJS,EV_LXJS,EV_FA_GL_TZ,	
                             #if defined GD_AREA_ECZD_2020
 	                           EV_FA_GL_TZ2,

dtu/dtu_main_t536/app/Sys.c

@@ -260,7 +260,9 @@ void SystemInit(void)
 	filelist_createfile();
 	//esam_init();
 	FA_Init();	
+#if !defined CPU_FUXI /* 不支持这个lcd lch 2025年12月18日16:38:52 */
 	lcdcomm_init();
+#endif
 	ReadUqua();
 	fa_g_init();
 #ifdef METERING_ENERGY
@@ -314,7 +316,7 @@ void app_yb_refresh(void)
         // EV_BH_YB (功能总)
         fresh_set_soe(EV_BH_YB, FUN_ALL_EN(sw), 0,sw);
 
-#if defined BHFAGS_YB_YK || defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020
+#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020
         // EV_GOOSE_YBTT/EV_FA_YBTT/EV_BH_YBTT (goose/fa/bh)
         fresh_set_soe(EV_BH_YBTT, BH_ALL_EN(sw), 0,sw);
         fresh_set_soe(EV_FA_YBTT, FA_ALL_EN(sw), 0,sw);
@@ -358,7 +360,7 @@ void app_yb_refresh(void)
 				soe_record_ev(EV_CHZ_CHECK+sw*EV_SW_NUM, 0, 0,0,0);
 			}
 		}		 
-		#if defined BHFAGS_YB_YK ||	defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
+		#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
 			//GOOSE
 			if(((short)g_sw[sw].di_cfg_index[SW_DI_FA_GOOSE] != INDEX_INVALLID)&&(pRunSet->bTT_SOFT_GOOSE_YB != g_tRelay[sw].run_stu.fa_g_tt))
 			{
@@ -637,33 +639,28 @@ void SignalReset(int rstsw,bool blnk)
 		bGJRst = true;
 
 		if(rstsw>0&&((sw+1)!=rstsw))continue;
-		for(i=BH_GL1;i<=FA_DLBS;i++)
-		{
-			TOC_T *poc = &g_tRelay[sw].tOC[i];
-			if(poc->sta.bFlag.bGj||poc->sta.bFlag.bTz)
-			{
-				if(poc->sta.bFlag.bGj)
-					bGJRst = false;
-				bRst=false;
-				if(i==BH_GL1||i==BH_GL2||i==BH_GL3||i==BH_GLJS||i==FA_GL||i==FA_GL2||i==FA_DLBS||i==FA_GL_II)
-				{
-					bGLRst = false;
-				}
-			#ifdef DISP_SET_LX3
-				if(i==BH_LX1||i==BH_LX2||i==BH_LX3||i==BH_GLJS||i==FA_LX||i==FA_LX2)
-			#else				
-				if(i==BH_LX1||i==BH_LX2||i==BH_GLJS||i==FA_LX||i==FA_LX2)
-			#endif
-				{
-					bJDRst = false;
-				}
-			}
-			else
-			{
-				poc->sta.bFlag.bDzLed=false;
-			}
-
-		}
+        for (i = BH_GL1; i <= FA_DLBS; i++)
+        {
+            TOC_T *poc = &g_tRelay[sw].tOC[i];
+            if (poc->sta.bFlag.bGj || poc->sta.bFlag.bTz)
+            {
+                if (poc->sta.bFlag.bGj)
+                    bGJRst = false;
+                bRst = false;
+                if (i == BH_GL1 || i == BH_GL2 || i == BH_GL3 || i == BH_GLJS || i == FA_GL || i == FA_GL2 || i == FA_DLBS || i == FA_GL_II)
+                {
+                    bGLRst = false;
+                }
+                if (i == BH_LX1 || i == BH_LX2 || i == BH_LX3 || i == BH_GLJS || i == FA_LX || i == FA_LX2)
+                {
+                    bJDRst = false;
+                }
+            }
+            else
+            {
+                poc->sta.bFlag.bDzLed = false;
+            }
+        }
 #ifdef GD_AREA_ZHONGSHAN_2020
 		for(i=FAG_GL1;i<=FAG_LX;i++)
 		{
@@ -942,57 +939,55 @@ g_RmtCtrl_ErrCode[err_code];
 //遥控修改软压板判断
 bool ykEditYb(BYTE ykTypeNo)
 {
-	switch(ykTypeNo-1)
-	{
-		case PUB_CHYB_HZ:
-		case PUB_CHYB_FZ:
-		case PUB_BHYB_HZ:
-		case PUB_BHYB_FZ:
-		case PUB_KZYB_HZ:
-		case PUB_KZYB_FZ:
-			
-	#if (defined BHFA_YB_YK || defined BHFAGS_YB_YK) && !defined BH_FA_INONE_SW
-		case PUB_BHYBTT_HZ:		// 虚遥控，常规保护投退合闸压板(线路保护投停&&保护投入软压板)
-		case PUB_BHYBTT_FZ:		// 虚遥控，常规保护投退分闸压板(线路保护投停&&保护投入软压板)
-		case PUB_FAYBTT_HZ:		// 虚遥控，FA保护投退合闸压板(线路保护投停&&保护投入软压板)
-		case PUB_FAYBTT_FZ:		// 虚遥控，FA保护投退分闸压板(线路保护投停&&保护投入软压板)
-		#ifdef BHFAGS_YB_YK
-		case PUB_GOOSEYBTT_HZ:	// 虚遥控，goose保护投退合闸压板(线路保护投停&&保护投入软压板)
-		case PUB_GOOSEYBTT_FZ:	// 虚遥控，goose保护投退分闸压板(线路保护投停&&保护投入软压板)
-		#endif
-	#endif
+    switch (ykTypeNo - 1)
+    {
+    case PUB_CHYB_HZ:
+    case PUB_CHYB_FZ:
+    case PUB_BHYB_HZ:
+    case PUB_BHYB_FZ:
+    case PUB_KZYB_HZ:
+    case PUB_KZYB_FZ:
+
+#ifdef BHFA_YB_YK
+    case PUB_BHYBTT_HZ:    // 虚遥控，常规保护投退合闸压板(线路保护投停&&保护投入软压板)
+    case PUB_BHYBTT_FZ:    // 虚遥控，常规保护投退分闸压板(线路保护投停&&保护投入软压板)
+    case PUB_FAYBTT_HZ:    // 虚遥控，FA保护投退合闸压板(线路保护投停&&保护投入软压板)
+    case PUB_FAYBTT_FZ:    // 虚遥控，FA保护投退分闸压板(线路保护投停&&保护投入软压板)
+    case PUB_GOOSEYBTT_HZ: // 虚遥控，goose保护投退合闸压板(线路保护投停&&保护投入软压板)
+    case PUB_GOOSEYBTT_FZ: // 虚遥控，goose保护投退分闸压板(线路保护投停&&保护投入软压板)
+#endif
 
-		case PUB_TQ_YB_HZ:	//虚遥控，同期合闸软压板
-		case PUB_TQ_YB_FZ:	//虚遥控，同期合闸软压板
-		case PUB_JZS_YB_HZ:
-		case PUB_JZS_YB_FZ:
-	
-	#ifdef YK_SOFT_YB
-		case PUB_YK_YB_HZ:	//虚遥控，遥控软压板
-		case PUB_YK_YB_FZ:	//虚遥控，遥控软压板
-	#endif
+    case PUB_TQ_YB_HZ: // 虚遥控，同期合闸软压板
+    case PUB_TQ_YB_FZ: // 虚遥控，同期合闸软压板
+    case PUB_JZS_YB_HZ:
+    case PUB_JZS_YB_FZ:
 
-	#ifdef YK_FA_ENBLE
-		case PUB_YK_BS_FA_HZ:	//	"FA遥控闭锁-合",
-		case PUB_YK_BS_FA_FZ:
-	#endif
-	#ifdef YK_FA_S_L_ENBLE
-		case PUB_YK_FA_S_L_HZ:	//	"分段/联络-合",
-		case PUB_YK_FA_S_L_FZ:	//	"分段/联络-分",
-	#endif
+#ifdef YK_SOFT_YB
+    case PUB_YK_YB_HZ: // 虚遥控，遥控软压板
+    case PUB_YK_YB_FZ: // 虚遥控，遥控软压板
+#endif
 
-    case PUB_JL_YB_HZ:  //虚遥控，停用自动解列软压板
-    case PUB_JL_YB_FZ:  //虚遥控，停用自动解列软压板
+#ifdef YK_FA_ENBLE
+    case PUB_YK_BS_FA_HZ: //	"FA遥控闭锁-合",
+    case PUB_YK_BS_FA_FZ:
+#endif
+#ifdef YK_FA_S_L_ENBLE
+    case PUB_YK_FA_S_L_HZ: //	"分段/联络-合",
+    case PUB_YK_FA_S_L_FZ: //	"分段/联络-分",
+#endif
 
-	#ifdef FUNC_DRIVE
-		case PUB_DRIVE_YB_ON:	//虚遥控，不停电传动软压板投入
-		case PUB_DRIVE_YB_OFF:	//虚遥控，不停电传动软压板退出
-	#endif
-            return TRUE;    //当前遥控修改软压板
+    case PUB_JL_YB_HZ: // 虚遥控，停用自动解列软压板
+    case PUB_JL_YB_FZ: // 虚遥控，停用自动解列软压板
 
-		default:
-			return FALSE;
-	}
+#ifdef FUNC_DRIVE
+    case PUB_DRIVE_YB_ON:  // 虚遥控，不停电传动软压板投入
+    case PUB_DRIVE_YB_OFF: // 虚遥控，不停电传动软压板退出
+#endif
+        return TRUE; // 当前遥控修改软压板
+
+    default:
+        return FALSE;
+    }
 }
 
 static bool yk_pub_yb(int no)
@@ -1004,14 +999,14 @@ static bool yk_pub_yb(int no)
     	case PUB_BHYB_FZ:
     	case PUB_KZYB_HZ:
     	case PUB_KZYB_FZ:
-	#if defined BHFAGS_YB_YK && !defined BH_FA_INONE_SW
+    #ifdef BHFA_YB_YK
     	case PUB_BHYBTT_HZ:
     	case PUB_BHYBTT_FZ:
     	case PUB_FAYBTT_HZ:
     	case PUB_FAYBTT_FZ:
     	case PUB_GOOSEYBTT_HZ:
     	case PUB_GOOSEYBTT_FZ:
-	#endif
+    #endif
     	case PUB_JL_YB_HZ:
     	case PUB_JL_YB_FZ:
     	case PUB_TQ_YB_HZ:
@@ -1600,7 +1595,7 @@ int _RemoteCtrl(BYTE yktype,BYTE index,BYTE ykval,WORD wID)
                     setno=SET_KZ_OUT_YB;
                     val=1;
                 }
-#if (defined BHFA_YB_YK || defined BHFAGS_YB_YK) && !defined BH_FA_INONE_SW
+#if (defined BHFA_YB_YK)
                 else if(no==PUB_BHYBTT_FZ+1)
                 {
                     setno=SET_BH_YBTT;
@@ -1621,7 +1616,6 @@ int _RemoteCtrl(BYTE yktype,BYTE index,BYTE ykval,WORD wID)
                     setno=SET_FA_YBTT;
                     val=1;
                 }
-			#ifdef BHFAGS_YB_YK
                 else if(no==PUB_GOOSEYBTT_FZ+1)
                 {
                     setno=SET_GOOSE_YBTT;
@@ -1632,7 +1626,6 @@ int _RemoteCtrl(BYTE yktype,BYTE index,BYTE ykval,WORD wID)
                     setno=SET_GOOSE_YBTT;
                     val=1;
                 }
-			#endif
 #endif
                 else if(no==PUB_TQ_YB_FZ+1)
                 {
@@ -1716,12 +1709,12 @@ int _RemoteCtrl(BYTE yktype,BYTE index,BYTE ykval,WORD wID)
             #ifdef FUNC_DRIVE
 			   else if(no==PUB_DRIVE_YB_ON+1)
 			   {
-				   setno=SET_DRIVE;
+				   setno=SET_TRASW_YB;
 				   val=1;
 			   }
 			   else if(no==PUB_DRIVE_YB_OFF+1)
 			   {
-				   setno=SET_DRIVE;
+				   setno=SET_TRASW_YB;
 				   val=0;
 			   }
 			#endif
@@ -1732,9 +1725,7 @@ int _RemoteCtrl(BYTE yktype,BYTE index,BYTE ykval,WORD wID)
                 }
 #ifdef GD_AREA_ECZD_2020//二次指导意见开始将公共软压板放到公共定值
                 /*if((no == PUB_BHYB_HZ+1) || (no ==PUB_BHYB_FZ+1)||(no == PUB_KZYB_HZ+1) || (no ==PUB_KZYB_FZ+1)
-#if defined BHFAGS_YB_YK && !defined BH_FA_INONE_SW
                    ||(no==PUB_BHYBTT_HZ+1)||(no==PUB_BHYBTT_FZ+1)||(no == PUB_FAYBTT_HZ+1) || (no ==PUB_FAYBTT_FZ+1)||(no == PUB_GOOSEYBTT_HZ+1) || (no ==PUB_GOOSEYBTT_FZ+1)
-#endif
 				  ||(no == PUB_JL_YB_HZ+1) || (no ==PUB_JL_YB_FZ+1)
                    ||(no == PUB_TQ_YB_HZ+1) || (no ==PUB_TQ_YB_FZ+1)
                   )   //公共定值*/

dtu/dtu_main_t536/app/Sys.h

@@ -222,6 +222,7 @@ typedef struct YK_DRIVE
 	bool bHz_Doing;				//传动功能合闸中
 	bool bQuit;					//退出传动软压板标志
 	bool b_drive_process;		//传动功能进行中
+    DWORD sw;                   //开关
 	#ifdef FUNC_DRIVE_PULSE
 		bool b_set_pulse;		//设置分合闸脉宽标志
 		bool b_unset_pulse;		//恢复分合闸脉宽标志

dtu/dtu_main_t536/app/UnitsLib.c

@@ -170,11 +170,9 @@ void ProtectRelayInit(void)
 		InitTR(&pR->tCHZ.tTCHJBSHw,			T_100ms,	0);           // 开关合位100ms确认
 
 	#ifdef PRO_UZ_START_REC
-		InitTR(&pR->tCHZ.tTCH_UO_BS,		T_100ms, 0   );           //；零序电压重合闭锁延时
-	#endif
-	#ifdef FUN_CHZ_TOPEN
-		InitTR(&pR->tCHZ.tTCHOPENTime,		pSet->dT_chz_Topen, 0   );           //；重合开放时间
+		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); 
@@ -386,7 +384,7 @@ void ProtectRelayInit(void)
 
 		fresh_set_soe(EV_BH_YB, FUN_ALL_EN(sw), true,sw);
 	   	
-	#if defined BHFAGS_YB_YK ||	defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020
+	#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020
 		fresh_set_soe(EV_BH_YBTT, BH_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);			
@@ -578,9 +576,7 @@ void ProtectRelayInit1(void)
 	#ifdef PRO_UZ_START_REC
 		InitTR(&pR->tCHZ.tTCH_UO_BS,		 T_100ms, 0   );			// 零序电压重合闭锁延时
 	#endif
-	#ifdef FUN_CHZ_TOPEN
-		InitTR(&pR->tCHZ.tTCHOPENTime, 	 pSet->dT_chz_Topen, 0	 ); 		  //；重合开放时间
-	#endif
+		InitTR(&pR->tCHZ.tTCHOPENTime, 	 pSet->dT_chz_Topen, 0	 ); 		  // 重合开放时间
 		
 		 //配网功能定值
 		InitTR_Time(&pR->tSDHZ.tOnXSTime, pSet->dT_X,0);

dtu/dtu_main_t536/app/bzt.c

@@ -60,9 +60,7 @@ void OC_FaultEventClear(int sw)
 	pro_rst_event(sw, EV_GL3TZ);
 	pro_rst_event(sw, EV_LX1TZ);
 	pro_rst_event(sw, EV_LX2TZ);
-#ifdef DISP_SET_LX3
 	pro_rst_event(sw, EV_LX3TZ);
-#endif
 	
 //	pro_rst_event(sw, EV_FA_GLTZ);
 //	pro_rst_event(sw, EV_FA_LXTZ);

dtu/dtu_main_t536/app/defineSys.h

@@ -12,15 +12,13 @@
 #ifndef _DEFINE_SYS_H
 #define _DEFINE_SYS_H
 
-#define DEVICE_VERSION_INFORMATION "NW24_20251212_001" // NW2022意思是按照22年南网标准文件（总调）来做的
+#define DEVICE_VERSION_INFORMATION "NW24_20251218_008" // NW2022意思是按照22年南网标准文件（总调）来做的
 
 #ifdef ___defineSys____//！！！此宏定义不开启，以下宏不直接开启，只用于注释显示
 
 //需要的时候打开宏重新编译
 #define DISP_SET_CH_T3       // 维护工具&&液晶显示重合闸三次
 #define DISP_MEA_CN          // 液晶遥测名称显示中文
-#define DISP_SET_LX3         // 维护工具&&液晶显示零序三段定值&时间
-#define DISP_SET_DLYX        // 电流越限告警
 
 #define SOE_PARA_ALL_SAVE              // soe 全参数处理有效
 #define SOE_RECORD_DELAY               // SOE延迟保存
@@ -28,7 +26,6 @@
 #define COMM_STATION_NR                // 定义南瑞主站适应模式
 #define IECTABLE_NEWDPI_V106           // 转发表配合工具完成合并点和遥信单双点配合版本  0X01010106
 #define BHFA_YB_YK                     // 遥控保护和FA软压板投退
-#define BHFAGS_YB_YK                   // 保护、FA合goose软压板定值投退/SOE硬压板关联/遥控
 #define EV_GL_STATR                    // 过流启动SOE
 #define DISP_CHZOKCHR_2_SW             // 重合闸确认时间+充电时间移到开关定值
 #define YX_DI_ERROR                    // 遥信硬件自检错误
@@ -46,7 +43,6 @@
 #define YD_TEST_REALTIME_VALUE_DISPLAY // 远动测试遥信、遥测数据显示
 #define SEC_SETVALUE_4                 // 4个定值区
 #define SEC_SETVALUE_7                 // 7个定值区
-#define FUN_CHZ_TOPEN                  // 重合闸开放时间功能
 #define SW_FAIL_SINGLE_OUT             // 开关失灵
 #define DC_OLLECT_NOT_156US_LOOPC      // DC采样在非156us循环中使用
 #define ADD_DEBUG_RECORD_FUN           // 增加调试记录功能选项
@@ -55,7 +51,6 @@
 #define SW_AC_I0S_SAMPLE               // I0S电流采样
 #define FA_PL_PJ                       // FA频率判据(内部定值):频率在49~50.8Hz的频率才认为有效,可参与判得电
 #define YC_QUANTITY                    // 每间隔遥参数量可通过内部定值设定(内部定值)
-#define BH_FA_INONE_SW                 // 功能模块配置定值部分，主要特征为BH/FA/智能FA三合一(在开关定值中)
 #define VOLT_ADAPTIVE_FACTOR           // 电压系数自适应
 #define BATTERY_WITH_COMM              // 带通讯电源模块
 #define BATTERY_BP_L500			       // 无锡市欧瑞杰TX-BPL500W24D
@@ -64,7 +59,6 @@
 #define GEN_QUEUE                      // 录波相关
 #define RCD_STRAN_M                    /*录波传输*/
 #define RCD_STRAN_S                    /*录波传输*/
-#define INRUSH_CURRENT_IN_DECIMALS     // 涌流识别定值显示为小数并给主站送小数形式
 #define FUN_FUXI_ESAM                  // 南网加密芯片
 #define FUNC_GET_RD_ONLY               // lcd_menu可配置只读定值
 #define FUNC_YT_HARD_YB                // lcd_menu新增关键硬件遥信（如常规保护硬压板、FA硬压板等）
@@ -92,6 +86,7 @@
 #define PRO_AL_RESET_FA                // 解列动作复归FA
 #define PRO_PT_LL_NC                   // 非Fa联络 无压有流动作 PT断线告警
 #define FIXAREA_VERSION_T              // 定值区号版本2 待召唤定值区号、待执行定值区号
+#define PUB_SET_SECTION                // 定义之后公共定值在定值区概念里面管辖
 // #define TMP_CHIP_AHT20
 
 //定制功能
@@ -162,6 +157,9 @@
     #define FUNC_MORE_PRESET  // 支持遥调时多次预置,固化
     #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		    //开关失灵
 
 #elif defined GD_AREA_ZHONGSHAN	//中山局要求
  	#ifdef __IEC61850_GOOSE_FUNC__
@@ -175,7 +173,7 @@
 
 #elif defined GD_AREA_ZHONGSHAN_2020	//中山局2020要求
 	#define VER_NUM 				    30103			// 版本号30.101->30.103
-	#define PUB_SET_SECTION
+	#define PUB_SET_SECTION // 定义之后公共定值在定值区概念里面管辖
     #define ADD_DEBUG_RECORD_FUN    //增加调试记录功能选项
     #define ADD_DEBUG_RECORD_AUTO_SHOW_FUN    //增加调试记录功能自动显示功能
 	#define GEN_QUEUE	
@@ -192,28 +190,6 @@
 	#endif
 #endif
 
-#if (VER_NUM>=28101 && VER_NUM<50101)
-	#if (VER_NUM<29101)
-		#define BHFAGS_YB_YK                 //保护、FA合goose软压板定值投退/SOE硬压板关联/遥控
-	#elif ((VER_NUM>=29101) && (VER_NUM<32101))
-		#ifndef GD_AREA_ECZD_2020
-			#define GD_AREA_ECZD_2020	//广东2020二次指导意见框架宏
-		#endif
-		#define SEC_SETVALUE_5
-		#define FUN_CHZ_TOPEN
-	#elif (VER_NUM>=32101)
-		#define BHFAGS_YB_YK                 //保护、FA合goose软压板定值投退/SOE硬压板关联/遥控
-		#define FUN_JDXX					//小电流接地功能
-	#endif
-    #define YK_FA_S_L_ENBLE 	//分段联络遥控
-    #define DC_OLLECT_NOT_156US_LOOPC  //DC采样在非156us循环中使用
-#endif
-
-#if ((VER_NUM >= 29101) && (VER_NUM < 32101))// 2020广东配网终端二次功能指导意见 以后的版本都带以下功能
-	#define EV_GL_STATR			//过流启动SOE
-	#define SW_FAIL_SINGLE_OUT		//开关失灵
-#endif
-
 #ifdef __IEC61850_GOOSE_FUNC__
 	#if(((VER_NUM > 28209) && (VER_NUM <= 29201)) || (VER_NUM >= 31201))
 		#define YC_QUANTITY			//每间隔遥参数量可通过内部定值设定
@@ -251,7 +227,6 @@
 #define NW_AREA_MAIN_2021
 
 #define BATTERY_WITH_COMM		//带通讯电源模块
-#define BH_FA_INONE_SW			//功能模块配置定值部分，主要特征为BH/FA三合一(在开关定值中)
 #define YB_AUTO_SELECT			//在没配置硬压板的时自动选择软压板执行
 
 #endif /* _DEFINE_SYS_H */

dtu/dtu_main_t536/app/head.h

@@ -136,7 +136,6 @@
 #endif
 #include  "plc.h"
 #include "battery.h"
-#include "sxyb.h"
 #include "sntp.h"
 #include "FA_g.h"
 #include "CommPowerModule.h"

dtu/dtu_main_t536/app/history_file.c

@@ -401,11 +401,7 @@ END:
 */
 static char *  hf_get_wavefile_content(char * dir, int filename,  int part, int *p_part_len)
 {
-#ifdef CPU_AM335X
-	char* m_path = "/app/335x_m";
-#else
-	char* m_path = "/app/m";
-#endif		
+	char* m_path = "/app/m";	
 	char *p=NULL;
 	char *cmd_ls[] = {m_path,"ls", dir, HF_WAVE_TMP,  NULL};
 	char *envp[] = { NULL };
@@ -1006,11 +1002,7 @@ static int  hf_get_file_len(char *filename)
 */
 struct dir_file_struct * hf_get_dir_file(char *dir,  int *p_file_cnt)
 {
-#ifdef CPU_AM335X
-	char* m_path = "/app/335x_m";
-#else
 	char* m_path = "/app/m";
-#endif	
 #ifdef CPU_FUXI
 		char tmp[128];
 #endif
@@ -1247,11 +1239,7 @@ END:
 */
 int  hf_get_wavefile_len(char *dir,  int  file_name)
 {
-#ifdef CPU_AM335X
-	char* m_path = "/app/335x_m";
-#else
 	char* m_path = "/app/m";
-#endif
 	char *cmd_ls[] = {m_path,"ls", dir, HF_WAVE_TMP,  NULL};
 	char *envp[] = { NULL };
 	char tmp[128];
@@ -1728,11 +1716,7 @@ bool check_dir_enable(char *namestr)
 
 void hf_get_dir_file_ext_depth(char *dir,  int *p_file_cnt, char *tmpfile,struct dir_file_ext_struct *p_dfs)
 {
-#ifdef CPU_AM335X
-	char* m_path = "/app/335x_m";
-#else
 	char* m_path = "/app/m";
-#endif		
 	char *cmd_ls[] = {m_path,"ls", dir, tmpfile,	NULL};
 	
 	char *envp[] = { NULL };
@@ -1905,11 +1889,7 @@ struct dir_file_ext_struct * hf_get_dir_file_ext_all(char *dir,  int *p_file_cnt
 */
 struct dir_file_ext_struct * hf_get_dir_file_ext(char *dir,  int *p_file_cnt, char *tmpfile)
 {
-#ifdef CPU_AM335X
-		char* m_path = "/app/335x_m";
-#else
-		char* m_path = "/app/m";
-#endif
+    char* m_path = "/app/m";
 	char *cmd_ls[] = {m_path,"ls", dir, tmpfile,  NULL};
 	char *envp[] = { NULL };
 	struct dir_file_ext_struct * p_dfs=NULL;	

dtu/dtu_main_t536/app/iectable.c

@@ -169,6 +169,7 @@ int tbl_create_rsc(void)
 	memcpy(p,(char *)&fh,sizeof(fh));
 	
 	// д¹«¹²Ò£ÐÅ
+    printf("[%s:%d] fh.pub_di_num = %d\r\n", __func__, __LINE__, fh.pub_di_num);
 	for(i=0; i<fh.pub_di_num; i++)
 	{
 		memset(&disrc,0,sizeof(disrc));
@@ -221,6 +222,7 @@ int tbl_create_rsc(void)
 	}	
 
 	// д¿ª¹ØÒ£ÐÅ
+    printf("[%s:%d] fh.sw_di_num = %d\r\n", __func__, __LINE__, fh.sw_di_num);
 	for(i=0; i<fh.sw_di_num; i++)
 	{
 		memset(&disrc,0,sizeof(disrc));

dtu/dtu_main_t536/app/oc.c

@@ -98,9 +98,7 @@ bool pro_check_bh_all(int sw)
 	if(soe_check(EV_GL3TZ+sw*EV_SW_NUM)==true)return true;
 	if(soe_check(EV_LX1TZ+sw*EV_SW_NUM)==true)return true;
 	if(soe_check(EV_LX2TZ+sw*EV_SW_NUM)==true)return true;
-#ifdef DISP_SET_LX3
 	if(soe_check(EV_LX3TZ+sw*EV_SW_NUM)==true)return true;
-#endif
 
 	if(soe_check(EV_GLJS+sw*EV_SW_NUM)==true)return true;
 	if(soe_check(EV_LXJS+sw*EV_SW_NUM)==true)return true;
@@ -132,14 +130,10 @@ bool pro_check_lx_all(int sw)
 {
 	if(soe_check(EV_LX1GJ+sw*EV_SW_NUM)==true)return true;
 	if(soe_check(EV_LX2GJ+sw*EV_SW_NUM)==true)return true;
-#ifdef DISP_SET_LX3
 	if(soe_check(EV_LX3GJ+sw*EV_SW_NUM)==true)return true;
-#endif
 	if(soe_check(EV_LX1TZ+sw*EV_SW_NUM)==true)return true;
 	if(soe_check(EV_LX2TZ+sw*EV_SW_NUM)==true)return true;
-#ifdef DISP_SET_LX3
 	if(soe_check(EV_LX3TZ+sw*EV_SW_NUM)==true)return true;
-#endif
 
 	if(soe_check(EV_LXJS+sw*EV_SW_NUM)==true)return true;
 	if(soe_check(EV_FA_LX_TZ+sw*EV_SW_NUM)==true)return true;

dtu/dtu_main_t536/app/oc.h

@@ -56,34 +56,29 @@ typedef union UOCFLAG
 
 enum
 {
-	BH_GL1=0, 	// 过流1段
-	BH_GL2,		// 过流2段
-	BH_GL3,		// 过流3段
-	BH_LX1,		// 零序1段
-	BH_LX2,		// 零序2段
-#ifdef DISP_SET_LX3
-	BH_LX3,     // 零序3段
-#endif
-	BH_GLJS,	// 过流加速段
-	BH_LXJS,	// 零序加速段
-	FA_GL,
-	FA_GL_II,	//FA相间故障II段
-	FA_LX,      //FA零序故障
-	FA_GL2,		//FA相间告警
-
-	FA_LX2,     //FA零序告警
-	FA_DLBS,	//大电流闭锁
-	BH_DLBS,	//常规保护大电流闭锁
-#ifdef DISP_SET_DLYX
-	BH_OVI_ZZ,     //电流重载
-	BH_OVI_GZ,     //电流过载
-#endif
-	BH_OVI,      // 电流越限
-	BH_OVI0,	 // 零序电流越限
-	BHOC_NUMBER
+    BH_GL1 = 0, // 过流1段
+    BH_GL2,     // 过流2段
+    BH_GL3,     // 过流3段
+    BH_LX1,     // 零序1段
+    BH_LX2,     // 零序2段
+    BH_LX3,     // 零序3段
+    BH_GLJS,    // 过流加速段
+    BH_LXJS,    // 零序加速段
+    FA_GL,      // FA相间故障I段
+    FA_GL_II,   // FA相间故障II段
+    FA_LX,      // FA零序故障
+    FA_GL2,     // FA相间告警
+
+    FA_LX2,  // FA零序告警
+    FA_DLBS, // 大电流闭锁
+    BH_DLBS, // 常规保护大电流闭锁
+    BH_OVI_ZZ, // 电流重载
+    BH_OVI_GZ, // 电流过载
+    BH_OVI,  // 电流越限
+    BH_OVI0, // 零序电流越限
+    BHOC_NUMBER
 };
 
-
 typedef struct  TOC_T
 {
 	UOCFLAG        sta;			// 动作标志字

dtu/dtu_main_t536/app/protect.c

@@ -176,46 +176,46 @@ static void clear_func_drive(u32 dStep)
 //退出不停电传动功能软压板处理
 void quit_drive(void)
 {
-	SET_VALUE *parBuf;	// 定义定值查看及整定时的buf
+    SET_VALUE *parBuf; // 定义定值查看及整定时的buf
 
-	if(gb_drive.bQuit)
-	{
-		gb_drive.b_drive_on = false;
-		gb_drive.b_drive_soe = false;
-		gb_drive.b_drive_process = false;
-	#ifdef FUNC_DRIVE_PULSE
-		gb_drive.b_unset_pulse = true;
-		MakeRunPara( false, false);	//恢复合分闸脉冲原来的值
-		MakeRunSet(false);		//加入先设置一次所有定值的处理，避免提前return导致没恢复原定值内容
-	#endif
-		parBuf = rt_malloc(PUB_SET_NUMBER*4);
-	
-		if(!parBuf)
-		{
-			rt_free(parBuf);
-			rt_printf("\r\n退出不停电传动功能软压板时分配缓冲区出错!\r\n");
-			return;
-		}
-		
-		//不停电传动投入软压板置0
-		gb_drive.bQuit = false;
-		if(!ReadPara((void*)parBuf,EEP_PUB_ADDR+m_runsection*PUB_SETSIZE,PUB_SET_NUMBER,&tPubSetTable[0]))
-		{
-			rt_err_set(ERR_CODE_SET,0);
-			GetDefPara((void*)parBuf,PUB_SET_NUMBER,&tPubSetTable[0]);
-		}
-		
-		parBuf[SET_DRIVE].ff=0;
-		
-		if(SavePara((void*)parBuf,EEP_PUB_ADDR+m_runsection*PUB_SETSIZE,PUB_SET_NUMBER,&tPubSetTable[0]))
-		{
-			soe_record_opt(EV_YBSET_OK,0);
-			MakeRunSet(false);
-			rt_err_clr(ERR_CODE_SET,0);
-		}
+    if (gb_drive.bQuit)
+    {
+        gb_drive.b_drive_on = false;
+        gb_drive.b_drive_soe = false;
+        gb_drive.b_drive_process = false;
+#ifdef FUNC_DRIVE_PULSE
+        gb_drive.b_unset_pulse = true;
+        MakeRunPara(false, false); // 恢复合分闸脉冲原来的值
+        MakeRunSet(false);         // 加入先设置一次所有定值的处理，避免提前return导致没恢复原定值内容
+#endif
+        parBuf = rt_malloc(PUB_SET_NUMBER * 4);
 
-		rt_free(parBuf);
-	}
+        if (!parBuf)
+        {
+            rt_free(parBuf);
+            rt_printf("\r\n退出不停电传动功能软压板时分配缓冲区出错!\r\n");
+            return;
+        }
+
+        // 不停电传动投入软压板置0
+        gb_drive.bQuit = false;
+        if (!ReadPara((void *)parBuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
+        {
+            rt_err_set(ERR_CODE_SET, 0);
+            GetDefPara((void *)parBuf, PUB_SET_NUMBER, &tSwSetTable[0]);
+        }
+
+        parBuf[SET_XDL_YB + gb_drive.sw * SW_SET_NUMBER].ff = 0;
+
+        if (SavePara((void *)parBuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
+        {
+            soe_record_opt(EV_YBSET_OK, 0);
+            MakeRunSet(false);
+            rt_err_clr(ERR_CODE_SET, 0);
+        }
+
+        rt_free(parBuf);
+    }
 }
 #endif
 
@@ -378,10 +378,8 @@ int protect_polling(void)
 		_protect_rmt_sw(dTDelta);		// 遥控器，其手分或手合标志在其他保护逻辑中有使用，故放在最开始
 		XBCalc_goc(g_protect.sw);               // goose 谐波计算:处理标志:谐波闭锁动作		
 		// 电流轮巡类
-		#ifdef DISP_SET_DLYX
 		Pro_over_i(g_protect.sw,dTDelta,BH_OVI_ZZ,EV_DLZZ);	// 电流重载
 		Pro_over_i(g_protect.sw,dTDelta,BH_OVI_GZ,EV_DLGZ);		// 电流过载
-		#endif
 		Pro_over_i(g_protect.sw,dTDelta,BH_OVI,EV_DLYX);		// 电流越限
 		Pro_over_i0(g_protect.sw,dTDelta,BH_OVI0,EV_I0YX);		// 零序电流越限
 
@@ -754,11 +752,7 @@ static int _protect_amp_qd(u32  dStep)
 
 		if (bEn&& (pSet->bTz||pSet->bGj))
 		{
-		#ifdef DISP_SET_LX3
 			if(i==BH_LX1||i==BH_LX2||i==BH_LX3||i==BH_LXJS||i==FA_LX)
-		#else
-			if(i==BH_LX1||i==BH_LX2||i==BH_LXJS||i==FA_LX)
-		#endif
 			{
 				bY1 = OverRelay(g_ui[UI_SW_INDEX(sw,SW_AC_I0)].m2[0], pSet->dI, pSet->dI, false); 
 			}
@@ -1083,9 +1077,7 @@ static int _protect_gzcl_process(void)
 		Pro_OC(sw,dTGZDelta,BH_GL3,EV_GL3TZ);		
 		Pro_LX(sw,dTGZDelta,BH_LX1,EV_LX1TZ);
 		Pro_LX(sw,dTGZDelta,BH_LX2,EV_LX2TZ);
-		#ifdef DISP_SET_LX3
-			Pro_LX(sw,dTGZDelta,BH_LX3,EV_LX3TZ);
-		#endif
+        Pro_LX(sw,dTGZDelta,BH_LX3,EV_LX3TZ);
 		Pro_Accheck(sw,dTGZDelta,BH_GLJS,EV_GLJS);
 		Pro_Accheck(sw,dTGZDelta,BH_LXJS,EV_LXJS);
 	//	Pro_Accheck(sw,dTGZDelta,FA_GL,EV_FA_GL_TZ);
@@ -1878,6 +1870,7 @@ void sw_op_fail(DWORD     dStep)
 		gb_drive.b_drive_on = false;
 		gb_drive.b_drive_process = false;
 		gb_drive.bQuit = true;
+		gb_drive.sw  = sw;
 		ResetTR(&gb_drive.tQDTime_fz_end);
 		ResetTR(&gb_drive.tQDTime_hz_end);
 

dtu/dtu_main_t536/app/protect.h

@@ -214,7 +214,7 @@ typedef struct TRELAY_T  //
 
 	bool  bARSTFLT; //开关自动复归事故总202004
 
-	TFDL_T tFdl[8];	
+	TFDL_T tFdl[6];	
 	TOC_T 		tOC[BHOC_NUMBER];		// 过流保护相关
 	TCH_T 		tCHZ;				// 重合闸
 

dtu/dtu_main_t536/app/protocol.c

@@ -465,11 +465,7 @@ void protocol_proc_task(s8 chnl)
 				}
 				}
 			//如果数据发送完毕,则调整发送缓冲区的下标
-#if defined (CPU_AM335X) || defined (CPU_FUXI)
 			else
-#else	
-			else if(MCF_UART_USR(chnl) & MCF_UART_USR_TXEMP)
-#endif	
 			{
 				RS_Recv_Enable(chnl);
 				//调整发送缓冲区的下标

dtu/dtu_main_t536/app/reclose.c

@@ -197,9 +197,7 @@ static void AR_Disable(int sw)
 					       		|| pR->tOC[BH_GL3].sta.bFlag.bBSCH 		// 
 					       		|| pR->tOC[BH_LX1].sta.bFlag.bBSCH 		// 
 					       		|| pR->tOC[BH_LX2].sta.bFlag.bBSCH 		// 
-					       		#ifdef DISP_SET_LX3
 								|| pR->tOC[BH_LX3].sta.bFlag.bBSCH		// 
-								#endif
 					       		||pR->tLostVot.uLostVot.bFlag.bTz	// 失压跳闸闭锁重合
 			                    ||pR->tXXTZ.uZOV.bFlag.bTz
 			                #ifdef PRO_AL_LOCK_HZ
@@ -282,13 +280,11 @@ static void AR_Recharge(int sw,DWORD  dStep)
 						#endif
 							;
 	//放电清开放时间
-#ifdef FUN_CHZ_TOPEN 
 	if(pSW->sta.bFlag.bFDBZ)
 	{
 		pSW->sta.bFlag.bCHZOP=false;
 		ResetTR(&pSW->tTCHOPENTime);
 	}
-#endif	
 
 	if(pR->tSWST.uSWST.bFlag.bIBSCHZ&&pSW->sta.bFlag.bCDWC)
 	{
@@ -329,14 +325,11 @@ static void AR_Recharge(int sw,DWORD  dStep)
 		{				
 			soe_record_ev( EV_ARCD+sw*EV_SW_NUM,1, 0,0,0 ); 
 		}
-
-	#ifdef FUN_CHZ_TOPEN 
 		//终止重合返回
 		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);  // 终止重合闸过程				
 		}
-	#endif
 	}
 	else
 	{
@@ -438,7 +431,6 @@ static void AR_Start(int sw,DWORD  dStep)
 			soe_record_ev(EV_AR_START+sw*EV_SW_NUM,0 ,0,0,0);   
 		}
 	}
-#ifdef FUN_CHZ_TOPEN 
 	//重合开放计时		
 	pSW->sta.bFlag.bCHZOP = bCHQD_CHQD||pSW->sta.bFlag.bCHZOP;
 	RunTR(&pSW->tTCHOPENTime, pSW->sta.bFlag.bCHZOP, dStep);    //重合开放延时
@@ -463,7 +455,6 @@ static void AR_Start(int sw,DWORD  dStep)
 			soe_record_ev(EV_CHZ_TOPEN+sw*EV_SW_NUM, 1, 0,0,0);  // 终止重合闸过程				
 		}			
 	}
-#endif
 }
 
 /**************************************************************************
@@ -728,10 +719,8 @@ static void AR_Reset(int sw,DWORD  dStep)
 		ResetTR(&pSW->tTCHOKTime);
 		ResetTR(&pSW->tTCHBSDelay);		
 		ResetTR(&pSW->tTCHJBSTime);	//重合成功时间继电器，在重合出口后重新计数
-	#ifdef FUN_CHZ_TOPEN
 		pSW->sta.bFlag.bCHZOP=false;
 		ResetTR(&pSW->tTCHOPENTime);
-	#endif
 	}	
 	// 手动/自动复归条件:(1)重合闸闭锁(2)重合已启动，但充电标志已清零
 	if(g_tRelay[sw].run_stu.chzbs	//闭锁				

dtu/dtu_main_t536/app/reclose.h

@@ -42,10 +42,7 @@ typedef union UCHFLAG
 		DWORD   bMWYMZ:1; //母线无压条件满足
 		DWORD   bUWYMZ:1; //线路无压条件满足
 		DWORD   bCHMZ:1;	//重合闸条件满足(同期、无压或不判断)
-		
-    #ifdef FUN_CHZ_TOPEN 
 		DWORD	bCHZOP:1;   //重合闸开放时间标志
-	#endif
     }bFlag;
 }UCHFLAG;
 
@@ -79,9 +76,7 @@ typedef struct TCH_T
 #ifdef PRO_UZ_START_REC
 	TIMERELAY tTCH_UO_BS;				//零序电压闭锁确认时间
 #endif
-#ifdef FUN_CHZ_TOPEN
 	TIMERELAY tTCHOPENTime;             //重合闸开放时间
-#endif
 
 #ifdef PRO_AL_LOCK_HZ
 	CHZFALG CHZ_Judge_V_F;				//重合闸判电压、频率用

dtu/dtu_main_t536/app/record.c

@@ -1977,11 +1977,7 @@ int rcd_check_ok(u32 sw)
 */
 int rcd_get_list_name(void)
 {
-#ifdef CPU_AM335X
-	char* m_path = "/app/335x_m";
-#else
 	char* m_path = "/app/m";
-#endif
 	u32 len;
 	int i, loop;
 	u8 *buf;

dtu/dtu_main_t536/app/run_status.c

@@ -1136,9 +1136,7 @@ int app_action_result(void)
 		|| pR->tOC[BH_GL3].sta.bFlag.bGjLed
 		|| pR->tOC[BH_LX1].sta.bFlag.bGjLed
 		|| pR->tOC[BH_LX2].sta.bFlag.bGjLed
-		#ifdef DISP_SET_LX3
 		|| pR->tOC[BH_LX3].sta.bFlag.bGjLed
-		#endif
 		|| pR->tOC[FA_GL2].sta.bFlag.bGjLed
 		|| pR->tOC[FA_LX2].sta.bFlag.bGjLed
 		|| pR->tOVER_U0TZ.bU0GjLed
@@ -1156,9 +1154,7 @@ int app_action_result(void)
 #else 
            if(pR->tOC[BH_LX1].sta.bFlag.bGjLed
             || pR->tOC[BH_LX2].sta.bFlag.bGjLed
-#ifdef DISP_SET_LX3
             || pR->tOC[BH_LX3].sta.bFlag.bGjLed
-#endif
             || pR->tOC[FA_LX2].sta.bFlag.bGjLed
             || pR->tOVER_U0TZ.bU0GjLed
             || pR->tU0TZ.bU0GjLed)
@@ -1196,9 +1192,7 @@ int app_action_result(void)
 		// ±£»¤½ÓµØ
 		if (pR->tOC[BH_LX1].sta.bFlag.bDzLed
 			|| pR->tOC[BH_LX2].sta.bFlag.bDzLed
-			#ifdef DISP_SET_LX3
 			|| pR->tOC[BH_LX3].sta.bFlag.bDzLed
-			#endif
 			|| pR->tOC[BH_LXJS].sta.bFlag.bDzLed
 			|| pR->tOC[FA_LX].sta.bFlag.bDzLed
 			//|| pR->tOC[FA_LX2].sta.bFlag.bGj

dtu/dtu_main_t536/app/switch.c

@@ -376,8 +376,6 @@ const s8 *g_pub_di_name[PUB_DI_NUM] =
     "非电量4",
     "非电量5",
     "非电量6",
-    "非电量7",
-    "非电量8",
     "开入1",
     "开入2",
     "开入3",
@@ -420,7 +418,7 @@ const s8 * g_pub_do_name[PUB_DO_NUM] =
 #endif
 	"重合软压板合",
 	"重合软压板分",
-#if defined BHFA_YB_YK || defined BHFAGS_YB_YK
+#if defined BHFA_YB_YK
 	#if defined GD_AREA_ECZD_2020
 	"停用保护总软压板合",
 	"停用保护总软压板分",
@@ -430,16 +428,12 @@ const s8 * g_pub_do_name[PUB_DO_NUM] =
 	#endif	
 	"保护出口软压板合",
 	"保护出口软压板分",
-	#ifndef BH_FA_INONE_SW
 	"常规保护软压板合",
 	"常规保护软压板分",
 	"馈线自动化软压板合",
 	"馈线自动化软压板分",
-		#ifdef BHFAGS_YB_YK
-		"智能分布式软压板合",
-		"智能分布式软压板分",
-		#endif
-	#endif
+    "智能分布式软压板合",
+    "智能分布式软压板分",
 #else
     #if defined GD_AREA_ECZD_2020
 	"停用保护总软压板合",
@@ -4188,12 +4182,12 @@ int sw_get_chnl_ps(int index,bool prim)
 		else if(PUB_AC_UA2||PUB_AC_UB2||PUB_AC_UC2||PUB_AC_UAB2||PUB_AC_UBC2||PUB_AC_UCA2)
 		{	//采用PT2变比 dlj 2019-6-5
 			if(prim)return 10000;	
-			else return pRunSet->pt2_two;
+			else return pRunSet->b_pt_two;
 		}
 		else if(type<PUB_AC_NUM)
 		{
 			if(prim)return 10000;
-			else return pRunSet->pt1_two;
+			else return pRunSet->a_pt_two;
 		}
 	}
 	else

dtu/dtu_main_t536/app/switch.h

@@ -363,8 +363,6 @@ enum
     PUB_DI_FDL4,   // 非电量4
     PUB_DI_FDL5,   // 非电量5
     PUB_DI_FDL6,   // 非电量6
-    PUB_DI_FDL7,   // 非电量7
-    PUB_DI_FDL8,   // 非电量8
     PUB_DI_1,
     PUB_DI_2,
     PUB_DI_3,
@@ -409,21 +407,17 @@ enum
 #endif
 	PUB_CHYB_HZ,		// 虚遥控，重合闸压板
 	PUB_CHYB_FZ,		// 虚遥控，分闸压板	
-#if defined BHFA_YB_YK || defined BHFAGS_YB_YK
+#if defined BHFA_YB_YK
 	PUB_BHYB_HZ,		// 虚遥控，分闸压板
 	PUB_BHYB_FZ,		// 虚遥控，分闸压板
 	PUB_KZYB_HZ,		// 虚遥控，控制出口合闸压板(线路保护投停&&保护投入软压板)
 	PUB_KZYB_FZ,		// 虚遥控，控制出口分闸压板(线路保护投停&&保护投入软压板)
-	#ifndef BH_FA_INONE_SW
 	PUB_BHYBTT_HZ,		// 虚遥控，常规保护投退合闸压板(线路保护投停&&保护投入软压板)
 	PUB_BHYBTT_FZ,		// 虚遥控，常规保护投退分闸压板(线路保护投停&&保护投入软压板)
 	PUB_FAYBTT_HZ,		// 虚遥控，FA保护投退合闸压板(线路保护投停&&保护投入软压板)
 	PUB_FAYBTT_FZ,		// 虚遥控，FA保护投退分闸压板(线路保护投停&&保护投入软压板)
-		#ifdef BHFAGS_YB_YK
-		PUB_GOOSEYBTT_HZ,	// 虚遥控，goose保护投退合闸压板(线路保护投停&&保护投入软压板)
-		PUB_GOOSEYBTT_FZ,	// 虚遥控，goose保护投退分闸压板(线路保护投停&&保护投入软压板)
-		#endif
-	#endif
+    PUB_GOOSEYBTT_HZ,	// 虚遥控，goose保护投退合闸压板(线路保护投停&&保护投入软压板)
+    PUB_GOOSEYBTT_FZ,	// 虚遥控，goose保护投退分闸压板(线路保护投停&&保护投入软压板)
 #else
 	PUB_BHYB_HZ,		// 虚遥控，分闸压板
 	PUB_BHYB_FZ,		// 虚遥控，分闸压板
@@ -469,7 +463,7 @@ enum
 #ifdef FUNC_RESET_EQU
 	PUB_RESET_EQU,			//重启装置
 #endif
-	PUB_DO_NUM
+	PUB_DO_NUM,
 };
 
 // 公共类LED类型

dtu/dtu_main_t536/app/vol.c

@@ -1217,56 +1217,54 @@ void PT_Check(DWORD  dStep)
 
 void FDL_Check(DWORD    dStep)
 {
-	int i;
-	struct equ_config_di *ecd;	
-	
-	int sw=0;
-	for(i=0;i<8;i++)  //·ÇµçÁ¿ÌøÕ¢
-	{
-		bool byx=false;
-		TFDL_T*pFDL=&g_tRelay[sw].tFdl[i];
-		if ((short)g_sw_pub.di_cfg_index[PUB_DI_FDL1+i] != INDEX_INVALLID)	
-		{
-			ecd = &g_equ_config_di[g_sw_pub.di_cfg_index[PUB_DI_FDL1+i]];
-			byx = dido_di_is_on(ecd->slot,ecd->index);
-		}
-		pFDL->sta.bFlag.bQD=byx&&(pRunSet->bTT_FDLGj[i]||pRunSet->bTT_FDLTz[i]);
-		
-		RunTR(&pFDL->tFdlTime, pFDL->sta.bFlag.bQD, dStep);
+    int i;
+    struct equ_config_di *ecd;
+
+    int sw = 0;
+    for (i = 0; i < 6; i++) // ·ÇµçÁ¿ÌøÕ¢
+    {
+        bool byx = false;
+        TFDL_T *pFDL = &g_tRelay[sw].tFdl[i];
+        if ((short)g_sw_pub.di_cfg_index[PUB_DI_FDL1 + i] != INDEX_INVALLID)
+        {
+            ecd = &g_equ_config_di[g_sw_pub.di_cfg_index[PUB_DI_FDL1 + i]];
+            byx = dido_di_is_on(ecd->slot, ecd->index);
+        }
+        pFDL->sta.bFlag.bQD = byx && (pRunSet->bTT_FDLGj[i] || pRunSet->bTT_FDLTz[i]);
 
-		pFDL->sta.bFlag.bTz=pFDL->tFdlTime.boolTrip&&pRunSet->bTT_FDLTz[i];
-		pFDL->sta.bFlag.bGj=pFDL->tFdlTime.boolTrip&&pRunSet->bTT_FDLGj[i];
-		if(pFDL->sta.bFlag.bTz)
-		{
-			if(soe_check(EV_FDL1_TZ+i)==false)
-			{
-				soe_record_ev( EV_FDL1_TZ+i, 1, 0,0,0 ); 
-			}
-		}
-		else
-		{
-			if(soe_check(EV_FDL1_TZ+i)==true)
-			{
-				soe_record_ev( EV_FDL1_TZ+i, 0, 0,0,0 ); 
-			}
-
-		}
-		if(pFDL->sta.bFlag.bGj)
-		{
-			if(soe_check(EV_FDL1_GJ+i)==false)
-			{
-				soe_record_ev( EV_FDL1_GJ+i, 1, 0,0,0 ); 
-			}
-		}
-		else
-		{
-			if(soe_check(EV_FDL1_GJ+i)==true)
-			{
-				soe_record_ev( EV_FDL1_GJ+i, 0, 0,0,0 ); 
-			}
-		}
-	}
+        RunTR(&pFDL->tFdlTime, pFDL->sta.bFlag.bQD, dStep);
 
+        pFDL->sta.bFlag.bTz = pFDL->tFdlTime.boolTrip && pRunSet->bTT_FDLTz[i];
+        pFDL->sta.bFlag.bGj = pFDL->tFdlTime.boolTrip && pRunSet->bTT_FDLGj[i];
+        if (pFDL->sta.bFlag.bTz)
+        {
+            if (soe_check(EV_FDL1_TZ + i) == false)
+            {
+                soe_record_ev(EV_FDL1_TZ + i, 1, 0, 0, 0);
+            }
+        }
+        else
+        {
+            if (soe_check(EV_FDL1_TZ + i) == true)
+            {
+                soe_record_ev(EV_FDL1_TZ + i, 0, 0, 0, 0);
+            }
+        }
+        if (pFDL->sta.bFlag.bGj)
+        {
+            if (soe_check(EV_FDL1_GJ + i) == false)
+            {
+                soe_record_ev(EV_FDL1_GJ + i, 1, 0, 0, 0);
+            }
+        }
+        else
+        {
+            if (soe_check(EV_FDL1_GJ + i) == true)
+            {
+                soe_record_ev(EV_FDL1_GJ + i, 0, 0, 0, 0);
+            }
+        }
+    }
 }
 
 void Pro_3U0(int sw,DWORD  dStep)