配置RAR和7z文件使用Git LFS

.gitattributes

@@ -1 +1,3 @@
 *.zip filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text

TSCP/Makefile

@@ -20,77 +20,23 @@ LD = $(CC)
 
 #INCLUDES += -I/path/to/my/lib/include
 #INCLUDES += -I../mylib/public
-INCLUDES += -I ./src/APP \
+INCLUDES += -I ./src/commoncode/common \
-            -I ./src/APP/ciapp/2oo2 \
-            -I ./src/APP/ciapp/AllAutoReturn \
-            -I ./src/APP/ciapp/AutoReturn \
-            -I ./src/APP/ciapp/AutoRoute \
-            -I ./src/APP/ciapp/AxisAssert \
-            -I ./src/APP/ciapp/AxisSort \
-            -I ./src/APP/ciapp/CutoffPoint \
-            -I ./src/APP/ciapp/DataManage \
-            -I ./src/APP/ciapp/DebugPrint \
-            -I ./src/APP/ciapp/Deployment \
-            -I ./src/APP/ciapp/DiffLineDev \
-            -I ./src/APP/ciapp/EnvelopeManage \
-            -I ./src/APP/ciapp/ERROR \
-            -I ./src/APP/ciapp/ESB \
-            -I ./src/APP/ciapp/FloodGate \
-            -I ./src/APP/ciapp/Garagedoor \
-            -I ./src/APP/ciapp/HLHTMsgHead \
-            -I ./src/APP/ciapp/Indicator \
-            -I ./src/APP/ciapp/Initial \
-            -I ./src/APP/ciapp/InvadeSection \
-            -I ./src/APP/ciapp/IO \
-            -I ./src/APP/ciapp/LogicManage \
-            -I ./src/APP/ciapp/LogicProcess \
-            -I ./src/APP/ciapp/LogRecord \
-            -I ./src/APP/ciapp/Main \
-            -I ./src/APP/ciapp/Mask \
-            -I ./src/APP/ciapp/NonAutoReturn \
-            -I ./src/APP/ciapp/NonRoute \
-            -I ./src/APP/ciapp/Overlap \
-            -I ./src/APP/ciapp/ParsePack \
-            -I ./src/APP/ciapp/PSC \
-            -I ./src/APP/ciapp/PSD \
-            -I ./src/APP/ciapp/QueryFiles \
-            -I ./src/APP/ciapp/Relay \
-            -I ./src/APP/ciapp/RemoteRM \
-            -I ./src/APP/ciapp/ReverseCut \
-            -I ./src/APP/ciapp/ReverseRoute \
-            -I ./src/APP/ciapp/Route \
-            -I ./src/APP/ciapp/Section \
-            -I ./src/APP/ciapp/SectionStateProcess \
-            -I ./src/APP/ciapp/SGBJ \
-            -I ./src/APP/ciapp/Signal \
-            -I ./src/APP/ciapp/SPKS \
-            -I ./src/APP/ciapp/Switch \
-            -I ./src/APP/ciapp/System \
-            -I ./src/APP/ciapp/Train \
-            -I ./src/APP/ciapp/Transmit \
-            -I ./src/APP/ciapp/VirtualDevice \
-            -I ./src/APP/ciapp/WashMachine \
-			-I ./src/APP/ciapp/WLScreen \
-            -I ./src/APP/ciapp/WLBrake \
-            -I ./src/APP/PU13_integration_config \
-			-I ./src/commoncode/common \
             -I ./src/commoncode/commoncode_config_vxworks \
             -I ./src/dqu_common/dqu_idmap_common \
             -I ./src/dqu_common/dqu_emap_common \
             -I ./src/dqu_common/dqu_dfs_common \
             -I ./src/dqu_common/dqu_cbtc_common \
-            -I .\src\protocol\fsfb\common_dqu_fsfb \
-			-I .\src\protocol\fsfb\common_fsfb \
             -I .\src\protocol\protocol_cbtc\common_protocol_config \
             -I .\src\protocol\protocol_cbtc\common_dqu_protocol \
             -I .\src\protocol\protocol_cbtc\common_protocol \
+			-I .\src\protocol\protocol_cbtc\common_protocol_sfp_rsspi-config \
             -I .\src\protocol\redun_record_cbtc\common_dqu_rp \
             -I .\src\protocol\redun_record_cbtc\common_redun \
             -I .\src\protocol\redun_record_cbtc\common_redun_record_config \
             -I .\src\protocol\rsr_record_cbtc\common_dqu_rsr \
-            -I .\src\protocol\rsr_record_cbtc\common_rsr \
             -I .\src\protocol\rsr_record_cbtc\common_rsr\rssp \
             -I .\src\protocol\rsr_record_cbtc\common_rsr\sig \
+            -I .\src\protocol\rsr_record_cbtc\common_rsr \
             -I .\src\protocol\rsr_record_cbtc\common_rsr_record_config \
             -I .\src\protocol\rssp_record_cbtc1\common_dqu_rssp \
             -I .\src\protocol\rssp_record_cbtc1\common_rssp \
@@ -101,6 +47,8 @@ INCLUDES += -I ./src/APP \
             -I .\src\protocol\sfp_record_cbtc1\common_dqu_sfp \
             -I .\src\protocol\sfp_record_cbtc1\common_sfp \
             -I .\src\protocol\sfp_record_cbtc1\common_sfp_nr_config \
+            -I .\src\protocol\fsfb\common_dqu_fsfb \
+			-I .\src\protocol\fsfb\common_fsfb \
             -I ./src/DRV \
             -I ./src/MSCP \
             -I ./src/MSCP/CM \
@@ -109,6 +57,59 @@ INCLUDES += -I ./src/APP \
             -I ./src/MSCP/SFM \
             -I ./src/MSCP/PFM \
             -I ./src/MSCP_CFG \
+            -I ./src/APP \
+            -I ./src/APP/ciapp/2oo2 \
+            -I ./src/APP/ciapp/AllAutoReturn \
+            -I ./src/APP/ciapp/AutoReturn \
+            -I ./src/APP/ciapp/AutoRoute \
+            -I ./src/APP/ciapp/DataManage \
+            -I ./src/APP/ciapp/DebugPrint \
+            -I ./src/APP/ciapp/DiffLineDev \
+            -I ./src/APP/ciapp/ERROR \
+            -I ./src/APP/ciapp/ESB \
+            -I ./src/APP/ciapp/FloodGate \
+            -I ./src/APP/ciapp/Garagedoor \
+            -I ./src/APP/ciapp/HLHTMsgHead \
+            -I ./src/APP/ciapp/Indicator \
+            -I ./src/APP/ciapp/Initial \
+            -I ./src/APP/ciapp/InvadeSection \
+            -I ./src/APP/ciapp/IO \
+            -I ./src/APP/ciapp/LightTestButtonManage \
+            -I ./src/APP/ciapp/LogicManage \
+            -I ./src/APP/ciapp/LogicProcess \
+            -I ./src/APP/ciapp/LogRecord \
+            -I ./src/APP/ciapp/Main \
+            -I ./src/APP/ciapp/Mask \
+            -I ./src/APP/ciapp/NonRoute \
+            -I ./src/APP/ciapp/Overlap \
+            -I ./src/APP/ciapp/ParsePack \
+            -I ./src/APP/ciapp/PSC \
+            -I ./src/APP/ciapp/PSD \
+            -I ./src/APP/ciapp/QueryFiles \
+            -I ./src/APP/ciapp/Relay \
+            -I ./src/APP/ciapp/ReverseRoute \
+            -I ./src/APP/ciapp/Route \
+            -I ./src/APP/ciapp/Section \
+            -I ./src/APP/ciapp/Signal \
+            -I ./src/APP/ciapp/SPKS \
+            -I ./src/APP/ciapp/Switch \
+            -I ./src/APP/ciapp/System \
+            -I ./src/APP/ciapp/Transmit \
+            -I ./src/APP/ciapp/VirtualDevice \
+            -I ./src/APP/ciapp/WashMachine \
+            -I ./src/APP/PU13_integration_config \
+            -I ./src/APP/ciapp/AxisSort \
+            -I ./src/APP/ciapp/Train \
+            -I ./src/APP/ciapp/EnvelopeManage \
+            -I ./src/APP/ciapp/CutoffPoint \
+            -I ./src/APP/ciapp/SectionStateProcess \
+            -I ./src/APP/ciapp/AxisAssert \
+            -I ./src/APP/ciapp/ReverseCut \
+            -I ./src/APP/ciapp/WLScreen \
+            -I ./src/APP/ciapp/WLBrake \
+            -I ./src/APP/ciapp/RemoteRM \
+            -I ./src/APP/ciapp/NonAutoReturn \
+            -include stdarg.h
 
 #LIBS += -L/path/to/my/lib/$(PLATFORM)/usr/lib -lmylib
 #LIBS += -L../mylib/$(OUTPUT_DIR) -lmylib

TSCP/src/APP/APP_API.c

@@ -16,6 +16,10 @@
 static CM_UINT32 gFollowDataLen = 0u; /*应用跟随数据长度*/
 static CM_UINT8 gFollowData[MSCP_FOLLOW_BUFF_SIZE] = { 0 }; /*应用跟随数据*/
 
+static CM_UINT32 gCiRcFollowDataLen = 0u; /*CI-RC同步数据长度*/
+static CM_UINT8 gCiRcFollowData[MSCP_FOLLOW_BUFF_SIZE] = { 0 }; /*CI-RC同步数据*/
+
+extern UINT8 LocalCiId;                                                   /*系统配置文件中定义的联锁ID*/
 /* 内网安全通信配置参数，示例： */
 /* 内网安全通信配置参数，示例： */
 /*ATP、ATO、MMI间通信时,SFP协议使用的数据库数组:
@@ -25,14 +29,15 @@ static CM_UINT8 gFollowData[MSCP_FOLLOW_BUFF_SIZE] = { 0 }; /*应用跟随数据
 const CM_UINT8 g_SfpInnetParam[] =
 {
 
-	0,4,/*不同设备通信关系表记录个数*/
+	0,5,/*不同设备通信关系表记录个数*/
 		/*记录的格式如下:*/
 		/*                   发起方  发起方发送数据  发起方报文   发起方报文  发起方接收Ack          跟随方  跟随方发送数据  跟随方运行  跟随方报文  此通信关系中成功发送           */
 		/*                   设备类型    通信类型    发送周期长度   最大延时   报文最大延时差       设备类型    通信类型      周期长度    最大延时   一包数据所需最小周期数                               */
 		/*ZC->CI*/           0x22,       0x55,       0x01,0x1D,   0x01,0x1D,   0x01,0x1D,            0xff,   0x55,           0x00,0xC8,  0x00,0xC8,  0x02,
 		/*AOM->TIAS*/        0x15,       0x55,       0x00,0xC8,   0x00,0xC8,   0x00,0xC8,            0x03,   0x55,           0x00,0xC8,  0x00,0xC8,  0x02,
 		/*AOM->ATP*/         0x14,       0x55,       0x00,0xC8,   0x00,0xC8,   0x00,0xC8,            0x15,   0x55,           0x00,0xC8,  0x00,0xC8,  0x02,
-		/*主机->维护机*/   0xD9,       0x55,       0x01,0x2c,   0x01,0x2C,   0x01,0x2C,            0xf8,   0x55,           0x00,0xc8,  0x00,0xc8,  0x02,
+		/*RC主机->维护机*/   0xD9,       0x55,       0x01,0x2c,   0x01,0x2C,   0x01,0x2C,            0xf8,   0x55,           0x00,0xc8,  0x00,0xc8,  0x02,
+		/*CI主机->维护机*/   0xDE,       0x55,       0x01,0x2c,   0x01,0x2C,   0x01,0x2C,            0xf8,   0x55,           0x00,0xc8,  0x00,0xc8,  0x02,
 		0,2,/*相同设备通信关系表记录个数*/
 			/*记录的格式如下:*/
 			/*                   发起方  发起方      发起方发送数据  发起方报文  发起方报文 发起方接收Ack    跟随方  跟随方      跟随方发送数据  跟随方运行  跟随方报文  此通信关系中成功发送           */
@@ -185,6 +190,7 @@ ENUM_CM_RETURN APP_API_Init(OUT CM_UINT8 VitalBuf[200], OUT CM_UINT16* pVitalLen
 		MSCP_SetOutAtsVobcFunc(pReserveOutVobc);
 		pReserveInAts = SerialInVobcAtsFunc;
 		MSCP_SetInVobcAtsFunc(pReserveInAts);
+		MSCP_SetRCFollowUpFunc(SetCiGeneralData);
 #if 1
 		cSwtichFalg = GetCiFunctionSwitchConfig(FUNC_OC_200_INOUTNET);
 
@@ -224,11 +230,65 @@ void APP_API_Data_Init()
 	UINT16 ii = 0U;
 	UINT8 szFSFILEVersionFS[DFS_VERSION_LENGTH] = { 0 };
 	UINT8 funcRetVal = 0U;
+	UINT8 cBoardInfo = 0U;
+	UINT8 cPluginId = 0U;
+	UINT8 cBoardId = 0U;
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 locTypeId = 0U;
+	UINT8 cDevType = 0U;
+	UINT8 cSystemWorkType = SYSTEM_WORK_MODE_ONLY;
 	funcRetVal = dquGetFSVersion(DataPath, szFSFILEVersionFS);
 
+	locTypeId = MSCP_GetOutnetID();
+	LocalCiId = (UINT8)(locTypeId & 0x00FFU);  /*联锁设备ID*/
+	cDevType = (UINT8)((locTypeId >> 8U) & 0x00FFU);  /*RC/CI类型*/
+													 
+	
+	cRetVal = RciCommonConfigDataInit((const)DataPath); /*初始化当前联锁类型配置数据*/
+	if ((CI_SUCCESS == cRetVal) && (CI_SUCCESS == funcRetVal)) /*初始化当前联锁类型配置数据*/
+	{
+		cSystemWorkType = GetSystemWorkType();
 #if (kPLATFORM==kVXWORKS)
-	/*文件配置*/
+		/*若为真机，则通过平台获取设备类型*/
-	STRU_APP_CFG_T AppCfgInterface = {
+		cBoardInfo = MSCP_GetDrvBoardID();
+		PlatSheBeiType = &gSheBeiType;                     /*联锁设备类型*/
+		cPluginId = ((cBoardInfo >> 4U) & 0x0FU);
+		cBoardId = (cBoardInfo & 0x0FU);
+		if (((0x03U == cPluginId) && ((0x03U == cBoardId) || (0x05U == cBoardId)))
+			|| ((0x0CU == cPluginId) && ((0x06U == cBoardId) || (0x0AU == cBoardId))))
+		{
+			(void)SetLocalRcWorkMode(RC_WORK_MODE_TIOC);
+			gSheBeiType = RC_WORK_MODE_TIOC;
+		}
+		else if (((0x04U == cPluginId) && ((0x03U == cBoardId) || (0x05U == cBoardId)))
+			|| ((0x0BU == cPluginId) && ((0x06U == cBoardId) || (0x0AU == cBoardId))))
+		{
+			(void)SetLocalRcWorkMode(RC_WORK_MODE_CI);
+			gSheBeiType = RC_WORK_MODE_CI;
+		}
+		else
+		{
+			debug_infor_printf((const)"APP_API_Data_Init Error: CI_SYSTEM_TYPE Error.\n");
+			printf((const)"APP_API_Data_Init Error: CI_SYSTEM_TYPE Error.\n");
+		}
+		/*真机需校验设备类型是否一致*/
+		locTypeId = MSCP_GetOutnetID();
+		cDevType = (UINT8)((locTypeId >> 8U) & 0x00FFU);  /*RC/CI类型*/
+		if (gSheBeiType == cDevType)
+		{
+			/*继续处理*/
+		}
+		else
+		{
+			debug_infor_printf((const)"APP_API_Data_Init Error: DevType[0x%x] And [0x%x] Is Not Equal \n", gSheBeiType, cDevType);
+			cRetVal = CI_ERROR;
+		}
+		
+	}
+	if(CI_SUCCESS == cRetVal)
+	{
+		/*文件配置*/
+		STRU_APP_CFG_T AppCfgInterface = {
 			.FS_NAME = "RCI.FS",			/**< FS文件名称 */
 			.APP_NAME = "RCOCI",			/**< 应用文件名称 */
 			.CYC_TIME = 300,			/**< 系统周期 */
@@ -246,51 +306,29 @@ void APP_API_Data_Init()
 			.reboot_replycount = 10,	/**< 重启确认报文回复次数 */
 			.M_AutoReboot_Count = 3,	/**< 自动重启次数 */
 			.M_AutoClear_Days = 1,		/**< 连续运行多久清空宕机次数的天数 */
-			.CPU[0].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+			.M_Area_Enable = 0,			/**< 区域状态开关配置 */
-			.CPU[0].IP_2x2 = "192.168.1.62",       /**< 2x2通信IP */
+			.M_AREA_SEB_Enable = 0xAA,	 /**< RC与CI扩展板卡通信功能开关配置 */
-			.CPU[0].IP_Out = "192.168.1.62",       /**< 外网通信IP */
+			
-			.CPU[0].IP_Maintain = "192.168.146.101",  /**< 维护通信IP */
-			/*适用透传通道-选配*/
-			.CPU[0].IP_Com = "192.168.1.62",       /**< 通用通信IP */
-			.CPU[0].IP_Com_Extend = "192.168.1.62",/**< 通用通信扩展IP */
 			.CPU[0].Logger_PortBase = 55011,   		 /**< 明文日志记录发送端口 */
 			.CPU[0].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
 
-			.CPU[1].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+			
-			.CPU[1].IP_2x2 = "192.168.2.62",       /**< 2x2通信IP */
-			.CPU[1].IP_Out = "192.168.2.62",       /**< 外网通信IP */
-			.CPU[1].IP_Maintain = "192.168.18.102",  /**< 维护通信IP */
-			/*适用透传通道-选配*/
-			.CPU[1].IP_Com = "192.168.2.62",       /**< 通用通信IP */
-			.CPU[1].IP_Com_Extend = "192.168.2.62",/**< 通用通信扩展IP */
 			.CPU[1].Logger_PortBase = 55012,   		 /**< 明文日志记录发送端口 */
 			.CPU[1].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
 
-			.CPU[2].IP_2oo2 = "192.168.0.21",     /**< 2oo2通信IP */
+			
-			.CPU[2].IP_2x2 = "192.168.1.64",       /**< 2x2通信IP */
-			.CPU[2].IP_Out = "192.168.1.64",       /**< 外网通信IP */
-			.CPU[2].IP_Maintain = "192.168.146.103",  /**< 维护通信IP */
-			/*适用透传通道-选配*/
-			.CPU[2].IP_Com = "192.168.1.64",       /**< 通用通信IP */
-			.CPU[2].IP_Com_Extend = "192.168.1.64",/**< 通用通信扩展IP */
 			.CPU[2].Logger_PortBase = 55021,   		 /**< 明文日志记录发送端口 */
 			.CPU[2].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
 
-			.CPU[3].IP_2oo2 = "192.168.0.22",     /**< 2oo2通信IP */
+			
-			.CPU[3].IP_2x2 = "192.168.2.64",       /**< 2x2通信IP */
-			.CPU[3].IP_Out = "192.168.2.64",       /**< 外网通信IP */
-			.CPU[3].IP_Maintain = "192.168.18.104",  /**< 维护通信IP */
-			/*适用透传通道-选配*/
-			.CPU[3].IP_Com = "192.168.2.64",       /**< 通用通信IP */
-			.CPU[3].IP_Com_Extend = "192.168.2.64",/**< 通用通信扩展IP */
 			.CPU[3].Logger_PortBase = 55022,   		 /**< 明文日志记录发送端口 */
 			.CPU[3].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
-			/*通用端口配置*/
+													 /*通用端口配置*/
 			.Port_Outnet_Safe = 54001,   	 /**< 外网安全通信端口 */
 			.Port_Innet_Safe = 53001,   	 /**< 内网安全通信端口 */
 			.Port_Outnet_Raw = 54002,   	 /**< 外网透明传输端口 */
 			.Port_Remote_Update = 50000,  	 /**< 远程部署通信端口 */
-			/*透传配置-选配*/
+											 /*透传配置-选配*/
 			.Port_Innet_Raw_Num = 0, 	 /**< 内网透传端口数量 */
 			.Port_Innet_Raw_Extend_Num = 0, /**< 内网透传扩展端口数量 */
 			.Innet_Raw_Parameter[0].Port_Innet_Raw = 3956, 		     /**< 内网透明传输端口 */
@@ -308,57 +346,215 @@ void APP_API_Data_Init()
 			.Innet_Raw_Parameter[1].INNET_2oo2_RAW = 0X55,		     /**< 透传通道2取开关 */
 			.Innet_Raw_Parameter[1].INNET_2x2_RAW = 0XAA,		     /**< 透传通道2乘开关 */
 			.Innet_Raw_Parameter[1].IP_InnetRaw_maddr = "224.0.0.32",/**< 内网透传的组播IP */
-			/*外网通信配置*/
+																	 /*外网通信配置*/
 			.OutNetRed.CC_G_IP = "192.168.1.60",  /**< 通控的内网IP */
 			.OutNetRed.CC_P_IP = "192.168.2.60",  /**< 通控的内网IP */
 			.OutNetRed.EXTEND_G_IP = "192.168.1.70",       	/**< 扩展板卡的内网IP */
 			.OutNetRed.EXTEND_P_IP = "192.168.2.70",       	/**< 扩展板卡的内网IP */
+			.Another_SEB.EXTEND_R_G_IP = "192.168.1.90",	/**< CI扩展板卡的内网IP */
+			.Another_SEB.EXTEND_R_P_IP = "192.168.2.90",	/**< CI扩展板卡的内网IP */
+			.Another_SEB.OutnetSafe_R_Port = 54001,      /**< 外网安全通信端口 */
 			.OutNetRed.OutnetSafe_Port = 54001, 		/**< 外网安全通信端口 */
 			.OutNetRed.OutnetRaw_Port = 54002, 		/**< 外网透传通信端口 */
 			.OutNetRed.InnetRaw_Port = 53003,   		/**< 内网透传通信端口 */
 
 			.OutNetBlue.CC_G_IP = "192.168.1.61",  /**< 通控的内网IP */
 			.OutNetBlue.CC_P_IP = "192.168.2.61",  /**< 通控的内网IP */
-			.OutNetBlue.EXTEND_G_IP = "192.168.1.71",       	/**< 扩展板卡的内网IP */
+			.OutNetBlue.EXTEND_G_IP = "192.168.1.71",       /**< 扩展板卡的内网IP */
-			.OutNetBlue.EXTEND_P_IP = "192.168.2.71",       	/**< 扩展板卡的内网IP */
+			.OutNetBlue.EXTEND_P_IP = "192.168.2.71",       /**< 扩展板卡的内网IP */
+			.Another_SEB.EXTEND_B_G_IP = "192.168.1.91",	/**< CI扩展板卡的内网IP */
+			.Another_SEB.EXTEND_B_P_IP = "192.168.2.91",	/**< CI扩展板卡的内网IP */
+			.Another_SEB.OutnetSafe_B_Port = 54001,		/**< 外网安全通信端口 */
 			.OutNetBlue.OutnetSafe_Port = 54001, 		/**< 外网安全通信端口 */
 			.OutNetBlue.OutnetRaw_Port = 54002, 		/**< 外网透传通信端口 */
 			.OutNetBlue.InnetRaw_Port = 53003,   		/**< 内网透传通信端口 */
-			/*日志记录目标设备IP配置*/
+
-			.Logger_G_IP = "192.168.146.100",         /**< 绿网日志记录IP */
-			.Logger_P_IP = "192.168.18.100",         /**< 紫网日志记录IP */
-			/*内网通信设备注册最大支持0-255*/
 			.INNET_COM_NUM = 1,     				/**< 内网通信设备数量 */
 			.INNET_COM_CFG[0].InnetID = DEVICE_TYPE_AIM,     /**< 内网通信ID */
-			.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.146.100"),/**< 绿网IP */
 			.INNET_COM_CFG[0].Port_Raw_G = 55004,   /**< 绿网透传端口 */
 			.INNET_COM_CFG[0].Port_Safe_G = 55003,  /**< 绿网安全端口 */
-			.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.18.100"),/**< 紫网IP */
 			.INNET_COM_CFG[0].Port_Raw_P = 55004,   /**< 紫网透传端口 */
 			.INNET_COM_CFG[0].Port_Safe_P = 55003,  /**< 紫网安全端口 */
-	};
+
-	MSCP_Set_APP_ConfigData(&AppCfgInterface);
+		};
+
+
+		if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
+		{
+			/*设置IP 与CIIP一致*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.11"), (UINT32)sizeof("192.168.0.11"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.12"), (UINT32)sizeof("192.168.0.12"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.21"), (UINT32)sizeof("192.168.0.21"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
+
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.22"), (UINT32)sizeof("192.168.0.22"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
+
+			/*CPU1*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.21"), (UINT32)sizeof("239.0.0.21"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.11"), (UINT32)sizeof("239.0.0.11"));
+
+			/*CPU2*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.22"), (UINT32)sizeof("239.0.0.22"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.12"), (UINT32)sizeof("239.0.0.12"));
+			
+			/*内网 通控与扩展板卡*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.60"), (UINT32)sizeof("192.168.1.60"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.60"), (UINT32)sizeof("192.168.2.60"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.70"), (UINT32)sizeof("192.168.1.70"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.70"), (UINT32)sizeof("192.168.2.70"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.90"), (UINT32)sizeof("192.168.1.90"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.90"), (UINT32)sizeof("192.168.2.90"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.61"), (UINT32)sizeof("192.168.1.61"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.61"), (UINT32)sizeof("192.168.2.61"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.71"), (UINT32)sizeof("192.168.1.71"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.71"), (UINT32)sizeof("192.168.2.71"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.91"), (UINT32)sizeof("192.168.1.91"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.91"), (UINT32)sizeof("192.168.2.91"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.146.101"), (UINT32)sizeof("192.168.146.101"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.102"), (UINT32)sizeof("192.168.18.102"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.146.103"), (UINT32)sizeof("192.168.146.103"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.104"), (UINT32)sizeof("192.168.18.104"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.Logger_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.146.100"), (UINT32)sizeof("192.168.146.100"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Logger_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.100"), (UINT32)sizeof("192.168.18.100"));
+			AppCfgInterface.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.146.100");
+			AppCfgInterface.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.18.100");
+
+		}
+		else
+		{/*设置IP 与CIIP一致*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.11"), (UINT32)sizeof("192.168.0.11"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.12"), (UINT32)sizeof("192.168.0.12"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.21"), (UINT32)sizeof("192.168.0.21"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
+
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.22"), (UINT32)sizeof("192.168.0.22"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
+
+			/*CPU1*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.11"), (UINT32)sizeof("239.0.0.11"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.21"), (UINT32)sizeof("239.0.0.21"));
+
+			/*CPU2*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.12"), (UINT32)sizeof("239.0.0.12"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.22"), (UINT32)sizeof("239.0.0.22"));
+
+			/*内网 通控与扩展板卡*/
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.80"), (UINT32)sizeof("192.168.1.80"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.80"), (UINT32)sizeof("192.168.2.80"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.90"), (UINT32)sizeof("192.168.1.90"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.90"), (UINT32)sizeof("192.168.2.90"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.90"), (UINT32)sizeof("192.168.1.90"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.90"), (UINT32)sizeof("192.168.2.90"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.81"), (UINT32)sizeof("192.168.1.81"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.81"), (UINT32)sizeof("192.168.2.81"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.91"), (UINT32)sizeof("192.168.1.91"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.91"), (UINT32)sizeof("192.168.2.91"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.91"), (UINT32)sizeof("192.168.1.91"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.91"), (UINT32)sizeof("192.168.2.91"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.148.101"), (UINT32)sizeof("192.168.148.101"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.102"), (UINT32)sizeof("192.168.20.102"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.148.103"), (UINT32)sizeof("192.168.148.103"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.104"), (UINT32)sizeof("192.168.20.104"));
+
+			(void)CommonMemCpy((void*)(AppCfgInterface.Logger_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.148.100"), (UINT32)sizeof("192.168.148.100"));
+			(void)CommonMemCpy((void*)(AppCfgInterface.Logger_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.100"), (UINT32)sizeof("192.168.20.100"));
+			AppCfgInterface.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.148.100");
+			AppCfgInterface.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.20.100");
+
+		}
+		if(SYSTEM_WORK_MODE_ONLY == cSystemWorkType)
+		{
+			/*单系统运行：区域开关设置为0*/
+			AppCfgInterface.M_Area_Enable = 0u;
+		}
+		else
+		{
+			/*双系统运行*/
+			if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
+			{
+				/*RC区域开关设置为0xAA*/
+				AppCfgInterface.M_Area_Enable = 0xAAu;
+				/**< RC与CI扩展板卡通信功能开关配置 */
+				AppCfgInterface.M_AREA_SEB_Enable = 0x55u;  
+
+			}
+			else
+			{
+				/*设置CI IP+区域IP*/
+				AppCfgInterface.M_Area_Enable = 0x55u;
+			}
+		
+		}
+		MSCP_Set_APP_ConfigData(&AppCfgInterface);
+
 #endif
 
-	/*组FS版本号*/
+		/*组FS版本号*/
-	ii = 0U;
+		ii = 0U;
-	fsVersBuffer[ii++] = szFSFILEVersionFS[0];
+		fsVersBuffer[ii++] = szFSFILEVersionFS[0];
-	fsVersBuffer[ii++] = szFSFILEVersionFS[1];
+		fsVersBuffer[ii++] = szFSFILEVersionFS[1];
-	fsVersBuffer[ii++] = szFSFILEVersionFS[2];
+		fsVersBuffer[ii++] = szFSFILEVersionFS[2];
-	fsVersBuffer[ii++] = szFSFILEVersionFS[3];
+		fsVersBuffer[ii++] = szFSFILEVersionFS[3];
 
-	/*组软件版本号*/
+		/*组软件版本号*/
-	ii = 0U;
+		ii = 0U;
-	appVersBuffer[ii++] = VER_INTE_PROJECT;
+		appVersBuffer[ii++] = VER_INTE_PROJECT;
-	appVersBuffer[ii++] = VER_INTE_PRODUCT >> 2U;
+		appVersBuffer[ii++] = VER_INTE_PRODUCT >> 2U;
-	appVersBuffer[ii++] = (VER_INTE_PRODUCT << 6U) + (VER_INTE_EXE & (UINT8)0x3F);
+		appVersBuffer[ii++] = (VER_INTE_PRODUCT << 6U) + (VER_INTE_EXE & (UINT8)0x3F);
-	appVersBuffer[ii++] = VER_INTE_TIME;
+		appVersBuffer[ii++] = VER_INTE_TIME;
-	/*设置平台调用获取外网信息函数*/
+		/*设置平台调用获取外网信息函数*/
-	MSCP_SetSrcId(SetOutNetPara);
+		MSCP_SetSrcId(SetOutNetPara);
-	/*设置内网参数*/
+		/*设置内网参数*/
-	MSCP_SetSfpInnetPara(g_SfpInnetParam);
+		MSCP_SetSfpInnetPara(g_SfpInnetParam);
-	MSCP_SetAppVersion(appVersBuffer);
+		MSCP_SetAppVersion(appVersBuffer);
-	MSCP_SetFsVersion(fsVersBuffer);
+		MSCP_SetFsVersion(fsVersBuffer);
+	}
 }
 /**
 * @brief 应用周期主逻辑
@@ -396,6 +592,9 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
 	gFollowDataLen = GetCiAppData(gFollowData);
 	MSCP_SetFollowData(gFollowData, gFollowDataLen);
 
+	gCiRcFollowDataLen = GetCiGeneralData(gCiRcFollowData);
+	MSCP_CISendAppData(gCiRcFollowData, gCiRcFollowDataLen);
+
 	return retVal;
 }
 
@@ -518,44 +717,27 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
 {
 	ENUM_CM_RECCUSEB retVal = ENUM_CM_CC; /*返回值*/
 	CM_UINT8 devType = 0U; /*设备类型*/
-	CM_UINT8 devId = 0U; /*设备ID*/
 	CM_UINT16 wAtsGtWayDevTypeId = 0U;
-	UINT8 chLocalCiType = 0U; /*本联锁属性*/
+	UINT8 chWorkType = 0U; /*双系工作模式*/
-	UINT8 chDstCiType = 0U; /*本联锁属性*/
+	UINT8 cControlState = 0U;/*主备用模式*/
-	UINT8 chCldScxCommMode = 0U;
+	UINT8 cRcWorkMode = 0u;/*RC工作模式*/
 	UINT8 chResult = CI_ERROR; /*联锁属性检查结果*/
+	UINT8 serialGroup = 0U; /*串口通信组索引*/
 
 	wAtsGtWayDevTypeId = GetTiocTrnsmtGtwyDevTypeId();
 	/**使用通控板与ATS网关通信*/
 	if (dstDevTypeId != wAtsGtWayDevTypeId)
 	{
 		devType = (CM_UINT8)((dstDevTypeId >> 8) & 0xFF);
-		devId = (CM_UINT8)(dstDevTypeId & 0xFF);
+		chWorkType = GetSystemWorkType();
+		cControlState = GetLocalCiBackUpPattern();
+		cRcWorkMode = GetLocalRcWorkMode();
 
-		chLocalCiType = GetLocalCiType();
+		chResult = IsSerialDevice(dstDevTypeId, &serialGroup);
-		chDstCiType = GetCiType(devId);
-		chCldScxCommMode = GetCiFunctionSwitchConfig(SCX_CLD_INTERFACE_TYPE);
 
-		if ((SCX_CLD_SERIAL_PORT_COMM == chCldScxCommMode) && (CI_SYSTEM_TYPE_CI == devType))
+		if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType)
-		{
-			if (((CI_TYPE_CLD == chLocalCiType) && (CI_TYPE_SCX == chDstCiType)) || ((CI_TYPE_SCX == chLocalCiType) && (CI_TYPE_CLD == chDstCiType)))
-			{
-				/*串口通信要求双方一个为车辆段一个为试车线*/
-				chResult = CI_SUCCESS;
-			}
-			else
-			{
-				; /*CI类型错误，返回失败*/
-			}
-		}
-		else
-		{
-			; /*不为串口通信，此时不对本地CI类型及对方CI类型进行判断*/
-		}
-
-		if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType) || (CI_SYSTEM_TYPE_LEU == devType)
 			|| (CI_SUCCESS == chResult)
-			|| (CI_SYSTEM_TYPE_VOBC_BACKUP == devType)) /*现地,ATS,LEU,使用串口的相邻CI*/
+			|| (CI_SYSTEM_TYPE_VOBC_BACKUP == devType)) /*现地,ATS,使用串口的相邻CI*/
 		{
 			retVal = ENUM_CM_SEB;
 		}
@@ -563,6 +745,28 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
 		{
 			retVal = ENUM_CM_CCSEB;
 		}
+		else if (CI_SYSTEM_TYPE_LEU == devType)
+		{
+			if ((SYSTEM_WORK_MODE_ALL == chWorkType) && (RC_WORK_MODE_TIOC == cRcWorkMode))
+			{
+				/*双系统,并且当前是RC*/
+				if (SYSTEM_WORK_MODE_MAIN == cControlState)
+				{
+					/*是RC主用时，需要用CI的串口板进行LEU通信*/
+					retVal = ENUM_CM_SEB_ANOTHER;
+				}
+				else
+				{
+					/*RC备用，禁止发送*/
+					retVal = ENUM_CM_FORBIDDEN;
+				}
+			}
+			else
+			{
+				/*单系统，或当前是CI*/
+				retVal = ENUM_CM_SEB;
+			}
+		}
 		else
 		{
 			retVal = ENUM_CM_CC;
@@ -761,7 +965,7 @@ ENUM_CM_RETURN SerialOutAtsVobcFunc(UINT16 inDstId IN, UINT16* outSrcId OUT, UIN
 	inDstType = (UINT8)((inDstId & 0xff00U) >> 8);
 	if ((CI_SYSTEM_TYPE_VOBC_BACKUP == inDstType) || (CI_SYSTEM_TYPE_ITE == inDstType))
 	{
-		*outSrcId = (CI_SYSTEM_TYPE_CI << 8) + GetSystemParaLocalCiId();
+		*outSrcId = (CI_SYSTEM_TYPE_RCI << 8) + GetSystemParaLocalCiId();
 		*outDstId = GetATSInterfaceTypeId();
 
 		retVal = ENUM_CM_TRUE;

TSCP/src/APP/PU13_integration_config/ci_integrate_config.h

@@ -30,6 +30,6 @@
 #define VER_INTE_PROJECT            220  /*项目编号*/
 #define VER_INTE_PRODUCT            40   /*产品编号*/
 #define VER_INTE_EXE                1   /*可执行编号*/
-#define VER_INTE_TIME               118   /*集成次数编号*/
+#define VER_INTE_TIME               131   /*集成次数编号*/
 
 #endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/

TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.h

@@ -56,8 +56,7 @@
 #include "../Route/LogicalRouteDataManage.h"
 #include "../Route/LongRouteDataManage.h"
 #include "../ReverseCut/ReverseCutDataManage.h"
-#include "../SsksLightRelay/SsksLightRelayDataManage.h"
+#include "../AxisSort/AxisSort.h"
-#include "AxisAssertManageAPI.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -155,6 +154,20 @@ UINT32 CopyValidSetVobcBackHlht(const UINT8 *pCurCiAppDataPointer, UINT16 struNu
 */
 UINT32 CopyValidSetVobcDataStru(const UINT8* pCurCiAppDataPointer, VobcToCiDataStruct* pDataStru, UINT16 struNum);
 
+/*
+* 功能描述： 拷贝RC通信的VOBC有效数据到对应的全局数组
+* 参数说明：
+	输入参数
+	const UINT8 *pCurCiAppDataPointer:当前数据指针
+	UINT16 struNum:数组长度,
+	UINT16 struLength:结构体长度
+	输出参数
+	void *pDataStru:结构体指针,
+* 返回值  ： 拷贝数据的长度
+*/
+UINT32 CopyValidSetRcVobcDataStru(const UINT8* pCurCiAppDataPointer, void* pDataStru, UINT16 struNum, UINT16 struLength);
+
+
 /*
 * 功能描述：拷贝ITE有效数据到对应的全局数组
 * 参数说明：const UINT8 *pCurCiAppDataPointer:当前数据指针
@@ -190,6 +203,280 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer);
 */
 UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len);
 
+
+/**
+* @brief 拷贝获取现地有效互联互通头
+* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
+* @param[in] UINT16 struNum:数组长度
+* @param[in] struLength:结构体长度
+* @return 无
+* @note by cgh 20251103
+*/
+UINT32 CopyValidGetXiandiHlht(UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
+
+/**
+* @brief 拷贝设置现地有效互联互通头
+* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
+* @param[in] UINT16 struNum:数组长度
+* @param[in] struLength:结构体长度
+* @return 无
+* @note by cgh 20251103
+*/
+UINT32 CopyValidSetXiandiHlht(const UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
+
+/**
+* @brief 拷贝获取ATS有效互联互通头
+* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
+* @param[in] UINT16 struNum:数组长度
+* @param[in] struLength:结构体长度
+* @return 无
+* @note by cgh 20251103
+*/
+UINT32 CopyValidGetAtsHlht(UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
+
+/**
+* @brief 拷贝设置ATS有效互联互通头
+* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
+* @param[in] UINT16 struNum:数组长度
+* @param[in] struLength:结构体长度
+* @return 无
+* @note by cgh 20251103
+*/
+UINT32 CopyValidSetAtsiHlht(const UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
+
+/*
+* 功能描述： CI待发送RC应用数据
+* 参数说明： UINT8 *pCiAppDataPointer, CI应用数据指针
+* 返回值  ： void
+*/
+UINT32 GetCiGeneralData(UINT8* pCiAppDataPointer);
+
+/*
+* 功能描述： RC设置CI的应用数据
+* 参数说明： UINT8 *pCiAppDataPointer, CI应用数据指针
+*			 const UINT32 len，数据长度
+* 返回值  ： UINT8，
+*/
+UINT8 SetCiGeneralData(const UINT8* pCiAppDataPointer, const UINT32 len);
+
+/*
+* 功能描述：二乘拷贝互联互通报文头
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           struLength 结构体长度
+*           HLHTHeadContextStru pstrHLHTHeadCtxs[] 待拷贝的互联互通报文头
+* 返 回 值：拷贝的数据长度
+* Created By LQ 2025.11.04
+*/
+UINT32 CopyValidGetHlhtHeadCtxs(UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength, HLHTHeadContextStru pstrHLHTHeadCtxs[]);
+
+/*
+* 功能描述：二乘设置互联互通报文头
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           struLength 结构体长度
+*           HLHTHeadContextStru pstrHLHTHeadCtxs[] 待设置的互联互通报文头
+* 返 回 值：拷贝的数据长度
+* Created By LQ 2025.11.04
+*/
+UINT32 CopyValidSetHlhtHeadCtxs(const UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength, HLHTHeadContextStru pstrHLHTHeadCtxs[]);
+/*
+* 功能描述：二乘拷贝信号机结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           SignalDataStructCC pstSignalDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.07
+*/
+UINT32 CopyValidGetSigDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, SignalDataStructCC pstSignalDataStruCC[]);
+/*
+* 功能描述：二乘设置信号机结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           SignalDataStructCC pstSignalDataStruCC[] 待设置的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.07
+*/
+UINT32 CopyValidSetSigDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, SignalDataStructCC pstSignalDataStruCC[]);
+/*
+* 功能描述：二乘拷贝防淹门结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           FloodGateDataStructCC pstFloodGateDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.07
+*/
+UINT32 CopyValidGetFloodGateDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, FloodGateDataStructCC pstFloodGateDataStruCC[]);
+/*
+* 功能描述：二乘设置防淹门结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           FloodGateDataStructCC pstFloodGateDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.07
+*/
+UINT32 CopyValidSetFloodGateDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, FloodGateDataStructCC pstFloodGateDataStruCC[]);
+/*
+* 功能描述：二乘拷贝逻辑区段结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           LogicSectionDataStructCC pstLogSecDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.07
+*/
+UINT32 CopyValidGetLogicSecDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, LogicSectionDataStructCC pstLogSecDataStruCC[]);
+/*
+* 功能描述：二乘设置逻辑区段结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           LogicSectionDataStructCC pstLogSecDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.07
+*/
+UINT32 CopyValidSetLogicSecDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, LogicSectionDataStructCC pstLogSecDataStruCC[]);
+/*
+* 功能描述：二乘拷贝进路结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           RouteDataStructCC pstRouteDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.10
+*/
+UINT32 CopyValidGetRouteDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, RouteDataStructCC pstRouteDataStruCC[]);
+/*
+* 功能描述：二乘拷贝进路结构体-车车
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*           RouteDataStructCC pstRouteDataStruCC[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By LYJ 2025.11.10
+*/
+UINT32 CopyValidSetRouteDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, RouteDataStructCC pstRouteDataStruCC[]);
+
+/*
+* 功能描述：拷贝ZC发送的信号机数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopyGetZcSignalDymDataStru(UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：同步ZC发送的信号机数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopySetZcSignalDymDataStru(const UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：拷贝ZC发送的逻辑区段数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopyGetZcLogSecDymDataStru(UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：同步ZC发送的逻辑区段数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopySetZcLogSecDymDataStru(const UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：拷贝ZC发送的计轴区段数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopyGetZcAxisSecDymDataStru(UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：同步ZC发送的计轴区段数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopySetZcAxisSecDymDataStru(const UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：拷贝ZC发送的物理区段数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopyGetZcPhySecDymDataStru(UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：同步ZC发送的物理区段数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopySetZcPhySecDymDataStru(const UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：拷贝ZC发送的进路数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopyGetZcRouteDymDataStru(UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：同步ZC发送的进路数据
+* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
+* 返 回 值：拷贝数据的长度
+* Created By LQ 2025.11.10
+*/
+UINT32 CopySetZcRouteDymDataStru(const UINT8* pCurCiAppDataPointer);
+
+/*
+* 功能描述：二乘设置OC有效数据
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+* 返 回 值：拷贝的数据长度
+* Created By fan 2025.11.12
+*/
+UINT32 CopyValidSetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcToCiOriginDataStruct OcRecvData[]);
+
+/*
+* 功能描述：二乘拷贝OC原始数据有效值
+* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
+*           UINT16 struNum 数组长度
+*          OcToCiOriginDataStruct OcRecvData[] 待拷贝的结构体
+* 返 回 值：拷贝的数据长度
+* Created By fan 2025.11.12
+*/
+UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcToCiOriginDataStruct OcRecvData[]);
+
+/*
+* 功能描述： 设置报文上下文数据
+* 参数说明：
+输入参数
+const UINT8 *pCurCiAppDataPointer:当前数据指针
+UINT16 struNum:数组长度,
+输出参数
+HLHTHeadContextStru *pDataStru:结构体指针,
+* 返回值  ： 拷贝数据的长度
+* 注   意 ； 只适用于报文上下文
+*/
+UINT32 CopyValidSetHlhtHeadDataStru(const UINT8 *pCurCiAppDataPointer, UINT16 struNum, HLHTHeadContextStru *pDataStru);
+
+/*
+* 功能描述： 拷贝报文上下文数据数据
+输入参数
+const HLHTHeadContextStru *pDataStru 结构体指针
+UINT16 struNum:数组长度,
+输出参数
+UINT8 *pCurCiAppDataPointer:当前数据指针,
+* 返回值  ： 拷贝数据的长度
+* 注   意 ； 只适用于报文上下文
+*/
+UINT32 CopyValidGetHlhtHeadDataStru(UINT8 *pCurCiAppDataPointer, UINT16 struNum, const HLHTHeadContextStru *pDataStru);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/2oo2/2oo2InterfaceDataManage.c

@@ -10,7 +10,6 @@
 ********************************************************/ 
 
 #include "../2oo2/2oo2InterfaceDataManage.h"
-#include "MSCP_APP_API.h"
 #include "stdarg.h"
 #include "protclStruct.h"
 #include "ParsePackCommon.h"
@@ -29,9 +28,7 @@ extern UINT8 processor_mode;					                          /*ƽ̨
 extern UINT8 FSIOLinkStatusInfo;                                          /*联锁机与FSIO之间连接状态*/
 extern UINT8 LEULinkStatusInfo;                                           /*联锁与LEU通信状态*/
 extern UINT8 ZCLinkStatusInfo;                                            /*联锁与ZC通信状态*/
-extern UINT8  gSheBeiType;                                                /*对外的设备类型*/
 extern UINT8  gSheBeiID;                                                  /*对外的设备ID*/
-extern UINT8 LocalCiId;                                                   /*系统配置文件中定义的联锁ID*/
 extern QueueStruct logPrintfQue;                                          /*日志存储数据队列*/
 UINT8  gSheBeiType; 
 #endif
@@ -97,44 +94,44 @@ QueueStruct logPrintfQue;            /*
 /*
 * 功能描述： 平台初始化
 * 参数说明： void
-* 返回值  ： NULL: 获取数据失败
+* 返回值  ： 0: 失败
-*           !NULL: 平台ATS到CI接口队列
+*            1: 成功
+* Modified By LQ 2025.08.27
 */
 UINT8 Initial2oo2Interface(void)
 {
-	UINT8 rtn = 0u;
+	UINT8 rtn = CI_ERROR;
-	UINT16 locTypeId = 0;
+	UINT8 result = 0U;
-	UINT8 result = 0u;
 
-    /*定义平台数据队列指针*/
+	/*定义平台数据队列指针*/
 
 #ifdef PLATFORM_2OO2
 
-	
+	rtn = CI_SUCCESS;
 	ProtocolToCiDataQueue = &gCbtcData.DataToApp;       /*初始化协议到CI数据队列*/
 	CiToProtocolDataQueue = &gCbtcData.OutputDataQueue; /*初始化CI到协议数据队列*/
 
-    FsfbToCiDataQueue = &Fsfb_Info.DataToApp;           /*初始化Fsfb到CI数据队列*/
+	FsfbToCiDataQueue = &Fsfb_Info.DataToApp;           /*初始化Fsfb到CI数据队列*/
-    CiToFsfbDataQueue = &Fsfb_Info.OutputDataQueue;     /*初始化CI到Fsfb数据队列*/
+	CiToFsfbDataQueue = &Fsfb_Info.OutputDataQueue;     /*初始化CI到Fsfb数据队列*/
 
 	CurCycleNum = &CycleNum;                            /*初始化平台周期*/
 	StartCycleNum = MSCP_GetSysCount(); /*上电周期号*/
 
-    PlatComputerId = &Computer_Id_Local_File;
+	PlatComputerId = &Computer_Id_Local_File;
-    PlatRunMode = &processor_mode;
+	PlatRunMode = &processor_mode;
 
 	IoToCiDataQueue = &canQueueRecv;                   /*初始化IO到CI数据队列*/
 	CiToIoDataQueue = &canQueueSend;                   /*初始化CI到IO数据队列*/
 
 	AtsToCiDataQueue = NULL;					       /*初始化ATS到CI数据队列*/
-    CiToAtsDataQueue = CiToProtocolDataQueue;          /*初始化CI到ATS数据队列*/
+	CiToAtsDataQueue = CiToProtocolDataQueue;          /*初始化CI到ATS数据队列*/
 
-    XianDiToCiDataQueue = NULL;					       /*初始化ATS到CI数据队列*/
+	XianDiToCiDataQueue = NULL;					       /*初始化ATS到CI数据队列*/
 	CiToXianDiDataQueue = CiToProtocolDataQueue;       /*初始化CI到ATS数据队列*/
 
 
 	ZcToCiDataQueue = NULL;							   /*初始化ZC到CI数据队列*/
-    CiToZcDataQueue = CiToProtocolDataQueue;           /*初始化CI到ZC数据队列*/
+	CiToZcDataQueue = CiToProtocolDataQueue;           /*初始化CI到ZC数据队列*/
 
 	AxisToCiDataQueue = NULL;							 /*初始化Axis到CI数据队列*/
 	CiToAxisDataQueue = CiToProtocolDataQueue;           /*初始化CI到Axis数据队列*/
@@ -142,7 +139,7 @@ UINT8 Initial2oo2Interface(void)
 	CiRecvFromCiDataQueue = NULL;					   /*初始化CI接受其他CI数据队列*/
 	CiSendToCiDataQueue = CiToProtocolDataQueue;       /*初始化CI发送到其他CI数据队列*/
 
-    VobcToCiDataQueue = NULL;						   /*初始化Vobc到CI数据队列*/
+	VobcToCiDataQueue = NULL;						   /*初始化Vobc到CI数据队列*/
 	CiToVobcDataQueue = CiToProtocolDataQueue;         /*初始化CI到Vobc数据队列*/
 
 	PlatformToCiDataQueue = NULL;                           /*初始化Psd到CI数据队列*/
@@ -151,55 +148,66 @@ UINT8 Initial2oo2Interface(void)
 	PscToCiDataQueue = NULL;							/*初始化PSC到CI数据队列*/
 	CiToPscDataQueue = CiToProtocolDataQueue;			/*初始化CI到PSC数据队列*/
 
-    LEUToCiDataQueue = NULL;						   /*初始化Leu到CI数据队列*/
+	LEUToCiDataQueue = NULL;						   /*初始化Leu到CI数据队列*/
 	CiToLEUDataQueue = CiToFsfbDataQueue;			   /*初始化CI到Leu数据队列*/
 
-    CiAndIoComState = &FSIOLinkStatusInfo;             /*联锁与IO通信状态*/
+	CiAndIoComState = &FSIOLinkStatusInfo;             /*联锁与IO通信状态*/
-	locTypeId = MSCP_GetOutnetID();
+
-    /*LocalCiId = gSheBeiID;*/                             /*联锁设备ID*/
-    PlatSheBeiType = &gSheBeiType;                     /*联锁设备类型*/
-	LocalCiId = (UINT8)(locTypeId & 0xFFu);                             /*联锁设备ID*/
-	gSheBeiType = (UINT8)((locTypeId >> 8u) & 0xFFu);
 
 	OcToCiDataQueue = NULL;								/*初始化Oc到Ci的数据队列*/
 	CiToOcDataQueue = CiToProtocolDataQueue;			/*初始化Ci到Oc的数据队列*/
 	
-	if (1U != QueueInitial(&logPrintfQue, 500000U))       /*初始化日志缓存队列*/
+	if (CI_SUCCESS == rtn)
 	{
-		debug_infor_printf((const)"canQueueRecv init error \n");
+		if (1U != QueueInitial(&logPrintfQue, 500000U))       /*初始化日志缓存队列*/
-	}
+		{
+			debug_infor_printf((const)"canQueueRecv init error \n");
+			rtn = CI_ERROR;
+		}
+		else
+		{
 
 #if 0
-    /*联锁与LEU、ZC、CI等的通信状态描述*/
+			/*联锁与LEU、ZC、CI等的通信状态描述*/
-    if (TransmitRelaDataCurSum < TRANSMIT_OBJECT_SUM_MAX)
+			if (TransmitRelaDataCurSum < TRANSMIT_OBJECT_SUM_MAX)
-    {
+			{
-        for (ii = 0u; ii < TRANSMIT_OBJECT_SUM_MAX; ii++)
+				for (ii = 0u; ii < TRANSMIT_OBJECT_SUM_MAX; ii++)
-        {
+				{
-            PlatComStatusStru[ii].SystemType = &(ComDevStatusInfo[ii].DeviceTypeOther);
+					PlatComStatusStru[ii].SystemType = &(ComDevStatusInfo[ii].DeviceTypeOther);
-            PlatComStatusStru[ii].SystemNum = &(ComDevStatusInfo[ii].ComDevSum);
+					PlatComStatusStru[ii].SystemNum = &(ComDevStatusInfo[ii].ComDevSum);
-            for (jj = 0u; jj < TRANSMIT_OBJECT_DEVICE_SUM_MAX; jj++)
+					for (jj = 0u; jj < TRANSMIT_OBJECT_DEVICE_SUM_MAX; jj++)
-            {
+					{
-                PlatComStatusStru[ii].SystemIdBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdBuf[jj]);
+						PlatComStatusStru[ii].SystemIdBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdBuf[jj]);
-                PlatComStatusStru[ii].CommunicationStatusBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdComStatusBuf[jj]);
+						PlatComStatusStru[ii].CommunicationStatusBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdComStatusBuf[jj]);
-            }
+					}
-        }
+				}
 
-    }
+			}
-    else
+			else
-    {
+			{
 
-    }
+			}
 #endif
 
 #endif
-	result = HLHTCiIdMapInitial();
+			result = HLHTCiIdMapInitial();
-	if (CI_SUCCESS == result)
+			if (CI_SUCCESS == result)
+			{
+				rtn = CI_SUCCESS;
+			}
+			else
+			{
+				debug_infor_printf((const)"Initial2oo2Interface init error: HLHTCiIdMapInitial Error\n");
+				rtn = CI_ERROR;  /*返回失败*/
+			}
+		}
+	}
+	else
 	{
-		rtn = 1;
+		rtn = CI_ERROR;  /*返回失败*/
 	}
 
 	return rtn;
-
 }
 
 /*
@@ -504,7 +512,7 @@ QueueStruct* Get2oo2CiToPscDataQueue(void)
 UINT32 Get2oo2CurCycleNum(void)
 {
 #if (kPLATFORM==kVXWORKS)
-	return MSCP_GetSysCount();
+	return MSCP_GetAreaSysCount();
 #else
 	return *CurCycleNum;
 #endif
@@ -1074,10 +1082,11 @@ UINT8 InnetChannelIODataRecv(UINT8* ioData)
 
 /*
 * 功能描述： 将队列中的数据传输出去
-* 参数说明： 无
+* 参数说明： UINT8* thisString, 本周期数据
-* 返回值  ： 无
+* 返回值  ： 0: 打印失败
+*			 1: 打印成功
 */
-void SendOut_LogBuff(void)
+void SendOut_LogBuff()
 {
 #if (kPLATFORM==kVXWORKS)
 

TSCP/src/APP/ciapp/2oo2/2oo2InterfaceDataManage.h

@@ -21,6 +21,7 @@
 #include "CommonQueue.h"
 #include "../Transmit/TransmitStateDataManage.h"
 
+#include "MSCP_APP_API.h"
 #ifdef PLATFORM_2OO2
 #include "sfpplatform.h"
 #include "RsspWl.h"
@@ -89,12 +90,14 @@ extern UINT8* CiAndCiComDeviceNum;                                       /*
 extern UINT8* CiAndCiComIdBuf;                                           /*联锁与联锁通信设备ID*/
 extern UINT8* CiAndCiComState;                                           /*联锁与联锁通信状态*/
 extern UINT8* PlatSheBeiType;                                            /*平台对外设备类型*/
+extern UINT8  gSheBeiType;                                                /*对外的设备类型*/
 
 /*
 * 功能描述： 平台初始化
 * 参数说明： void
-* 返回值  ： NULL: 获取数据失败
+* 返回值  ： 0: 失败
-*           !NULL: 平台ATS到CI接口队列
+*            1: 成功
+* Modified By LQ 2025.08.27
 */
 UINT8 Initial2oo2Interface(void);
 
@@ -374,10 +377,11 @@ QueueStruct* Get2oo2CiToAxisDataQueue(void);
 
 /*
 * 功能描述： 将队列中的数据传输出去
-* 参数说明： 无
+* 参数说明： UINT8* thisString, 本周期数据
-* 返回值  ： 无
+* 返回值  ： 0: 打印失败
+*			 1: 打印成功
 */
-void SendOut_LogBuff(void);
+void SendOut_LogBuff();
 
 
 

TSCP/src/APP/ciapp/AllAutoReturn/AllAutoReturnConfigDataManage.c

@@ -125,6 +125,27 @@ UINT8 GetAllAutoReturnRouteBelongCiId(const UINT16 allAutoReturnId)
 
 	return belongCiId;
 }
+/*
+* 功能描述： 获取指定ID全自动折返所属虚拟联锁ID
+* 参数说明： const UINT16 allAutoReturnId, 全自动折返ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属虚拟联锁ID
+* add by mpt 20260107
+*/
+UINT8 GetAllAutoRetRoutBelongVirCiId(const UINT16 allAutoReturnId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 belongVirCiId = CI_ERROR;
+
+	bufIndex = GetAllAutoReturnBufIndex(allAutoReturnId);  /*获取全自动折返数组下标*/
+
+	if (bufIndex < ALL_AUTO_RETURN_SUM_MAX)
+	{
+		belongVirCiId = AllAutoReturnConfigDataStru[bufIndex].BelongVirCiId;
+	}
+
+	return belongVirCiId;
+}
 
 /*
 * 功能描述： 获取指定ID全自动折返包含进路ID数组

TSCP/src/APP/ciapp/AllAutoReturn/AllAutoReturnConfigDataManage.h

@@ -34,6 +34,7 @@ typedef struct S_AllAutoReturnConfigDataStruct
 {
     UINT16 AllAutoReturnId;          /*全自动折返ID (配置字段)*/
 	UINT8 BelongCiId;				/*所属联锁ID*/
+	UINT8 BelongVirCiId;           /*虚拟联锁ID*/
     UINT8 RouteSum;              /*全自动折返包含进路数目 (配置字段)*/
     UINT16 RouteIdBuf[ALL_AUTO_RETURN_INCLROUTE_SUM_MAX];   /*全自动折返进路ID数组 (配置字段)*/
 	UINT16 RebackRouteIdBuf[ALL_AUTO_RETURN_REBACKROUTE_SUM_MAX];   /*全自动折返包含折出进路数组(配置字段)*/
@@ -92,6 +93,14 @@ UINT8 GetAllAutoReturnIncludeRouteSum(const UINT16 allAutoReturnId);
 *			>0: 所属联锁ID
 */
 UINT8 GetAllAutoReturnRouteBelongCiId(const UINT16 allAutoReturnId);
+/*
+* 功能描述： 获取指定ID全自动折返所属虚拟联锁ID
+* 参数说明： const UINT16 allAutoReturnId, 全自动折返ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属虚拟联锁ID
+* add by mpt 20260107
+*/
+UINT8 GetAllAutoRetRoutBelongVirCiId(const UINT16 allAutoReturnId);
 
 /*
 * 功能描述： 获取指定ID全自动折返包含进路ID数组

TSCP/src/APP/ciapp/AllAutoReturn/AllAutoReturnDefine.h

@@ -41,5 +41,5 @@
 #define ALL_AUTO_RETURN_DICHU_COMMR             ((UINT8)0x06)    /*抵触的普通进路已办理*/
 #define ALL_AUTO_RETURN_HAVE_BLOCK              ((UINT8)0x02)    /*全自动折返进路存在封锁*/
 #define ALL_AUTO_RETURN_FLOOD_STATE_ERR         ((UINT8)0x03)    /*全自动折返进路存在防淹门不满足*/
-
+#define ALL_AUTO_RETURN_COUPROUTE_SET            ((UINT8)0x07)    /*联挂进路已办理*/
 #endif

TSCP/src/APP/ciapp/AutoReturn/AutoReturnConfigDataManage.c

@@ -119,6 +119,27 @@ UINT8 GetAutoReturnRouteBelongCiId(const UINT16 autoReturnId)
 
     return returnValue;
 }
+/*
+* 功能描述： 获取指定ID自动折返所属虚拟联锁ID
+* 参数说明： const UINT16 autoReturnId, 自动折返ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属联锁ID
+* add by mpt 20260107
+*/
+UINT8 GetAutoReturnRouteBelongVirCiId(const UINT16 autoReturnId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 returnValue = CI_ERROR;
+
+	bufIndex = GetAutoReturnBufIndex(autoReturnId);  /*获取自动折返数组下标*/
+
+	if (bufIndex < AUTO_RETURN_SUM_MAX)
+	{
+		returnValue = AutoReturnConfigDataStru[bufIndex].BelongVirCiId;
+	}
+
+	return returnValue;
+}
 
 /*
 * 功能描述： 获取指定ID自动折返包含进路ID数组

TSCP/src/APP/ciapp/AutoReturn/AutoReturnConfigDataManage.h

@@ -34,6 +34,7 @@ typedef struct S_AutoReturnConfigDataStruct
 {
     UINT16 AutoReturnId;          /*自动折返ID (配置字段)*/
 	UINT8 BelongCiId;				/*所属联锁ID*/
+	UINT8 BelongVirCiId;				/*所属虚拟联锁ID*/
     UINT8 RouteSum;              /*自动折返包含进路数目 (配置字段)*/
     UINT16 RouteIdBuf[AUTO_RETURN_INCLROUTE_SUM_MAX];   /*自动折返进路包含进路ID数组 (配置字段)*/
 	UINT8 AutoReturnOpposedReturnIdSum;									/*自动折返抵触自动折返进路数目 (配置字段)*/
@@ -88,6 +89,14 @@ UINT8 GetAutoReturnIncludeRouteSum(const UINT16 autoReturnId);
 *			>0: 所属联锁ID
 */
 UINT8 GetAutoReturnRouteBelongCiId(const UINT16 autoReturnId);
+/*
+* 功能描述： 获取指定ID自动折返所属虚拟联锁ID
+* 参数说明： const UINT16 autoReturnId, 自动折返ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属联锁ID
+* add by mpt 20260107
+*/
+UINT8 GetAutoReturnRouteBelongVirCiId(const UINT16 autoReturnId);
 
 /*
 * 功能描述： 获取指定ID自动折返包含进路ID数组

TSCP/src/APP/ciapp/AutoReturn/AutoReturnDefine.h

@@ -41,5 +41,5 @@
 #define AUTO_RETURN_DICHU_COMMROUTE             ((UINT8)0x06)    /*抵触的普通进路已办理*/
 #define AUTO_RETURN_HAVE_BLOCK                  ((UINT8)0x02)    /*自动折返进路存在封锁*/
 #define AUTO_RETURN_FLOOD_STATE_ERR             ((UINT8)0x03)    /*自动折返进路存在防淹门不满足*/
-
+#define AUTO_RETURN_COUPROUTE_SET               ((UINT8)0x07)    /*联挂进路已办理*/
 #endif

TSCP/src/APP/ciapp/AutoRoute/AutoRouteConfigDataManage.c

@@ -97,6 +97,26 @@ UINT8 GetAutoRouteBelongCiId(const UINT16 autoRouteId)
     }
 	return belongCiId;
 }
+/*
+* 功能描述： 获取指定ID自动进路所属虚拟联锁ID
+* 参数说明： const UINT16 autoRouteId, 自动进路ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属联锁ID
+* add by mpt 20260107
+*/
+UINT8 GetAutoRouteBelongVirCiId(const UINT16 autoRouteId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 belongVirCiId = CI_ERROR;
+
+	bufIndex = GetAutoRouteBufIndex(autoRouteId);  /*获取自动进路数组下标*/
+
+	if (bufIndex < AUTO_ROUTE_SUM_MAX)
+	{
+		belongVirCiId = AutoRouteConfigDataStru[bufIndex].BelongVirCiId;
+	}
+	return belongVirCiId;
+}
 
 
 /*

TSCP/src/APP/ciapp/AutoRoute/AutoRouteConfigDataManage.h

@@ -32,6 +32,7 @@ typedef struct S_AutoRouteConfigDataStruct
 {
     UINT16 AutoRouteId;                                                 /*自动进路ID (配置字段)*/
     UINT8 BelongCiId;				                                    /*所属联锁ID*/
+	UINT8 BelongVirCiId;				                                /*所属虚拟联锁ID*/
     UINT8 RouteSum;                                                     /*自动进路包含进路数目 (配置字段)*/
     UINT16 RouteIdBuf[AUTO_ROUTE_INCLROUTE_SUM_MAX];                    /*自动进路进路ID数组 (配置字段)*/
 	UINT8 AutoRouteOpposedRouteIdSum;								    /*自动通过进路抵触自动通过进路数目 (配置字段)*/
@@ -89,6 +90,13 @@ UINT16 GetAutoRouteBufIndex(const UINT16 AutoRouteId);
 *			>0: 所属联锁ID
 */
 UINT8 GetAutoRouteBelongCiId(const UINT16 autoRouteId);
+/*
+* 功能描述： 获取指定ID自动进路所属虚拟联锁ID
+* 参数说明： const UINT16 autoRouteId, 自动进路ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属联锁ID
+*/
+UINT8 GetAutoRouteBelongVirCiId(const UINT16 autoRouteId);
 
 /*
 * 功能描述： 获取指定ID自动进路包含进路数目

TSCP/src/APP/ciapp/AutoRoute/AutoRouteDefine.h

@@ -36,7 +36,7 @@
 #define AUTO_ROUTE_DICHU_COMMROUTE             ((UINT8)0x06)    /*抵触普通进路已办理*/
 #define AUTO_ROUTE_HAVE_BLOCK                  ((UINT8)0x02)    /*自动进路存在封锁*/
 #define AUTO_ROUTE_FLOOD_STATE_ERR             ((UINT8)0x03)    /*自动进路存在防淹门不满足*/
-
+#define AUTO_ROUTE_COUPROUTE_SET               ((UINT8)0x07)    /*联挂进路已办理*/
 
 
 #endif

TSCP/src/APP/ciapp/AxisAssert/AxisAssertDefine.h

@@ -48,10 +48,6 @@
 #define AAM_COMM_BAD_ARB_YES (0x55U)     /*计轴系统通信中断ARB有效*/
 #define AAM_COMM_BAD_ARB_NO (0xAAU)      /*计轴系统通信中断ARB无效*/ 
 
-#define LOCAL_ALL_AXIS_SEC_ARB_DEFAULT  ((UINT8)0xFFU) /*本控区RC和计轴通信中断设置ARB标志-默认*/
-#define LOCAL_ALL_AXIS_SEC_ARB_YES      ((UINT8)0x55U) /*本控区RC和计轴通信中断设置ARB标志-有效*/
-#define LOCAL_ALL_AXIS_SEC_ARB_NO       ((UINT8)0xAAU) /*本控区RC和计轴通信中断设置ARB标志-无效*/
-
 /** 定义计轴诊断信息结构体 */
 typedef struct  
 {
@@ -64,6 +60,7 @@ typedef struct
 	UINT8 tailEnterTrainCnt;                                 /* 进入的列车尾数量 */
 	UINT16 tailEnterTrainId[SECTION_REL_ENVELOPE_SUM_MAX];   /* 列车尾进入的计轴 */
 	UINT8 redunOverCanArb;  /*冗余结束后能否判为ARB标志 空闲时设置为0x55*/
+	UINT8 AxisCommBadArbFlag;  /*计轴通信中断可判ARB有效标志：0x55-有效,0xAA-无效*/
 }AxisAsserStruct;
 
 

TSCP/src/APP/ciapp/AxisAssert/AxisAssertManage.c

@@ -2,7 +2,6 @@
 
 static AxisAsserStruct gs_AxisAssert[AXIS_SECTION_SUM_MAX] = {0u};     /** 计轴故障诊断数据缓存 */
 static UINT8 gs_InitEndlineFlag = AAM_END_LINE_UNINIT;      /* 尽头线ARB特殊处理标志 */
-UINT8 gLocalAllAxisSecArbFlag = LOCAL_ALL_AXIS_SEC_ARB_DEFAULT; /*本控区RC和计轴通信中断设置ARB标志-默认*/
 
 
 /**
@@ -542,3 +541,53 @@ void aam_SetAxisRedunCanArbFlag(const UINT16 acIndex, const UINT8 redunOverArbFl
 		; /*不做处理*/
 	}
 }
+
+/*
+* 功能描述：设置指定ID计轴区段计轴通信中断可判ARB标志
+* 参数说明：const UINT16 acIndex 计轴索引
+*			const UINT8 cCommBadArbFlag 计轴通信中断可判ARB标志
+* 返 回 值：无
+* Created By LQ 2025.02.24
+*/
+void aam_SetAxisCommBadArbFlag(const UINT16 acIndex, const UINT8 cCommBadArbFlag)
+{
+
+	if ((0U != acIndex) && (AXIS_SECTION_SUM_MAX > acIndex))
+	{
+		if ((AAM_COMM_BAD_ARB_YES == cCommBadArbFlag) || (AAM_COMM_BAD_ARB_NO == cCommBadArbFlag))
+		{
+			gs_AxisAssert[acIndex].AxisCommBadArbFlag = cCommBadArbFlag;
+		}
+		else
+		{
+			; /*不做处理*/
+		}
+	}
+	else
+	{
+		; /*不做处理*/
+	}
+}
+
+/*
+* 功能描述：获取指定ID计轴区段计轴通信中断可判ARB标志
+* 参数说明：const UINT16 acIndex 计轴索引
+* 返 回 值：0x55 有效
+*           0xAA 无效
+* Created By LQ 2025.02.24
+*/
+UINT8 aam_GetAxisCommBadArbFlag(const UINT16 acIndex)
+{
+	UINT8 ret = AAM_COMM_BAD_ARB_NO;
+
+	if ((0U != acIndex) && (acIndex < AXIS_SECTION_SUM_MAX))
+	{
+		ret = gs_AxisAssert[acIndex].AxisCommBadArbFlag;
+	}
+	else
+	{
+		;
+	}
+
+	return ret;
+}

TSCP/src/APP/ciapp/AxisAssert/AxisAssertManage.h

@@ -7,8 +7,6 @@
 #include "AxisAssertDefine.h"
 #include "ELMDataPrepare.h"
 
-extern UINT8 gLocalAllAxisSecArbFlag; /*本控区RC和计轴通信中断设置ARB标志-默认*/
-
 /**
  * @brief 初始化计轴诊断信息
  * @param[in] 
@@ -229,4 +227,22 @@ UINT8 aam_GetAxisRedunCanArbFlag(const UINT16 acIndex);
 */
 void aam_SetAxisRedunCanArbFlag(const UINT16 acIndex, const UINT8 redunOverArbFlag);
 
+/*
+* 功能描述：设置指定ID计轴区段计轴通信中断可判ARB标志
+* 参数说明：const UINT16 acIndex 计轴索引
+*			const UINT8 cCommBadArbFlag 计轴通信中断可判ARB标志
+* 返 回 值：无
+* Created By LQ 2025.02.24
+*/
+void aam_SetAxisCommBadArbFlag(const UINT16 acIndex, const UINT8 cCommBadArbFlag);
+
+/*
+* 功能描述：获取指定ID计轴区段计轴通信中断可判ARB标志
+* 参数说明：const UINT16 acIndex 计轴索引
+* 返 回 值：0x55 有效
+*           0xAA 无效
+* Created By LQ 2025.02.24
+*/
+UINT8 aam_GetAxisCommBadArbFlag(const UINT16 acIndex);
+
 #endif

TSCP/src/APP/ciapp/AxisAssert/AxisAssertManageAPI.h

@@ -10,7 +10,6 @@
 #include "EnvelopeDefine.h"
 
 
-
 /**
  * @brief 计轴故障诊断模块初始化
  * @return CI_ERROR 初始化成功
@@ -25,7 +24,7 @@ UINT8 aam_Init(void);
  * @param[in] 
  * @param[out]
  * @return 
- * @note edit cgh 20260310
+ * @note 
  */
 void aam_MainProcess(void);
 
@@ -176,7 +175,7 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID);
 * 函数功能：计轴子系统通信中断ARB处理
 * 输入参数：无
 * 返回值：无
-* by cgh 20260309
+* Create By LQ 2025.02.23
 */
 void aam_AxisCommBadArbPro(void);
 
@@ -185,35 +184,25 @@ void aam_AxisCommBadArbPro(void);
 * 输入参数：无
 * 返回值：CI_SUCCESS 1 成功
 *         CI_ERROR 0 失败
-* by cgh 20260309
+* Create By LQ 2025.02.23
 */
 UINT8 aam_AxisCommBadArbTrainCheck(void);
 
 /**
-* 函数功能：相邻计轴区段列车条件检查
+* 函数功能：计轴子系统通信中断ARB处理——区段条件检查
-* 输入参数：UINT16 wAxisSecId 计轴区段ID
+* 输入参数：无
 * 返回值：CI_SUCCESS 1 成功
 *         CI_ERROR 0 失败
-* by cgh 20260309
+* Create By LQ 2025.02.23
 */
-UINT8 aam_AdjacentAcTrainCheck(UINT16 wAxisSecId);
+UINT8 aam_AxisCommBadArbSecCheck(void);
-
-/**
-* 函数功能：检查计轴区段上包络条件是否满足
-* 输入参数：UINT16 wAxisSecId 计轴区段ID
-* 返回值：CI_SUCCESS 1 成功
-*         CI_ERROR 0 失败
-* by cgh 20260309
-*/
-UINT8 aam_AxisSecEnvelopeCheck(UINT16 wAxisSecId);
 
 /*
-* 功能描述：设置集中区内计轴区段状态
+* 功能描述：设置集中区内计轴区段ARB
-* 参数说明：UINT8 chAxisSecState 待设置的计轴区段状态
+* 参数说明：无
 * 返 回 值：无
-* by cgh 20260310
 */
-void SetLocalAllAxisSecState(UINT8 chAxisSecState);
+void SetRcAxleArb(void);
 
 /**
 * @brief 对外接口：获取计轴诊断状态接口
@@ -244,40 +233,4 @@ UINT8 aam_CheckPhyTrain(UINT16 ACID);
 */
 UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH]);
 
-/**
- * @brief 获取本控区RC和计轴通信中断设置ARB标志
- * @param[in] void
- * @param[out] 无
- * @return 0xFF-默认 0x55U-有效 0xAAU-无效
- * by cgh 20260307
- */
-UINT8 aam_GetLocalAllAxisSecArbFlag(void);
-
-/**
- * @brief 设置本控区RC和计轴通信中断设置ARB标志
- * @param[in] chLocalAllAxisSecArbFlag 本控区RC和计轴通信中断设置ARB标志
- * @param[out] 无
- * @return 无
- * by cgh 20260307
- */
-void aam_SetLocalAllAxisSecArbFlag(UINT8 chLocalAllAxisSecArbFlag);
-
-/**
- * @brief 计轴故障诊断模块正常处理函数
- * @param[in]
- * @param[out]
- * @return
- * @note by cgh 20260310
- */
-void aam_NormalProcess(void);
-
-/**
-* 函数功能：计轴区段空闲检查
-* 输入参数：UINT16 wAxisSecId 计轴区段ID
-* 返回值：CI_SUCCESS 1 集合C所有区段条件检查通过
-*         CI_ERROR 0 集合C存在区段条件检查不通过
-* by cgh 20260309
-*/
-UINT8 aam_AxisSecIdleCheck(void);
-
 #endif /*AXIS_ASSERT_MANAGE_API_H_*/

TSCP/src/APP/ciapp/AxisSort/AxisSort.c

@@ -16,7 +16,7 @@
 static UINT16 g_pSortLinkNum;                         /* 本控区的Link数量 */
 static UINT16 g_pSortLinkIndex[AS_LINK_MAX + 1U];     /* 本控区的Link索引 */
 
-static AS_SORT_INFO_s g_pSortLinkInfo[AS_LINK_MAX + 1U]; /*link排序*/
+AS_SORT_INFO_s g_pSortLinkInfo[AS_LINK_MAX + 1U]; /*link排序*/
 
 /* 通信车序列，在SortCT阶段完成CT车排序 */
 static UINT16 s_pCTSortIndex[SIZE_MAX_LINE_TRAIN_NUM];            /*本信息不周期清空*/
@@ -2188,12 +2188,34 @@ UINT32 as_GetTransferData(OUT UINT8 * pDataBuff, IN UINT32 curIndex)
 {
 	UINT32 ret = curIndex;
 	UINT32 copyIndex = curIndex;
+	UINT16 wLinkNum = 0U;
+	UINT16 u16Index = 0U;
+	UINT16 wTmpLinkId = 0U;
+	UINT8 chLocalId = GetSystemParaLocalCiId();
+	UINT8 chLinkCIId = 0U;/*link所属联锁*/
+	UINT32 dwLinkNumIndex =0U;/*数量位置 */
 	if (NULL != pDataBuff)
 	{
 		(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM), s_pCTSortIndex, (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM));
 		copyIndex += (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM);
-		(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u), s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u));
+		(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)), s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)));
-		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u);
+		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U));
+		/*拷贝link列车排序*/
+		dwLinkNumIndex = copyIndex;
+		copyIndex += 2U;
+		for (u16Index = 1U; u16Index <= g_pSortLinkNum; u16Index++)
+		{
+			wTmpLinkId = g_pSortLinkInfo[u16Index].u16ID;
+			chLinkCIId = (UINT8)GetLinkManageTiocById(wTmpLinkId);
+			if ((0U != chLocalId) && (chLinkCIId == chLocalId))
+			{
+				/*仅拷贝本联锁*/
+				(void)CommonMemCpy(&pDataBuff[copyIndex],(UINT32)(sizeof(AS_SORT_INFO_s)), &g_pSortLinkInfo[u16Index], (UINT32)(sizeof(AS_SORT_INFO_s)));
+				copyIndex += (UINT32)(sizeof(AS_SORT_INFO_s));
+				wLinkNum++;
+			}
+		}
+		ShortToChar(wLinkNum, &pDataBuff[dwLinkNumIndex]); /* 写入有车占用的计轴区段数量 */
 		ret = copyIndex;
 	}
 	else
@@ -2215,12 +2237,29 @@ UINT32 as_SetTransferData(IN UINT8 * pDataBuff, IN UINT32 curIndex)
 {
 	UINT32 ret = curIndex;
 	UINT32 copyIndex = curIndex;
+	UINT16 wLinkNum = 0U;
+	UINT16 jj = 0U;
+	UINT16 wTmpLinkId =0U;
+	UINT16 wLinkIndex = 0U;
 	if (NULL != pDataBuff)
 	{
 		(void)CommonMemCpy(s_pCTSortIndex, (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM), &pDataBuff[copyIndex], (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM));
 		copyIndex += (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM);
-		(void)CommonMemCpy(s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u), &pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u));
+		(void)CommonMemCpy(s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)), &pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)));
-		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u);
+		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U));
+		/*拷贝列车排序*/
+		wLinkNum = ShortFromChar(&pDataBuff[copyIndex]);
+		copyIndex += 2u;
+		for (jj = 0U; jj < wLinkNum; jj++)
+		{
+			wTmpLinkId = ShortFromCharLE(&pDataBuff[copyIndex]);
+			wLinkIndex = g_pSortLinkIndex[wTmpLinkId];
+			if ((DEFAULT_ZERO < wLinkIndex) && (wLinkIndex < AS_LINK_MAX+1U))
+			{			
+				(void)CommonMemCpy(&g_pSortLinkInfo[wLinkIndex], (UINT32)(sizeof(AS_SORT_INFO_s)), &pDataBuff[copyIndex], (UINT32)(sizeof(AS_SORT_INFO_s)));
+				copyIndex += (UINT32)(sizeof(AS_SORT_INFO_s));
+			}
+		}
 		ret = copyIndex;
 	}
 	else

TSCP/src/APP/ciapp/AxisSort/AxisSort.h

@@ -48,5 +48,5 @@ typedef struct
 	UINT16 TrainEnveLopeID[ENVELOPE_SUM_MAX];                           /*所有包络ID信息*/
 }s_TRAIN_ENVELOPE_ID;
 
-
+extern  AS_SORT_INFO_s g_pSortLinkInfo[AS_LINK_MAX + 1U]; /*link排序*/
 #endif /* INC_AXIS_SORT_INC */

TSCP/src/APP/ciapp/ConnectOverride/ConnectOverrideCfgDataMg.c

@@ -1,177 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ConnectOverrideCfgDataMg.c
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2026-3-11
-* 作    者： 联锁组
-* 功能描述： 联络线旁路继电器相关配置
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-#include "ConnectOverrideCfgDataMg.h"
-
-ConnectOverrideCfgDataStru gConnectOverrideRelayCfgStr[CONNECT_OVERRIDE_RELAY_SUM_MAX] = { 0U };  /*联络线旁路继电器信息*/
-INT16 gConnectOverrideRelaySum = 0;  /*联络线旁路继电器数量*/
-
-/*
-* 功能描述：获取指定ID的联络线旁路继电器的索引号
-* 参数说明：const UINT16 wConnectOverrideId 联络线旁路ID
-* 返 回 值：CONNECT_OVERRIDE_RELAY_SUM_MAX 获取数据失败
-*			< CONNECT_OVERRIDE_RELAY_SUM_MAX 查找成功
-* Created By wyd 2026.3.11
-*/
-UINT16 GetConnectOverrideCfgBufIndex(const UINT16 wConnectOverrideId)
-{
-	UINT16 index = CONNECT_OVERRIDE_RELAY_SUM_MAX;
-	UINT16 ii = 0U;
-
-	for (ii = 0U; ii < gConnectOverrideRelaySum; ii++)
-	{
-		if (wConnectOverrideId == gConnectOverrideRelayCfgStr[ii].ConnectOverrideId)
-		{
-			index = ii;
-			break;
-		}
-		else
-		{
-			/*继续查找*/
-		}
-	}
-
-	return index;
-}
-
-/*
-* 功能描述：获取联络线旁路继电器数量
-* 参数说明：void
-* 返 回 值：联络线旁路继电器数量
-* Created By wyd 2026.3.11
-*/
-UINT16 GetConnectOverrideRelaySum(void)
-{
-	UINT16 retVal = 0U;
-
-	if (0 > gConnectOverrideRelaySum)
-	{
-		retVal = 0U;
-	}
-	else if (CONNECT_OVERRIDE_RELAY_SUM_MAX <= (UINT16)gConnectOverrideRelaySum)
-	{
-		retVal = CONNECT_OVERRIDE_RELAY_SUM_MAX;
-	}
-	else
-	{
-		retVal = (UINT16)gConnectOverrideRelaySum;
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述：获取联络线旁路继电器静态数据
-* 参数说明：void
-* 返 回 值：联络线旁路继电器静态数据
-* Created By wyd 2026.3.11
-*/
-ConnectOverrideCfgDataStru* GetConnectOverrideRelayCfgStr(void)
-{
-	return gConnectOverrideRelayCfgStr;
-}
-
-/*
-* 功能描述：获取联络线旁路开关采集继电器ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线旁路开关采集继电器ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetConnectOverrideRelayId(UINT16 wOverrideId)
-{
-	UINT16 wIndex = CONNECT_OVERRIDE_RELAY_SUM_MAX;
-	UINT16 retVal = 0u;
-
-	wIndex = GetConnectOverrideCfgBufIndex(wOverrideId);
-	if (CONNECT_OVERRIDE_RELAY_SUM_MAX > wIndex)
-	{
-		retVal = gConnectOverrideRelayCfgStr[wIndex].OverrideRelayId;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述：获取联络线旁路关联物理区段ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线旁路关联物理区段ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetConnectOverridePhySecId(UINT16 wOverrideId)
-{
-	UINT16 wIndex = CONNECT_OVERRIDE_RELAY_SUM_MAX;
-	UINT16 retVal = 0u;
-
-	wIndex = GetConnectOverrideCfgBufIndex(wOverrideId);
-	if (CONNECT_OVERRIDE_RELAY_SUM_MAX > wIndex)
-	{
-		retVal = gConnectOverrideRelayCfgStr[wIndex].RelPhySecId;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述：获取联络线旁路关联进路请求继电器ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线关联进路请求继电器ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetOverrideRouteRequestRelayId(UINT16 wOverrideId)
-{
-	UINT16 wIndex = CONNECT_OVERRIDE_RELAY_SUM_MAX;
-	UINT16 retVal = 0u;
-
-	wIndex = GetConnectOverrideCfgBufIndex(wOverrideId);
-	if (CONNECT_OVERRIDE_RELAY_SUM_MAX > wIndex)
-	{
-		retVal = gConnectOverrideRelayCfgStr[wIndex].RelRouteRequestRelayId;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述：获取联络线旁路关联道岔ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线旁路关联道岔ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetConnectOverrideSwitchId(UINT16 wOverrideId)
-{
-	UINT16 wIndex = CONNECT_OVERRIDE_RELAY_SUM_MAX;
-	UINT16 retVal = 0u;
-
-	wIndex = GetConnectOverrideCfgBufIndex(wOverrideId);
-	if (CONNECT_OVERRIDE_RELAY_SUM_MAX > wIndex)
-	{
-		retVal = gConnectOverrideRelayCfgStr[wIndex].RelSwitchId;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
-	return retVal;
-}

TSCP/src/APP/ciapp/ConnectOverride/ConnectOverrideCfgDataMg.h

@@ -1,101 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ConnectOverrideCfgDataMg.h
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2026-3-11
-* 作    者： 联锁组
-* 功能描述： 联络线旁路继电器相关配置
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#ifndef CONNECT_OVERRIDE_CFGDATA_MG_H
-#define CONNECT_OVERRIDE_CFGDATA_MG_H
-
-#include "CommonTypes.h"
-#include "ConnectOverrideRelayDefine.h"
-
-/*联络线旁路继电器配置数据结构体*/
-typedef struct S_ConnectOverrideCfgDataStru
-{
-	UINT16 ConnectOverrideId;			/*联络线旁路继电器ID*/
-	UINT16 BelongOcId;					/*继电器所属OC ID*/
-	UINT8 BelongCiId;					/*继电器所属联锁ID*/
-	UINT16 OverrideRelayId;				/*联络线旁路开关采集继电器ID*/
-	UINT16 RelPhySecId;					/*关联物理区段ID*/
-	UINT16 RelRouteRequestRelayId;		/*关联进路请求继电器ID*/
-	UINT16 RelSwitchId;					/*关联道岔ID*/
-} ConnectOverrideCfgDataStru;
-
-/*******************************全局变量声明*******************************/
-extern ConnectOverrideCfgDataStru gConnectOverrideRelayCfgStr[CONNECT_OVERRIDE_RELAY_SUM_MAX];  /*联络线旁路继电器信息*/
-extern INT16 gConnectOverrideRelaySum;  /*联络线旁路继电器数量*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-* 功能描述：获取指定ID的联络线旁路继电器的索引号
-* 参数说明：const UINT16 wConnectOverrideId 联络线旁路ID
-* 返 回 值：CONNECT_OVERRIDE_RELAY_SUM_MAX 获取数据失败
-*			< CONNECT_OVERRIDE_RELAY_SUM_MAX 查找成功
-* Created By wyd 2026.3.11
-*/
-UINT16 GetConnectOverrideCfgBufIndex(const UINT16 wConnectOverrideId);
-
-/*
-* 功能描述：获取联络线旁路继电器数量
-* 参数说明：void
-* 返 回 值：联络线旁路继电器数量
-* Created By wyd 2026.3.11
-*/
-UINT16 GetConnectOverrideRelaySum(void);
-
-/*
-* 功能描述：获取联络线旁路继电器静态数据
-* 参数说明：void
-* 返 回 值：联络线旁路继电器静态数据
-* Created By wyd 2026.3.11
-*/
-ConnectOverrideCfgDataStru* GetConnectOverrideRelayCfgStr(void);
-
-/*
-* 功能描述：获取联络线旁路开关采集继电器ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线旁路开关采集继电器ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetConnectOverrideRelayId(UINT16 wOverrideId);
-
-/*
-* 功能描述：获取联络线旁路关联物理区段ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线旁路关联物理区段ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetConnectOverridePhySecId(UINT16 wOverrideId);
-
-/*
-* 功能描述：获取联络线旁路关联进路请求继电器ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线关联进路请求继电器ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetOverrideRouteRequestRelayId(UINT16 wOverrideId);
-
-/*
-* 功能描述：获取联络线旁路关联道岔ID
-* 参数说明：wOverrideId 联络线旁路索引编号
-* 返 回 值：0：查询失败 其他：联络线旁路关联道岔ID
-* Created By wyd 2026.3.12
-*/
-UINT16 GetConnectOverrideSwitchId(UINT16 wOverrideId);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif

TSCP/src/APP/ciapp/ConnectOverride/ConnectOverrideDataMg.h

@@ -1,91 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ConnectOverrideDataMg.h
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2025-12-17
-* 作    者： 联锁组
-* 功能描述： 联络线旁路继电器相关数据
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#ifndef CONNECT_OVERRIDE_DATA_MG_H
-#define CONNECT_OVERRIDE_DATA_MG_H
-
-#include "CommonTypes.h"
-#include "../System/CiSystemDefine.h"
-#include "ConnectOverrideCfgDataMg.h"
-
-/*联络线旁路继电器动态数据结构体*/
-typedef struct S_ConnectOverrideDataStru
-{
-	UINT16 ConnectOverrideId;		/*联络线旁路继电器ID*/
-	UINT8 OverrideState;			/*旁路状态 0x55：未激活 0xAA：已激活*/
-	UINT8 OverrideReason;			/*每一个bit代表一种条件
-										bit0=1：逻辑区段占用且未判ARB
-										bit1=1：区段封锁—ATS设置区段封锁
-										bit2=1：区段封锁—全线区段封锁
-										bit3=1：区段封锁—SPKS激活
-										bit4=1：区段封锁—CESB激活
-										bit5=1：防护区建立
-										bit6-bit7：预留
-										当旁路状态为0xAA（已激活），但旁路条件为0x00（无条件）时，
-										说明该旁路状态激活时存在某种条件，但目前该条件已不满足，
-										且无取消条件触发，此时旁路状态仍保留激活状态。*/
-	UINT32 OverridePressStartCyc;	/*采集到旁路按钮正常按下起始周期号（上周期未按下且本周期按下，记录周期号；未按下时清空）*/
-	UINT32 OverrideErrTrigStartCyc;	/*采集到旁路按钮误触发按下起始周期号（上周期未按下且本周期按下，记录周期号；未按下时清空）*/
-	UINT8 OverrideErrTrigState;		/*旁路开关采集继电器异常吸起标志，0x55未异常吸起，0xaa异常吸起
-										旁路开关正常按下时间达到故障判断时间，或误触发按下时间达到误触发判断时间，设置旁路开关异常吸起标志*/
-	UINT8 OverrideErrDownState;		/*旁路开关采集继电器异常落下状态 0x55：未异常落下 0xAA：异常落下
-										OC通信异常或两系板卡状态均故障，设置继电器通信异常落下*/
-} ConnectOverrideDataStru;
-
-extern ConnectOverrideDataStru gConnectOverrideData[CONNECT_OVERRIDE_RELAY_SUM_MAX];		/* 联络线旁路继电器动态数据 */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-	/*
-	* 功能描述：获取联络线旁路结构体地址
-	* 参数说明：void
-	* 返 回 值：联络线旁路结构体地址
-	* Created By wyd 20260311
-	*/
-	ConnectOverrideDataStru *GetConnectOverrideData(void);
-
-	/*
-	* 功能描述：联络线旁路主处理
-	* 参数说明：无
-	* 返 回 值：无
-	* Created By wyd 20260311
-	*/
-	void ConnectOverrideMainProc(void);
-
-	/*
-	* 功能描述：根据物理区段ID查询联络线旁路状态
-	* 参数说明：const UINT16 wOverrideId 联络线旁路索引编号
-	* 返 回 值：CONNECT_OVERRIDE_STATE_NO：未旁路
-	*			CONNECT_OVERRIDE_STATE_YES：已旁路
-	*			CI_ERROR：未查询到
-	* Created By wyd 20260313
-	*/
-	UINT8 GetOverrideStateByPhySecId(UINT16 wPhySecId);
-
-	/*
-	* 功能描述：根据逻辑区段ID查询联络线旁路状态
-	* 参数说明：const UINT16 wOverrideId 联络线旁路索引编号
-	* 返 回 值：CONNECT_OVERRIDE_STATE_NO：未旁路
-	*			CONNECT_OVERRIDE_STATE_YES：已旁路
-	*			CI_ERROR：未查询到
-	* Created By wyd 20260313
-	*/
-	UINT8 GetOverrideStateByLogSecId(UINT16 wLogSecId);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif

TSCP/src/APP/ciapp/ConnectOverride/ConnectOverrideRelayDefine.h

@@ -1,45 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ConnectOverrideRelayDefine.h
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2026-3-11
-* 作    者： 联锁组
-* 功能描述： 联络线旁路继电器相关常量定义
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#ifndef CONNECT_OVERRIDE_DATA_DEFINE_H
-#define CONNECT_OVERRIDE_DATA_DEFINE_H
-
-/*联络线旁路继电器数量最大值*/
-#define CONNECT_OVERRIDE_RELAY_SUM_MAX    (UINT16)1U
-
-/*联络线旁路激活状态*/
-#define CONNECT_OVERRIDE_STATE_NO		(UINT8)0x55u	/*联络线旁路未激活*/
-#define CONNECT_OVERRIDE_STATE_YES		(UINT8)0xAAu	/*联络线旁路已激活*/
-
-/*联络线旁路开关采集继电器异常落下状态*/
-#define CONNECT_OVERRIDE_ERRDOWN_NO		(UINT8)0x55u	/*联络线旁路开关采集继电器未异常落下*/
-#define CONNECT_OVERRIDE_ERRDOWN_YES	(UINT8)0xAAu	/*联络线旁路开关采集继电器异常落下*/
-
-/*联络线旁路开关采集状态*/
-#define CONNECT_OVERRIDE_PRESSED_NO		(UINT8)0x55u	/*联络线旁路开关未有效按下*/
-#define CONNECT_OVERRIDE_PRESSED_YES	(UINT8)0xaau	/*联络线旁路开关有效按下*/
-
-/*联络线旁路原因*/
-#define OVERRIDE_REASON_NONE			(UINT8)0x00u	/*联络线旁路原因：无原因*/
-#define OVERRIDE_REASON_NCT				(UINT8)0x01u	/*联络线旁路原因：NCT占用且未判ARB*/
-#define OVERRIDE_REASON_FLOCK_CMD		(UINT8)0x02u	/*联络线旁路原因：ATS区段封锁*/
-#define OVERRIDE_REASON_FLOCK_ALL		(UINT8)0x04u	/*联络线旁路原因：ATS全线封锁*/
-#define OVERRIDE_REASON_FLOCK_SPKS		(UINT8)0x08u	/*联络线旁路原因：SPKS激活*/
-#define OVERRIDE_REASON_FLOCK_CESB		(UINT8)0x10u	/*联络线旁路原因：CESB激活*/
-#define OVERRIDE_REASON_EA				(UINT8)0x20u	/*联络线旁路原因：防护区建立*/
-
-/*旁路开关采集继电器异常吸起标志*/
-#define CONNECT_OVERRIDE_ERRTRIG_NO		((UINT8)0x55)    /*旁路开关异常吸起标志无效*/
-#define CONNECT_OVERRIDE_ERRTRIG_YES	((UINT8)0xaa)    /*旁路开关异常吸起标志有效*/
-
-#endif

TSCP/src/APP/ciapp/CutoffPoint/CutoffPointDataManage.c

@@ -792,6 +792,7 @@ void SetCfpLocalOcCtData(const UINT16 wCfpId)
 	UINT8 chSendNum = 0u;
 	UINT8 chFunRtn = CI_ERROR;
 	struct_PathPoint strPoint = { 0u };
+	UINT8 dir = 0u;
 
 	wIndex = GetCfpBufIndex(wCfpId);
 	/* 输入合法 */
@@ -812,7 +813,9 @@ void SetCfpLocalOcCtData(const UINT16 wCfpId)
 				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].dwDelay = GetTrainMsgDelayTime(szCtTrainId[chCtIndex]);
 				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].wSpeed = GetTrainSpeed(szCtTrainId[chCtIndex]);
 				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].chSpeedDir = GetTrainSpeedDir(szCtTrainId[chCtIndex]);
-				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].chTrainDir = GetTrainDir(szCtTrainId[chCtIndex]);
+
+				dir = GetTrainDir(szCtTrainId[chCtIndex]);	/*获取列车的逻辑方向*/
+				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].chTrainDir = ConvertDirectionToLogic(dir);	/*将逻辑方向转换为运营方向*/
 				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].wMaxHeadLink = GetTrainMaxHeadLink(szCtTrainId[chCtIndex]);
 				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].dwMaxHeadOff = GetTrainMaxHeadOffset(szCtTrainId[chCtIndex]);
 				g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].wMinHeadLink = GetTrainMinHeadLink(szCtTrainId[chCtIndex]);
@@ -1629,7 +1632,7 @@ void OtherCfpTrainInfoCal(UINT16 wLinkId,UINT32 dwOffSet,UINT32 dwLocalOffSet, C
 		{
 			chLinkTiocId = (UINT8)GetLinkManageTiocById(wLinkId);
 			strCfpInfo = GetCfpOtherOcTrainInfo(wCfpId);
-			chTransmitStat = GetCiTransmitState(CI_SYSTEM_TYPE_CI, chLinkTiocId);
+			chTransmitStat = GetRcPbTacsTransmitState(chLinkTiocId);
 			if ((TRANSMIT_STATE_GOOD != chTransmitStat) || (UINT16_MAX == strCfpInfo.wTrainId))
 			{
 				;/*通信不良好，或者分界点列车信息获取失败*/

TSCP/src/APP/ciapp/DataManage/DeviceConfigDataManage.c

@@ -43,6 +43,7 @@ UINT8 GetCiEmapCheckVer(const UINT8 ciId, UINT32 *emapVer,const UINT8 commDevTyp
 			switch (commDevType)
 			{/*根据通信设备类型获取CI与该通信设备的共用数据校验信息*/
 			case CI_SYSTEM_TYPE_VOBC:
+			case CI_SYSTEM_TYPE_IVOC:
 			case CI_SYSTEM_TYPE_ITE:
 				*emapVer = gEmapCiConfigStrus[ciId].dataVerCheckCIAndVOBC;  /*ITE使用与VOBC相同的校验信息*/
 				break;
@@ -57,7 +58,7 @@ UINT8 GetCiEmapCheckVer(const UINT8 ciId, UINT32 *emapVer,const UINT8 commDevTyp
 				*emapVer = gEmapCiConfigStrus[ciId].dataVerCheckCIAndTMC;
 				break;
 			default:
-				/*CI_SYSTEM_TYPE_CI等情况*/
+				/*CI_SYSTEM_TYPE_RCI等情况*/
 				break;
 			}
 
@@ -104,37 +105,34 @@ SAME_LINE_ERR,
 */
 UINT8 IsSameLineCI(const UINT8 ciA, const UINT8 ciB)
 {
-	UINT32 etcsIdA, etcsIdB;
+	UINT32 etcsIdA = 0U;
-	UINT16 u16CiA, u16CiB;
+	UINT32 etcsIdB = 0U;
+	UINT16 u16CiA = 0U;
+	UINT16 u16CiB = 0U;
 	UINT8 retVal = SAME_LINE_ERR;
-	UINT8 cbtcSysType = DQU_CBTC_FAO;
 	UINT8 dquDevNameA = CI_ERROR;
 	UINT8 dquDevNameB = CI_ERROR;
+	UINT8 chCiAFactoryType = 0U;
+	UINT8 chCiBFactoryType = 0U;
 
-	u16CiA = (UINT16)((CI_SYSTEM_TYPE_CI * 256u) + ciA);
+	u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciA);
-	u16CiB = (UINT16)((CI_SYSTEM_TYPE_CI * 256u) + ciB);
+	u16CiB = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciB);
 
-	cbtcSysType = GetCbtcSysType();
+	dquDevNameA = dquDevName2HlhtId(u16CiA,0U,&etcsIdA);
+	dquDevNameB = dquDevName2HlhtId(u16CiB,0U,&etcsIdB);
 
-	dquDevNameA = dquDevName2HlhtId(u16CiA,0u,&etcsIdA);
+	/*需要增加互联互通的判断*/
-
+	if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
-	dquDevNameB = dquDevName2HlhtId(u16CiB,0u,&etcsIdB);
-
-	if(DQU_CBTC_CPK == cbtcSysType)
 	{
-		retVal = SAME_LINE_YES;
+		/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
-	}
+		if ((etcsIdA & ((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
-	else if(DQU_CBTC_FAO == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;	
-	}
-	else if(DQU_CBTC_HLT == cbtcSysType)
-	{
-		/*需要增加互联互通的判断*/
-		if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
 		{
-			/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
+			retVal = SAME_LINE_YES;
-			if ((etcsIdA&((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
+
+			/*同一条线路，一期二期使用不同厂家联锁，也判为不同线路，接口走互联互通*/
+			chCiAFactoryType = GetCiFactoryType(ciA);
+			chCiBFactoryType = GetCiFactoryType(ciB);
+			if (chCiAFactoryType == chCiBFactoryType)
 			{
 				retVal = SAME_LINE_YES;
 			}
@@ -145,17 +143,14 @@ UINT8 IsSameLineCI(const UINT8 ciA, const UINT8 ciB)
 		}
 		else
 		{
-			retVal = SAME_LINE_ERR;
+			retVal = SAME_LINE_NO;
 		}
-	}/* zt 删除单轨相关代码 2022-02-15 */
-	else if (DQU_CBTC_CC == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;
 	}
 	else
 	{
 		retVal = SAME_LINE_ERR;
 	}
+	
 	return retVal;
 }
 /*
@@ -202,28 +197,55 @@ UINT32 GetCiTranCiDataCheckVer(const UINT8 ciId, const UINT16 deviceName)
 	UINT32 retDataVer = CI_ERROR;
 	UINT8 ii = 0U;
 	UINT8 chBreakFlag = 0U;
-
+	UINT8 chDevType = 0U;
-	if ((ciId > 0U) && (ciId < CI_SUM_MAX) && (deviceName > 0U))
+	chDevType = (UINT8)((deviceName & 0xFF00u) >> 8U);
+	if ((ciId > 0U) && (ciId < CI_SUM_MAX) && 
+		((RC_WORK_MODE_CI == chDevType)||(RC_WORK_MODE_TIOC == chDevType)))
 	{
 		if (gEmapCiConfigStrus[ciId].devId == ciId)
 		{
-			for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinCICount; ii++)
+			if (RC_WORK_MODE_CI == chDevType)
 			{
-				if (ii < CI_TRAINSMIT_CI_MAX_NUM)
+				for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinCICount; ii++)
 				{
-					if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinCIId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] < 0xFFFFU))
+					if (ii < CI_TRAINSMIT_CI_MAX_NUM)
+					{
+						if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinCIId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] < 0xFFFFU))
+						{
+							retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinCIShareCheckData[ii];
+							chBreakFlag = 1U;
+						}
+					}
+					else
 					{
-						retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinCIShareCheckData[ii];
 						chBreakFlag = 1U;
 					}
+					if (1U == chBreakFlag)
+					{
+						break;
+					}
 				}
-				else
+			}
+			else
+			{
+				for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinRCCount; ii++)
 				{
-					chBreakFlag = 1U;
+					if (ii < CI_TRAINSMIT_CI_MAX_NUM)
-				}
+					{
-				if (1U == chBreakFlag)
+						if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinRCId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinRCId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinRCId[ii] < 0xFFFFU))
-				{
+						{
-					break;
+							retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinRCShareCheckData[ii];
+							chBreakFlag = 1U;
+						}
+					}
+					else
+					{
+						chBreakFlag = 1U;
+					}
+					if (1U == chBreakFlag)
+					{
+						break;
+					}
 				}
 			}
 		}

TSCP/src/APP/ciapp/DataManage/DeviceConfigDataManage.h

@@ -36,11 +36,15 @@ typedef struct S_EmapCheckVerConfigStruct
 	UINT8  chAdjoinCICount;		/*相邻CI数量*/
 	UINT16 wAdjoinCIId[CI_TRAINSMIT_CI_MAX_NUM];        /*相邻CI[1-6]的ID*/
 	UINT32 dwAdjoinCIShareCheckData[CI_TRAINSMIT_CI_MAX_NUM];        /*与相邻CI[1-6]的共用数据校验信息*/
+	UINT8  chAdjoinRCCount;		/*相邻RC数量*/
+	UINT16 wAdjoinRCId[CI_TRAINSMIT_CI_MAX_NUM];        /*相邻RC[1-6]的ID*/
+	UINT32 dwAdjoinRCShareCheckData[CI_TRAINSMIT_CI_MAX_NUM];        /*与相邻RC[1-6]的共用数据校验信息*/
 	UINT16 ciTransmitAxisId[CI_TRAINSMIT_AXIS_MAX_NUM];/*与联锁通信的计轴系统ID*/
 	UINT32 ciTransmitAxisCheckData[CI_TRAINSMIT_AXIS_MAX_NUM];/*与联锁通信的计轴系统校验信息*/
 	UINT8 chAdjoinOcCount;			/*与CI通信的oc数量*/
 	UINT16 wAdjoinOcId[CI_TRAINSMIT_OC_MAX_NUM];        /*Oc[1-10]的ID*/
 	UINT32 dwAdjoinOcShareCheckData[CI_TRAINSMIT_OC_MAX_NUM];        /*与OC[1-10]的共用数据校验信息*/
+	UINT32 dwLocalShareCheckData; /*与本控区RC/CI校验信息*/
 } EmapCiConfigStru;
 
 extern EmapCiConfigStru gEmapCiConfigStrus[CI_SUM_MAX];/*存储各CI使用的电子地图版本*/

TSCP/src/APP/ciapp/DataManage/DeviceDataManage.h

@@ -72,8 +72,13 @@ typedef struct S_AreaSnowInfoStruct
  * 其他联锁条件状态定义
  *--------------------------------------------------------------------------*/
 /* 其他联锁条件检查配置状态相关定义 */
-#define LOCAL_AREA_SNOW_SUM_MAX   ((UINT8)20)     /*本控区及相邻控区发送的区间雨雪站台数量*/
+#define LOCAL_AREA_SNOW_SUM_MAX		((UINT8)20)			/*本控区及相邻控区发送的区间雨雪站台数量*/
-#define ALL_AREA_SNOW_SUM_MAX     ((UINT8)254)    /*TMC发送的全线区间雨雪站台数量*/
+#define ALL_AREA_SNOW_SUM_MAX		((UINT8)254)		/*TMC发送的全线区间雨雪站台数量*/
+#define ALL_CBTC_CROSS_SUM_MAX		((UINT8)253)		/*CBTC跨压最大数量*/
+#define ALL_TACS_CROSS_SUM_MAX		((UINT8)253)		/*TACS跨压最大数量*/
+#define CROSS_SIGNAL_ID_MAX			((UINT16)1499)		/*跨压信号机ID最大值*/
+#define CBTC_CROSS_ID_MAX			((UINT8)253)		/*CBTC跨压最大列车ID*/
+#define TACS_CROSS_ID_MAX			((UINT8)253)		/*TACS跨压最大列车ID*/
 
 /* 1	信号机	
 开放0x55
@@ -164,19 +169,6 @@ typedef struct S_LineCommTrainStruct
 	UINT16 szCommTrainNumID[TRAIN_SUM_MAX];	 /*全线通信车ID数组*/
 }LineCommTrainStruct;
 
-/*区间牵引加速度信息结构体*/
-typedef struct S_AreaAccelerationInfoStruct
-{
-	UINT16 wAreaId;	 /*区间ID*/
-	UINT8 cAreaAccelerationValue;  /*区间牵引加速度值*/
-} AreaAccelerationInfoStruct;
-
-/*区间制动率信息结构体*/
-typedef struct S_AreaBrakeRateInfoStruct
-{
-	UINT16 wAreaId;	 /*区间ID*/
-	UINT8 cAreaBrakeRateValue;  /*区间制动率值*/
-} AreaBrakeRateInfoStruct;
 
 /*******************************全局变量声明*******************************/
 extern UINT8 AllSignalBrightFlag;					                  /*全站亮灯标志*/
@@ -203,6 +195,8 @@ extern UINT8 g_AllTsrFlag;												  /*
 
 extern UINT8 g_AllSnowModel;                                                 /*全线雨雪模式命令*/
 
+extern UINT8 g_AllSnowModelCC;                                                 /*全线雨雪模式命令CC：0x55-有效；0xAA-无效*/
+
 extern UINT8 g_AllSnowLevel;                                                 /*全线湿轨级别：0-默认值；1-一级；2-二级*/
 
 extern UINT8 g_IteLineCutState;                                          /*ITE全线切除状态：0x55：切除ITE；0xAA：使用ITE；0xFF：默认值*/
@@ -232,8 +226,6 @@ extern UINT8 comm_Train_Test_YSKJ_SCX_State;				/*
 extern UINT8 comm_Train_Test_SQJ_CLD_State;				/*试车线与车辆段采用通信接口时车辆段SQJ状态*/
 extern UINT8 comm_Train_Test_TYSJ_CLD_State;				/*试车线与车辆段采用通信接口时车辆段TYSJ状态*/
 
-extern UINT8 ZCToCIAutoRtnIndict_Flash_Sta;			/*ZC给CI的无人折返灯闪灯状态*/
-extern UINT8 ZCToCIAutoRtnIndict_Steady_Sta;		/*ZC给CI的无人折返灯稳灯状态*/
 extern UINT8 AutoTriggerFlag;                                             /*自动触发标志初始化为未设置*/
 
 extern UINT8 CiCiRelayInterfaceConfirmFlag;/*继电接口确认标志*/
@@ -245,26 +237,19 @@ extern CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX];
 extern UINT8 LocalAreaSnowNum;  /*本地区间雨雪站台数量*/
 extern AreaSnowInfoStruct szLocalAreaSnow[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间雨雪数组*/
 
+extern UINT8 gLocalAreaSnowNumCC;  /*本地区间雨雪站台数量CC*/
+extern AreaSnowInfoStruct gszLocalAreaSnowCC[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间雨雪数组CC*/
+
 extern LineCommTrainStruct gStrLineCommTrain;  /*全线通信车结构体*/
 
 extern UINT32 gFlyProtectOverCyc;										                  /*飞车宕机报警起始周期*/
 extern UINT8 g_LocalSnowModel;     /*本地雨雪模式命令*/
 
+extern UINT8 g_LocalSnowModelCC;   /*本地雨雪模式命令CC*/
+
 extern UINT8 gLocalAreaIteCutNum;  /*本地区间ITE切除数量*/
 extern UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*本地区间ITE切除ID数组*/
 
-extern UINT8 gAllLineAccelerationState;  /*全线牵引加速度设置状态：0x55-未设置；0xAA-已设置*/
-extern UINT8 gAllLineAccelerationValue;  /*全线牵引加速度设置值*/
-
-extern UINT8 gAllLineBrakeRateState;  /*全线制动率设置状态：0x55-未设置；0xAA-已设置*/
-extern UINT8 gAllLineBrakeRateValue;  /*全线制动率设置值*/
-
-extern UINT8 gLocalAreaAccelerationNum;  /*本地区间牵引加速度数量*/
-extern AreaAccelerationInfoStruct gszLocalAreaAcceleration[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间牵引加速度数组*/
-
-extern UINT8 gLocalAreaBrakeRateNum;  /*本地区间制动率数量*/
-extern AreaBrakeRateInfoStruct gszLocalAreaBrakeRate[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间制动率数组*/
-
 /******************************联锁标志数据管理****************************/
 
 /*
@@ -313,13 +298,6 @@ void SetStartLockFlag(UINT8 setFlag);
 			LINSHIXIANSU_COMM_BAD_YES_LABOURCANCLE_STATE
 */
 UINT8 GetLabourCancelLinShiXianState(void);
-
-/*
-	功能描述：人工取消临时限速状态迁移处理
-	参数说明：setFlag  状态
-	返回值：无
-*/
-void LabourCancelLSXianStaMoveProc(UINT8 setFlag);
 /*
 	功能描述：人工取消临时限速状态迁移处理
 	参数说明：setFlag  状态,UINT8 virCIid 虚拟联锁ID
@@ -1794,7 +1772,7 @@ AreaSnowInfoStruct* GetLocalAreaSnow(void);
 * 返回值  ：  0 第一个锁闭的区段不是故障锁闭
 *            1 第一个锁闭的区段是故障锁闭
 */
-UINT8 RouteFirstLockErrCheck(UINT16 routeId, UINT16 *pPhySecId);
+UINT8 RouteFirstLockErrCheck(UINT16 routeId);
 
 /*
 * 功能描述：获取全线通信车数据
@@ -1922,163 +1900,114 @@ void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCut
 * Created By LQ 2025.05.08
 */
 UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId);
-
 /*
-* 功能描述： 道岔单操可动作物理区段检查
+* 功能描述：紧急临时限速处理
-* 参数说明： UINT16 phySecId，物理区段Id
+* 参数说明：const UINT16 wPhySectionId 逻辑区段ID
-*			 UINT8	oper_src,操作来源
+*           const UINT8 chExiansuState 限速状态
-*			 UINT8 sendLevel，发送级别
-* 返回值  ： CI_SUCCESS: 检查成功
-*			 CI_ERROR: 检查失败
-*/
-UINT8 GetDanCaoPhySecValidState(UINT16 phySecId, UINT8 oper_src, UINT8 sendLevel);
-
-/*
-* 功能描述： 道岔强扳可动作物理区段检查
-* 参数说明： UINT16 phySecId，物理区段Id
-*			 UINT8 sendLevel，发送级别
-* 返回值  ： CI_SUCCESS: 检查成功
-*			 CI_ERROR: 检查失败
-*/
-UINT8 GetForcePhySecValidState(UINT16 phySecId, UINT8 sendLevel);
-
-/*
-* 功能描述： 道岔常态位置检查
-* 参数说明： UINT16 wSwitchId，道岔Id
-* 返回值  ： 无
-*/
-void CheckSwitchNomalPosProc(const UINT16 wSwitchId);
-
-/*
-* 功能描述： 道岔定反操互斥条件检查
-* 参数说明： const UINT16 wSwitchId, 道岔ID
-* 返回值  ：CI_SUCCESS: 检查成功
-*			 CI_ERROR: 检查失败
-*/
-UINT8 CheckSwitchDFMulValid(const UINT16 wSwitchId, const UINT8 chSwitchPos);
-
-/*
-* 功能描述： 道岔常态位置检查道岔封锁和道岔区段(包含额外物理区段)封锁
-* 参数说明： UINT16 wSwitchId，道岔Id
-* 返回值  ： CI_ERROR
-*            CI_SUCCESS
-*/
-UINT8 GetSwitchAndSecFLockState(const UINT16 wSwitchId);
-
-/*
-* 功能描述：获取全线牵引加速度设置状态
-* 参数说明：无
-* 返 回 值：0x55 未设置
-*           0xAA 已设置
-* Created By LQ 2026.02.04
-*/
-UINT8 GetAllLineAccelerationState(void);
-
-/*
-* 功能描述：获取全线牵引加速度设置状态
-* 参数说明：UINT8 setState 全线牵引加速度设置状态
 * 返 回 值：无
-* Created By LQ 2026.02.04
+* by 202500916
 */
-void SetAllLineAccelerationState(UINT8 setState);
+
+void EmergXianSuProcess(const UINT16 wPhySectionId, const UINT8 chExiansuState);
 
 /*
-* 功能描述：获取全线牵引加速度设置值
+* 功能描述：获取全线雨雪模式命令CC
+* 参数说明：void
+* 返 回 值：0x55 有效
+*           0xAA 无效
+* Created By LQ 2025.11.07
+*/
+UINT8 GetAllSnowModelCC(void);
+
+/*
+* 功能描述：设置全线雨雪模式命令CC
+* 参数说明：UINT8 setmodle 全线雨雪模式
+* 返 回 值：void
+* Created By LQ 2025.11.07
+*/
+void SetAllSnowModelCC(UINT8 setmodle);
+
+/*
+* 功能描述：获取本地区间雨雪站台数量CC
 * 参数说明：无
-* 返 回 值：全线牵引加速度设置值
+* 返 回 值：区间雨雪站台数量
-* Created By LQ 2026.02.04
+* Created By LQ 2025.11.06
 */
-UINT8 GetAllLineAccelerationValue(void);
+UINT8 GetLocalAreaSnowNumCC(void);
 
 /*
-* 功能描述：设置全线牵引加速度设置值
+* 功能描述：获取本地区间雨雪信息CC
-* 参数说明：UINT8 setValue 全线牵引加速度设置值
+* 参数说明：无
+* 返 回 值：区间雨雪信息
+* Created By LQ 2025.11.06
+*/
+AreaSnowInfoStruct* GetLocalAreaSnowCC(void);
+
+/*
+* 功能描述：设置本地区间雨雪站台信息CC
+* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
+*			const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
 * 返 回 值：无
-* Created By LQ 2026.02.04
+* Created By LQ 2025.11.06
 */
-void SetAllLineAccelerationValue(UINT8 setValue);
+void SetLocalAreaSnowInfoCC(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX]);
 
 /*
-* 功能描述：获取全线制动率设置状态
+* 功能描述：获取本地雨雪模式命令CC
 * 参数说明：无
-* 返 回 值：0x55 未设置
+* 返 回 值：0x55 无效
-*           0xAA 已设置
+*           0xAA 有效
-* Created By LQ 2026.02.04
+* Created By LQ 2025.11.06
 */
-UINT8 GetAllLineBrakeRateState(void);
+UINT8 GetLocalSnowModelCC(void);
 
 /*
-* 功能描述：设置全线制动率设置状态
+* 功能描述：设置本地雨雪模式命令CC
-* 参数说明：UINT8 setState 全线制动率设置状态
+* 参数说明：UINT8 setmodle 本地雨雪模式
 * 返 回 值：无
-* Created By LQ 2026.02.04
+* Created By LQ 2025.11.06
 */
-void SetAllLineBrakeRateState(UINT8 setState);
+void SetLocalSnowModelCC(UINT8 setmodle);
-
 /*
-* 功能描述：获取全线牵引加速度设置值
+* 功能描述： 获取虚拟联锁类型
+* 参数说明： UINT8 chVirCiId 虚拟联锁ID
+* 返回值  ：
+			CI_TYPE_ZX                ((UINT8)0x01)     正线联锁
+			CI_TYPE_CLD               ((UINT8)0x04)     车辆段联锁
+			CI_TYPE_SCX				  ((UINT8)0x02)		试车线
+add by mpt 20260104
+*/
+UINT8 GetLocalVirCiType(UINT8 chVirCiId);
+/*
+* 功能描述：判断本联锁临时限速状态
 * 参数说明：无
-* 返 回 值：全线牵引加速度设置值
+* 返 回 值：临时限速有效返回失败，清除或与ZC通信正常返回成功
-* Created By LQ 2026.02.04
+* Created :LYJ
 */
-UINT8 GetAllLineBrakeRateValue(void);
 
+UINT8 CheckLocalCiLSXSStata(void);
 /*
-* 功能描述：设置全线牵引加速度设置值
+功能描述:
-* 参数说明：UINT8 setValue 全线牵引加速度设置值
+	清除逻辑区段关联道岔单操位置
-* 返 回 值：无
+输入参数:
-* Created By LQ 2026.02.04
+	const UINT16 逻辑区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
 */
-void SetAllLineBrakeRateValue(UINT8 setValue);
+void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId);
-
 /*
-* 功能描述：设置本地区间牵引加速度信息
+功能描述:
-* 参数说明：const UINT8 cAreaNum 区间数量
+	清除计轴区段关联道岔单操位置
-*			const AreaAccelerationInfoStruct pAreaAccBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间牵引加速度数组
+输入参数:
-* 返 回 值：无
+	const UINT16 计轴区段ID
-* Created By LQ 2026.02.04
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
 */
-void SetLocalAreaAccelerationInfo(const UINT8 cAreaNum, const AreaAccelerationInfoStruct pAreaAccBuf[LOCAL_AREA_SNOW_SUM_MAX]);
+void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId);
-
-/*
-* 功能描述：获取本地区间牵引加速度数量
-* 参数说明：无
-* 返 回 值：区间牵引加速度数量
-* Created By LQ 2026.02.04
-*/
-UINT8 GetLocalAreaAccelerationNum(void);
-
-/*
-* 功能描述：获取本地区间牵引加速度信息
-* 参数说明：无
-* 返 回 值：区间牵引加速度信息
-* Created By LQ 2026.02.04
-*/
-AreaAccelerationInfoStruct* GetLocalAreaAcceleration(void);
-
-/*
-* 功能描述：设置本地区间制动率信息
-* 参数说明：const UINT8 cAreaNum 区间数量
-*			const AreaBrakeRateInfoStruct pAreaBrakeBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间制动率数组
-* 返 回 值：无
-* Created By LQ 2026.02.04
-*/
-void SetLocalAreaBrakeRateInfo(const UINT8 cAreaNum, const AreaBrakeRateInfoStruct pAreaBrakeBuf[LOCAL_AREA_SNOW_SUM_MAX]);
-
-/*
-* 功能描述：获取本地区间制动率数量
-* 参数说明：无
-* 返 回 值：区间制动率数量
-* Created By LQ 2026.02.04
-*/
-UINT8 GetLocalAreaBrakeRateNum(void);
-
-/*
-* 功能描述：获取本地区间制动率信息
-* 参数说明：无
-* 返 回 值：区间制动率信息
-* Created By LQ 2026.02.04
-*/
-AreaBrakeRateInfoStruct* GetLocalAreaBrakeRate(void);
-
 #endif

TSCP/src/APP/ciapp/DataManage/PlatDataManage.c

@@ -17,7 +17,7 @@
 
 extern PlatHeartDataStruct RecvHeartDataStru ;  /*平台心跳帧数据结构*/
 extern PlatGPIODataStruct RecvPlatDataStruGPIO;/*平台0x2D帧数据结构 GPIO采集状态*/
-
+extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;/*平台硬件采集故障容忍记录数据*/
 
 
 
@@ -427,18 +427,36 @@ UINT8 CheckRCIAPowerFaultState(void)
 {
 	UINT8 retVal = CI_ERROR;
 	UINT8 cxABreakFlag = 0U; /*A系电源插箱空开断开检查*/
-
+	UINT8 chCheckState = 0U;
+	UINT32 dwErrorStartCyc = 0U;
+	UINT32 dwCurCyc = 0U;
 	cxABreakFlag = GetPowerANodeStatue();
-
+	dwErrorStartCyc = gPlatDataGPIOTolercance.powerANode_TolCyc;
+	dwCurCyc = Get2oo2CurCycleNum();
 	/* 1、A系电源插箱空开断开 */
 	if (NODE_STATUS_BREAK == cxABreakFlag)
 	{
 		/*A系电源故障状态*/
-		retVal = CI_ERROR;
+		chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
+		if (CI_TIME_NO == chCheckState)
+		{
+			gPlatDataGPIOTolercance.powerANode_TolCyc = dwCurCyc;
+			retVal = CI_SUCCESS;
+		}
+		else if (CI_TIME_IN == chCheckState)
+		{
+			retVal = CI_SUCCESS;/*继续容忍*/
+		}
+		else
+		{
+			retVal = CI_ERROR;
+			debug_infor_printf((const)"\nPLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
+		gPlatDataGPIOTolercance.powerANode_TolCyc = 0U;
 	}
 	return retVal;
 }
@@ -453,18 +471,36 @@ UINT8 CheckRCIBPowerFaultState(void)
 {
 	UINT8 retVal = CI_ERROR;
 	UINT8 cxBBreakFlag = 0U; /*B系电源插箱空开断开检查*/
-
+	UINT8 chCheckState = 0U;
+	UINT32 dwErrorStartCyc = 0U;
+	UINT32 dwCurCyc = 0U;
 	cxBBreakFlag = GetPowerBNodeStatue();
-
+	dwErrorStartCyc = gPlatDataGPIOTolercance.powerBNode_TolCyc;
-	/* 1、B系电源插箱空开断开 */
+	dwCurCyc = Get2oo2CurCycleNum();
+	/* 1、B系电源插箱空开断开*/
 	if (NODE_STATUS_BREAK == cxBBreakFlag)
 	{
 		/*B系电源故障状态*/
-		retVal = CI_ERROR;
+		chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
+		if (CI_TIME_NO == chCheckState)
+		{
+			gPlatDataGPIOTolercance.powerBNode_TolCyc = dwCurCyc;
+			retVal = CI_SUCCESS;
+		}
+		else if (CI_TIME_IN == chCheckState)
+		{
+			retVal = CI_SUCCESS;/*继续容忍*/
+		}
+		else
+		{
+			retVal = CI_ERROR;
+			debug_infor_printf((const)"\nPLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
+		gPlatDataGPIOTolercance.powerBNode_TolCyc = 0U;
 	}
 	return retVal;
 }
@@ -479,16 +515,20 @@ UINT8 CheckRCIBPowerFaultState(void)
 UINT8 CheckRCIAPowerModeFaultState(void)
 {
 	UINT8 retVal = CI_ERROR;
-
 	UINT8 powerAPUBAState = 0U; /*PUB A采集的24VA电源状态 1*/
 	UINT8 powerBPUBAState = 0U; /*PUB A采集的24VB电源状态 3*/
 	UINT8 vol1Flag = 0U;       /*CPI A采集24VA电源 1*/
 	UINT8 vol3Flag = 0U;       /*CPI A采集24VB电源 3*/
+	UINT8 chCheckState = 0U;
+	UINT32 dwErrorStartCyc = 0U;
+	UINT32 dwCurCyc = 0U;
 
 	powerAPUBAState = GetGPIOCollectPointStatus(COLLECT_MODEA_CCUA);
 	powerBPUBAState = GetGPIOCollectPointStatus(COLLECT_MODEB_CCUA);
 	vol1Flag = CheckPointVoltageState(COLLECT_MODEA_CCUA);
 	vol3Flag = CheckPointVoltageState(COLLECT_MODEB_CCUA);
+	dwErrorStartCyc = gPlatDataGPIOTolercance.powerAMode_TolCyc;
+	dwCurCyc = Get2oo2CurCycleNum();
 
 	/* 1、PUB A采集的24VA电源异常、或24VB电源异常
 	   2、CPI A采集24VA电源、或24VB电源电压为0V */
@@ -496,11 +536,27 @@ UINT8 CheckRCIAPowerModeFaultState(void)
 	if (((CHECK_VOLTAGE_ZERO == vol1Flag) || (CHECK_VOLTAGE_ZERO == vol3Flag))
 		&& ((POWER_STATUS_ABNORMAL == powerAPUBAState) || (POWER_STATUS_ABNORMAL == powerBPUBAState)))
 	{
-		retVal = CI_ERROR;
+		/*检查容忍*/
+		chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
+		if (CI_TIME_NO == chCheckState)
+		{
+			gPlatDataGPIOTolercance.powerAMode_TolCyc = dwCurCyc;
+			retVal = CI_SUCCESS;
+		}
+		else if (CI_TIME_IN == chCheckState)
+		{
+			retVal = CI_SUCCESS;/*继续容忍*/
+		}
+		else
+		{
+			retVal = CI_ERROR;
+			debug_infor_printf((const)"\nPLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
+		gPlatDataGPIOTolercance.powerAMode_TolCyc = 0U;
 	}
 	
 	return retVal;
@@ -520,25 +576,43 @@ UINT8 CheckRCIBPowerModeFaultState(void)
 	UINT8 powerBPUBBState = 0U; /*PUB A采集的24VB电源状态 4*/
 	UINT8 vol2Flag = 0U;       /*CPI B采集24VA电源 2*/
 	UINT8 vol4Flag = 0U;       /*CPI B采集24VB电源 4*/
+	UINT8 chCheckState = 0U;
+	UINT32 dwErrorStartCyc = 0U;
+	UINT32 dwCurCyc = 0U;
 
 	powerAPUBBState = GetGPIOCollectPointStatus(COLLECT_MODEA_CCUB);
 	powerBPUBBState = GetGPIOCollectPointStatus(COLLECT_MODEB_CCUB);
 	vol2Flag = CheckPointVoltageState(COLLECT_MODEA_CCUB);
 	vol4Flag = CheckPointVoltageState(COLLECT_MODEB_CCUB);
+	dwErrorStartCyc = gPlatDataGPIOTolercance.powerBMode_TolCyc;
+	dwCurCyc = Get2oo2CurCycleNum();
 
 	/* 1、PUB B采集的24VA电源异常、或24VB电源异常
-       2、CPI B采集24VA电源、或24VB电源电压为0V */
+	2、CPI B采集24VA电源、或24VB电源电压为0V */
-
-
-	   /*暂未实现PUB采集，只判断电源电压*/
 	if (((CHECK_VOLTAGE_ZERO == vol2Flag) || (CHECK_VOLTAGE_ZERO == vol4Flag))
 		&& ((POWER_STATUS_ABNORMAL == powerAPUBBState) || (POWER_STATUS_ABNORMAL == powerBPUBBState)))
 	{
-		retVal = CI_ERROR;
+		/*检查容忍*/
+		chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
+		if (CI_TIME_NO == chCheckState)
+		{
+			gPlatDataGPIOTolercance.powerBMode_TolCyc = dwCurCyc;
+			retVal = CI_SUCCESS;
+		}
+		else if (CI_TIME_IN == chCheckState)
+		{
+			retVal = CI_SUCCESS;/*继续容忍*/
+		}
+		else
+		{
+			retVal = CI_ERROR;
+			debug_infor_printf((const)"\nPLATIO_B_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
+		gPlatDataGPIOTolercance.powerBMode_TolCyc = 0U;
 	}
 
 	return retVal;

TSCP/src/APP/ciapp/DataManage/PlatDataManage.h

@@ -16,7 +16,7 @@
 
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
-
+#include "../System/SystemParameterManage.h"
 
 
 #define BOARD_TYPE_CCUA   ((UINT8)0x09)     /*通控板A*/
@@ -59,6 +59,7 @@
 #define CCU_CommBadEnsureTime_CycleCount   	((UINT16)5u)	  /*应用与通控通信中断判断周期数*/  
 
 #define VOLTAGE_MAX_TO_0        ((UINT16)500U)           /*电压判断为0的阈值*/
+#define IO_POWERSTATE_TOLERANCE   ((UINT8)0x02)           /*平台电源报警容忍周期数，容忍3周期，超过2周期报警*/
 
 /*平台心跳帧信息结构*/
 typedef struct S_PlatHeartDataStruct
@@ -100,7 +101,14 @@ typedef struct S_PlatGPIODataStruct
 	UINT8 ModepowerBState_PUB;                             /*机柜B系电源插箱中为CPUB供电的24VDC电源模块状态*/
 }PlatGPIODataStruct;
 
-
+/*平台发送的电源采集状态容忍同步数据*/
+typedef struct S_PlatGPIOToleranceData
+{
+	UINT32 powerANode_TolCyc;                                 /*A系电源插箱的故障容忍起始周期*/
+	UINT32 powerBNode_TolCyc;                                  /*B系电源插箱的故障容忍起始周期*/
+	UINT32 powerAMode_TolCyc;                             /*A系电源模块的故障容忍起始周期*/
+	UINT32 powerBMode_TolCyc;                              /*B系电源模块的故障容忍起始周期*/
+}PlatGPIOToleranceDataStruct;
 
 
 

TSCP/src/APP/ciapp/ECS/ECSConfigDataManage.c

@@ -1,386 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ECSConfigDataManage.c
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2026.01.24
-* 作    者： 联锁组
-* 功能描述： 环境控制系统配置数据
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#include "ECSConfigDataManage.h"
-
-ECSConfigDataStruct ECSConfigDataStru[ECS_MAX_NUM] = { 0U };	/*ECS配置数据结构体*/
-INT16 ECSCurSum = 0;   /*ECS当前总数*/
-UINT16 LocalCiECSIdBuf[ECS_MAX_NUM] = { 0U };   /*定义本地联ECS ID数组*/
-
-/*
-* 功能描述：获取指定ID ECS索引号
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：ECS_MAX_NUM 10 获取数据失败
-*			其它 ECS索引号
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsConfigBufIndex(const UINT16 EcslId)
-{
-	UINT16 wRetVal = ECS_MAX_NUM;
-
-	if ((1U <= EcslId) && (ECS_MAX_NUM > EcslId))
-	{
-		wRetVal = EcslId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-	}
-
-	return wRetVal;
-}
-
-/*
-* 功能描述：获取ECS当前总数
-* 参数说明：void
-* 返 回 值：ECS当前总数
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsCurSum(void)
-{
-	UINT16 wRetVal = 0U;
-
-	if ((INT16)ECS_MAX_NUM <= ECSCurSum)
-	{
-		wRetVal = ECS_MAX_NUM;
-	}
-	else if (0 > ECSCurSum)
-	{
-		wRetVal = 0U;
-	}
-	else
-	{
-		wRetVal = (UINT16)ECSCurSum;
-	}
-
-	return wRetVal;
-}
-
-/*
-* 功能描述：获取指定数组下标对应的ECS ID
-* 参数说明：const UINT16 bufIndex 数组下标
-* 返 回 值：0 获取数据失败
-*			其它 ECS ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsId(const UINT16 bufIndex)
-{
-	UINT16 wRetVal = CI_ERROR;
-	UINT16 wEcsCurNum = 0U;
-
-	wEcsCurNum = GetEcsCurSum();
-
-	if (bufIndex < wEcsCurNum)
-	{
-		wRetVal = LocalCiECSIdBuf[bufIndex];
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		wRetVal = CI_ERROR;
-	}
-
-	return wRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS所属控区ID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 控区ID
-* Created By LQ 2026.01.24
-*/
-UINT8 GetEcsBelongCiId(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT8 cRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		cRetVal = ECSConfigDataStru[bufIndex].cBelongCiId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		cRetVal = CI_ERROR;
-	}
-
-	return cRetVal;
-}
-
-/*
-* 功能描述：整理读入的ECS配置数据
-* 参数说明：无
-* 返 回 值：CI_SUCCESS 1 整理成功
-*			CI_ERROR 0 整理失败
-* Created By LQ 2026.01.27
-*/
-UINT8 EcsConfigDataManage(void)
-{
-	UINT16 ii = 0U;
-	UINT16 jj = 0U;
-	UINT16 wEcsCurSum = 0U;  /*ECS配置数据总数*/
-	UINT8 cLocalCiId = 0U;
-	UINT8 retVal = CI_ERROR;
-
-	wEcsCurSum = GetEcsCurSum();
-
-	if (ECS_MAX_NUM > wEcsCurSum)
-	{
-		retVal = CI_SUCCESS;
-
-		for (ii = 0U; ii < ECS_MAX_NUM; ii++)
-		{
-			cLocalCiId = GetSystemParaLocalCiId();
-
-			if (ECSConfigDataStru[ii].cBelongCiId == cLocalCiId)
-			{
-				if (wEcsCurSum > jj)
-				{
-					LocalCiECSIdBuf[jj] = ECSConfigDataStru[ii].wEcsId;  /*存储本控区的ECS ID*/
-					jj++;
-				}
-				else
-				{
-					break;  /*数量超限，停止遍历*/
-				}
-			}
-			else
-			{
-				/*继续初始化*/
-			}
-		}
-	}
-	else
-	{
-		retVal = CI_ERROR;  /*数据超限，返回失败*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS起点linkID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			起点linkID
-* Created By LQ 2026.01.26
-*/
-UINT16 GetEcsStartLinkId(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16 wRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		wRetVal = ECSConfigDataStru[bufIndex].wStartLinkId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		wRetVal = CI_ERROR;
-	}
-
-	return wRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS起点link偏移量
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：起点link偏移量
-* Created By LQ 2026.01.26
-*/
-UINT32 GetEcsStartLinkOff(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT32 dwRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		dwRetVal = ECSConfigDataStru[bufIndex].dwStartLinkOff;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		dwRetVal = CI_ERROR;
-	}
-
-	return dwRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS终点linkID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			终点linkID
-* Created By LQ 2026.01.26
-*/
-UINT16 GetEcsEndLinkId(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16 wRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		wRetVal = ECSConfigDataStru[bufIndex].wEndLinkId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		wRetVal = CI_ERROR;
-	}
-
-	return wRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS终点link偏移量
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：终点link偏移量
-* Created By LQ 2026.01.26
-*/
-UINT32 GetEcsEndLinkOff(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT32 dwRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		dwRetVal = ECSConfigDataStru[bufIndex].dwEndLinkOff;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		dwRetVal = CI_ERROR;
-	}
-
-	return dwRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS关联的物理区段数量
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 ECS关联的物理区段数量
-* Created By LQ 2026.01.24
-*/
-UINT8 GetEcsRelPhySecNum(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT8 cRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		cRetVal = ECSConfigDataStru[bufIndex].cRelPhySecNum;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		cRetVal = CI_ERROR;
-	}
-
-	return cRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS关联的物理区段ID数组
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：NULL 获取数据失败
-*			其它 ECS关联的物理区段ID数组
-* Created By LQ 2026.01.24
-*/
-UINT16* GetEcsRelPhySecId(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16* pRetVal = NULL;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		pRetVal = ECSConfigDataStru[bufIndex].szRelPhySecId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		pRetVal = NULL;
-	}
-
-	return pRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS关联的风向为逻辑正方向的继电器ID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 继电器ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsRelFanUpRelayId(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16 wRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		wRetVal = ECSConfigDataStru[bufIndex].wFanUpRelayId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		wRetVal = CI_ERROR;
-	}
-
-	return wRetVal;
-}
-
-/*
-* 功能描述：获取指定ID ECS关联的风向为逻辑反方向的继电器ID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 继电器ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsRelFanDownRelayId(const UINT16 EcslId)
-{
-	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16 wRetVal = CI_ERROR;
-
-	bufIndex = GetEcsConfigBufIndex(EcslId);
-
-	if (ECS_MAX_NUM > bufIndex)
-	{
-		wRetVal = ECSConfigDataStru[bufIndex].wFanDownRelayId;
-	}
-	else
-	{
-		/*入参非法，返回失败*/
-		wRetVal = CI_ERROR;
-	}
-
-	return wRetVal;
-}

TSCP/src/APP/ciapp/ECS/ECSConfigDataManage.h

@@ -1,163 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ECSConfigDataConfig.h
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2026.01.24
-* 作    者： 联锁组
-* 功能描述： 环境控制系统配置数据
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#ifndef _ECS_CONFIG_DATA_MANAGE_H_
-#define _ECS_CONFIG_DATA_MANAGE_H_
-
-#include "CommonTypes.h"
-#include "ECSDefine.h"
-#include "CiSystemDefine.h"
-#include "SystemParameterManage.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct S_ECSConfigDataStruct
-{
-	UINT16 wEcsId;  /*ECS ID*/
-	UINT8 cBelongCiId;  /*所属CI ID*/
-	UINT16 wStartLinkId;  /*隧道起点link ID*/
-	UINT32 dwStartLinkOff;  /*隧道起点link偏移量*/
-	UINT16 wEndLinkId;  /*隧道终点link ID*/
-	UINT32 dwEndLinkOff;  /*隧道终点link偏移量*/
-	UINT8 cRelPhySecNum;  /*隧道关联物理区段数量*/
-	UINT16 szRelPhySecId[ECS_REL_PHYSEC_MAX_NUM];  /*隧道关联物理区段ID*/
-	UINT16 wBelongOcId;  /*所属OC ID*/
-	UINT16 wFanUpRelayId;  /*风向为逻辑正方向的继电器ID*/
-	UINT16 wFanDownRelayId;  /*风向为逻辑反方向的继电器ID*/	
-}ECSConfigDataStruct;
-
-extern ECSConfigDataStruct ECSConfigDataStru[ECS_MAX_NUM];	/*/*ECS配置数据结构体*/
-extern INT16 ECSCurSum;  /*ECS当前总数*/
-extern UINT16 LocalCiECSIdBuf[ECS_MAX_NUM];  /*定义本地联ECS ID数组*/
-
-/*
-* 功能描述：获取指定ID ECS索引号
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：ECS_MAX_NUM 10 获取数据失败
-*			其它 ECS索引号
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsConfigBufIndex(const UINT16 EcslId);
-
-/*
-* 功能描述：获取ECS当前总数
-* 参数说明：void
-* 返 回 值：ECS当前总数
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsCurSum(void);
-
-/*
-* 功能描述：获取指定数组下标对应的ECS ID
-* 参数说明：const UINT16 bufIndex 数组下标
-* 返 回 值：0 获取数据失败
-*			其它 ECS ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsId(const UINT16 bufIndex);
-
-/*
-* 功能描述：获取指定ID ECS所属控区ID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 控区ID
-* Created By LQ 2026.01.24
-*/
-UINT8 GetEcsBelongCiId(const UINT16 EcslId);
-
-/*
-* 功能描述：整理读入的ECS配置数据
-* 参数说明：无
-* 返 回 值：CI_SUCCESS 1 整理成功
-*			CI_ERROR 0 整理失败
-* Created By LQ 2026.01.27
-*/
-UINT8 EcsConfigDataManage(void);
-
-/*
-* 功能描述：获取指定ID ECS起点linkID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			起点linkID
-* Created By LQ 2026.01.26
-*/
-UINT16 GetEcsStartLinkId(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS起点link偏移量
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：起点link偏移量
-* Created By LQ 2026.01.26
-*/
-UINT32 GetEcsStartLinkOff(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS终点linkID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			终点linkID
-* Created By LQ 2026.01.26
-*/
-UINT16 GetEcsEndLinkId(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS终点link偏移量
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：终点link偏移量
-* Created By LQ 2026.01.26
-*/
-UINT32 GetEcsEndLinkOff(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS关联的物理区段数量
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 ECS关联的物理区段数量
-* Created By LQ 2026.01.24
-*/
-UINT8 GetEcsRelPhySecNum(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS关联的物理区段ID数组
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：NULL 获取数据失败
-*			其它 ECS关联的物理区段ID数组
-* Created By LQ 2026.01.24
-*/
-UINT16* GetEcsRelPhySecId(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS关联的风向为逻辑正方向的继电器ID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 继电器ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsRelFanUpRelayId(const UINT16 EcslId);
-
-/*
-* 功能描述：获取指定ID ECS关联的风向为逻辑反方向的继电器ID
-* 参数说明：const UINT16 EcslId ECS ID
-* 返 回 值：0 获取数据失败
-*			其它 继电器ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsRelFanDownRelayId(const UINT16 EcslId);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif

TSCP/src/APP/ciapp/ECS/ECSDataManage.h

@@ -1,293 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ECSDataManage.h
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2026.01.24
-* 作    者： 联锁组
-* 功能描述： 环境控制系统动态数据
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#ifndef _ECS_DATA_MANAGE_H_
-#define _ECS_DATA_MANAGE_H_
-
-#include "ECSDefine.h"
-#include "ECSConfigDataManage.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*环境控制系统动态数据结构体*/
-typedef struct S_ECSDataStruct
-{
-    UINT16 wEcsId;  /*ECS/隧道 ID*/
-    UINT8 cAutoTrigState;  /*ECS自动触发状态：0x55-启用，0xAA-停用*/
-    UINT16 wRelTrainId;  /*隧道关联列车ID*/
-    UINT32 dwTrainStopStartCycNum;  /*关联列车停车起始周期号*/
-    UINT32 dwTrainMoveStartCycNum;  /*关联列车移动起始周期号（通信车使用）*/
-    UINT8 cJamState;  /*隧道拥堵状态：0x55-拥堵，0xAA-不拥堵*/
-    UINT8 cOccPhySecNum;  /*隧道内占用的物理区段数量*/
-    UINT16 szOccPhySecId[ECS_REL_PHYSEC_MAX_NUM];  /*隧道内占用的物理区段ID数组*/
-}ECSDataStruct;
-
-extern ECSDataStruct ECSDataStru[ECS_MAX_NUM];	/*环境控制系统动态数据结构体*/
-
-/*
-* 功能描述：获取ECS动态数据结构体
-* 参数说明：
-* 返 回 值：ECS动态数据结构体
-* Created By LQ 2026.01.24
-*/
-ECSDataStruct* GetEcsData(void);
-
-/*
-* 功能描述：设置指定ID ECS自动触发状态
-* 参数说明：const UINT16 wEcsId ECS ID
-*			const UINT8 cState 自动触发状态
-* 返 回 值：无
-* Created By LQ 2026.01.24
-*/
-void SetEcsAutoTrigState(const UINT16 wEcsId, const UINT8 cState);
-
-/*
-* 功能描述：获取指定ID ECS自动触发状态
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：0 获取数据失败
-*			0x55 启用
-*           0xAA 停用
-* Created By LQ 2026.01.24
-*/
-UINT8 GetEcsAutoTrigState(const UINT16 wEcsId);
-
-/*
-* 功能描述：设置指定ID ECS关联列车ID
-* 参数说明：const UINT16 wEcsId ECS ID
-*			const UINT16 wTrainId 列车ID
-* 返 回 值：无
-* Created By LQ 2026.01.24
-*/
-void SetEcsRelTrainId(const UINT16 wEcsId, const UINT16 wTrainId);
-
-/*
-* 功能描述：获取指定ID ECS关联列车ID
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：ECS关联列车ID
-* Created By LQ 2026.01.24
-*/
-UINT16 GetEcsRelTrainId(const UINT16 wEcsId);
-
-/*
-* 功能描述：设置ECS关联列车停车起始周期
-* 参数说明：const UINT16 wEcsId ECS ID
-*           const UINT32 dwCycNum 周期号
-* 返 回 值：无
-* Created By LQ 2026.01.24
-*/
-void SetEcsTrainStopStartCycNum(const UINT16 wEcsId, const UINT32 dwCycNum);
-
-/*
-* 功能描述：获取ECS关联列车停车起始周期
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：ECS关联列车停车起始周期
-* Created By LQ 2026.01.24
-*/
-UINT32 GetEcsTrainStopStartCycNum(const UINT16 wEcsId);
-
-/*
-* 功能描述：设置ECS关联列车移动起始周期
-* 参数说明：const UINT16 wEcsId ECS ID
-*           const UINT32 dwCycNum 周期号
-* 返 回 值：无
-* Created By LQ 2026.01.24
-*/
-void SetEcsTrainMoveStartCycNum(const UINT16 wEcsId, const UINT32 dwCycNum);
-
-/*
-* 功能描述：获取ECS关联列车移动起始周期
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：ECS关联列车停车移动周期
-* Created By LQ 2026.01.24
-*/
-UINT32 GetEcsTrainMoveStartCycNum(const UINT16 wEcsId);
-
-/*
-* 功能描述：设置指定ID ECS拥堵状态
-* 参数说明：const UINT16 wEcsId ECS ID
-*			const UINT8 cState 拥堵状态
-* 返 回 值：无
-* Created By LQ 2026.01.24
-*/
-void SetEcsJamState(const UINT16 wEcsId, const UINT8 cState);
-
-/*
-* 功能描述：获取指定ID ECS拥堵状态
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：0 获取数据失败
-*			0x55 拥堵
-*           0xAA 不拥堵
-* Created By LQ 2026.01.24
-*/
-UINT8 GetEcsJamState(const UINT16 wEcsId);
-
-/*
-* 功能描述：更新指定ID ECS当前占用的物理区段信息
-* 参数说明：const UINT16 wEcsId ECS ID
-*           UINT16 pOccPhySecId[ECS_REL_PHYSEC_MAX_NUM] 当前占用的物理区段ID（出参）
-* 返 回 值：当前占用的物理区段数量
-* Created By LQ 2026.01.25
-*/
-UINT8 GetEcsCurOccPhySecInfo(const UINT16 wEcsId, UINT16 pOccPhySecId[ECS_REL_PHYSEC_MAX_NUM]);
-
-/*
-* 功能描述：清除指定ID ECS占用的物理区段信息
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：无
-* Created By LQ 2026.01.25
-*/
-void ClearEcsOccPhySecInfo(const UINT16 wEcsId);
-
-/*
-* 功能描述：更新指定ID ECS占用的物理区段信息
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：无
-* Created By LQ 2026.01.25
-*/
-void UpdateEcsOccPhySecInfo(const UINT16 wEcsId);
-
-/*
-* 功能描述：获取指定ID ECS占用的物理区段数量
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：占用的物理区段数量
-* Created By LQ 2026.01.25
-*/
-UINT8 GetEcsOccPhySecNum(const UINT16 wEcsId);
-
-/*
-* 功能描述：获取指定ID ECS占用的物理区段ID
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：NULL 获取数据失败
-*           非NULL 占用的物理区段ID
-* Created By LQ 2026.01.25
-*/
-UINT16* GetEcsOccPhySecId(const UINT16 wEcsId);
-
-/*
-* 功能描述：清除指定ID ECS的动态数据
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void ClearEcsDymData(const UINT16 wEcsId);
-
-/*
-* 功能描述：更新ECS关联列车
-* 参数说明：无
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void UpdateEcsRelTrain(const UINT16 wEcsId);
-
-/*
-* 功能描述：按照通信车监督ECS隧道内列车停车状态
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void MonitorEcsTrainByCommTrain(const UINT16 wEcsId);
-
-/*
-* 功能描述：按照非通信车监督ECS隧道内列车停车状态
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void MonitorEcsTrainByBadTrain(const UINT16 wEcsId);
-
-/*
-* 功能描述：检查ECS物理区段是否全为非通信车占用
-* 参数说明：const UINT16 wEcsId
-* 返 回 值：0 全为UT占用
-*           1 空闲或存在CT占用
-* Created By LQ 2026.01.26
-*/
-UINT8 EcsPhySecUTOccCheck(const UINT16 wEcsId);
-
-/*
-* 功能描述：检查ECS物理区段非通信车占用状态是否发生变化
-* 参数说明：const UINT16 wEcsId
-* 返 回 值：0 变化
-*           1 未变化
-* Created By LQ 2026.01.26
-*/
-UINT8 EcsPhySecUTOccChangeCheck(const UINT16 wEcsId);
-
-/*
-* 功能描述：检查ECS物理区段非通信车占用是否连续
-* 参数说明：const UINT16 wEcsId ECS ID
-*           UINT8 cPhySecNum 占用的物理区段数量
-*           UINT16 pCurOccPhySecId[ECS_REL_PHYSEC_MAX_NUM] 占用的物理区段ID数组
-* 返 回 值：0 占用不连续
-*           1 占用连续
-* Created By LQ 2026.01.26
-*/
-UINT8 EcsPhySecUTOccContinusCheck(const UINT16 wEcsId, UINT8 cPhySecNum, UINT16 pCurOccPhySecId[ECS_REL_PHYSEC_MAX_NUM]);
-
-/*
-* 功能描述：检查ECS外方物理区段占用状态是否变化
-* 参数说明：const UINT16 wEcsId ECS ID
-* 返 回 值：0 变化
-*           1 未变化
-* Created By LQ 2026.01.26
-*/
-UINT8 EcsOutPhySecOccChangeCheck(const UINT16 wEcsId);
-
-/*
-* 功能描述：获取覆盖多个物理区段的ECS外方物理区段ID
-* 参数说明：const UINT16 wRouteId 进路ID
-*           const UINT16 wCurPhySecId ECS当前物理区段ID
-*           const UINT16 wNextPhySecId ECS下一物理区段ID
-*           UINT16* pEnterPhySecId 驶入ECS隧道的外方物理区段ID（出参）
-*           UINT16* pGoOutPhySecId 驶出ECS隧道的外方物理区段ID（出参）
-* 返 回 值：0 获取失败
-*           1 获取成功
-* Created By LQ 2026.01.26
-*/
-UINT8 GetMultipleSecEcsOutPhySec(const UINT16 wRouteId, const UINT16 wCurPhySecId, const UINT16 wNextPhySecId, UINT16* pEnterPhySecId, UINT16* pGoOutPhySecId);
-
-/*
-* 功能描述：获取仅覆盖一个物理区段的ECS外方物理区段ID
-* 参数说明：const UINT16 wRouteId 进路ID
-*           const UINT16 wCurPhySecId ECS当前物理区段ID
-*           UINT16* pEnterPhySecId 驶入ECS隧道的外方物理区段ID（出参）
-*           UINT16* pGoOutPhySecId 驶出ECS隧道的外方物理区段ID（出参）
-* 返 回 值：0 获取失败
-*           1 获取成功
-* Created By LQ 2026.01.27
-*/
-UINT8 GetSingleSecEcsOutPhySec(const UINT16 wRouteId, const UINT16 wCurPhySecId, UINT16* pEnterPhySecId, UINT16* pGoOutPhySecId);
-
-/*
-* 功能描述：更新ECS隧道拥堵状态
-* 参数说明：无
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void UpdateEcsJamState(const UINT16 wEcsId);
-
-/*
-* 功能描述：ECS风机继电器驱动处理
-* 参数说明：无
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void EcsFanRelayDriveProc(const UINT16 wEcsId);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif

TSCP/src/APP/ciapp/ECS/ECSDefine.h

@@ -1,31 +0,0 @@
-/********************************************************
-*
-* 文 件 名： ECSDefine.h
-* 版权说明： 交控科技股份有限公司
-* 创建时间： 2024.01.24
-* 作    者： 联锁组
-* 功能描述： 环境控制系统相关常量定义
-* 函数包括：
-* 使用注意：
-* 修改记录：
-*
-********************************************************/
-
-#ifndef _ECS_Define_H_
-#define _ECS_Define_H_
-
-#define ECS_MAX_NUM	 (UINT16)3U		/*ECS数量最大值*/
-
-#define ECS_REL_PHYSEC_MAX_NUM	 (UINT8)20U		/*隧道关联物理区段数量最大值*/
-
-#define ECS_REL_LOGSEC_MAX_NUM	 (UINT8)80U		/*隧道关联逻辑区段数量最大值*/
-
-/*ECS自动触发状态*/
-#define ECS_AUTOTRIG_YES		((UINT8)0x55U)  /*启用*/
-#define ECS_AUTOTRIG_NO			((UINT8)0xAAU)  /*停用*/
-
-/*ECS拥堵状态*/
-#define ECS_JAM_YES		        ((UINT8)0x55U)  /*拥堵*/
-#define ECS_JAM_NO			    ((UINT8)0xAAU)  /*不拥堵*/
-
-#endif

TSCP/src/APP/ciapp/ERROR/ErrorDataManage.c

@@ -94,16 +94,23 @@ void SetErrorData(const UINT8 FunctionId, const UINT8 DeviceType, const UINT16 D
     tempErrorDataIndex = ErrorDataCurSum;
     if (tempErrorDataIndex < ERROR_DATA_SUM_MAX)
     {
-		/* 记录新数据 */
+		if (ETYPE_PS_FLOCK_SPKSCMD_STATE == DeviceStateType)
-		ErrorDataStru[tempErrorDataIndex].FunctionId = FunctionId;
+		{
-		ErrorDataStru[tempErrorDataIndex].DeviceType = DeviceType;
+			SetPhySecSpksCmdFlockErrorData(FunctionId, DeviceType, DeviceId, DeviceStateType, DeviceState, SendLevel);
-		ErrorDataStru[tempErrorDataIndex].DeviceId = DeviceId;
+		}
-		ErrorDataStru[tempErrorDataIndex].DeviceStateType = DeviceStateType;
+		else
-		ErrorDataStru[tempErrorDataIndex].DeviceState = DeviceState;
+		{
-		ErrorDataStru[tempErrorDataIndex].SendLevel = SendLevel;
+			/* 记录新数据 */
+			ErrorDataStru[tempErrorDataIndex].FunctionId = FunctionId;
+			ErrorDataStru[tempErrorDataIndex].DeviceType = DeviceType;
+			ErrorDataStru[tempErrorDataIndex].DeviceId = DeviceId;
+			ErrorDataStru[tempErrorDataIndex].DeviceStateType = DeviceStateType;
+			ErrorDataStru[tempErrorDataIndex].DeviceState = DeviceState;
+			ErrorDataStru[tempErrorDataIndex].SendLevel = SendLevel;
 
-		/* 记录未满寻址指向新数据 */
+			/* 记录未满寻址指向新数据 */
-		ErrorDataCurSum = (UINT16)(tempErrorDataIndex + 1u);
+			ErrorDataCurSum = (UINT16)(tempErrorDataIndex + 1u);
+		}
 
     }
     else
@@ -183,7 +190,7 @@ void SetErrorDataBelongVirCiId(const UINT16 preErrorNum, const UINT8 virCIid)
 	}
 
 }
-#if 0
+
 /*
 * 功能描述： 设置物理区段封锁类型为SPKS按下且命令封锁时的错误数据
 * 参数说明： const UINT8 functionId, 函数ID
@@ -239,7 +246,6 @@ void SetPhySecSpksCmdFlockErrorData(const UINT8 FunctionId, const UINT8 DeviceTy
 	}
 
 }
-#endif
 
 
 

TSCP/src/APP/ciapp/ERROR/ErrorDataManage.h

@@ -98,7 +98,6 @@ void DeleteErrorData(const UINT16 Index);
 * cgh-合并CID-2349-5：
 */
 void SetErrorDataBelongVirCiId(const UINT16 preErrorNum, const UINT8 virCIid);
-#if 0
 /*
 * 功能描述： 设置物理区段封锁类型为SPKS按下且命令封锁时的错误数据
 * 参数说明： const UINT8 functionId, 函数ID
@@ -113,7 +112,6 @@ void SetErrorDataBelongVirCiId(const UINT16 preErrorNum, const UINT8 virCIid);
 void SetPhySecSpksCmdFlockErrorData(const UINT8 FunctionId, const UINT8 DeviceType, const UINT16 DeviceId,
     const UINT8 DeviceStateType, const UINT8 DeviceState,
     const UINT8 SendLevel);
-#endif
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/ERROR/ErrorDefine.h

@@ -110,6 +110,11 @@
 #define EFUNC_SWITCHTESTLOGIC      			((UINT8)0x80U) /*函数：SetSwitchTestLogicManage道岔定反位测试*/
 #define EFUNC_OVERLAP_VALIDMASK_CHECK				((UINT8)0x4A)	/*函数：OverlapValidMaskCheck 计算保护区段有效码位检查*/
 #define EFUNC_ROUTE_LOCK_DRIVE_SWITCH        ((UINT8)0xD2)		/*RouteLockDriveSwitch 锁闭道岔*/
+#define EFUNC_ROUTE_COUPLINK_SET              ((UINT8)0xD7)		/*SetCouplinkRouteLogicManage 办理联挂进路逻辑管理*/
+#define EFUNC_FOLLOWUP_SWITCH_DANSUO_CANCLE              ((UINT8)0xD8)		/*FollowUpSwitchUnFlockCheck 一二次道岔单解命令*/
+#define EFUNC_FOLLOWUP_SWITCH_UNFLOCK              ((UINT8)0xD9)		/*FollowUpSwitchUnFlockCheck 一二次道岔解封命令*/
+#define EFUNC_FOLLOWUP_SEC_UNFLOCK              ((UINT8)0xDA)		/*FollowUpSecUnFlockCheck 一二次区段解封命令*/
+#define EFUNC_FOLLOWUP_SIGNAL_UNFLOCK              ((UINT8)0xDB)		/*FollowUpSwitchUnFlockCheck 一二次信号解封命令*/
 
 /*车辆段联锁逻辑检查*/
 #define EFUNC_SET_LEAD_ROUTE_CHECK          ((UINT8)0x4B)    /*办理引导进路检查*/    
@@ -189,13 +194,6 @@
 #define EFUNC_OpenLogRouteSignalProcess	((UINT8)0xC5)	/*LogRouteSignalProcess开放逻辑进路信号条件检查*/
 #define EFUNC_LOGROUTE_LOGIC_RES_APP_CHECK	((UINT8)0xC6)	/*逻辑进路逻辑区段资源可用性检查*/
 #define EFUNC_LogRoureUsingStateCheck	((UINT8)0xC7)	/*LogRoutePhySecUseLogicProcess*/
-/*联络线相关报警函数*/
-#define EFUNC_ConnectOverrideSetProc	((UINT8)0xCA)			/*ConnectOverrideSetProc*/
-#define EFUNC_ConnectSwitchAlarmProc	((UINT8)0xCB)			/*LogSecConnectSwitchAlarmProc*/
-#define EFUNC_GetDisneyGJDriveState		((UINT8)0xCC)			/*GetDisneyGJDriveState*/
-#define EFUNC_DsnConnectOtherCi			((UINT8)0xCD)			/*DsnConnectOtherCiValidCheck*/
-#define EFUNC_LogSecDsnConnectCheck		((UINT8)0xCE)			/*LogSecDsnConnectCheck*/
-#define EFUNC_RouteCbtcTiranEnterCheck	((UINT8)0xCF)			/*RouteCbtcTiranEnterCheck*/
 /*其他函数*/
 #define EFUNC_LOGIC_MANAGE_SYETEM           ((UINT8)0xF0)    /* Logicmanage.c中导致宕机异常 */
 #define EFUNC_CHECK_ROUTE_SEC_FLOCK         ((UINT8)0xF1)    /* RouteSecFlockVainCheck */
@@ -221,6 +219,12 @@
 
 #define EFUNC_OVERLAP_ZHAOCHA_CHECK          ((UINT8)0xD3)		/*保护区段照查条件检查*/
 
+#define EFUNC_PARSE_LOCAL_CI2RC_DATA         ((UINT8)0xD4U)	   /*函数：ParseCiToLocalRcDataFrame*/
+#define EFUNC_PARSE_LOCAL_RC2CI_DATA         ((UINT8)0xD5U)	   /*函数：ParseRcToLocalCiDataFrame*/
+#define EFUNC_PARSE_LOCAL_CI2CI_DATA         ((UINT8)0xD6U)	   /*函数：ParseCiToCiDataFrame*/
+#define EFUNC_PARSE_LOCAL_OC2CI_DATA         ((UINT8)0xD7U)	   /*函数：ParseOcToCiDataFrame*/
+#define EFUNC_CONNECT_ROUTE_RELEASE          ((UINT8)0xD8U)	   /*函数：ConnectRouteReleaseManage*/
+#define EFUNC_PARSE_GATEWAY2CI_DATA         ((UINT8)0xD9U)	   /*函数：ParseGateWayToCiDataProc*/
 
 /*************************************************分界线******************************************************************************/
 /*************************************************分界线******************************************************************************/
@@ -228,23 +232,22 @@
 /* 故障类型*/
 /* 进路故障类型编码 (UINT8)0x01-(UINT8)0x2f */
 /* 设备类型 CI_DEVICE_TYPE_ROUTE */                   
-#define ETYPE_ROUTE_LEVEL					((UINT8)0x01)	/*进路监督级别*/
+#define ETYPE_ROUTE_LEVEL           ((UINT8)0x01)    /*进路监督级别*/
-#define ETYPE_ROUTE_TYPE					((UINT8)0x02)	/*进路类型*/
+#define ETYPE_ROUTE_TYPE            ((UINT8)0x02)    /*进路类型*/
-#define ETYPE_ROUTE_STATE					((UINT8)0x03)	/*进路状态*/
+#define ETYPE_ROUTE_STATE           ((UINT8)0x03)    /*进路状态*/
-#define ETYPE_ROUTE_LEAD_PROPERTY			((UINT8)0x04)	/*进路引导*/
+#define ETYPE_ROUTE_LEAD_PROPERTY   ((UINT8)0x04)    /*进路引导*/
-#define ETYPE_ROUTE_CANCEL					((UINT8)0x05)	/*进路取消*/
+#define ETYPE_ROUTE_CANCEL          ((UINT8)0x05)    /*进路取消*/
-#define ETYPE_ROUTE_OVERLAP_UNLOCK			((UINT8)0x06)	/*Overlap未锁闭*/
+#define ETYPE_ROUTE_OVERLAP_UNLOCK  ((UINT8)0x06)    /*Overlap未锁闭*/
-#define ETYPE_ROUTE_OVERLAP_OCCUPY			((UINT8)0x07)	/*Overlap占用*/
+#define ETYPE_ROUTE_OVERLAP_OCCUPY  ((UINT8)0x07)    /*Overlap占用*/
-#define ETYPE_ROUTE_FLYING_TRAIN			((UINT8)0x08)	/*进路飞车*/
+#define ETYPE_ROUTE_FLYING_TRAIN    ((UINT8)0x08)    /*进路飞车*/
-#define ETYPE_RETURN_ROUTE_STATE			((UINT8)0x09)	/*折返进路状态*/
+#define ETYPE_RETURN_ROUTE_STATE    ((UINT8)0x09)    /*折返进路状态*/
-#define ETYPE_ROUTE_FIRST_XUANPAI_OVERTIME	((UINT8)0x0a)	/*进路初选排超时*/
+#define ETYPE_ROUTE_FIRST_XUANPAI_OVERTIME	((UINT8)0x0a)    /*进路初选排超时*/
-#define ETYPE_ROUTE_APPLY_SWITCH_CHECK		((UINT8)0x0b)	/*进路办理道岔状态检查*/
+#define ETYPE_ROUTE_APPLY_SWITCH_CHECK	((UINT8)0x0b)    /*进路办理道岔状态检查*/
-#define ETYPE_ROUTE_XUANPAI_OVERTIME		((UINT8)0x10)	/*进路选排超时*/
+#define ETYPE_ROUTE_XUANPAI_OVERTIME ((UINT8)0x10)    /*进路选排超时*/
-#define ETYPE_GROUP_AUTO_ROUTE_STATE		((UINT8)0x16)	/*组合自动进路*/
+#define ETYPE_GROUP_AUTO_ROUTE_STATE ((UINT8)0x16)    /*组合自动进路*/
-#define ETYPE_ROUTE_CONNECT_OVERRIME		((UINT8)0x18)	/*（联络线）进路办理超时*/
+#define ETYPE_ROUTE_APPLY_SWITCH_MOVE ((UINT8)0xA4)    /*进路道岔单操中*/
-#define ETYPE_ROUTE_APPLY_SWITCH_MOVE		((UINT8)0xA4)	/*进路道岔单操中*/
+#define ETYPE_COUPLINK_ROUTE_IDLE        ((UINT8)0xA5)    /*联挂进路内无被联挂车*/
-#define ETYPE_ROUTE_DSNCONNECT				((UINT8)0x19)	/*迪士尼联络线联锁条件*/
+#define ETYPE_CONNECT_ROUTE_RELEASE      ((UINT8)0xA6)    /*联络线接车进路解锁条件不满足*/
-#define ETYPE_ROUTE_DSNCONNECT_CROSS		((UINT8)0x1A)	/*迪士尼联络线跨压*/
 
 
 #define ETYPE_COMM_WITH_VOBC		((UINT8)0x11)	/*与VOBC通信*/
@@ -255,6 +258,9 @@
 #define ETYPE_COMM_WITH_PSC                     ((UINT8)0x15) /*CI与PSC通信*/
 
 #define ETYPE_COMM_WITH_TMC		    ((UINT8)0x17)	/*与TMC通信*/
+#define ETYPE_COMM_WITH_RC		    ((UINT8)0x18U)	/*与RC通信*/
+#define ETYPE_COMM_WITH_OC		    ((UINT8)0x19U)	/*与OC通信*/
+#define ETYPE_COMM_WITH_GATEWAY		    ((UINT8)0x1AU)	/*与网关通信*/
 
 /* 信号机故障类型编码 (UINT8)0x21-(UINT8)0x3f */
 /* 设备类型 CI_DEVICE_TYPE_SIGNAL */
@@ -308,20 +314,19 @@
 /*保护区段类型*/
 #define ETYPE_OVERLAP_LABORUNLOCK_FAIL    ((UINT8)0x51U)  /*保护区段人工锁闭条件不满足*/
 #define ETYPE_OVERLAP_RES_CHECK_FAIL    ((UINT8)0x52U)  /*保护区段资源检查条件不满足*/
+#define ETYPE_OVERLAP_LABORUNLOCK_STATE   ((UINT8)0x53U)  /*保护区段人工解锁状态不满足*/
 
 /* 道岔类型编码 (UINT8)0x61-(UINT8)0x7f */
 /* 设备类型 CI_DEVICE_TYPE_SWITCH */
-#define ETYPE_SWT_YLOCK_STATE       	((UINT8)0x61)		/*道岔引导总锁状态*/
+#define ETYPE_SWT_YLOCK_STATE       	((UINT8)0x61)    /*道岔引导总锁状态*/
-#define ETYPE_SWT_FLOCK_STATE       	((UINT8)0x62)		/*道岔封锁状态*/
+#define ETYPE_SWT_FLOCK_STATE       	((UINT8)0x62)    /*道岔封锁状态*/
-#define ETYPE_SWT_LOCK_STATUS         	((UINT8)0x63)		/*道岔锁闭状态*/
+#define ETYPE_SWT_LOCK_STATUS         	((UINT8)0x63)    /*道岔锁闭状态*/
-#define ETYPE_SWT_POSTION_STATE     	((UINT8)0x64)		/*道岔位置*/
+#define ETYPE_SWT_POSTION_STATE     	((UINT8)0x64)    /*道岔位置*/
-#define ETYPE_SWT_MOVE_INVALID      	((UINT8)0x65)		/*道岔不可动*/
+#define ETYPE_SWT_MOVE_INVALID      	((UINT8)0x65)    /*道岔不可动*/
-#define ETYPE_SWT_MOVE_OVERTIME     	((UINT8)0x66)		/*道岔动作锁闭超时*/
+#define ETYPE_SWT_MOVE_OVERTIME     	((UINT8)0x66)    /*道岔动作锁闭超时*/
-#define ETYPE_SWT_USE_STATE     		((UINT8)0x6aU)		/*道岔征用*/
+#define ETYPE_SWT_USE_STATE     		((UINT8)0x6aU)    /*道岔征用*/
-#define ETYPE_SWT_MOVE_STATE     		((UINT8)0x6bU)		/*道岔搬动状态*/
+#define ETYPE_SWT_MOVE_STATE     		((UINT8)0x6bU)    /*道岔搬动状态*/
-#define ETYPE_SWT_MOVE_CHECK_RESULT     ((UINT8)0x6cU)		/*道岔可动性检查结果*/
+#define ETYPE_SWT_MOVE_CHECK_RESULT     ((UINT8)0x6cU)    /*道岔可动性检查结果*/
-#define ETYPE_SWT_WAIT_MOVE             ((UINT8)0x6dU)		/*等待道岔动作完成*/
-#define ETYPE_SWT_CONNECT_RET_FAIL		((UINT8)0x6Eu)		/* Point failed to move to normal within 20 seconds of the over switch block being cleared */
 
 /* 继电器故障类型编码 (UINT8)0x81-(UINT8)0x8f */
 /* 设备类型 CI_DEVICE_TYPE_RELAY */
@@ -398,9 +403,6 @@
 #define ETYPE_LOGSEC_FIRSTLOCK_STATE                ((UINT8)0xC6)       /*逻辑区段为第一个锁闭区段检查*/
 #define ETYPE_LOGSEC_CBTC_PROPERTY                  ((UINT8)0xC7)       /*逻辑区段CBTC属性检查*/
 #define ETYPE_LOGSEC_CONTINUOUS                     ((UINT8)0xC8)       /*逻辑区段连续性检查*/
-#define ETYPE_LOGSEC_CT_OVERRIDE_FAIL				((UINT8)0xC9)       /*逻辑区段有CT列车占用，旁路无效*/
-#define ETYPE_LOGSEC_EA_BUILD						((UINT8)0xCA)		/*逻辑区段防护区建立*/
-#define ETYPE_LOGSEC_DIRLOC_FAIL					((UINT8)0xCB)		/*逻辑区段继电器检查条件不满足（迪士尼联络线）*/
 
 /*动态路径故障类型*/
 #define ETYPE_PART_ROUTE_RES             ((UINT8)0xD0)       /*动态路径资源检查*/

TSCP/src/APP/ciapp/ESB/ESBConfigDataManage.c

@@ -18,7 +18,8 @@ EsbConfigDataStruct EsbConfigDataStru[ESB_SUM_MAX];   /*
 UINT16 LocalCiEsbIdBuf[ESB_SUM_MAX] = {0u};                   /*定义本地联锁紧急停车按钮ID映射数组*/
 INT16 EsbCurSum = 0;   /*ESB当前总数*/
 UINT16 totalEsbNum = 0u;/*本联锁和相邻联锁发送给本联锁ESB总数*/
-CesbConfigDataStruct LocalCesbConfigDataStru;/*定义本联锁全线紧急制动数据*/
+
+
 
 
 /*
@@ -664,51 +665,52 @@ UINT8 CheckEsbBelSendRange(const UINT16 wCheckEsbId)
 }
 
 /*
-* 功能描述： 获取指定ESB ID关联的link编号
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮数量
-* 参数说明： const UINT16 esbId, 紧急停车按钮
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* 返回值  ： 无
+* 返 回 值：同站紧急按钮数量
-*Create fan 2026.02.05
+* Created By LQ 2025.12.30
 */
-UINT16 GetEsbRelateLinkId(const UINT16 esbId)
+UINT8 GetEsbRelOnePlatEsbNum(const UINT16 esbId)
 {
 	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16 wLinkId = 0U;
+	UINT8 reVal = 0U;
 
 	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-	if (bufIndex < ESB_SUM_MAX)
-	{
 
-		wLinkId = EsbConfigDataStru[bufIndex].wRelateLink;
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		reVal = EsbConfigDataStru[bufIndex].RelOnePlatEsbNum;
 	}
 	else
 	{
-		/*不做处理*/
+		/*返回0*/
 	}
-	return wLinkId;
+
+	return reVal;
 }
 
 /*
-* 功能描述： 获取指定CESB关联的激活继电器ID
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮ID数组
-* 参数说明： 无
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* 返回值  ： 无
+* 返 回 值：NULL 获取数据失败
-*Create fan 2026.02.05
+*			其它 同站紧急按钮ID数组
+* Created By LQ 2025.12.30
 */
-UINT16 GetCesbRelayId(void)
+UINT16* GetEsbRelOnePlatEsbId(const UINT16 esbId)
 {
-	UINT16 wCesbRelay = 0U;
+	UINT16 bufIndex = 0U;  /*数组下标*/
-	wCesbRelay = LocalCesbConfigDataStru.wCesbRelayId;
+	UINT16* reVal = NULL;
-	return wCesbRelay;
-}
 
-/*
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-* 功能描述： 获取指定CESB关联的旁路继电器ID
+
-* 参数说明： 无
+	if (ESB_SUM_MAX > bufIndex)
-* 返回值  ： 无
+	{
-*Create fan 2026.02.05
+		reVal = EsbConfigDataStru[bufIndex].RelOnePlatEsbId;
-*/
+	}
-UINT16 GetCesbCutRelayId(void)
+	else
-{
+	{
-	UINT16 wCesbCutRelay = 0U;
+		/*返回NULL*/
-	wCesbCutRelay = LocalCesbConfigDataStru.wCesbCutRelayId;
+	}
-	return wCesbCutRelay;
+
+	return reVal;
 }

TSCP/src/APP/ciapp/ESB/ESBConfigDataManage.h

@@ -19,6 +19,7 @@
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
 #include "../System/SystemParameterManage.h"
+#include "dquStructInit.h"
 
 
 #ifdef __cplusplus
@@ -50,24 +51,16 @@ typedef struct S_EsbConfigDataStruct
 	UINT16 EsbCutoffBuzzRelayId;		    /*切除蜂鸣器报警继电器ID*/
 	UINT8 ConfigAtsCiEssSteadyMask;			/*是否配置了ATS-CI稳灯状态码位0x55 配置；0xaa未配置*/
 	UINT8 ConfigAtsCiEssFlashMask;			/*是否配置了ATS-CI闪灯状态码位0x55 配置；0xaa未配置*/
-	UINT16 wRelateLink;/*电子地图配置中关联LINK标号*/
+	UINT8 RelOnePlatEsbNum;  /*关联同站ESB数量*/
+	UINT16 RelOnePlatEsbId[ESB_PROTECT_LINK_NUM];  /*关联同站ESB ID数组*/
 } EsbConfigDataStruct;
 
-/*CESB按钮配置数据结构体*/
-typedef struct S_CesbConfigDataStruct
-{
-	UINT16 wCesbId;             /*全线紧急按钮ID (配置字段)*/
-	UINT8 BelongCiId;         /*所属联锁ID*/
-	UINT16 wCesbRelayId; /*全线紧急停车按钮关联继电器*/
-	UINT16 wCesbCutRelayId; /*全线紧急停车旁路按钮关联继电器*/
-} CesbConfigDataStruct;
-
 /*******************************全局变量声明*******************************/
 extern EsbConfigDataStruct EsbConfigDataStru[ESB_SUM_MAX];   /*定义ESB数据配置结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
 extern UINT16 LocalCiEsbIdBuf[ESB_SUM_MAX];                   /*定义本地联锁紧急停车按钮ID映射数组*/
 extern INT16 EsbCurSum;   /*ESB当前总数*/
 extern UINT16 totalEsbNum;/*本联锁和相邻联锁发送给本联锁ESB总数*/
-extern CesbConfigDataStruct LocalCesbConfigDataStru;/*定义本联锁全线紧急制动数据*/
+
 /*
 * 功能描述： 获取紧急停车当前总数
 * 参数说明： void    
@@ -304,28 +297,21 @@ UINT16 GetEsbCutoffBuzzRelayId(const UINT16 esbId);
 UINT8 CheckEsbBelSendRange(const UINT16 wCheckEsbId);
 
 /*
-* 功能描述： 获取指定ESB ID关联的link编号
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮数量
-* 参数说明： const UINT16 esbId, 紧急停车按钮
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* 返回值  ： 无
+* 返 回 值：同站紧急按钮数量
-*Create fan 2026.02.05
+* Created By LQ 2025.12.30
 */
-UINT16 GetEsbRelateLinkId(const UINT16 esbId);
+UINT8 GetEsbRelOnePlatEsbNum(const UINT16 esbId);
 
 /*
-* 功能描述： 获取指定CESB关联的激活继电器ID
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮ID数组
-* 参数说明： 无
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* 返回值  ： 无
+* 返 回 值：NULL 获取数据失败
-*Create fan 2026.02.05
+*			其它 同站紧急按钮ID数组
+* Created By LQ 2025.12.30
 */
-UINT16 GetCesbRelayId(void);
+UINT16* GetEsbRelOnePlatEsbId(const UINT16 esbId);
-
-/*
-* 功能描述： 获取指定CESB关联的旁路继电器ID
-* 参数说明： 无
-* 返回值  ： 无
-*Create fan 2026.02.05
-*/
-UINT16 GetCesbCutRelayId(void);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/ESB/ESBDataManage.c

@@ -11,12 +11,9 @@
 
 #include "ESBDataManage.h"
 #include "ESBConfigDataManage.h"
-#include "../ParsePack/ParsePackGateWayData.h"
+
-#include "../QueryFiles/dquCIInterFace.h"
 EsbDataStruct EsbDataStru[ESB_SUM_MAX];   /*定义ESB数据结构体*/
-UINT8 g_CesbFlockState = CESB_STATE_VALID_NO;	/* 全线区段CESB封锁状态 */
+
-UINT8 g_ScxCesbData = CESB_STATE_VALID_NO; /*试车线CESB状态*/
-UINT8 g_ScxCesbCutData = ESB_CUT_NO;/*试车线CESB旁路状态*/
 
 /*
 * 功能描述： 获取指定ESB数据
@@ -174,6 +171,8 @@ UINT8 EsbDataManageInit(void)
 		EsbDataStru[esbId].EsbCutErrTriggerPressCycNum = 0U;   /*紧急关闭旁路按钮误触发按下周期*/
 		EsbDataStru[esbId].EsbCutErrorFlag = ESB_ERROR_FLAG_NO;     /*紧急关闭旁路按钮未故障*/
 		EsbDataStru[esbId].EsbCutRelayDownState = ESB_RELAY_ERROR_DOWN_YES;   /*紧急关闭旁路按钮采集继电器落下状态初始化为通信异常落下*/
+		EsbDataStru[esbId].cOnePlatEsbState = ESB_STATE_VALID_NO;  /*初始化同站紧急按钮未激活*/
+		EsbDataStru[esbId].cOnePlatEsbCutState = ESB_CUT_NO;  /*初始化同站紧急旁路按钮未激活*/
 	}
 	rtn = CI_SUCCESS;
 	return rtn;
@@ -1077,375 +1076,301 @@ UINT8 GetEsbRelayDownState(const UINT16 esbId)
 	return reVal;
 }
 
-/**
+
-* @brief 设置全线区段CESB封锁全局变量状态
+/*
-* @param const UINT8 chState 全线区段CESB封锁状态
+* 功能描述： 获取指定ID紧急停车按钮状态(融合了旁路状态)
-* @return 无
+* 参数说明： const UINT16 esbId, 紧急停车按钮ID
-* @note 当输入参数不合法时，设置全线区段CESB封锁
+* 返回值  ： 0: 获取数据失败
-* Created By fan 2026.02.04
+*			>0: 紧急停车按钮状态
 */
-void SetAllSecCesbState(const UINT8 chState)
+UINT8 GetEsbMergeState(const UINT16 esbId)
 {
-	if (CESB_STATE_VALID_NO == chState)
+	
+	UINT8 reVal = CI_ERROR;
+	UINT8 chEsbState = 0U;
+	UINT8 chEsbCutState = 0U;
+	 
+
+	chEsbState = GetEsbState(esbId);
+	chEsbCutState = GetEsbCutState(esbId);
+	if (ESB_CUT_YES == chEsbCutState)
 	{
-		g_CesbFlockState = chState;
+		reVal = ESB_STATE_VALID_NO;/*未按下*/
 	}
 	else
 	{
-		g_CesbFlockState = CESB_STATE_VALID_YES;
+		if (ESB_STATE_VALID_NO == chEsbState)
+		{
+			reVal = ESB_STATE_VALID_NO;/*未按下*/
+		}
+		else
+		{
+			reVal = ESB_STATE_VALID_YES;
+		}
 	}
+
+	return reVal;
 }
 
-/**
+/*
-* @brief 获取全线区段CESB封锁全局变量状态
+* 功能描述：获取指定ID紧急按钮同站紧急按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* @return CESB_STATE_VALID_NO:未全线CESB封锁；CESB_STATE_VALID_YES :全线CESB封锁
+* 返 回 值：0 获取数据失败
-* Created By fan 2026.02.04
+*			0x55 紧急未激活
+*           0xAA 紧急激活
+* Created By LQ 2025.12.29
 */
-UINT8 GetAllSecCesbState(void)
+UINT8 GetOnePlatEsbState(const UINT16 esbId)
 {
-	return g_CesbFlockState;
+	UINT16 bufIndex = 0U;  /*数组下标*/
-}
+	UINT8 reVal = CI_ERROR;
 
-/**
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-* @brief 全线CEsb封锁取消主处理函数
-* @param 无
-* @return 无
-* Created By fan 2026.02.04
-*/
-void CancleCesbFlockCmdProc(void)
-{
-	AtsCESBCancleMsgStru * strMsgFst = NULL;
-	AtsCESBCancleMsgStru * strMsgSnd = NULL;
 
-	/*以下消息获取不会返回NULL*/
+	if (ESB_SUM_MAX > bufIndex)
-	strMsgFst = GetAtsCesbMsgFst();
-	strMsgSnd = GetAtsCesbMsgSnd();
-
-	if ((strMsgFst->chFlag != FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET))
 	{
-		; /* 没有消息，什么也不做 */
+		reVal = EsbDataStru[bufIndex].cOnePlatEsbState;
-	}
-	else if ((strMsgFst->chFlag == FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET))
-	{/* 一次消息 */
-		CancelCesbFlockAtsCmdFst();
 	}
 	else
-	{/* 二次消息 */
+	{
-		CancelCesbFlockAtsCmdSnd();
+		/*返回失败*/
 	}
+
+	return reVal;
 }
 
-/**
+
-* @brief 全线CESB首次命令处理函数
+/*
-* @param 无
+* 功能描述：设置指定ID紧急按钮同站紧急按钮激活状态
-* @return 无
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* Created By fan 2026.02.04
+*			const UINT8 esbState 紧急按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
 */
-void CancelCesbFlockAtsCmdFst(void)
+void SetOnePlatEsbState(const UINT16 esbId, const UINT8 esbState)
 {
-	AtsCESBCancleMsgStru * strMsgFst = NULL;
+	UINT16 bufIndex = 0U;  /*数组下标*/
-	AtsMsgCfmStru * strCfmFst = NULL;
+
-	UINT32 dwCycle = 0u;
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-	UINT8 chLocalId = 0u;
+
-	UINT8 szCrcTmp[1024] = { 0u };
+	if (ESB_SUM_MAX > bufIndex)
-	UINT32 ii = 0u;
-	UINT8 chFunRtn = CI_TIME_OUT;
-	UINT8 chState = 0U;  /*全线区段CESB封锁状态*/
-	UINT16 wCesbRelayId = 0u;/*CESB继电器*/
-	UINT8 chCesbState = 0U;/*CESB激活状态*/
-	UINT16 wCesbCutRelayId = 0u;/*CESB旁路继电器*/
-	UINT8 chCesbCutState = 0U;/*CESB旁路状态*/
-	UINT8 localCiType = 0U;/*联锁类型*/
-	chLocalId = GetSystemParaLocalCiId();
-	dwCycle = Get2oo2CurCycleNum();
-	/*以下消息获取不会返回NULL*/
-	strMsgFst = GetAtsCesbMsgFst();
-	strCfmFst = GetAtsCesbCfmFst();
-	chState = GetAllSecCesbState();
-	if (strMsgFst->dwCycle == dwCycle)
 	{
-		strCfmFst->chFlag = FLAG_SET;
+		if ((ESB_STATE_VALID_NO == esbState) || (ESB_STATE_VALID_YES == esbState))
-		strCfmFst->chTiocId = chLocalId;
+		{
-		strCfmFst->chStation = strMsgFst->chStation;
+			EsbDataStru[bufIndex].cOnePlatEsbState = esbState;  /*同站紧急按钮激活状态*/
-		strCfmFst->wIndex = strMsgFst->wIndex;
-		strCfmFst->dwTime = dwCycle;
-		
-		/* 取消全线区段CESB封锁 */
-		if (CESB_STATE_VALID_NO == chState)
-		{/* 当前未设置 */
-			strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_FST_UNSET;
 		}
 		else
 		{
-			localCiType = GetLocalCiType();/*获取联锁类型*/
+			/*不处理*/
-			if (CI_TYPE_SCX == localCiType)
-			{
-				/*获取试车线旁路及激活命令状态*/
-				chCesbState = GetScxCesbCmdState();
-				chCesbCutState = GetScxCesbCutCmdState();
-				/*旁路或未激活*/
-				if ((CESB_STATE_VALID_NO == chCesbState) || (ESB_CUT_YES == chCesbCutState))
-				{
-					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_FST_SUCCESS;
-				}
-				else
-				{
-					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;
-				}
-			}
-			else
-			{
-				wCesbRelayId = GetCesbRelayId();
-				chCesbState = GetRelayCollState(wCesbRelayId);
-				wCesbCutRelayId = GetCesbCutRelayId();
-				chCesbCutState = GetRelayCollState(wCesbCutRelayId);
-				if ((RELAY_STATE_UP == chCesbCutState) || (RELAY_STATE_UP == chCesbState))
-				{
-					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_FST_SUCCESS;
-				}
-				else
-				{
-					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;
-				}
-			}
-		}
-
-		szCrcTmp[ii] = strMsgFst->chAtsId;
-		ii++;
-		szCrcTmp[ii] = strMsgFst->chStation;
-		ii++;
-		ShortToChar(strMsgFst->wIndex, &szCrcTmp[ii]);
-		ii += 2U;
-		LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]);
-		ii += 4u;
-		strCfmFst->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii);	/* ATS编号、车站编号、操作站编号、下发时间、命令类型计算CRC */
-
-		if (CONFIRM_CANCLE_CESB_FST_SUCCESS != strCfmFst->chOpStatus)
-		{
-			ClearAtsCesbMsgFirst(); /*处理不成功，需清除一次命令 */
-		}
-		else
-		{
-			;
 		}
 	}
 	else
-	{/* 接收到ATS一次消息非本周期，超时判断 */
+	{
-		chFunRtn = SystemOverTimeCheck(strMsgFst->dwCycle, CONFIRM_TIMEOUT_CC);
+		/*不处理*/
-		if (CI_TIME_OUT == chFunRtn)
-		{
-			ClearAtsCesbMsgFirst();
-		}
-		else
-		{
-			;
-		}
 	}
 }
 
-/**
+/*
-* @brief 取消CESB封锁二次命令处理函数
+* 功能描述：获取指定ID紧急按钮同站紧急旁路按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* @return 无
+* 返 回 值：0 获取数据失败
-* Created By fan 2026.02.04
+*			0x55 旁路未激活
+*           0xAA 旁路激活
+* Created By LQ 2025.12.29
 */
-void CancelCesbFlockAtsCmdSnd(void)
+UINT8 GetOnePlatEsbCutState(const UINT16 esbId)
 {
-	AtsCESBCancleMsgStru * strMsgFst = NULL;
+	UINT16 bufIndex = 0U;  /*数组下标*/
-	AtsCESBCancleMsgStru * strMsgSnd = NULL;
+	UINT8 reVal = CI_ERROR;
-	AtsMsgCfmStru * strCfmFst = NULL;
-	AtsMsgCfmStru * strCfmSnd = NULL;
-	UINT32 dwCycle = 0u;
-	UINT8 chLocalId = 0u;
-	UINT8 chFlag = FLAG_UNSET;
-	UINT8 szCrcTmp[1024] = { 0u };
-	UINT32 ii = 0u;
-	UINT32 dwCrc = 0u;
-	UINT16 wCesbRelayId = 0u;/*CESB继电器*/
-	UINT8 chCesbState = 0U;/*CESB激活状态*/
-	UINT16 wCesbCutRelayId = 0u;/*CESB旁路继电器*/
-	UINT8 chCesbCutState = 0U;/*CESB旁路状态*/
-	UINT8 localCiType = 0U;/*联锁类型*/
-	chLocalId = GetSystemParaLocalCiId();
-	dwCycle = Get2oo2CurCycleNum();
-	strMsgFst = GetAtsCesbMsgFst();
-	strMsgSnd = GetAtsCesbMsgSnd();
-	strCfmFst = GetAtsCesbCfmFst();
-	strCfmSnd = GetAtsCesbCfmSnd();
 
-	if ((NULL != strMsgFst)
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-		&& (NULL != strMsgSnd)
+
-		&& (NULL != strCfmFst)
+	if (ESB_SUM_MAX > bufIndex)
-		&& (NULL != strCfmSnd))
 	{
-		if (strMsgSnd->dwCycle == dwCycle)
+		reVal = EsbDataStru[bufIndex].cOnePlatEsbCutState;
+	}
+	else
+	{
+		/*返回失败*/
+	}
+
+	return reVal;
+}
+
+
+/*
+* 功能描述：设置指定ID紧急按钮同站紧急旁路按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbCutState 紧急旁路按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		if ((ESB_CUT_NO == esbCutState) || (ESB_CUT_YES == esbCutState))
 		{
-			strCfmSnd->chFlag = FLAG_SET;
+			EsbDataStru[bufIndex].cOnePlatEsbCutState = esbCutState;  /*同站紧急按钮激活状态*/
-			strCfmSnd->chTiocId = chLocalId;
+		}
-			strCfmSnd->chStation = strMsgSnd->chStation;
+		else
-			strCfmSnd->wIndex = strMsgSnd->wIndex;
+		{
-			strCfmSnd->dwTime = dwCycle;
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
 
-			if (FLAG_SET != strMsgFst->chFlag)
+/*
-			{
+* 功能描述：清除同站紧急按钮及旁路按钮激活状态
-				strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_FIRST;  /* 一次命令未执行，返回未执行首次取消 */
+* 参数说明：无
-				chFlag = FLAG_SET;
+* 返 回 值：无
-			}
+* Created By LQ 2025.12.30
-			else if ((strMsgSnd->chAtsId != strMsgFst->chAtsId)
+*/
-				|| (strMsgSnd->chStation != strMsgFst->chStation)
+void ClearOnePlatEsbAndCutState(void)
-				|| (strMsgSnd->wIndex != strMsgFst->wIndex))
+{
-			{
+	UINT16 wEsbTotalSum = 0U;  /*ESB总数*/
-				strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_UNKNOWN;  /* ATS一二次命令帧头输入不一致，返回未知 */
+	UINT16 ii = 0U;
-				chFlag = FLAG_SET;
+	UINT16 wEsbId = 0U;  /*ESB ID*/
-			}
-			else
-			{
-				localCiType = GetLocalCiType();/*获取联锁类型*/
-				if (CI_TYPE_SCX == localCiType)
-				{
-					/*获取试车线旁路及激活命令状态*/
-					chCesbState = GetScxCesbCmdState();
-					chCesbCutState = GetScxCesbCutCmdState();
-					/*旁路或未激活成功*/
-					if ((CESB_STATE_VALID_YES == chCesbState) && (ESB_CUT_NO == chCesbCutState))
-					{
-						strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;  /* 未旁路且CESB仍然有效*/
-						chFlag = FLAG_SET;
-					}
-					else
-					{
-						;/*不处理*/
-					}
-				}
-				else
-				{
-					/*正线看继电器状态*/
-					wCesbRelayId = GetCesbRelayId();
-					chCesbState = GetRelayCollState(wCesbRelayId);
-					wCesbCutRelayId = GetCesbCutRelayId();
-					chCesbCutState = GetRelayCollState(wCesbCutRelayId);
-					if ((RELAY_STATE_UP != chCesbCutState) && (RELAY_STATE_UP != chCesbState))
-					{
-						strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;  /* 未旁路且CESB仍然有效*/
-						chFlag = FLAG_SET;
-					}
-					else
-					{
-						/*不处理*/
-						;
-					}
-				}
-			}
 
-			if (FLAG_UNSET == chFlag)
+	wEsbTotalSum = GetTotalEsbCurNum();
-			{
-				szCrcTmp[ii] = strMsgSnd->chTiocId;
-				ii++;
-				LongToChar(strCfmFst->dwTime, &szCrcTmp[ii]);
-				ii += 4u;
-				dwCrc = Tioc_CommonCrc32(szCrcTmp, ii);
 
-				if (dwCrc != strMsgSnd->dwCrc32)
+	/*重置所有紧急按钮的同站紧急按钮及旁路按钮为未激活状态*/
-				{
+	for (ii = 0U; ii < wEsbTotalSum; ii++)
-					strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_CHECKFAIL;  /* 计算的CRC32与ATS二次消息CRC32不一致 */
+	{		
-					chFlag = FLAG_SET;
+		wEsbId = GetEsbId(ii);
-				}
+		SetOnePlatEsbState(wEsbId, ESB_STATE_VALID_NO);
-				else
+		SetOnePlatEsbCutState(wEsbId, ESB_CUT_NO);
-				{
+	}
-					;
+}
-				}
-			}
-			else
-			{
-				;
-			}
 
-			ii = 0u;
+/*
-			szCrcTmp[ii++] = strMsgSnd->chAtsId;
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急按钮激活状态
-			szCrcTmp[ii++] = strMsgSnd->chStation;
+* 参数说明：const UINT16 esbId 紧急按钮ID
-			ShortToChar(strMsgSnd->wIndex, &szCrcTmp[ii]);
+*			const UINT8 esbState 紧急按钮状态
-			ii += 2U;
+* 返 回 值：无
-			LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]);
+* Created By LQ 2025.12.29
-			ii += 4u;
+*/
-			LongToChar(strMsgSnd->dwTime, &szCrcTmp[ii]);
+void SetRelOtherOnePlatEsbState(const UINT16 esbId, const UINT8 esbState)
-			ii += 4u;
+{
-			strCfmSnd->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii);
+	UINT16 bufIndex = 0U;  /*数组下标*/
-			if (FLAG_UNSET == chFlag)
+	UINT8 cRelOnePlatEsbNum = 0U;  /*关联的其它同站紧急按钮数量*/
+	UINT16* pRelOnePlatEsbId = NULL;  /*关联的其它同站紧急按钮ID*/
+	UINT8 ii = 0U;
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+	cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
+	pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
+
+	if ((ESB_SUM_MAX > bufIndex) && (0U < cRelOnePlatEsbNum) && (NULL != pRelOnePlatEsbId))
+	{
+		if ((ESB_STATE_VALID_NO == esbState) || (ESB_STATE_VALID_YES == esbState))
+		{
+			for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
 			{
-				strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_SUCCESS;  /* 检查通过，反馈确认成功 */
+				SetOnePlatEsbState(pRelOnePlatEsbId[ii], esbState);
-				SetAllSecCesbState(CESB_STATE_VALID_NO);  /*设置CESB封锁无效*/
-			}
-			else
-			{
-				;
 			}
 		}
 		else
 		{
-			; /** 非本周期消息，不处理 */
+			/*不处理*/
 		}
-		ClearAtsCesbMsgFirst();
-		ClearAtsCesbMsgSecond();
 	}
 	else
 	{
-		; /**不可能分支 不处理 */
+		/*不处理*/
 	}
 }
 
-/**
+/*
-* @brief 获取试车线CESB命令设置状态
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急旁路按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* @return CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+*			const UINT8 esbCutState 紧急旁路按钮状态
-* Created By fan 2026.03.10
+* 返 回 值：无
+* Created By LQ 2025.12.29
 */
-UINT8 GetScxCesbCmdState(void)
+void SetRelOtherOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState)
 {
-	return g_ScxCesbData;
+	UINT16 bufIndex = 0U;  /*数组下标*/
-}
+	UINT8 cRelOnePlatEsbNum = 0U;  /*关联的其它同站紧急按钮数量*/
+	UINT16* pRelOnePlatEsbId = NULL;  /*关联的其它同站紧急按钮ID*/
+	UINT8 ii = 0U;
 
-/**
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-* @brief 设置试车线CESB命令状态
+	cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
-* @input  CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+	pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
-* Created By fan 2026.03.10
+
-*/
+	if ((ESB_SUM_MAX > bufIndex) && (0U < cRelOnePlatEsbNum) && (NULL != pRelOnePlatEsbId))
-void SetScxCesbCmdState(UINT8 chCesbCmd)
-{
-	if ((CESB_STATE_VALID_NO == chCesbCmd)||(CESB_STATE_VALID_YES == chCesbCmd))
 	{
-		g_ScxCesbData = chCesbCmd;
+		if ((ESB_CUT_NO == esbCutState) || (ESB_CUT_YES == esbCutState))
+		{
+			for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
+			{
+				SetOnePlatEsbCutState(pRelOnePlatEsbId[ii], esbCutState);
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
 	}
 	else
 	{
-		;/*不处理*/
+		/*不处理*/
 	}
 }
 
-/**
+/*
-* @brief 获取全线区段试车线CESB旁路命令设置状态
+* 功能描述：检查指定ID紧急按钮关联的其它同站紧急按钮状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* @return ESB_CUT_NO:试车线未CESB旁路；ESB_CUT_YES 试车线CESB旁路有效
+* 返 回 值：1 紧急无效或旁路有效
-* Created By fan 2026.03.10
+*           0 紧急有效
+* Created By LQ 2025.12.29
 */
-UINT8 GetScxCesbCutCmdState(void)
+UINT8 CheckRelOtherOnePlatEsbState(const UINT16 esbId)
 {
-	return g_ScxCesbCutData;
+	UINT8 cRetVal = CI_ERROR;
-}
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 cRelOnePlatEsbNum = 0U;  /*关联的其它同站紧急按钮数量*/
+	UINT16* pRelOnePlatEsbId = NULL;  /*关联的其它同站紧急按钮ID*/
+	UINT8 ii = 0U;
+	UINT8 cEsbState = 0U;  /*紧急按钮状态*/
+	UINT8 cEsbCutState = 0U;  /*紧急按钮旁路状态*/
 
-/**
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
-* @brief 设置试车线CESB旁路命令状态
+	cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
-* @input ESB_CUT_NO: 试车线未CESB旁路；ESB_CUT_YES : 试车线CESB旁路
+	pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
-* Created By fan 2026.03.10
+
-*/
+	if ((ESB_SUM_MAX > bufIndex) && (NULL != pRelOnePlatEsbId))
-void SetScxCesbCutCmdState(UINT8 chCesbCmd)
-{
-	if ((ESB_CUT_NO == chCesbCmd) || (ESB_CUT_YES == chCesbCmd))
 	{
-		g_ScxCesbCutData = chCesbCmd;
+		cRetVal = CI_SUCCESS;
+		for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
+		{
+			cEsbState = GetEsbState(pRelOnePlatEsbId[ii]);
+			cEsbCutState = GetEsbCutState(pRelOnePlatEsbId[ii]);
+
+			if ((ESB_STATE_VALID_NO == cEsbState) || (ESB_CUT_YES == cEsbCutState))
+			{
+				/*继续检查*/
+			}
+			else
+			{
+				cRetVal = CI_ERROR;  /*存在一个ESB紧急有效且旁路无效，返回0*/
+				break;
+			}
+		}
 	}
 	else
 	{
-		;/*不处理*/
+		cRetVal = CI_ERROR;  /*入参非法，返回0*/
 	}
+
+	return cRetVal;
 }

TSCP/src/APP/ciapp/ESB/ESBDataManage.h

@@ -19,7 +19,6 @@
 #include "ESBConfigDataManage.h"
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
-#include "../Section/SectionDefine.h"
 
 
 #ifdef __cplusplus
@@ -50,16 +49,13 @@ typedef struct S_EsbDataStruct
 	UINT32 EsbCutErrTriggerPressCycNum;   /*紧急关闭旁路按钮误触发按下周期*/
 	UINT8 EsbCutErrorFlag;      /*紧急关闭旁路按钮故障标志，0x55-未故障，0xaa-故障*/
 	UINT8 EsbCutRelayDownState;  /*紧急关闭旁路按钮采集继电器落下状态，0x55-正常采集落下，0xaa-通信异常落下*/
+	UINT8 cOnePlatEsbState;  /*同站紧急按钮激活状态：0x55-未激活，0xAA-激活*/
+	UINT8 cOnePlatEsbCutState;  /*同站紧急旁路按钮激活状态：0x55-未激活，0xAA-激活*/
 } EsbDataStruct;
 
-
-
-
 /*******************************全局变量声明*******************************/
 extern EsbDataStruct EsbDataStru[ESB_SUM_MAX];   /*定义ESB数据结构体*/
-extern UINT8 g_CesbFlockState ;	/* 全线区段CESB封锁状态 */
+
-extern UINT8 g_ScxCesbData;/*试车线CESB状态*/
-extern UINT8 g_ScxCesbCutData;/*试车线CESB旁路状态*/
 
 /*
 * 功能描述： 获取指定ESB数据
@@ -412,77 +408,86 @@ void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState);
 * Created By LQ 2025.04.01
 */
 UINT8 GetEsbRelayDownState(const UINT16 esbId);
-
+/*
-/**
+* 功能描述： 获取指定ID紧急停车按钮状态(融合了旁路状态)
-* @brief 设置全线区段CESB封锁全局变量状态
+* 参数说明： const UINT16 esbId, 紧急停车按钮ID
-* @param const UINT8 chState 全线区段CESB封锁状态
+* 返回值  ： 0: 获取数据失败
-* @return 无
+*			>0: 紧急停车按钮状态
-* @note 当输入参数不合法时，设置全线区段CESB封锁
-* Created By fan 2026.02.04
 */
-void SetAllSecCesbState(const UINT8 chState);
+UINT8 GetEsbMergeState(const UINT16 esbId);
 
-/**
+/*
-* @brief 获取全线区段CESB封锁全局变量状态
+* 功能描述：获取指定ID紧急按钮同站紧急按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* @return CESB_STATE_VALID_NO:未全线CESB封锁；CESB_STATE_VALID_YES :全线CESB封锁
+* 返 回 值：0 获取数据失败
-* Created By fan 2026.02.04
+*			0x55 紧急未激活
+*           0xAA 紧急激活
+* Created By LQ 2025.12.29
 */
-UINT8 GetAllSecCesbState(void);
+UINT8 GetOnePlatEsbState(const UINT16 esbId);
 
-/**
+/*
-* @brief 全线CEsb封锁取消主处理函数
+* 功能描述：设置指定ID紧急按钮同站紧急按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* @return 无
+*			const UINT8 esbState 紧急按钮状态
-* Created By fan 2026.02.04
+* 返 回 值：无
+* Created By LQ 2025.12.29
 */
-void CancleCesbFlockCmdProc(void);
+void SetOnePlatEsbState(const UINT16 esbId, const UINT8 esbState);
 
-/**
+/*
-* @brief 全线CESB首次命令处理函数
+* 功能描述：获取指定ID紧急按钮同站紧急旁路按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
-* @return 无
+* 返 回 值：0 获取数据失败
-* Created By fan 2026.02.04
+*			0x55 旁路未激活
+*           0xAA 旁路激活
+* Created By LQ 2025.12.29
 */
-void CancelCesbFlockAtsCmdFst(void);
+UINT8 GetOnePlatEsbCutState(const UINT16 esbId);
 
-/**
+/*
-* @brief 取消CESB封锁二次命令处理函数
+* 功能描述：设置指定ID紧急按钮同站紧急旁路按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* @return 无
+*			const UINT8 esbCutState 紧急旁路按钮状态
-* Created By fan 2026.02.04
+* 返 回 值：无
+* Created By LQ 2025.12.29
 */
-void CancelCesbFlockAtsCmdSnd(void);
+void SetOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState);
 
-/**
+/*
-* @brief 获取试车线CESB命令设置状态
+* 功能描述：清除同站紧急按钮及旁路按钮激活状态
-* @param 无
+* 参数说明：无
-* @return CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+* 返 回 值：无
-* Created By fan 2026.03.10
+* Created By LQ 2025.12.30
 */
-UINT8 GetScxCesbCmdState(void);
+void ClearOnePlatEsbAndCutState(void);
 
-/**
+/*
-* @brief 设置试车线CESB命令状态
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急按钮激活状态
-* @input  CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* Created By fan 2026.03.10
+*			const UINT8 esbState 紧急按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
 */
-void SetScxCesbCmdState(UINT8 chCesbCmd);
+void SetRelOtherOnePlatEsbState(const UINT16 esbId, const UINT8 esbState);
 
-/**
+/*
-* @brief 获取全线区段试车线CESB旁路命令设置状态
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急旁路按钮激活状态
-* @param 无
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* @return ESB_CUT_NO:试车线未CESB旁路；ESB_CUT_YES 试车线CESB旁路有效
+*			const UINT8 esbCutState 紧急旁路按钮状态
-* Created By fan 2026.03.10
+* 返 回 值：无
+* Created By LQ 2025.12.29
 */
-UINT8 GetScxCesbCutCmdState(void);
+void SetRelOtherOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState);
 
-/**
+/*
-* @brief 设置试车线CESB旁路命令状态
+* 功能描述：检查指定ID紧急按钮关联的其它同站紧急按钮状态
-* @input ESB_CUT_NO: 试车线未CESB旁路；ESB_CUT_YES : 试车线CESB旁路
+* 参数说明：const UINT16 esbId 紧急按钮ID
-* Created By fan 2026.03.10
+* 返 回 值：1 紧急无效或旁路有效
+*           0 紧急有效
+* Created By LQ 2025.12.29
 */
-void SetScxCesbCutCmdState(UINT8 chCesbCmd);
+UINT8 CheckRelOtherOnePlatEsbState(const UINT16 esbId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/ESB/ESBDefine.h

@@ -23,10 +23,6 @@
 #define ESB_STATE_VALID_NO               ((UINT8)0x55)   /*紧急无效*/
 #define ESB_STATE_VALID_YES              ((UINT8)0xaa)   /*紧急有效*/
 
-/*全线紧急状态*/
-#define CESB_STATE_VALID_NO               ((UINT8)0xAA)   /*CESB紧急无效*/
-#define CESB_STATE_VALID_YES              ((UINT8)0x55)   /*CESB紧急有效*/
-
 /*紧急按钮旁路状态*/
 #define ESB_CUT_NO                   ((UINT8)0x55)    /* 未旁路 */
 #define ESB_CUT_YES                  ((UINT8)0xaa)    /* 旁路 */

TSCP/src/APP/ciapp/EnvelopeManage/ELMDataPrepare.c

@@ -176,7 +176,7 @@ else
 UINT8 elm_PrepareTrainSafeLoc(UINT16 trainID,INOUT ELM_TrainSafeLocStruct* pTrainSafeLoc)
 {
 UINT8 chRtnVal = CI_ERROR;
-UINT16 wTrainID = (UINT16)(0x1400u + (trainID & 0x00ffu));
+UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainID & 0x00ffU));
 
 if (NULL != pTrainSafeLoc)
 {
@@ -1012,7 +1012,7 @@ UINT32 elm_PrepareTrainLength(UINT16 trainid)
 	UINT8 chTrainType = 0u;
 	UINT8 chFunRtn = CI_ERROR;
 	UINT32 dwRtnVal = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	/*获取列车类型*/
 	chFunRtn = dquGetTrainType(wTrainID, &chTrainType);
@@ -1074,7 +1074,7 @@ UINT8 elm_PrepareNextAcMinSafeHeadLoc(UINT16 trainid, OUT UINT16 acID[AC_MAXCNT_
 	UINT8 chFunRtn = CI_ERROR;
 	LinkPointDataStru strPoint = { 0u };
 	UINT16 wSwitchId = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 	UINT8 cDirectionPointFlag = 0U;			/*是否具有方向变化点标志*/
 
 
@@ -1135,7 +1135,7 @@ UINT8 elm_PrepareMaxSafeHeadLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
 	UINT16 wLink = 0u;
 	UINT32 dwOff = UINT32_MAX;
 	UINT8 chDir = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 
 	wLink = GetTrainMaxHeadLink(wTrainID);
@@ -1169,7 +1169,7 @@ UINT8 elm_PrepareMinSafeHeadLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
 	UINT16 wLink = 0u;
 	UINT32 dwOff = UINT32_MAX;
 	UINT8 chDir = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 
 	wLink = GetTrainMinHeadLink(wTrainID);
@@ -1200,7 +1200,7 @@ UINT16 elm_PrepareACOfMaxSafeHeadLoc(UINT16 trainid)
 	UINT16 wMinHeadLink = 0u;
 	UINT8 chFunRtn = CI_ERROR;
 	UINT16 wRtn = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	wMinHeadLink = GetTrainMaxHeadLink(wTrainID);
 	chFunRtn = IsLinkIdValid(wMinHeadLink);
@@ -1227,7 +1227,7 @@ UINT16 elm_PrepareACOfMinSafeHeadLoc(UINT16 trainid)
 	UINT16 wMinHeadLink = 0u;
 	UINT8 chFunRtn = CI_ERROR;
 	UINT16 wRtn = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	wMinHeadLink = GetTrainMinHeadLink(wTrainID);
 	chFunRtn = IsLinkIdValid(wMinHeadLink);
@@ -1261,7 +1261,7 @@ UINT8 elm_PrepareNextAcMaxSafeTailLoc(UINT16 trainid, OUT UINT16 acID[AC_MAXCNT_
 	UINT8 chFunRtn = CI_ERROR;
 	LinkPointDataStru strPoint = { 0u };
 	UINT16 wSwitchId = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 	UINT8 cDirectionPointFlag = 0U;			/*是否具有方向变化点标志*/
 
 
@@ -1324,7 +1324,7 @@ UINT8 elm_PrepareMaxSafeTailLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
 	UINT16 wLink = 0u;
 	UINT32 dwOff = UINT32_MAX;
 	UINT8 chDir = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	wLink = GetTrainMaxTailLink(wTrainID);
 	dwOff = GetTrainMaxTailOffset(wTrainID);
@@ -1357,7 +1357,7 @@ UINT8 elm_PrepareMinSafeTailLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
 	UINT16 wLink = 0u;
 	UINT32 dwOff = UINT32_MAX;
 	UINT8 chDir = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	wLink = GetTrainMinTailLink(wTrainID);
 	dwOff = GetTrainMinTailOffset(wTrainID);
@@ -1387,7 +1387,7 @@ UINT16 elm_PrepareACOfMaxSafeTailLoc(UINT16 trainid)
 	UINT16 wMaxTailLink = 0u;
 	UINT8 chFunRtn = CI_ERROR;
 	UINT16 wRtn = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	wMaxTailLink = GetTrainMaxTailLink(wTrainID);
 	chFunRtn = IsLinkIdValid(wMaxTailLink);
@@ -1414,7 +1414,7 @@ UINT16 elm_PrepareACOfMinSafeTailLoc(UINT16 trainid)
 	UINT16 wMaxTailLink = 0u;
 	UINT8 chFunRtn = CI_ERROR;
 	UINT16 wRtn = 0u;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
 
 	wMaxTailLink = GetTrainMinTailLink(wTrainID);
 	chFunRtn = IsLinkIdValid(wMaxTailLink);
@@ -1529,7 +1529,7 @@ UINT8 elm_PrepareEnvelopeIsSelf(IN const EnvelopeStruct* ptemp)
 		/** 在一个OC*/
 		ret = ELM_BELONG_OWNER;
 	}
-	else if((localOCid != pointABelongOcid) && (localOCid != pointBBelongOcid))
+	else if ((localOCid != pointABelongOcid) && (localOCid != pointBBelongOcid))
 	{
 		/** 不在同一OC*/
 		ret = ELM_BELONG_OTHER;
@@ -1652,7 +1652,7 @@ UINT8 elm_PrepareComOCID(IN const UINT8 **pOCIDbuff)
 	else
 	{
 		/** 获取本OC通信的OC数量 */
-		ret = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_CI);
+		ret = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_RCI);
 
 		/** 判断是否存在，不存在直接返回*/
 		if (0u == ret)
@@ -1662,7 +1662,7 @@ UINT8 elm_PrepareComOCID(IN const UINT8 **pOCIDbuff)
 		else
 		{
 			/** 获取相邻通信的TIOC ID */
-			(*pOCIDbuff) = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_CI);
+			(*pOCIDbuff) = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RCI);
 		}
 	}
 	 
@@ -1683,8 +1683,8 @@ UINT8 elm_PrepareOCCommStatus(UINT8 OCID)
 	UINT8 ret = ELM_COM_STATUS_ERROR;
 	UINT8 funRtn = TRANSMIT_STATE_BAD;
 
-	/** 获取OC通信状态 */
+	/** 获取Rc通信状态 */
-	funRtn = GetCiTransmitState(CI_SYSTEM_TYPE_CI,OCID);
+	funRtn = GetRcPbTacsTransmitState(OCID); 
 	 
 	/** 设置函数返回值 */
 	ASSERT_SETRET(TRANSMIT_STATE_GOOD == funRtn,ret,ELM_COM_STATUS_OK,ELM_COM_STATUS_ERROR)
@@ -1771,7 +1771,7 @@ UINT8 elm_PrepareTrainSafeHeadFlag(UINT16 trainId)
 {
 	UINT8 ret = CI_ERROR;
 	UINT16 funRtn = TRAIN_HEAD_FLAG_YES;
-	UINT16 wTrainID = (UINT16)(0x1400u + (trainId & 0x00ffu));
+	UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainId & 0x00ffU));
 
 	funRtn = GetTrainSafeHeadFlag(wTrainID);
 

TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeLogicProcess.c

@@ -1511,6 +1511,8 @@ void elm_MaintenanceInfo(void)
 			outStringLength++;
 			outString[outStringLength] = pAcAssertInfo->redunOverCanArb;  /*冗余结束可判ARB标志*/
 			outStringLength++;
+			outString[outStringLength] = pAcAssertInfo->AxisCommBadArbFlag;  /*计轴通信中断可判ARB标志*/
+			outStringLength++;
 			outString[outStringLength] = pAcAssertInfo->passTrainFlag;  /*计轴区段好车通过标志*/
 			outStringLength++;
 			ShortToChar(pAcAssertInfo->passTrainID, &outString[outStringLength]);  /*计轴区段好车通过的列车ID*/

TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeScreen.c

@@ -6,8 +6,6 @@
 #include "EnvelopeLogicProcess.h"
 #include "WholeLineScreenAPI.h"
 #include "TrainDataManage.h"
-#include "SystemParameterManage.h"
-#include "DeviceDataManage.h"
 
 
 /*================================静态函数声明区==============================*/
@@ -565,12 +563,6 @@ void elm_TrainScreen(void)
 	UINT32 errorCode = 0u;
 	UINT8 comstatus = 0U;
 	const EnvelopeStruct* pEnvelop = NULL;
-	UINT8 cLocalCiType = 0U;
-	UINT8 cDsnFuncSwitch = 0U;  /*迪士尼功能开关*/
-	UINT8 cCurTrainTestStatus = 0U;  /*当前试车状态*/
-	UINT8 cFuncRetVal = CI_ERROR;
-	UINT8 cAcNum = 0U;  /*车身占用的计轴区段数量*/
-	UINT16 szAcId[MAX_AC_IN_TRAIN] = { 0U };  /*车身占用的计轴区段ID数组*/
 
 	for (cycle = 1u; cycle < ENVELOPE_SUM_MAX; cycle++)
 	{
@@ -587,45 +579,28 @@ void elm_TrainScreen(void)
 			/** 获取列车的通信状态 */
 			comstatus = elm_PrepareTrainCommStatus(pEnvelop->trainID[0u]);
 			/*CT包络且通信正常，才进行筛选*/
-			if ((TYPE_CT_ENVELOPE == pEnvelop->envelopeType) && (ELM_COM_STATUS_OK == comstatus))
+			if ((TYPE_CT_ENVELOPE == pEnvelop->envelopeType)&&(ELM_COM_STATUS_OK ==comstatus))
 			{
-				cLocalCiType = GetLocalCiType();
+				/** 判断前端是否可疑 */
-				cDsnFuncSwitch = GetCiFunctionSwitchConfig(FUNC_DSN_LINE_SWITCH);
+				if (0u != pEnvelop->headTrainID)
-				cCurTrainTestStatus = GetCiTrainTestStatus();  /*获取试车状态*/
-				cFuncRetVal = CheckTrainIsCompletelyLocal(pEnvelop->trainID[0U], &cAcNum, szAcId);  /*判断列车是否完全在本控区*/
-
-				if ((CI_TYPE_SCX == cLocalCiType)
-					&& (FUNC_SWITCH_ON == cDsnFuncSwitch)
-					&& (CI_TRAIN_TEST_ON == cCurTrainTestStatus)
-					&& (CI_SUCCESS == cFuncRetVal))
 				{
-					/*DSN试车线在试车中时，RC设置本控区内的通信车无前后端可疑*/
+					/** 处理前端筛选*/
-					(void)elm_SetEnvelopeHeadTrainID(pEnvelop->id, 0U);
+					elm_TrainHeadScreen(pEnvelop);
-					(void)elm_SetEnvelopeTailTrainID(pEnvelop->id, 0U);
 				}
 				else
 				{
-					/** 判断前端是否可疑 */
+					/** 无需处理 */
-					if (0u != pEnvelop->headTrainID)
+				}
-					{
-						/** 处理前端筛选*/
-						elm_TrainHeadScreen(pEnvelop);
-					}
-					else
-					{
-						/** 无需处理 */
-					}
 
-					/** 判断后端是否可疑*/
+				/** 判断后端是否可疑*/
-					if (0u != pEnvelop->tailTrainID)
+				if (0u != pEnvelop->tailTrainID)
-					{
+				{
-						/** 处理后端筛选*/
+					/** 处理后端筛选*/
-						elm_TrainTailScreen(pEnvelop);
+					elm_TrainTailScreen(pEnvelop);
-					}
+				}
-					else
+				else
-					{
+				{
-						/** 无需处理 */
+					/** 无需处理 */
-					}
 				}
 
 			}

TSCP/src/APP/ciapp/FloodGate/FloodGateDataManage.c

@@ -14,6 +14,7 @@
 
 
 FloodGateDataStruct FloodGateDataStru[FLOOD_GATE_SUM_MAX];   /*定义防淹门动态数据*/
+FloodGateDataStructCC FloodGateDataStruCC[FLOOD_GATE_SUM_MAX];   /*定义防淹门动态数据-车车*/
 
 
 /*
@@ -26,7 +27,16 @@ FloodGateDataStruct *GetFloodGateData(void)
 {
     return FloodGateDataStru;
 }
-
+/*
+* 功能描述： 获取防淹门数据结构体指针车车
+* 参数说明：
+* 返回值  ：
+			FloodGateDataStructCC *
+*/
+FloodGateDataStructCC* GetFloodGateDataCC(void)
+{
+	return FloodGateDataStruCC;
+}
 
 /*
 * 功能描述： 获取指定ID防淹门开门锁闭状态
@@ -482,7 +492,7 @@ UINT8 GetFloodGateCloseApplyIvocSum(const UINT16 floodGateId)
 
 	if (0u < bufIndex)
 	{
-		reVal = FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocSum;
+		reVal = FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocSum;
 	}
 	else
 	{
@@ -505,7 +515,7 @@ void SetFloodGateCloseApplyIvocSum(const UINT16 floodGateId, const UINT8 wTrainS
 
 	if (0u < bufIndex)
 	{
-		FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocSum = wTrainSum;
+		FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocSum = wTrainSum;
 	}
 	else
 	{
@@ -527,7 +537,7 @@ UINT16* GetFloodGateCloseApplyIvocId(const UINT16 floodGateId)
 
 	if (0u < bufIndex)
 	{
-		applyIvocBuf = FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocId;
+		applyIvocBuf = FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocId;
 	}
 	else
 	{
@@ -549,11 +559,11 @@ void SetFloodGateCloseApplyIvocId(const UINT16 floodGateId, const UINT16* applyI
 
 	if (0u < bufIndex)
 	{
-		(void)CommonMemSet(FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocId,
+		(void)CommonMemSet(FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocId,
 			(UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX),
 			0U, (UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX));			/*先出清，防止脏数据*/
 
-		(void)CommonMemCpy(FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocId,		/*赋值申请的列车ID*/
+		(void)CommonMemCpy(FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocId,		/*赋值申请的列车ID*/
 			(UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX),
 			applyIvocBuf, (UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX));
 	}
@@ -574,7 +584,7 @@ FloodGateTrainAnsStruct* GetFloodGateCloseFromIvocStru(const UINT16 floodGateId)
 
 	if (0u < bufIndex)
 	{
-		retVal = FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru;
+		retVal = FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru;
 	}
 	else
 	{
@@ -610,7 +620,7 @@ void SetFloodGateAllowCloseFlagIVOC(UINT16 floodGateId, UINT16 wTrainId, UINT8 a
 			trainSumIndex = chIvocSum;
 			for (ii = 0U; ii < chIvocSum; ii++)
 			{
-				if (FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId == wTrainId)
+				if (FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId == wTrainId)
 				{
 					retVal = CI_ERROR;	/*已存入过的列车,且回复了，不再存入*/
 					break;
@@ -619,8 +629,8 @@ void SetFloodGateAllowCloseFlagIVOC(UINT16 floodGateId, UINT16 wTrainId, UINT8 a
 
 			if (CI_SUCCESS == retVal)
 			{
-				FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wTrainId = wTrainId;
+				FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wTrainId = wTrainId;
-				FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wFloodGateCloseIvocFlag = agreeFlag;		/*检查标志的时候，查所有起始周期询问的列车是否都回复了同意*/
+				FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wFloodGateCloseIvocFlag = agreeFlag;		/*检查标志的时候，查所有起始周期询问的列车是否都回复了同意*/
 				chIvocSum++;
 				SetFloodGateCloseAnsIvocSum(floodGateId, chIvocSum);
 			}
@@ -653,8 +663,8 @@ void ClearFloodGateAllowClosFlagIVOC(UINT16 floodGateId)
 	{
 		for (ii = 0U; ii < chIvocSum; ii++)
 		{
-			FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId = 0U;
+			FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId = 0U;
-			FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC;
+			FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC;
 		}
 		SetFloodGateCloseAnsIvocSum(floodGateId, 0U);
 	}
@@ -674,7 +684,7 @@ UINT8 GetFloodGateAccessUTFlag(const UINT16 floodGateId)
 
 	if (0u < bufIndex)
 	{
-		reVal = FloodGateDataStru[bufIndex].FloodGateAccessUTFlag;
+		reVal = FloodGateDataStruCC[bufIndex].FloodGateAccessUTFlag;
 	}
 	else
 	{
@@ -699,7 +709,7 @@ void SetFloodGateAccessUTFlag(const UINT16 floodGateId, const UINT8 accessUTFlag
 	{
 		if ((FLOOD_GATE_ACCESS_UT_YES == accessUTFlag) || (FLOOD_GATE_ACCESS_UT_NO == accessUTFlag))
 		{/*混跑或者纯CT跑*/
-			FloodGateDataStru[bufIndex].FloodGateAccessUTFlag = accessUTFlag;
+			FloodGateDataStruCC[bufIndex].FloodGateAccessUTFlag = accessUTFlag;
 		}
 	}
 	else
@@ -722,7 +732,7 @@ UINT8 GetFloodGateCloseAnsIvocSum(const UINT16 floodGateId)
 
 	if (0u < bufIndex)
 	{
-		reVal = FloodGateDataStru[bufIndex].FloodGateCloseAnsIvocSum;
+		reVal = FloodGateDataStruCC[bufIndex].FloodGateCloseAnsIvocSum;
 	}
 	else
 	{
@@ -745,7 +755,7 @@ void SetFloodGateCloseAnsIvocSum(const UINT16 floodGateId, const UINT8 wTrainSum
 
 	if (0u < bufIndex)
 	{
-		FloodGateDataStru[bufIndex].FloodGateCloseAnsIvocSum = wTrainSum;
+		FloodGateDataStruCC[bufIndex].FloodGateCloseAnsIvocSum = wTrainSum;
 	}
 	else
 	{

TSCP/src/APP/ciapp/FloodGate/FloodGateDataManage.h

@@ -50,21 +50,23 @@ typedef struct S_FloodGateDataStruct
 	* 条件1为当前关门请求为是，且条件2满足，当前同意关门状态才为同意；
 	*/
 	UINT8  CurAgreeCloseStateOut;	 /*当前同意关门输出状态（动态字段）:FLOOD_GATE_AGREE_CLOSE、FLOOD_GATE_NOT_AGREE_CLOSE*/
-
 	UINT32 CurYGJCrossLineStartCount;/*当前YGJ混线开始时间*/
-
 	UINT32 CurFloodGateDelayCloseStartCyc;		/*防淹门接近区段占压延时关门开始时间*/
+} FloodGateDataStruct;
+
+/*防淹门数据结构体*/
+typedef struct S_FloodGateDataStructCC
+{
+	UINT16 FloodGateId;							/*防淹门ID (初始化字段)*/
 	UINT8 FloodGateCloseApplyIvocSum;			/*防淹门关门申请列车数量*/
 	UINT16 FloodGateCloseApplyIvocId[FLOOD_GATE_APPLY_TRAIN_SUM_MAX];	/*防淹门关门申请列车ID*/
-
 	UINT8 FloodGateCloseAnsIvocSum;				/*防淹门关门允许，列车回复数量*/
 	FloodGateTrainAnsStruct	FloodGateCloseFromIvocStru[FLOOD_GATE_APPLY_TRAIN_SUM_MAX];		/*列车同意防淹门关门请求结构体*/
 	UINT8 FloodGateAccessUTFlag;				/*防淹门接近区段是否有非通信车标志*/
-} FloodGateDataStruct;
+}FloodGateDataStructCC;
-
 /*******************************全局变量声明*******************************/
 extern FloodGateDataStruct FloodGateDataStru[FLOOD_GATE_SUM_MAX];   /*定义防淹门动态数据*/
-
+extern FloodGateDataStructCC FloodGateDataStruCC[FLOOD_GATE_SUM_MAX];   /*定义防淹门动态数据-车车*/
 /*
 * 功能描述： 获取防淹门数据结构体指针
 * 参数说明：    
@@ -72,6 +74,13 @@ extern FloodGateDataStruct FloodGateDataStru[FLOOD_GATE_SUM_MAX];   /*
             FloodGateDataStruct *  
 */
 FloodGateDataStruct *GetFloodGateData(void);
+/*
+* 功能描述： 获取防淹门数据结构体指针车车
+* 参数说明：
+* 返回值  ：
+			FloodGateDataStructCC *
+*/
+FloodGateDataStructCC* GetFloodGateDataCC(void);
 
 /*
 * 功能描述： 获取指定ID防淹门开门锁闭状态

TSCP/src/APP/ciapp/Garagedoor/GaragedoorDataManage.c

@@ -14,7 +14,7 @@
 #include "WLScreenDataPrepare.h"
 
 GaragedoorDataStruct GaragedoorDataStru[GARAGE_DOOR_SUM_MAX];   /*定义车库门数据结构体*/
-
+GaragedoorDataStructCC GaragedoorDataStruCC[GARAGE_DOOR_SUM_MAX];   /*定义车库门数据结构体-车车*/
 
 /*
 * 功能描述： 获取指定车库门数据
@@ -26,7 +26,16 @@ GaragedoorDataStruct *GetGaragedoorData(void)
 {
     return GaragedoorDataStru;
 }
-
+/*
+* 功能描述： 获取指定车库门数据-车车
+* 参数说明：
+* 返回值  ：
+			GaragedoorDataStructCC *
+*/
+GaragedoorDataStructCC* GetGaragedoorDataCC(void)
+{
+	return GaragedoorDataStruCC;
+}
 /*
 * 功能描述： 获取指定ID车库门状态
 * 参数说明： const UINT16 garagedoorId, 车库门ID    
@@ -143,7 +152,7 @@ UINT8 GetGaragedoorAllowCloseFlagIVOC(const UINT16 garagedoorId)
 
 	if (bufIndex < GARAGE_DOOR_SUM_MAX)
 	{
-		reVal = GaragedoorDataStru[bufIndex].GDAllowCloseFlagIVOC;
+		reVal = GaragedoorDataStruCC[bufIndex].GDAllowCloseFlagIVOC;
 	}
 
 	return reVal;
@@ -167,7 +176,7 @@ void SetGaragedoorAllowCloseFlagIVOC(const UINT16 garagedoorId, const UINT8 allo
 		if ((GARAGE_DOOR_ALLOW_CLOSE_YES == allowCloseFlag) || (GARAGE_DOOR_ALLOW_CLOSE_NO == allowCloseFlag))
 		{
 
-			GaragedoorDataStru[bufIndex].GDAllowCloseFlagIVOC = allowCloseFlag;  /*允许关门标志*/
+			GaragedoorDataStruCC[bufIndex].GDAllowCloseFlagIVOC = allowCloseFlag;  /*允许关门标志*/
 
 		}
 	}
@@ -190,7 +199,7 @@ UINT16 GetGaragedoorNearestTrainId(const UINT16 garagedoorId)
 
 	if (bufIndex < GARAGE_DOOR_SUM_MAX)
 	{
-		reVal = GaragedoorDataStru[bufIndex].GDAkuNearestTrainId;
+		reVal = GaragedoorDataStruCC[bufIndex].GDAkuNearestTrainId;
 	}
 
 	return reVal;
@@ -215,7 +224,7 @@ void SetGaragedoorNearestTrainId(const UINT16 garagedoorId, const UINT16 trainId
 		if (UINT16_MAX!= trainId)
 		{
 
-			GaragedoorDataStru[bufIndex].GDAkuNearestTrainId = trainId;  /*允许关门标志*/
+			GaragedoorDataStruCC[bufIndex].GDAkuNearestTrainId = trainId;  /*允许关门标志*/
 
 		}
 	}
@@ -561,7 +570,7 @@ void SetWaiteIVOCResponseStartCycNum(const UINT16 garagedoorId, const UINT32 sta
 
 	if (bufIndex < GARAGE_DOOR_SUM_MAX)
 	{
-		GaragedoorDataStru[bufIndex].waiteIVOCResponseStartCycNum = startCycNum;   /*起始周期号*/
+		GaragedoorDataStruCC[bufIndex].waiteIVOCResponseStartCycNum = startCycNum;   /*起始周期号*/
 	}
 
 }
@@ -581,7 +590,7 @@ UINT32 GetWaiteIVOCResponseStartCycNum(const UINT16 garagedoorId)
 
 	if (bufIndex < GARAGE_DOOR_SUM_MAX)
 	{
-		ret = GaragedoorDataStru[bufIndex].waiteIVOCResponseStartCycNum;
+		ret = GaragedoorDataStruCC[bufIndex].waiteIVOCResponseStartCycNum;
 	}
 
 	return ret;

TSCP/src/APP/ciapp/Garagedoor/GaragedoorDataManage.h

@@ -32,8 +32,7 @@ typedef struct S_GaragedoorDataStruct
     UINT16 GaragedoorId;         /*车库门ID (初始化字段)*/
 	UINT8 GaragedoorState;      /*车库门状态 (动态字段)*/
 	UINT8 GaragedoorAllowCloseFlag; /*车库门允许关门标志，ZC发送*/
-	UINT8 GDAllowCloseFlagIVOC;   /*车库门允许关门标志，IVOC发送*/
+
-	UINT16 GDAkuNearestTrainId;     /*A库物理区段上最接近的列车*/
     UINT8 GaragedoorModeState;       /*车库门模式状态*/
     UINT8 GaragedoorFaultState;		/*车库门故障状态*/
 	UINT8 GaragedoorPangLuState;    /*车库门旁路状态*/
@@ -41,14 +40,21 @@ typedef struct S_GaragedoorDataStruct
 	UINT8 cmdProcessState;			/* 命令处理状态 */
 	UINT32 drvDoorStartCycle;		/* 驱动开始时间,预留 */
     UINT32 waiteZCResponseStartCycNum; /*等待ZC反馈开始时间*/
-	UINT32 waiteIVOCResponseStartCycNum; /*等待IVOC反馈开始时间*/
+	
 	UINT32 GaragedoorOpenStartCycNum;   /*车库门打开开始周期 (动态字段)*/
 	UINT32 GaragedoorCloseStartCycNum;   /*车库门关闭开始周期 (动态字段)*/
 } GaragedoorDataStruct;
-
+/*车库门数据结构体*/
+typedef struct S_GaragedoorDataStructCC
+{
+	UINT16 GaragedoorId;         /*车库门ID (初始化字段)*/
+	UINT8 GDAllowCloseFlagIVOC;   /*车库门允许关门标志，IVOC发送*/
+	UINT16 GDAkuNearestTrainId;     /*A库物理区段上最接近的列车*/
+	UINT32 waiteIVOCResponseStartCycNum; /*等待IVOC反馈开始时间*/
+}GaragedoorDataStructCC;
 
 extern GaragedoorDataStruct GaragedoorDataStru[GARAGE_DOOR_SUM_MAX];   /*定义车库门数据结构体*/
-
+extern GaragedoorDataStructCC GaragedoorDataStruCC[GARAGE_DOOR_SUM_MAX];   /*定义车库门数据结构体-车车*/
 /*
 * 功能描述： 获取指定车库门数据
 * 参数说明：    
@@ -56,6 +62,13 @@ extern GaragedoorDataStruct GaragedoorDataStru[GARAGE_DOOR_SUM_MAX];   /*
             GaragedoorDataStruct *  
 */
 GaragedoorDataStruct *GetGaragedoorData(void);
+/*
+* 功能描述： 获取指定车库门数据-车车
+* 参数说明：
+* 返回值  ：
+			GaragedoorDataStructCC *
+*/
+GaragedoorDataStructCC* GetGaragedoorDataCC(void);
 
 /*
 * 功能描述： 获取指定ID车库门驱动状态

TSCP/src/APP/ciapp/HLHTMsgHead/HLHTCommonDataPacketHead.c

@@ -93,7 +93,7 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
 	UINT32 LocalEtcsId = 0u;					  /*发送方标识*/
 	UINT32 RemoteEtcsId = 0u; 				  /*接收方标识*/
 	UINT32 emapVer = 0U;/*应该使用的电子地图版本*/
-	UINT8 emapCheckVer = 0U; /*电子地图版本校验结果*/
+	UINT8 emapCheckVer = CI_ERROR; /*电子地图版本获取结果*/
 	UINT8 chRet = 0U;
 
 	/*错误码每次都清零*/
@@ -109,29 +109,66 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
 		;
 	}
 
-	/*发送方校验*/
+
-	chRet = dquDevName2HlhtId(LocalDevName, logId, &LocalEtcsId);
+	if ((CI_SYSTEM_TYPE_OC == devType) || (CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType))
-	if ((CI_ERROR == chRet) || (pMICommonPackage->sourceId != LocalEtcsId))
 	{
-		*pErrorCode |= GAL_COMPARE_SEND_FLAG_ERR;
+		/*OC/现地/ATS无互联互通ID*/
+		if ((UINT16)(pMICommonPackage->sourceId & 0x0000FFFFU) != LocalDevName)
+		{
+			*pErrorCode |= GAL_COMPARE_SEND_FLAG_ERR;
+		}
+		else
+		{
+			;
+		}
+		if((UINT16)(pMICommonPackage->destId & 0x0000FFFFU) != RemoteDevName)
+		{
+			*pErrorCode |= GAL_COMPARE_RECV_FLAG_ERR;
+		}
+		else
+		{
+			;
+		}
 	}
 	else
 	{
-		;
+		/*发送方校验*/
+		chRet = dquDevName2HlhtId(LocalDevName, logId, &LocalEtcsId);
+		if ((CI_ERROR == chRet) || (pMICommonPackage->sourceId != LocalEtcsId))
+		{
+			*pErrorCode |= GAL_COMPARE_SEND_FLAG_ERR;
+		}
+		else
+		{
+			;
+		}
+		/*接收方校验*/
+		chRet = dquDevName2HlhtId(RemoteDevName, logId, &RemoteEtcsId);
+		if ((CI_ERROR == chRet) || (pMICommonPackage->destId != RemoteEtcsId))
+		{
+			*pErrorCode |= GAL_COMPARE_RECV_FLAG_ERR;
+		}
+		else
+		{
+			;
+		}
 	}
 
-	/*接收方校验*/
+	if ((CI_SYSTEM_TYPE_CI == devType) || (CI_SYSTEM_TYPE_RC == devType))
-	chRet = dquDevName2HlhtId(RemoteDevName, logId, &RemoteEtcsId);
-	if ((CI_ERROR == chRet) || (pMICommonPackage->destId != RemoteEtcsId))
 	{
-		*pErrorCode |= GAL_COMPARE_RECV_FLAG_ERR;
+		/*修改：根据发送方类型获取电子地图校验*/
+		emapVer = GetCiTranCiDataCheckVer((UINT8)(RemoteDevName & 0x00FFU), LocalDevName);
+		emapCheckVer = CI_SUCCESS;
+	}
+	else if (CI_SYSTEM_TYPE_OC == devType)
+	{
+		emapVer = GetCiTranOcDataCheckVer((UINT8)(RemoteDevName & 0x00FFU), LocalDevName);
+		emapCheckVer = CI_SUCCESS;
 	}
 	else
 	{
-		;
+		emapCheckVer = GetCiEmapCheckVer((UINT8)RemoteDevName, &emapVer, devType);
 	}
-
-	emapCheckVer = GetCiEmapCheckVer((UINT8)RemoteDevName, &emapVer, devType);
 	if (CI_SUCCESS == emapCheckVer)
 	{
 		/*电子地图版本校验信息(4字节CRC比较)*/

TSCP/src/APP/ciapp/HLHTMsgHead/HLHTHeadContexManage.c

@@ -15,15 +15,22 @@
 #include "../2oo2/2oo2InterfaceDataManage.h"
 #include "CommonMemory.h"
 
-HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX]={0};/*存放与本CI通信的相邻CI互联互通报文头上下文数据*/
+HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX]={0U};/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
-HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX]={0};/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
+HLHTHeadContextStru gSzRcHLHTHeadCtxs[CI_SUM_MAX] = { 0U };  /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
-HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX] = { 0 };/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
+HLHTHeadContextStru ciHLHTHeadCtxsCiToRc[CI_SUM_MAX] = { 0U };/*存放本控区CI同步的相邻CI互联互通报文头上下文数据*/
-HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX]={0};/*存放与本CI通信的ZC互联互通报文头上下文数据*/
+HLHTHeadContextStru gSzRcHLHTHeadCtxsCiToRc[CI_SUM_MAX] = { 0U };  /*存放本控区CI同步的相邻RC互联互通报文头上下文数据*/
-HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX]={0};/*存放与本CI通信的OC互联互通报文头上下文数据*/
+HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX]={0U};/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
-HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0 };/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
+HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX] = { 0U };/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
-HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX] = { 0 };/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
+HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX]={0U};/*存放与本CI通信的ZC互联互通报文头上下文数据*/
+HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX]={0U};/*存放与本CI通信的OC互联互通报文头上下文数据*/
+HLHTHeadContextStru ocHLHTHeadCtxsCiToRc[OC_SUM_MAX] = { 0U };/*存放同步的CI通-OC互联互通报文头上下文数据*/
+HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0U };/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
+HLHTHeadContextStru gSzRcAxleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0U };/*存放与RC通信的计轴系统互联互通报文头上下文数据*/
+HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX] = { 0U };/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
 HLHTHeadContextStru IteHLHTHeadCtxs[ITE_SUM_MAX][VOBC_INC_ITE_SUM_MAX] = { 0U };/*存放与本TIOC通信的ITE互联互通报文头上下文数据*/
-
+HLHTHeadContextStru gSzXiandiHLHTHeadCtxs[ATS_SUM_MAX] = { 0U };/*存放与本CI通信的现地互联互通报文头上下文数据*/
+HLHTHeadContextStru gSzAtsHLHTHeadCtxs[ATS_SUM_MAX] = { 0U };/*存放与本CI通信的ATS互联互通报文头上下文数据*/
+HLHTHeadContextStru vobcToRcHLHTHeadCtxs[VOBC_SUM_MAX] = { 0 };/*RC模式下，存放与本RC通信的510 VOBC互联互通报文头上下文数据。CI模式下不使用*/
 /*
 * 功能描述:本地函数，获得某种设备类型的用于后续运算的互联互通头上下文数据
 * 参数说明:
@@ -417,6 +424,7 @@ void ProcHlhtHeadCtxTimeOut(void)
 {
 	UINT32 timeoutSnCount = 0U;
 	UINT32 timeoutSpan = 0U;
+	UINT8 chSystemWorkType = GetSystemWorkType();; /*系统工作类型*/
 
 	/*处理VOBC通用报文头的时效性*/
 	timeoutSnCount = GetCiAndVobcTransBadEnsureCnt();
@@ -436,6 +444,11 @@ void ProcHlhtHeadCtxTimeOut(void)
 	timeoutSpan = GetCiAndCiTransmitBadEnsureTime();
 	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, ciHLHTHeadCtxs, CI_SUM_MAX);
 
+	/*处理RC通用报文头的时效性*/
+	timeoutSnCount = GetCiAndCiTransBadEnsureCnt();
+	timeoutSpan = GetCiAndCiTransmitBadEnsureTime();
+	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzRcHLHTHeadCtxs, CI_SUM_MAX);
+
 	/*处理与CI通信的ZC通用报文头的时效性*/
 	timeoutSnCount = GetCiAndZcTransBadEnsureCnt();
 	timeoutSpan = GetCiAndZcTransmitBadEnsureTime();
@@ -451,10 +464,38 @@ void ProcHlhtHeadCtxTimeOut(void)
 	timeoutSpan = GetCiAndOcTransmitBadEnsureTime();
 	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, ocHLHTHeadCtxs, OC_SUM_MAX);
 
+#if 0
+	/*不需要处理CI同步过来的数据 需要留着周期号用来做接收数据判断*/
+	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, ocHLHTHeadCtxsCiToRc, OC_SUM_MAX);
+#endif 
 	/*处理与AXLE通信报文头的时效性*/
 	timeoutSnCount = GetCiAndAxleTransBadEnsureCnt();
 	timeoutSpan = GetCiAndAxleTransBadEnsureTime();
 	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, axleHLHTHeadCtxs, AXLE_SUM_MAX);
+	if ((SYSTEM_WORK_MODE_ALL == chSystemWorkType) && (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI))
+	{
+		/*双系统RC还需要处理RC通用报文头*/
+		ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzRcAxleHLHTHeadCtxs, AXLE_SUM_MAX);
+	}
+	else
+	{
+		;
+	}
+
+	/*处理与现地通信报文头的时效性*/
+	timeoutSnCount = GetCiAndAtsTransBadEnsureCnt();
+	timeoutSpan = GetCiAndAtsTransBadEnsureTime();
+	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzXiandiHLHTHeadCtxs, ATS_SUM_MAX);
+
+	/*处理与ATS通信报文头的时效性*/
+	timeoutSnCount = GetCiAndAtsTransBadEnsureCnt();
+	timeoutSpan = GetCiAndAtsTransBadEnsureTime();
+	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzAtsHLHTHeadCtxs, ATS_SUM_MAX);
+
+	/*处理VOBC通用报文头的时效性*/
+	timeoutSnCount = GetCiAndVobcTransBadEnsureCnt();
+	timeoutSpan = GetCiAndVobcTransBadEnsureTime();
+	ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, vobcToRcHLHTHeadCtxs, VOBC_SUM_MAX);
 }
 /*
 * 功能描述： 根据设备类型，获得具备初始通信互联互通头的所有设备ID
@@ -537,15 +578,40 @@ static UINT8 GetHLHTHeadCtxTmepVars(const UINT8 devType, UINT16 *devMaxSum, HLHT
 	UINT8 retVal = CI_ERROR;
 	UINT16 maxDevSum = 0u;
 	HLHTHeadContextStru *tempHeadCtxPtr = NULL;
+	UINT8 chSystemWorkType = GetSystemWorkType();/*系统工作类型*/
+	UINT8 cRcWorkMode = 0U;/*本系统当前工作模式*/
 
-	if ((CI_SYSTEM_TYPE_CI == devType))
+	cRcWorkMode = GetLocalRcWorkMode();
+
+	if (CI_SYSTEM_TYPE_CI == devType)
 	{
 		maxDevSum = CI_SUM_MAX;
 		tempHeadCtxPtr = ciHLHTHeadCtxs;
 
 		retVal = CI_SUCCESS;
 	}
+	else if (CI_SYSTEM_TYPE_RC == devType)
+	{
+		maxDevSum = CI_SUM_MAX;
+		tempHeadCtxPtr = gSzRcHLHTHeadCtxs;
+
+		retVal = CI_SUCCESS;
+	}
 	else if (CI_SYSTEM_TYPE_VOBC == devType)
+	{
+		maxDevSum = VOBC_SUM_MAX;
+		if (RC_WORK_MODE_CI == cRcWorkMode)
+		{
+			tempHeadCtxPtr = vobcHLHTHeadCtxs;
+		}
+		else
+		{/*RC模式下*/
+			tempHeadCtxPtr = vobcToRcHLHTHeadCtxs;
+		}
+
+		retVal = CI_SUCCESS;
+	}
+	else if (CI_SYSTEM_TYPE_IVOC == devType)
 	{
 		maxDevSum = VOBC_SUM_MAX;
 		tempHeadCtxPtr = vobcHLHTHeadCtxs;	
@@ -576,7 +642,14 @@ static UINT8 GetHLHTHeadCtxTmepVars(const UINT8 devType, UINT16 *devMaxSum, HLHT
 	else if (CI_SYSTEM_TYPE_AXIS == devType)
 	{
 		maxDevSum = AXLE_SUM_MAX;
-		tempHeadCtxPtr = axleHLHTHeadCtxs;
+		if((SYSTEM_WORK_MODE_ALL == chSystemWorkType) && (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI))
+		{
+			tempHeadCtxPtr = gSzRcAxleHLHTHeadCtxs;
+		}
+		else
+		{
+			tempHeadCtxPtr = axleHLHTHeadCtxs;
+		}
 		
 		retVal = CI_SUCCESS;
 	}
@@ -587,6 +660,20 @@ static UINT8 GetHLHTHeadCtxTmepVars(const UINT8 devType, UINT16 *devMaxSum, HLHT
 
 		retVal = CI_SUCCESS;
 	}
+	else if (CI_SYSTEM_TYPE_XIANDI == devType)
+	{
+		maxDevSum = ATS_SUM_MAX;
+		tempHeadCtxPtr = gSzXiandiHLHTHeadCtxs;
+
+		retVal = CI_SUCCESS;
+	}
+	else if (CI_SYSTEM_TYPE_ATS == devType)
+	{
+		maxDevSum = ATS_SUM_MAX;
+		tempHeadCtxPtr = gSzAtsHLHTHeadCtxs;
+
+		retVal = CI_SUCCESS;
+	}
 	else
 	{
 		retVal = CI_ERROR;
@@ -614,7 +701,7 @@ static void ProcHlhtHeadCtxTimeOutDiffSys(const UINT32 timeoutSnCount, const UIN
 	HLHTHeadContextStru tempHeadCtx = { 0u };
 	UINT8 headValid = 0u;
 	INT32 remainValidiy;/*剩余的时间*/
-
+	UINT8 chRcID = 0U;
 	if (NULL != headCtxs)
 	{
 		for (i = 0u;i < headCount;i++)
@@ -652,21 +739,9 @@ static void ProcHlhtHeadCtxTimeOutDiffSys(const UINT32 timeoutSnCount, const UIN
 
 				if (0u == headValid)
 				{
-					if (headCtxs == axleHLHTHeadCtxs) /*计轴系统中断时,GAL层对方序号,收到对方数据时本方序号,设置0xFFFFFFFF*/
+					(void)CommonMemSet(&(headCtxs[i]), (UINT32)sizeof(HLHTHeadContextStru), 0u, (UINT32)sizeof(HLHTHeadContextStru));
-					{
+					headCtxs[i].sourceCrntOwnMsgSN = 0xFFFFFFFFu;
-						headCtxs[i].logId = 0u;
+					headCtxs[i].ciPreRecvOwnSn = 0xFFFFFFFFu;
-						headCtxs[i].sourceRecvOppMsgSN = 0u;
-						headCtxs[i].sourcePreOwnMsgSN = 0u;
-						headCtxs[i].sourceComPeriod = 0u;
-						headCtxs[i].sourceCrntOwnMsgSN = 0xFFFFFFFFu;
-						headCtxs[i].ciPreRecvOwnSn = 0xFFFFFFFFu;
-					}
-					else
-					{
-						(void)CommonMemSet(&(headCtxs[i]), (UINT32)sizeof(HLHTHeadContextStru), 0u, (UINT32)sizeof(HLHTHeadContextStru));
-						headCtxs[i].sourceCrntOwnMsgSN = 0xFFFFFFFFu;
-						headCtxs[i].ciPreRecvOwnSn = 0xFFFFFFFFu;
-					}
 				}
 				else
 				{
@@ -1183,3 +1258,72 @@ void ProcIteHlhtHeadCtxTimeOut(const UINT32 dwTimeoutSnCount, const UINT32 dwTim
 		}
 	}
 }
+
+/*
+* 功能描述：获取指定oc的CI-RC同步互联互通报文头上下文数据
+* 参数说明：const UINT8 oc ID
+* 返 回 值：NULL 获取数据失败
+*           非NULL 获取数据成功
+* Created By fan 2025.11.12
+*/
+HLHTHeadContextStru* GetCiToRcHLHTOcHeadCtx(const UINT8 ocId)
+{
+	HLHTHeadContextStru* pstrRetVal = NULL;
+
+	if ((0U < ocId) && (OC_SUM_MAX > ocId))
+	{
+		pstrRetVal = &ocHLHTHeadCtxsCiToRc[ocId];
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	return pstrRetVal;
+}
+
+/*
+* 功能描述：获取指定CI的CI-RC同步CI互联互通报文头上下文数据
+* 参数说明：const UINT8 chDevId 设备ID
+* 返 回 值：NULL 获取数据失败
+*           非NULL 获取数据成功
+* Created By fan 2025.12.31
+*/
+HLHTHeadContextStru* GetCiToRcWithCiHeadCtx(const UINT8 chDevId)
+{
+	HLHTHeadContextStru* pstrRetVal = NULL;
+
+	if ((0U < chDevId) && (CI_SUM_MAX > chDevId))
+	{
+		pstrRetVal = &ciHLHTHeadCtxsCiToRc[chDevId];
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	return pstrRetVal;
+}
+
+/*
+* 功能描述：获取指定CI的CI-RC同步RC互联互通报文头上下文数据
+* 参数说明：const UINT8 chDevId 设备ID
+* 返 回 值：NULL 获取数据失败
+*           非NULL 获取数据成功
+* Created By fan 2025.12.31
+*/
+HLHTHeadContextStru* GetCiToRcWithRcHeadCtx(const UINT8 chDevId)
+{
+	HLHTHeadContextStru* pstrRetVal = NULL;
+
+	if ((0U < chDevId) && (CI_SUM_MAX > chDevId))
+	{
+		pstrRetVal = &gSzRcHLHTHeadCtxsCiToRc[chDevId];
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	return pstrRetVal;
+}

TSCP/src/APP/ciapp/HLHTMsgHead/HLHTHeadContexManage.h

@@ -38,15 +38,22 @@ extern "C" {
 	} HLHTHeadContextStru;
 
 	/*******************************全局变量声明*******************************/
-	extern HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX];/*存放与本CI通信的相邻CI互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX];/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru gSzRcHLHTHeadCtxs[CI_SUM_MAX];  /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru ciHLHTHeadCtxsCiToRc[CI_SUM_MAX];/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru gSzRcHLHTHeadCtxsCiToRc[CI_SUM_MAX];  /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX];/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX];/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX];/*存放与本CI通信的ZC互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX];/*存放与本CI通信的OC互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru ocHLHTHeadCtxsCiToRc[OC_SUM_MAX];/*存放与本CI通信的OC互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX];/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru gSzRcAxleHLHTHeadCtxs[AXLE_SUM_MAX];/*存放与RC通信的计轴系统互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX];/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
 	extern HLHTHeadContextStru IteHLHTHeadCtxs[ITE_SUM_MAX][VOBC_INC_ITE_SUM_MAX];/*存放与本TIOC通信的ITE互联互通报文头上下文数据*/
-
+	extern HLHTHeadContextStru gSzXiandiHLHTHeadCtxs[ATS_SUM_MAX]; /*存放与本CI通信的现地互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru gSzAtsHLHTHeadCtxs[ATS_SUM_MAX]; /*存放与本CI通信的ATS互联互通报文头上下文数据*/
+	extern HLHTHeadContextStru vobcToRcHLHTHeadCtxs[VOBC_SUM_MAX];/*RC模式下，存放与本RC通信的510 VOBC互联互通报文头上下文数据。CI模式下不使用*/
 	/*
 	* 功能描述:获取某个设备最近一次给CI发送数据时其当前的序号
 	* 参数说明:
@@ -285,6 +292,31 @@ extern "C" {
     * Created By LQ 2024.06.11
     */
 	void ProcIteHlhtHeadCtxTimeOut(const UINT32 dwTimeoutSnCount, const UINT32 dwTimeoutSpan);
+	/*
+	* 功能描述：获取指定oc的CI-RC同步互联互通报文头上下文数据
+	* 参数说明：const UINT8 oc ID
+	* 返 回 值：NULL 获取数据失败
+	*           非NULL 获取数据成功
+	* Created By fan 2025.11.12
+	*/
+	HLHTHeadContextStru* GetCiToRcHLHTOcHeadCtx(const UINT8 ocId);
+	/*
+	* 功能描述：获取指定CI的CI-RC同步CI互联互通报文头上下文数据
+	* 参数说明：const UINT8 chDevId 设备ID
+	* 返 回 值：NULL 获取数据失败
+	*           非NULL 获取数据成功
+	* Created By fan 2025.12.31
+	*/
+	HLHTHeadContextStru* GetCiToRcWithCiHeadCtx(const UINT8 chDevId);
+
+	/*
+	* 功能描述：获取指定CI的CI-RC同步RC互联互通报文头上下文数据
+	* 参数说明：const UINT8 chDevId 设备ID
+	* 返 回 值：NULL 获取数据失败
+	*           非NULL 获取数据成功
+	* Created By fan 2025.12.31
+	*/
+	HLHTHeadContextStru* GetCiToRcWithRcHeadCtx(const UINT8 chDevId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h

@@ -44,10 +44,8 @@
 #include "../WashMachine/WashMachineConfigDataManage.h"
 #include "../WashMachine/WashMachineDataManage.h"
 #include "../ParsePack/ParsePackOcData.h"
-#include "../OHL/OHLDataManage.h"
 #include "ReverseCutDataManage.h"
 #include "ReverseCutConfigDataManage.h"
-#include "../SsksLightRelay/SsksLightRelayDefine.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -139,12 +137,14 @@ void SwitchDeviceToRelayStateProc(void);
 */
 void PhySecRelayToDeviceStateProc(void);
 
+#if 0
 /*
 * 功能描述： 更新区段计轴复位继电器状态
 * 参数说明： void
 * 返回值  ： void     
 */
 void PhySecResetToRelayStateProc(void);
+#endif
 /*
 * 功能描述： 更新区段计轴复位继电器状态
 * 参数说明： void
@@ -186,10 +186,9 @@ UINT8 PsdDeviceToRelayStateProc(void);
 /*
 * 功能描述： 更新洗车机继电器状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
+* 返回值  ： void     
-*			 1: 更新成功      
 */
-UINT8 WashMachineDevToRelayStaProc(void);
+void WashMachineDevToRelayStaProc(void);
 
 /*
 * 功能描述： 更新紧急停车按钮逻辑状态
@@ -226,10 +225,9 @@ void GaragedoorDevToRelayStaProc(void);
 /*
 * 功能描述： 更新洗车机的逻辑状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
+* 返回值  ： void
-*			 1: 更新成功
 */
-UINT8 WashMachineToDeviceStateProc(void);
+void WashMachineToDeviceStateProc(void);
 /*
 * 功能描述： 更新Spks按钮逻辑状态
 * 参数说明： void
@@ -328,12 +326,17 @@ void OcSwitchDeviceOutput(void);
 UINT8 GetOcSignalColor(UINT16 signalId);
 
 /*
-* 功能描述： 获取OC道岔设备颜色
+* 功能描述： 获取OC道岔设备状态
 * 参数说明：
-		UINT16 signalId：信号机id
+		UINT16 switchId：道岔id
-* 返回值  ： void
+		UINT8 mainControlOCId 主控OCId
+* 返回值  ：
+*			((UINT8)0x01)    道岔定位
+*			((UINT8)0x02)    道岔反位
+*			((UINT8)0x04)    道岔四开
+*			((UINT8)0x08)    道岔移动
 */
-UINT8 GetOcSwitchState(UINT16 switchId);
+UINT8 GetOcSwitchState(UINT16 switchId, UINT8 mainControlOCId);
 
 /*
 * 功能描述： 间隙探测脉冲接口方式启动驱动处理
@@ -356,7 +359,7 @@ void ProcessJXTCPulseInterfStopDrv(UINT16 startJXTCRelayId, UINT16 stopJXTCRelay
 
 /******************************OC spks指示灯输出处理****************************/
 /*
-* 功能描述： OC spks指示灯和spks旁路指示灯输出处理
+* 功能描述： OC spks指示灯、spks旁路指示灯及蜂鸣继电器处理
 * 参数说明： void
 * 返回值  ： void
 */
@@ -760,43 +763,6 @@ UINT8 CheckRelayDriveOutTime(const UINT16 wRelayId, const UINT32 dwTimeOutCycCou
 */
 void SGBJDriveOutputProc(void);
 
-/*
-* 功能描述：SSKS闪灯稳灯输出处理
-* 参数说明：void
-* 返 回 值：void
-* Created By LQ 2025.12.16
-*/
-void SsksFlashSteadyLightOutputProc(void);
-
-/*
-* 功能描述：SSKS关联驶入存车线进路标志处理
-* 参数说明：UINT16 wRelayId SSKS闪灯稳灯继电器ID
-*           UINT8 cEnterRouteNum 驶入存车线进路数量
-*           UINT16 szEnterRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX] 驶入存车线进路ID数组
-* 返 回 值：void
-* Created By LQ 2025.12.16
-*/
-void SsksRelEnterRouteFlagProc(UINT16 wRelayId, UINT8 cEnterRouteNum, UINT16 szEnterRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX]);
-
-/*
-* 功能描述：检查进路内方最后一个物理区段的上一个区段是否空闲且解锁
-* 参数说明：UINT16 wRouteId 进路ID
-* 返 回 值：0 失败（区段锁闭或占用）
-*           1 成功（区段未锁闭且空闲）
-* Created By LQ 2026.03.11
-*/
-UINT8 CheckRouteLastPSUnlockAndIdle(UINT16 wRouteId);
-
-/*
-* 功能描述：SSKS关联驶出存车线进路标志处理
-* 参数说明：UINT16 wRelayId SSKS闪灯稳灯继电器ID
-*           UINT8 cExportRouteNum 驶出存车线进路数量
-*           UINT16 szExportRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX] 驶出存车线进路ID数组
-* 返 回 值：void
-* Created By LQ 2025.12.16
-*/
-void SsksRelExportRouteFlagProc(UINT16 wRelayId, UINT8 cExportRouteNum, UINT16 szExportRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX]);
-
 /*
 * 功能描述： 设置继电器驱动起始周期
 * 参数说明： const UINT16 relayId 继电器ID
@@ -842,7 +808,7 @@ UINT8 WashMachineWorkModeRelayProc(const UINT16 washMachineId);
 *			 CI_SUCCESS: 更新成功
 * by cgh 20231113
 */
-UINT8 DownWashDevToRelayStaProc(const UINT16 washMachineId);
+void DownWashDevToRelayStaProc(const UINT16 washMachineId);
 
 /*
 * 功能描述： 降级模式洗车线关联进路状态检查
@@ -1024,45 +990,217 @@ UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
 UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
 
 /*
-* 功能描述： 更新接触网状态
+* 功能描述： 设置所有道岔转辙机位置
-* 参数说明： void
+* 参数说明： UINT16 switchCurSum 道岔总数
 * 返回值  ： 无
 */
-void OhlRelayToDeviceStateProc(void);
+void SetAllSingleSwitchZzjState(UINT16 switchCurSum);
 
 /*
-* 功能描述：迪士尼屏蔽门旁路按钮按下状态处理
+* 功能描述： 指定洗车机ID降级模式洗车按钮状态更新
-* 参数说明：const UINT16 wPsbId  ID
+* 参数说明： const UINT16 washMachineId 洗车机ID
-*           const UINT16 wMutualLockRelayId 旁路按钮采集继电器ID
+* 返回值  ： void
+*/
+void WashMachineButtonStateProc(const UINT16 washMachineId);
+
+/*
+* 功能描述： 指定洗车机ID降级模式请求信息处理
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachineApplyStateProc(const UINT16 washMachineId);
+
+/*
+* 功能描述： 指定洗车机ID降级模式洗车请求信息处理
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachineApplyProc(const UINT16 washMachineId);
+
+/*
+* 功能描述： 指定洗车机ID降级模式反向通过请求信息处理
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachinePassApplyProc(const UINT16 washMachineId);
+
+/*
+* 功能描述： 洗车线控制室更新洗车同意按钮逻辑
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachineButtonUpdate(const UINT16 washMachineId);
+
+/*
+* 功能描述： DCC更新洗车同意按钮逻辑
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachineDCCButtonUpdate(const UINT16 washMachineId);
+
+/*
+* 功能描述： 融合洗车同意状态
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void FusionWashMachineAllowState(const UINT16 washMachineId);
+
+/*
+* 功能描述： 洗车线控制室更新反向洗车同意按钮逻辑
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachinePassButtonUpdate(const UINT16 washMachineId);
+
+/*
+* 功能描述： DCC更新反向洗车同意按钮逻辑
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void WashMachineDCCPassButtonUpdate(const UINT16 washMachineId);
+
+/*
+* 功能描述： 融合反向通过同意按钮状态
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ： void
+*/
+void FusionWashMachinePassAllowState(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式洗车线洗车请求指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachineApplyLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式DCC洗车请求指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachineDccApplyLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式洗车线洗车反向通过请求指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachinePassApplyLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式DCC洗车反向通过请求指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachineDccPassApplyLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式洗车同意指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachineAllowLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式DCC洗车同意指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachineDccAllowLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 降级模式洗车同意反向通过指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachinePassAllowLight(const UINT16 washMachineId);
+
+
+/*
+* 功能描述： 降级模式DCC洗车同意反向通过指示灯
+* 参数说明： const UINT16 washMachineId 洗车机ID
+* 返回值  ：void
+*/
+void WashMachineDccPassAllowLight(const UINT16 washMachineId);
+
+/*
+* 功能描述： 更新屏蔽门对应IBP盘发车按钮继电器状态
+* 参数说明： const UINT16 wPsdId 屏蔽门ID
+* 返回值  ： CI_ERROR: 更新失败
+*			 CI_SUCCESS: 更新成功
+*/
+UINT8 PsdIbpRelToDevStaProc(const UINT16 wPsdId);
+
+/*
+* 功能描述：同站紧急按钮及旁路按钮状态处理
+* 参数说明：void
+* 返 回 值：无
+* Created By LQ 2025.12.30
+*/
+void OnePlatEsbAndCutBtnProc(void);
+
+/*
+* 功能描述：取消当前未异常打开的站台门的异常状态
+* 参数说明： const UINT16 doorId，屏蔽门ID
 * 返回值  ：无
-* Created By fan 2025.12.17
+*Create fan 2026.03.26
 */
-void PsdDsnPsdCutBtnPressStateProc(const UINT16 wPsdId, const UINT16 wMutualLockRelayId);
+void CancelPsdExceptState(UINT16 doorId);
-
 /*
-* 功能描述： 处理迪士尼屏蔽门互锁解除继电器状态
+* 功能描述： 设置道岔的每一个OC的主控状态
-* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 参数说明：
-* Created By fan 2025.12.15
+		UINT16 switchId：道岔id
+* 返回值  ：void
+* add by mpt 20260326
+*/
+void SetOcSwitchControlState(UINT16 switchId);
+/*
+* 功能描述： 仲裁当前道岔的主控OC
+* 参数说明： UINT16 switchCurSum 道岔总数
 * 返回值  ： 无
+* add by mpt 20260326
 */
-void DsnPsdMutualLockStateUpdate(const UINT16 doorId);
+void SetAllSwitchCurMainControlOC(UINT16 switchCurSum);
-
 /*
-* 功能描述： 根据PSD状态更新区段的站台门异常打开封锁状态
+* 功能描述： OC道岔主控命令生成处理
-* 参数说明： 无
+* 参数说明： UINT16 switchId 道岔ID
-* 返回值  ： 无
+* 返回值  ： void
-* by fan 20260127
 */
-void PsdRelayToSecFlockStatus(void);
+void OutSwitchControlModeCmd(UINT16 switchId);
-
 /*
-* 功能描述： 更新全线紧急停车逻辑状态
+* 功能描述： 道岔无主控时产生主备控命令处理
+* 参数说明： UINT16 switchId
+* 返回值  ： void
+*/
+void SwitchMainControlCmdOut(UINT16 switchId, UINT8 ocId);
+/*
+* 功能描述： OC道岔主控状态管理
 * 参数说明： void
-* 返回值  ： 0u: 更新失败
+* 返回值  ： void
-*			 1: 更新成功
-* Created By fan 2026.03.10
 */
-void CesbStateUpdateProc(void);
+void OcSwitchControlModeCmdOutput(void);
+/*
+* 功能描述： 双主防护模块
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+*/
+void SwitchDoubleMainProtect(UINT16 switchId);
+/*
+* 功能描述：道岔寻表模块
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+* add by mpt 20260328
+*/
+void FindSwitchPostionCmdOut(UINT16 switchId);
+
+/*
+* 功能描述： 更新倒切柜状态
+* 参数说明： void
+* 返回值  ： 无
+* Create Fan 20260608
+*/
+void ReverseStateUpdateProc(void);
+
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/IO/InputDataProcess.h

@@ -128,14 +128,6 @@ void ProcessPscToCiData(void);
 */
 UINT8 ProcessAtsOrXianDiToCiData(void);
 
-/*
-* 功能描述： 处理车辆段的ATS或现地到CI数据
-* 参数说明： void
-* 返回值  ： 0:处理失败
-*			 1:处理成功         
-*/
-UINT8 ProcessAtsOrXianDiToCiDataCld(void);
-
 /*
 * 功能描述： 处理设备逻辑状态
 * 参数说明： void
@@ -304,7 +296,7 @@ UINT8 CheckOrderWhetherDoing(UINT8 virCIid,UINT8 belongVirCIid,UINT8 orderType,U
 *           UINT8 MaskType   码位类型
 * 返回值  ： 无
 */
-void DealAutoReturnMask_UseVirCI(UINT16 DeviceId,UINT16*maskBuf,UINT8 MaskType,UINT16 index);
+void DealAutoReturnMask(UINT16 DeviceId,UINT8* pMaskBuf,UINT8 MaskType,UINT16 index);
 /*
 * 功能描述： 获取全站维修点灯状态
 * 参数说明：  UINT8 virCIid   虚拟联锁ID
@@ -467,20 +459,91 @@ void ProcessOCToCiPsdData(void);
 void ProcessOcToCiRelayDiffData(void);
 
 /*
-* 功能描述：迪士尼试车线试车状态处理
+* 功能描述：处理CI与RC间通信状态和数据
-* 参数说明：无
+* 参数说明：void
 * 返 回 值：无
-* Created By LQ 2026.01.23
+* Created By LQ 2025.11.04
 */
-void DsnScxStateProc(void);
+void ProcessCiAndRcInfo(void);
+
+/**
+* @brief 保护区段解锁申请
+* @param[in] 无
+* @return 无
+* @note by cgh 20251107
+*/
+void OverlapUnlockApplyDeal(void);
+
+
+/**
+* @brief 进路停车保证处理
+* @param[in] 无
+* @return 无
+* @note by cgh 20251107
+*/
+void RouteStopensureDeal(void);
+
+/**
+* @brief 更新双系统融合数据
+* @param[in] void
+* @return 无
+* @note by cgh 20251106
+*/
+void UpdateDoubleSystemMergeInfo(void);
 
 /*
-* 功能描述：迪士尼试车线物理区段采集占用状态处理
+* 功能描述：逻辑区段信息融合处理
 * 参数说明：无
 * 返 回 值：无
-* Created By LQ 2026.01.23
+* Created By LQ 2025.11.07
 */
-void DsnScxPhySecColOccProc(void);
+void LogSecInfoMergePro(void);
+
+/*
+* 功能描述：雨雪信息融合处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.11.10
+*/
+void SnowInfoMergePro(void);
+
+/**
+* @brief 进路停车保证信息融合
+* @param[in] void
+* @return 无
+* @note by cgh 20251106
+*/
+void RouteStopensureFlagMergeDeal(void);
+
+/**
+* @brief 信号机信息融合处理
+* @param[in] void
+* @return 无
+* @note by cgh 20251106
+*/
+void SignalInfoMergeDeal(void);
+
+/*
+* 功能描述：信号机列车跨压处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.11.11
+*/
+void SignalTrainCrossPro(void);
+
+/*
+* 功能描述： 处理VOBC到CI数据
+* 参数说明： void
+* 返回值  ： void
+*/
+void ProcessIvocToRCData(void);
+/*
+* 功能描述： Vobc点连式信息清除
+* 参数说明： UINT16 wTrainId：VOBCid
+* 返回值  ： void
+* by lyj 20260316
+*/
+void VobcBlocLinkDataClear(const UINT16 wTrainId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/IO/OutputDataProcess.h

@@ -92,6 +92,7 @@ UINT8 CiToAtsBackInfoFunctionJudge(const UINT8 functionId,const UINT8 deviceType
 */
 void IndicatorStateProc(void);
 
+#if 0
 /*
 * 功能描述： 指示器状态处理
 * 参数说明： void
@@ -99,6 +100,7 @@ void IndicatorStateProc(void);
 */
 void IndicatorStateProc_UseVirCI(UINT8 virCIid);
 
+#endif
 /*
 * 功能描述： 非进路继电器状态处理
 * 参数说明： void
@@ -147,12 +149,7 @@ void SignaDsBreakAlarmIndicator_Vir(UINT8 virCIid,UINT8 devId);
 */
 void CiToCiOutputCmdProc(void);
 
-/*
+
-* 功能描述： 根据无人折返指示灯的闪灯和稳灯状态驱动继电器或设置状态
-* 参数说明： 无
-* 返回值  ： 无
-*/
-static void AutoRtnIndictStatusProc_VirCI(void);
 /*
 * 功能描述： 获取组合自动进路所属虚拟联锁ID
 * 参数说明： groupAutoRouteId 组合自动进路的ID    
@@ -457,12 +454,99 @@ UINT8 FindRouteLeaveAxis(const UINT16 routeId);
 void RtnRealyAdhesionStatePro(void);
 
 /*
-* 功能描述：ECS监督处理
+* 功能描述： 获取人工解锁保护区段剩余倒计时
-* 参数说明：无
+* 参数说明： const UINT16 overlapId  保护区段id
-* 返 回 值：无
+* 返回值  ： 倒计时
-* Created By LQ 2026.01.26
+* by cgh 20250928
 */
-void EcsMonitorProc(void);
+UINT16 GetOverlapLaborUnlockBackTime(const UINT16 overlapId);
+/*
+* 功能描述： 设置联锁I系II系工作状态指示灯
+* 参数说明： const UINT16 wFIndicatorId  I系指示灯id
+*			 const UINT16 wSIndicatorId  II系指示灯id
+* 返回值  ： 无
+* by lyj 20260105
+*/
+void SetWorkStatusIndicator(const UINT16 wFIndicatorId, const UINT16 wSIndicatorId);
+/*
+* 功能描述： 设置信号故障关闭指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260105
+*/
+void SetSigFaultCloseIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置道岔挤岔指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260105
+*/
+void SetSwitchJiChaIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置车库门故障指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260105
+*/
+void SetGDoorFaultIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置继电器混线指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260105
+*/
+void SetRealyHunXianIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置应急盘指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260106
+*/
+void SetYjpIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置试车请求指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260106
+*/
+void SetSCApplyIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置试车同意指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260106
+*/
+void SetSCAllowIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 设置试车结束指示灯
+* 参数说明： const UINT16 wIndicatorId  指示灯id
+* 返回值  ： 无
+* by lyj 20260106
+*/
+void SetSCOverIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 处理点连式列车发送数据信息
+* 参数说明： void
+* 返回值  ： 无
+* by lyj 20260314
+*/
+void VobcBlocLinkOutputProcess(void);
+/*
+* 功能描述： 处理点连式列车进路信息
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 计算结果
+* by lyj 20260316
+*/
+
+UINT8 BlocLinkTrainRouteMange(const UINT16 wTrainId);
+/*
+* 功能描述： 处理点连式列车逻辑区段信息
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 计算结果
+* by lyj 20260316
+*/
+
+UINT8 BlocLinkTrainLogSecMange(const UINT16 wTrainId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/Indicator/IndicatorConfigDataManage.c

@@ -423,7 +423,7 @@ UINT8 GetIndicatorDevId(UINT16 indicatorId)
 *			>0u: 报警灯设备ID
 * by cgh 20240910
 */
-UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId)
+UINT16 GetIndicatorRelNonReturnId(UINT16 indicatorId)
 {
 
 	UINT16 wRetVal = CI_ERROR;
@@ -459,42 +459,27 @@ UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId)
 }
 
 /*
-* 功能描述：通过表示灯类型获取表示灯ID
+* 功能描述： 根据指示灯ID获取指示灯虚拟联锁ID
-* 参数说明：UINT8 cDevType 表示灯类型
+* 参数说明：  UINT16 wIndicId  指示灯ID
-* 返 回 值：0 获取数据失败
+* 返回值  ： 0u: 获取数据失败
-*           其它 表示灯ID
+*			>0u: 虚拟联锁ID
-* Created By LQ 2026.01.23
+* BY:lyj 20260105
 */
-UINT16 GetIndicatorIdByDevType(UINT8 cDevType)
+UINT8 GetIndicBelongRtuId(UINT16 wIndicId)
 {
-	UINT16 wRetVal = 0U;
+	UINT16 bufIndex = 0U;  /*数组下标*/
-	UINT16 wDevCurSum = 0U;  /*表示灯总数*/
+	UINT8 reVal = CI_ERROR;
-	UINT16 ii = 0U;
-	UINT16 wDevId = 0U;  /*表示灯ID*/
-	UINT8 cIndicatorType = 0U;  /*表示灯类型*/
 
-	if (0U != cDevType)
+	bufIndex = GetIndicatorConfigBufIndex(wIndicId);  /*获取指示器相关继电器数组下标*/
+
+	if (INDICATOR_SUM_MAX > bufIndex)
 	{
-		wDevCurSum = GetIndicatorCurSum(); /*获取指示器当前总数*/
+		reVal = IndicatorConfigDataStru[bufIndex].chBelongVirCIid;
-		for (ii = 0U; ii < wDevCurSum; ii++)
-		{
-			wDevId = GetIndicatorId(ii);  /*获取表示灯ID*/
-			cIndicatorType = GetIndicatorType(wDevId);  /*获取表示灯类型*/
-			if (cDevType == cIndicatorType)
-			{
-				wRetVal = wDevId;
-				break;  /*找到目标类型，停止遍历*/
-			}
-			else
-			{
-				/*继续遍历查找*/
-			}
-		}
 	}
 	else
 	{
-		/*入参非法，返回0*/
+		/*不处理*/
 	}
 
-	return wRetVal;
+	return reVal;
 }

TSCP/src/APP/ciapp/Indicator/IndicatorConfigDataManage.h

@@ -29,7 +29,8 @@ typedef struct S_IndicatorConfigDataStruct
     UINT8 AvalibleFlag;/*指示灯有效标志位 0x55无效 0xAA进路相关 0xAA继电器相关*/
 	UINT8  IdSum; /*相关Id数量(配置字段)*/				
 	UINT16 IdBuf[INDICATOR_RELAY_SUM_MAX]; /*相关ID (配置字段)*/
-	UINT8 BjdDeviceId; /*报警灯设备ID*/
+	UINT8 BjdDeviceId;     /*报警灯设备ID*/
+	UINT8 chBelongVirCIid; /*所属虚拟联锁ID*/
 } IndicatorConfigDataStruct;
 
 /*cgh-合并ECI11.0:OC站表示灯 OC站指一级集中站（CI+OC）的现地工作站、二级集中站（OC）的有岔非集现地工作站，中央联锁工作站*/
@@ -183,16 +184,15 @@ UINT8 GetIndicatorDevId(UINT16 indicatorId);
 *			>0u: 报警灯设备ID
 * by cgh 20240910
 */
-UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId);
+UINT16 GetIndicatorRelNonReturnId(UINT16 indicatorId);
-
 /*
-* 功能描述：通过表示灯类型获取表示灯ID
+* 功能描述： 根据指示灯ID获取指示灯虚拟联锁ID
-* 参数说明：UINT8 cDevType 表示灯类型
+* 参数说明：  UINT16 wIndicId  指示灯ID
-* 返 回 值：0 获取数据失败
+* 返回值  ： 0u: 获取数据失败
-*           其它 表示灯ID
+*			>0u: 虚拟联锁ID
-* Created By LQ 2026.01.23
+* BY:lyj 20260105
 */
-UINT16 GetIndicatorIdByDevType(UINT8 cDevType);
+UINT8 GetIndicBelongRtuId(UINT16 wIndicId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h

@@ -64,7 +64,10 @@
 #define INDICATOR_TYPE_SWITCH_JICHA					((UINT8)0x24)  /* 道岔挤岔状态 */
 #define INDICATOR_TYPE_GD_DAD						((UINT8)0x25)  /* 车库门故障报警状态 */
 #define INDICATOR_TYPE_XICHEJI_ALLOW_STATE			((UINT8)0x26)  /* 非FAO线路同意洗车状态指示灯 */
-#define INDICATOR_TYPE_DOWNWASH_ALLOW_PASS_STATE	((UINT8)0x29)  /* 슉섬친駕求났谿雷繫법寧刻됐 */
+#define INDICATOR_TYPE_DOWNWASH_ALLOW_PASS	        ((UINT8)0x29)  /* 降级模式洗车同意通过指示灯 */
+#define INDICATOR_TYPE_DOWNWASH_APPLY		        ((UINT8)0x63)  /* 降级模式洗车请求指示灯 */
+#define INDICATOR_TYPE_DOWNWASH_PASS_APPLY	        ((UINT8)0x64)  /* 降级模式反向通过请求指示灯 */
+#define INDICATOR_TYPE_XDC_DCGDJ	                ((UINT8)0x65)  /* 蓄电池供电报警指示灯 */
 
 #define	INDICATOR_TYPE_ATS_CONFIRM_RELAY_INTERFACE	((UINT8)0x27)	/*相邻联锁继电接口确认状态指示灯*/
 
@@ -132,9 +135,6 @@
 #define INDICATOR_TYPE_RELAY_HUNXIAN                   ((UINT8)0x92) /*继电器混线表示灯*/
 #define INDICATOR_TYPE_AUTORTN_ADHESION   	  		((UINT8)0x62)  /*无人折返按钮粘连状态指示灯*/
 #define INDICATOR_TYPE_COMM_AXIS                  ((UINT8)0x96) /*与计轴通信状态：1-所有计轴通信正常；3-存在计轴通信异常*/
-#define INDICATOR_TYPE_ALLSEC_FLOCK   	  		((UINT8)0x65)  /*홍窟혐뙈룐傑寧刻됐*/
-#define INDICATOR_TYPE_CESB   	  		((UINT8)0x98)  /*CESB寧刻됐*/
-#define INDICATOR_TYPE_SCX_SHD_ESS   	  		((UINT8)0x97U)  /*둑却콩桿났窟SHD-ESS榴檄깊刻됐*/
 
 
 /*指示灯显示状态*/
@@ -184,12 +184,6 @@
 #define INDICATOR_SHOW_SC_NO  		  		        ((UINT8)0x55)  /*试车指示灯显示无效*/
 #define INDICATOR_SHOW_SC_YES  		  		        ((UINT8)0xaa)  /*试车指示灯显示有效*/
 
-#define INDICATOR_CESB_INACTIVE_NOFLOCK				((UINT8)0x01)		/* CESB灌샴삶灌룐傑*/
-#define INDICATOR_CESB_INACTIVE_FLOCK				((UINT8)0x02)		/* CESB灌샴삶할룐傑*/
-#define INDICATOR_CESB_ACTIVE_FLOCK				((UINT8)0x03)		/* CESB샴삶할룐傑*/
-#define INDICATOR_CESB_CUT_FLOCK				((UINT8)0x04)		/* CESB텃쨌할룐傑*/
-#define INDICATOR_CESB_CUT_NOFLOCK				((UINT8)0x05)		/* CESB텃쨌할灌룐傑*/
-
 #define INDIC_POWER_I_1       ((UINT8)0x01)   /*一路电源1*/
 #define INDIC_POWER_I_2       ((UINT8)0x02)    /*一路电源2*/
 #define INDIC_POWER_II_1       ((UINT8)0x03)   /*二路电源1*/

TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c

@@ -129,8 +129,8 @@ UINT8 InitAllStaticDataStr(void)
 	/*声光报警器配置数据结构体*/
 	chRtn &= CommonMemSet(SGBJConfigDataStru, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)), 0u, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)));
 
-	/*ECS配置数据结构体*/
+	/*试灯数据配置结构体*/
-	chRtn &= CommonMemSet(ECSConfigDataStru, (UINT32)(ECS_MAX_NUM * sizeof(ECSConfigDataStruct)), (UINT8)0U, (UINT32)(ECS_MAX_NUM * sizeof(ECSConfigDataStruct)));
+	chRtn &= CommonMemSet(LightTestButtonConfigDataStru, (UINT32)(LIGHTTESTBUTTON_BUTTON_MAX_NUM * sizeof(LightTestButtonConfigDataStruct)), 0u, (UINT32)(LIGHTTESTBUTTON_BUTTON_MAX_NUM * sizeof(LightTestButtonConfigDataStruct)));
 
 	return chRtn;
 }
@@ -249,6 +249,7 @@ UINT8 ReadConfigureData(void)
 			{
 				; /*不处理*/
 			}
+			
 			if (0u == rtnVal)
 			{
 				PhysicalSectionCurSum = ReadPhySicalSectionConfigData(LocalCiId, PhysicalSectionConfigDataStru);/*读物理区段配置数据*/
@@ -449,6 +450,13 @@ UINT8 ReadConfigureData(void)
 
 			if (0u == rtnVal)
 			{
+				IndicatorCurSum = ReadIndicatorConfigData(LocalCiId, IndicatorConfigDataStru);                  /*读指示灯报警灯配置数据*/
+				if (-1 == IndicatorCurSum)
+				{
+					rtnVal = 20u;/*读取指示灯报警灯配置数据失败*/
+					debug_infor_printf((const)"ReadIndicatorConfigData fail.");
+				}
+#if 0
 				includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 				if (FUNC_SWITCH_ON == includeVirFlag)
 				{
@@ -471,15 +479,7 @@ UINT8 ReadConfigureData(void)
 
 					}
 				}
-				else
+#endif	
-				{
-					IndicatorCurSum = ReadIndicatorConfigData(LocalCiId, IndicatorConfigDataStru);                  /*读指示灯报警灯配置数据*/
-					if (-1 == IndicatorCurSum)
-					{
-						rtnVal = 20u;/*读取指示灯报警灯配置数据失败*/
-						debug_infor_printf((const)"ReadIndicatorConfigData fail.");
-					}
-				}
 			}
 			else
 			{
@@ -531,7 +531,7 @@ UINT8 ReadConfigureData(void)
 				g_ret = ReadReverseCutConfigData(LocalCiId, gstReverseCutCfgData);
 				if (-1 == g_ret)
 				{
-					rtnVal = 28u;/*读保护区段配置数据失败*/
+					rtnVal = 28u;/*读倒切配置数据失败-OC配置数据表单30*/
 					debug_infor_printf((const)"ReadReverseCutConfigData fail.");
 				}
 				else if (0 < g_ret)
@@ -555,7 +555,23 @@ UINT8 ReadConfigureData(void)
 			{
 				; /*不处理*/
 			}
-
+			if (0u == rtnVal)
+			{
+				LightTestButtonCurSum = ReadLightTestConfigData(LocalCiId, LightTestButtonConfigDataStru);             /*读OC试灯按钮配置数据*/
+				if (-1 == LightTestButtonCurSum)
+				{
+					rtnVal = 44u;/*读取OC试灯按钮数据失败*/
+					debug_infor_printf((const)"\nReadLightTestConfigData fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+			else
+			{
+				; /*不处理*/
+			}
 			if (0u == rtnVal)
 			{
 				CiToAtsMaskCurSum = ReadCiToAtsMaskConfigData(LocalCiId, CiToAtsMaskConfigDataStru);            /*读CI-ATS配置数据*/
@@ -670,6 +686,7 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 
+
 			if (0u == rtnVal)
 			{
 				InvSecSum = ReadInvaSectionConfigData(LocalCiId, InvSecConfigDataStru);							/*读侵入区段配置数据*/
@@ -774,44 +791,6 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 
-			/*读SSKS闪灯稳灯继电器配置数据*/
-			if (0U == rtnVal)
-			{
-				gSsksLightRelaySum = ReadSsksLightRelayCfgData(LocalCiId, gSsksLightRelayCfgStr);
-				if (-1 == gSsksLightRelaySum)
-				{
-					rtnVal = 40U;  /*读取SSKS闪灯稳灯继电器配置数据失败*/
-					debug_infor_printf((const)"\nReadSsksLightRelayCfgData fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
-			else
-			{
-				; /*不处理*/
-			}
-
-			/*读联络线旁路继电器配置数据*/
-			if (0U == rtnVal)
-			{
-				gConnectOverrideRelaySum = ReadConnectOverrideCfgData(LocalCiId, gConnectOverrideRelayCfgStr);
-				if (-1 == gConnectOverrideRelaySum)
-				{
-					rtnVal = 46U;  /*读取联络线旁路继电器配置数据失败*/
-					debug_infor_printf((const)"\nReadConnectOverrideCfgData fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
-			else
-			{
-				; /*不处理*/
-			}
-
 			/*读声光报警器配置数据*/
 			if (0u == rtnVal)
 			{
@@ -831,17 +810,18 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 
+
 			if (0u == rtnVal)
 			{
-				OhlCurSum = ReadOhlConfigData(LocalCiId, OhlConfigDataStru);
+				g_ret = ReadReverseSwitchConfigData(LocalCiId, &gLocalReverseData);
-				if (-1 == OhlCurSum)
+				if (-1 == g_ret)
 				{
-					rtnVal = 39U;/*读取接触网数据失败*/
+					rtnVal = 39u;/*读板卡配置数据失败-OC配置数据表单40、41*/
-					debug_infor_printf((const)"ReadOhlConfigData fail.");
+					debug_infor_printf((const)"ReadReverseSwitchConfigData fail.");
 				}
 				else
 				{
-					; /*不处理*/
+					/*无操作*/
 				}
 			}
 			else
@@ -849,38 +829,6 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 
-			if (0U == rtnVal)
-			{
-				ECSCurSum = ReadEcsConfigData(LocalCiId, ECSConfigDataStru);
-				if (-1 == ECSCurSum)
-				{
-					rtnVal = 43U;/*读取ECS数据失败*/
-					debug_infor_printf((const)"\nReadEcsConfigData fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
-			else
-			{
-				; /*不处理*/
-			}
-
-			if (0U == rtnVal)
-			{
-				RtnTemp = ReadLocalCesbConfigData(LocalCiId, &LocalCesbConfigDataStru);
-				if (0U == RtnTemp)
-				{
-					rtnVal = 45U;/*读取CESB数据失败*/
-					debug_infor_printf((const)"\nReadCesbConfigData fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
-
 			if (0u == rtnVal)
 			{
 				/*读系统参数配置数据*/
@@ -1069,13 +1017,7 @@ UINT8 ReadConfigureData(void)
 					if (CI_SUCCESS == retValue)
 					{
 						/*读取联络线数据*/
-						g_ret = OcConnectConfigDataToDevStruct(SignalConfigDataStru, 
+						g_ret = OcConnectConfigDataToDevStruct(SignalConfigDataStru, PhysicalSectionConfigDataStru, SwitchConfigDataStru, OcConnetDataCfgStru, RelayConfigDataStru);
-							PhysicalSectionConfigDataStru, 
-							SwitchConfigDataStru, 
-							OcConnetDataCfgStru, 
-							RelayConfigDataStru, 
-							RouteConfigDataStru,
-							LogicSectionConfigDataStru);
 						if (-1 == g_ret)
 						{
 							rtnVal = 35u;
@@ -1167,68 +1109,6 @@ UINT8 ReadConfigureData(void)
 			{
 				; /*不处理*/
 			}
-			
-			if (0U == rtnVal)
-			{
-				/*ECS关联物理区段初始化*/
-				RtnTemp = EcsIncPhySecInfoInit(ECSConfigDataStru);  /*需要在Link后面初始化*/
-				if (0U == RtnTemp)
-				{
-					rtnVal = 44U;  /*ECS关联物理区段初始化失败*/
-					debug_infor_printf((const)"\nEcsIncPhySecInfoInit fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
-			else
-			{
-				; /*不处理*/
-			}
-
-			if (0u == rtnVal)
-			{
-				/*迪士尼联络线逻辑区段继电器条件读取*/
-				retValue = OcConnectLogSecCondInit();
-				if (1u == retValue)
-				{
-					ConnectLogSecCondRelayInit(ConnectLogSecCondCfgStru, LogicSectionConfigDataStru);
-				}
-				else
-				{
-					rtnVal = 47u;
-					debug_infor_printf((const)"OcConnectLogSecCondInit errcode =%d, OcConnectLogSecCondInit", rtnVal);
-				}
-			}
-			if (0u == rtnVal)
-			{
-				/*迪士尼共用道岔的逻辑区段整理*/
-				retValue = InitLogSecSwitchShareStatusByPhysec();
-				if (0U == retValue)
-				{
-					rtnVal = 48U;  
-					debug_infor_printf((const)"\InitLogSecSwitchShareStatusByPhysec fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
-
-			if (0u == rtnVal)
-			{
-				retValue = InitSpeedLimitSecConfigData();
-				if (0U == retValue)
-				{
-					rtnVal = 49U;
-					debug_infor_printf((const)"\InitSpeedLimitSecConfigData fail.\n");
-				}
-				else
-				{
-					; /*不处理*/
-				}
-			}
 		}
 		else
 		{
@@ -1241,6 +1121,32 @@ UINT8 ReadConfigureData(void)
 		rtnVal = 2u;
 		}
 
+		if (0u == rtnVal)
+		{
+			g_ret = QueryTrackBelongLink();
+			if (CI_ERROR == g_ret)
+			{
+				debug_infor_printf((const)"QueryTrackBelongLink Error\n");
+				rtnVal = 43u;
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+
+		if (0u == rtnVal)
+		{
+			/*设置试车线与车辆段合设配置*/
+			g_ret = (INT16)SetCldAndScxMergeConfig();
+			if (0 == g_ret)
+			{
+				debug_infor_printf((const)"SetCldAndScxMergeConfig fail.\r\n");
+				rtnVal = 44u;
+			}
+		}
+
+
 
 	}
 
@@ -1257,7 +1163,6 @@ UINT8 ReadConfigureData(void)
 UINT8 DeviceDataManage(void)
 {
 	UINT8 rtValue = 0u;
-	UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 reval = CI_ERROR;
     /*整理继电器数据*/
     if (CI_ERROR == RelayConfigDataManage())
@@ -1381,6 +1286,7 @@ UINT8 DeviceDataManage(void)
 	{
 		rtValue = 0u;
 	}
+#if 0
 	if(FUNC_SWITCH_ON == includeVirFlag)
 	{
 		reval = InitVirCIlocalCiIndicatorIdBuf();
@@ -1389,15 +1295,17 @@ UINT8 DeviceDataManage(void)
 			rtValue = 1u;
 		}
 	}
-	else
+#endif
+	if (0U == rtValue)
 	{
 		reval = IndicatorConfigDataManage();
-		if(CI_ERROR == reval)
+		if (CI_ERROR == reval)
 		{
 			rtValue = 1u;
 		}
 	}
 	
+
 	if (0U == rtValue)
 	{
 		reval = CutoffPointConfigDataManage();
@@ -1425,33 +1333,6 @@ UINT8 DeviceDataManage(void)
 		}
 	}
 
-	if (0U == rtValue)
-	{
-		reval = OhlConfigDataManage();
-		if (CI_ERROR == reval)
-		{
-			rtValue = 1u;
-		}
-	}
-
-	if (0U == rtValue)
-	{
-		/*读取本地ECS ID*/
-		reval = EcsConfigDataManage();
-		if (CI_ERROR == reval)
-		{
-			rtValue = 1U;
-		}
-		else
-		{
-			/*返回成功*/
-		}
-	}
-	else
-	{
-		/*返回失败*/
-	}
-
     return rtValue;
 }
 /*
@@ -2107,26 +1988,18 @@ UINT8 CheckCiHaveZcSumErr(const UINT8 ciId)
 *            OcConnetDataCfgStruct* pConnectCfgData 联络线数据结构体
 *			 RelayConfigDataStruct* pRelayCfgData	继电器结构体
 * 返回值  ： 0，成功；-1，失败
-* NOTE：
+* NOTE：集成bug YF0083-224		      
 */
-INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, 
+INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, PhysicalSectionConfigDataStruct* pPhyCfgData, SwitchConfigDataStruct* pSwitchCfgData, OcConnetDataCfgStruct* pConnectCfgData, RelayConfigDataStruct* pRelayCfgData)
-	PhysicalSectionConfigDataStruct* pPhyCfgData, 
-	SwitchConfigDataStruct* pSwitchCfgData, 
-	OcConnetDataCfgStruct* pConnectCfgData, 
-	RelayConfigDataStruct* pRelayCfgData, 
-	RouteConfigDataStruct *pRouteCfgData,
-	LogicSectionConfigDataStruct *pLogSecCfgData)
 {
 	/*变量初始化*/
 	UINT16 i = 0u;
 	UINT16 j = 0u;
 	UINT16 k = 0u;
 	UINT16 m = 0U;
-	UINT16 n = 0U;
 	INT8 retValue = -1;
 
-	if ((NULL != pSignalCfgData) && (NULL != pPhyCfgData) && (NULL != pSwitchCfgData) 
+	if ((NULL != pSignalCfgData) && (NULL != pPhyCfgData) && (NULL != pSwitchCfgData) && ((NULL != pConnectCfgData)))
-		&& (NULL != pConnectCfgData) && (NULL != pRelayCfgData) && (NULL != pRouteCfgData) && (NULL != pLogSecCfgData))
 	{
 		retValue = 0;
 		for (i = 0u; i < OcConnetDataDevNum; i++)
@@ -2157,6 +2030,23 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData,
 								pSignalCfgData[j].DxRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 								pSignalCfgData[j].DxDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
 							}
+							else if (SIGNAL_DJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSignalCfgData[j].FirDsRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
+								pSignalCfgData[j].wFirstDsDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+							}
+							else if (SIGNAL_MAINJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSignalCfgData[j].wMainDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+							}
+							else if (SIGNAL_ACKJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSignalCfgData[j].wAckDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+							}
+							else if (SINNAL_CMAINJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSignalCfgData[j].wCMainDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+							}
 							else
 							{
 								; /*不处理*/
@@ -2228,67 +2118,15 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData,
 								pSwitchCfgData[j].DsHRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 								pSwitchCfgData[j].DsDrvHRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
 							}
-							/*BYPASS*/
+							/*PYPASS*/
 							else if (SWITCH_BYPASSJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
 							{
 								pSwitchCfgData[j].ByPassRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 							}
-							/*反位使能请求RWM*/
+							/*IBP*/
-							else if (SWITCH_RWM_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							else if(SWITCH_IBP_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
 							{
-								pSwitchCfgData[j].RwmRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+								pSwitchCfgData[j].IbpDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
-								
-								/*给迪士尼联络线进路添加关键道岔，遍历所有进路*/
-								for (m = 0u; m < ROUTE_SUM_MAX; m++)
-								{
-									/*判断迪士尼联络线进路类型*/
-									if ((ROUTE_DISNEY_CONNECT_ENDMINE == pRouteCfgData[m].cDisneyConnectRouteAttr)
-										|| (ROUTE_DISNEY_CONNECT_STARTMINE == pRouteCfgData[m].cDisneyConnectRouteAttr))
-									{
-										/*后半段属于本线，或者前半段属于本线，遍历所有道岔*/
-										for (n = 0u; n < (UINT16)pRouteCfgData[m].RouteSwitchSum; n++)
-										{
-											/*判断道岔ID是否为当前RWM继电器对应道岔ID*/
-											if (pRouteCfgData[m].RouteSwitchStru[n].SwitchId == pSwitchCfgData[j].SwitchId)
-											{
-												/*道岔ID一致，赋值联络线关键道岔ID*/
-												pRouteCfgData[m].wRelConnectSwitchId = pSwitchCfgData[j].SwitchId;
-												break;
-											}
-											else
-											{
-												/*继续遍历*/
-											}
-										}
-									}
-									else
-									{
-										/*类型不满足，无需添加关键道岔，继续遍历*/
-									}
-								}
-
-								for (m = 0u; m < LOGIC_SECTION_SUM_MAX; m++)
-								{
-									for (n = 0u; n < pLogSecCfgData[m].chLogsecSwitchSum; n++)
-									{
-										if ((pLogSecCfgData[m].LogsecSwitchIdStru[n].SwitchId == pSwitchCfgData[j].SwitchId)
-											&& (SWITCH_POSITION_FANWEI == pLogSecCfgData[m].LogsecSwitchIdStru[n].SwitchPosition))
-										{
-											/*逻辑区段反位包含该继电器，记录联络线道岔ID*/
-											pLogSecCfgData[m].wConnectSwticthId = pSwitchCfgData[j].SwitchId;
-											break;
-										}
-										else
-										{
-											/*继续遍历*/
-										}
-									}
-								}
-							}
-							/*反位使能旁路ENABLE BYPASS*/
-							else if (SWITCH_ENABLE_BYPASS_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
-							{
-								pSwitchCfgData[j].EnableBypassRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 							}
 							else
 							{
@@ -2357,6 +2195,7 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData,
 	return(retValue);
 }
 
+
 /*********************************************
 *函数功能：初始化OC 联络线接口继电器配置表数据
 *参数说明：void
@@ -2436,132 +2275,6 @@ UINT8 OcConnectConfigDataStructInit(void)
 	return(rtnValue);
 }
 
-/*********************************************
-*函数功能：初始化联络线逻辑区段继电器条件器配置表数据
-*参数说明：void
-*返回值：1，成功；0，失败
-*********************************************/
-UINT8 OcConnectLogSecCondInit(void)
-{
-	UINT8 funcRtn = 0u;
-	UINT8* pDataAddr = NULL;         /*数据地址*/
-	UINT32 DataSize = 0u;          /*数据大小（字节数）*/
-	UINT16 i = 0u;
-	UINT16 j = 0u;
-	UINT16 realRowCount = 0u; /*实际表数据的行数*/
-	UINT8 rtnValue = 0u;
-
-
-	/*读取数据*/
-	/*读取 默认行车序列  数据*/
-	funcRtn = dquGetConfigDataNew((const)DataPath, OC_DATA_TYPE, CONNECT_LOGSEC_COND_ID, &pDataAddr, &DataSize, &realRowCount);
-	if (0u == funcRtn)
-	{
-		/*函数调用失败*/
-		rtnValue = 1u;
-		debug_infor_printf((const)"\nCONNECT_LOGSEC_COND_ID NO IN FS\n");
-	}
-	else
-	{
-		rtnValue = 1u;
-		/*数据正常*/
-		if ((0u != DataSize) && (0u != realRowCount))
-		{
-			if (0u != (DataSize % realRowCount))
-			{
-				debug_infor_printf((const)"\n OC_DATA_TYPE,CONNECT_LOGSEC_COND_ID len %d %d not equal to fs\n", DataSize, realRowCount);
-				DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, ((UINT32)CI_DATA_TYPE << 8) + CONNECT_LOGSEC_COND_ID, PRINT_ONCE);
-				rtnValue = 0u;
-			}
-			else
-			{
-				/*填写设备数量*/
-				ConnectLogSecCondDevNum = realRowCount;
-				/*内存先设为无效*/
-				(void)CommonMemSet(ConnectLogSecCondCfgStru, sizeof(ConnectLogSecDataCfgStru) *OC_CONNECT_LOGSEC_COND_SUM_MAX,
-					0x00u, sizeof(ConnectLogSecDataCfgStru) *OC_CONNECT_LOGSEC_COND_SUM_MAX);
-
-				for (i = 0u; i < realRowCount; i++)
-				{
-					if (OC_CONNECT_LOGSEC_COND_SUM_MAX > i)
-					{
-						ConnectLogSecCondCfgStru[i].LogSecId = dquCiShortFromChar(pDataAddr);
-						pDataAddr += 2u;
-						ConnectLogSecCondCfgStru[i].RelSecDirLockRelayId = ShortFromChar(pDataAddr);
-						pDataAddr += 2u;
-						ConnectLogSecCondCfgStru[i].RelRoutePrtlRelayId = ShortFromChar(pDataAddr);
-						pDataAddr += 2u;
-					}
-					else
-					{
-						/*无操作*/
-					}
-				}
-			}
-		}
-		else
-		{
-			/*不做处理*/
-		}
-	}
-	return(rtnValue);
-}
-
-/*
-* 功能描述： 将联络线逻辑区段继电器条件数据初始化到对应设备
-* 参数说明： ConnectLogSecDataCfgStru *pConnectLogSecCondCfgStru 联络线逻辑区段继电器条件配置数据结构体
-*            LogicSectionConfigDataStruct *pLogicSectionConfigDataStru 逻辑区段配置数据结构体
-* 返回值  ： 0，成功；-1，失败
-* NOTE：集成bug YF0083-224
-*/
-INT8 ConnectLogSecCondRelayInit(ConnectLogSecDataCfgStru *pConnectLogSecCondCfgStru, 
-	LogicSectionConfigDataStruct *pLogicSectionConfigDataStru)
-{
-	/*变量初始化*/
-	UINT16 i = 0u;			/*循环变量*/
-	UINT16 j = 0u;			/*循环变量*/
-	INT8 retValue = -1;		/*返回值*/
-
-	if ((NULL != pConnectLogSecCondCfgStru) && (NULL != pLogicSectionConfigDataStru))
-	{
-		retValue = 0;
-		for (i = 0u; i < ConnectLogSecCondDevNum; i++)
-		{
-			for (j = 0u; j < LOGIC_SECTION_SUM_MAX; j++)
-			{
-				if (pLogicSectionConfigDataStru[j].LogicSectionId == pConnectLogSecCondCfgStru[i].LogSecId)
-				{
-					pLogicSectionConfigDataStru[j].wRelSecDirLockRelayId = pConnectLogSecCondCfgStru[i].RelSecDirLockRelayId;
-					pLogicSectionConfigDataStru[j].wRelRoutePrtlRelayId = pConnectLogSecCondCfgStru[i].RelRoutePrtlRelayId;
-					break;
-				}
-				else
-				{
-					/*继续遍历*/
-				}
-			}
-
-			if (LOGIC_SECTION_SUM_MAX == j)
-			{
-				/*联络线逻辑区段继电器条件表配置的逻辑区段未在电子地图找到，返回失败*/
-				retValue = -1;
-				break;
-			}
-			else
-			{
-				/*继续遍历*/
-			}
-		}
-	}
-	else
-	{
-		/*返回失败*/
-		retValue = -1;
-	}
-
-	return(retValue);
-}
-
 /*********************************************
 *函数功能：获取静态数据
 *参数说明：UINT32* pConfigDataAdderBuf 静态数据存放地址,UINT16 pConfigDataLenBuf 静态数据长度存放地址,UINT16 wBufMaxLen数组容量

TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.h

@@ -60,6 +60,7 @@
 #include "../Route/LongRouteConfigDataManage.h"
 #include "../SGBJ/SGBJConfigDataManage.h"
 #include "../VirtualDevice/VirtualDevDataManage.h"
+#include "LightTestButtonConfigDataManage.h"
 
 extern INT16 trackCheckRes;
 extern INT16 g_ret;
@@ -142,13 +143,6 @@ UINT8 CheckCiHaveZcSumErr(const UINT8 ciId);
 *********************************************/
 UINT8 OcConnectConfigDataStructInit(void);
 
-/*********************************************
-*函数功能：初始化联络线逻辑区段继电器条件器配置表数据
-*参数说明：void
-*返回值：1，成功；0，失败
-*********************************************/
-UINT8 OcConnectLogSecCondInit(void);
-
 /*
 * 功能描述： 将联络线接口继电器配置表数据初始化到对应设备
 * 参数说明： SignalConfigDataStruct* pSignalCfgData 信号机结构体
@@ -159,23 +153,7 @@ UINT8 OcConnectLogSecCondInit(void);
 * 返回值  ： 0，成功；-1，失败
 * NOTE：集成bug YF0083-224
 */
-INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData,
+INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, PhysicalSectionConfigDataStruct* pPhyCfgData, SwitchConfigDataStruct* pSwitchCfgData, OcConnetDataCfgStruct* pConnectCfgData, RelayConfigDataStruct* pRelayCfgData);
-	PhysicalSectionConfigDataStruct* pPhyCfgData,
-	SwitchConfigDataStruct* pSwitchCfgData,
-	OcConnetDataCfgStruct* pConnectCfgData,
-	RelayConfigDataStruct* pRelayCfgData,
-	RouteConfigDataStruct* pRouteCfgData,
-	LogicSectionConfigDataStruct* pLogSecCfgData);
-
-/*
-* 功能描述： 将联络线逻辑区段继电器条件数据初始化到对应设备
-* 参数说明： ConnectLogSecDataCfgStru *pConnectLogSecCondCfgStru 联络线逻辑区段继电器条件配置数据结构体
-*            LogicSectionConfigDataStruct *pLogicSectionConfigDataStru 逻辑区段配置数据结构体
-* 返回值  ： 0，成功；-1，失败
-* NOTE：
-*/
-INT8 ConnectLogSecCondRelayInit(ConnectLogSecDataCfgStru *pConnectLogSecCondCfgStru,
-	LogicSectionConfigDataStruct *pLogicSectionConfigDataStru);
 
 /*********************************************
 *函数功能：获取静态数据
@@ -193,8 +171,6 @@ UINT16 GetTiocDeviceConfigData(UINT32* pConfigDataAddrBuf, UINT16* pConfigDataLe
 * by cgh 20250605
 *********************************************/
 UINT8 ReadCiTransmitSpecifyDevData(const UINT8 chCiId, const UINT8 chSystemType, UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX]);
-
-
 #endif
 
 

TSCP/src/APP/ciapp/Initial/InitialProcess.h

@@ -73,9 +73,6 @@
 #include "../AutoRoute/AutoRouteDataManage.h"
 #include "../NonAutoReturn/NonAutoReturnDataManage.h"
 #include "../VirtualDevice/VirtualDevDataManage.h"
-#include "../SsksLightRelay/SsksLightRelayDataManage.h"
-#include "../ConnectOverride/ConnectOverrideDataMg.h"
-#include "SpeedLimitSecDataManage.h"
 
 #ifdef SCADE_MODE 
 #include "../LogicManage/General/LogicManageScadeInterface.h"
@@ -246,7 +243,12 @@ UINT8 InitialPhySecIdBufOfOtherCi(void);
 * 返回值  ： void
 */
 void ResetDynamicState(const UINT8 ciId);
-
+/*
+* 功能描述：重置相邻Rc通信中断动态数据
+* 参数说明：const UINT8 ciId, 重置联锁ID
+* 返回值  ： void
+*/
+void ResetDynamicRcState(const UINT8 ciId);
 	
 /*
 * 功能描述： 初始化全自动折返进路数据
@@ -324,24 +326,6 @@ void InitPlatDataStru(void);
 */
 UINT8 InitLEUDataStru(void);
 
-/*
-* 功能描述：SSKS闪灯稳灯继电器动态数据初始化
-* 参数说明：无
-* 返 回 值：0 失败
-*			1 成功
-* Created By LQ 2025.12.15
-*/
-UINT8 InitSsksLightRelayData(void);
-
-/*
-* 功能描述：联络线旁路继电器动态数据初始化
-* 参数说明：无
-* 返 回 值：0 失败
-*			1 成功
-* Created By wyd 20260311
-*/
-UINT8 InitConnectOverrideData(void);
-
 /*
 * 功能描述： 初始化无人折返指示灯状态数据
 * 参数说明： void
@@ -352,20 +336,22 @@ UINT8 InitConnectOverrideData(void);
 UINT8 InitialRtnIndicStaData(void);
 
 /*
-* 功能描述：初始化接触网数据
+* 功能描述：重置本控区RC的设备动态数据
 * 参数说明：void
-* 返回值  ：返回初始化结果
+* 返 回 值：void
+* Created By LQ 2025.11.07
 */
-UINT8 InitOhlDataStru(void);
+void ResetLocalRcDynamicState(void);
 
 /*
-* 功能描述：初始化ECS数据
+* 功能描述：重置控区设备状态处理
 * 参数说明：void
-* 返 回 值：0 初始化失败
+* 返 回 值：无
-*			1 初始化成功
+* Created By LQ 2025.11.19
-* Created By LQ 2026.01.26
 */
-UINT8 InitialEcsData(void);
+void ResetDevStateProcess(void);
+
+
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/InvadeSection/InvadeSectionConfigDataManage.c

@@ -134,8 +134,6 @@ UINT16 GetInvaSectId(UINT16 invSecAndConSwiId)
 	return retVal;
 }
 
-
-
 /*
 功能描述: 	获得侵限区段所有条件道岔数量
 输入参数:	UINT16 invSecAndConSwiId 侵限区段及条件道岔数据ID

TSCP/src/APP/ciapp/InvadeSection/InvadeSectionDefine.h

@@ -14,7 +14,7 @@
 #ifndef __INVADESECTION_DEFINE_H_
 #define __INVADESECTION_DEFINE_H_
 
-#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)400)	/*侵限区段与相关条件道岔数据条目最大数量*/
+#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)800)	/*侵限区段与相关条件道岔数据条目最大数量*/
 
 #define COND_SWITCH_SUM_MAX ((UINT16)16)				/*单一侵限区段与相关条件道岔数据条目内,条件道岔最大数量*/
 

TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonConfigDataManage.c

@@ -0,0 +1,129 @@
+/********************************************************
+*                                                                                                            
+* 文 件 名： LightTestButtonConfigDataManage.c   
+* 版权说明： 北京交控科技有限公司 
+* 创建时间： 2025-12-09
+* 作    者： 联锁组
+* 功能描述： 试灯按钮配置数据管理  
+* 修改记录：   
+*
+********************************************************/
+
+#include "LightTestButtonConfigDataManage.h"
+
+LightTestButtonConfigDataStruct LightTestButtonConfigDataStru[LIGHTTESTBUTTON_BUTTON_MAX_NUM] = {0};   /*定义试灯按钮数据配置结构体*/
+INT16 LightTestButtonCurSum = 0;   /*试灯按钮当前总数*/
+
+
+/*
+* 功能描述： 获取试灯按钮当前总数
+* 参数说明： void    
+* 返回值  ： 0: 获取数据失败
+*			>0: 试灯按钮当前总数
+*/
+UINT16 GetLightTestButtonCurSum(void)
+{
+    UINT16 retVal  = 0u;
+    if (LIGHTTESTBUTTON_BUTTON_MAX_NUM <= ((UINT16)LightTestButtonCurSum))
+    {
+        retVal = LIGHTTESTBUTTON_BUTTON_MAX_NUM;
+    }
+    else
+    {
+        retVal = (UINT16)LightTestButtonCurSum;
+    }
+    return retVal;
+}
+/*
+* 功能描述： 获取试灯按钮的ID
+* 参数说明： UINT16 index  试灯按钮索引    
+* 返回值    UINT16 retVal   试灯按钮ID
+*/
+UINT16 GetLightTestButtonId(UINT16 index)
+{
+    UINT16 retVal = 0u;
+	UINT16 lightTestButtonCurSum = GetLightTestButtonCurSum();
+    if (index < lightTestButtonCurSum)
+    {
+        retVal = LightTestButtonConfigDataStru[index].LightTestButtonId;
+    }
+	else
+	{
+	}
+    return retVal;
+}
+
+/*
+* 功能描述：  获取试灯按钮ID对应的继电器数据
+* 参数说明：  UINT16 lightTestButtonId  试灯按钮ID
+* 返回值  ： 
+             LightTestButtonConfigDataStruct *   
+*/
+LightTestButtonConfigDataStruct *GetLightTestButtonConfigData(UINT16 lightTestButtonId)
+{
+    LightTestButtonConfigDataStruct *retVal = NULL;
+    UINT16 i = 0u;
+    UINT16 lightTestButtonCurSum = GetLightTestButtonCurSum();
+
+    for (i = 0u; i < lightTestButtonCurSum; i++)
+    {
+        if (lightTestButtonId == LightTestButtonConfigDataStru[i].LightTestButtonId)
+        {
+            retVal = &LightTestButtonConfigDataStru[i];
+            break;
+        }
+		else
+		{
+		}
+    }
+    return retVal;
+}
+
+/*
+* 功能描述：  获取试灯按钮ID对应继电器的总数量
+* 参数说明：  UINT16 lightTestButtonId  试灯按钮ID
+* 返回值  ： UINT16  lightTestButtonRelayNum   继电器数量 
+*/
+UINT16 GetLightTestButtonRelayNum(UINT16 lightTestButtonId)
+{
+    UINT16 lightTestButtonRelayNum = 0u;
+    LightTestButtonConfigDataStruct *lightTestButtonConfigData = GetLightTestButtonConfigData(lightTestButtonId);
+    if (NULL != lightTestButtonConfigData)
+    {
+        lightTestButtonRelayNum = lightTestButtonConfigData->LightTestButtonRelayNum;
+    }
+    else
+    {
+		; /* 不处理 */
+    }
+    return lightTestButtonRelayNum;
+}
+
+/*
+* 功能描述：  获取试灯按钮ID对应继电器ID
+* 参数说明：  UINT16 lightTestButtonId  试灯按钮ID
+*            UINT16 index  继电器索引  
+* 返回值  ： UINT16  lightTestButtonRelayId   继电器ID
+*/
+UINT16 GetLightTestButtonRelayId(UINT16 lightTestButtonId, UINT16 index)
+{
+    UINT16 lightTestButtonRelayId = 0u;
+    LightTestButtonConfigDataStruct *lightTestButtonConfigData = GetLightTestButtonConfigData(lightTestButtonId);
+    if (NULL != lightTestButtonConfigData)
+    {
+        if (index < lightTestButtonConfigData->LightTestButtonRelayNum)
+        {
+            lightTestButtonRelayId = lightTestButtonConfigData->LightRelayId[index];
+        }
+        else
+        {
+            ; /* 不处理 */
+        }
+    }
+    else
+    {
+        ; /* 不处理 */
+	}
+    return lightTestButtonRelayId;
+}
+

TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonConfigDataManage.h

@@ -0,0 +1,80 @@
+/********************************************************
+*                                                                                                            
+* 文 件 名： LightTestButtonConfigDataManage.h   
+* 版权说明： 北京交控科技有限公司 
+* 创建时间： 2025-12-09
+* 作    者： 联锁组
+* 功能描述： 试灯按钮配置数据管理头文件  
+* 函数包括：
+* 使用注意：
+* 修改记录：   
+*
+********************************************************/
+
+#ifndef _LIGHTTESTBUTTON_CONFIG_DATA_MANAGE_H_
+#define _LIGHTTESTBUTTON_CONFIG_DATA_MANAGE_H_
+
+
+#include "LightTestButtonDefine.h"
+
+
+typedef struct S_LightTestButtonConfigDataStruct
+{
+    UINT16 LightTestButtonId;      	       /* 试灯按钮ID (配置字段) */
+    UINT16 BelongOcId;    	                   /* 所属OC ID (配置字段) */
+    UINT8  LightTestButtonType;               /* 试灯按钮类型 (配置字段) */
+    UINT16 LightTestButtonRelayNum;            /* 试灯表示灯继电器数量  */
+    UINT16 LightRelayId[LIGHTTESTBUTTON_LIGHT_SUPPORT_MAX_NUM];    /* 试灯表示灯继电器ID数组 */
+}LightTestButtonConfigDataStruct;
+
+
+extern LightTestButtonConfigDataStruct LightTestButtonConfigDataStru[LIGHTTESTBUTTON_BUTTON_MAX_NUM];   /*定义试灯按钮数据配置结构体*/
+extern INT16 LightTestButtonCurSum;   /*试灯按钮当前总数*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+* 功能描述： 获取试灯按钮当前总数
+* 参数说明： void    
+* 返回值  ： 0: 获取数据失败
+*			>0: 信试灯按钮当前总数
+*/
+UINT16 GetLightTestButtonCurSum(void);
+
+/*
+* 功能描述： 获取试灯按钮的ID
+* 参数说明： UINT16 index  试灯按钮索引    
+* 返回值    UINT16 retVal   试灯按钮ID
+*/
+UINT16 GetLightTestButtonId(UINT16 index);
+
+
+/*
+* 功能描述：  获取试灯按钮ID对应的继电器数据
+* 参数说明：  UINT16 lightTestButtonId  试灯按钮ID
+* 返回值  ： 
+             LightTestButtonConfigDataStruct *   
+*/
+LightTestButtonConfigDataStruct *GetLightTestButtonConfigData(UINT16 lightTestButtonId);
+
+/*
+* 功能描述：  获取试灯按钮ID对应继电器的总数量
+* 参数说明：  UINT16 lightTestButtonId  试灯按钮ID
+* 返回值  ： UINT16  lightTestButtonRelayNum   继电器数量 
+*/
+UINT16 GetLightTestButtonRelayNum(UINT16 lightTestButtonId);
+
+/*
+* 功能描述：  获取试灯按钮ID对应继电器ID
+* 参数说明：  UINT16 lightTestButtonId  试灯按钮ID
+*            UINT16 index  继电器索引  
+* 返回值  ： UINT16  lightTestButtonRelayId   继电器ID
+*/
+UINT16 GetLightTestButtonRelayId(UINT16 lightTestButtonId, UINT16 index);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDataManage.c

@@ -0,0 +1,63 @@
+/********************************************************
+*                                                                                                            
+* 文 件 名： LightTestButtonDataManage.c   
+* 版权说明： 北京交控科技有限公司 
+* 创建时间： 2025-12-09
+* 作    者： 联锁组
+* 功能描述： 试灯按钮数据管理  
+* 修改记录：   
+*
+********************************************************/
+
+#include "LightTestButtonDataManage.h"
+
+
+
+/*
+* 功能描述： 试灯按钮处理函数
+* 参数说明： void    
+* 返回值  ： void
+*/
+void LightTestButtonDataManageProc(void)
+{
+    UINT16 i = 0u;  /*循环变量*/
+    UINT16 j = 0u;  /*循环变量*/
+
+    UINT16 lightTestButtonId = 0u;  /* 试灯按钮ID */
+    UINT16 lightTestButtonRelayNum = 0u; /* 试灯按钮ID数量 */
+    UINT16 lightRelayId = 0u;      /* 试灯表示灯继电器ID */
+    UINT16 ligthtRelatNum = 0u;   /* 试灯表示灯继电器数量 */
+
+    UINT8 lightTestButtonState = RELAY_STATE_DOWN;   /*试灯按钮状态*/
+
+    lightTestButtonRelayNum = GetLightTestButtonCurSum(); /*获取试灯按钮总数量*/
+
+    for(i = 0u; i < lightTestButtonRelayNum; i++)
+    { 
+        /* 获取对应试灯按钮ID*/
+        lightTestButtonId = GetLightTestButtonId(i);
+        /*获取试灯按钮继电器采集状态*/
+        lightTestButtonState = GetRelayCollState(lightTestButtonId);
+        if(RELAY_STATE_UP == lightTestButtonState)      /*试灯按钮按下*/
+        {
+            /* 试灯表示灯继电器数量*/
+            ligthtRelatNum = GetLightTestButtonRelayNum(lightTestButtonId);
+            for(j = 0u; j < ligthtRelatNum; j++)
+            {
+                /* 获取对应试灯表示灯继电器ID*/
+                lightRelayId = GetLightTestButtonRelayId(lightTestButtonId,j);
+                /*设置试灯表示灯继电器吸起*/
+                (void)SetRelayDriveState(lightRelayId, RELAY_DRIVE_STATE_UP); 
+
+            }
+        }
+        else if(RELAY_STATE_DOWN == lightTestButtonState)   /*试灯按钮未按下*/
+        {
+            /* 不处理即可 */
+        }
+        else
+        {
+            /* 不处理 */
+        }
+    } 
+}

TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDataManage.h

@@ -0,0 +1,42 @@
+/********************************************************                                                                                                         
+* 文 件 名： LightTestButtonDataManage.h   
+* 版权说明： 北京交控科技有限公司 
+* 创建时间： 2025-12-09
+* 作    者： 联锁组
+* 功能描述： 试灯按钮数据管理头文件  
+* 函数包括：
+* 使用注意：
+* 修改记录：  
+*
+********************************************************/
+
+#ifndef _LIGHTTEST_BUTTON_DATA_MANAGE_H_
+#define _LIGHTTEST_BUTTON_DATA_MANAGE_H_
+
+
+#include "LightTestButtonDefine.h"
+#include "LightTestButtonConfigDataManage.h"
+#include "RelayDefine.h"
+#include "RelayDataManage.h"
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+/*
+* 功能描述： 试灯按钮处理函数
+* 参数说明： void    
+* 返回值  ： void
+*/
+void LightTestButtonDataManageProc(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDefine.h

@@ -0,0 +1,33 @@
+/********************************************************
+*                                                                                                            
+* 文 件 名： LightTestButtonDefine.h   
+* 版权说明： 北京交控科技有限公司 
+* 创建时间： 2025-12-09
+* 作    者： 联锁组
+* 功能描述： 试灯按钮配置数据头文件  
+* 函数包括：
+* 使用注意：
+* 修改记录：   
+*
+********************************************************/ 
+
+#ifndef _LIGHTTESTBUTTON_DEFINE_H_
+#define _LIGHTTESTBUTTON_DEFINE_H_
+
+#include "CommonTypes.h"
+
+/* 试灯表示灯最大数量 */
+#define LIGHTTESTBUTTON_LIGHT_MAX_NUM      ((UINT8)13U)
+
+/* 试灯表示灯支持最大数 */
+#define LIGHTTESTBUTTON_LIGHT_SUPPORT_MAX_NUM   ((UINT8)208U)
+
+/* 试灯按钮可配置最大数量 */
+#define LIGHTTESTBUTTON_BUTTON_MAX_NUM     ((UINT16)70U)
+
+/* 武汉新港OC采集试灯按钮类型 */
+#define LIGHTTESTBUTTON_TYPE_XINGANG ((UINT8)0xaaU)
+
+#endif
+
+

TSCP/src/APP/ciapp/LogRecord/LogRecord.h

@@ -45,10 +45,6 @@
 #include "../Route/LogicalRouteDataManage.h"
 #include "NonAutoReturnDataManage.h"
 #include "NonAutoReturnConfigDataManage.h"
-#include "../SsksLightRelay/SsksLightRelayDataManage.h"
-#include "../ECS/ECSDataManage.h"
-#include "SpeedLimitSecConfigDataManage.h"
-#include "../ConnectOverride/ConnectOverrideDataMg.h"
 
 #ifdef PLATFORM_LABVIEW_DEBUG
 #include "stdio.h"

TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c

@@ -16,6 +16,7 @@
 #include "../Section/LogicSectionDataManage.h"
 #include "LogicalRouteDataManage.h"
 #include "../LogicProcess/LogicalRouteLogicCheck.h"
+#include "../Overlap/OverlapDataManage.h"
 
 /* C01_进路监督级别确认 */
 /*
@@ -564,6 +565,8 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
 	UINT16 protectSwitchId = 0u;                                      /*防护道岔ID*/
 	UINT8 routeProtectSwitchSum = 0u; 	                      /*防护道岔数目*/
 	RouteProtectSwitchStruct* routeProtectSwitchStru = NULL;  /*防护道岔数据*/
+	UINT8 cSwitchCurPos = 0U;  /*道岔当前位置*/
+	UINT8 cFuncRet = CI_ERROR;
 	
 	routeProtectSwitchSum = GetRouteRelatedProtectSwitchSum(routeId);      /*获取防护道岔数目*/
 	routeProtectSwitchStru = GetRouteRelatedProtSwitchData(routeId);    /*获取防护道岔数据*/
@@ -586,20 +589,30 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
 
 	if (CI_SUCCESS == retVal)
 	{
-		for (ii= 0u; ii < routeProtectSwitchSum; ii++)
+		for (ii = 0u; ii < routeProtectSwitchSum; ii++)
 		{
 			protectSwitchId = routeProtectSwitchStru[ii].ProtectSwitchId;
-			SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE,routeId,protectSwitchId, lockCommand);                        /*设置道岔防护锁闭状态*/
+			cSwitchCurPos = GetSwitchCurPosition(protectSwitchId);
-			/*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
+			cFuncRet = checkSwtLastValDrvPosStayorNot(protectSwitchId, routeProtectSwitchStru[ii].ProtectPosition);
+			if ((SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+				|| ((cSwitchCurPos == routeProtectSwitchStru[ii].ProtectPosition) && (CI_SUCCESS == cFuncRet)))
+			{
+				SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, routeId, protectSwitchId, lockCommand);  /*设置道岔防护锁闭状态*/
+			    /*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
 #if 0
-			if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
+				if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
-			{ /*双动道岔*/
+				{ /*双动道岔*/
-				SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE,routeId,GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁闭状态*/
+					SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, routeId, GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁闭状态*/
+				}
+				else
+				{
+				}
+#endif
 			}
 			else
 			{
+				/*防护道岔不在防护位置或防护道岔存在反向驱动，不设置防护锁闭*/
 			}
-#endif
 		}
 	} 
 	else
@@ -789,7 +802,6 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 	UINT8 goExec = CI_ERROR;
 	UINT8 autoTriggerType = 0U;
 	UINT8 belongvirCIid = 0U;
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 chPhyIncLogSum = 0U;            /*包含逻辑区段数目*/
 	UINT16* pPhyIncLogId = NULL;   /*物理区段包含逻辑区段ID数组*/
 	UINT16 wLogLockBelongRouteId = 0U;  /*逻辑区段锁闭所属进路ID*/
@@ -878,7 +890,7 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 							*/
 
 							/*正常情况下区故解绿光带*/
-							phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId, CI_ERROR);
+							phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId);
 							if (CI_SUCCESS == phyFaultUnLockRes)
 							{ /*成功*/
 								routeDir = GetRouteDirection(lockBelongRouteId);
@@ -993,7 +1005,7 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 				(CICI_RELAY_INTERFACE_CONFIRM_YES == confirmRelayInterfaceFlag)&&
 				(FUNC_SWITCH_ON == funcSwitchSupportRelayInterface))
 			{
-				phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId, CI_ERROR);
+				phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId);
 				if (CI_SUCCESS == phyFaultUnLockRes)
 				{ /*成功*/
 					routeDir = GetRouteDirection(lockBelongRouteId);
@@ -1027,16 +1039,8 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 			}
 			else if((phyBelongCi == localCiId)&&(TRANSMIT_STATE_GOOD == commState))
 			{	
-				if(FUNC_SWITCH_ON == includeVirFlag)
+				belongvirCIid = GetPhySecBelongVirCiId(phySectionId);
-				{
+				if((belongvirCIid == virCIid)&&(0u != virCIid))/*区故解可以由相邻虚拟联锁现地操作，不相邻不能操作*/
-					belongvirCIid = GetPhySecBelongVirCiId(phySectionId);
-					if((belongvirCIid == virCIid)&&(0u != virCIid))/*区故解可以由相邻虚拟联锁现地操作，不相邻不能操作*/
-					{
-						/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令	*/	
-						AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK,phySectionId,0u,routeBelongCi);
-					}
-				}
-				else
 				{
 					/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令	*/	
 					AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK,phySectionId,0u,routeBelongCi);
@@ -1380,6 +1384,12 @@ void RouteRecoverOpenProc(const UINT16 routeId)
 	UINT8 errType = CI_ERROR;
 	UINT8 localCiType = GetLocalCiType();/*获得联锁类型*/
 	UINT16 wStartSignalId = 0U;  /*进路始端信号机ID*/
+	UINT8 chVirCiId = 0U;/*虚拟联锁*/
+	UINT8 chLocalVirCiType = 0U;
+
+
+	chVirCiId = GetRouteBelongVirCiId(routeId);
+	chLocalVirCiType = GetLocalVirCiType(chVirCiId);
 
 	routeState = GetRouteState(routeId);
 	recoverState = GetRouteRecoverOpenFlag(routeId);
@@ -1388,7 +1398,7 @@ void RouteRecoverOpenProc(const UINT16 routeId)
 	{
 		if (ROUTE_RECOVER_STA_WAIT == recoverState)
 		{
-			if ((CI_TYPE_ZX == localCiType) || (CI_TYPE_SCX == localCiType))
+			if ((CI_TYPE_ZX == chLocalVirCiType) || (CI_TYPE_SCX == chLocalVirCiType))
 			{
 				errType = RecoverOpenRouteCheck(routeId);
 			}
@@ -1433,7 +1443,6 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 	UINT16 ii = 0u;
 	UINT16 routeOverlapSum = 0u;	/*进路保护区段数目*/
 	UINT16 routeId = 0u;	         /*进路ID*/
-	UINT16 routedLockOverlapId = 0u;	/*进路锁闭过OverlapId*/
 	UINT8 retVal = CI_SUCCESS;	/*执行检查*/
 	UINT8 routeState = 0u;	/*进路状态*/
 	UINT16 preOverlepId = 0u;
@@ -1443,9 +1452,9 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 	UINT8 flag = 0u;
 	UINT8 belongCiId = 0u;
 	UINT8 localCiId = GetSystemParaLocalCiId();          /*获取本机联锁ID*/
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 virCIid = 0u;
 	UINT8 ciCtrModeFlag = 0u;
+	UINT32 dwCurCycNum = Get2oo2CurCycleNum();
 
 	if ((0u == expLkOverlapId) || (UINT16_MAX == expLkOverlapId))
 	{/*判断输入参数有效性*/
@@ -1486,9 +1495,9 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 				if (routeOverlapSum >= 1u)
 				{/*只有当进路的保护区段数目大于等于1个时，ATS或现地才发送期望锁闭保护区段ID*/
 					/*输入参数保护区段ID是否属于当前进路 且进路保护区段未锁闭过*/
-					if (1u == checkExpOverlapBelongToRtOrNot(routeId,expLkOverlapId))
+					if (1u == checkExpOverlapBelongToRtOrNot(routeId, expLkOverlapId))
 					{/*期望锁闭的保护区段ID属于进路的保护区段ID*/
-					    flag = 1u;/*有任意一条匹配到了，则置为1*/
+						flag = 1u;/*有任意一条匹配到了，则置为1*/
 						retVal = CI_SUCCESS;
 					}
 					else
@@ -1513,79 +1522,62 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 					/*判断当前保护区段所属联锁控制模式是否可以响应锁闭保护区段命令*/
 					if (CI_SUCCESS == retVal)
 					{
-						virCIid= GetOverlapBelongVirCiId(expLkOverlapId);
+						virCIid = GetOverlapBelongVirCiId(expLkOverlapId);
-						if(FUNC_SWITCH_ON == includeVirFlag)
-						{
-							ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
-						}	
-						else
-						{
-							ciCtrModeFlag = GetCiModeFlag();	/*获取联锁控制模式*/
-						}
 
-						if((CI_MODE_CI_LOCAL ==ciCtrModeFlag)||(0u ==ciCtrModeFlag))/*处于联锁控或者获取错误，发送现地不能响应人工锁闭命令*/
+						ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
+						if ((CI_MODE_CI_LOCAL == ciCtrModeFlag) || (0u == ciCtrModeFlag))/*处于联锁控或者获取错误，发送现地不能响应人工锁闭命令*/
 						{
 							retVal = CI_ERROR;
 						}
 					}
 
-					/*add by shl*/
-
 					if (CI_SUCCESS == retVal)
 					{
+						/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
+						routeState = GetRouteState(routeId);
 
-						routedLockOverlapId = GetRouteOverlapLockedId(routeId);	/*获取进路锁闭过保护区段ID*/
+						if ((routeState == ROUTE_STATE_FIRST_XUANPAI) ||
-
+							(routeState == ROUTE_STATE_XUANPAI) ||
-						if (0u == routedLockOverlapId)
+							(routeState == ROUTE_STATE_FIRST_LOCK) ||
-						{
+							(routeState == ROUTE_STATE_FIRST_LOCKERR) ||
-							/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
+							(routeState == ROUTE_STATE_YUXIAN_OPEN) ||
-							routeState = GetRouteState(routeId);
+							(routeState == ROUTE_STATE_YUXIAN_LOCK) ||
-
+							(routeState == ROUTE_STATE_NEAR_OPEN) ||
-							if ((routeState == ROUTE_STATE_FIRST_XUANPAI) ||
+							(routeState == ROUTE_STATE_NEAR_LOCK) ||
-								(routeState == ROUTE_STATE_XUANPAI) ||
+							(routeState == ROUTE_STATE_NEAR_LOCKERR) ||
-								(routeState == ROUTE_STATE_FIRST_LOCK) ||
+							(routeState == ROUTE_STATE_AUTO_UNLOCK) ||
-								(routeState == ROUTE_STATE_FIRST_LOCKERR) ||
+							(routeState == ROUTE_STATE_HALF_UNLOCK)
-								(routeState == ROUTE_STATE_YUXIAN_OPEN) ||
+							)
-								(routeState == ROUTE_STATE_YUXIAN_LOCK) ||
+						{/*设置指定ID进路的期望锁闭保护区段ID*/
-								(routeState == ROUTE_STATE_NEAR_OPEN) ||
+							if (LABOR_LOCK_OVERLAP == lockType)/*人工锁闭*/
-								(routeState == ROUTE_STATE_NEAR_LOCK) ||
+							{
-								(routeState == ROUTE_STATE_NEAR_LOCKERR) ||
+								SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
-								(routeState == ROUTE_STATE_AUTO_UNLOCK) ||
+								SetOverlaplaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置人工锁闭标志，用于人工命令一次有效处理*/
-								(routeState == ROUTE_STATE_HALF_UNLOCK)
+								ClearPreLoaborUnlockState(expLkOverlapId);
-								)
+							}
-							{/*设置指定ID进路的期望锁闭保护区段ID*/
+							else if (ATS_LOCK_OVERLAP == lockType)/*ATS锁闭*/
-							    if(LABOR_LOCK_OVERLAP == lockType)/*人工锁闭*/
+							{
+								phySectionId = GetRouteLastPhySectionId(routeId);
+								phySectionSta = GetPhySecCurMergeState(phySectionId);
+								if (SECTION_OCCUPY_YES == phySectionSta)
 								{
-									SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId,LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
+									SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志*/
-									SetOverlaplaborLockCmdFlag(expLkOverlapId,LOCK_OVERLAP_CMD_YES);/*设置人工锁闭标志，用于人工命令一次有效处理*/
 								}
-								else if(ATS_LOCK_OVERLAP == lockType)/*ATS锁闭*/
-								{ 
-								    phySectionId = GetRouteLastPhySectionId(routeId);
-									phySectionSta = GetPhySecCurMergeState(phySectionId);
-									if(SECTION_OCCUPY_YES==phySectionSta)
-									{
-										SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId,LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志*/
-									}
-								}
-								else
-								{
-									/*什么也不做*/
-								}
-								SetRouteAtsExpLkOverlapId(routeId,expLkOverlapId);
-								SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_NO);/*清除标志*/
-								retVal = CI_SUCCESS;
 							}
 							else
 							{
-								retVal = CI_ERROR;
+								/*什么也不做*/
 							}
-							
+							SetRouteAtsExpLkOverlapId(routeId, expLkOverlapId);
-
+							SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_NO);/*清除标志*/
+							SetOverlapAtsLastTimeLockCyc(expLkOverlapId, dwCurCycNum);
+							retVal = CI_SUCCESS;
+						}
+						else
+						{
+							retVal = CI_ERROR;
 						}
-						
 					}
-
 				}
 			}
 		}
@@ -1607,10 +1599,8 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 {
 	UINT16 lockBelongRouteId = 0u;  /*区段锁闭所属进路ID*/
-	UINT16 wTempPhySecId = 0u;
 	UINT8 reVal = CI_ERROR;
 	UINT8 belongvirCIid = 0u;
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 isErrLock = CI_ERROR;   
 	UINT8 phyLockState = 0U;
 
@@ -1636,44 +1626,39 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 	}
 	if(CI_SUCCESS == reVal)
 	{
-		if(FUNC_SWITCH_ON == includeVirFlag)
+	
+		belongvirCIid = GetRouteBelongVirCiId(lockBelongRouteId);
+		if(0u < virCIid)
 		{
-			belongvirCIid = GetRouteBelongVirCiId(lockBelongRouteId);
+			if(virCIid == belongvirCIid)
-			if(0u < virCIid)
 			{	
-				if(virCIid == belongvirCIid)
+				reVal = CI_SUCCESS;	/*本Rtu(虚拟联锁现地)可以操作属于本虚拟联锁的进路锁闭的物理区段区故解，无论该物理区段是否属于该Rtu*/
-				{	
-					reVal = CI_SUCCESS;	/*本Rtu(虚拟联锁现地)可以操作属于本虚拟联锁的进路锁闭的物理区段区故解，无论该物理区段是否属于该Rtu*/
-				}
-				else
-				{
-					belongvirCIid = GetPhySecBelongVirCiId(phySectionId);
-					if(belongvirCIid == virCIid)
-					{
-						reVal = CI_SUCCESS;/*本虚拟联锁物理区段由相邻虚拟联锁进路锁闭的，可以在该物理区段所属Rtu上操作区故解*/	
-					}
-					else
-					{
-						reVal = CI_ERROR;
-					}
-				}
 			}
 			else
 			{
-				reVal = CI_ERROR;
+				belongvirCIid = GetPhySecBelongVirCiId(phySectionId);
+				if(belongvirCIid == virCIid)
+				{
+					reVal = CI_SUCCESS;/*本虚拟联锁物理区段由相邻虚拟联锁进路锁闭的，可以在该物理区段所属Rtu上操作区故解*/	
+				}
+				else
+				{
+					reVal = CI_ERROR;
+				}
 			}
-
 		}
 		else
 		{
-			reVal = CI_SUCCESS;
+			reVal = CI_ERROR;
 		}
+
+		
 	}	
 
 	/*按顺序解锁进路异常锁闭*/
 	if (CI_SUCCESS == reVal)
 	{
-		isErrLock = RouteFirstLockErrCheck(lockBelongRouteId, &wTempPhySecId);
+		isErrLock = RouteFirstLockErrCheck(lockBelongRouteId);
 		phyLockState = GetPhySecLockState(phySectionId);
 		/*第一个锁闭的区段是故障锁闭*/
 		if (CI_SUCCESS == isErrLock )
@@ -1890,8 +1875,9 @@ void SetRouteOvlpOtherCiShrFlg(const UINT16 wRouteId, const UINT16 wOverlapId,co
 void ClearSomeFlagDependRouteState(const UINT16 routeId)
 {
 	UINT8 routeState = GetRouteState(routeId);
-	UINT16 startSignalId = 0u;
+	UINT16 startSignalId = 0U;
-	UINT16  EnginVehicCroCloBelongRoute = 0u;
+	UINT16  EnginVehicCroCloBelongRoute = 0U;
+	UINT8 chZrenjieFlag = 0U;
 
 	/*清理工程车跨压关信号所属进路,清理工程车跨压状态*/
 	if ((ROUTE_STATE_YUXIAN_LOCK != routeState)
@@ -1928,6 +1914,29 @@ void ClearSomeFlagDependRouteState(const UINT16 routeId)
 	{
 		SetRouteGroupRouteCmdFlag(routeId, ROUTE_GROUPROUTE_CMD_NO);	/*清除进路的组合进路命令标志*/
 	}
+
+	/*若进路处于以下状态，清除联挂进路标志*/
+	if ((ROUTE_STATE_IDLE == routeState) || (ROUTE_STATE_DELAY_UNLOCK == routeState)
+		|| (ROUTE_STATE_LEAD_XUANPAI == routeState) || (ROUTE_STATE_LEAD_LOCK == routeState)
+		|| (ROUTE_STATE_LEAD_LOCKERR == routeState) || (ROUTE_STATE_LEAD_OPEN == routeState))
+	{
+		SetRouteCouplinkFlag(routeId, ROUTE_COUPLINK_FLAG_NO);
+	}
+	else
+	{
+		/*不处理*/
+	}
+	/*无总人解标志且不处于延时解锁状态，清除联络线解锁标志*/
+	chZrenjieFlag = GetRouteZongRenJieFlag(routeId);
+	if ((ROUTE_ZONGRENJIE_SET_NO == chZrenjieFlag) && (ROUTE_STATE_DELAY_UNLOCK != routeState))
+	{
+		SetRouteConnectReleaseFlag(routeId, ROUTE_CONNECT_RELEASE_NO);  /*清除联络线解锁标志*/
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 }
 
 /*
@@ -3401,14 +3410,12 @@ void OtherCiLogSecFaultUnlockProcess(const UINT16 wLogSectionId, const UINT8 chV
 	UINT8 chLogFaultUnLockRes = 0U;/*逻辑区段故障解锁条件检查结果*/
 	UINT8 chLogSecBelongRouteDir = 0U;/*逻辑区段锁闭所属进路方向*/
 	UINT8 chRouteLogSecHaveUnLock = 0u;/*进路逻辑区段是否已解锁*/
-	UINT8 chIncludeVirFlag = 0U;/*是否支持虚拟联锁*/
 	UINT8 chBelongVirCiId = 0U;/*逻辑区段所属虚拟联锁ID*/
 	UINT16 wLogSecBelongPhySecId = 0U;/*逻辑区段所属物理区段ID*/
 
 	chLocalCiId = GetSystemParaLocalCiId();  /*获取本机联锁ID*/
 	wLogLockBelongRouteId = GetLogSecLockBelongRoute(wLogSectionId);
 	chFuncSwitch = GetCiFunctionSwitchConfig(FUNC_SWITCH_USE_RELAY_INTERFACE_BETWEEN_NEIGHBOURCI);
-	chIncludeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	chConfirmRelayInterfaceFlag = GetCiCiRelayInterfConfirmFlag();/*继电接口确认状态*/
 
 	if ((0U < wLogLockBelongRouteId) && (ROUTE_SUM_MAX > wLogLockBelongRouteId))
@@ -3442,21 +3449,15 @@ void OtherCiLogSecFaultUnlockProcess(const UINT16 wLogSectionId, const UINT8 chV
 		else if ((chLocalCiId == chLogSecBelongCiId) && (TRANSMIT_STATE_GOOD == chCommState))
 		{
 			wLogSecBelongPhySecId = GetLgcSecRelativePhySecId(wLogSectionId);
-			if (FUNC_SWITCH_ON == chIncludeVirFlag)
+			
-			{
+			chBelongVirCiId = GetLogSecBelongVirCiId(wLogSectionId);
-				chBelongVirCiId = GetLogSecBelongVirCiId(wLogSectionId);
+			if ((chVirCIid == chBelongVirCiId) && (0U != chVirCIid))
-				if ((chVirCIid == chBelongVirCiId) && (0U != chVirCIid))
-				{
-					/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令	*/
-					AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK, wLogSecBelongPhySecId, 0U, chRouteBelongCiId);
-				}
-			}
-			else
 			{
 				/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令	*/
 				AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK, wLogSecBelongPhySecId, 0U, chRouteBelongCiId);
-
 			}
+			
+			
 		}
 		else
 		{
@@ -3477,7 +3478,6 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
 	UINT16 wLockBelongRouteId = 0U;  /*区段锁闭所属进路ID*/
 	UINT8 reVal = CI_ERROR;
 	UINT8 chBelongvirCIid = 0U;
-	UINT8 chIncludeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 
 	if ((0u == wLogSectionId) || (LOGIC_SECTION_SUM_MAX <= wLogSectionId))
 	{
@@ -3500,38 +3500,32 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
 	}
 	if (CI_SUCCESS == reVal)
 	{
-		if (FUNC_SWITCH_ON == chIncludeVirFlag)
+		
+		chBelongvirCIid = GetRouteBelongVirCiId(wLockBelongRouteId);
+		if (0U < chVirCIid)
 		{
-			chBelongvirCIid = GetRouteBelongVirCiId(wLockBelongRouteId);
+			if (chVirCIid == chBelongvirCIid)
-			if (0U < chVirCIid)
 			{
-				if (chVirCIid == chBelongvirCIid)
+				reVal = CI_SUCCESS;	/*本Rtu(虚拟联锁现地)可以操作属于本虚拟联锁的进路锁闭的逻辑区段区故解，无论该逻辑区段是否属于该Rtu*/
-				{
-					reVal = CI_SUCCESS;	/*本Rtu(虚拟联锁现地)可以操作属于本虚拟联锁的进路锁闭的逻辑区段区故解，无论该逻辑区段是否属于该Rtu*/
-				}
-				else
-				{
-					chBelongvirCIid = GetLogSecBelongVirCiId(wLogSectionId);
-					if (chVirCIid == chBelongvirCIid)
-					{
-						reVal = CI_SUCCESS;/*本虚拟联锁逻辑区段由相邻虚拟联锁进路锁闭的，可以在该逻辑区段所属Rtu上操作区故解*/
-					}
-					else
-					{
-						reVal = CI_ERROR;
-					}
-				}
 			}
 			else
 			{
-				reVal = CI_ERROR;
+				chBelongvirCIid = GetLogSecBelongVirCiId(wLogSectionId);
+				if (chVirCIid == chBelongvirCIid)
+				{
+					reVal = CI_SUCCESS;/*本虚拟联锁逻辑区段由相邻虚拟联锁进路锁闭的，可以在该逻辑区段所属Rtu上操作区故解*/
+				}
+				else
+				{
+					reVal = CI_ERROR;
+				}
 			}
-
 		}
 		else
 		{
-			reVal = CI_SUCCESS;
+			reVal = CI_ERROR;
 		}
+		
 	}
 
 	return reVal;
@@ -4489,7 +4483,6 @@ void DriveLogRouteSignalClose(const UINT16 wLogSignalId)
 	UINT8 sigalMaintainState = 0u;
 	UINT8 detainOpenRedBright = 0u;
 	UINT8 signalDetainFlag = 0u;
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	if ((0u == wLogSignalId) || (SIGNAL_SUM_MAX <= wLogSignalId))
 	{
 		/*不做处理*/
@@ -4497,15 +4490,11 @@ void DriveLogRouteSignalClose(const UINT16 wLogSignalId)
 	else
 	{
 		/*虚拟联锁兼容*/
-		if (FUNC_SWITCH_ON == includeVirFlag)
+		
-		{
+		belongVirCIid = GetSignalBelongVirCiId(wLogSignalId);
-			belongVirCIid = GetSignalBelongVirCiId(wLogSignalId);
+		allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCIid); /*全站亮灯标志*/
-			allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCIid); /*全站亮灯标志*/
+		
-		}
+		
-		else
-		{
-			allSignalBrightFlag = GetAllSignalBrightFlag();  /*全站亮灯标志*/
-		}
 
 		/*无论什么时候，复示信号机关闭都驱动红灭*/
 		signalIsfushiFlag = GetSignalIsfushiFlag(wLogSignalId);
@@ -5104,7 +5093,6 @@ void LogRouteErrLockFaultManage(const UINT16 wPhySectionId)
 void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 routeId)
 {
 	UINT16 routeOverlapSum = 0U;	/*进路保护区段数目*/
-	UINT16 routedLockOverlapId = 0U;	/*进路锁闭过OverlapId*/
 	UINT8 retVal = CI_SUCCESS;	/*返回值*/
 	UINT8 routeState = 0U;	/*进路状态*/
 	UINT16 preOverlepId = 0U;
@@ -5113,11 +5101,11 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 	UINT8 phySectionSta = 0U;
 	UINT8 belongCiId = 0U;
 	UINT8 localCiId = GetSystemParaLocalCiId();          /*获取本机联锁ID*/
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 virCIid = 0U;
 	UINT8 ciCtrModeFlag = 0U;
 	UINT8 routeStateFlag = 0U;
 	UINT8 flag = 0U;
+	UINT32 dwCurCycNum = Get2oo2CurCycleNum();
 
 	routeStateFlag = GetRouteStateFlag(routeId);
 
@@ -5180,14 +5168,8 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 			if (CI_SUCCESS == retVal)
 			{
 				virCIid = GetOverlapBelongVirCiId(expLkOverlapId);
-				if (FUNC_SWITCH_ON == includeVirFlag)
+				ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
-				{
+
-					ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
-				}
-				else
-				{
-					ciCtrModeFlag = GetCiModeFlag();	/*获取联锁控制模式*/
-				}
 
 				if ((CI_MODE_CI_LOCAL == ciCtrModeFlag) || (0U == ciCtrModeFlag))/*处于联锁控或者获取错误，发送现地不能响应人工锁闭命令*/
 				{
@@ -5197,54 +5179,50 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 
 			if (CI_SUCCESS == retVal)
 			{
-				routedLockOverlapId = GetRouteOverlapLockedId(routeId);	/*获取进路锁闭过保护区段ID*/
+				/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
+				routeState = GetRouteState(routeId);
 
-				if (0U == routedLockOverlapId)
+				if ((ROUTE_STATE_FIRST_XUANPAI == routeState)
+					|| (ROUTE_STATE_XUANPAI == routeState)
+					|| (ROUTE_STATE_FIRST_LOCK == routeState)
+					|| (ROUTE_STATE_FIRST_LOCKERR == routeState)
+					|| (ROUTE_STATE_YUXIAN_OPEN == routeState)
+					|| (ROUTE_STATE_YUXIAN_LOCK == routeState)
+					|| (ROUTE_STATE_NEAR_OPEN == routeState)
+					|| (ROUTE_STATE_NEAR_LOCK == routeState)
+					|| (ROUTE_STATE_NEAR_LOCKERR == routeState)
+					|| ((ROUTE_STATE_AUTO_UNLOCK == routeState) && (ROUTE_STATE_FLAG_YES == routeStateFlag))
+					)
 				{
-					/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
+					/*设置指定ID进路的期望锁闭保护区段ID*/
-					routeState = GetRouteState(routeId);
+					/*仅处理ATS办理保护区段，不处理人工办理保护区段*/
-
+					phySectionId = GetRouteLastPhySectionId(routeId);
-					if ((ROUTE_STATE_FIRST_XUANPAI == routeState)
+					phySectionSta = GetPhySecCurMergeState(phySectionId);
-						|| (ROUTE_STATE_XUANPAI == routeState)
+					if (SECTION_OCCUPY_YES == phySectionSta)
-						|| (ROUTE_STATE_FIRST_LOCK == routeState)
+					{
-						|| (ROUTE_STATE_FIRST_LOCKERR == routeState)
+						SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
-						|| (ROUTE_STATE_YUXIAN_OPEN == routeState)
-						|| (ROUTE_STATE_YUXIAN_LOCK == routeState)
-						|| (ROUTE_STATE_NEAR_OPEN == routeState)
-						|| (ROUTE_STATE_NEAR_LOCK == routeState)
-						|| (ROUTE_STATE_NEAR_LOCKERR == routeState)
-						|| ((ROUTE_STATE_AUTO_UNLOCK == routeState) && (ROUTE_STATE_FLAG_YES == routeStateFlag))
-						)
-					{/*设置指定ID进路的期望锁闭保护区段ID*/
-						/*仅处理ATS办理保护区段，不处理人工办理保护区段*/
-						phySectionId = GetRouteLastPhySectionId(routeId);
-						phySectionSta = GetPhySecCurMergeState(phySectionId);
-						if (SECTION_OCCUPY_YES == phySectionSta)
-						{
-							SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
-						}
-						else
-						{
-							/*nothing do*/
-						}
-
-						SetRouteAtsExpLkOverlapId(routeId, expLkOverlapId);/*设置期望锁闭保护区段*/
-
-						SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_YES);/*设置保护区段由进路连带标识*/
-
-						retVal = CI_SUCCESS;
 					}
 					else
 					{
-						retVal = CI_ERROR;
+						/*nothing do*/
 					}
+
+					SetRouteAtsExpLkOverlapId(routeId, expLkOverlapId);/*设置期望锁闭保护区段*/
+
+					SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_YES);/*设置保护区段由进路连带标识*/
+
+					SetOverlapAtsLastTimeLockCyc(expLkOverlapId, dwCurCycNum);
+					retVal = CI_SUCCESS;
 				}
 				else
 				{
-					;	/*当前进路保护区段已锁，不处理*/
+					retVal = CI_ERROR;
 				}
 			}
-
+			else
+			{
+				;	/*当前进路保护区段已锁，不处理*/
+			}
 		}
 
 		if (0U == flag)

TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h

@@ -628,14 +628,6 @@ void StartTrianTestManage(void);
 */
 void StopTrianTestManage(void);
 
-/*
-* 功能描述： 取消临时限速设置
-* 参数说明： 无
-* 返回值  ：
-           CI_ERROR 		 失败
-           CI_SUCCESS 		 成功
-*/
-UINT8 CancleLinShiXianSuManage(void);
 /*
 * 功能描述： 取消临时限速设置
 * 参数说明： 无
@@ -1142,12 +1134,12 @@ void LeadRouteFirstXuanPaiManage(const UINT16 routeId);
 void SetOcPscPlConfirmFlag(UINT8 setFlag, const UINT16 ocPId);
 
 /*
-* 功能描述： 保护区段照查条件更新
+* 功能描述： 保护区段状态更新
 * 参数说明： const UINT16 wRouteId 进路ID
 * 返回值  ：无
-* by cgh 20250617
+* by cgh 20250928
 */
-void OverlapZhaoChaRelayUpDateManage(void);
+void OverlapStateUpdateManage(void);
 /*
 * 功能描述： 更新列车向后跳跃允许状态处理
 * 参数说明： 无
@@ -1155,61 +1147,144 @@ void OverlapZhaoChaRelayUpDateManage(void);
 * Create: fan 20250725
 */
 void TrainJumpBackApplyProc(void);
-
 /*
-* @brief 逻辑区段禁止FAO运行处理
+* 功能描述： 办理联挂进路逻辑管理
-* @param const UINT8 setFlag 禁止FAO运行的标志
+* 参数说明： const UINT16 wRouteId
-*		 const UINT8 cLogSecSum 逻辑区段数量
+* 返回值  ： 无
-*        const UINT16 pLogSecIdBuff[] 逻辑区段序列
+* Create: 20250917
 */
-void LogSecProhibitFAOManage(const UINT8 setFlag, const UINT8 cLogSecSum, const UINT16 pLogSecIdBuff[]);
+void SetCouplinkRouteLogicManage(const UINT16 wRouteId);
 
 /*
-* 功能描述：信号机列车闯红灯处理
+* 功能描述： 锁闭道岔逻辑管理
+* 参数说明： void
+* 返回值  ：
+*/
+void lockSwitchLogicManage(void);
+/*
+* 功能描述： 计轴区段跳跃锁闭状态机管理
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+* 返回值  ： void
+* add by mpt 20260407
+*/
+void AxisJumpLockStateManage(const UINT16 axisSectionId);
+
+/*
+* 功能描述： 试车状态管理逻辑处理中获取本联锁是否具备试车功能（拆分复杂度使用）
+*参数说明：无
+* 返回值  ：CI_SUCCESS 是试车线（含合设） CI_ERROR
+*/
+UINT8 GetLocalCiIsScx(void);
+/*
+* 功能描述： 联络线进路解锁管理
+* 参数说明： const UINT16 wRouteId 进路ID
+* 返回值  ： 无
+* Create:lyj 20260603
+*/
+void ConnectRouteReleaseManage(const UINT16 wRouteId);
+
+/*
+* 功能描述: 新增一二次命令管理
+* 参数说明： 无
+* 返回值  ： void
+* BY fan 20260602
+*/
+void AtsFollowUpCmdProcess(void);
+
+/*
+* 功能描述: 道岔单解命令管理
+* 参数说明： 无
+* 返回值  ： void
+* BY fan 20260602
+*/
+void FollowUpDansuoCanclMsgProc(void);
+
+/*
+* 功能描述: 道岔单解命令状态检查,返回成功或检查失败原因
+* 参数说明：
+UINT16 wDevId命令中设备
+UINT16 wMsgType, 命令类型
+* 返回值  ：
+1 成功
+2：道岔未设置单锁
+3：道岔不属于本集中区
+5：已办理非进路调车
+* BY fan 20260603
+*/
+UINT8 FollowUpDansuoCancleCheck(UINT16 wDevId, UINT16 wMsgType);
+
+/*
+* 功能描述: 道岔解封命令管理
+* 参数说明： 无
+* 返回值  ： void
+* BY fan 20260602
+*/
+void FollowUpSwitchUnFlockMsgProc(void);
+
+/*
+* 功能描述: 道岔解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令
+* 参数说明：
+UINT16 wDevId命令中设备
+UINT16 wMsgType, 命令类型
+* 返回值  ：
+1 成功
+2：道岔未设置封锁
+3：道岔不属于本集中区
+5：已办理非进路调车
+* BY fan 20260603
+*/
+UINT8 FollowUpSwitchUnFlockCheck(UINT16 wDevId, UINT16 wMsgType);
+
+/*
+* 功能描述: 区段解封命令管理
+* 参数说明： 无
+* 返回值  ： void
+* BY fan 20260604
+*/
+void FollowUpSecUnFlockMsgProc(void);
+
+/*
+* 功能描述: 区段解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令
+* 参数说明：
+UINT16 wDevId命令中设备
+UINT16 wMsgType, 命令类型
+* 返回值  ：
+1 成功
+2：未设置人工区段封锁
+3：不属于本集中区
+* BY fan 20260604
+*/
+UINT8 FollowUpSecUnFlockCheck(UINT16 wDevId, UINT16 wMsgType);
+
+/*
+* 功能描述: 信号机解封命令管理
+* 参数说明： 无
+* 返回值  ： void
+* BY fan 20260604
+*/
+void FollowUpSignalUnFlockMsgProc(void);
+
+/*
+* 功能描述: 信号机解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令
+* 参数说明：
+UINT16 wDevId命令中设备
+UINT16 wMsgType, 命令类型
+* 返回值  ：
+1 成功
+2：未设置信号机封锁
+3：不属于本集中区
+5：所属非进路已办理
+* BY fan 20260604
+*/
+UINT8 FollowUpSignalUnFlockCheck(UINT16 wDevId, UINT16 wMsgType);
+
+/*
+* 功能描述：信号已开放进路的共享资源处理
 * 参数说明：无
 * 返 回 值：无
-* Created By LQ 2025.12.12
+* Created By LQ 2026.06.09
 */
-void SignalTrainCrossRedPro(void);
+void OpenedRouteShareResPro(void);
-
-/*
-* @brief 接触网旁路处理
-* @param const UINT16 ohlId 接触网分区ID
-*		 const UINT8 setState 旁路标志
-*/
-void OhlBypassManage(const UINT16 ohlId, const UINT8 setState);
-
-/*
-* @brief 设置逻辑区段封锁命令处理
-*		 const UINT8 cLogSecSum 逻辑区段数量
-*        const UINT16 pLogSecIdBuff[] 逻辑区段序列
-* Created By fan 2026.01.22
-*/
-void LogSecFlockCmdSetManage(const UINT8 cLogSecSum, const UINT16 pLogSecIdBuff[]);
-
-/*
-* @brief 取消逻辑区段封锁命令处理
-*		 const UINT8 cLogSecSum 逻辑区段数量
-*        const UINT16 pLogSecIdBuff[] 逻辑区段序列
-* Created By fan 2026.01.22
-*/
-void LogSecFlockCmdCancleManage(const UINT8 cLogSecSum, const UINT16 pLogSecIdBuff[]);
-
-/*
-* 功能描述：ECS自动触发命令处理
-* 参数说明：const UINT16 EcsId ECS ID
-*           const UINT8 setState 待设置的状态
-* 返 回 值：无
-* Created By LQ 2026.01.26
-*/
-void EcsAutoTrigCmdPro(const UINT16 EcsId, const UINT8 setState);
-
-/*
-* 功能描述：道岔常态位置逻辑处理
-* 参数说明：const UINT16 EcsId ECS ID
-* 返 回 值：无
-*/
-void SwitchNormalPosProc(void);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/LogicManage/RouteRecoverManage.c

@@ -189,10 +189,7 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
 	UINT8 routeReverseProperty = 0u;
 	UINT8 airShaftRouteType = 0u;
-	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
+	UINT8 chRouteCouplinkFlag = 0U;
-
-	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
-
 	/* 联锁逻辑检查 */
 	/* 进路监督模式为【CBTC】*/
 	
@@ -328,24 +325,36 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	{
 		routeReverseProperty = GetRouteReverseProperty(routeId);
 		airShaftRouteType =  GetAirShaftRouteType(routeId);
-		if ((ROUTE_REVERSE_PROPERTY_YES == routeReverseProperty) || (ROUTE_TYPE_AIRSHAFT == airShaftRouteType))
+		chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
-		{  /*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
+		if ((ROUTE_REVERSE_PROPERTY_YES == routeReverseProperty)|| (ROUTE_TYPE_AIRSHAFT == airShaftRouteType))
-			/*风井进路不允许追踪办理，故开放条件需增加对进路内方所有区段的占用状态检查*/
+		{ 
-			devId = 0u;
+			if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
-			devState = 0u;
-			checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
-			if (checkResult == CI_SUCCESS)
 			{
-				/* 通过检查 */
+				/* 反向联挂进路允许追踪，区段条件在OpenCbtcRouteSectionErrCheck */
-				reResult = CI_SUCCESS;
+				/*存在联挂标志，不在查反向进路全部空闲，其他条件检查;风井进路设置不上联挂标志所以需要检查全部区段空闲*/
 			}
 			else
 			{
-				/* 记录故障码 */
+				/*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
-				SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel); 
+			
-				/* 失败返回 */
+				/*风井进路不允许追踪办理，故开放条件需增加对进路内方所有区段的占用状态检查*/
-				reResult = CI_ERROR;
+				devId = 0u;
+				devState = 0u;
+				checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+				if (checkResult == CI_SUCCESS)
+				{
+					/* 通过检查 */
+					reResult = CI_SUCCESS;
+				}
+				else
+				{
+					/* 记录故障码 */
+					SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
+					/* 失败返回 */
+					reResult = CI_ERROR;
+				}
 			}
+			
 			/* 防护进路联锁条件检查 */
 			if (CI_SUCCESS == reResult)
 			{
@@ -504,37 +513,6 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	{
 	    ;
 	}
-
-	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
-	{
-		/*迪士尼联络线其他联锁条件检查*/
-		checkResult = DsnConnectOtherCiValidCheck(routeId);
-		if (CI_ERROR == checkResult)
-		{
-			reResult = checkResult;
-		}
-		else
-		{
-			/*nothing*/
-		}
-	}
-	else
-	{
-		/*nothing*/
-	}
-
-	if ((CI_ERROR == reResult)
-		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr)
-			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
-	{
-		/*始端不在本线的迪士尼联络线进路，自动重开*/
-		reResult = CI_ROUTE_RECOVER_ERR;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
 	return reResult;
 }
 
@@ -557,16 +535,16 @@ UINT8 OpenBlocLTrainRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
 	UINT8 devState = 0u;                 /*设备状态*/
+	UINT16 devId = 0u;                 /*设备ID*/
 
-	/* 取消标志 */
+
+										/* 进路内设备数据 */
+										/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
 
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
-	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
-
-	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 
 	/* 联锁逻辑检查 */
 	/* 进路监督模式为【点式】*/
@@ -768,37 +746,6 @@ UINT8 OpenBlocLTrainRouteErrProcess(const UINT16 routeId)
 			reResult = checkResult;
 		}
 	}
-
-	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
-	{
-		/*迪士尼联络线其他联锁条件检查*/
-		checkResult = DsnConnectOtherCiValidCheck(routeId);
-		if (CI_ERROR == checkResult)
-		{
-			reResult = checkResult;
-		}
-		else
-		{
-			/*nothing*/
-		}
-	}
-	else
-	{
-		/*nothing*/
-	}
-
-	if ((CI_ERROR == reResult)
-		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr)
-			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
-	{
-		/*始端不在本线的迪士尼联络线进路，自动重开*/
-		reResult = CI_ROUTE_RECOVER_ERR;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
 	/* 返回 */
 	return reResult;
 }
@@ -828,7 +775,7 @@ UINT8 OpenCbtcReturnRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 										/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
-
+	UINT8 chRouteCouplinkFlag = 0U;
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
 
@@ -965,8 +912,16 @@ UINT8 OpenCbtcReturnRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	{
 		devId = 0u;
 		devState = 0u;
-		checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+		chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
-		if (checkResult == CI_SUCCESS)
+		if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+		{
+			checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+		}
+		else
+		{
+			checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+		}
+		if (CI_SUCCESS == checkResult)
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
@@ -1161,6 +1116,7 @@ UINT8 OpenBlocReturnRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
 	UINT8 devState = 0u;                 /*设备状态*/
+	UINT8 devId = 0u;                 /*设备Id*/
 
 										/* 进路内设备数据 */
 										/* 取消标志 */
@@ -1169,6 +1125,8 @@ UINT8 OpenBlocReturnRouteErrProcess(const UINT16 routeId)
 
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
+	UINT16 endSigId = 0u;				/*获取中途折返信号机ID*/
+	UINT8 endSigState = SIGNAL_OPEN;
 
 	/* 联锁逻辑检查 */
 
@@ -1408,9 +1366,7 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
 	UINT16 trainEnteringRouteState = 0u;
 	UINT8 signalCrossState = 0u;
 	UINT8 rcWorkMode = 0U; /*rc工作模式*/
-	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
+	UINT8 chRouteCouplinkFlag = 0U;
-
-	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 	rcWorkMode = GetLocalRcWorkMode();
 	/* 联锁逻辑检查 */
 
@@ -1536,7 +1492,16 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
 		{  /*反向进路或风井进路需对进路内方所有区段的占压状态进行检查*/
 			devId = 0u;
 			devState = 0u;
-			checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
+			chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+			if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+			{
+				checkResult = KeepCouplinkRouteSecOccCheck(routeId, &devId, &devState);;
+			}
+			else
+			{
+				checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+			}
+			
 			if (checkResult == CI_SUCCESS)
 			{
 				/* 通过检查 */
@@ -1662,36 +1627,6 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
 		}
 	}
 
-	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
-	{
-		/*迪士尼联络线其他联锁条件检查*/
-		checkResult = DsnConnectOtherCiValidCheck(routeId);
-		if (CI_ERROR == checkResult)
-		{
-			reResult = checkResult;
-		}
-		else
-		{
-			/*nothing*/
-		}
-	}
-	else
-	{
-		/*nothing*/
-	}
-
-	if ((CI_ERROR == reResult)
-		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr)
-			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
-	{
-		/*始端不在本线的迪士尼联络线进路，自动重开*/
-		reResult = CI_ROUTE_RECOVER_ERR;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
 	/* 返回 */
 	return reResult;
 }
@@ -1711,16 +1646,17 @@ UINT8 KeepBlocLTrainRouteErrProcess(const UINT16 routeId)
 	UINT8 const functionId = EFUNC_KEEP_UT_SIGNAL_ERR_ZX;
 
 	/* 局部变量定义初始化 */
-	UINT8 reResult = CI_ERROR;					/*返回值*/
+	UINT8 reResult = CI_ERROR;          /*返回值*/
-	UINT8 checkResult = CI_ERROR;				/*检查结果*/
+	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
-	UINT8 devState = 0u;						/*设备状态*/
+	UINT8 devState = 0u;                 /*设备状态*/
-	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
+	UINT16 devId = 0u;                   /*设备ID*/
-	/* 取消标志 */
+
+										/* 进路内设备数据 */
+										/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
 
-	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
 
@@ -1917,36 +1853,6 @@ UINT8 KeepBlocLTrainRouteErrProcess(const UINT16 routeId)
 		}
 	}
 
-	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
-	{
-		/*迪士尼联络线其他联锁条件检查*/
-		checkResult = DsnConnectOtherCiValidCheck(routeId);
-		if (CI_ERROR == checkResult)
-		{
-			reResult = checkResult;
-		}
-		else
-		{
-			/*nothing*/
-		}
-	}
-	else
-	{
-		/*nothing*/
-	}
-
-	if ((CI_ERROR == reResult)
-		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr) 
-			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
-	{
-		/*始端不在本线的迪士尼联络线进路，自动重开*/
-		reResult = CI_ROUTE_RECOVER_ERR;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
 	/* 返回 */
 	return reResult;
 }
@@ -1980,6 +1886,7 @@ UINT8 KeepCbtcReturnRouteErrProcess(const UINT16 routeId)
 	UINT8 trainEnteringRouteState =0u;
 	UINT8 signalCrossState = 0u;
 	UINT8 rcWorkMode = 0U; /*rc工作模式*/
+	UINT8 chRouteCouplinkFlag = 0U;
 	rcWorkMode = GetLocalRcWorkMode();
 	devState = GetRouteLevel(routeId);
 	if (ROUTE_LEVEL_CBTC == devState)
@@ -2115,7 +2022,16 @@ UINT8 KeepCbtcReturnRouteErrProcess(const UINT16 routeId)
 		}
 		else if(RC_WORK_MODE_CI == rcWorkMode)
 		{
-			checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+			chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+			if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+			{
+				checkResult = KeepCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+			}
+			else
+			{
+				checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+			}
+			
 			if (CI_SUCCESS == checkResult)
 			{
 				/* 通过检查 */
@@ -2266,8 +2182,10 @@ UINT8 KeepBlocReturnRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
 	UINT8 devState = 0u;                 /*设备状态*/
+	UINT16 devId = 0u;                   /*设备ID*/
 
-	/* 取消标志 */
+										/* 进路内设备数据 */
+										/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
 
@@ -3181,9 +3099,15 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 	UINT8  devState = 0u;
 	UINT8 ret = CI_SUCCESS;
 
+	/*进路始端信号机关联的PSD*/
+	UINT16 rtStartSigId = 0u;/*进路始端信号机ID*/
+	UINT8 psdSum = 0u;/*进路始端信号机关联的PSD数量*/
+	UINT16 *psdIdBuf = NULL;/*进路始端信号机关联的PSD ID数组*/
+	UINT16 j = 0u;/*遍历进路始端信号机关联的PSD ID数组的下标*/
 	UINT8 toOpenCheckFlag = 0u;/*恢复可重开信号的条件标志*/
 	UINT8 otherResult = 0u;/*其他联锁检查条件返回值*/
 	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
+	UINT8 cPsdExceptOpenState = 0U;  /*PSD异常打开状态*/
 
 	if (routeLevel == ROUTE_LEVEL_BLOC)
 	{
@@ -3205,13 +3129,17 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 	/* 开始检查 */
 	if ((0u != checkSum) && (NULL != dataOtherCiDevBuf))
 	{
+		rtStartSigId = GetRouteStartSignalId(routeId);/*获得进路始端信号机*/
+		psdSum = GetSignalRelatedPsdSum(rtStartSigId);/*获得进路始端信号机关联的PSD数量*/
+		psdIdBuf = GetSignalRelatedPsdBuf(rtStartSigId);/*获得进路始端信号机关联的PSD ID数组*/
+
 		/*开始检查*/
 		for (i = 0u; i < checkSum; i++)
 		{
 			tmpOtherCiDevInfo = &dataOtherCiDevBuf[i];
 
 			toOpenCheckFlag = 0u;/*默认为恢复不可重开*/
-			/*判断检查条件为SPKS或是进站、出战关联的PSD*/
+								/*判断检查条件为SPKS或是本信号机关联的PSD*/
 			if (CI_DEVICE_TYPE_SPKS == tmpOtherCiDevInfo->DevType)
 			{
 				cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
@@ -3227,11 +3155,25 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 			}
 			else if (CI_DEVICE_TYPE_PSD == tmpOtherCiDevInfo->DevType)
 			{
-				toOpenCheckFlag = 1U;
+				if ((NULL != psdIdBuf) && (0u < psdSum))
-			}
+				{
-			else if (CI_DEVICE_TYPE_ESB == tmpOtherCiDevInfo->DevType)
+					for (j = 0u;j < psdSum;j++)
-			{
+					{
-				toOpenCheckFlag = 1U;
+						if (psdIdBuf[j] == tmpOtherCiDevInfo->DevId)
+						{
+							cPsdExceptOpenState = GePsdExceptState(tmpOtherCiDevInfo->DevId);
+							if (PSD_EXCEPT_NO == cPsdExceptOpenState)
+							{
+								toOpenCheckFlag = 1U;  /*PSD未异常，设置可自动重开*/
+							}
+							else
+							{
+								toOpenCheckFlag = 0U;  /*存在PSD异常，停止遍历，设置不可自动重开*/
+								break;
+							}
+						}
+					}
+				}
 			}
 			else
 			{
@@ -3282,13 +3224,10 @@ static UINT8 RouteSecFLockErrCheck(UINT16 const routeId)
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8 ret = CI_SUCCESS;
-	UINT8 cRouteFlockCheck = CI_ERROR;  /*封锁检查*/
+	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;/*物理区段封锁类型变量*/
-	UINT8 chFlockType = 0U;/*区段封锁类型*/
+	UINT8 cRouteLevel = ROUTE_LEVEL_BLOC;  /*进路级别*/
-	UINT8 chPassFlockType = SEC_FLOCK_CBTCLASTSEC_PASS;/*不检查的类型*/
+	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
-	UINT8 chPassLastFlock = ROUTE_PASS_LAST_FLOCK_NO;/*跳过最后区段配置*/
+
-	UINT8 	chRouteLevel = 0U;/*进路等级*/
-	chRouteLevel = GetRouteLevel(routeId);
-	chPassLastFlock = GetRoutePassLastFlockProperty(routeId);
 	if (0u == checkSum) 
 	{
 		/*区段数据错误*/
@@ -3301,31 +3240,40 @@ static UINT8 RouteSecFLockErrCheck(UINT16 const routeId)
 		{
 			devId = dataIdBuf[i].PhysicalSectionId;
 			devState = GetPhySecFLockState(devId);
-			chFlockType = GetPhySecFLockType(devId);
 
 			/* 状态如果不是未封锁状态，则认为检查失败 */
 			if (PHYSICAL_SECTION_FLOCK_NO == devState)
 			{
 				/*不处理*/
 			}
-			else if ((ROUTE_LEVEL_CBTC == chRouteLevel)
-				&& (ROUTE_PASS_LAST_FLOCK_YES == chPassLastFlock)
-				&& ((checkSum - 1U) == i)
-				&& (chPassFlockType == (chPassFlockType | chFlockType)))
-			{
-				;/*CBTC进路最后区段 具备不检查ESB/APG/SPKS封锁属性/*/
-			}
 			else if (PHYSICAL_SECTION_FLOCK_YES ==devState )
 			{
-				cRouteFlockCheck = SectionFlockReOpenCheck(devId, routeId);
+				fLockType = GetPhySecFLockType(devId);/*获得物理区段封锁类型*/
-				if ((CI_SUCCESS == cRouteFlockCheck)&&(CI_ERROR != ret))
+
+				if (PHY_SEC_FLOCK_TYPE_SPKS == fLockType)
 				{
-					ret = CI_ROUTE_RECOVER_ERR;
+					if (CI_ERROR != ret)
+					{
+						cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
+						cRouteLevel = GetRouteLevel(routeId);
+						if ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel)))
+						{
+							/*SPKS信号重开检查进路级别开关打开或（关闭且进路级别为CBTC）*/
+							ret = CI_ROUTE_RECOVER_ERR;
+						}
+						else
+						{
+							ret = CI_ERROR;
+						}
+					}
+					else
+					{
+					    ;
+					}
 				}
 				else
 				{
 					ret = CI_ERROR;
-					break;
 				}
 			}
 			else
@@ -3357,7 +3305,10 @@ static UINT8 OverlapAllSecFLockValidErrCheck(UINT16 const overlapId)
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8 ret = CI_SUCCESS;
-	UINT8 fLockOpenCheck = CI_ERROR;/*物理区段封锁类型变量*/
+
+	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;/*物理区段封锁类型变量*/
+	UINT8 cRouteLevel = ROUTE_LEVEL_BLOC;  /*进路级别*/
+	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
 	UINT16 wBelongRouteId = 0U;  /*保护区段锁闭所属进路*/
 
 	if ((0U != overlapId) && (OVERLAP_SUM_MAX != overlapId))
@@ -3379,12 +3330,29 @@ static UINT8 OverlapAllSecFLockValidErrCheck(UINT16 const overlapId)
 				}
 				else if (PHYSICAL_SECTION_FLOCK_YES == devState)
 				{
-					wBelongRouteId = GetOverlapBelongRouteId(overlapId);
+					fLockType = GetPhySecFLockType(devId);/*获得物理区段封锁类型*/
-					fLockOpenCheck = SectionFlockReOpenCheck(devId, wBelongRouteId);/*获得物理区段封锁重开检查*/
 
-					if ((CI_ERROR != fLockOpenCheck)&&(CI_ERROR != ret))
+					if (PHY_SEC_FLOCK_TYPE_SPKS == fLockType)
 					{
-						ret = CI_ROUTE_RECOVER_ERR;
+						wBelongRouteId = GetOverlapBelongRouteId(overlapId);
+						if ((CI_ERROR != ret) && (CI_ERROR != wBelongRouteId))
+						{							
+							cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
+							cRouteLevel = GetRouteLevel(wBelongRouteId);
+							if ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel)))
+							{
+								/*SPKS信号重开检查进路级别开关打开或（关闭且进路级别为CBTC）*/
+								ret = CI_ROUTE_RECOVER_ERR;
+							}
+							else
+							{
+								ret = CI_ERROR;
+							}
+						}
+						else
+						{
+							;
+						}
 					}
 					else
 					{
@@ -3665,6 +3633,9 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 	/*防护进路*/
 	UINT8 const overlapSum = GetRouteOverlapSum(routeId);
 	UINT16 const overlapId = GetRouteOverlapLockedId(routeId);
+	UINT8 cSndSideProFuncSwitch = 0U;
+
+	cSndSideProFuncSwitch = GetSndSideProtectFuncSwitch();  /*二级侧防功能开关*/
 
 	UINT8 lineIdentity = CI_TRADITION_RAILWAY;
     
@@ -3708,7 +3679,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 			}
 		}
 
-		if(CI_TRADITION_RAILWAY == lineIdentity)
+		if (CI_TRADITION_RAILWAY == lineIdentity)
 		{
 			/*保护区段道岔【位置正确】*/
 			if (CI_SUCCESS == reResult)
@@ -3727,12 +3698,11 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 					reResult = CI_ERROR;
 				}
 			}
-
-
 		}
 		else
 		{
 			/* zt 删除单轨相关代码 2022-02-15 */
+			reResult = CI_ERROR;
 		}
 
 		/*保护区段 内所有道岔【未封锁】*/
@@ -3772,11 +3742,11 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		}
 
 		/*保护区段关联防护道岔【位置正确】*/
-		if(CI_SUCCESS == reResult)
+		if (CI_SUCCESS == reResult)
 		{
 			devId = 0u;
 			devState = 0u;
-			checkResult = OvlpRelatedProtSwitchPosCheck(overlapId,&devId,&devState);
+			checkResult = OvlpRelatedProtSwitchPosCheck(overlapId, &devId, &devState);
 			if (checkResult == CI_SUCCESS)
 			{
 				/* 通过检查 */
@@ -3794,7 +3764,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		{
 			devId = 0u;
 			devState = 0u;
-			checkResult = OvlpRelatedProtSwitchLockCheck(overlapId,&devId, &devState);
+			checkResult = OvlpRelatedProtSwitchLockCheck(overlapId, &devId, &devState);
 			if (checkResult == CI_SUCCESS)
 			{
 				/* 通过检查 */
@@ -3807,7 +3777,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 			}
 		}
 
-
 		if (CI_SUCCESS == reResult)
 		{
 			/*检查进路侵限条件状态*/
@@ -3823,13 +3792,21 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		/*保护区段侧防条件检查*/
 		if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
 		{
-			/*检查保护区段侧防道岔区段状态*/
+			if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
-			devId = 0u;
-			devState = 0u;
-			checkResult = OverlapLateralDfnCheck(overlapId, &devId, &devState);
-			if (CI_ERROR == checkResult)
 			{
-				reResult = checkResult;
+				/*仅在二级侧防开关配置为支持二级侧防时才进行侧防条件检查*/
+				/*检查保护区段侧防道岔区段状态*/
+				devId = 0u;
+				devState = 0u;
+				checkResult = OlapSideProtectConditionCheck(overlapId, 0U, 0U);
+				if (CI_ERROR == checkResult)
+				{
+					reResult = checkResult;
+				}
+			}
+			else
+			{
+				/*不处理*/
 			}
 		}
 
@@ -3849,7 +3826,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		{
 			devId = 0u;
 			devState = 0u;
-			checkResult = OverlapAllSecJumpLockStateCheck(overlapId,&devId,&devState);
+			checkResult = OverlapAllSecJumpLockStateCheck(overlapId, &devId, &devState);
 			if (CI_ERROR == checkResult)
 			{
 				reResult = checkResult;
@@ -3870,7 +3847,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		{
 			devId = 0u;
 			devState = 0u;
-			checkResult = OverlapFloodGateStateCheck(overlapId,&devId,&devStateType,&devState);
+			checkResult = OverlapFloodGateStateCheck(overlapId, &devId, &devStateType, &devState);
 			if (CI_ERROR == checkResult)
 			{
 				reResult = checkResult;
@@ -4195,12 +4172,15 @@ static UINT8 KeepCbtcRouteSectionErrCheck(const UINT16 routeId)
 	UINT8 preLogDevState = 0u;			/*之前逻辑区段占用状态*/
 	UINT8 LogSecCurCtOrUtOcc = 0U;		/*逻辑区段当前占用状态*/
 	UINT8 cLocalCiType = 0U;  /*本控区类型*/
+	UINT8 chRouteBelongVirCiId = 0U;
 
 	rcWorkMode = GetLocalRcWorkMode();
 
 	/* 联锁逻辑检查 */
 	reResult = CI_SUCCESS;
 	cLocalCiType = GetLocalCiType();
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	cLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 	if (CI_TYPE_CLD != cLocalCiType)
 	{
 		/*非车辆段，按CBTC既有逻辑处理*/
@@ -4304,28 +4284,6 @@ static UINT8 KeepCbtcRouteSectionErrCheck(const UINT16 routeId)
 	
 #endif
 
-	if (CI_SUCCESS == reResult)
-	{
-		/*CBTC通过进路需再检查数据中配置的逻辑区段的占用状态*/
-		devId = 0U;
-		devState = 0U;
-		checkResult = RouteCbtcKeepOpenLgcOccCheck(routeId, &devId, &devState);
-		if (CI_SUCCESS == checkResult)
-		{
-			/* 通过检查 */
-			reResult = CI_SUCCESS;
-		}
-		else
-		{
-			/* 失败返回 */
-			reResult = CI_ERROR;
-		}
-	}
-	else
-	{
-		/*非列车进路或已经检查失败，不处理*/
-	}
-
 	/* 进路内所有区段未被封锁 */
 	if (CI_SUCCESS == reResult)
 	{
@@ -4368,11 +4326,14 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	UINT8 functionId = EFUNC_OPENROUTESECTIONERRCHECK;
 	UINT8 rcWorkMode = 0U;
 	UINT8 cLocalCiType = 0U;  /*本控区类型*/
-
+	UINT8 chRouteCouplinkFlag = 0U;
+	UINT8 chSigCrossState = 0U;
+	UINT8 chRouteBelongVirCiId = 0U;
 	rcWorkMode = GetLocalRcWorkMode();
 
 	/* 联锁逻辑检查 */
-	cLocalCiType = GetLocalCiType();
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	cLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 	if (CI_TYPE_CLD != cLocalCiType)
 	{
 		/*非车辆段，按CBTC既有逻辑处理*/
@@ -4395,16 +4356,30 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 		}
 		else if (RC_WORK_MODE_CI == rcWorkMode)
 		{/*CI*/
-
-			/* 进路始端信号机【未跨压】且内方第一逻辑区段【空闲】*/
 			startSignalId = GetRouteStartSignalId(routeId);
-			devId = GetRouteInFirstLogSecId(routeId);
+			chSigCrossState = GetSignalCrossState(startSignalId);
-			devState = GetLogSecCurOccupyState(devId);
+			if (SIGNAL_CROSS_STATE_NO == chSigCrossState)
-			if ((GetSignalCrossState(startSignalId) == SIGNAL_CROSS_STATE_NO) &&
-				(devState == SECTION_OCCUPY_NO))
 			{
-				/* 通过检查 */
+				chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
-				reResult = CI_SUCCESS;
+				if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+				{
+					/*联挂进路区段占用检查*/
+					reResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+				}
+				else
+				{
+					devId = GetRouteInFirstLogSecId(routeId);
+					devState = GetLogSecCurOccupyState(devId);
+					if (SECTION_OCCUPY_NO == devState)
+					{
+						/* 通过检查 */
+						reResult = CI_SUCCESS;
+					}
+					else
+					{
+						reResult = CI_ERROR;
+					}
+				}
 			}
 			else
 			{
@@ -4445,29 +4420,6 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	    ;
 	}
 
-	if (CI_SUCCESS == reResult)
-	{
-		/*CBTC通过进路需再检查数据中配置的逻辑区段的占用状态*/
-		devId = 0U;
-		devState = 0U;
-		checkResult = RouteCbtcLogSecOccCheck(routeId, &devId, &devState);
-		if (CI_SUCCESS == checkResult)
-		{
-			/* 通过检查 */
-			reResult = CI_SUCCESS;
-		}
-		else
-		{
-			/* 失败返回 */
-			reResult = CI_ERROR;
-		}
-	}
-	else
-	{
-		/*非列车进路或已经检查失败，不处理*/
-	}
-
-
 /*使用新增的函数RouteIntruSecVainSPKSErrCheck*/
 #if 0
 	/*侵限区段侵限条件不满足检查*/
@@ -4509,7 +4461,7 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	}
 #endif
 	/* 进路内所有区段未被封锁 */
-	if (CI_SUCCESS == reResult)
+	if (checkResult == CI_SUCCESS)
 	{
 		checkResult = RouteSecFLockErrCheck(routeId);
 		if ((CI_ERROR == checkResult) || (CI_ROUTE_RECOVER_ERR == checkResult))
@@ -4664,8 +4616,10 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 	UINT8 devJumpLockState = 0U;
 	UINT8 intruSwitchPosValid = CI_ERROR;
 	UINT8 reVal = CI_ERROR;
-	UINT8 fLockOpenCheck = CI_ERROR;/*物理区段封锁检查*/
+	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;/*物理区段封锁类型变量*/
 	UINT8 checkFlockFlag = GetCiFunctionSwitchConfig(FUNC_INTRUSEC_CHECKFLOCK_FLAG);
+	UINT8 cFuncSwitchSpks = 0U; /*SPKS自动信号重开是否检查进路级别开关*/
+	UINT8 cRouteLevel = 0U;
 	UINT8 chPhySecLogLockState = 0U;/*物理区段逻辑锁闭状态*/
 
 	/* 检查侵限状态 */
@@ -4678,16 +4632,21 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 	{
 		/*开始检查*/
 		reVal = CI_SUCCESS;/*先将返回值设置成功，若侵限成立则会修改函数返回值为CI_ERROR或CI_ROUTE_RECOVER_ERR*/
+		cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
+		cRouteLevel = GetRouteLevel(routeId);
 
 		for (i = 0u; i < checkSum; i++)
 		{
 			devId = dataIdBuf[i].SectionId;
 			devState = GetPhySecCurMergeState(devId);/*获取物理区段占用状态*/
 			devFLockState = GetPhySecFLockState(devId);/*获取物理区段封锁状态*/
+			fLockType = GetPhySecFLockType(devId);/*获取物理区段封锁类型*/
 			devLockState = GetPhySecLockState(devId);
 			devJumpLockState = GetPhySecJumpLockState(devId);
 			chPhySecLogLockState = PhySecLogLockStateCheck(devId);
 
+
+
 			/* 检查侵限区段是否占用或封锁*/
 			if ((SECTION_OCCUPY_YES == devState)
 				|| ((PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (FUNC_SWITCH_ON != checkFlockFlag))
@@ -4724,11 +4683,10 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 					if (CI_ERROR == intruSwitchPosValid)
 					{
 						/*有岔侵限条件成立*/
-						fLockOpenCheck = SectionFlockReOpenCheck(devId, routeId);
 						if ((PHYSICAL_SECTION_JUMP_LOCK_YES != devJumpLockState) && (PHYSICAL_SECTION_LOCK_NO == devLockState) && (SECTION_OCCUPY_YES != devState)
-							&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
+							&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (PHY_SEC_FLOCK_TYPE_SPKS == fLockType) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
-							&& (CI_SUCCESS==fLockOpenCheck))
+							&& ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel))))
-						{/*侵限区段未占用且封锁且是由于可重开的封锁（spks或全线封锁），在恢复后可自动重开*/
+						{/*侵限区段未占用且封锁且是由于SPKS按下导致的封锁且(SPKS自动重开开关打开或关闭但进路为CBTC)，在SPKS恢复后可自动重开*/
 							reVal = CI_ROUTE_RECOVER_ERR;
 						}
 						else
@@ -4739,11 +4697,10 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 				}
 				else
 				{
-					fLockOpenCheck = SectionFlockReOpenCheck(devId, routeId);
 					if ((PHYSICAL_SECTION_JUMP_LOCK_YES != devJumpLockState) && (PHYSICAL_SECTION_LOCK_NO == devLockState) && (SECTION_OCCUPY_YES != devState)
-						&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
+						&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (PHY_SEC_FLOCK_TYPE_SPKS == fLockType) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
-						&& (CI_SUCCESS == fLockOpenCheck))
+						&& ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel))))
-					{/*侵限区段未占用且封锁且是由于可重开的封锁（spks或全线封锁），在恢复后可自动重开恢复后可自动重开*/
+					{/*侵限区段未占用且封锁且是由于SPKS按下导致的封锁且(SPKS自动重开开关打开或关闭但进路为CBTC)，在SPKS恢复后可自动重开*/
 						reVal = CI_ROUTE_RECOVER_ERR;
 					}
 					else
@@ -4786,6 +4743,8 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 	UINT8 thisRelayState = 0U;
 	UINT8 routeState = 0U;
 	UINT8 retVal = CI_ERROR;                      /*函数返回值*/
+	UINT16 pDevId = 0U;
+	UINT8 pDevState = 0U;
 	UINT8 chErrTemp = 0U;
 
 	/* 对端照查检查 */
@@ -4909,13 +4868,15 @@ UINT8 RoutePhySecZhaoChaErrCheck(UINT16 const routeId ,UINT16 const phySecId)
 	UINT8 secLockedDirection = 0u;                    /*区段锁闭方向*/
 	UINT8 routeDirection = 0u;                        /*进路方向*/
 	UINT8 retVal = CI_ERROR;                         /*函数返回值*/
-	UINT8 fLockOpenCheck = CI_ERROR;       /*物理区段封锁重开检查*/
+	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;       /*物理区段封锁类型变量*/
 	UINT8 phyBelongCi = 0u;                          /*物理区段所属联锁*/
 	UINT8 commState = 0u;                            /*通信状态*/
 	                                                 /*相邻联锁是否支持继电接口*/
 	UINT8 funcSwitchSupportRelayInterface = GetCiFunctionSwitchConfig(FUNC_SWITCH_USE_RELAY_INTERFACE_BETWEEN_NEIGHBOURCI);
 	UINT8 localCi = GetSystemParaLocalCiId();        /*本机联锁*/
 	UINT8 confirmRelayInterfaceFlag = GetCiCiRelayInterfConfirmFlag();/*继电接口确认状态*/
+	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号自动重开开关，0x55检查进路级别，0xaa不检查*/
+	UINT8 cRouteLevel = 0U;
 
 	if ((0U == routeId ) || (0U == phySecId))
 	{
@@ -4973,10 +4934,12 @@ UINT8 RoutePhySecZhaoChaErrCheck(UINT16 const routeId ,UINT16 const phySecId)
 			}
 			else if (PHYSICAL_SECTION_FLOCK_YES == secFlockState)
 			{
-				fLockOpenCheck = SectionFlockReOpenCheck(phySecId, routeId);/*物理区段封锁重开检查*/
+				fLockType = GetPhySecFLockType(phySecId);/*获得物理区段封锁类型*/
-				if (CI_SUCCESS == fLockOpenCheck)
+				cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
+				cRouteLevel = GetRouteLevel(routeId);
+				if ((PHY_SEC_FLOCK_TYPE_SPKS == fLockType) && ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel))))
 				{
-					retVal = CI_ROUTE_RECOVER_ERR;  /* 区段封锁且是可重开封锁类型导致封锁，在封锁恢复后可自动重开*/
+					retVal = CI_ROUTE_RECOVER_ERR;  /* 状态如果SPKS导致的封锁且SPKS自动重开开关打开或关闭但进路为CBTC，则可以恢复重开*/
 				}
 				else
 				{

TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.c

@@ -229,6 +229,7 @@ void NonRouteLogicProcess(void)
 		{ 
 			NonRouteCancelDeal(pNonRoute->NonRouteId); /*非进路取消处理*/
 		}
+
 	}
 }
 
@@ -240,22 +241,42 @@ void NonRouteLogicProcess(void)
 */
 void NonRouteXuanPaiDeal(UINT8 nonRouteId)
 {
+	UINT8 reResult = CI_ERROR;
 	NonRouteDataStruct *pNonRoute = GetNonRouteDataById(nonRouteId);
-	if (CI_SUCCESS == LockNonRouteP(nonRouteId))
+	reResult = LockNonRouteP(nonRouteId);
+	if (CI_SUCCESS == reResult)
 	{ /*锁闭成功*/
+		reResult = CheckNonRouteSwitchPosRight(nonRouteId, 0U, 0U);
+        if (CI_SUCCESS == reResult)
+		{ 
+			/*进路道岔位置正确*/
+			/*侵限区段侵限条件不满足检查*/
+			reResult = NonRouteIntruSecVainCheck(nonRouteId, EFUNC_CLD_LOCK_NONROUTE, ESEND_LEVEL_ATS);
+			if (CI_SUCCESS == reResult)
+			{
+				SetNonRouteStateDeal(nonRouteId, NONROUTE_STATE_LOCK); /*设置非进路为锁闭*/
+			}
+			else
+			{
+				SetNonRouteStateDeal(nonRouteId, NONROUTE_STATE_IDLE); /*设置非进路为空闲*/
+				/* NonRouteIntruSecVainCheck函数已经有故障码，不再记录*/
+			}
+	
 			
-        if (CI_SUCCESS == CheckNonRouteSwitchPosRight(nonRouteId,0u,0u))
-		{ /*进路道岔位置正确*/
-			SetNonRouteStateDeal(nonRouteId,NONROUTE_STATE_LOCK); /*设置非进路为锁闭*/
 		}
 		else
 		{ /*道岔未动作到位*/
 		
             /*非进路锁闭驱动道岔*/
-		    if (CI_ERROR == NonRouteLockDrvSwitchDeal(nonRouteId))
+			reResult = NonRouteLockDrvSwitchDeal(nonRouteId);
+		    if (CI_SUCCESS == reResult)
 		    {
-                SetNonRouteStateDeal(nonRouteId,NONROUTE_STATE_IDLE); /*设置非进路为空闲*/
+				/*继续驱动道岔*/
 		    }
+			else
+			{
+				SetNonRouteStateDeal(nonRouteId, NONROUTE_STATE_IDLE); /*设置非进路为空闲*/
+			}
 
 		}
     }
@@ -3787,7 +3808,7 @@ void SetSwitchPositionM(const UINT16 switchId, const UINT8 switchSetPos)
 	if (CI_SUCCESS == check_Result)
 	{/*单操位置有效*/
 		/*单操道岔处理*/
-		if (CI_SUCCESS == SetSwitchPositionLogicProcess(switchId, switchSetPos, 0u, &chTemp, ESEND_LEVEL_ATS))
+		if (CI_SUCCESS == SetSwitchPositionLogicProcess(switchId, switchSetPos, 0u, &chTemp))
 		{ /*检查通过*/
 
 			(void)SetSwitchDanCaoPosition(switchId, switchSetPos); /*设置单操位置标志*/
@@ -6026,6 +6047,8 @@ void DTrainReturnUnlockP(void)
 	UINT16 routeId = 0u;	         /*进路ID*/
 	UINT8 belongCiId = 0u;        /*进路所属联锁ID*/
 	UINT16 ii = 0u;               /*循环索引*/
+	UINT8 belongVirCIid = 0U;
+	UINT8 chLocalVirCiType = 0U;
 	
 	
 	routeCurSum = GetRouteCurSum();		        /*获取进路总数*/
@@ -6047,9 +6070,13 @@ void DTrainReturnUnlockP(void)
 		{
 			continue;
 		}
-
+		belongVirCIid = GetRouteBelongVirCiId(routeId);
-		/*调车中途折返进路完整锁闭处理*/
+		chLocalVirCiType = GetLocalVirCiType(belongVirCIid);
-        DTrainReturnUnlockRouteAllLockP(routeId);
+		if (CI_TYPE_CLD == chLocalVirCiType)
+		{
+			/*调车中途折返进路完整锁闭处理*/
+			DTrainReturnUnlockRouteAllLockP(routeId);
+		}
 	}
 
 	/*处理调车中途折返*/
@@ -6068,9 +6095,13 @@ void DTrainReturnUnlockP(void)
 		{
 			continue;
 		}
-
+		belongVirCIid = GetRouteBelongVirCiId(routeId);
-		/*调车中途折返进路部分锁闭处理*/
+		chLocalVirCiType = GetLocalVirCiType(belongVirCIid);
-        DTrainRtnUnlockRoutePartLockP(routeId);
+		if (CI_TYPE_CLD == chLocalVirCiType)
+		{
+			/*调车中途折返进路部分锁闭处理*/
+			DTrainRtnUnlockRoutePartLockP(routeId);
+		}
 	}
 }
 
@@ -6089,6 +6120,11 @@ UINT16 GetReturnId(const UINT16	routeId)
 	UINT8 preRouteState = 0u;	/* 之前进路状态 */
 	UINT16 ii = 0u;
 	UINT8 toGo = CI_SUCCESS;
+	UINT8 chRouteState = 0U;
+	UINT8 chRoutePhysicalType = 0U;
+	UINT8 chAllLockSecNoOccupyCheck = 0U;
+	UINT8 chTrainEnterRouteFlag = 0U;
+
 	routeState = GetRouteState(routeId); /*获取进路状态*/
 	preRouteState = GetRoutePreState(routeId);/*获取进路前一状态*/
 
@@ -6098,7 +6134,8 @@ UINT16 GetReturnId(const UINT16	routeId)
 		toGo = CI_ERROR;
 	}
 
-	if ((CI_ERROR == RouteAllLockSecNoOccupyCheck(routeId)) && (CI_SUCCESS == toGo))
+	chAllLockSecNoOccupyCheck = RouteAllLockSecNoOccupyCheck(routeId);
+	if ((CI_ERROR == chAllLockSecNoOccupyCheck) && (CI_SUCCESS == toGo))
 	{ /*进路区段不是都空闲*/
 
 		toGo = CI_ERROR;
@@ -6119,12 +6156,14 @@ UINT16 GetReturnId(const UINT16	routeId)
 					/*获取所有满足道岔条件的进路ID*/
 					for (ii = 0u; ii < starSigRouteSum; ii++)
 					{
+						chRouteState = GetRouteState(starSigRouteBuf[ii]);
+						chRoutePhysicalType = CheckRoutePhysicalType(starSigRouteBuf[ii]);
 						/*B库改为两条进路，当8编组车占压两条进路时，此时BG2进路解锁需要检查以差值信号机为始端的进路的状态*/
-						if ((ROUTE_STATE_IDLE == GetRouteState(starSigRouteBuf[ii])) &&(CI_SUCCESS == CheckRoutePhysicalType(starSigRouteBuf[ii])) &&
+						if ((ROUTE_STATE_IDLE == chRouteState) &&(CI_SUCCESS == chRoutePhysicalType))
-							(SIGNAL_VIRTUAL_YES == GetSignalVirtualAttr(returnSigId)))
 						{    
 							/*以并置信号机为始端的进路均为空闲且进路包含的区段均为列检库区段，且并置信号机为虚拟信号机,
-							该种算法目前只限制在库线中中途折返场景*/
+							该种算法目前只限制在库线中中途折返场景(SIGNAL_VIRTUAL_YES == GetSignalVirtualAttr(returnSigId))*/
+							 /*联挂功能去掉虚拟信号机检查条件*/
 						}
 						else
 						{
@@ -6148,7 +6187,8 @@ UINT16 GetReturnId(const UINT16	routeId)
 			/* 如果是差至，如果列车驶入过进路，同时之前状态必须为接近锁闭开放
 			* 否则不认为是同一列车跨入中途折返处理
 			*/
-			if((ROUTE_STATE_NEAR_OPEN == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == GetTrainEnterRouteFlag(routeId)))
+			chTrainEnterRouteFlag = GetTrainEnterRouteFlag(routeId);
+			if((ROUTE_STATE_NEAR_OPEN == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == chTrainEnterRouteFlag))
 			{
 				returnSigId = GetRouteChaZhiSignalId(routeId); /*获取差置信号机ID*/
 			}
@@ -6498,103 +6538,134 @@ UINT16 GetRouteBingZhiSignalId(const UINT16 routeId)
 */
 UINT16 GetRouteChaZhiSignalId(const UINT16 routeId)
 {
-	UINT16 startSigId = 0u; /*始端信号机ID*/
+	UINT16 startSigId = 0U; /*始端信号机ID*/
-	UINT16 signalSum = 0u; /*信号机总数*/
+	UINT16 signalSum = 0U; /*信号机总数*/
-	UINT16 signalId = 0u; /*信号机ID*/
+	UINT16 signalId = 0U; /*信号机ID*/
-	UINT16 routeSecSum = 0u; /*进路区段总数*/
+	UINT16 routeSecSum = 0U; /*进路区段总数*/
-	RoutePhysicalSectionStruct *pRoutePhySecStru = NULL; /*进路区段数据*/
+	RoutePhysicalSectionStruct* pRoutePhySecStru = NULL; /*进路区段数据*/
-	UINT16 returnOutSecId = 0u; /*折返信号机外方区段ID*/
+	UINT16 returnOutSecId = 0U; /*折返信号机外方区段ID*/
-	UINT16 returnInSecId = 0u; /*折返信号机内方区段ID*/
+	UINT16 returnInSecId = 0U; /*折返信号机内方区段ID*/
-    UINT16 lockBelongRouteId = 0u; /*锁闭所属进路ID*/
+    UINT16 lockBelongRouteId = 0U; /*锁闭所属进路ID*/
-    UINT16 outSecId = 0u; /*外方区段ID*/
+    UINT16 outSecId = 0U; /*外方区段ID*/
-	UINT16 ii = 0u;
+	UINT16 ii = 0U;
-	UINT16 tmpSigId = 0u;
+	UINT16 tmpSigId = 0U;
-
+	UINT8 chPhySecType = 0U;
+	UINT16 wTempPhySecId = 0U;
+	UINT16 wReturnSignal = 0U;
+	UINT16 wTempSigId = 0U;
+	UINT8 chPhyLockState = 0U;
+	UINT16 wLockRouteId = 0U;
+	UINT16 wTempSigOutPhyId = 0U;
+	UINT16 wTempSigInPhyId = 0U;
 
     startSigId = GetRouteStartSignalId(routeId); /*获取进路始端信号机ID*/
 	signalSum = GetSignalCurSum(); /*获取信号机总数*/
 
-	if (PHYSICAL_SEC_TYPE_NOSWITCH == GetPhySecType(GetSignalOutFirstPhySecId(startSigId)))
+	outSecId = GetSignalOutFirstPhySecId(startSigId);
+	chPhySecType = GetPhySecType(outSecId);
+	if (PHYSICAL_SEC_TYPE_NOSWITCH == chPhySecType)
 	{ /*无岔区段*/
 
 		for (ii = 0u; ii < signalSum; ii++)
 		{
 			signalId = GetSignalId(ii); /*获取信号机ID*/
+			wTempPhySecId = GetSignalOutFirstPhySecId(signalId);
 
-			if ((GetSignalOutFirstPhySecId(startSigId) == GetSignalOutFirstPhySecId(signalId)) &&
+			if ((outSecId == wTempPhySecId) && (startSigId != signalId))
-				(startSigId != signalId))
 			{
-				return signalId;
+				wReturnSignal =  signalId;
+				break;
+			}
+			else
+			{
+				/*不处理*/
 			}
 		}
 	}
 	else
 	{ /*有岔*/
 
-		outSecId = GetSignalOutFirstPhySecId(startSigId); /*进路始端信号机外方区段ID*/
 		lockBelongRouteId = GetPhySecRLockBelongRouteId(outSecId); /*区段锁闭所属进路ID*/
 		
 		routeSecSum = GetRoutePhysicalSectionSum(lockBelongRouteId); /*获取进路区段总数*/
 		pRoutePhySecStru = GetRouteSectionData(lockBelongRouteId); /*获取进路区段数据*/
 		
-		if ((0u == routeSecSum) || (NULL == pRoutePhySecStru))
+		if ((0U == routeSecSum) || (NULL == pRoutePhySecStru))
 		{
-			return 0u;
+			/*不处理*/
 		}
-		if (routeSecSum == 1u)
+		else
 		{
-			/*if ((PHYSICAL_SECTION_LOCK_NORMAL == GetPhySecLockState(pRoutePhySecStru[0].PhysicalSectionId)) &&
+			if (1U == routeSecSum)
-				(lockBelongRouteId == GetPhySecRLockBelongRouteId(pRoutePhySecStru[0].PhysicalSectionId)))*/
 			{
-				returnOutSecId = pRoutePhySecStru[0].PhysicalSectionId;/*折返信号机外方区段ID*/
+				returnOutSecId = pRoutePhySecStru[0U].PhysicalSectionId;/*折返信号机外方区段ID*/
 
 				tmpSigId = GetRouteStartSignalId(lockBelongRouteId);/*折返信号机内方区段ID*/
 
 				returnInSecId = GetSignalOutFirstPhySecId(tmpSigId);
 			}
-		}
+			else if (1U < routeSecSum)
-		else if (routeSecSum > 1u)
-		{
-			for (ii = 0u; ii < routeSecSum; ii++)
 			{
+				for (ii = 0U; ii < routeSecSum; ii++)
+				{
 
-				if ((PHYSICAL_SECTION_LOCK_NORMAL == GetPhySecLockState(pRoutePhySecStru[ii].PhysicalSectionId)) &&
+					chPhyLockState = GetPhySecLockState(pRoutePhySecStru[ii].PhysicalSectionId);
-					(lockBelongRouteId == GetPhySecRLockBelongRouteId(pRoutePhySecStru[ii].PhysicalSectionId)))
+					wLockRouteId = GetPhySecRLockBelongRouteId(pRoutePhySecStru[ii].PhysicalSectionId);
-				{ /*本进路第一个锁闭的区段*/
+					if ((PHYSICAL_SECTION_LOCK_NORMAL == chPhyLockState) &&
+						(lockBelongRouteId == wLockRouteId))
+					{ /*本进路第一个锁闭的区段*/
 
-					returnOutSecId = pRoutePhySecStru[ii].PhysicalSectionId; /*折返信号机外方区段ID*/
+						returnOutSecId = pRoutePhySecStru[ii].PhysicalSectionId; /*折返信号机外方区段ID*/
 
-					if (ii > 0u)
+						if (0U < ii)
-					{
+						{
-						returnInSecId = pRoutePhySecStru[ii-1U].PhysicalSectionId; /*折返信号机内方区段ID*/
+							returnInSecId = pRoutePhySecStru[ii - 1U].PhysicalSectionId; /*折返信号机内方区段ID*/
+						}
+						else
+						{
+							wTempSigId = GetRouteStartSignalId(lockBelongRouteId);/*获取锁闭进路的外方第一区段*/
+							returnInSecId = GetSignalOutFirstPhySecId(wTempSigId);
+
+						}
+
+						break;
 					}
-
-					break;
 				}
 			}
+			else
+			{
+				/*无操作*/
+			}
 		}
-		else
+		
+		if ((0U == returnOutSecId) || (0U == returnInSecId))
 		{
 			/*无操作*/
 		}
-		if ((0u == returnOutSecId) || (0u == returnInSecId))
+		else
 		{
-			return 0u;
+			for (ii = 0u; ii < signalSum; ii++)
-		}
-
-		for (ii = 0u; ii < signalSum; ii++)
-		{
-			signalId = GetSignalId(ii); /*获取信号机ID*/
-
-			if ((returnOutSecId == GetSignalOutFirstPhySecId(signalId)) &&
-				(returnInSecId == GetSignalInFirstPhySecId(signalId, routeId)))
 			{
-				return signalId;
+				signalId = GetSignalId(ii); /*获取信号机ID*/
+				wTempSigOutPhyId = GetSignalOutFirstPhySecId(signalId);
+				wTempSigInPhyId = GetSignalInFirstPhySecId(signalId, routeId);
+				if ((returnOutSecId == wTempSigOutPhyId) &&
+					(returnInSecId == wTempSigInPhyId))
+				{
+					wReturnSignal = signalId;
+					break;
+				}
+				else
+				{
+					/*无操作*/
+				}
 			}
 		}
+
+		
 	}
 
-	return 0u;
+	return wReturnSignal;
 }
 
 
@@ -7100,23 +7171,187 @@ UINT8 CLDPhySectionFaultUnlockDeal(const UINT16 phySectionId,const UINT16 lockBe
 }
 
 /*
-* 功能描述： 取消洗车逻辑管理
+* 功能描述： 取消洗车命令处理
-* 参数说明： void
+* 参数说明： 无
 * 返回值  ： void   
+by hh  20251208
 */
 void CancelWashWorkLogicM(void)
-{/*取消洗车命令*/
+{
-	UINT16 washMachineId = 0u;
+	UINT16 washMachineId = 0U; /*洗车机ID*/
-	washMachineId = GetWashMachineId(0u);
+	UINT16 wDownWashRelateRouteFirstId = 0U; /*降级模式洗车线控制台表示灯1关联进路ID*/
-#if 0
+	UINT8 chRouteState = 0U;/*进路状态*/
-	SetCancelWashMachineFlag(washMachineId,CANCEL_WASH_FLAG_SET_YES);
+	UINT8 downWashAllowState = 0U;/*降级模式洗车同意状态(融合)*/
-#endif
+	UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
-	if (washMachineId >0u)
+	washMachineId = GetWashMachineId(0U);
-	{/*收到现地取消洗车命令，直接把洗车同意按钮状逻辑态置为抬起*/
+
-		(void)SetWashmachineXTALogicState(washMachineId,XTA_STATE_RAISE_UP);
+	if ((FUNC_SWITCH_ON == washMachineButtonType) && (washMachineId > 0u) && (washMachineId < WASHMACHINE_SUM_MAX))
+	{
+		downWashAllowState = GetDownWashAllowState(washMachineId);
+
+		if (WASH_COL_STATE_ALLOW_YES == downWashAllowState)
+		{
+			wDownWashRelateRouteFirstId = GetDownWashRelateRoute1Id(washMachineId);
+			chRouteState = GetRouteState(wDownWashRelateRouteFirstId);
+
+			if (ROUTE_STATE_IDLE == chRouteState)
+			{
+				/*设置降级模式洗车线和DCC的洗车同意按钮状态无效*/
+				SetDownWashAllowColState(washMachineId, WASH_COL_STATE_ALLOW_NO);
+				/*清除洗车线洗车同意按钮有效周期*/
+				SetDownWashBtVadCycle(washMachineId, 0U);
+				SetDownDccWashAllowColState(washMachineId, WASH_COL_STATE_ALLOW_NO);
+				/*清除DCC洗车同意按钮有效周期*/
+				SetDownWashDccBtVadCycle(washMachineId, 0U);
+				SetDownWashReqState(washMachineId, WASH_REQ_STATE_ALLOW_NO);
+				SetDownWashReqCycle(washMachineId, 0U);
+			}
+			else
+			{
+				/*向ATS报警进路未取消，请先取消进路 0XB5*/
+				SetCiSendCmdBackInfoData(CI_BACK_ROUTE_IDLE_NOT, CI_DEVICE_TYPE_ROUTE, wDownWashRelateRouteFirstId, 0U, 0U);
+			}
+		}
+		else 
+		{
+			/*向ATS报警"当前洗车机洗车同意按钮未按下，不需要取消 0XB6"*/
+			SetCiSendCmdBackInfoData(CI_BACK_WASH_BUTTON_PRESS_NOT, CI_DEVICE_TYPE_WASHMACHINE, washMachineId, 0U, 0U);
+		}
+	}
+	else 
+	{
+		/*其他情况不处理*/
 	}
 }
 
+/*
+* 功能描述： 请求洗车命令处理
+* 参数说明： 无
+* 返回值  ： void
+*by hh 20251208
+*/
+void ReqWashWorkLogicM(void)
+{
+	UINT32 curCycle = Get2oo2CurCycleNum(); /*当前周期号*/
+	UINT8 downWashReqState = WASH_REQ_STATE_ALLOW_NO;  /*洗车机洗车请求状态*/
+	UINT16 wMachineId = 0U; /*洗车机ID*/
+	UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
+	wMachineId = GetWashMachineId(0U);
+
+	if((FUNC_SWITCH_ON == washMachineButtonType) && (wMachineId >0u) && (wMachineId < WASHMACHINE_SUM_MAX))
+	{
+		downWashReqState = GetDownWashReqState(wMachineId);
+		if (WASH_REQ_STATE_ALLOW_NO == downWashReqState) 
+		{
+			/*设置降级模式洗车请求有效*/
+			SetDownWashReqState(wMachineId, WASH_REQ_STATE_ALLOW_YES);
+			/*设置降级模式洗车请求周期号有效*/
+			SetDownWashReqCycle(wMachineId, curCycle);
+		}
+		else 
+		{
+			/*向ATS报警当前洗车机洗车请求有效，请勿重复操作 0xB3*/
+			SetCiSendCmdBackInfoData(CI_BACK_WASH_APPLY_NOT, CI_DEVICE_TYPE_WASHMACHINE, wMachineId, 0U, 0U);
+		}		
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+}
+
+/*
+* 功能描述： 反向通过请求命令处理
+* 参数说明：无
+* 返回值  ： void
+*by hh 20251208
+*/
+void ReqPassWashWorkLogicM(void)
+{
+	UINT32 curCycle = Get2oo2CurCycleNum(); /*当前周期号*/
+	UINT8 downWashPassReqState = WASH_REQ_STATE_ALLOW_NO; /*反向洗车请求状态*/
+	UINT16 wMachineId = 0U; /*洗车机ID*/
+	UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
+	wMachineId = GetWashMachineId(0U);
+
+	if ((FUNC_SWITCH_ON == washMachineButtonType) && (wMachineId > 0u) && (wMachineId < WASHMACHINE_SUM_MAX))
+	{
+		downWashPassReqState = GetDownWashPassReqState(wMachineId);
+
+		if (WASH_REQ_STATE_ALLOW_NO == downWashPassReqState)
+		{
+			/*设置降级模式反向洗车请求有效*/
+			SetDownWashPassReqState(wMachineId, WASH_REQ_STATE_ALLOW_YES);
+			/*设置降级模式反向洗车请求周期号有效*/
+			SetDownWashPassReqCycle(wMachineId, curCycle);
+		}
+		else
+		{
+			SetCiSendCmdBackInfoData(CI_BACK_WASH_PASSAPPLY_NOT, CI_DEVICE_TYPE_WASHMACHINE, wMachineId, 0U, 0U);
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述： 取消反向通过请求命令处理
+* 参数说明： 无
+* 返回值  ： void
+*by hh 20251208
+*/
+void CancelPassWashWorkLogicM(void)
+{
+	UINT16 wDownWashRelateRouteSecId = 0U; /*降级模式洗车线控制台表示灯2关联进路ID*/
+	UINT8 chRouteState = 0U;/*进路状态*/
+	UINT8 downWashAllowPassState = 0U;/*降级模式反向通过洗车同意状态(融合)*/
+	UINT16 wMachineId = 0U; /*洗车机ID*/
+	UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
+	wMachineId = GetWashMachineId(0U);
+	if ((FUNC_SWITCH_ON == washMachineButtonType) && (wMachineId > 0u && wMachineId < WASHMACHINE_SUM_MAX))
+	{
+		downWashAllowPassState = GetDownWashAllowPassState(wMachineId);
+
+		if (WASH_COL_STATE_ALLOW_YES == downWashAllowPassState)
+		{
+			wDownWashRelateRouteSecId = GetDownWashRelateRoute2Id(wMachineId);
+			chRouteState = GetRouteState(wDownWashRelateRouteSecId);
+
+			if (ROUTE_STATE_IDLE == chRouteState)
+			{
+				/*设置降级模式洗车线和DCC的反向洗车同意按钮状态无效*/
+				SetDownWashAllowPassColState(wMachineId, WASH_COL_STATE_ALLOW_NO);
+				/*清除洗车线反向通过同意按钮有效周期*/
+				SetDownWashBtVadPassCycle(wMachineId, 0U);
+				SetDownDccWashAllowPassColState(wMachineId, WASH_COL_STATE_ALLOW_NO);
+				/*清除DCC反向通过同意按钮有效周期*/
+				SetDownWashDccBtVadPassCycle(wMachineId, 0U);
+				SetDownWashPassReqState(wMachineId, WASH_REQ_STATE_ALLOW_NO);
+				SetDownWashPassReqCycle(wMachineId, 0U);
+			}
+			else
+			{
+				/*向ATS报警进路未取消，请先取消进路 0XB5*/
+				SetCiSendCmdBackInfoData(CI_BACK_ROUTE_IDLE_NOT, CI_DEVICE_TYPE_ROUTE, wDownWashRelateRouteSecId, 0U, 0U);
+			}
+
+		}
+		else 
+		{
+			/*向ATS报警"洗车机XXX反向通过同意按钮未按下，不需要取消 0XB7"*/
+			SetCiSendCmdBackInfoData(CI_BACK_WASH_PASSBUTTON_PRESS_NOT, CI_DEVICE_TYPE_WASHMACHINE, wMachineId, 0U, 0U);
+		}
+	}
+	else
+	{
+		/*其他情况不处理*/
+	}
+}
+
+
 /*
 * 功能描述： 进路调车同意逻辑管理
 * 参数说明： void

TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.h

@@ -766,12 +766,37 @@ UINT16 GetReturnId(const UINT16	routeId);
 void DTrainRtnUnlockRemoteRAllLockP(const UINT16 routeId);
 
 /*
-* 功能描述： 取消洗车逻辑管理
+* 功能描述： 取消洗车命令处理
-* 参数说明： void
+* 参数说明： 无
 * 返回值  ： void
+by hh  20251208
 */
 void CancelWashWorkLogicM(void);
 
+/*
+* 功能描述： 请求洗车命令处理
+* 参数说明： 无
+* 返回值  ： void
+*by hh 20251208
+*/
+void ReqWashWorkLogicM(void);
+
+/*
+* 功能描述： 反向通过请求命令处理
+* 参数说明：无
+* 返回值  ： void
+*by hh 20251208
+*/
+void ReqPassWashWorkLogicM(void);
+
+/*
+* 功能描述： 取消反向通过请求洗车逻辑管理
+* 参数说明： const UINT16 wMachineId 洗车机ID
+* 返回值  ： void
+*by hh 20251208
+*/
+void CancelPassWashWorkLogicM(void);
+
 /*
 * 功能描述： 进路调车同意逻辑管理
 * 参数说明： void

TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.h

@@ -946,6 +946,18 @@ UINT8 RouteAllSecJumpLockStateCheck(UINT16 const routeId,UINT16 *pDevId,UINT8 *p
 *            CI_SUCCESS 
 */
 UINT8 KeepRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
+
+/*
+* 功能描述：引导进路信号保持道岔联锁条件检查
+* 参数说明：UINT16 RouteId,    进路号
+*           UINT8 functionId,  调用函数编号
+*           UINT8 sendLevel,   故障码发送级别
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2025.09.29
+*/
+UINT8 KeepLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
+
 /*
 * 功能描述： 保持列车进路信号机联锁条件检查
 * 参数说明：
@@ -970,6 +982,18 @@ UINT8 KeepLTrainRouteSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
 */
 UINT8 LockBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
 
+/*
+* 功能描述：引导进路锁闭道岔联锁条件检查
+* 参数说明：UINT16 RouteId,    进路号
+*           UINT8 functionId,  调用函数编号
+*           UINT8 sendLevel,   故障码发送级别
+* 返 回 值：CI_ERROR
+*           CI_SUCCESS
+*			RETURN_LOCK_ERR_SWITPOS 道岔位置不正确
+* Created By LQ 2025.09.29
+*/
+UINT8 LockLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
+
 /*
 * 功能描述： 锁闭点式进路区段联锁条件检查
 * 参数说明：
@@ -1006,12 +1030,11 @@ UINT8 ChekRoutSwitDrivOvtmStat(const UINT16 routeId);
 /*
 * 功能描述： 区段故障解锁
 * 参数说明： UINT16 const phySectionId
-*			 UINT8 const isConnectSec 是否联络线（联络线不报警）CI_SUCCESS是 CI_ERROR否
 * 返回值  ： CI_ERROR
 *            CI_SUCCESS
 * 故障编码： EFUNC_UNLOCK_FAULT_SECTION
 */
-UINT8 PhySecFaultUnlockLogicProcess(const UINT16 phySectionId, UINT8 const isConnectSec);
+UINT8 PhySecFaultUnlockLogicProcess(const UINT16 phySectionId);
 
 /*
 * 功能描述： 检查进路总人解的可行性。只要进路有一个区段可以直接解锁或变绿光带都认为总人解可行。
@@ -1166,6 +1189,17 @@ UINT8 OpenLTrainRouteSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
 */
 UINT8 OpenBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
 
+/*
+* 功能描述：引导进路开放信号道岔联锁条件检查
+* 参数说明：UINT16 RouteId,    进路号
+*           UINT8 functionId,  调用函数编号
+*           UINT8 sendLevel,   故障码发送级别
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2025.09.29
+*/
+UINT8 OpenLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
+
 /* L10_点式进路开放信号保护区段联锁条件检查 */
 /*
 * 功能描述： 点式进路开放信号保护区段联锁条件检查
@@ -1735,16 +1769,6 @@ UINT8 LogicSecFLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
 */
 UINT8 LogicSecRelativeSwitchPosCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState);
 
-/*
-* 功能描述：获取逻辑区段所处道岔位置不一致原因
-* 参数说明：UINT16 const wLgcId 逻辑区段ID
-* 返 回 值：1 位置一致
-*           0x55 道岔在相反位置
-*           0xAA 道岔失表
-* Created By LQ 2025.12.19
-*/
-UINT8 GetLogSecRelSwPosErrReason(UINT16 const wLgcId);
-
 /*
 * 功能描述： 进路VBTC条件下第一逻辑区段检查
 * 参数说明：
@@ -1873,15 +1897,7 @@ UINT8 LockLeadRouteSectionCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
 */
 UINT8 LogicSecSwitchLtrlDfncCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
 
-/*
+
-* 功能描述： 进路区段全部侧防条件满足检查
-* 参数说明： UINT16 routeId,    进路号
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
-* 返回值  ： CI_ERROR
-*            CI_SUCCESS
-*/
-UINT8 RouteAllLtrlDfncSwitchCheck(UINT16 const routeId, UINT16 *pDevId, UINT8 *pDevState);
 
 /*
 * 功能描述： 进路区段全部联络线设备条件满足检查
@@ -2215,15 +2231,7 @@ UINT8 LogSecSeqIncUTCheck(const UINT16 wTrainId, const UINT8 cLogSecSum, const U
 */
 UINT8 RouteHalfProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState, UINT8* pYLockAlarmFlag);
 
-/*
+
-* 功能描述： 进路区段全部侧防条件满足检查
-* 参数说明： UINT16 routeId,    进路号
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
-* 返回值  ： CI_ERROR
-*            CI_SUCCESS
-*/
-UINT8 RouteHalfLtrlDfncSwitchCheck(UINT16 const routeId, UINT16 *pDevId, UINT8 *pDevState);
 
 /*
 * 功能描述： 部分进路区段全部联络线设备条件满足检查
@@ -2510,16 +2518,7 @@ UINT8 CheckRouteZhefanJiesuo(UINT16 const routeId);
 */
 UINT8 CheckOverlapPhysecOtherLock(UINT16 const overlapId, UINT16* pDevId, UINT8* pDevState);
 
-/*
+
-* 功能描述：保护区段侧防条件检查
-* 参数说明：UINT16 const overlapId,  OverlapID
-*           UINT16* pDevId 设备Id（返回）
-*           UINT8* pDevState 设备状态（返回）
-* 返回值  ：0 检查失败
-*           1 检查成功
-* Created By LQ 2024.01.05
-*/
-UINT8 OverlapLateralDfnCheck(UINT16 const overlapId, UINT16* pDevId, UINT8* pDevState);
 
 /*
 * 功能描述： 检查保护区段的CBTC区域属性
@@ -2772,37 +2771,276 @@ UINT8 RouteCldAttrCheck(UINT16 wRouteId);
 * Created By LQ 2025.08.18
 */
 UINT8 OverlapOccuUnlockCheck(UINT16 overlapId, UINT8 functionId);
-
 /*
-* 功能描述：区段封锁但可重开条件检查:存在spks封锁时检查开关打开或cbtc进路、无CMD封锁
+* 功能描述：办理联挂进路区段检查
-* 参数说明：UINT16 wPhySecId 区段ID wRouteId进路ID
+* 参数说明：const UINT16 wRouteId 进路ID
-* 返 回 值：CI_ERROR 0 失败 非可重开封锁
+*           UINT16* pDevId 设备ID
-*           CI_SUCCESS 1 成功 可重开的封锁类型
+*			UINT8* pDevState 设备状态
-* Created By fan 2025.12.16
-*/
-UINT8 SectionFlockReOpenCheck(UINT16 wPhySecId, UINT16 wRouteId);
-
-/*
-* 功能描述：CBTC进路逻辑区段占用检查
-* 参数说明：UINT16 const routeId 进路ID
-*           UINT16 *pDevId 设备Id（出参）
-*           UINT8 *pDevState 设备状态（出参）
 * 返 回 值：CI_ERROR 0 失败
 *           CI_SUCCESS 1 成功
-* Created By LQ 2026.01.25
+* Created By  2025.09.18
 */
-UINT8 RouteCbtcLogSecOccCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
+UINT8 SetCouplinkRouteSecOccCheck(const UINT16 wRouteId, UINT16* pDevId, UINT8* pDevState);
-
 /*
-* 功能描述：CBTC进路保持开放阶段逻辑区段占用检查
+* 功能描述：保持联挂进路区段占用检查
-* 参数说明：UINT16 const routeId 进路ID
+* 参数说明：const UINT16 wRouteId 进路ID
-*           UINT16 *pDevId 设备Id（出参）
+*           UINT16* pDevId 设备ID
-*           UINT8 *pDevState 设备状态（出参）
+*			UINT8* pDevState 设备状态
 * 返 回 值：CI_ERROR 0 失败
 *           CI_SUCCESS 1 成功
-* Created By LQ 2026.03.12
+* Created By  2025.09.18
 */
-UINT8 RouteCbtcKeepOpenLgcOccCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
+UINT8 KeepCouplinkRouteSecOccCheck(const UINT16 wRouteId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述：单个侧防条件检查
+* 参数说明：SideProtecStru SidePretectData 一项侧防条件
+*			UINT16 wDevId 设备ID
+*           UINT8 cDevType 设备类型
+*           UINT8 functionId 函数ID
+*			UINT8 sendLevel 发送等级
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+*/
+UINT8 SingleSideProtectCheck(SideProtecStru SidePretectData, UINT16 wDevId, UINT8 cDevType, UINT8 functionId, UINT8 sendLevel);
+
+/*
+* 功能描述：侧防道岔位置检查
+* 参数说明：SideProtecSwitchData* pSideProtecSwitchBuf 道岔侧防条件
+*           UINT8 chSideProtecSwitchNum 侧防道岔数量
+* 返 回 值：CI_ERROR 0 侧防道岔位置连通
+*           CI_SUCCESS 1 侧防道岔位置不连通
+*/
+UINT8 SideProtectSwitchPosCheck(SideProtecSwitchData* pSideProtecSwitchBuf, UINT8 chSideProtecSwitchNum);
+
+/*
+* 功能描述：侧防物理区段条件检查
+* 参数说明：SideProtecStru SidePretectData 侧防条件
+*           UINT8 functionId 函数ID
+*			UINT8 sendLevel 发送等级
+* 返 回 值： CI_ERROR    失败
+*            CI_SUCCESS   成功
+*/
+UINT8 SideProtectPhySecCheck(SideProtecStru SidePretectData, UINT8 functionId, UINT8 sendLevel);
+
+/*
+* 功能描述： 检查进路侧防条件
+* 参数说明：UINT16 routeId 进路ID
+			UINT8 functionId 函数ID
+			UINT8 sendLevel 发送等级
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* 创建    ：
+*/
+UINT8 RouteSideProtectConditionCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
+/*
+* 功能描述： 检查保护区段侧防条件
+* 参数说明：UINT16 wOverlapId 保护区段ID
+			UINT8 functionId 函数ID
+			UINT8 sendLevel 发送等级
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* 创建    ：
+*/
+UINT8 OlapSideProtectConditionCheck(UINT16 wOverlapId, UINT8 functionId, UINT8 sendLevel);
+
+/*
+* 功能描述：侧防区段道岔位置检查
+* 参数说明：UINT16 const physicalId,    物理区段ID
+*           SideProtecStru SidePretectData 侧防数据
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+*/
+UINT8 SideProtectPhySecSwtPosCheck(const UINT16  physicalId, SideProtecStru SidePretectData);
+
+/*
+* 功能描述：检查保护区段道岔及防护道岔位置是否正确
+* 参数说明：const UINT16 overlapId overlap ID
+* 返 回 值：CI_ERROR 0 道岔位置错误
+*			CI_SUCCESS 1 道岔位置正确
+* Created By LQ 2025.09.28
+*/
+UINT8 CheckOverlapSwitchPosRight(const UINT16 overlapId);
+
+/*
+*函数功能：保护区段之前人工解锁状态检查
+*参数说明：const UINT16 wRouteId 进路ID
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* by cgh 20250929
+*/
+UINT8 OverlapPreLaborUnLockStateCheck(UINT16 const wRouteId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述：侧防关键道岔检查
+* 参数说明：UINT16 wSwitchId 关键道岔ID
+*			UINT16 wDevId 设备ID
+*           UINT8 cDevType 设备类型
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2025.09.29
+*/
+UINT8 SingleSideKeySwitchCheck(UINT16 wSwitchId, UINT16 wDevId, UINT8 cDevType);
+
+/*
+* 功能描述：物理区段锁闭码位侧防条件检查
+* 参数说明：UINT16 wPhySecId 物理区段ID
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2025.09.29
+*/
+UINT8 PhySecLockMaskSideProtectCheck(UINT16 wPhySecId);
+/*
+*函数功能：自动通过进路办理联挂属性检查
+*参数说明：  const UINT16 wAutoRouteId 进路ID
+*			 const UINT8 chFunctionId 函数ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* by lyj 20250929
+*/
+UINT8 AutoRouteCouplinkStateCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
+/*
+*函数功能：自动折返进路办理联挂属性检查
+*参数说明：  const UINT16 wAutoRouteId 进路ID
+*			 const UINT8 chFunctionId 函数ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* by lyj 20250929
+*/
+UINT8 AutoReturnRouteCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
+/*
+*函数功能：全自动折返进路办理联挂属性检查
+*参数说明：  const UINT16 wAutoRouteId 进路ID
+*			 const UINT8 chFunctionId 函数ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* by lyj 20250929
+*/
+UINT8 AllAutoReturnRCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
+/*
+* 功能描述： 区段征用、区段防护道岔区段征用、区段内道岔道岔征用检查、区段内防护道岔道岔征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：区段防护道岔区段、防护道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*  add by mpt 20260331
+*/
+UINT8 JumpPhySectionPortectUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：逻辑区段防护道岔区段征用、道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 JumpLogicSecPortectUseCheck(const UINT16 wLgcId);
+/*
+* 功能描述：计轴区段所在道岔道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*  add by mpt 20260331
+*/
+UINT8 JumpPhySectionSwitchUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：设置跳跃锁闭防护道岔区段征用状态
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+*           const UINT8 state 状态
+* 返回值  ： void
+*  add by mpt 20260331
+*/
+void SetJumpPhySectionPortectSecUse(const UINT16 axisSecId, const UINT8 state);
+/*
+* 功能描述：设置逻辑区段的防护道岔区段征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+*           const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetJumpLogicSecPortectUse(const UINT16 wLgcId, const UINT8 state);
+/*
+* 功能描述： 检查计轴区段跳跃锁闭是否有防护道岔驱动超时
+* 参数说明： const UINT16 routeId, 进路ID
+* 返回值  ： UINT8
+			 CI_SUCCESS:计轴区段防护道岔无道岔驱动超时
+			 CI_ERROR:计轴区段防护道岔驱动超时
+add by mpt 20260331
+*/
+UINT8 ChekJumpLockProtectSwitDrivOvtmStat(const UINT16 axisSecId);
+/*
+* 功能描述： 计轴区段道岔封锁状态检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* Add by mpt 20260331
+*/
+UINT8 AxisSecProtSwitchFLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 计轴区段的防护道岔位置和动作有效性检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 AxisSecPorteSwitchPosMoveCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState, UINT8 funcId, UINT8 sendLevel);
+/*
+* 功能描述： 计轴区段所有防护道岔位置正确检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add mpt 20260331
+*/
+UINT8 AxisSecAllProtSwitchPosCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 设置计轴区段关联防护道岔防护锁闭状态
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+*            const UINT8 lockCommand, 锁闭状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetAxisRelProSwitchLockSta(const UINT16 axisSecId, const UINT8 lockCommand);
+/*
+* 功能描述： 计轴区段关联防护道岔防护锁闭检查
+* 参数说明： UINT16 const routeId,    计轴区段号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add mpt 20260331
+*/
+UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 设置逻辑区段关联防护道岔防护锁闭状态
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+*            const UINT8 lockCommand, 锁闭状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand);	
+/*
+* 功能描述：计轴区段所有道岔是否全部征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR  未全部征用
+*            CI_SUCCESS 全部征用
+*  add by mpt 20260403
+*/
+UINT8 JumpPhySecAllUseCheck(const UINT16 axisSecId);
+
 
 #endif
 

TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h

@@ -368,7 +368,7 @@ UINT8 RoutePhySectionUseLogicProcess(const UINT16 routeId);
 * 故障编码： EFUNC_SET_SWITCH_POS
 * cgh-合并CID-3037-6：
 */
-UINT8 SetSwitchPositionLogicProcess(UINT16 const switchId, UINT8 const switchSetPos, const UINT8 chCmdType, UINT8* chSwitchTestFlag, UINT8 sendLevelFlag);
+UINT8 SetSwitchPositionLogicProcess(UINT16 const switchId, UINT8 const switchSetPos, const UINT8 chCmdType, UINT8* chSwitchTestFlag);
 
 /* C30_设置道岔单锁*/
 /*
@@ -688,15 +688,16 @@ void LgcSecUnlockProc(const UINT16 routeId, const UINT16 logSectionId);
 * 返回值  ： void
 */
 void RouteLgcSecResReleaseProcess(const UINT16 wRouteId);
+
 /*
 * 功能描述： 检查保护区段人工解锁是否可执行
 * 参数说明： const UINT16 overlapId, 保护区段ID
-*            const UINT32 dwOverlapUnlockCount 保护区段自动解锁周期数
+*            const UINT16 wRouteId 进路ID
-*            const UINT32 dwOverlapUnlockStartCyc 保护区段自动解锁起始周期
 * 返回值  ： CI_SUCCESS:成功
 			 CI_ERROR:失败
+* edit cgh 20250928
 */
-UINT8 CheckOverlapLaborUnlock(const UINT16 overlapId, const UINT32 dwOverlapUnlockCount, const UINT32 dwOverlapUnlockStartCyc);
+UINT8 CheckOverlapLaborUnlock(const UINT16 overlapId, const UINT16 wRouteId);
 /*
 * 功能描述： 计算保护区段解锁倒计时开始周期
 * 参数说明： const UINT16 overlapId, 保护区段ID
@@ -815,23 +816,6 @@ UINT8 RouteLgcSecResUnlockNextSecCheck(const UINT16 wRouteId, const UINT16 wUnlo
 */
 UINT8 RouteLgcSecResReturnSecCheck(UINT16 wValidReturnSigId, const UINT16 wRouteId);
 
-/*
-* 功能描述： 迪士尼联络线其他联锁条件检查
-* 参数说明： UINT16 routeId 进路ID
-* 返回值  ： CI_ERROR						检查失败
-*            CI_SUCCESS						检查成功
-* 注意事项： 本函数只检查区段方向、进路协议相关内容
-*/
-UINT8 DsnConnectOtherCiValidCheck(UINT16 const routeId);
-
-/*
-* 功能描述：迪士尼联络线自动区故解处理
-* 参数说明：const UINT16 wRouteId 进路ID
-* 返 回 值：CI_SUCCESS：可以解锁 CI_ERROR：不能解锁
-* Created By wyd 20260318
-*/
-void DsnConnectRouteSecUnlockProc(UINT16 wRouteId);
-
 #if 0 
 /*
 * 功能描述： 逻辑区段保护锁闭可用性逻辑处理
@@ -841,6 +825,30 @@ void DsnConnectRouteSecUnlockProc(UINT16 wRouteId);
 */
 UINT8 LgcOverlapUsableProcess(UINT16 const wLgcSecId);
 #endif
+/*
+* 功能描述： 进路联挂标志处理
+* 参数说明： const UINT16 wRouteId 进路ID
+*			 const UINT8 functionId 函数ID
+*			 const UINT8 sendLevel 报警级别
+* 返回值  ： 联挂标志设置结果
+* Create: 20250917
+*/
+UINT8 SetRouteCouplinkProcess(const UINT16 wRouteId, const UINT8 functionId, const UINT8 sendLevel);
+/*
+* 功能描述： 刷新联挂标志
+* 参数说明： const UINT16 wRouteId 进路ID
+* 返回值  ： 无
+* Create: 20250919
+*/
+void UpdateRouteCouplinkFlag(const UINT16 wRouteId);
+/*
+* 功能描述： 联络线接车进路解锁处理
+* 参数说明： const UINT16 wRouteId 进路ID
+* 返回值  ： 无
+* Create: lyj 20260603
+*/
+void ConnectRouteReleaseProc(const UINT16 wRouteId);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/LogicProcess/LogicalRouteLogicCheck.c

@@ -274,17 +274,15 @@ UINT8 LockLogRouteCheckProcess(UINT16 const logRouteId)
 *          UINT8 pDevState,设备状态
 * @note：
 */
-UINT8 LogRouteSecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState)
+UINT8 LogRoutePhySecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState)
 {
 	UINT16* LogSecIdBuff = NULL;
 	UINT16 logSecSum = 0U;
 	UINT16 ii = 0U;
-	UINT16 devId = 0U; /*关联区段ID*/
+	UINT16 devId = 0U; /*关联物理区段ID*/
 	UINT8 devState = 0U;
 	UINT8 retval = CI_ERROR;
-	UINT8 chShareSwitchNum = 0U;/*共用道岔区段个数*/
+
-	UINT16* plogSecIdPBuf = NULL;/*共用道岔区段序列*/
-	UINT8 jj = 0U;
 	LogSecIdBuff = GetLogicalRouteInLogSecId(logRouteId);
 	logSecSum = GetLogicalRouteInLogSecSum(logRouteId);
 	if ((NULL != LogSecIdBuff) && (0U != logSecSum) && (NULL!= pDevId) && (NULL != pDevState))
@@ -292,48 +290,21 @@ UINT8 LogRouteSecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevStat
 		retval = CI_SUCCESS;
 		for (ii = 0U; ii < logSecSum; ii++)
 		{
-			devId =LogSecIdBuff[ii];
+			devId = GetLgcSecRelativePhySecId(LogSecIdBuff[ii]);
-			devState = GetLogSecFLockType(devId);
+			devState = GetPhySecFLockState(devId);
+
 			/* 状态如果不是未封锁状态，则认为检查失败 */
-			if (SEC_FLOCK_TYPE_NONE != devState )
+			if (PHYSICAL_SECTION_FLOCK_NO != devState )
 			{
 				/*状态不一致返回故障状态*/
 				*pDevId = devId;
-				*pDevState = PHYSICAL_SECTION_FLOCK_YES;
+				*pDevState = devState;
 				retval = CI_ERROR;
+				break;
 			}
 			else
 			{
-				chShareSwitchNum = GetLogSecSameSwitchSecSum(devId);
+				/*继续检查*/
-				plogSecIdPBuf = GetLogSecSameSwitchSecId(devId);
-				if ((PHYSICAL_INCLUDE_AXIS_SUM_MAX > chShareSwitchNum) && (NULL != plogSecIdPBuf))
-				{	
-					/*检查与逻辑区段共用道岔的逻辑区段封锁状态*/
-					for (jj = 0U; jj < chShareSwitchNum; jj++)
-					{
-						devState = GetLogSecFLockType(plogSecIdPBuf[jj]);/*逻辑区段封锁*/
-						if (SEC_FLOCK_TYPE_NONE != devState)
-						{
-							/*区段处于封锁状态*/
-							/*状态不一致返回故障状态*/
-							*pDevId = plogSecIdPBuf[jj];
-							*pDevState = PHYSICAL_SECTION_FLOCK_YES;
-							retval = CI_ERROR;
-							break;
-						}
-					}
-				}
-				else
-				{
-					*pDevId = devId;
-					*pDevState = PHYSICAL_SECTION_FLOCK_YES;
-					retval = CI_ERROR;
-				}
-				
-			}
-			if (CI_ERROR == retval)
-			{
-				break;/*跳出*/
 			}
 		}
 	}
@@ -666,7 +637,7 @@ UINT8 LogRouteSectionCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLevel)
 	/*逻辑进路关联的物理区段未封锁*/
 	devId = 0u;
 	devState = 0u;
-	checkResult = LogRouteSecFengSuoCheck(logRouteId, &devId, &devState);
+	checkResult = LogRoutePhySecFengSuoCheck(logRouteId, &devId, &devState);
 	if (checkResult == CI_SUCCESS)
 	{
 		/* 通过检查 */
@@ -675,7 +646,7 @@ UINT8 LogRouteSectionCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLevel)
 	else
 	{
 		/* 记录故障码 */
-		SetErrorData(functionId, CI_DEVICE_TYPE_LOGICSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
+		SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
 		/* 失败返回 */
 		reResult = CI_ERROR;
 	}
@@ -852,7 +823,7 @@ UINT8 SetLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLeve
 	{
 		devId = 0u;
 		devState = 0u;
-		checkResult = LogRouteCeFangSwitchCheck(logRouteId, &devId, &devState);
+		checkResult = LogRouteCeFangSwitchCheck(logRouteId, functionId, sendLevel);
 		if (CI_SUCCESS == checkResult)
 		{
 			/* 通过检查 */
@@ -860,8 +831,7 @@ UINT8 SetLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLeve
 		}
 		else
 		{
-			/* 记录故障码 */
+
-			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
@@ -1063,7 +1033,7 @@ UINT8 LockLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLev
 	{
 		devId = 0u;
 		devState = 0u;
-		checkResult = LogRouteCeFangSwitchCheck(logRouteId, &devId, &devState);
+		checkResult = LogRouteCeFangSwitchCheck(logRouteId, functionId, sendLevel);
 		if (CI_SUCCESS == checkResult)
 		{
 			/* 通过检查 */
@@ -1071,8 +1041,7 @@ UINT8 LockLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLev
 		}
 		else
 		{
-			/* 记录故障码 */
+
-			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
@@ -1327,46 +1296,39 @@ UINT8 LogRouteProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* p
 /*
 * 功能描述： 逻辑进路侧防条件满足检查
 * 参数说明： UINT16 routeId,    逻辑进路号
-*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 functionId,  函数ID
-*            UINT8 *pDevState,  设备状态（返回）
+*             UINT8 sendLevel   发送等级
 * 返回值  ： CI_ERROR
 *            CI_SUCCESS
 */
-UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState)
+UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId,UINT8 functionId, UINT8 sendLevel)
 {
-	/* 进路区段*/
-	UINT16 const checkSum = GetLogicalRouteInLogSecSum(routeId);
-	UINT16* const dataIdBuf = GetLogicalRouteInLogSecId(routeId);
-
 	/* 局部变量定义初始化 */
-	UINT16 i = 0u;           /* 循环变量 */
+	UINT8 i = 0u;           /* 循环变量 */
-	UINT16 devId = 0u;
 	UINT8 reVal = CI_ERROR;
+	SideProtecStru* pLogRoutSidePrtectData = NULL;
+	UINT8 chLogRoutSidePrtectDataNum = 0u;
 
-	if ((0u == checkSum) || (NULL == pDevId) || (NULL == pDevState))
+	UINT8 cDevType = 0u;
+	UINT8 cDevStateType = 0u;
+	UINT16 cDevId = 0u;
+	UINT8 cDevState = 0u;
+
+	pLogRoutSidePrtectData = GetLogRoutSidePrtectData(routeId);
+	chLogRoutSidePrtectDataNum = GetLogRoutSidePrtectDataNum(routeId);
+
+	if (NULL == pLogRoutSidePrtectData)
 	{
 		/*区段数据错误*/
 		reVal = CI_ERROR;
 	}
 	else
 	{
-		/*开始检查*/
+		reVal = CI_SUCCESS;
-		for (i = 0u; i < checkSum; i++)
+		/*功能预留*/
-		{
-			devId = dataIdBuf[i];
-			reVal = LogicSecSwitchLtrlDfncCheck(devId, pDevId, pDevState);
-			if (CI_SUCCESS == reVal)
-			{
-				/* 通过检查*/
-			}
-			else
-			{
-				/*状态不一致返回故障状态*/
-				reVal = CI_ERROR;
-				break;
-			}
-		}
 	}
+
+
 	/*全部通过检查*/
 	return reVal;
 }
@@ -2039,7 +2001,7 @@ UINT8 KeepLogRouteSectionCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendL
 	UINT8 devState = 0U;                 /*设备状态*/
 
 	/* 逻辑进路内所有区段未被封锁 */
-	checkResult = LogRouteSecFengSuoCheck(wLogRouteId, &devId, &devState);
+	checkResult = LogRoutePhySecFengSuoCheck(wLogRouteId, &devId, &devState);
 	if (CI_SUCCESS == checkResult)
 	{
 		/* 通过检查 */
@@ -2048,7 +2010,7 @@ UINT8 KeepLogRouteSectionCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendL
 	else
 	{
 		/* 记录故障码 */
-		SetErrorData(functionId, CI_DEVICE_TYPE_LOGICSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
+		SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
 		/* 失败返回 */
 		reResult = CI_ERROR;
 	}
@@ -2829,7 +2791,7 @@ UINT8 KeepLogRouteSwitchCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendLe
 	{
 		devId = 0u;
 		devState = 0u;
-		checkResult = LogRouteCeFangSwitchCheck(wLogRouteId, &devId, &devState);
+		checkResult = LogRouteCeFangSwitchCheck(wLogRouteId, functionId, sendLevel);
 		if (CI_SUCCESS == checkResult)
 		{
 			/* 通过检查 */
@@ -2837,8 +2799,7 @@ UINT8 KeepLogRouteSwitchCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendLe
 		}
 		else
 		{
-			/* 记录故障码 */
+
-			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}

TSCP/src/APP/ciapp/LogicProcess/LogicalRouteLogicCheck.h

@@ -51,7 +51,7 @@ UINT8 LockLogRouteCheckProcess(UINT16 const logRouteId);
 *          UINT8 sendLevel,       故障码发送级别
 * @note：
 */
-UINT8 LogRouteSecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState);
+UINT8 LogRoutePhySecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState);
 
 /**
 * @brief 逻辑进路逻辑区段锁闭检查
@@ -138,12 +138,12 @@ UINT8 LogRouteProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* p
 /*
 * 功能描述： 逻辑进路侧防条件满足检查
 * 参数说明： UINT16 routeId,    逻辑进路号
-*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 functionId,  函数ID
-*            UINT8 *pDevState,  设备状态（返回）
+*             UINT8 sendLevel   发送等级
 * 返回值  ： CI_ERROR
 *            CI_SUCCESS
 */
-UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
+UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId, UINT8 functionId, UINT8 sendLevel);
 
 /*
 * 功能描述： 逻辑进路区段全部联络线设备条件满足检查

TSCP/src/APP/ciapp/LogicProcess/TradInterlockLogicProcess.c

@@ -28,24 +28,48 @@ UINT8 SetLTrainRouteP(const UINT16 routeId)
 /* 局部变量定义初始化 */
 	UINT8 devState = 0U;                 /*设备状态*/
 	UINT8 reResult = CI_ERROR;          /*返回值*/
-
+	UINT8 chRouteCouplinkFlag = 0U;
+	UINT8 chRouteLevel = 0U;
 /* 联锁条件检查 */
-
+	chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+	chRouteLevel = GetRouteLevel(routeId);               /*获取进路监督级别*/
 	devState = GetRouteState(routeId);
-	/*进路状态空闲或初选或自动解锁异常（ARB且故障锁闭）*/
+	if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
-	if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
 	{
-		/* 返回成功 */
+		/* 进路状态条件：进路状态空闲、进路初选、自动解锁正常、自动解锁异常（ARB）、初锁异常、预先锁闭、接近锁闭正常、接近锁闭异常都可以办理联挂进路 */
-		reResult = CI_SUCCESS;
+		if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_FIRST_LOCKERR == devState)
+			|| (ROUTE_STATE_YUXIAN_LOCK == devState) || (ROUTE_STATE_NEAR_LOCK == devState) || (ROUTE_STATE_NEAR_LOCKERR == devState)
+			|| (ROUTE_STATE_AUTO_UNLOCK == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
+		{
+			/* 返回成功 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
 	}
 	else
 	{
-		/* 记录故障码 */
+		/*进路状态空闲或初选或自动解锁异常（ARB且故障锁闭）*/
-		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, devState, sendLevel);
+		if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
-		/* 失败返回 */
+		{
-		reResult = CI_ERROR;
+			/* 返回成功 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
 	}
 	
+
 	/*信号联锁条件检查*/
 	/*if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLTrainRouteSignalCheck(routeId,functionId,sendLevel)))*/
 	if ((CI_SUCCESS == reResult) && (CI_ERROR == SetBlocRouteSignalCheck(routeId, functionId, sendLevel)))
@@ -218,7 +242,7 @@ UINT8 SetLeadRouteP(const UINT16 routeId)
 	}
 
 	/*道岔联锁条件检查*/
-    if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLTrainRouteSwitchCheck(routeId,functionId,sendLevel)))
+    if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLeadRouteSwitchCheck(routeId,functionId,sendLevel)))
     {
         /* 失败返回 */
         reResult = CI_ERROR;
@@ -670,7 +694,7 @@ UINT8 LockLeadTrainRouteP(const UINT16 routeId)
 
 	if (CI_SUCCESS == reResult)
 	{
-		chCheckResult = SetLTrainRouteSwitchCheck(routeId, functionId, sendLevel);
+		chCheckResult = SetLeadRouteSwitchCheck(routeId, functionId, sendLevel);
 		if (CI_ERROR == chCheckResult)
 		{
 			/* 失败返回 */
@@ -1574,12 +1598,14 @@ UINT8 SetNonRouteP(UINT8 nonRouteId)
 		reResult = NonRouteRelProSwiPosMovValCheck(nonRouteId,functionId,sendLevel);
 	}
 
+#if 0
+	/*修复缺陷YF0083-2105---LYJ--20260128*/
 	if (CI_SUCCESS == reResult)
 	{/*侵限区段侵限条件不满足检查*/
 		reResult = NonRouteIntruSecVainCheck(nonRouteId,functionId,sendLevel);
 	}
 
-	
+#endif	
 
 	return reResult;
 }
@@ -1697,14 +1723,6 @@ UINT8 LockNonRouteP(UINT8 nonRouteId)
 
 		reResult = NonRouteRelProSwiPosMovValCheck(nonRouteId,functionId,sendLevel);
 	}
-
-	if (CI_SUCCESS == reResult)
-	{/*侵限区段侵限条件不满足检查*/
-		reResult = NonRouteIntruSecVainCheck(nonRouteId,functionId,sendLevel);
-	}
-
-	
-
 	return reResult;
 }
 
@@ -2183,7 +2201,8 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
     
     UINT16 devId = 0u;                   /*设备ID*/
     UINT8 devState = 0u;                 /*设备状态*/
-    
+	UINT8 chRouteCouplinkFlag = 0U;
+	UINT8 chRouteLevel = 0U;
     
 /* 联锁逻辑检查 */  
 	/* 进路内所有区段未被封锁 */
@@ -2208,7 +2227,17 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
 	{
 		devId = 0u;
 		devState = 0u;
-		checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
+		chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+		chRouteLevel = GetRouteLevel(routeId);               /*获取进路监督级别*/
+		if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
+		{
+			checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+		}
+		else
+		{
+			checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+		}
+		
 		if (checkResult == CI_SUCCESS)
 		{
 			/* 通过检查 */
@@ -2216,8 +2245,17 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
 		}
 		else
 		{
-			/* 记录故障码 */
+			if (0U == devId)
-			SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel); 
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_COUPLINK_ROUTE_IDLE, 0U, sendLevel);
+			}
+			else
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
+			}
+			
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
@@ -2370,11 +2408,12 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
 
 		}
 	}
-
+	/*场段进路不查侧防条件*/
+#if 0
 	/*进路侧防道岔条件检查*/
 	if (CI_SUCCESS == reResult)
 	{
-		checkResult = RouteAllLtrlDfncSwitchCheck(routeId, &devId, &devState);
+		checkResult =  RouteSideProtectConditionCheck(routeId, functionId, sendLevel);
 		if (CI_SUCCESS == checkResult)
 		{
 			/* 通过检查 */
@@ -2382,8 +2421,7 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
 		}
 		else
 		{
-			/* 记录故障码 */
+
-			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
@@ -2393,6 +2431,7 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
 		/* 失败返回 */
 		reResult = CI_ERROR;
 	}
+#endif
 
 	if (CI_SUCCESS == reResult)
 	{
@@ -2564,6 +2603,285 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
 	return reResult;
 }
 
+/*
+* 功能描述：办理引导进路道岔联锁条件检查
+* 参数说明：UINT16 RouteId,    进路号
+*           UINT8 functionId,  调用函数编号
+*           UINT8 sendLevel,   故障码发送级别
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2025.09.29
+*/
+UINT8 SetLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel)
+{
+	/* 局部变量定义初始化 */
+	UINT8 reResult = CI_ERROR;          /*返回值*/
+	UINT8 checkResult = CI_ERROR;       /*检查结果*/
+	UINT16 devId = 0U;                   /*设备ID*/
+	UINT8 devState = 0U;                 /*设备状态*/
+	UINT8 reResultP = CI_ERROR;          /*道岔位置局部检查返回值*/
+	UINT8 chConnetCheckFunc = 0U;
+
+	chConnetCheckFunc = GetCiFunctionSwitchConfig(FUNC_SETROUTE_CONNECT_CHECK);		/*获取是否要检查联络线条件的开关*/
+
+		/*进路内所有道岔【未引导总锁】*/
+	devId = 0U;
+	devState = 0U;
+	checkResult = RouteSwitchYLockCheck(routeId, &devId, &devState);
+	if (CI_SUCCESS == checkResult)
+	{
+		/* 通过检查 */
+		reResult = CI_SUCCESS;
+	}
+	else
+	{
+		/* 记录故障码 */
+		SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_YLOCK_STATE, devState, sendLevel);
+		/* 失败返回 */
+		reResult = CI_ERROR;
+
+	}
+
+	if (CI_SUCCESS == reResult)
+	{
+		/*进路内所有道岔【未封锁】*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteSwitchFLockCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_FLOCK_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+
+		}
+	}
+	else
+	{
+		; /*继续执行*/
+	}
+
+	if (CI_SUCCESS == reResult)
+	{
+		/*进路防护道岔【未封锁】*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteReltProtSwitchFLockCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_FLOCK_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+
+		}
+	}
+
+#if 0
+	/*进路侧防道岔条件检查*/
+	if (CI_SUCCESS == reResult)
+	{
+		checkResult = RouteSideProtectConditionCheck(routeId, functionId, sendLevel);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/* 失败返回 */
+		reResult = CI_ERROR;
+	}
+#endif
+
+	if (CI_SUCCESS == reResult)
+	{
+		if (FUNC_SWITCH_ON == chConnetCheckFunc)
+		{
+			;	/*开关打开，不检查联络线条件*/
+		}
+		else
+		{
+			/*进路联络线设备条件检查*/
+			checkResult = RouteContactLineDevSwitchCheck(routeId, functionId, sendLevel);
+			if (CI_SUCCESS == checkResult)
+			{
+				/* 通过检查 */
+				reResult = CI_SUCCESS;
+			}
+			else
+			{
+				/* 失败返回 */
+				reResult = CI_ERROR;
+			}
+		}
+	}
+
+	if (CI_SUCCESS == reResult)
+	{
+		/*进路内所有道岔位置正确或位置不正确但可动作*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteSwitchPosAndMoveValidCheck(routeId, sendLevel);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 失败返回 */
+			reResult = checkResult;
+		}
+	}
+	else
+	{
+		; /*继续执行*/
+	}
+
+	if (CI_SUCCESS == reResult)
+	{
+		/*进路内所有道岔位置正确
+			不正确：RETURN_LOCK_ERR_SWITPOS
+			正确：CI_SUCCESS  */
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteAllSwitchPosCheck(routeId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 失败返回 */
+			reResult = RETURN_LOCK_ERR_SWITPOS;
+
+		}
+	}
+	else
+	{
+		/*如果是进路内道岔等待相邻联锁反馈道岔检查状态,先不检查道岔是否全在位置，继续等待*/
+	}
+
+	if ((CI_SUCCESS == reResult) || (RETURN_LOCK_ERR_SWITPOS == reResult))
+	{
+		/*进路关联防护道岔【未引导总锁】*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteRelatedProSwitchYLockCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResultP = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_YLOCK_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResultP = CI_ERROR;
+		}
+
+		if (CI_SUCCESS == reResultP)
+		{
+			/*进路关联防护道岔位置正确或位置不正确但可动作*/
+			devId = 0U;
+			devState = 0U;
+			checkResult = RouteRelProSwiPosAndMovValCheck(routeId, sendLevel);
+			if (CI_SUCCESS == checkResult)
+			{
+				/* 能检查到防护道岔是否可动作，说明道岔全在本控区或相邻控区已反馈道岔检查状态 */
+				/* 通过检查 */
+				reResultP = CI_SUCCESS;
+			}
+			else
+			{
+				/* 失败返回 */
+				reResultP = checkResult;
+			}
+		}
+		else
+		{
+			reResultP = CI_ERROR;
+		}
+
+		if (CI_SUCCESS == reResultP)
+		{
+			/*进路关联防护道岔位置正确*/
+			devId = 0U;
+			devState = 0U;
+			checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+			if (checkResult == CI_SUCCESS)
+			{
+				/* 通过检查 */
+				reResultP = CI_SUCCESS;
+			}
+			else
+			{
+				/* 失败返回 */
+				reResultP = RETURN_LOCK_ERR_SWITPOS;
+			}
+		}
+		else
+		{
+			/*如果是进路防护道岔等待相邻联锁反馈道岔检查状态,先不检查防护道岔是否全在位置，继续等待*/
+		}
+
+		if (CI_ERROR == reResultP)
+		{/*如果防护道岔的检查结果为错误，则总的检查结果为错误*/
+			reResult = CI_ERROR;
+		}
+		else if (CI_SUCCESS == reResultP)
+		{
+			/*如果防护道岔的检查结果为成功，则总的检查结果保持不变*/
+		}
+		else if (RETURN_LOCK_ERR_WAIT_SWCHECK == reResultP)
+		{
+			/*如果防护道岔的检查结果等待检查，则总的检查结果等待检查*/
+			reResult = RETURN_LOCK_ERR_WAIT_SWCHECK;
+		}
+		else if (RETURN_LOCK_ERR_SWITPOS == reResultP)
+		{/*如果防护道岔的检查结果为锁闭位置错误，则总的检查结果为锁闭位置错误*/
+			reResult = RETURN_LOCK_ERR_SWITPOS;
+		}
+		else
+		{/*其它不存在的情况，置总的结果为错误*/
+			reResult = CI_ERROR;
+		}
+	}
+	else if (RETURN_LOCK_ERR_WAIT_SWCHECK == reResult)
+	{
+		/*进路内道岔等待相邻联锁反馈道岔检查状态,先不检查防护道岔状态，继续等待*/
+		;
+	}
+	else
+	{
+		/* 失败返回 */
+		reResult = CI_ERROR;
+	}
+	/* 返回结果 */
+	return reResult;
+}
+
 /*
 * 功能描述： 办理调车进路区段联锁条件检查
 * 参数说明：
@@ -2892,7 +3210,8 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
     
     UINT16 devId = 0u;                   /*设备ID*/
     UINT8 devState = 0u;                 /*设备状态*/
-    
+	UINT8 chRouteCouplinkFlag = 0U;
+	UINT8 chRouteLevel = 0U;
     
 /* 联锁逻辑检查 */  
 	/* 进路内所有区段未被封锁 */
@@ -2917,7 +3236,17 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
 	{
 		devId = 0u;
 		devState = 0u;
-		checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
+		chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+		chRouteLevel = GetRouteLevel(routeId);               /*获取进路监督级别*/
+		if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
+		{
+			checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+		}
+		else
+		{
+			checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+		}
+		
 		if (checkResult == CI_SUCCESS)
 		{
 			/* 通过检查 */
@@ -2925,8 +3254,17 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
 		}
 		else
 		{
-			/* 记录故障码 */
+			if (0U == devId)
-			SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel); 
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_COUPLINK_ROUTE_IDLE, 0U, sendLevel);
+			}
+			else
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
+			}
+			
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
@@ -4193,7 +4531,7 @@ UINT8 SetLeadRouteCheck(const UINT16 routeId)
 	/*道岔联锁条件检查*/
 	if (CI_SUCCESS == reResult)
 	{
-		reResult = SetLTrainRouteSwitchCheck(routeId, functionId, sendLevel);
+		reResult = SetLeadRouteSwitchCheck(routeId, functionId, sendLevel);
 		if (CI_ERROR == reResult)
 		{
 			/* 失败返回 */

TSCP/src/APP/ciapp/LogicProcess/TradInterlockLogicProcess.h

@@ -266,6 +266,17 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
 */
 UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
 
+/*
+* 功能描述：办理引导进路道岔联锁条件检查
+* 参数说明：UINT16 RouteId,    进路号
+*           UINT8 functionId,  调用函数编号
+*           UINT8 sendLevel,   故障码发送级别
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2025.09.29
+*/
+UINT8 SetLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
+
 /*
 * 功能描述： 办理调车进路区段联锁条件检查
 * 参数说明：

TSCP/src/APP/ciapp/Main/MainApp.c

@@ -46,6 +46,7 @@ UINT8 MainProcess(void)
 	UINT8 retVal = CI_SUCCESS;
 	UINT8 localCiType = GetLocalCiType();
 	UINT16* pTiocFsVersion = NULL;
+	UINT8 cControlState = 0U;  /*主备用状态*/
 	unsigned long long cost[20] = {0U};
 
     #ifdef LOGPRINT
@@ -102,6 +103,10 @@ UINT8 MainProcess(void)
 #endif/*2OO2平台标志结束*/
 	}
 
+	/*更新当前系统升主起始周期号*/
+	UpdateSystemMainUseCyc();
+	debug_infor_printf((const)"\n\nSystemMainUseCyc: %d\n", gSystemUpdateMainUseCycNum);/*系统切换主用起始周期号*/
+
     #endif/*打印标志结束*/
 
 	cost[0] = MSCP_GetTick();
@@ -113,7 +118,7 @@ UINT8 MainProcess(void)
 
 	cost[2] = MSCP_GetTick();
 	/*退出运营处理*/
-	APP_API_ExitOperation();
+	(void)APP_API_ExitOperation();
 
 
 	/*联锁逻辑处理*/
@@ -144,6 +149,21 @@ UINT8 MainProcess(void)
 	/*清除上周期故障码*/
 	ClearErrorData();
 
+	cControlState = GetLocalCiBackUpPattern();
+	
+	if (SYSTEM_WORK_MODE_UNAVAILABLE == cControlState)
+	{
+#if 0
+		/*系统不可用时，周期重置设备状态*/
+		ResetDevStateProcess();
+		debug_infor_printf((const)"\nMainProcess: ControlState[%d], ResetDevStateProcess\n", cControlState); 
+#endif
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	cost[6] = MSCP_GetTick();
 	debug_infor_printf((const)"\n Parse :%dms  InputData:%dms MainProcess:%dms Output:%dms PackOut:%dms SendLog:%dms  \n", (cost[1] - cost[0]) / 1000, (cost[2] - cost[1]) / 1000, (cost[3] - cost[2]) / 1000, (cost[4] - cost[3]) / 1000, (cost[5] - cost[4]) / 1000, (cost[6] - cost[5]) / 1000);
 

TSCP/src/APP/ciapp/Mask/MaskConfigDataManage.c

@@ -50,7 +50,7 @@ UINT16 GetMaskId(const UINT8 SendsystemType, const UINT8 RecvsystemType, const U
 {
     UINT16 returnValue = 0u;/*·µ»ØÖµ*/
 
-	if (SendsystemType == CI_SYSTEM_TYPE_CI)
+	if (SendsystemType == CI_SYSTEM_TYPE_RCI)
 	{
 		switch (RecvsystemType)
 		{
@@ -74,7 +74,7 @@ UINT16 GetMaskId(const UINT8 SendsystemType, const UINT8 RecvsystemType, const U
 	}
 	else if (SendsystemType == CI_SYSTEM_TYPE_ZC)
 	{
-		if (CI_SYSTEM_TYPE_CI == RecvsystemType)
+		if (CI_SYSTEM_TYPE_RCI == RecvsystemType)
         {
             returnValue = ZcToCiMaskConfigDataStru[Index].MaskId;
         }
@@ -345,7 +345,7 @@ UINT16 GetMaskIndex(const UINT8 SendsystemType, const UINT8 RecvsystemType, cons
 
 	
 
-    if (SendsystemType == CI_SYSTEM_TYPE_CI)
+    if (SendsystemType == CI_SYSTEM_TYPE_RCI)
     {
         switch (RecvsystemType)
         {
@@ -390,7 +390,7 @@ UINT16 GetMaskIndex(const UINT8 SendsystemType, const UINT8 RecvsystemType, cons
     }
     else if (SendsystemType == CI_SYSTEM_TYPE_ZC)
     {
-        if (CI_SYSTEM_TYPE_CI == RecvsystemType)
+        if (CI_SYSTEM_TYPE_RCI == RecvsystemType)
         {
             for (ii = 1u; ii <= ZcToCiMaskCurSum; ii++)
             {

TSCP/src/APP/ciapp/Mask/MaskDefine.h

@@ -50,6 +50,7 @@
 #define MASK_TYPE_SWITCH_OPEN_CAP                   ((UINT8)0x0E)     /*定义道岔所在板卡开盖状态*/
 #define MASK_TYPE_SWITCH_SUDDEN_JICHA              ((UINT8)0x0F)     /*定义道岔静态红闪码位*/
 #define MASK_TYPE_SWITCH_JICHA              ((UINT8)0x10)     /*定义道岔挤岔码位：28.0.0.14数据结构使用*/
+#define MASK_TYPE_SWITCH_QINGXIAN                 ((UINT8)0x11)     /*定义道岔侵限状态码位*/
 
 /*单轨_道岔码位*/
 /* zt 删除单轨相关代码 2022-02-15 */
@@ -98,8 +99,6 @@
 #define MASK_ZC_CI_SIG_ENGINEERV_NEAR              ((UINT8)0x97)    /*定义信号机工程车接近码位*/
 #define MASK_CI_ZC_SIG_ENGINCROSS_STE              ((UINT8)0x98)    /*定义信号机工程车关灯码位*/
 
-#define MASK_TYPE_SIGNAL_CROSS_RED                 ((UINT8)0x9F)    /*定义CI-ATS信号机列车闯红灯码位*/
-
 /*物理区段相关码位*/
 #define MASK_TYPE_PHYSECTION_OCCUPY                 ((UINT8)0x25)    /*定义物理区段占用码位*/
 #define MASK_TYPE_PHYSECTION_STARTLOCK              ((UINT8)0x26)    /*定义物理区段上电锁闭码位*/
@@ -119,6 +118,8 @@
 #define MASK_TYPE_PHYSECTION_HEAD_XTD				((UINT8)0x31)	/*定义物理区段运行方向下行状态码位*/
 #define MASK_TYPE_PHYSECTION_HEAD_STD				((UINT8)0x32)	/*定义物理区段运行方向上行状态码位*/
 #define MASK_TYPE_LIECHE_STOPSTATE					((UINT8)0x3a)	/*定义列车停稳信息状态码位*/
+#define MASK_TYPE_PHYSECTION_INTRUSION				((UINT8)0x5a)	/*定义物理区段侵限状态码位(CI->ZC)*/
+#define MASK_TYPE_PHYSECTION_ATS_FLOCK				((UINT8)0x5b)	/*定义物理区段由ATS封锁状态码位(CI->ZC)*/
 #define MASK_TYPE_PHYSEC_CENTERDETAIN_UP					((UINT8)0x3d)	/*定义物理区段CI-ATS中心上行扣车状态状态码位 (兼容28.0.0.14使用)*/
 #define MASK_TYPE_PHYSEC_CENTERDETAIN_DOWN				((UINT8)0x3e)	/*定义物理区段CI-ATS中心下行扣车状态状态码位 (兼容28.0.0.14使用)*/
 #define MASK_TYPE_PHYSEC_STATIONDETAIN_UP					((UINT8)0x3f)	/*定义物理区段CI-ATS车站上行扣车状态状态码位 (兼容28.0.0.14使用)*/
@@ -140,15 +141,11 @@
 #define MASK_TYPE_DOWNWARD_DIRECTION    			((UINT8)0x94)	/*定义逻辑区段下行锁闭码位*/
 #define MASK_TYPE_LOGICSECTION_PROTECTLOCK			((UINT8)0x99)	/*定义逻辑区段防护锁闭码位*/
 #define MASK_TYPE_LOGICSECTION_JUMPLOCK				((UINT8)0x9A)   /*定义逻辑区段跳跃锁闭码位*/
-#define MASK_TYPE_LOGICSECTION_ARB		            ((UINT8)0x9B)   /*定义逻辑区段ARB状态码位*/
+#define MASK_TYPE_LOGSEC_CBTC_ARB		            ((UINT8)0x9B)   /*定义逻辑区段CBTC_ARB状态码位*/
 #define MASK_TYPE_LOGICSECTION_SPKS_FLOCK		    ((UINT8)0x9C)   /*定义逻辑区段SPKS封锁状态码位*/
-#define MASK_TYPE_LOGICSECTION_ALLSEC_FLOCK			((UINT8)0x9D)	/*定义逻辑区段全线封锁状态码位*/
+#define MASK_TYPE_LOGICSECTION_EMERG_XIANSU         ((UINT8)0x9D)   /*定义逻辑区段紧急临时限速码位*/
-#define MASK_TYPE_LOGICSECTION_APG_FLOCK			((UINT8)0x9E)	/*定义逻辑区段站台门异常打开封锁码位*/
+#define MASK_TYPE_LOGSEC_PB_TACS_ARB		        ((UINT8)0xB3)   /*定义逻辑区段PB_TACS_ARB状态码位*/
-#define MASK_TYPE_LOGICSECTION_PROHIBIT_FAO			((UINT8)0x9F)	/*定义逻辑区段禁止FAO运行码位*/
+
-#define MASK_TYPE_LOGICSECTION_CMD_FLOCK			((UINT8)0xA0)	/*定义逻辑区段人工封锁码位*/
-#define MASK_TYPE_LOGICSECTION_ESB_FLOCK			((UINT8)0xA1)	/*定义逻辑区段ESB封锁码位*/
-#define MASK_TYPE_LOGICSECTION_CESB_FLOCK			((UINT8)0xA2)	/*定义逻辑区段CESB封锁码位*/
-#define MASK_TYPE_LOGICSECTION_OVERRIDE				((UINT8)0xA8)	/*定义逻辑区段旁路码位*/
 
 /*保护区段相关码位*/
 #define MASK_TYPE_OVERLAP_LOCKSTATE                 ((UINT8)0x30)   /*定义保护区段锁闭状态码位*/
@@ -174,6 +171,8 @@
 #define MASK_TYPE_ROUTE_DC_AGREE					((UINT8)0x52)    /*定义进路调车同意状态码位(CI-ATS)*/
 #define MASK_TYPE_ROUTE_AUTO_TRIGGER                ((UINT8)0x53)    /*定义进路自动触发标码位(CI-ATS)*/
 #define MASK_TYPE_ROUTE_DC_AGREE_ERR				((UINT8)0x54)    /*定义进路调车同意按钮故障状态码位(CI-ATS)*/
+#define MASK_TYPE_ROUTE_COUPLIN_SUCCESS				((UINT8)0xA8)    /*定义进路联挂成功码位(ZC-CI)*/
+#define MASK_TYPE_ROUTE_COUPLIN_ERROR				((UINT8)0xA9)    /*定义进路联挂失败码位(ZC-CI)*/
 
 
 /*站台相关码位*/
@@ -188,8 +187,9 @@
 #define MASK_TYPE_CANCEL_ESP_FAULT                  ((UINT8)0x9c)    /*定义取消紧急关闭按钮故障码位*/
 #define MASK_TYPE_ESP_FAULT                         ((UINT8)0x9d)    /*定义紧急关闭按钮故障码位*/
 #define MASK_TYPE_CUT_ESP_FAULT                     ((UINT8)0xA3)    /*定义紧急关闭旁路按钮故障码位*/
-#define MASK_TYPE_ESP_PRESS_STATE                   ((UINT8)0xA4)    /*定义紧急关闭按钮按下状态码位*/
+#define MASK_TYPE_CUT_ESP_STATE                     ((UINT8)0xA4)    /*定义紧急关闭旁路按钮激活状态码位*/
-#define MASK_TYPE_ESS_STATE                   ((UINT8)0xA7)    /*定义ESS去位/停位状态码位*/
+#define MASK_TYPE_ONEPLAT_ESP_STATE                 ((UINT8)0xAB)    /*定义紧急关闭按钮同站紧急按钮激活状态码位*/
+#define MASK_TYPE_ONEPLAT_CUT_ESP_STATE             ((UINT8)0xAC)    /*定义紧急关闭按钮同站旁路按钮激活状态码位*/
 
 /*站台安全门相关码位*/
 #define MASK_TYPE_PSD_STATE                         ((UINT8)0x60)   /*定义站台安全门状态码位-ZC,LEU用*/
@@ -207,9 +207,11 @@
 #define MASK_TYPE_PSD_PDB_FLASH_STATE		        ((UINT8)0xA0)	/*定义清客确认箱PDB按钮指示灯闪灯状态码位*/
 #define MASK_TYPE_PSD_VIDEO_QK_LU		            ((UINT8)0xA1)	/*定义清客按钮箱视频清客表示灯（绿)状态码位*/
 #define MASK_TYPE_PSD_VIDEO_QK_HONG		            ((UINT8)0xA2)	/*定义清客按钮箱视频清客表示灯（红)状态码位*/
-#define MASK_TYPE_PSD_EXCEPT_OPEN                   ((UINT8)0xA5)   /*定义站台安全门异常打开码位*/
+#define MASK_TYPE_PSD_EXCEPT                   ((UINT8)0xA5)   /*定义站台安全门异常码位 CI-ATS、CI-ZC*/
-#define MASK_TYPE_PSD_MUTUALLOCK_BTNERR                   ((UINT8)0xA6)   /*定义站台安全门互锁解除按钮异常码位*/
+#define MASK_TYPE_PSD_JXTCPANGLU_FAULT              ((UINT8)0xAA)   /*定义间隙探测旁路按钮故障码位*/
-
+#define MASK_TYPE_PSD_IBP_STATE                     ((UINT8)0xAD)   /*定义IBP盘按钮状态码位*/
+#define MASK_TYPE_PSD_IBP_FAULT                     ((UINT8)0xAE)   /*定义IBP盘按钮故障码位*/
+#define MASK_TYPE_PSD_JXTC_STATE                    ((UINT8)0xAF)   /*定义间隙探测状态码位*/
 /*车库门相关码位*/
 #define MASK_TYPE_GARAGEDOOR_OPEN_STATE             ((UINT8)0x62)    /*定义车库门开门状态码位（CI->ATS）*/
 #define MASK_TYPE_GARAGEDOOR_CLOSE_STATE            ((UINT8)0x63)    /*定义车库门关门状态码位（CI->ATS）*/
@@ -241,13 +243,12 @@
 /*洗车机相关码位*/
 #define MASK_TYPE_WASHMACHINE_READYSTATE			((UINT8)0x74)	/*定义洗车机就绪状态码位*/
 #define MASK_TYPE_WASHMACHINE_WORKMODE			    ((UINT8)0x9E)	/*定义洗车机工作模式码位*/
+#define MASK_TYPE_WASHMACHINE_ZNTBUTTN            ((UINT8)0x9F)	/*定义CI-ATS洗车机降级模式洗车线洗车同意按钮粘连码位,0有粘连，1为无粘连*/ 
+#define MASK_TYPE_DCCWASHACHINE_ZNTBUTTN        ((UINT8)0xb0)	/*定义CI-ATS洗车机降级模式DCC洗车同意按钮粘连码位,0有粘连，1为无粘连*/    
+#define MASK_TYPE_PASSWASHMACHINE_ZNTBUTTN            ((UINT8)0xb1)	/*定义CI-ATS洗车机降级模式洗车线洗车反向通过同意按钮粘连码位,0有粘连，1为无粘连*/
+#define MASK_TYPE_DCCPASSWASHMACHINE_ZNTBUTTN        ((UINT8)0xb2)	/*定义CI-ATS洗车机降级模式DCC洗车反向通过同意按钮粘连码位,0有粘连，1为无粘连*/
 
 /*防淹门相关码位*/
 
-/*临时限速相关码位*/
-#define  MASK_TYPE_SPEEDLIMITSEC_STATE              ((UINT8)0x9F)  /*CI-ATS限速区段临时限速设置码位*/
-#define  MASK_TYPE_SPEEDLIMITTF_STATE               ((UINT8)0xa9)  /*CI-ATS限速区段台风限速设置码位*/
-#define  MASK_TYPE_SPEEDLIMITTNR_STATE              ((UINT8)0xab)  /*CI-ATS限速区段NR限速设置码位*/
-#define  MASK_TYPE_SPEEDLIMITQX_STATE               ((UINT8)0xac)  /*CI-ATS限速区段全线临时限速设置码位*/
 
 #endif

TSCP/src/APP/ciapp/NonAutoReturn/NonAutoReturnDataManage.c

@@ -15,7 +15,8 @@
 
 
 
-NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX];   /*无人自动折返动态结构体*/
+NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX];       /*无人自动折返动态结构体*/
+NonAutoReturnDataStructCC NonReturnDataStruCC[NON_AUTO_RETURN_SUM_MAX];   /*无人自动折返动态结构体-车车*/
 
 /*
 * 功能描述： 获取无人折返数据结构体指针
@@ -28,6 +29,16 @@ NonAutoReturnDataStruct* GetNonReturnData(void)
 	return NonReturnDataStru;
 }
 
+/*
+* 功能描述： 获取无人折返数据结构体指针-车车
+* 参数说明：
+* 返回值  ：
+			NonAutoReturnDataStruct *
+*/
+NonAutoReturnDataStruct* GetNonReturnDataCC(void)
+{
+	return NonReturnDataStruCC;
+}
 /*
 * 功能描述： 获取指定ID无人自动折返按钮命令列车ID
 * 参数说明： const UINT16 autoReturnId, 自动折返ID
@@ -41,7 +52,7 @@ UINT16 GetNonRtnCmdSetTrainId(const UINT16 nonReturnId)
 	bufIndex = GetNonReturnBufIndex(nonReturnId);
 	if (bufIndex < NON_AUTO_RETURN_SUM_MAX)
 	{
-		trainId = NonReturnDataStru[bufIndex].cmdSetTrainId;
+		trainId = NonReturnDataStruCC[bufIndex].cmdSetTrainId;
 	}
 	else
 	{
@@ -64,7 +75,7 @@ void SetNonRtnCmdSetTrainId(const UINT16 nonReturnId,const UINT16 trainId)
 	if (bufIndex < NON_AUTO_RETURN_SUM_MAX)
 	{
 		
-		NonReturnDataStru[bufIndex].cmdSetTrainId = trainId;
+		NonReturnDataStruCC[bufIndex].cmdSetTrainId = trainId;
 	}
 	else
 	{

TSCP/src/APP/ciapp/NonAutoReturn/NonAutoReturnDataManage.h

@@ -35,15 +35,21 @@ typedef struct S_RtnRelayAdhesionStruct
 /*无人自动自动折返数据结构体*/
 typedef struct S_NonAutoReturnDataStruct
 {
-	UINT16 cmdSetTrainId;												/*命令列车ID (动态字段)*/
 	UINT8 IndicatorDevID; /*指示灯设备ID*/
 	UINT8 VobcToCIAutoRtnIndicFlashState; /*车载给联锁的无人折返指示灯闪灯状态*/
 	UINT8 VobcToCIAutoRtnIndicSteadyState; /*车载给联锁的无人折返指示灯稳灯状态*/
 	RtnRelayAdhesionStruct RtnRelayAdhesionState; /*无人折返继电器粘连状态*/
 } NonAutoReturnDataStruct;
 
-extern NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX];   /*无人自动折返动态结构体*/
+/*无人自动自动折返数据结构体-车车*/
+typedef struct S_NonAutoReturnDataStructCC
+{
+	UINT8 IndicatorDevID; /*指示灯设备ID*/
+	UINT16 cmdSetTrainId;												/*命令列车ID (动态字段)*/
+} NonAutoReturnDataStructCC;
 
+extern NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX];   /*无人自动折返动态结构体*/
+extern NonAutoReturnDataStructCC NonReturnDataStruCC[NON_AUTO_RETURN_SUM_MAX];   /*无人自动折返动态结构体-车车*/
 /*
 * 功能描述： 获取指定ID无人自动折返按钮命令列车ID
 * 参数说明： const UINT16 autoReturnId, 自动折返ID
@@ -51,6 +57,13 @@ extern NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX];   /*
 *			>0: 无人自动折返按钮指示灯继电器ID
 */
 UINT16 GetNonRtnCmdSetTrainId(const UINT16 nonReturnId);
+/*
+* 功能描述： 获取无人折返数据结构体指针-车车
+* 参数说明：
+* 返回值  ：
+			NonAutoReturnDataStruct *
+*/
+NonAutoReturnDataStruct* GetNonReturnDataCC(void);
 
 /*
 * 功能描述： 获取无人折返数据结构体指针