9.9首版首轮发签代码 Merge branch 'test/9.9外网接收时间测试' into dev/9.9

TSCP/Makefile

@@ -20,77 +20,23 @@ LD = $(CC)
 
 #INCLUDES += -I/path/to/my/lib/include
 #INCLUDES += -I../mylib/public
-INCLUDES += -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/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 \
+INCLUDES += -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,9 +230,63 @@ 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)
+		/*若为真机，则通过平台获取设备类型*/
+		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文件名称 */
@@ -246,43 +306,21 @@ 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 */
-			.CPU[0].IP_2x2 = "192.168.1.62",       /**< 2x2通信IP */
-			.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 */
+			.M_Area_Enable = 0,			/**< 区域状态开关配置 */
+			.M_AREA_SEB_Enable = 0xAA,	 /**< RC与CI扩展板卡通信功能开关配置 */
+			
 			.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, 	 /**< 暗文日志记录发送端口 */
 													 /*通用端口配置*/
@@ -313,6 +351,9 @@ void APP_API_Data_Init()
 			.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,   		/**< 内网透传通信端口 */
@@ -321,23 +362,177 @@ void APP_API_Data_Init()
 			.OutNetBlue.CC_P_IP = "192.168.2.61",  /**< 通控的内网IP */
 			.OutNetBlue.EXTEND_G_IP = "192.168.1.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,  /**< 紫网安全端口 */
+
 		};
+
+
+		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版本号*/
@@ -359,6 +554,7 @@ void APP_API_Data_Init()
 		MSCP_SetSfpInnetPara(g_SfpInnetParam);
 		MSCP_SetAppVersion(appVersBuffer);
 		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 chDstCiType = 0U; /*本联锁属性*/
-	UINT8 chCldScxCommMode = 0U;
+	UINT8 chWorkType = 0U; /*双系工作模式*/
+	UINT8 cControlState = 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();
-		chDstCiType = GetCiType(devId);
-		chCldScxCommMode = GetCiFunctionSwitchConfig(SCX_CLD_INTERFACE_TYPE);
+		chResult = IsSerialDevice(dstDevTypeId, &serialGroup);
 
-		if ((SCX_CLD_SERIAL_PORT_COMM == chCldScxCommMode) && (CI_SYSTEM_TYPE_CI == 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)
+		if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == 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               101   /*集成次数编号*/
+#define VER_INTE_TIME               127   /*集成次数编号*/
 
 #endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/

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

@@ -56,6 +56,7 @@
 #include "../Route/LogicalRouteDataManage.h"
 #include "../Route/LongRouteDataManage.h"
 #include "../ReverseCut/ReverseCutDataManage.h"
+#include "../AxisSort/AxisSort.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -153,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:当前数据指针
@@ -188,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,20 +94,20 @@ QueueStruct logPrintfQue;            /*
 /*
 * 功能描述： 平台初始化
 * 参数说明： void
-* 返回值  ： NULL: 获取数据失败
-*           !NULL: 平台ATS到CI接口队列
+* 返回值  ： 0: 失败
+*            1: 成功
+* Modified By LQ 2025.08.27
 */
 UINT8 Initial2oo2Interface(void)
 {
-	UINT8 rtn = 0u;
-	UINT16 locTypeId = 0;
-	UINT8 result = 0u;
+	UINT8 rtn = CI_ERROR;
+	UINT8 result = 0U;
 
 	/*定义平台数据队列指针*/
 
 #ifdef PLATFORM_2OO2
 
-	
+	rtn = CI_SUCCESS;
 	ProtocolToCiDataQueue = &gCbtcData.DataToApp;       /*初始化协议到CI数据队列*/
 	CiToProtocolDataQueue = &gCbtcData.OutputDataQueue; /*初始化CI到协议数据队列*/
 
@@ -155,19 +152,20 @@ UINT8 Initial2oo2Interface(void)
 	CiToLEUDataQueue = CiToFsfbDataQueue;			   /*初始化CI到Leu数据队列*/
 
 	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 (CI_SUCCESS == rtn)
+	{
 		if (1U != QueueInitial(&logPrintfQue, 500000U))       /*初始化日志缓存队列*/
 		{
 			debug_infor_printf((const)"canQueueRecv init error \n");
+			rtn = CI_ERROR;
 		}
+		else
+		{
 
 #if 0
 			/*联锁与LEU、ZC、CI等的通信状态描述*/
@@ -195,11 +193,21 @@ UINT8 Initial2oo2Interface(void)
 			result = HLHTCiIdMapInitial();
 			if (CI_SUCCESS == result)
 			{
-		rtn = 1;
+				rtn = CI_SUCCESS;
+			}
+			else
+			{
+				debug_infor_printf((const)"Initial2oo2Interface init error: HLHTCiIdMapInitial Error\n");
+				rtn = CI_ERROR;  /*返回失败*/
+			}
+		}
+	}
+	else
+	{
+		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

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: 获取数据失败
-*           !NULL: 平台ATS到CI接口队列
+* 返回值  ： 0: 失败
+*            1: 成功
+* Modified By LQ 2025.08.27
 */
 UINT8 Initial2oo2Interface(void);
 

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/AxisAssertManageAPI.c

@@ -394,7 +394,7 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 				; /*继续处理*/
 			}
 			/** 判断相邻范围内计轴坏车最近占用时间检查通过 */
-			if ((CI_ERROR == chNearbyCheck))
+			if (CI_ERROR == chNearbyCheck)
 			{
 				/*有 坏车接近 或左右相邻计轴均无车接近 立即清除冗余计时*/
 				if ((AAM_BAD_NEAR == sameTrainType) || (AAM_BAD_NEAR == convertTrainType))
@@ -423,7 +423,6 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 				/** 冗余计时位加1*/
 				aam_AddRedunTime(acIndex, maxRedunTimes);
 			}
-
 			/** 计轴故障的判断 */
 			tmpRedunTime = aam_GetRedunTime(acIndex);
 			tmppassTrainType = aam_GetPassTrainFlag(acIndex);
@@ -2111,7 +2110,7 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
 	UINT8 cRetVal = CI_ERROR;
 	UINT16 wBufIndex = 0U;
 	UINT16 wCurRelPhySecId = 0U;  /*本计轴区段所属物理区段ID*/
-	UINT8 dwCiAndAxleTransBadEnsureCnt = 0U;  /*判断与计轴通信中断周期数*/
+	UINT32 dwCiAndAxleTransBadEnsureCnt = 0U;  /*判断与计轴通信中断周期数*/
 	UINT32 dwCurAxleOccStartCycNum = 0U;  /*本计轴区段占用起始周期*/
 	UINT8 ii = 0U;
 	UINT16 wNearRelPhySecId = 0U;  /*相邻计轴区段所属物理区段ID*/

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));
-		copyIndex += (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));
+		/*拷贝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));
-		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));
+		/*拷贝列车排序*/
+		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/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;
-	UINT16 u16CiA, u16CiB;
+	UINT32 etcsIdA = 0U;
+	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);
-	u16CiB = (UINT16)((CI_SYSTEM_TYPE_CI * 256u) + ciB);
+	u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciA);
+	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);
-
-	dquDevNameB = dquDevName2HlhtId(u16CiB,0u,&etcsIdB);
-
-	if(DQU_CBTC_CPK == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;
-	}
-	else if(DQU_CBTC_FAO == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;	
-	}
-	else if(DQU_CBTC_HLT == cbtcSysType)
-	{
 	/*需要增加互联互通的判断*/
 	if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
 	{
 		/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
-			if ((etcsIdA&((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
+		if ((etcsIdA & ((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
+		{
+			retVal = SAME_LINE_YES;
+
+			/*同一条线路，一期二期使用不同厂家联锁，也判为不同线路，接口走互联互通*/
+			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,10 +197,14 @@ UINT32 GetCiTranCiDataCheckVer(const UINT8 ciId, const UINT16 deviceName)
 	UINT32 retDataVer = CI_ERROR;
 	UINT8 ii = 0U;
 	UINT8 chBreakFlag = 0U;
-
-	if ((ciId > 0U) && (ciId < CI_SUM_MAX) && (deviceName > 0U))
+	UINT8 chDevType = 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)
+		{
+			if (RC_WORK_MODE_CI == chDevType)
 			{
 				for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinCICount; ii++)
 				{
@@ -227,6 +226,29 @@ UINT32 GetCiTranCiDataCheckVer(const UINT8 ciId, const UINT16 deviceName)
 					}
 				}
 			}
+			else
+			{
+				for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinRCCount; ii++)
+				{
+					if (ii < CI_TRAINSMIT_CI_MAX_NUM)
+					{
+						if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinRCId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinRCId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinRCId[ii] < 0xFFFFU))
+						{
+							retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinRCShareCheckData[ii];
+							chBreakFlag = 1U;
+						}
+					}
+					else
+					{
+						chBreakFlag = 1U;
+					}
+					if (1U == chBreakFlag)
+					{
+						break;
+					}
+				}
+			}
+		}
 	}
 	return retDataVer;
 }

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.c

@@ -46,6 +46,8 @@ UINT8 g_AllTsrFlag = CI_ALL_TSR_UNVALID;												  /*
 
 UINT8 g_AllSnowModel = CI_ALL_SNOW_UNVALID;                                                 /*全线雨雪模式命令：0x55-有效；0xAA-无效*/
 
+UINT8 g_AllSnowModelCC = CI_ALL_SNOW_UNVALID;                                                 /*全线雨雪模式命令CC：0x55-有效；0xAA-无效*/
+
 UINT8 g_AllSnowLevel = CI_SNOW_LEVEL_DEFAULT;                                                 /*全线湿轨级别：0-默认值；1-一级；2-二级*/
 
 UINT8 g_IteLineCutState = CI_ITE_LINE_CUT_DEFAULT;                                          /*ITE全线切除状态：0x55：切除ITE；0xAA：使用ITE；0xFF：默认值*/
@@ -86,11 +88,15 @@ CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX] = { 0u };
 UINT8 LocalAreaSnowNum = 0U;  /*本地区间雨雪站台数量*/
 AreaSnowInfoStruct szLocalAreaSnow[LOCAL_AREA_SNOW_SUM_MAX] = { 0U };  /*本地区间雨雪数组*/
 
+UINT8 gLocalAreaSnowNumCC = 0U;  /*本地区间雨雪站台数量CC*/
+AreaSnowInfoStruct gszLocalAreaSnowCC[LOCAL_AREA_SNOW_SUM_MAX] = { 0U };  /*本地区间雨雪数组CC*/
+
 LineCommTrainStruct gStrLineCommTrain = { 0U };  /*全线通信车结构体*/
 
 UINT32 gFlyProtectOverCyc = 0U;										                  /*飞车宕机报警起始周期*/
 
 UINT8 g_LocalSnowModel = CI_LOCAL_SNOW_UNVALID;   /*本地雨雪模式命令*/
+UINT8 g_LocalSnowModelCC = CI_LOCAL_SNOW_UNVALID;   /*本地雨雪模式命令CC*/
 
 UINT8 gLocalAreaIteCutNum = 0U;  /*本地区间ITE切除数量*/
 UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX] = { 0U };  /*本地区间ITE切除ID数组——需要存储ZC发送的所有区间ID*/
@@ -210,46 +216,6 @@ UINT8 GetLabourCancelLinShiXianState(void)
 	return LabourCancelLinShiXianState;
 }
 
-
-/*
-	功能描述：人工取消临时限速状态迁移处理
-	参数说明：setFlag  状态
-	返回值：无
-*/
-void LabourCancelLSXianStaMoveProc(UINT8 setFlag)
-{
-	UINT8 linShiXianState = 0u;
-	UINT8 wholelinShiXianState = 0u;
-	linShiXianState = GetLabourCancelLinShiXianState();
-	wholelinShiXianState = GetWholeLineLinShiXianSuFlag();
-	switch(setFlag)
-	{
-		case LINSHIXIANSU_COMM_GOOD_STATE:/*与ZC通信正常状态*/
-			if((LINSHIXIANSU_COMM_BAD_STATE == linShiXianState) || 
-			   (LINSHIXIANSU_LABOURCANCLE_YES_STATE == linShiXianState))
-			{/*前一状态为： 通信故障且未进行人工取消  ||  通信故障且进行了人工取消   则进行状态迁移*/
-				LabourCancelLinShiXianState = setFlag;
-			}
-			break;
-		case LINSHIXIANSU_COMM_BAD_STATE:/*与ZC通信故障状态*/
-			if((LINSHIXIANSU_COMM_GOOD_STATE == linShiXianState) && (WHOLE_LINE_LINSHIXIANSUSET_YES == wholelinShiXianState))
-			{/*前一状态为：通信正常状态且临时限速标志为设置  则进行状态迁移*/
-				LabourCancelLinShiXianState = setFlag;
-			}
-			break;
-		case LINSHIXIANSU_LABOURCANCLE_YES_STATE:/*已经进行了人工取消临时限速*/
-			if(LINSHIXIANSU_COMM_BAD_STATE == linShiXianState)
-			{/*前一状态为：通信故障状态  则进行状态迁移*/
-				LabourCancelLinShiXianState = setFlag;
-			}
-			break;
-		default:
-			/*不可达分支*/
-			break;
-
-			
-	}
-}
 /*
 	功能描述：人工取消临时限速状态迁移处理
 	参数说明：setFlag  状态,UINT8 virCIid 虚拟联锁ID
@@ -1262,10 +1228,18 @@ void RouteDrvInnerSwitch(const UINT16 routeId, const UINT8 DrivFlag)
 			switchId = pRouteProtectSwitchStru[ii].ProtectSwitchId;
 			chSwitchBelCiId = GetSwitchBelongCiId(switchId);
 			if ((chLocalCiId == chSwitchBelCiId) && (0U != chLocalCiId))
+			{
+				funRtn = CheckSwitchPosAndMoveValid(pRouteProtectSwitchStru[ii].ProtectSwitchId, pRouteProtectSwitchStru[ii].ProtectPosition, ESEND_LEVEL_ZERO);
+				if (CI_ERROR == funRtn)
+				{
+					/*不可动防护道岔不进行驱动，已在锁闭条件中通过二级侧防进行防护*/
+				}
+				else
 				{
 					switchExpPos = pRouteProtectSwitchStru[ii].ProtectPosition;
 					(void)SwitchDriveProcess(switchId, switchExpPos); /*设置进路关联防护道岔的驱动状态为驱动中*/
 				}
+			}
 			else
 			{
 				;
@@ -1318,17 +1292,13 @@ edit cgh 20241203
 UINT8 RouteLockDriveSwitch(const UINT16 routeId, const UINT8 NeedForDrvRoutAssoSwit)
 {
     UINT8 ii = 0u;
-	UINT8 switchSum = 0u;
 	UINT16 switchId = 0u;
 	UINT8 switchExpPosition = SWITCH_POSITION_INVALID;			/*道岔期望位置*/
     UINT8 switchDancaoPosition = SWITCH_POSITION_INVALID; 		/*单操有效位置*/
-	RouteSwitchStruct* pRouteSwitchStru = NULL;					/*道岔数据结构指针*/
 	UINT8 innerSwitchRetVal = CI_ERROR;							/*检查进路内道岔是否可被驱动的结果*/
 	UINT8 assocSwitchRetVal = CI_ERROR; 						/*检查带动道岔是否可被驱动的结果*/
 	UINT8 assocSwitchSum = 0u; 									/*道岔数目*/
 	RouteAssocSwitchStruct routeAssocSwitchStru = {0,0}; 		        /*道岔数据*/
-	UINT8 routeProtectSwitchSum = 0u; 							/*防护道岔数目*/
-	RouteProtectSwitchStruct* pRouteProtectSwitchStru = NULL;    /*防护道岔数据*/
 	UINT8 chAutoCheck = 0U;
 	UINT8 chSendLevel = 0U;
 	chAutoCheck = AutoSignalOrRouteValid(routeId);
@@ -1696,10 +1666,10 @@ void DriveSignalOpen(const UINT16 signalId, const UINT16 routeId)
 
 	UINT8 bCiSwitchShowGreenYellow = FUNC_SWITCH_OFF;/*ci显示绿黄开关,默认是关闭的*/
 	UINT8 belongVirCI= 0u;
-	UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 sigalMaintainState = 0u;
 	UINT8 signalIsfushiFlag = 0u;
 	UINT8 signalCurDriveColor = 0u;
+	UINT8 chRoutelightFlag = 0U;
 
 	routeLevel = GetRouteLevel(routeId);  /*获取进路级别*/
 	if(ROUTE_LEVEL_BLOC == routeLevel)
@@ -1789,19 +1759,24 @@ void DriveSignalOpen(const UINT16 signalId, const UINT16 routeId)
 		}
 
 	    /*虚拟联锁兼容*/
-		if(FUNC_SWITCH_ON == includeVirFlag)
-		{
 		belongVirCI = GetSignalBelongVirCiId(signalId);
 		allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCI);/*本虚拟联锁全站亮灯标志*/
-		}
-		else
-		{
-			allSignalBrightFlag = GetAllSignalBrightFlag();  /*全站亮灯标志*/
-		}
+		
+		
 		
 		lightExtinctState = GetSignalLightExtinctState(signalId);/*信号机亮灭状态*/
 		sigalMaintainState = GetSignalMaintainState(signalId);/*信号机维修点灯状态*/
 
+		chRoutelightFlag = GetSignalShineBit2(signalId);
+		if (SIGNAL_LIGHT_CONFIG_CBTC_LIGHT_BIT2 == chRoutelightFlag)
+		{
+			lightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
+		}
+		else
+		{
+			/*数据配置常亮，CBTC接近时灭灯，驱动亮灯；配置其他依据亮灭灯状态*/
+
+		}
 		signalIsfushiFlag = GetSignalIsfushiFlag(signalId);
 		signalCurDriveColor = GetSignalCurDriveColor(signalId);
 		if ((SIGNAL_DRIVECOLOUR_NULL == signalCurDriveColor)&&(SIGNALTYPE_FUSHI_YES != signalIsfushiFlag))/*驱开放增加是否复示防护逻辑，避免数据配错导致的异常情况*/
@@ -2061,7 +2036,6 @@ UINT8 DriveSignalClose(const UINT16 signalId)
 	UINT8 belongVirCIid = 0u;
 	UINT8 detainOpenRedBright = 0u;        
 	UINT8 signalDetainFlag = 0u;
-	UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 sigalMaintainState = 0u;
 	UINT8 signalIsfushiFlag = 0u;
 	UINT16 wSigInFirstPhyId = 0U;
@@ -2069,22 +2043,18 @@ UINT8 DriveSignalClose(const UINT16 signalId)
 	UINT8 routeLeadProperty = 0U;
 	UINT8 routeState = 0U;
 	UINT16 wStartSignalId = 0u;
+	UINT8 chRoutelightFlag = 0U;
     if ((0u == signalId) || (signalId >= SIGNAL_SUM_MAX))
     {
 		reVal = CI_ERROR;
     }
 	else
 	{
-	    /*虚拟联锁兼容*/
-		if(FUNC_SWITCH_ON == includeVirFlag)
-		{
+	  
+		
 		belongVirCIid = GetSignalBelongVirCiId(signalId);
 		allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCIid); /*全站亮灯标志*/	
-		}
-		else
-		{
-			allSignalBrightFlag = GetAllSignalBrightFlag();  /*全站亮灯标志*/
-		}
+		
 		/*无论什么时候，复示信号机关闭都驱动红灭*/
 		signalIsfushiFlag = GetSignalIsfushiFlag(signalId);
 		if (SIGNALTYPE_FUSHI_YES == signalIsfushiFlag)
@@ -2103,6 +2073,15 @@ UINT8 DriveSignalClose(const UINT16 signalId)
 			routeState = GetRouteState(routeId);/*获取进路状态*/
 			wStartSignalId = GetRouteStartSignalId(routeId);
 
+			chRoutelightFlag = GetSignalShineBit2(signalId);
+			if (SIGNAL_LIGHT_CONFIG_CBTC_LIGHT_BIT2 == chRoutelightFlag)
+			{
+				lightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
+			}
+			else
+			{
+				/*数据配置常亮，CBTC接近时灭灯，驱动亮灯；配置其他依据亮灭灯状态*/
+			}
 			if (((ROUTE_LEAD_PROPERTY_YES == routeLeadProperty) || (ROUTE_LEAD_PROPERTY_CBTC_YES == routeLeadProperty))
 				&& ((ROUTE_STATE_LEAD_LOCK == routeState)
 					|| (ROUTE_STATE_LEAD_LOCKERR == routeState)
@@ -3253,7 +3232,6 @@ UINT8 GetSwitchRouteLockState(UINT16 switchId)
 {
 	UINT16 bufIndex = 0u;		/*数组下标*/
 	UINT16 belongSecId = 0u;		/*所属区段ID*/
-    UINT16 doubleSwitchId = 0u;  /*双动道岔ID*/
 	UINT8 belongPhySecState = 0u;	/*所属物理区段的进路状态*/
 	UINT8 reVal = CI_ERROR;
 
@@ -3275,21 +3253,7 @@ UINT8 GetSwitchRouteLockState(UINT16 switchId)
 		}
         else
         {
-            doubleSwitchId = GetDSwitchOtherId(switchId);/*获取双动道岔ID*/
-            if (doubleSwitchId != 0u)
-            {/*双动道岔非空*/
-
-                belongSecId = GetSwitchPhySectionId(doubleSwitchId);
-                belongPhySecState = GetPhySecLockState(belongSecId);
-                
-                if ((PHYSICAL_SECTION_LOCK_NORMAL == belongPhySecState) || 
-                    (PHYSICAL_SECTION_LOCK_PROTECT == belongPhySecState) ||
-					(PHYSICAL_SECTION_LOCK_DELAY == belongPhySecState) ||
-					(PHYSICAL_SECTION_LOCK_FAULTDELAY == belongPhySecState))
-                {
-                    reVal = CI_SUCCESS;
-                }
-            }            
+              /*双动道岔锁闭状态不处理*/ 
         }
     }
 	return reVal;
@@ -4344,7 +4308,6 @@ void YLockSignalOpenManage(void)
 	UINT8 belongVirCI = 0u;
 	UINT8 flag = 0u;
 	UINT8 yLockState = 0u;
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 
 	
     /*处理信号机*/
@@ -4356,15 +4319,12 @@ void YLockSignalOpenManage(void)
         
         signalId = GetSignalId(ii);                         /*获取信号机ID*/
         belongCiId = GetSignalBelongCiId(signalId);           /*获取进路所属联锁ID*/
-		if(FUNC_SWITCH_ON == includeVirFlag)
-		{
+		
+		
 		belongVirCI = GetSignalBelongVirCiId(signalId); /*获取信号机所属虚拟联锁ID*/
 		yLockState = GetVirCIAllSwitchYLockState(belongVirCI);
-		}
-		else
-		{
-			yLockState = GetAllSwitchYLockFlag();
-		}
+		
+		
         
         if ((0u == signalId) || (signalId >= SIGNAL_SUM_MAX))
         {
@@ -5037,15 +4997,15 @@ void SetPhySecSpksFLockBySpksId(UINT16 spksId,UINT8 spksStatus)
 */
 UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const chkDevStatus)
 {	
-	UINT8 devState = 0u;
-	UINT8 tmpDevState = 0u;
-	UINT8 tmpPsdVobcCmd = 0u;
-	UINT8 tmpColor = 0u;
-	UINT8 ttmpDevState = 0u;
-	UINT8 psdMutualLockState = 0u;
-	UINT16 tempdevId = 0u;                   /*临时设备ID*/
-	UINT8 tempdevState = 0u;                 /*临时设备状态*/
-
+	UINT8 devState = 0U;
+	UINT8 tmpDevState = 0U;
+	UINT8 tmpPsdVobcCmd = 0U;
+	UINT8 tmpColor = 0U;
+	UINT8 ttmpDevState = 0U;
+	UINT8 psdMutualLockState = 0U;
+	UINT16 tempdevId = 0U;                   /*临时设备ID*/
+	UINT8 tempdevState = 0U;                 /*临时设备状态*/
+	UINT8 chPsdExceptState = 0U;
 	switch(devType)
 	{
 	case CI_DEVICE_TYPE_SWITCH:           /*道岔*/
@@ -5060,12 +5020,12 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_SIGNAL:          /*信号机*/
 		tmpColor = GetSignalCurColor(devId);
-		if (tmpColor > 0u)
+		if (0U < tmpColor)
 		{
 			tmpDevState = GetSignalOpenCloseState(tmpColor);
 			if (SIGNAL_OPEN == tmpDevState)
@@ -5079,7 +5039,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_ROUTE:          /*进路*/
@@ -5113,13 +5073,21 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_PSD:              /*站台屏蔽门*/
 		tmpDevState = GetPsdState(devId);
 		tmpPsdVobcCmd = GetPsdVobcCmd(devId);
 		psdMutualLockState = GetPsdMutualLockRemoveState(devId);
+		chPsdExceptState = GePsdExceptState(devId);
+
+		if (PSD_EXCEPT_NO != chPsdExceptState)
+		{
+			devState = OTHER_CI_PSD_STATUS_OPEN;  /* 屏蔽门异常状态,则认为打开 */
+		}
+		else
+		{
 			if ((PSD_MUTUALLOCK_REMOVE_YES == psdMutualLockState) || (PSD_ATS_MUTUALLOCK_REMOVE_YES == psdMutualLockState)
 				|| (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == psdMutualLockState))
 			{
@@ -5128,7 +5096,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 			}
 			else if (PSD_STATE_OPEN == tmpDevState)
 			{
-			if (tmpPsdVobcCmd == VOBCTOCI_COMMAND_TYPE_PSDOPEN)
+				if (VOBCTOCI_COMMAND_TYPE_PSDOPEN == tmpPsdVobcCmd)
 				{
 					/* 收到VOBCToCI打开屏蔽门命令，则直接认为屏蔽门占用打开 */
 					devState = OTHER_CI_PSD_STATUS_OCCUPY_OPEN;
@@ -5146,11 +5114,14 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 			}
 			else
 			{
-			devState = 0u;
+				devState = 0U;
 			}
+		}
+		
 		break;
-	case CI_DEVICE_TYPE_PSD_EXCEPT_OPEN:  /*站台屏蔽门（异常打开）*/
-		devState = GePsdExceptOpenState(devId);
+	case CI_DEVICE_TYPE_PSD_EXCEPT_OPEN:  /*站台屏蔽门（异常）*/
+		devState = GePsdExceptState(devId);
+		/*宁象需求：屏蔽门异常打开又关闭、尚未取消异常状态时不开放信号*/
 		break;
 	case CI_DEVICE_TYPE_GARAGEDOOR:       /*车库门*/
 		tmpDevState = GetGaragedoorState(devId);
@@ -5164,7 +5135,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_WASHMACHINE:	/* 洗车机 */
@@ -5187,7 +5158,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			if (ttmpDevState == SPKS_CUT_NO)
+			if (SPKS_CUT_NO == ttmpDevState)
 			{
 				devState = OTHER_CI_SPKS_YES;
 			}
@@ -5949,6 +5920,8 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
 	UINT8 routeTrainNear = 0u;
 	UINT8 physicalCheck = 0u;
 	UINT8 phyPLockRouteState = 0u;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
 
 	physicalSecId = GetAxisSecRelativePhySecId(axisSectionId);
 	routeRlockId = GetPhySecRLockBelongRouteId(physicalSecId);/*物理区段进路锁闭所属进路ID*/
@@ -6093,6 +6066,21 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
 			}
 		}
 	}
+
+	if (CI_SUCCESS == reVal)
+	{/*检查防护道岔位置*/
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecAllProtSwitchPosCheck(axisSectionId, &devId, &devState);
+	}
+
+	if (CI_SUCCESS == reVal)
+	{/*检查防护道岔封锁状态*/
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecProtSwitchFLockCheck(axisSectionId, &devId, &devState);
+	}
+
 	return reVal;
 }
 
@@ -6222,6 +6210,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 	UINT8 logSecLockState = 0U;
 	UINT8 logSecLockRouteNum = 0U;
 	UINT8 chFailStep = 0U;
+	UINT8 cYLockAlarmFlag = FLAG_UNSET;  /*引导总锁报警标志*/
 	
 	bufIndex = GetlogSectionBufIndex(logSectionId);  /*获取区段数组下标*/
 	/**区段下标合法*/
@@ -6487,6 +6476,28 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				reVal = CI_SUCCESS;
 			}
 		}
+
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔封锁状态检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwFLockCheck(logSectionId, &devId, &devState, &cYLockAlarmFlag);/*封锁检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 13U;
+			}
+		}
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔位置检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwPosCheck(logSectionId, &devId, &devState);/*位置检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 14U;
+			}
+		}
+
 	}
 	else 
 	{
@@ -6788,10 +6799,17 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 	AxisSwitchStruct* pRouteSwitchStru = NULL;					/*道岔数据结构指针*/
 	UINT8 innerSwitchRetVal = CI_ERROR;							/*检查计轴区段内道岔是否可被驱动的结果*/
 
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
+
 	switchSum = GetAxisSwitchSum(axisSecId);
 	pRouteSwitchStru = GetAxisSwitchIdStru(axisSecId);
 
-	if((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX))
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
+
+	if((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX)||(NULL == pRouteSwitchStru) || (NULL == pProtectSwitchStru))
 	{
 		innerSwitchRetVal = CI_ERROR;
 	}
@@ -6820,6 +6838,32 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 			}
 		}
 
+		if (innerSwitchRetVal == CI_SUCCESS)
+		{
+			/* 单操相反位置取消驱动检查 */
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPosition = pProtectSwitchStru[ii].SwitchPosition;
+				switchDancaoPosition = GetSwitchDanCaoPostition(switchId);
+
+				if ((SWITCH_POSITION_INVALID == switchDancaoPosition)
+					||
+					(switchDancaoPosition == switchExpPosition))
+				{/*单操无效 或者 单操位置与动作位置一样*/
+					innerSwitchRetVal = CI_SUCCESS;
+				}
+				else
+				{
+					/*单操到相反位置取消道岔的驱动*/
+					innerSwitchRetVal = CI_ERROR;
+					break;
+				}
+			}
+		}
+
+
+		
 		if(innerSwitchRetVal == CI_SUCCESS)
 		{
 			/*驱动计轴区段道岔*/
@@ -6838,7 +6882,7 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 
 
 /*
-功能描述: 	驱动计轴区段内道岔处理
+功能描述: 	驱动计轴区段内道岔，计轴区段关联防护道岔处理
 输入参数:	const UINT16 axisSecId 计轴区段ID
 输出参数:	const UINT8 DrivFlag 道岔驱动标志
 返回值:		无
@@ -6850,22 +6894,36 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
 	UINT8 switchExpPos = 0u; 								/*道岔期望位置*/
 	AxisSwitchStruct* pAxisSecSwitchStru = NULL; 				/*道岔数据*/
 	UINT8 ii = 0u;											/*循环变量*/
-	UINT8 funRtn = CI_ERROR;
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
 
 	switchSum = GetAxisSwitchSum(axisSecId); /*获取计轴区段道岔数目*/
 	pAxisSecSwitchStru = GetAxisSwitchIdStru(axisSecId); /*获取计轴区段内道岔数据*/
 	
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
 
-	if(SWITCH_NEED_DRIV_TRUE == DrivFlag)
+	if ((NULL != pAxisSecSwitchStru) && (NULL != pProtectSwitchStru))
+	{
+		if (SWITCH_NEED_DRIV_TRUE == DrivFlag)
 		{/*需要驱动计轴区段内道岔*/
 
-		for(ii = 0u; ii < switchSum; ii++)
+			for (ii = 0u; ii < switchSum; ii++)
 			{
 				switchId = pAxisSecSwitchStru[ii].SwitchId;
 				switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
-			funRtn = SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
 			}
 
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPos = pProtectSwitchStru[ii].SwitchPosition;
+				(void) SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段防护道岔的驱动状态为驱动中*/
+			}
+
+		}
 	}
 }
 
@@ -7319,7 +7377,7 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 	UINT8 retValue = CI_ERROR;
 	UINT8 chLogSecLogLockState = 0U;  /*逻辑区段逻辑锁闭状态*/
 	UINT8 cLockBelongLogicRouteNum = 0U;  /*逻辑区段逻辑锁闭所属逻辑进路数量*/
-
+	UINT8 chLogSecJumpLockState = 0U;
 	/*获取道岔关联逻辑区段信息*/
 	logSecSum = GetSwitchLogSecSum(switchId);
 	logSecBuf = GetSwitchLogSecBuf(switchId);
@@ -7343,8 +7401,9 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 				/*检查逻辑区段逻辑锁闭状态*/
 				chLogSecLogLockState = GetLogSecLogLockState(logSecBuf[i]);
 				cLockBelongLogicRouteNum = GetLogSecLockBelLogRouteSum(logSecBuf[i]);
+				chLogSecJumpLockState = GetLogSecJumpLockState(logSecBuf[i]);
 
-				if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum))
+				if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum)&&(LOGIC_SECTION_JUMP_LOCK_NO== chLogSecJumpLockState))
 				{
 					retValue = CI_SUCCESS;
 				}
@@ -8964,7 +9023,7 @@ void SetCtrlPower(const UINT8 virtualCiId, const UINT8 ctrlPowerFlag, const UINT
 	UINT8 i = 0u;
 	UINT8 cimode = 0u;
 	UINT8 virtualCiNum = 0u;
-	cimode = GetCiModeFlag();
+	cimode = GetVirCImode(virtualCiId);
 	virtualCiNum = GetVirtualCINum();
 	if (CI_MODE_ATS != cimode)
 	{
@@ -9071,26 +9130,30 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
 {
 	UINT8 chkFState = CI_ERROR;
 	UINT8 chkFloodState = CI_ERROR;
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 belongCiId = 0u;        /*进路所属联锁ID*/
 	UINT8 localCiId = 0u;         /*本地联锁ID*/
 	UINT8 belongVirCI = 0u;
 	UINT8 flag = 0u;
 	UINT8 autoTriggerType = 0u;      /*自动触发进路属性*/
-
+	UINT8 chRoutCouplinkFlag = 0U;
+	UINT16 wLastPhyId = 0U;
+	UINT16 wLockRouteId = 0U;
+	UINT16 wSigId = 0U;
+	UINT16 wSameStartSigRouteNum = 0U;
+	UINT16* pSameStartSigRouteBuf = NULL;
+	UINT16 jj = 0U;
 	autoTriggerType = GetAutoTriggerType(routeId);      /*获取进路自动触发进路属性*/
 	localCiId = GetSystemParaLocalCiId();       /*获取本机联锁ID*/
 	belongCiId = GetRouteBelongCiId(routeId);           /*获取进路所属联锁ID*/
 	if (ROUTE_TYPE_AUTO_TRIGGER == autoTriggerType)
 	{
-		if (FUNC_SWITCH_ON == includeVirFlag)
-		{
+		
 		belongVirCI = GetRouteBelongVirCiId(routeId);
 		if (belongVirCI != virCIid)
 		{
 			flag = 1u;
 		}
-		}
+		
 
 		if ((0u == routeId) || (routeId >= ROUTE_SUM_MAX) || (belongCiId != localCiId) || (1u == flag))
 		{
@@ -9100,7 +9163,71 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
 		{
 			/*检查自动触发进路封锁状态*/
 			chkFState = ChekAutoTriggerRouteFlockState(routeId);
+			if (CI_SUCCESS == chkFState)
+			{
+				/*检查进路无联挂标志*/
+				chRoutCouplinkFlag = GetRouteCouplinkFlag(routeId);
+				if (ROUTE_COUPLINK_FLAG_NO == chRoutCouplinkFlag)
+				{
+					/*继续检查*/
+				}
+				else
+				{
+					chkFState = CI_ERROR;
+				}
+				/*进路最后区段锁闭所属进路不存在联挂标志*/
+				if (CI_SUCCESS == chkFState)
+				{
+					wLastPhyId = GetRouteLastPhySectionId(routeId);	/*获取进路最后物理区段*/
+					wLockRouteId = GetPhySecRLockBelongRouteId(wLastPhyId);	/*获取物理区段锁闭所属进路*/
+					chRoutCouplinkFlag = GetRouteCouplinkFlag(wLockRouteId);/*获取联挂标志*/
+					if (ROUTE_COUPLINK_FLAG_NO == chRoutCouplinkFlag)
+					{
+						/*不存在联挂标志*/
+					}
+					else
+					{
+						chkFState = CI_ERROR;
+					}
+				}
+				else
+				{
+					/*不处理*/
+				}
+				if (CI_SUCCESS == chkFState)
+				{
+					/*进路始端信号机为始端的其他进路也不存在联挂标志*/
+					wSigId = GetRouteStartSignalId(routeId);
+					wSameStartSigRouteNum = GetStartSignalRouteSum(wSigId); /*获取始端信号机进路数量和数组*/
+					pSameStartSigRouteBuf = GetStartSignalRouteBuf(wSigId);
+					if ((NULL != pSameStartSigRouteBuf) && (0U < wSameStartSigRouteNum))
+					{
+						for (jj = 0U; jj < wSameStartSigRouteNum; jj++)
+						{
+							chRoutCouplinkFlag = GetRouteCouplinkFlag(pSameStartSigRouteBuf[jj]);
+							if (ROUTE_COUPLINK_FLAG_NO == chRoutCouplinkFlag)
+							{
+								/*不存在联挂标志*/
+							}
+							else
+							{
+								chkFState = CI_ERROR;
+								break;
+							}
+						}
+					}
+					else
+					{
+						chkFState = CI_ERROR;
+					}
+				}
+				else
+				{
+					/*不处理*/
+				}
 
+	
+			}
 			if (CI_SUCCESS == chkFState)
 			{
 				/*检查自动触发进路防淹门状态*/
@@ -9138,7 +9265,6 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
 */
 void CancelSigleRouteAutoTrigger(UINT8 virCIid, UINT16 routeId, UINT8 setFlag)
 {
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 belongCiId = 0u;        /*进路所属联锁ID*/
 	UINT8 localCiId = 0u;         /*本地联锁ID*/
 	UINT8 belongVirCI = 0u;
@@ -9148,14 +9274,13 @@ void CancelSigleRouteAutoTrigger(UINT8 virCIid, UINT16 routeId, UINT8 setFlag)
 	localCiId = GetSystemParaLocalCiId();       /*获取本机联锁ID*/
 	belongCiId = GetRouteBelongCiId(routeId);           /*获取进路所属联锁ID*/
 	flag = 0u;
-	if (FUNC_SWITCH_ON == includeVirFlag)
-	{
+	
 	belongVirCI = GetRouteBelongVirCiId(routeId);
 	if (belongVirCI != virCIid)
 	{
 		flag = 1u;
 	}
-	}
+	
 
 	if ((0u == routeId) || (routeId >= ROUTE_SUM_MAX) || (belongCiId != localCiId) || (1u == flag))
 	{
@@ -11367,3 +11492,308 @@ UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId)
 
 	return wRetVal;
 }
+
+/*
+* 功能描述：紧急临时限速处理
+* 参数说明：const UINT16 wLogSectionId 逻辑区段ID
+*           const UINT8 chExiansuState 限速状态
+* 返 回 值：无
+* by 20250916
+*/
+
+void EmergXianSuProcess(const UINT16 wLogSectionId, const UINT8 chExiansuState)
+{
+	UINT8 chBelongCiId = 0U;
+	UINT8 chLocalCiId = 0U;
+	UINT8 chPerLogSecExiansuState = 0U;
+	if ((0U < wLogSectionId) && (LOGIC_SECTION_SUM_MAX > wLogSectionId))
+	{
+		chBelongCiId = GetLogSecBelongCiId(wLogSectionId);/*逻辑区段所属联锁*/
+		chLocalCiId = GetSystemParaLocalCiId();
+		if ((chLocalCiId == chBelongCiId) && (0U != chLocalCiId))
+		{
+			chPerLogSecExiansuState = GetLogSecEmergXianSu(wLogSectionId);
+			SetLogSecEmergXianSu(wLogSectionId, chExiansuState);/*设置逻辑区段紧急临时限速*/
+
+			if ((LOGSEC_EMERG_XS_SET_YES != chPerLogSecExiansuState) && (LOGSEC_EMERG_XS_SET_YES == chExiansuState))
+			{
+				/*由未设置到设置*/
+				ClearLgcSecBelongRtXsCfm(wLogSectionId);  /*清除限速确认*/
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+		else
+		{
+			/*非本联锁逻辑区段，不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取全线雨雪模式命令CC
+* 参数说明：void
+* 返 回 值：0x55 有效
+*           0xAA 无效
+* Created By LQ 2025.11.07
+*/
+UINT8 GetAllSnowModelCC(void)
+{
+	return g_AllSnowModelCC;
+}
+
+/*
+* 功能描述：设置全线雨雪模式命令CC
+* 参数说明：UINT8 setmodle 全线雨雪模式
+* 返 回 值：void
+* Created By LQ 2025.11.07
+*/
+void SetAllSnowModelCC(UINT8 setmodle)
+{
+	if ((CI_ALL_SNOW_VALID == setmodle) || (CI_ALL_SNOW_UNVALID == setmodle))
+	{
+		g_AllSnowModelCC = setmodle;
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取本地区间雨雪站台数量CC
+* 参数说明：无
+* 返 回 值：区间雨雪站台数量
+* Created By LQ 2025.11.06
+*/
+UINT8 GetLocalAreaSnowNumCC(void)
+{
+	return gLocalAreaSnowNumCC;
+}
+
+/*
+* 功能描述：获取本地区间雨雪信息CC
+* 参数说明：无
+* 返 回 值：区间雨雪信息
+* Created By LQ 2025.11.06
+*/
+AreaSnowInfoStruct* GetLocalAreaSnowCC(void)
+{
+	return gszLocalAreaSnowCC;
+}
+
+/*
+* 功能描述：设置本地区间雨雪站台信息CC
+* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
+*			const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
+* 返 回 值：无
+* Created By LQ 2025.11.06
+*/
+void SetLocalAreaSnowInfoCC(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX])
+{
+	UINT8 ii = 0U;
+
+	if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowBuf))
+	{
+		/*清除本地区间雨雪站台信息CC*/
+		(void)CommonMemSet(gszLocalAreaSnowCC, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
+
+		gLocalAreaSnowNumCC = cAreaSnowNum;
+		for (ii = 0U; ii < cAreaSnowNum; ii++)
+		{
+			gszLocalAreaSnowCC[ii] = pAreaSnowBuf[ii];  /*存储本控区的区间雨雪状态信息*/
+		}
+	}
+	else
+	{
+		/*入参非法，不处理*/
+	}
+}
+
+/*
+* 功能描述：获取本地雨雪模式命令CC
+* 参数说明：无
+* 返 回 值：0x55 无效 
+*           0xAA 有效
+* Created By LQ 2025.11.06
+*/
+UINT8 GetLocalSnowModelCC(void)
+{
+	return g_LocalSnowModelCC;
+}
+
+/*
+* 功能描述：设置本地雨雪模式命令CC
+* 参数说明：UINT8 setmodle 本地雨雪模式
+* 返 回 值：无
+* Created By LQ 2025.11.06
+*/
+void SetLocalSnowModelCC(UINT8 setmodle)
+{
+	if ((CI_LOCAL_SNOW_UNVALID == setmodle) || (CI_LOCAL_SNOW_VALID == setmodle))
+	{
+		g_LocalSnowModelCC = setmodle;
+	}
+	else
+	{
+		; /*不处理*/
+	}
+}
+/*
+* 功能描述： 获取虚拟联锁类型
+* 参数说明： 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)
+{
+	UINT8 cLocalCiId = 0U;
+	UINT8 ret = 0U;
+
+
+	cLocalCiId = GetSystemParaLocalCiId();
+	if (chVirCiId == 200U + cLocalCiId)
+	{
+		ret = CI_TYPE_SCX;
+	}
+	else
+	{
+		ret = GetLocalCiType();
+	}
+
+	return ret;
+}
+/*
+* 功能描述：判断本联锁临时限速状态
+* 参数说明：无
+* 返 回 值：临时限速有效返回失败，清除或与限速确认返回成功
+* Created :LYJ
+*/
+
+UINT8 CheckLocalCiLSXSStata(void)
+{
+	UINT8 chRet = 0U;
+	UINT8 chVirCINum = 0U;
+	UINT8 i = 0U;
+	UINT8 chXiansuState = 0U;
+	UINT8 chVirtualCIid = 0U;
+	UINT8 chTsrSureFlag = 0U;
+	
+	chTsrSureFlag = GetTsrSureFlag(); /*获取临时限速确认标志*/
+	if (CI_TSR_SURE_YES == chTsrSureFlag)
+	{
+		chRet = CI_SUCCESS; 
+	}
+	else
+	{
+		/*临时限速未确认，判断是否做了限速清除*/
+		
+		chVirCINum = GetVirtualCINum();
+		for (i = 0U; i < chVirCINum; i++)
+		{
+			chVirtualCIid = GetVirtualCIid(i);
+			chXiansuState = GetVirCILabourCancelLSXianSta(chVirtualCIid);
+			if ((LINSHIXIANSU_COMM_GOOD_STATE == chXiansuState) || (LINSHIXIANSU_LABOURCANCLE_YES_STATE == chXiansuState))
+			{
+				chRet = CI_SUCCESS;
+			}
+			else
+			{
+				chRet = CI_ERROR;
+				break;
+			}
+		}
+	}
+
+	return chRet;
+}
+
+/*
+功能描述:
+	清除逻辑区段关联道岔单操位置
+输入参数:
+	const UINT16 逻辑区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId)
+{
+	UINT8 	switchSum = 0u; 									/*道岔数目*/
+	UINT16 	switchId = 0u; 									/*道岔ID*/
+	UINT8 	ii = 0u;											/*循环变量*/
+	UINT8  checkSum = 0u;
+	LogsecSwitchStruct* dataIdBuf = NULL;
+
+	UINT8 chLogicSecSwitchSum = 0U;/*逻辑区段道岔数目*/
+	LogsecSwitchStruct* pLogicSecSwitchIdData = NULL;/*逻辑区段道岔ID数据*/
+
+	chLogicSecSwitchSum = GetLogicSecSwitchSum(logicSecId);/*逻辑区段道岔数目*/
+	pLogicSecSwitchIdData = GetLogicSecSwitchIdStru(logicSecId);/*逻辑区段道岔ID数据*/
+
+	checkSum = GetLgcRelateProSwSum(logicSecId);/*获取指定ID逻辑区段关联防护道岔数目*/
+	dataIdBuf = GetLgcRelateProSwStru(logicSecId);
+
+	
+
+	if (NULL != pLogicSecSwitchIdData)
+	{
+		for (ii = 0u; ii < chLogicSecSwitchSum; ii++)
+		{
+			switchId = pLogicSecSwitchIdData[ii].SwitchId;
+			/*设置该道岔期望驱动位置为无效*/
+			(void)SetSwitchDanCaoPosition(switchId, SWITCH_POSITION_INVALID);
+		}
+	}
+
+	if (NULL != dataIdBuf)
+	{
+		for (ii = 0u; ii < checkSum; ii++)
+		{
+			switchId = dataIdBuf[ii].SwitchId;
+			/*设置该道岔期望驱动位置为无效*/
+			(void) SetSwitchDanCaoPosition(switchId, SWITCH_POSITION_INVALID);
+		}
+	}
+}
+
+/*
+功能描述:
+	清除计轴区段关联道岔单操位置
+输入参数:
+	const UINT16 计轴区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId)
+{
+	UINT16* pLogSectionIdBuf = NULL;
+	UINT8 chLogSectionSum = 0U;
+	UINT8 ii = 0U;
+
+	pLogSectionIdBuf = GetAxisSecLogSectionIdBuf(axisSecId);
+	chLogSectionSum = GetAxisSecLogSectionSum(axisSecId);
+
+	if (NULL != pLogSectionIdBuf)
+	{
+		for (ii = 0U; ii < chLogSectionSum; ii++)
+		{
+			/*清除逻辑区段道岔道岔标志*/
+			ClearLogSeceSwitchDanCaoPos(pLogSectionIdBuf[ii]);
+		}
+	}
+}

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

@@ -74,6 +74,11 @@ typedef struct S_AreaSnowInfoStruct
 /* 其他联锁条件检查配置状态相关定义 */
 #define LOCAL_AREA_SNOW_SUM_MAX		((UINT8)20)			/*本控区及相邻控区发送的区间雨雪站台数量*/
 #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
@@ -190,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：默认值*/
@@ -219,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;/*继电接口确认标志*/
@@ -232,11 +237,16 @@ 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数组*/
 
@@ -288,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
@@ -1897,5 +1900,114 @@ void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCut
 * Created By LQ 2025.05.08
 */
 UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId);
+/*
+* 功能描述：紧急临时限速处理
+* 参数说明：const UINT16 wPhySectionId 逻辑区段ID
+*           const UINT8 chExiansuState 限速状态
+* 返 回 值：无
+* by 202500916
+*/
 
+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 2025.11.06
+*/
+UINT8 GetLocalAreaSnowNumCC(void);
+
+/*
+* 功能描述：获取本地区间雨雪信息CC
+* 参数说明：无
+* 返 回 值：区间雨雪信息
+* Created By LQ 2025.11.06
+*/
+AreaSnowInfoStruct* GetLocalAreaSnowCC(void);
+
+/*
+* 功能描述：设置本地区间雨雪站台信息CC
+* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
+*			const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
+* 返 回 值：无
+* Created By LQ 2025.11.06
+*/
+void SetLocalAreaSnowInfoCC(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX]);
+
+/*
+* 功能描述：获取本地雨雪模式命令CC
+* 参数说明：无
+* 返 回 值：0x55 无效
+*           0xAA 有效
+* Created By LQ 2025.11.06
+*/
+UINT8 GetLocalSnowModelCC(void);
+
+/*
+* 功能描述：设置本地雨雪模式命令CC
+* 参数说明：UINT8 setmodle 本地雨雪模式
+* 返 回 值：无
+* Created By LQ 2025.11.06
+*/
+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 :LYJ
+*/
+
+UINT8 CheckLocalCiLSXSStata(void);
+/*
+功能描述:
+	清除逻辑区段关联道岔单操位置
+输入参数:
+	const UINT16 逻辑区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId);
+/*
+功能描述:
+	清除计轴区段关联道岔单操位置
+输入参数:
+	const UINT16 计轴区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId);
 #endif

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

@@ -443,14 +443,14 @@ UINT8 CheckRCIAPowerFaultState(void)
 			gPlatDataGPIOTolercance.powerANode_TolCyc = dwCurCyc;
 			retVal = CI_SUCCESS;
 		}
-		else if(CI_TIME_IN == chCheckState)
+		else if (CI_TIME_IN == chCheckState)
 		{
 			retVal = CI_SUCCESS;/*继续容忍*/
 		}
 		else
 		{
 			retVal = CI_ERROR;
-			debug_infor_printf((const)"PLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+			debug_infor_printf((const)"\nPLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
 		}
 	}
 	else
@@ -494,7 +494,7 @@ UINT8 CheckRCIBPowerFaultState(void)
 		else
 		{
 			retVal = CI_ERROR;
-			debug_infor_printf((const)"PLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+			debug_infor_printf((const)"\nPLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
 		}
 	}
 	else
@@ -515,7 +515,6 @@ 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*/
@@ -551,7 +550,7 @@ UINT8 CheckRCIAPowerModeFaultState(void)
 		else
 		{
 			retVal = CI_ERROR;
-			debug_infor_printf((const)"PLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+			debug_infor_printf((const)"\nPLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
 		}
 	}
 	else
@@ -607,7 +606,7 @@ UINT8 CheckRCIBPowerModeFaultState(void)
 		else
 		{
 			retVal = CI_ERROR;
-			debug_infor_printf((const)"PLATIO_B_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
+			debug_infor_printf((const)"\nPLATIO_B_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
 		}
 	}
 	else

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

@@ -59,7 +59,6 @@
 #define CCU_CommBadEnsureTime_CycleCount   	((UINT16)5u)	  /*应用与通控通信中断判断周期数*/  
 
 #define VOLTAGE_MAX_TO_0        ((UINT16)500U)           /*电压判断为0的阈值*/
-
 #define IO_POWERSTATE_TOLERANCE   ((UINT8)0x02)           /*平台电源报警容忍周期数，容忍3周期，超过2周期报警*/
 
 /*平台心跳帧信息结构*/
@@ -102,7 +101,6 @@ typedef struct S_PlatGPIODataStruct
 	UINT8 ModepowerBState_PUB;                             /*机柜B系电源插箱中为CPUB供电的24VDC电源模块状态*/
 }PlatGPIODataStruct;
 
-
 /*平台发送的电源采集状态容忍同步数据*/
 typedef struct S_PlatGPIOToleranceData
 {
@@ -114,6 +112,7 @@ typedef struct S_PlatGPIOToleranceData
 
 
 
+
 /*
 * 功能描述： 清空指定通控板卡发送的心跳数据
 * 参数说明： 板卡ID

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

@@ -110,6 +110,7 @@
 #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_SET_LEAD_ROUTE_CHECK          ((UINT8)0x4B)    /*办理引导进路检查*/    
@@ -214,6 +215,11 @@
 
 #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*/
+
 
 /*************************************************分界线******************************************************************************/
 /*************************************************分界线******************************************************************************/
@@ -235,6 +241,7 @@
 #define ETYPE_ROUTE_XUANPAI_OVERTIME ((UINT8)0x10)    /*进路选排超时*/
 #define ETYPE_GROUP_AUTO_ROUTE_STATE ((UINT8)0x16)    /*组合自动进路*/
 #define ETYPE_ROUTE_APPLY_SWITCH_MOVE ((UINT8)0xA4)    /*进路道岔单操中*/
+#define ETYPE_COUPLINK_ROUTE_IDLE        ((UINT8)0xA5)    /*联挂进路内无被联挂车*/
 
 
 #define ETYPE_COMM_WITH_VOBC		((UINT8)0x11)	/*与VOBC通信*/
@@ -245,6 +252,8 @@
 #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通信*/
 
 /* 信号机故障类型编码 (UINT8)0x21-(UINT8)0x3f */
 /* 设备类型 CI_DEVICE_TYPE_SIGNAL */
@@ -298,6 +307,7 @@
 /*保护区段类型*/
 #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 */

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

@@ -663,3 +663,54 @@ UINT8 CheckEsbBelSendRange(const UINT16 wCheckEsbId)
 
 	return retVal;
 }
+
+/*
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮数量
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：同站紧急按钮数量
+* Created By LQ 2025.12.30
+*/
+UINT8 GetEsbRelOnePlatEsbNum(const UINT16 esbId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 reVal = 0U;
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		reVal = EsbConfigDataStru[bufIndex].RelOnePlatEsbNum;
+	}
+	else
+	{
+		/*返回0*/
+	}
+
+	return reVal;
+}
+
+/*
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮ID数组
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：NULL 获取数据失败
+*			其它 同站紧急按钮ID数组
+* Created By LQ 2025.12.30
+*/
+UINT16* GetEsbRelOnePlatEsbId(const UINT16 esbId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT16* reVal = NULL;
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		reVal = EsbConfigDataStru[bufIndex].RelOnePlatEsbId;
+	}
+	else
+	{
+		/*返回NULL*/
+	}
+
+	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,6 +51,8 @@ typedef struct S_EsbConfigDataStruct
 	UINT16 EsbCutoffBuzzRelayId;		    /*切除蜂鸣器报警继电器ID*/
 	UINT8 ConfigAtsCiEssSteadyMask;			/*是否配置了ATS-CI稳灯状态码位0x55 配置；0xaa未配置*/
 	UINT8 ConfigAtsCiEssFlashMask;			/*是否配置了ATS-CI闪灯状态码位0x55 配置；0xaa未配置*/
+	UINT8 RelOnePlatEsbNum;  /*关联同站ESB数量*/
+	UINT16 RelOnePlatEsbId[ESB_PROTECT_LINK_NUM];  /*关联同站ESB ID数组*/
 } EsbConfigDataStruct;
 
 /*******************************全局变量声明*******************************/
@@ -293,6 +296,23 @@ UINT16 GetEsbCutoffBuzzRelayId(const UINT16 esbId);
 */
 UINT8 CheckEsbBelSendRange(const UINT16 wCheckEsbId);
 
+/*
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮数量
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：同站紧急按钮数量
+* Created By LQ 2025.12.30
+*/
+UINT8 GetEsbRelOnePlatEsbNum(const UINT16 esbId);
+
+/*
+* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮ID数组
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：NULL 获取数据失败
+*			其它 同站紧急按钮ID数组
+* Created By LQ 2025.12.30
+*/
+UINT16* GetEsbRelOnePlatEsbId(const UINT16 esbId);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -171,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;
@@ -1073,3 +1075,302 @@ UINT8 GetEsbRelayDownState(const UINT16 esbId)
 
 	return reVal;
 }
+
+
+/*
+* 功能描述： 获取指定ID紧急停车按钮状态(融合了旁路状态)
+* 参数说明： const UINT16 esbId, 紧急停车按钮ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 紧急停车按钮状态
+*/
+UINT8 GetEsbMergeState(const UINT16 esbId)
+{
+	
+	UINT8 reVal = CI_ERROR;
+	UINT8 chEsbState = 0U;
+	UINT8 chEsbCutState = 0U;
+	 
+
+	chEsbState = GetEsbState(esbId);
+	chEsbCutState = GetEsbCutState(esbId);
+	if (ESB_CUT_YES == chEsbCutState)
+	{
+		reVal = ESB_STATE_VALID_NO;/*未按下*/
+	}
+	else
+	{
+		if (ESB_STATE_VALID_NO == chEsbState)
+		{
+			reVal = ESB_STATE_VALID_NO;/*未按下*/
+		}
+		else
+		{
+			reVal = ESB_STATE_VALID_YES;
+		}
+	}
+
+	return reVal;
+}
+
+/*
+* 功能描述：获取指定ID紧急按钮同站紧急按钮激活状态
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：0 获取数据失败
+*			0x55 紧急未激活
+*           0xAA 紧急激活
+* Created By LQ 2025.12.29
+*/
+UINT8 GetOnePlatEsbState(const UINT16 esbId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 reVal = CI_ERROR;
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		reVal = EsbDataStru[bufIndex].cOnePlatEsbState;
+	}
+	else
+	{
+		/*返回失败*/
+	}
+
+	return reVal;
+}
+
+
+/*
+* 功能描述：设置指定ID紧急按钮同站紧急按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbState 紧急按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetOnePlatEsbState(const UINT16 esbId, const UINT8 esbState)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		if ((ESB_STATE_VALID_NO == esbState) || (ESB_STATE_VALID_YES == esbState))
+		{
+			EsbDataStru[bufIndex].cOnePlatEsbState = esbState;  /*同站紧急按钮激活状态*/
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取指定ID紧急按钮同站紧急旁路按钮激活状态
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：0 获取数据失败
+*			0x55 旁路未激活
+*           0xAA 旁路激活
+* Created By LQ 2025.12.29
+*/
+UINT8 GetOnePlatEsbCutState(const UINT16 esbId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 reVal = CI_ERROR;
+
+	bufIndex = GetEsbConfigBufIndex(esbId);  /*获取数组下标*/
+
+	if (ESB_SUM_MAX > bufIndex)
+	{
+		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))
+		{
+			EsbDataStru[bufIndex].cOnePlatEsbCutState = esbCutState;  /*同站紧急按钮激活状态*/
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：清除同站紧急按钮及旁路按钮激活状态
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.12.30
+*/
+void ClearOnePlatEsbAndCutState(void)
+{
+	UINT16 wEsbTotalSum = 0U;  /*ESB总数*/
+	UINT16 ii = 0U;
+	UINT16 wEsbId = 0U;  /*ESB ID*/
+
+	wEsbTotalSum = GetTotalEsbCurNum();
+
+	/*重置所有紧急按钮的同站紧急按钮及旁路按钮为未激活状态*/
+	for (ii = 0U; ii < wEsbTotalSum; ii++)
+	{		
+		wEsbId = GetEsbId(ii);
+		SetOnePlatEsbState(wEsbId, ESB_STATE_VALID_NO);
+		SetOnePlatEsbCutState(wEsbId, ESB_CUT_NO);
+	}
+}
+
+/*
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbState 紧急按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetRelOtherOnePlatEsbState(const UINT16 esbId, const UINT8 esbState)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	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++)
+			{
+				SetOnePlatEsbState(pRelOnePlatEsbId[ii], esbState);
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急旁路按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbCutState 紧急旁路按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetRelOtherOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	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_CUT_NO == esbCutState) || (ESB_CUT_YES == esbCutState))
+		{
+			for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
+			{
+				SetOnePlatEsbCutState(pRelOnePlatEsbId[ii], esbCutState);
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：检查指定ID紧急按钮关联的其它同站紧急按钮状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+* 返 回 值：1 紧急无效或旁路有效
+*           0 紧急有效
+* Created By LQ 2025.12.29
+*/
+UINT8 CheckRelOtherOnePlatEsbState(const UINT16 esbId)
+{
+	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);  /*获取数组下标*/
+	cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
+	pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
+
+	if ((ESB_SUM_MAX > bufIndex) && (NULL != pRelOnePlatEsbId))
+	{
+		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

@@ -49,6 +49,8 @@ typedef struct S_EsbDataStruct
 	UINT32 EsbCutErrTriggerPressCycNum;   /*紧急关闭旁路按钮误触发按下周期*/
 	UINT8 EsbCutErrorFlag;      /*紧急关闭旁路按钮故障标志，0x55-未故障，0xaa-故障*/
 	UINT8 EsbCutRelayDownState;  /*紧急关闭旁路按钮采集继电器落下状态，0x55-正常采集落下，0xaa-通信异常落下*/
+	UINT8 cOnePlatEsbState;  /*同站紧急按钮激活状态：0x55-未激活，0xAA-激活*/
+	UINT8 cOnePlatEsbCutState;  /*同站紧急旁路按钮激活状态：0x55-未激活，0xAA-激活*/
 } EsbDataStruct;
 
 /*******************************全局变量声明*******************************/
@@ -406,6 +408,86 @@ void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState);
 * Created By LQ 2025.04.01
 */
 UINT8 GetEsbRelayDownState(const UINT16 esbId);
+/*
+* 功能描述： 获取指定ID紧急停车按钮状态(融合了旁路状态)
+* 参数说明： const UINT16 esbId, 紧急停车按钮ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 紧急停车按钮状态
+*/
+UINT8 GetEsbMergeState(const UINT16 esbId);
+
+/*
+* 功能描述：获取指定ID紧急按钮同站紧急按钮激活状态
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：0 获取数据失败
+*			0x55 紧急未激活
+*           0xAA 紧急激活
+* Created By LQ 2025.12.29
+*/
+UINT8 GetOnePlatEsbState(const UINT16 esbId);
+
+/*
+* 功能描述：设置指定ID紧急按钮同站紧急按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbState 紧急按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetOnePlatEsbState(const UINT16 esbId, const UINT8 esbState);
+
+/*
+* 功能描述：获取指定ID紧急按钮同站紧急旁路按钮激活状态
+* 参数说明：const UINT16 esbId 紧急停车按钮ID
+* 返 回 值：0 获取数据失败
+*			0x55 旁路未激活
+*           0xAA 旁路激活
+* Created By LQ 2025.12.29
+*/
+UINT8 GetOnePlatEsbCutState(const UINT16 esbId);
+
+/*
+* 功能描述：设置指定ID紧急按钮同站紧急旁路按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbCutState 紧急旁路按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState);
+
+/*
+* 功能描述：清除同站紧急按钮及旁路按钮激活状态
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.12.30
+*/
+void ClearOnePlatEsbAndCutState(void);
+
+/*
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbState 紧急按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetRelOtherOnePlatEsbState(const UINT16 esbId, const UINT8 esbState);
+
+/*
+* 功能描述：设置指定ID紧急按钮关联的其它同站紧急旁路按钮激活状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+*			const UINT8 esbCutState 紧急旁路按钮状态
+* 返 回 值：无
+* Created By LQ 2025.12.29
+*/
+void SetRelOtherOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState);
+
+/*
+* 功能描述：检查指定ID紧急按钮关联的其它同站紧急按钮状态
+* 参数说明：const UINT16 esbId 紧急按钮ID
+* 返 回 值：1 紧急无效或旁路有效
+*           0 紧急有效
+* Created By LQ 2025.12.29
+*/
+UINT8 CheckRelOtherOnePlatEsbState(const UINT16 esbId);
 
 #ifdef __cplusplus
 }

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通信状态 */
-	funRtn = GetCiTransmitState(CI_SYSTEM_TYPE_CI,OCID);
+	/** 获取Rc通信状态 */
+	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

@@ -330,12 +330,6 @@ static void elm_FlyingProtect(void)
 	UINT16 wTrainId = 0U;
 	UINT8 chTimeCheck = 0u;
 	UINT32 dwFlyOverCyc = 0U;
-	UINT8 cNvramFlag = 0U;  /*列车使用NVRAM标志*/
-	UINT8 cPosMonistorState = 0U;  /*列车位置监督状态*/
-	UINT8 cFuncSwitch = 0U;  /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
-
-	/*周期清除使用NVRAM位置且位置监督无效的飞车信息*/
-	ClearNvramFlyingTrain();
 
 	chCTCheck = elm_FlyingProtect_CT(); /*检查CT飞车*/
 	elm_FlyingProtect_UCT();/*UCT包络飞车删除为UKT*/
@@ -350,7 +344,7 @@ static void elm_FlyingProtect(void)
 	{
 		/** 获取数据配置的飞车宕机最大冗余时间 */
 		maxShutdownRedunTime = elm_PrepareCTFlyingRedunTime();
-		cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_NVRAM_TRAIN_FlYING_OVER);
+
 		for (ii = 0U; ii < trainCnt; ii++)
 		{
 			wTrainId = GetTrainId(ii);
@@ -358,23 +352,13 @@ static void elm_FlyingProtect(void)
 			{
 				dwFlyStartCyc = GetTrainStartFlyProtectCycNum(wTrainId);
 				chTimeCheck = SystemOverTimeCheck(dwFlyStartCyc, (UINT32)maxShutdownRedunTime);
-
 				if (CI_TIME_OUT== chTimeCheck) 
-				{
-					cNvramFlag = GetTrainNvramPosFlag(wTrainId);
-					cPosMonistorState = GetTrainPosMonitorState(wTrainId);
-					if ((TRAIN_NVRAM_POS_FLAG_YES == cNvramFlag) && (TRAIN_POS_MONITOR_VALID != cPosMonistorState) && (FUNC_SWITCH_ON == cFuncSwitch))
-					{
-						/*使用NVRAM位置且位置监督无效的列车飞车后，若NVRAM列车飞车不宕机开关打开，RC仅向列车发飞车特控报文，不宕机*/
-					}
-					else
 				{
 					SetFlyProtectOverCyc(dwCurCyc); /*飞车标志*/
 				}
-				}
 				else
 				{
-					; /*未超过冗余时间或列车通信中断*/
+					; /*未超过冗余时间*/
 				}
 			}
 		}
@@ -3064,13 +3048,9 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 	 UINT32 dwFlyStartCyc = 0U;
 	 UINT8 chTimeCheck = 0U;
 	 UINT8 flyCheck = 0U;
-	 UINT8 cNvramFlag = 0U;  /*列车使用NVRAM标志*/
-	 UINT8 cPosMonistorState = 0U;  /*列车位置监督状态*/
-	 UINT8 cFuncSwitch = 0U;  /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
-
 	 /** CT飞车防护*/
 	 trainCnt = elm_PrepareCommTrainID(trainID);
-	 cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_NVRAM_TRAIN_FlYING_OVER);
+
 	 /** 遍历所有的通信车 */
 	 for (cycle = 0u; cycle < trainCnt; cycle++)
 	 {
@@ -3116,19 +3096,9 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 					 dwFlyStartCyc = GetTrainStartFlyProtectCycNum(trainID[cycle]);
 					 chTimeCheck = SystemOverTimeCheck(dwFlyStartCyc, (UINT32)maxShutdownRedunTime);
 					 if (CI_TIME_OUT == chTimeCheck)
-					 {
-						 cNvramFlag = GetTrainNvramPosFlag(trainID[cycle]);
-						 cPosMonistorState = GetTrainPosMonitorState(trainID[cycle]);
-						 if ((TRAIN_NVRAM_POS_FLAG_YES == cNvramFlag) && (TRAIN_POS_MONITOR_VALID != cPosMonistorState) && (FUNC_SWITCH_ON == cFuncSwitch))
-						 {
-							 /*使用NVRAM位置且位置监督无效的列车飞车后，若NVRAM列车飞车不宕机开关打开，RC仅向列车发飞车特控报文，不宕机*/
-							 AddNvramFlyingTrain(trainID[cycle]);
-						 }
-						 else
 					 {
 						 elm_AddFlyingTrain(trainID[cycle], pEnvelop->id);
 					 }
-					 }
 					 flyCheck++;
 				 }
 				 else

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

@@ -2114,10 +2114,8 @@ static UINT8 elm_UCTEnvelopeHeadHandle(UINT8 endlineFlag, IN const EnvelopeStruc
 			wAgLink = GetBGLinkRelAGLinkId(wLinkId);
 			chBgUtSwitch = GetNoCGFollowUtSwitch();
 			wNextLinkId = FindAdjacentLinkIDSafe(wLinkId, ptemp->endPos.Dir, &wSwitchId, &cDirectionPointFlag);
-			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) 
-				&& ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink))
-				&& (1U == ptemp->ACCnt))
-			{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
+			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink)))
+			{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
 				ret = 0x55u;
 			}
 			else
@@ -2786,10 +2784,8 @@ static UINT8 elm_UCTEnvelopeTailHandle(UINT8 endlineFlag, const EnvelopeStruct *
 			wAgLink = GetBGLinkRelAGLinkId(wLinkId);
 			chBgUtSwitch = GetNoCGFollowUtSwitch();
 			wNextLinkId = FindAdjacentLinkIDSafe(wLinkId, ~ptemp->startPos.Dir, &wSwitchId, &cDirectionPointFlag);
-			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) 
-				&& ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink))
-				&& (1U == ptemp->ACCnt))
-			{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
+			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink)))
+			{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
 				ret = 0x55u;
 			}
 			else
@@ -3299,7 +3295,6 @@ static UINT8 elm_UCTEnvelopeMoving(const EnvelopeStruct* ptemp)
 								 2、包络内包含的道岔无四开且占用，
 								 3，不为休眠车,
 								 4、列车车长不小于两倍线路最小车长
-* by cgh 20250915
  */
 static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
 {
@@ -3311,7 +3306,6 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
 	UINT32 minTrainLength = 0U;
 	UINT32 dwTempLength = 0U;
 	UINT8 chTrainNvramPosFlag = 0U;
-	UINT8 chTrainIsIsFollowUtFlag = 0U;/*是否为列车可追踪UT*/
 
 	/** 入口参数校验 */
 	ASSERT_RET_VALUE(NULL == ptemp,ret,0x80000000U);
@@ -3364,17 +3358,6 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
 		; /* 不满足转为UCT条件 */
 	}
 	
-	if (0U == errorCode)
-	{
-		/** 获取列车是否处于可追踪UT场景 */
-		chTrainIsIsFollowUtFlag = CheckTrainIsFollowUt(ptemp->id);
-		ASSER_ERROR(CI_SUCCESS == chTrainIsIsFollowUtFlag, errorCode, 0x02000000U);
-	}
-	else
-	{
-		; /* 不满足转为UCT条件 */
-	}
-	
 	/** 设置函数返回值 */
 	ASSERT_SETRET(0U == errorCode,ret,CI_SUCCESS,CI_ERROR);
 	ASSER_DEBUG(0U != errorCode,ELM_LOG_LOC(ELM_LOG_ERROR,"errorCode:0x%08x info:ELM%d can't convert to UCT!",errorCode,ptemp->id));

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;
-				FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wFloodGateCloseIvocFlag = agreeFlag;		/*检查标志的时候，查所有起始周期询问的列车是否都回复了同意*/
+				FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wTrainId = wTrainId;
+				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;
-			FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC;
+			FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId = 0U;
+			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,6 +109,29 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
 		;
 	}
 
+
+	if ((CI_SYSTEM_TYPE_OC == devType) || (CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType))
+	{
+		/*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))
@@ -119,7 +142,6 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
 		{
 			;
 		}
-
 		/*接收方校验*/
 		chRet = dquDevName2HlhtId(RemoteDevName, logId, &RemoteEtcsId);
 		if ((CI_ERROR == chRet) || (pMICommonPackage->destId != RemoteEtcsId))
@@ -130,8 +152,23 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
 		{
 			;
 		}
+	}
 
+	if ((CI_SYSTEM_TYPE_CI == devType) || (CI_SYSTEM_TYPE_RC == devType))
+	{
+		/*修改：根据发送方类型获取电子地图校验*/
+		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);
+	}
 	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 vobcHLHTHeadCtxs[VOBC_SUM_MAX]={0};/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
-HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX] = { 0 };/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
-HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX]={0};/*存放与本CI通信的ZC互联互通报文头上下文数据*/
-HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX]={0};/*存放与本CI通信的OC互联互通报文头上下文数据*/
-HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0 };/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
-HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX] = { 0 };/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
+HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX]={0U};/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
+HLHTHeadContextStru gSzRcHLHTHeadCtxs[CI_SUM_MAX] = { 0U };  /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
+HLHTHeadContextStru ciHLHTHeadCtxsCiToRc[CI_SUM_MAX] = { 0U };/*存放本控区CI同步的相邻CI互联互通报文头上下文数据*/
+HLHTHeadContextStru gSzRcHLHTHeadCtxsCiToRc[CI_SUM_MAX] = { 0U };  /*存放本控区CI同步的相邻RC互联互通报文头上下文数据*/
+HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX]={0U};/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
+HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX] = { 0U };/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
+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;
+		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++)
@@ -651,23 +738,11 @@ static void ProcHlhtHeadCtxTimeOutDiffSys(const UINT32 timeoutSnCount, const UIN
 				}
 
 				if (0u == headValid)
-				{
-					if (headCtxs == axleHLHTHeadCtxs) /*计轴系统中断时,GAL层对方序号,收到对方数据时本方序号,设置0xFFFFFFFF*/
-					{
-						headCtxs[i].logId = 0u;
-						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

@@ -137,12 +137,14 @@ void SwitchDeviceToRelayStateProc(void);
 */
 void PhySecRelayToDeviceStateProc(void);
 
+#if 0
 /*
 * 功能描述： 更新区段计轴复位继电器状态
 * 参数说明： void
 * 返回值  ： void     
 */
 void PhySecResetToRelayStateProc(void);
+#endif
 /*
 * 功能描述： 更新区段计轴复位继电器状态
 * 参数说明： void
@@ -184,10 +186,9 @@ UINT8 PsdDeviceToRelayStateProc(void);
 /*
 * 功能描述： 更新洗车机继电器状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
-*			 1: 更新成功      
+* 返回值  ： void     
 */
-UINT8 WashMachineDevToRelayStaProc(void);
+void WashMachineDevToRelayStaProc(void);
 
 /*
 * 功能描述： 更新紧急停车按钮逻辑状态
@@ -224,10 +225,9 @@ void GaragedoorDevToRelayStaProc(void);
 /*
 * 功能描述： 更新洗车机的逻辑状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
-*			 1: 更新成功
+* 返回值  ： void
 */
-UINT8 WashMachineToDeviceStateProc(void);
+void WashMachineToDeviceStateProc(void);
 /*
 * 功能描述： 更新Spks按钮逻辑状态
 * 参数说明： void
@@ -326,12 +326,17 @@ void OcSwitchDeviceOutput(void);
 UINT8 GetOcSignalColor(UINT16 signalId);
 
 /*
-* 功能描述： 获取OC道岔设备颜色
+* 功能描述： 获取OC道岔设备状态
 * 参数说明：
-		UINT16 signalId：信号机id
-* 返回值  ： void
+		UINT16 switchId：道岔id
+		UINT8 mainControlOCId 主控OCId
+* 返回值  ：
+*			((UINT8)0x01)    道岔定位
+*			((UINT8)0x02)    道岔反位
+*			((UINT8)0x04)    道岔四开
+*			((UINT8)0x08)    道岔移动
 */
-UINT8 GetOcSwitchState(UINT16 switchId);
+UINT8 GetOcSwitchState(UINT16 switchId, UINT8 mainControlOCId);
 
 /*
 * 功能描述： 间隙探测脉冲接口方式启动驱动处理
@@ -354,7 +359,7 @@ void ProcessJXTCPulseInterfStopDrv(UINT16 startJXTCRelayId, UINT16 stopJXTCRelay
 
 /******************************OC spks指示灯输出处理****************************/
 /*
-* 功能描述： OC spks指示灯和spks旁路指示灯输出处理
+* 功能描述： OC spks指示灯、spks旁路指示灯及蜂鸣继电器处理
 * 参数说明： void
 * 返回值  ： void
 */
@@ -803,7 +808,7 @@ UINT8 WashMachineWorkModeRelayProc(const UINT16 washMachineId);
 *			 CI_SUCCESS: 更新成功
 * by cgh 20231113
 */
-UINT8 DownWashDevToRelayStaProc(const UINT16 washMachineId);
+void DownWashDevToRelayStaProc(const UINT16 washMachineId);
 
 /*
 * 功能描述： 降级模式洗车线关联进路状态检查
@@ -984,6 +989,211 @@ UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
 */
 UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
 
+/*
+* 功能描述： 设置所有道岔转辙机位置
+* 参数说明： UINT16 switchCurSum 道岔总数
+* 返回值  ： 无
+*/
+void SetAllSingleSwitchZzjState(UINT16 switchCurSum);
+
+/*
+* 功能描述： 指定洗车机ID降级模式洗车按钮状态更新
+* 参数说明： const UINT16 washMachineId 洗车机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
+* 返回值  ：无
+*Create fan 2026.03.26
+*/
+void CancelPsdExceptState(UINT16 doorId);
+/*
+* 功能描述： 设置道岔的每一个OC的主控状态
+* 参数说明：
+		UINT16 switchId：道岔id
+* 返回值  ：void
+* add by mpt 20260326
+*/
+void SetOcSwitchControlState(UINT16 switchId);
+/*
+* 功能描述： 仲裁当前道岔的主控OC
+* 参数说明： UINT16 switchCurSum 道岔总数
+* 返回值  ： 无
+* add by mpt 20260326
+*/
+void SetAllSwitchCurMainControlOC(UINT16 switchCurSum);
+/*
+* 功能描述： OC道岔主控命令生成处理
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+*/
+void OutSwitchControlModeCmd(UINT16 switchId);
+/*
+* 功能描述： 道岔无主控时产生主备控命令处理
+* 参数说明： UINT16 switchId
+* 返回值  ： void
+*/
+void SwitchMainControlCmdOut(UINT16 switchId, UINT8 ocId);
+/*
+* 功能描述： OC道岔主控状态管理
+* 参数说明： void
+* 返回值  ： void
+*/
+void OcSwitchControlModeCmdOutput(void);
+/*
+* 功能描述： 双主防护模块
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+*/
+void SwitchDoubleMainProtect(UINT16 switchId);
+/*
+* 功能描述：道岔寻表模块
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+* add by mpt 20260328
+*/
+void FindSwitchPostionCmdOut(UINT16 switchId);
+
+
 #ifdef __cplusplus
 }
 #endif

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
@@ -466,6 +458,93 @@ void ProcessOCToCiPsdData(void);
 */
 void ProcessOcToCiRelayDiffData(void);
 
+/*
+* 功能描述：处理CI与RC间通信状态和数据
+* 参数说明：void
+* 返 回 值：无
+* Created By LQ 2025.11.04
+*/
+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 2025.11.07
+*/
+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
 }
 #endif

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    
@@ -456,6 +453,101 @@ UINT8 FindRouteLeaveAxis(const UINT16 routeId);
 */
 void RtnRealyAdhesionStatePro(void);
 
+/*
+* 功能描述： 获取人工解锁保护区段剩余倒计时
+* 参数说明： const UINT16 overlapId  保护区段id
+* 返回值  ： 倒计时
+* by cgh 20250928
+*/
+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
 }
 #endif

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;
@@ -457,3 +457,29 @@ UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId)
 
 	return wRetVal;
 }
+
+/*
+* 功能描述： 根据指示灯ID获取指示灯虚拟联锁ID
+* 参数说明：  UINT16 wIndicId  指示灯ID
+* 返回值  ： 0u: 获取数据失败
+*			>0u: 虚拟联锁ID
+* BY:lyj 20260105
+*/
+UINT8 GetIndicBelongRtuId(UINT16 wIndicId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 reVal = CI_ERROR;
+
+	bufIndex = GetIndicatorConfigBufIndex(wIndicId);  /*获取指示器相关继电器数组下标*/
+
+	if (INDICATOR_SUM_MAX > bufIndex)
+	{
+		reVal = IndicatorConfigDataStru[bufIndex].chBelongVirCIid;
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	return reVal;
+}

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

@@ -30,6 +30,7 @@ typedef struct S_IndicatorConfigDataStruct
 	UINT8  IdSum; /*相关Id数量(配置字段)*/				
 	UINT16 IdBuf[INDICATOR_RELAY_SUM_MAX]; /*相关ID (配置字段)*/
 	UINT8 BjdDeviceId;     /*报警灯设备ID*/
+	UINT8 chBelongVirCIid; /*所属虚拟联锁ID*/
 } IndicatorConfigDataStruct;
 
 /*cgh-合并ECI11.0:OC站表示灯 OC站指一级集中站（CI+OC）的现地工作站、二级集中站（OC）的有岔非集现地工作站，中央联锁工作站*/
@@ -183,7 +184,15 @@ UINT8 GetIndicatorDevId(UINT16 indicatorId);
 *			>0u: 报警灯设备ID
 * by cgh 20240910
 */
-UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId);
+UINT16 GetIndicatorRelNonReturnId(UINT16 indicatorId);
+/*
+* 功能描述： 根据指示灯ID获取指示灯虚拟联锁ID
+* 参数说明：  UINT16 wIndicId  指示灯ID
+* 返回值  ： 0u: 获取数据失败
+*			>0u: 虚拟联锁ID
+* BY:lyj 20260105
+*/
+UINT8 GetIndicBelongRtuId(UINT16 wIndicId);
 
 #ifdef __cplusplus
 }

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

@@ -64,7 +64,9 @@
 #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_ATS_CONFIRM_RELAY_INTERFACE	((UINT8)0x27)	/*相邻联锁继电接口确认状态指示灯*/
 

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

@@ -129,6 +129,9 @@ UINT8 InitAllStaticDataStr(void)
 	/*声光报警器配置数据结构体*/
 	chRtn &= CommonMemSet(SGBJConfigDataStru, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)), 0u, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)));
 
+	/*试灯数据配置结构体*/
+	chRtn &= CommonMemSet(LightTestButtonConfigDataStru, (UINT32)(LIGHTTESTBUTTON_BUTTON_MAX_NUM * sizeof(LightTestButtonConfigDataStruct)), 0u, (UINT32)(LIGHTTESTBUTTON_BUTTON_MAX_NUM * sizeof(LightTestButtonConfigDataStruct)));
+
 	return chRtn;
 }
 
@@ -246,6 +249,7 @@ UINT8 ReadConfigureData(void)
 			{
 				; /*不处理*/
 			}
+			
 			if (0u == rtnVal)
 			{
 				PhysicalSectionCurSum = ReadPhySicalSectionConfigData(LocalCiId, PhysicalSectionConfigDataStru);/*读物理区段配置数据*/
@@ -446,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)
 				{
@@ -468,15 +479,7 @@ UINT8 ReadConfigureData(void)
 
 					}
 				}
-				else
-				{
-					IndicatorCurSum = ReadIndicatorConfigData(LocalCiId, IndicatorConfigDataStru);                  /*读指示灯报警灯配置数据*/
-					if (-1 == IndicatorCurSum)
-					{
-						rtnVal = 20u;/*读取指示灯报警灯配置数据失败*/
-						debug_infor_printf((const)"ReadIndicatorConfigData fail.");
-					}
-				}
+#endif	
 			}
 			else
 			{
@@ -552,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配置数据*/
@@ -1083,6 +1102,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;
+			}
+		}
+
+
 
 	}
 
@@ -1099,7 +1144,6 @@ UINT8 ReadConfigureData(void)
 UINT8 DeviceDataManage(void)
 {
 	UINT8 rtValue = 0u;
-	UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 reval = CI_ERROR;
     /*整理继电器数据*/
     if (CI_ERROR == RelayConfigDataManage())
@@ -1223,6 +1267,7 @@ UINT8 DeviceDataManage(void)
 	{
 		rtValue = 0u;
 	}
+#if 0
 	if(FUNC_SWITCH_ON == includeVirFlag)
 	{
 		reval = InitVirCIlocalCiIndicatorIdBuf();
@@ -1231,15 +1276,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();
@@ -2040,6 +2087,11 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, Phys
 							{
 								pSwitchCfgData[j].ByPassRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 							}
+							/*IBP*/
+							else if(SWITCH_IBP_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSwitchCfgData[j].IbpDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+							}
 							else
 							{
 								/*不做处理*/

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;

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

@@ -243,7 +243,12 @@ UINT8 InitialPhySecIdBufOfOtherCi(void);
 * 返回值  ： void
 */
 void ResetDynamicState(const UINT8 ciId);
-
+/*
+* 功能描述：重置相邻Rc通信中断动态数据
+* 参数说明：const UINT8 ciId, 重置联锁ID
+* 返回值  ： void
+*/
+void ResetDynamicRcState(const UINT8 ciId);
 	
 /*
 * 功能描述： 初始化全自动折返进路数据
@@ -330,6 +335,24 @@ UINT8 InitLEUDataStru(void);
 */
 UINT8 InitialRtnIndicStaData(void);
 
+/*
+* 功能描述：重置本控区RC的设备动态数据
+* 参数说明：void
+* 返 回 值：void
+* Created By LQ 2025.11.07
+*/
+void ResetLocalRcDynamicState(void);
+
+/*
+* 功能描述：重置控区设备状态处理
+* 参数说明：void
+* 返 回 值：无
+* Created By LQ 2025.11.19
+*/
+void ResetDevStateProcess(void);
+
+
+
 #ifdef __cplusplus
 }
 #endif

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)39U)
+
+/* 试灯按钮可配置最大数量 */
+#define LIGHTTESTBUTTON_BUTTON_MAX_NUM     ((UINT16)70U)
+
+/* 武汉新港OC采集试灯按钮类型 */
+#define LIGHTTESTBUTTON_TYPE_XINGANG ((UINT8)0xaaU)
+
+#endif
+
+

TSCP/src/APP/ciapp/LogRecord/LogRecord.c

@@ -13,6 +13,7 @@
 
 #include "LogRecord.h"
 #include "../ParsePack/ParsePackVobcData.h"
+#include "../ParsePack/ParsePackZcData.h"
 #include <stdarg.h>
 
 
@@ -21,18 +22,27 @@ UINT16 colStringLength = 0u;
 UINT8 drvString[RELAY_SUM_MAX] = {0u};/*驱动数据*/
 UINT16 drvStringLength = 0u;
 AxisSectionDataStruct Record_AxisSecDataStru[AXIS_SECTION_SUM_MAX];/*参考计轴区段数据*/
+AxisSectionDataStructCC Record_AxisSecDataStruCC[AXIS_SECTION_SUM_MAX];/*参考计轴区段数据-车车*/
 SignalDataStruct Record_SignalDataStru[SIGNAL_SUM_MAX];/*参考信号机动态数据*/
+SignalDataStructCC Record_SignalDataStruCC[SIGNAL_SUM_MAX];/*参考信号机动态数据-车车*/
 EsbDataStruct Record_EsbDataStru[ESB_SUM_MAX]; /*参考ESB动态数据*/
 SwitchDataStruct Record_SwitchDataStru[SWITCH_SUM_MAX];/*参考道岔动态数据*/
 PhysicalSectionDataStruct Record_PhysicalSectionDataStru[PHYSICAL_SECTION_SUM_MAX];/*参考物理区段动态数据*/
+PhysicalSectionDataStructCC Record_PhySecDataStruCC[PHYSICAL_SECTION_SUM_MAX] = { 0U };/*参考物理区段动态数据CC*/
 RouteDataStruct Record_RouteDataStru[ROUTE_SUM_MAX];/*参考进路动态数据*/
+RouteDataStructCC Record_RouteDataStruCC[ROUTE_SUM_MAX];/*参考进路动态数据-车车*/
 NonRouteDataStruct Record_NonRouteDataStru[NONROUTE_ID_NUM_MAX]; /*参考非进路调车动态数据*/
 LogicSectionDataStruct Record_LogicSecDataStru[LOGIC_SECTION_SUM_MAX];/*参考逻辑区段动态数据*/
+LogicSectionDataStructCC Record_LogicSecDataStruCC[LOGIC_SECTION_SUM_MAX];/*参考逻辑区段动态数据-车车*/
 WashMachineDataStruct Record_WashMachineDataStru[WASHMACHINE_SUM_MAX]; /*参考洗车机动态数据*/
 PsdDataStruct Record_PsdDataStru[PSD_SUM_MAX];/*参考屏蔽门动态数据*/
+PsdDataStructCC Record_PsdDataStruCC[PSD_SUM_MAX] = { 0U };/*参考屏蔽门动态数据CC*/
 GaragedoorDataStruct Record_GaragedoorDataStru[GARAGE_DOOR_SUM_MAX];   /*参考车库门数据结构体*/
-FloodGateDataStruct Record_FloodGateDataStru[FLOOD_GATE_SUM_MAX];	/**/
+GaragedoorDataStructCC Record_GaragedoorDataStruCC[GARAGE_DOOR_SUM_MAX];   /*参考车库门数据结构体-车车*/
+FloodGateDataStruct Record_FloodGateDataStru[FLOOD_GATE_SUM_MAX];	/*参考防烟门数据结构体*/
+FloodGateDataStructCC Record_FloodGateDataStruCC[FLOOD_GATE_SUM_MAX];	/*参考防烟门数据结构体-车车*/
 OverlapDataStruct Record_OverlapDataStru[OVERLAP_SUM_MAX];/*参考保护区段动态数据*/
+OverlapDataStructCC Record_OverlapDataStruCC[OVERLAP_SUM_MAX];/*参考保护区段动态数据-车车*/
 VirCIKeyDataStru Record_VirCIKeyDataStru[VIRTUAL_CI_MAX]= {0u};/*记录虚拟联锁关键数据*/
 VirCIKeyDataStru newVirCIKeyDataStru[VIRTUAL_CI_MAX]= {0u};
 SpksDataStruct Record_spksDataBuff[SPKS_SUM_MAX] = { 0u };
@@ -42,7 +52,7 @@ TsrDataStruct Record_TsrInfo[TSR_MAX_SUM] = { 0u };		/*
 OCStationIndicDataStru Record_OCStationIndicBuff[INDICATOR_SUM_MAX] = { 0u };
 LogicalRouteDataStruct Record_LogicalRouteDataStru[ROUTE_LOGICAL_SUM_MAX] = { 0U };
 NonAutoReturnDataStruct Record_NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX] = { 0U };
-
+NonAutoReturnDataStructCC Record_NonReturnDataStruCC[NON_AUTO_RETURN_SUM_MAX] = { 0U };
 UINT8 outString[1024*1024] = {0u};/*比较后的设备打印数据缓冲*/
 extern QueueStruct logPrintfQue;    /*日志打印缓存队列*/
 UINT16 logIndex = 0u;             /*日志缓存索引*/
@@ -458,19 +468,29 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	UINT16 wTrainId = 0u;
     UINT8 returnValue = CI_SUCCESS;/*返回值*/
     UINT8 comparaResult = 0u;/*比较结果*/
+	UINT8 comparaResultCC = 0u;/*比较结果*/
 	UINT16 floodGateTotalSum = 0u;/*防淹门总数量*/
 	AxisSectionDataStruct* newAxisSecData = GetAxisSecData();
+	AxisSectionDataStructCC* pAxisSecDataCC = GetAxisSecDataCC();
     SignalDataStruct* newSignalData = GetSignalData();
+	SignalDataStructCC* pSignalDataCC = GetSignalDataCC();
     SwitchDataStruct* newSwitchData = GetSwitchData();
     PhysicalSectionDataStruct* newPhysicalSectionData = GetPhySecData();
+	PhysicalSectionDataStructCC* pPhysicalSectionDataCC = GetPhySecDataCC();
     RouteDataStruct* newRouteData = GetRouteData();
+	RouteDataStructCC* pRouteDataCC = GetRouteDataCC();
     NonRouteDataStruct* newNonRouteDataStru = GetNonRouteDataPtr();
     LogicSectionDataStruct* newLogicSecData = GetLogicSecData();
+	LogicSectionDataStructCC* pLogicSecDataCC = GetLogicSecDataCC();
 	WashMachineDataStruct* newWashMachineData = GetWashMachineData();
 	PsdDataStruct * newPsdData = GetPsdData();
+	PsdDataStructCC* pPsdDataCC = GetPsdDataCC();
     GaragedoorDataStruct* newGaragedoorData = GetGaragedoorData();   /*获取车库门数据结构体*/
+	GaragedoorDataStructCC* pGaragedoorDataCC = GetGaragedoorDataCC();   /*获取车库门数据结构体*/
 	FloodGateDataStruct *pNewFloodGateData = GetFloodGateData();		/*获取防淹门数据结构体*/
+	FloodGateDataStructCC* pNewFloodGateDataCC = GetFloodGateDataCC();		/*获取防淹门数据结构体*/
 	OverlapDataStruct* newOverlapData = GetOverlapData();
+	OverlapDataStructCC* pOverlapDataCC = GetOverlapDataCC();
 	TrainInfoStru* pNewTrainInfoData = GetTrainInfoData();
 	TsrDataStruct* pNewTsrInfo = GetTsrData();			/* 临时限速信息 */
 	CfpDataStru * pNewCfpData = GetCfpData();
@@ -478,14 +498,16 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	OCStationIndicDataStru* pNewOCStationIndicData = GetOCStationIndicDataStru();
 	EsbDataStruct* pNewEsbData = GetEsbData();
 	LogicalRouteDataStruct* pNewLogicalRouteDataStru = GetLogicalRouteStr();
+	CbtcCrossStructZC* pCbtcCrossStructZCStru = GetCbtcCrossStructZc();
 	UINT16 wCfpId = 0u;
 	UINT8 chEnIndex = 0u;
 	UINT8 chTrainIndex = 0u;
 	UINT16 deviceNum = 0u; 
 	UINT8 localCiType = 0u;
 	UINT16 wNonAutoReturnCurSum = 0U;/*无人折返按钮当前总数*/
-	NonAutoReturnDataStruct* pNonAutoReturnData = NULL;/*无人折返数据结构体指针*/
-
+	NonAutoReturnDataStruct* pNonAutoReturnData = NULL;    /*无人折返数据结构体指针*/
+	NonAutoReturnDataStructCC* pNonReturnDataStruCC = NULL;  /*无人折返数据结构体指针-CC*/
+	UINT8 chThisOCBoardState = 0U;
 
     /*************************************打印物理区段数据********************************************/
     /*打印区段数据*/
@@ -497,9 +519,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
         deviceId = GetPhySecId(ii);
         comparaResult = DeviceCompara((UINT8*)(&Record_PhysicalSectionDataStru[deviceId]), (UINT16)sizeof(PhysicalSectionDataStruct),
             (UINT8*)(&newPhysicalSectionData[deviceId]), (UINT16)sizeof(PhysicalSectionDataStruct));
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_PhySecDataStruCC[deviceId]), (UINT16)sizeof(PhysicalSectionDataStructCC),
+			(UINT8*)(&pPhysicalSectionDataCC[deviceId]), (UINT16)sizeof(PhysicalSectionDataStructCC));
 
-
-        if(0u != comparaResult)
+        if ((1U == comparaResult) || (1U == comparaResultCC))
         {/*比较数据不一致*/
 
             if (CI_ERROR != Flag)
@@ -529,11 +552,15 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].SectionResetType;/*区段计轴复位类型*/
 				LongToChar(newPhysicalSectionData[deviceId].SectionResetStartCycNum, &outString[outStringLength]);/*区段计轴复位开始周期*/
 				outStringLength += 4u;
+				outString[outStringLength++] = newPhysicalSectionData[deviceId].chResetCmdTag;/*复位命令标签*/
+				outString[outStringLength++] = newPhysicalSectionData[deviceId].chResetCmdTagBack;/*复位命令标签反馈*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].PhySecPreResetState;/*计轴预复位状态*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].chPreResetBack;/*预复位命令反馈*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].chDirectResetRst;/*直接复位结果*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].chDirectResetBack;/*直接复位命令反馈*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].StopSteadyFlag;/*停稳状态信息*/
+				outString[outStringLength] = pPhysicalSectionDataCC[deviceId].StopSteadyFlag;/*停稳状态信息CC(0x55-未停稳，0xAA-停稳)*/
+				outStringLength++;
                 outString[outStringLength++] = newPhysicalSectionData[deviceId].ArbState;/*ARB状态*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].ProtectSecLockDelayTimeFlag;/*保护区段锁闭延时标志(动态字段)*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].StopCheckFlag;			   /*物理区段停止检查标志(未设置/设置) (动态字段)*/
@@ -567,6 +594,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
             }
         }
+		else
+		{
+			/*数据一致，不处理*/
+		}
     }
 
     if (0u == outStringLength)
@@ -613,11 +644,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
         comparaResult = DeviceCompara((UINT8*)(&Record_SignalDataStru[deviceId]), (UINT16)sizeof(SignalDataStruct),
             (UINT8*)(&newSignalData[deviceId]), (UINT16)sizeof(SignalDataStruct));
 
-        if (0u==comparaResult)
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_SignalDataStruCC[deviceId]), (UINT16)sizeof(SignalDataStructCC),
+			(UINT8*)(&pSignalDataCC[deviceId]), (UINT16)sizeof(SignalDataStructCC));
+
+        if ((0U==comparaResult) && (0U == comparaResultCC))
         {/*比较数据一致*/
 
         }
-        else if (1u==comparaResult )
+        else if ((1U==comparaResult ) || (1U == comparaResultCC))
         {/*比较数据不一致*/
 
             if (CI_ERROR != Flag)
@@ -628,6 +662,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 2u;
 				outString[outStringLength++] = newSignalData[deviceId].FLockState;/*封锁状态*/
 				outString[outStringLength++] = newSignalData[deviceId].LightExtinctState;/*亮灭灯状态*/
+				outString[outStringLength] = pSignalDataCC[deviceId].LightExtinctState;/*亮灭灯状态CC(0x55：灭灯，0xaa：亮灯)*/
+				outStringLength++;
 				outString[outStringLength++] = newSignalData[deviceId].PreColor;/*之前显示颜色*/
 				outString[outStringLength++] = newSignalData[deviceId].CurColor;/*当前显示颜色*/
 				outString[outStringLength++] = newSignalData[deviceId].PreDriveColor;/*之前驱动颜色*/
@@ -640,6 +676,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				LongToChar(newSignalData[deviceId].CollSigOpenStartCycNum,&outString[outStringLength]);  /*采集信号机开放起始周期*/
 				outStringLength += 4u;
 				outString[outStringLength++] = newSignalData[deviceId].SignalCrossState;/*信号机跨压状态*/
+				outString[outStringLength] = pSignalDataCC[deviceId].SignalCrossState;/*信号机跨压状态CC(0x55：未跨压，0xaa：跨压)*/
+				outStringLength++;
 				outString[outStringLength++] = newSignalData[deviceId].SignalYLockOpenState;/*引导总锁信号开放状态*/
 				outString[outStringLength++] = newSignalData[deviceId].AtsDetainFlag;/*Ats人工扣车标志*/
 				outString[outStringLength++] = newSignalData[deviceId].AtsDetainFlagAuto;/*Ats自动扣车标志*/
@@ -666,8 +704,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newSignalData[deviceId].DoubleGreenDsBreakFlag;/*双绿灯丝断丝标志状态*/
 				outString[outStringLength++] = newSignalData[deviceId].DoubleYellowDsBreakFlag;/*双黄灯丝断丝标志状态*/
 				outString[outStringLength++] = newSignalData[deviceId].MaintainLightState;/*信号机维修点灯状态*/
+				outString[outStringLength++] = pSignalDataCC[deviceId].wCrossTacsTrainId;/*TACS跨压列车ID*/
 
-				if (MAX_SIGNAL_LIGHTUPLINK_NUM < newSignalData[deviceId].wSignalLightUpLinkIdSum)
+				if (MAX_SIGNAL_LIGHTUPLINK_NUM < pSignalDataCC[deviceId].wSignalLightUpLinkIdSum)
 				{
 					/* 数量合法 */
 					ShortToChar(0u, &outString[outStringLength]);/*信号机点灯link数量*/
@@ -676,12 +715,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				else
 				{
 					/* 数量合法 */
-					ShortToChar(newSignalData[deviceId].wSignalLightUpLinkIdSum, &outString[outStringLength]);/*信号机点灯link数量*/
+					ShortToChar(pSignalDataCC[deviceId].wSignalLightUpLinkIdSum, &outString[outStringLength]);/*信号机点灯link数量*/
 					outStringLength += 2u;
 
-					for (jj = 0u; jj < newSignalData[deviceId].wSignalLightUpLinkIdSum; jj++)
+					for (jj = 0u; jj < pSignalDataCC[deviceId].wSignalLightUpLinkIdSum; jj++)
 					{
-						ShortToChar(newSignalData[deviceId].szSignalLightUpLinkIdBuf[jj], &outString[outStringLength]);/*信号机点灯link数量*/
+						ShortToChar(pSignalDataCC[deviceId].szSignalLightUpLinkIdBuf[jj], &outString[outStringLength]);/*信号机点灯link数量*/
 						outStringLength += 2u;
 					}
 				}
@@ -699,9 +738,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
 				LongToChar(newSignalData[deviceId].CancelDetainErrTrigPressCycNum, &outString[outStringLength]); /*取消扣车按钮误触发按下周期*/
 				outStringLength += 4u;
-				ShortToChar(newSignalData[deviceId].wSignalLightUpTrainId, &outString[outStringLength]);/*信号机点灯区段接近列车ID*/
+				ShortToChar(pSignalDataCC[deviceId].wSignalLightUpTrainId, &outString[outStringLength]);/*信号机点灯区段接近列车ID*/
 				outStringLength += 2u;
-				outString[outStringLength++] = newSignalData[deviceId].cSleepTrainLightUpFlag;  /*休眠车点亮信号机标志：0x55 无效，0xAA 有效*/
+				outString[outStringLength++] = pSignalDataCC[deviceId].cSleepTrainLightUpFlag;  /*休眠车点亮信号机标志：0x55 无效，0xAA 有效*/
 				outString[outStringLength++] = newSignalData[deviceId].cInHumidRailFlag;  /*信号机湿轨标志：0x55 无效，0xAA 有效*/
 				outString[outStringLength] = newSignalData[deviceId].cDetCutBtnState;  /*扣车旁路按钮状态：0x55-无效，0xAA-有效*/
 				outStringLength++;
@@ -798,6 +837,11 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
 				LongToChar(pNewEsbData[deviceId].EsbCutErrTriggerPressCycNum, &outString[outStringLength]);  /*紧急关闭旁路按钮误触发按下周期*/
 				outStringLength += 4U;
+
+				outString[outStringLength] = pNewEsbData[deviceId].cOnePlatEsbState;/*同站紧急按钮激活状态：0x55-未激活，0xAA-激活*/
+				outStringLength++;
+				outString[outStringLength] = pNewEsbData[deviceId].cOnePlatEsbCutState;/*同站紧急旁路按钮激活状态：0x55-未激活，0xAA-激活*/
+				outStringLength++;
 			}
 		}
 		else
@@ -915,6 +959,36 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newSwitchData[deviceId].chSwitchJichaState;   /*道岔挤岔状态*/
 				LongToChar(newSwitchData[deviceId].SwitchCollTolerateCycNum, &outString[outStringLength]);/*容忍周期号*/
 				outStringLength += 4u;
+
+				LongToChar(newSwitchData[deviceId].SwitchOutputDrvCmdCycNum, &outString[outStringLength]);/*驱动起始周期*/
+				outStringLength += 4u;
+
+				outString[outStringLength++] = newSwitchData[deviceId].mainControlOcId;/*主控OC*/
+
+				outString[outStringLength++] = newSwitchData[deviceId].chSwitchBelongOcNum;/*道岔所属OC数*/
+				for (jj = 0U; jj < newSwitchData[deviceId].chSwitchBelongOcNum; jj++)
+				{
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].OcId;/*道岔所属OC*/
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].controlMode;/*OC当前主控状态*/
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].OutControlCmd;/*发送OC当前主控命令*/
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].PlusBoxSate;/*插箱状态*/
+					chThisOCBoardState = GetSwitchThisOCBoardState(deviceId, newSwitchData[deviceId].belongOCData[jj].OcId);
+					outString[outStringLength++] = chThisOCBoardState;/*双系板卡故障状态*/
+
+					LongToChar(newSwitchData[deviceId].belongOCData[jj].OutMainControlCmdCycNum, &outString[outStringLength]);/*升主控命令周期*/
+					outStringLength += 4u;
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].FindPostionCmd;/*寻表命令*/
+					LongToChar(newSwitchData[deviceId].belongOCData[jj].FindCmdStartCycNum, &outString[outStringLength]);/*寻表命令起始周期*/
+					outStringLength += 4u;
+				}
+
+				outString[outStringLength++] = newSwitchData[deviceId].PLockedAxisSecNum;/*被防护锁闭的计轴区段ID*/
+				for (jj = 0; jj < SWITCH_MAX_PROTECT_LOCKED_NUM; jj++)
+				{
+					ShortToChar(newSwitchData[deviceId].PLockedAxisSecIdArr[jj], &outString[outStringLength]);
+					outStringLength += 2u;
+				}
+				
             }
         }
         else
@@ -963,11 +1037,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
         comparaResult = DeviceCompara((UINT8*)(&Record_RouteDataStru[deviceId]), (UINT16)sizeof(RouteDataStruct),
             (UINT8*)(&newRouteData[deviceId]), (UINT16)sizeof(RouteDataStruct));
 
-        if (0u==comparaResult)
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_RouteDataStruCC[deviceId]), (UINT16)sizeof(RouteDataStructCC),
+			(UINT8*)(&pRouteDataCC[deviceId]), (UINT16)sizeof(RouteDataStructCC));
+
+        if ((0U == comparaResult) && (0U == comparaResultCC))
         {/*比较数据一致*/
             
         }
-        else if (1u==comparaResult )
+        else if ((1U==comparaResult) || (1U == comparaResultCC))
         {/*比较数据不一致*/
             
             if (CI_ERROR != Flag)
@@ -1003,6 +1080,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				ShortToChar(newRouteData[deviceId].AllAutoReturnId,&outString[outStringLength]);/*全自动折返进路ID*/
 				outStringLength += 2u;
 				outString[outStringLength++] = newRouteData[deviceId].StopensureFlag;/*停车保证标志*/
+				outString[outStringLength] = pRouteDataCC[deviceId].StopensureFlag;/*停车保证标志CC(0x55：已设置，0xAA：未设置)*/
+				outStringLength++;
 				outString[outStringLength++] = newRouteData[deviceId].StopKeepCheckFlag; /* 保持时候用的停车保证标志 */
 				outString[outStringLength++] = newRouteData[deviceId].RouteStateFlag;       /*进路状态标志（1：表示有效；0：表示无效）*/
 				outString[outStringLength++] = newRouteData[deviceId].TrainEnterFlag;/*列车驶入标志*/
@@ -1035,19 +1114,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newRouteData[deviceId].AutoSigPropertyLoseEfficacyFlag;   /*自动信号属性失效标志（未设置/设置）*/
 				outString[outStringLength++] = newRouteData[deviceId].OverlapNeedCIlockFlag;   /*保护区段需要CI锁闭标志*/
 				outString[outStringLength++] = newRouteData[deviceId].OverlapLockProcFlag;     /*保护区段在锁闭过程中标志*/
-				ShortToChar(newRouteData[deviceId].wStopEnsureTrainId, &outString[outStringLength]);/*进路停车保证列车ID*/
+				ShortToChar(pRouteDataCC[deviceId].wStopEnsureTrainId, &outString[outStringLength]);/*进路停车保证列车ID*/
 				outStringLength += 2u;
-				LongToChar(newRouteData[deviceId].dwStopEnsureCyc, &outString[outStringLength]);/*停车保证询问周期号*/
+				LongToChar(pRouteDataCC[deviceId].dwStopEnsureCyc, &outString[outStringLength]);/*停车保证询问周期号*/
 				outStringLength += 4u;
-				outString[outStringLength++] = newRouteData[deviceId].cResReqOtherCIId;   /*发送资源申请的联锁ID*/
+				outString[outStringLength++] = pRouteDataCC[deviceId].cResReqOtherCIId;   /*发送资源申请的联锁ID*/
 
 
-				if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= newRouteData[deviceId].chResReqTrainSum)
+				if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= pRouteDataCC[deviceId].chResReqTrainSum)
 				{
-					outString[outStringLength++] = newRouteData[deviceId].chResReqTrainSum;   /*发送资源申请的联锁ID*/
-					for (jj = 0u; jj < newRouteData[deviceId].chResReqTrainSum; jj++)
+					outString[outStringLength++] = pRouteDataCC[deviceId].chResReqTrainSum;   /*发送资源申请的联锁ID*/
+					for (jj = 0u; jj < pRouteDataCC[deviceId].chResReqTrainSum; jj++)
 					{
-						ShortToChar(newRouteData[deviceId].wszResReqTrainId[jj], &outString[outStringLength]);/*发送资源申请的列车ID*/
+						ShortToChar(pRouteDataCC[deviceId].wszResReqTrainId[jj], &outString[outStringLength]);/*发送资源申请的列车ID*/
 						outStringLength += 2u;
 					}
 				}
@@ -1056,13 +1135,13 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 					outString[outStringLength++] = 0u;   /*发送资源申请的联锁ID*/
 				}
 
-				if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= newRouteData[deviceId].ITSRouteApplyTrainIdSum)
+				if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= pRouteDataCC[deviceId].ITSRouteApplyTrainIdSum)
 				{
-					outString[outStringLength++] = newRouteData[deviceId].ITSRouteApplyTrainIdSum;   /*ITS申请路径命令的列车ID记录总数*/
+					outString[outStringLength++] = pRouteDataCC[deviceId].ITSRouteApplyTrainIdSum;   /*ITS申请路径命令的列车ID记录总数*/
 
-					for (jj = 0u; jj < newRouteData[deviceId].ITSRouteApplyTrainIdSum; jj++)
+					for (jj = 0u; jj < pRouteDataCC[deviceId].ITSRouteApplyTrainIdSum; jj++)
 					{
-						ShortToChar(newRouteData[deviceId].ITSRouteApplyTrainIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
+						ShortToChar(pRouteDataCC[deviceId].ITSRouteApplyTrainIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
 						outStringLength += 2u;
 					}
 
@@ -1073,16 +1152,16 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				}
 
 				/*可动道岔标志*/
-				outString[outStringLength++] = newRouteData[deviceId].HalfRouteDataSt.HalfRouteSwitchMoveValid;
+				outString[outStringLength++] = pRouteDataCC[deviceId].HalfRouteDataSt.HalfRouteSwitchMoveValid;
 				
-				if (MAX_ROUTE_IN_LT_NUM > newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecNum)
+				if (MAX_ROUTE_IN_LT_NUM > pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecNum)
 				{
 					/*部分锁闭逻辑区段数量*/
-					outString[outStringLength++] = newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecNum;   
+					outString[outStringLength++] = pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecNum;
 					/*部分锁闭逻辑区段ID*/
-					for (jj = 0u; jj < newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecNum; jj++)
+					for (jj = 0u; jj < pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecNum; jj++)
 					{
-						ShortToChar(newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
+						ShortToChar(pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
 						outStringLength += 2u;
 					}
 
@@ -1092,18 +1171,18 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 					outString[outStringLength++] = 0u;
 				}
 				/*部分锁闭列车ID*/
-				ShortToChar(newRouteData[deviceId].HalfRouteDataSt.HalfResReqTrainId, &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
+				ShortToChar(pRouteDataCC[deviceId].HalfRouteDataSt.HalfResReqTrainId, &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
 				outStringLength += 2u;
 		
-				if (ROUTE_TRAIN_LOC_MAX_LGC_SUM >= newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecNum)
+				if (ROUTE_TRAIN_LOC_MAX_LGC_SUM >= pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecNum)
 				{
 					/*部分锁闭列车身下资源数量*/
-					outString[outStringLength++] = newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecNum;  
+					outString[outStringLength++] = pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecNum;
 
-					for (jj = 0u; jj < newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecNum; jj++)
+					for (jj = 0u; jj < pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecNum; jj++)
 					{
 						/*部分锁闭列车身下资源逻辑区段ID*/
-						ShortToChar(newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
+						ShortToChar(pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
 						outStringLength += 2u;
 					}
 
@@ -1112,7 +1191,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				{
 					outString[outStringLength++] = 0u;
 				}
-				LongToChar(newRouteData[deviceId].dwFirstElockStartCycNum, &outString[outStringLength]); /*进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
+				LongToChar(pRouteDataCC[deviceId].dwFirstElockStartCycNum, &outString[outStringLength]); /*进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
 				outStringLength += 4u;
 
 				outString[outStringLength++] = newRouteData[deviceId].cRelZuHeRouteSGBJDelayFlag;  /*关联组合进路声光报警是否延时标志*/
@@ -1123,8 +1202,11 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newRouteData[deviceId].cRouteNeedDriveSGBJFlag;  /*进路驱动声光报警标志*/
 
 				outString[outStringLength++] = newRouteData[deviceId].cRouteDrivedSGBJFlag;  /*进路驱动声光报警标志：0x55 未驱动过；0xAA 已驱动过*/
-				outString[outStringLength++] = newRouteData[deviceId].chRouteNearSecSearchState;  /*进路接近区段查询状态是否有故障车*/
+				outString[outStringLength++] = pRouteDataCC[deviceId].chRouteNearSecSearchState;  /*进路接近区段查询状态是否有故障车*/
 				outString[outStringLength++] = newRouteData[deviceId].chRouteApplySwitchCheckFlag;  /*进路办理相邻控区道岔检查标志*/
+				outString[outStringLength++] = newRouteData[deviceId].chRoutCouplinkFlag;			 /*进路联挂标志*/
+				outString[outStringLength++] = newRouteData[deviceId].chCouplinkSuccessFlag;	     /*进路联挂成功*/
+				outString[outStringLength++] = newRouteData[deviceId].chCouplinkErrorFlag;			 /*进路联挂失败*/
             }
         }
 		else
@@ -1265,12 +1347,13 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
         deviceId = GetLogicSecId(ii);
         comparaResult = DeviceCompara((UINT8*)(&Record_LogicSecDataStru[deviceId]), (UINT16)sizeof(LogicSectionDataStruct),
             (UINT8*)(&newLogicSecData[deviceId]), (UINT16)sizeof(LogicSectionDataStruct));
-
-        if (0u==comparaResult)
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_LogicSecDataStruCC[deviceId]), (UINT16)sizeof(LogicSectionDataStructCC),
+			(UINT8*)(&pLogicSecDataCC[deviceId]), (UINT16)sizeof(LogicSectionDataStructCC));
+        if ((0U==comparaResult) && (0U == comparaResultCC))
         {/*比较数据一致*/
             
         }
-        else if (1u==comparaResult )
+        else if ((1U==comparaResult) || (1U == comparaResultCC))
         {/*比较数据不一致*/
             
             if (CI_ERROR==Flag)
@@ -1286,10 +1369,21 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newLogicSecData[deviceId].PreOccupyState;/*逻辑区段之前占用状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].CurOccupyState;/*逻辑区段当前占用状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].LinShiXianSuSetFlag;/*逻辑区段临时限速*/
-				outString[outStringLength++] = newLogicSecData[deviceId].OccupyState;/*逻辑区段占用状态*/
+				outString[outStringLength] = pLogicSecDataCC[deviceId].LinShiXianSuSetFlag;/*逻辑区段临时限速CC(0x55-已未设置临时限速，0xAA-已设置临时限速，0xFF-临时限速无效)*/
+				outStringLength++;
+				outString[outStringLength++] = newLogicSecData[deviceId].OccupyState;/*逻辑区段初始占用状态*/
+				outString[outStringLength] = pLogicSecDataCC[deviceId].OccupyState;/*逻辑区段初始占用状态CC(0x55-未占用，0xAA-非通信车占用，0xBB-通信车占用)*/
+				outStringLength++;
+				outString[outStringLength] = newLogicSecData[deviceId].TXOccupyState;/*逻辑区段通信车占用状态(0x55-无车或非通信车占用，0xAA-通信车占用)*/
+				outStringLength++;
+				outString[outStringLength] = pLogicSecDataCC[deviceId].TXOccupyState;/*逻辑区段通信车占用状态CC(0x55-无车或非通信车占用，0xAA-通信车占用)*/
+				outStringLength++;
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecCbtcArbState;/*逻辑区段CBTC_ARB状态*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecPbTacsArbState;/*逻辑区段PB_TACS_ARB状态*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chArbState;/*逻辑区段ARB状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].LogLockState;/*逻辑区段锁闭状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].LogLockDir;/*逻辑区段锁闭方向*/
-				outString[outStringLength++] = newLogicSecData[deviceId].chResShareFlag;/*逻辑区段共享标志 0x55共享 0xAA非共享*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].chResShareFlag;/*逻辑区段共享标志 0x55共享 0xAA非共享*/
 				ShortToChar(newLogicSecData[deviceId].LogLockBelongRoute,&outString[outStringLength]);/*逻辑锁闭所属进路*/
 				outStringLength += 2u;
 				LongToChar(newLogicSecData[deviceId].LogUnlockStartCycNum,&outString[outStringLength]);/*逻辑延时解锁周期号*/
@@ -1297,53 +1391,53 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				ShortToChar(newLogicSecData[deviceId].wPLockBelongRouteId, &outString[outStringLength]);/*防护锁闭的进路编号*/
 				outStringLength += 2u;
 
-				outString[outStringLength++] = newLogicSecData[deviceId].cResReqOtherCIId;/*发送资源请求的其他联锁ID*/
-				ShortToChar(newLogicSecData[deviceId].wResReqTrainId, &outString[outStringLength]);/*发送资源请求的列车ID*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].cResReqOtherCIId;/*发送资源请求的其他联锁ID*/
+				ShortToChar(pLogicSecDataCC[deviceId].wResReqTrainId, &outString[outStringLength]);/*发送资源请求的列车ID*/
 				outStringLength += 2u;
-				ShortToChar(newLogicSecData[deviceId].JumpLockTrainId, &outString[outStringLength]);/*申请或释放跳跃锁闭命令的列车ID*/
+				ShortToChar(pLogicSecDataCC[deviceId].JumpLockTrainId, &outString[outStringLength]);/*申请或释放跳跃锁闭命令的列车ID*/
 				outStringLength += 2u;
-				outString[outStringLength++] = newLogicSecData[deviceId].LogJumpLockState;/*逻辑区段跳跃锁闭状态 0x55 未锁闭，0xAA 锁闭*/
-				outString[outStringLength++] = newLogicSecData[deviceId].LogJumpLockDelayUnlockFlag;/*逻辑区段跳跃锁闭延时解锁设置标志 0x55 未设置，0xaa 设置*/
-				LongToChar(newLogicSecData[deviceId].LogSecJumpDelayUnlockStartCyc, &outString[outStringLength]);/*逻辑区段跳跃锁闭延时解锁起始周期号*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].LogJumpLockState;/*逻辑区段跳跃锁闭状态 0x55 未锁闭，0xAA 锁闭*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].LogJumpLockDelayUnlockFlag;/*逻辑区段跳跃锁闭延时解锁设置标志 0x55 未设置，0xaa 设置*/
+				LongToChar(pLogicSecDataCC[deviceId].LogSecJumpDelayUnlockStartCyc, &outString[outStringLength]);/*逻辑区段跳跃锁闭延时解锁起始周期号*/
 				outStringLength += 4u;
-				outString[outStringLength++] = newLogicSecData[deviceId].LogSecJumpLockPermFlag;/*逻辑区段跳跃锁闭允许标志 0x55 允许，0xaa 禁止*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].LogSecJumpLockPermFlag;/*逻辑区段跳跃锁闭允许标志 0x55 允许，0xaa 禁止*/
 
 
-				if (LOGIC_SECTION_RES_SUM_MAX < newLogicSecData[deviceId].chTrainInfoSum)
+				if (LOGIC_SECTION_RES_SUM_MAX < pLogicSecDataCC[deviceId].chTrainInfoSum)
 				{
 					/* 数量不合法 */
 					outString[outStringLength++] = 0u;/*逻辑区段资源数量*/
 				}
 				else
 				{
-					outString[outStringLength++] = newLogicSecData[deviceId].chTrainInfoSum;/*逻辑区段资源数量*/
-					for (jj = 0u; jj < newLogicSecData[deviceId].chTrainInfoSum; jj++)
+					outString[outStringLength++] = pLogicSecDataCC[deviceId].chTrainInfoSum;/*逻辑区段资源数量*/
+					for (jj = 0u; jj < pLogicSecDataCC[deviceId].chTrainInfoSum; jj++)
 					{
-						ShortToChar(newLogicSecData[deviceId].szTrainResData[jj].wTrainId, &outString[outStringLength]);/*列车ID*/
+						ShortToChar(pLogicSecDataCC[deviceId].szTrainResData[jj].wTrainId, &outString[outStringLength]);/*列车ID*/
 						outStringLength += 2u;
 
-						outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chTrainApplyState;/*列车申请状态*/
-						outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chLogicResUsable;/*列车资源状态*/
-						outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chLogicReturnState;/*折返逻辑区段标志*/
-						outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chLogicUnlockState;/*列车申请状态*/
-						LongToChar(newLogicSecData[deviceId].szTrainResData[jj].dwRcvUnlockCmdCyc, &outString[outStringLength]);/*逻辑延时解锁周期号*/
+						outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chTrainApplyState;/*列车申请状态*/
+						outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chLogicResUsable;/*列车资源状态*/
+						outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chLogicReturnState;/*折返逻辑区段标志*/
+						outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chLogicUnlockState;/*列车申请状态*/
+						LongToChar(pLogicSecDataCC[deviceId].szTrainResData[jj].dwRcvUnlockCmdCyc, &outString[outStringLength]);/*逻辑延时解锁周期号*/
 						outStringLength += 4u;
 					}
 				}
-				LongToChar(newLogicSecData[deviceId].LogErrlockStartCycNum, &outString[outStringLength]);/*逻辑区段延时设置故障锁闭起始周期号*/
+				LongToChar(pLogicSecDataCC[deviceId].LogErrlockStartCycNum, &outString[outStringLength]);/*逻辑区段延时设置故障锁闭起始周期号*/
 				outStringLength += 4U;
 				outString[outStringLength++] = newLogicSecData[deviceId].chLogicProResUsable;/*逻辑区段防护锁闭资源可用状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].chLogicSpksFLockState;/*逻辑区段被SPKS封锁状态*/
 
-				if (LOGSEC_RELATE_ROUTE_SUM_MAX >= newLogicSecData[deviceId].chLogSecLockBelLogRouteSum)
+				if (LOGSEC_RELATE_ROUTE_SUM_MAX >= pLogicSecDataCC[deviceId].chLogSecLockBelLogRouteSum)
 				{
-					outString[outStringLength++] = newLogicSecData[deviceId].chLogSecLockBelLogRouteSum;  /*逻辑区段锁闭所属逻辑进路数量*/
-					for (kk = 0U; kk < newLogicSecData[deviceId].chLogSecLockBelLogRouteSum; kk++)
+					outString[outStringLength++] = pLogicSecDataCC[deviceId].chLogSecLockBelLogRouteSum;  /*逻辑区段锁闭所属逻辑进路数量*/
+					for (kk = 0U; kk < pLogicSecDataCC[deviceId].chLogSecLockBelLogRouteSum; kk++)
 					{
-						ShortToChar(newLogicSecData[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteId, &outString[outStringLength]);  /*逻辑区段锁闭所属逻辑进路ID*/
+						ShortToChar(pLogicSecDataCC[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteId, &outString[outStringLength]);  /*逻辑区段锁闭所属逻辑进路ID*/
 						outStringLength += 2u;
-						outString[outStringLength++] = newLogicSecData[deviceId].szLogSecLockBelLogRouteData[kk].chLogSecLockBelLogRouteState;  /*逻辑区段锁闭所属逻辑进路状态*/
-						outString[outStringLength++] = newLogicSecData[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteDir;  /*逻辑区段被逻辑进路锁闭的方向ID*/
+						outString[outStringLength++] = pLogicSecDataCC[deviceId].szLogSecLockBelLogRouteData[kk].chLogSecLockBelLogRouteState;  /*逻辑区段锁闭所属逻辑进路状态*/
+						outString[outStringLength++] = pLogicSecDataCC[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteDir;  /*逻辑区段被逻辑进路锁闭的方向ID*/
 					}
 				}
 				else
@@ -1351,11 +1445,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 					outString[outStringLength++] = 0U;  /*逻辑区段锁闭所属逻辑进路数量超限，不解析*/
 				}
 
-				outString[outStringLength++] = newLogicSecData[deviceId].LogSecLogLockState;  /*逻辑区段逻辑锁闭状态*/
-				outString[outStringLength++] = newLogicSecData[deviceId].LogSecLogLockDir;  /*逻辑区段逻辑锁闭方向*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].LogSecLogLockState;  /*逻辑区段逻辑锁闭状态*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].LogSecLogLockDir;  /*逻辑区段逻辑锁闭方向*/
 				outString[outStringLength++] = newLogicSecData[deviceId].chLinShiXianSuSetSpeed;  /*逻辑区段临时限速值*/
-				outString[outStringLength++] = newLogicSecData[deviceId].chAblRelLogSecUsableFlag;  /*ABL列车关联逻辑区段允许使用标志*/
-				outString[outStringLength++] = newLogicSecData[deviceId].cRouteLeaveLogFlag;  /*离去区段ABL列车检查标志*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].chAblRelLogSecUsableFlag;  /*ABL列车关联逻辑区段允许使用标志*/
+				outString[outStringLength++] = pLogicSecDataCC[deviceId].cRouteLeaveLogFlag;  /*离去区段ABL列车检查标志*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecEmergXianSu;/*逻辑区段紧急临时限速*/
 			}
         }
         else
@@ -1427,9 +1522,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainEmergencyStopState;/*列车紧急停车状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].HeadWashAllowState;/*允许车头清洗状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].TailWashAllowState;/*允许车尾清洗状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chCoupingWashAllowState;/*允许联挂端清洗状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].WashTrainRequestDrvState;/*洗车请求驱动状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainHeadStopSteadyDrvState;/*车头停稳驱动状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainTailStopSteadyDrvState;/*车尾停稳驱动状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chCoupingStopSteadyDrvState;    /*联挂端停稳驱动状态*/
+
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainOutWashTrainPortAllowState;/*允许出洗车库状态*/
 				ShortToChar(newWashMachineData[deviceId].CurVobcId, &outString[outStringLength]);/*当前洗车的VOBC ID*/
 				outStringLength += 2u;
@@ -1437,18 +1535,46 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newWashMachineData[deviceId].PauseTrainWashRequestDrvState;/*暂停洗车请求驱动状态(动态字段:驱动)*/
 				outString[outStringLength++] = newWashMachineData[deviceId].PaseWashMachineRequesDrvtState;/*通过洗车机请求驱动状态(动态字段:驱动)*/
 
-				outString[outStringLength++] = newWashMachineData[deviceId].WashmachineXTACurState;/*洗车同意按钮当前状态*/
-				outString[outStringLength++] = newWashMachineData[deviceId].WashmachineXTAPreState;/*洗车同意按钮上周期状态*/
-				outString[outStringLength++] = newWashMachineData[deviceId].WashmachineXTALogicState;/*洗车机按钮逻辑状态*/
-				LongToChar(newWashMachineData[deviceId].WashmachineXTAPressDownCycle,&outString[outStringLength]);/*洗车机洗车同意按钮按下起始周期*/
-				outStringLength += 4u;
 				outString[outStringLength++] = newWashMachineData[deviceId].WashMachineWorkModeDrvtState;/*洗车机洗车模式驱动状态(动态字段:驱动)*/
 				outString[outStringLength++] = newWashMachineData[deviceId].WashModeState;/*洗车机洗车模式采集状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].chSetWashWorkModeBack;/*设置洗车机工作模式反馈*/
-				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowState;/*降级模式洗车同意状态*/
-				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassState;/*降级模式洗车同意通过状态*/
 				LongToChar(newWashMachineData[deviceId].WashWorkModeRelayDrvCycle, &outString[outStringLength]);/*洗车模式继电器驱动起始周期号*/
 				outStringLength += 4u;
+
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowState;/**降级模式洗车同意状态(动态字段:融合)*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassState;/*降级模式洗车同意通过状态(动态字段:融合)*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashReqState;/*降级模式洗车请求状态*/
+				LongToChar(newWashMachineData[deviceId].dwDownWashReqCycle, &outString[outStringLength]);/*降级模式洗车请求周期*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashPassReqState;/*降级模式反向洗车请求状态*/
+				LongToChar(newWashMachineData[deviceId].dwDownWashPassReqCycle, &outString[outStringLength]);/*降级模式反向洗车请求周期*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowColState;/*降级模式洗车线洗车同意状态*/
+				LongToChar(newWashMachineData[deviceId].dwDownWashAllowCycle, &outString[outStringLength]);/*降级模式洗车线洗车同意按钮按下起始周期*/
+				outStringLength += 4u;
+				LongToChar(newWashMachineData[deviceId].dwDownWashBtVadCycle, &outString[outStringLength]);/*降级模式洗车线洗车同意按钮有效周期*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowColState;/*降级模式DCC洗车同意状态*/
+				LongToChar(newWashMachineData[deviceId].dwDownWashDccAllowCycle, &outString[outStringLength]);/*降级模式DCC洗车同意按钮按下起始周期*/
+				outStringLength += 4u;
+				LongToChar(newWashMachineData[deviceId].dwDownWashDccBtVadCycle, &outString[outStringLength]);/*降级模式DCC洗车同意按钮有效周期*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowErrState;/*降级模式洗车线洗车同意粘连状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowErrState;/*降级模式DCC洗车同意粘连状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassColState;/*降级模式洗车线洗车同意反向通过状态*/
+				LongToChar(newWashMachineData[deviceId].dwDownWashAllowPassCycle, &outString[outStringLength]);/*降级模式洗车线反向通过洗车同意按钮按下起始周期*/
+				outStringLength += 4u;
+				LongToChar(newWashMachineData[deviceId].dwDownWashBtVadPassCycle, &outString[outStringLength]);/*降级模式洗车线反向通过洗车同意按钮有效周期*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowPassColState;/*降级模式DCC洗车同意反向通过状态*/
+				LongToChar(newWashMachineData[deviceId].dwDownWashDccAllowPassCycle, &outString[outStringLength]);/*降级模式DCC反向通过洗车同意按钮按下起始周期*/
+				outStringLength += 4u;
+				LongToChar(newWashMachineData[deviceId].dwDownWashDccBtVadPassCycle, &outString[outStringLength]);/*降级模式DCC反向通过洗车同意按钮有效周期*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassErrState;/*降级模式洗车线洗车同意反向通过粘连状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowPassErrState;/*降级模式DCC洗车同意反向通过粘连状态*/
+
+
 			}
 
 		}
@@ -1492,12 +1618,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 		deviceId = GetPsdId(ii);
 		comparaResult = DeviceCompara((UINT8*)(&Record_PsdDataStru[deviceId]), (UINT16)sizeof(PsdDataStruct),
 			(UINT8*)(&newPsdData[deviceId]), (UINT16)sizeof(PsdDataStruct));
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_PsdDataStruCC[deviceId]), (UINT16)sizeof(PsdDataStructCC),
+			(UINT8*)(&pPsdDataCC[deviceId]), (UINT16)sizeof(PsdDataStructCC));
 
-		if (0u==comparaResult)
+		if ((0U == comparaResult) && (0U == comparaResultCC))
 		{/*比较数据一致*/
 
 		}
-		else if (1u==comparaResult )
+		else if ((1U == comparaResult)|| (1U == comparaResultCC))
 		{/*比较数据不一致*/
 
 			if (CI_ERROR==Flag)
@@ -1512,6 +1640,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 2u;
 				ShortToChar(newPsdData[deviceId].psdEditGroupInfo,&outString[outStringLength]);/*PSD 编组信息*/
 				outStringLength += 2u;
+				ShortToChar(pPsdDataCC[deviceId].psdEditGroupInfo, &outString[outStringLength]);/*PSD 编组信息CC(0-默认值，3-三编组，4-四编组，6-六编组，8-八编组)*/
+				outStringLength += 2U;
 				outString[outStringLength++] = newPsdData[deviceId].DoorButtonState;/*屏蔽门按钮状态*/
 				outString[outStringLength++] = newPsdData[deviceId].MutualLockRemoveState;/*屏蔽门互锁解除状态*/
 				outString[outStringLength++] = newPsdData[deviceId].PsdDriveState;/*屏蔽门驱动状态*/
@@ -1521,6 +1651,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newPsdData[deviceId].PsdCmd;/*操作屏蔽门的命令*/
 				LongToChar(newPsdData[deviceId].CmdSetCycle,&outString[outStringLength]);/*命令设置周期*/
 				outStringLength += 4u;
+				ShortToChar(pPsdDataCC[deviceId].SrcVobcId, &outString[outStringLength]);/*操作该屏蔽门的当前VOBC编号CC*/
+				outStringLength += 2U;
+				outString[outStringLength] = pPsdDataCC[deviceId].PsdCmd;/*操作屏蔽门的命令CC(0x00-默认值，0x55-打开PSD命令，0xAA-关闭PSD命令，0xFF-查询PSD命令)*/
+				outStringLength++;
+				LongToChar(pPsdDataCC[deviceId].CmdSetCycle, &outString[outStringLength]);/*命令设置周期CC*/
+				outStringLength += 4U;
 				LongToChar(newPsdData[deviceId].CmdSetCyclePsc,&outString[outStringLength]);/*psc状态设置周期*/
 				outStringLength += 4u;
 				outString[outStringLength++] = newPsdData[deviceId].doorOpenButtonState;/*站台开门按钮状态*/
@@ -1532,6 +1668,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
 				outString[outStringLength++] = newPsdData[deviceId].StartDetectionState;/*启动探测状态*/
 				outString[outStringLength++] = newPsdData[deviceId].StopDetectionState; /*停止探测状态*/
+				LongToChar(newPsdData[deviceId].StopDetectionCycNum,&outString[outStringLength]);/*停止探测周期*/
+				outStringLength += 4u;
 				outString[outStringLength++] = newPsdData[deviceId].VOBCDoorState;      /*VOBC车门状态*/
 				LongToChar(newPsdData[deviceId].PCBPressCycNum,&outString[outStringLength]);/*PCB按下起始周期*/
 				outStringLength += 4u;
@@ -1561,6 +1699,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength++;
 				LongToChar(newPsdData[deviceId].dwPsdRelayDownCycNum, &outString[outStringLength]);  /*PSD门关继电器落下起始周期*/
 				outStringLength += 4U;
+
+				outString[outStringLength] = newPsdData[deviceId].JXTCMutualLockFaultState;  /*间隙探测旁路按钮故障状态*/
+				outStringLength++;
+				LongToChar(newPsdData[deviceId].JXTCMutualLockStartCycNum, &outString[outStringLength]);  /*间隙探测旁路按钮按压起始周期*/
+				outStringLength += 4U;
+				outString[outStringLength++] = newPsdData[deviceId].ibpButtonState;/*IBP盘发车按钮状态*/
+				LongToChar(newPsdData[deviceId].IBPPressCycNum, &outString[outStringLength]);  /*IBP盘发车按钮按下周期*/
+				outStringLength += 4U;
 			}
 		}
 		else
@@ -1604,12 +1750,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
         deviceId = GetGaragedoorId(ii);
         comparaResult = DeviceCompara((UINT8*)(&Record_GaragedoorDataStru[deviceId]), (UINT16)sizeof(GaragedoorDataStruct),
             (UINT8*)(&newGaragedoorData[deviceId]), (UINT16)sizeof(GaragedoorDataStruct));
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_GaragedoorDataStruCC[deviceId]), (UINT16)sizeof(GaragedoorDataStructCC),
+			(UINT8*)(&pGaragedoorDataCC[deviceId]), (UINT16)sizeof(GaragedoorDataStructCC));
 
-        if (0u==comparaResult)
+        if ((0U == comparaResult) && (0U == comparaResultCC))
         {/*比较数据一致*/
 
         }
-        else if (1u==comparaResult )
+        else if ((1U == comparaResult) || (1U == comparaResultCC))
         {/*比较数据不一致*/
 
             if (CI_ERROR==Flag)
@@ -1624,7 +1772,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
                 outStringLength += 2u;
                 outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorState;      /*车库门状态 (动态字段)*/
                 outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorAllowCloseFlag; /*车库门允许关门标志ZC*/
-				outString[outStringLength++] = newGaragedoorData[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志IVOC*/
+				outString[outStringLength++] = pGaragedoorDataCC[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志IVOC*/
                 outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorModeState;       /*车库门模式状态*/
 				outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorFaultState;	/*车库门故障状态*/
 				outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorPangLuState;    /*车库门旁路状态*/;
@@ -1632,7 +1780,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
                 outString[outStringLength++] = newGaragedoorData[deviceId].cmdProcessState;			/* 命令处理状态 */
                 LongToChar(newGaragedoorData[deviceId].waiteZCResponseStartCycNum,&outString[outStringLength]);/* 等待ZC反馈开始时间 */
                 outStringLength += 4u; 
-				LongToChar(newGaragedoorData[deviceId].waiteIVOCResponseStartCycNum, &outString[outStringLength]);/* 等待IVOC反馈开始时间 */
+				LongToChar(pGaragedoorDataCC[deviceId].waiteIVOCResponseStartCycNum, &outString[outStringLength]);/* 等待IVOC反馈开始时间 */
 				outStringLength += 4u;
 				LongToChar(newGaragedoorData[deviceId].GaragedoorOpenStartCycNum,&outString[outStringLength]);/* 车库门打开开始周期 */
 				outStringLength += 4u; 
@@ -1681,12 +1829,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 		deviceId = GetFloodGateId(ii);
 		comparaResult = DeviceCompara((UINT8*)(&Record_FloodGateDataStru[deviceId]), (UINT16)sizeof(FloodGateDataStruct),
 			(UINT8*)(&pNewFloodGateData[deviceId]), (UINT16)sizeof(FloodGateDataStruct));
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_FloodGateDataStruCC[deviceId]), (UINT16)sizeof(FloodGateDataStructCC),
+			(UINT8*)(&pNewFloodGateDataCC[deviceId]), (UINT16)sizeof(FloodGateDataStructCC));
 
-		if (0u==comparaResult  )
+		if ((0U == comparaResult) && (0U == comparaResultCC))
 		{/*比较数据一致*/
 
 		}
-		else if (1u==comparaResult  )
+		else if ((1U == comparaResult) || (1U == comparaResultCC))
 		{/*比较数据不一致*/
 
 			if (CI_ERROR==Flag  )
@@ -1706,19 +1856,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = pNewFloodGateData[deviceId].CurAgreeCloseStateIn;		/*当前同意关门采集状态*/;
 				outString[outStringLength++] = pNewFloodGateData[deviceId].CurAgreeCloseStateOut;	/* 当前同意关门输出状态（动态字段）*/
 
-				outString[outStringLength++] = pNewFloodGateData[deviceId].FloodGateCloseApplyIvocSum;		/*防淹门关门申请列车数量*/
-				for (jj = 0u; jj < pNewFloodGateData[deviceId].FloodGateCloseApplyIvocSum; jj++)
+				outString[outStringLength++] = pNewFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum;		/*防淹门关门申请列车数量*/
+				for (jj = 0u; jj < pNewFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum; jj++)
 				{
-					ShortToChar(pNewFloodGateData[deviceId].FloodGateCloseApplyIvocId[jj], &outString[outStringLength]);/*防淹门关门申请列车ID*/
+					ShortToChar(pNewFloodGateDataCC[deviceId].FloodGateCloseApplyIvocId[jj], &outString[outStringLength]);/*防淹门关门申请列车ID*/
 					outStringLength += 2u;
 				}
 
-				outString[outStringLength++] = pNewFloodGateData[deviceId].FloodGateCloseAnsIvocSum;		/*防淹门关门列车回复列车数量*/
-				for (jj = 0u; jj < pNewFloodGateData[deviceId].FloodGateCloseAnsIvocSum; jj++)
+				outString[outStringLength++] = pNewFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum;		/*防淹门关门列车回复列车数量*/
+				for (jj = 0u; jj < pNewFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum; jj++)
 				{
-					ShortToChar(pNewFloodGateData[deviceId].FloodGateCloseFromIvocStru[jj].wTrainId, &outString[outStringLength]);/*列车同意防淹门关门请求列车ID*/
+					ShortToChar(pNewFloodGateDataCC[deviceId].FloodGateCloseFromIvocStru[jj].wTrainId, &outString[outStringLength]);/*列车同意防淹门关门请求列车ID*/
 					outStringLength += 2u;
-					outString[outStringLength++] = pNewFloodGateData[deviceId].FloodGateCloseFromIvocStru[jj].wFloodGateCloseIvocFlag;	/*列车同意防淹门关门请求状态*/
+					outString[outStringLength++] = pNewFloodGateDataCC[deviceId].FloodGateCloseFromIvocStru[jj].wFloodGateCloseIvocFlag;	/*列车同意防淹门关门请求状态*/
 				}
 			}
 
@@ -1762,12 +1912,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 		deviceId = GetOverlapId(ii);
 		comparaResult = DeviceCompara((UINT8*)(&Record_OverlapDataStru[deviceId]), (UINT16)sizeof(OverlapDataStruct),
 			(UINT8*)(&newOverlapData[deviceId]), (UINT16)sizeof(OverlapDataStruct));
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_OverlapDataStruCC[deviceId]), (UINT16)sizeof(OverlapDataStructCC),
+			(UINT8*)(&pOverlapDataCC[deviceId]), (UINT16)sizeof(OverlapDataStructCC));
 
-		if (0u==comparaResult)
+		if ((0U == comparaResult) && (0U == comparaResultCC))
 		{/*比较数据一致*/
 
 		}
-		else if (1u==comparaResult )
+		else if ((1U == comparaResult) || (1U == comparaResultCC))
 		{/*比较数据不一致*/
 
 			if (CI_ERROR != Flag)
@@ -1782,6 +1934,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
 				LongToChar(newOverlapData[deviceId].XuanPaiStartCycNum,&outString[outStringLength]);/*保护区段选排开始周期号*/
 				outStringLength += 4u;
+				LongToChar(newOverlapData[deviceId].dwAtsLastTimeLockCyc, &outString[outStringLength]);/*最近一次ATS锁闭保护区段周期号*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newOverlapData[deviceId].OverlapFromSetRouteCmdFlag; /*保护区段由进路办理时连带的标志*/
+				outString[outStringLength++] = newOverlapData[deviceId].chPreLaborUnlockState; /*之前人工解锁状态*/
 				outString[outStringLength++] = newOverlapData[deviceId].OverlapUnlockApplyFlag;/*向ZC申请解锁保护区段解锁标志*/
 				outString[outStringLength++] = newOverlapData[deviceId].OverlapCanLaborUnlockFlag;/*保护区段可以人工解锁标志*/
 				outString[outStringLength++] = newOverlapData[deviceId].OverlapLaborUnlockSetState;/*保护区段人工解锁设置状态*/
@@ -1798,10 +1954,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 2U;
 				outString[outStringLength++] = newOverlapData[deviceId].laborLockOverlapCmd;/*人工锁闭保护区段命令标志*/
 
-				ShortToChar(newOverlapData[deviceId].wOverlapUnlockApplyTrainId, &outString[outStringLength]);/*申请解锁保护区段的列车ID*/
+				ShortToChar(pOverlapDataCC[deviceId].wOverlapUnlockApplyTrainId, &outString[outStringLength]);/*申请解锁保护区段的列车ID*/
 				outStringLength += 2U;
 
-				LongToChar(newOverlapData[deviceId].dwReqIvocUnLockStartCycNum, &outString[outStringLength]);/*向车申请解锁保护区段起始周期号*/
+				LongToChar(pOverlapDataCC[deviceId].dwReqIvocUnLockStartCycNum, &outString[outStringLength]);/*向车申请解锁保护区段起始周期号*/
 				outStringLength += 4U;
 
 				outString[outStringLength++] = newOverlapData[deviceId].cProSwitchCheckResultFlag;/*跨控区防护道岔检查结果标志（0xFF：默认值，0x55：失败，0xAA：成功）*/
@@ -1876,11 +2032,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 		comparaResult = DeviceCompara((UINT8*)(&Record_AxisSecDataStru[deviceId]), (UINT16)sizeof(AxisSectionDataStruct),
 			(UINT8*)(&newAxisSecData[deviceId]), (UINT16)sizeof(AxisSectionDataStruct));
 
-		if (0u==comparaResult)
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_AxisSecDataStruCC[deviceId]), (UINT16)sizeof(AxisSectionDataStructCC),
+			(UINT8*)(&pAxisSecDataCC[deviceId]), (UINT16)sizeof(AxisSectionDataStructCC));
+
+		if ((0u==comparaResult) && (0U == comparaResultCC))
 		{/*比较数据一致*/
 
 		}
-		else if (1u==comparaResult )
+		else if ((1U==comparaResult ) || (1U == comparaResultCC))
 		{/*比较数据不一致*/
 
 			if (CI_ERROR != Flag)
@@ -1890,17 +2049,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				ShortToChar(newAxisSecData[deviceId].AxisSectionId,&outString[outStringLength]);/*计轴区段ID*/
 				outStringLength += 2u;
 				outString[outStringLength++] = newAxisSecData[deviceId].AxisArbState;/*计轴ARB状态 (动态字段)*/
+				outString[outStringLength] = pAxisSecDataCC[deviceId].AxisArbState;/*计轴ARB状态CC(0x55-未ARB，0xaa-ARB)*/
+				outStringLength++;
 				outString[outStringLength++] = newAxisSecData[deviceId].AxisJumpLockApplyFlag;/*跳跃锁闭申请标志*/
 				outString[outStringLength++] = newAxisSecData[deviceId].AxisJumpLockCancelApplyFlag;/*跳跃锁闭取消申请标志*/
 				LongToChar(newAxisSecData[deviceId].AxisJumpLockApplyCylce,&outString[outStringLength]);/*跳跃锁闭申请周期号*/
 				outStringLength += 4u;
 				outString[outStringLength++] = newAxisSecData[deviceId].AxisJumpLockState;/*跳跃锁闭状态*/	
-				outString[outStringLength++] = newAxisSecData[deviceId].AxisOccStatus;/*计轴占用状态*/
-				LongToChar(newAxisSecData[deviceId].dwAxisOccCycNum, &outString[outStringLength]);/*计轴占用起始周期*/
+				outString[outStringLength++] = pAxisSecDataCC[deviceId].AxisOccStatus;/*计轴占用状态*/
+				LongToChar(pAxisSecDataCC[deviceId].dwAxisOccCycNum, &outString[outStringLength]);/*计轴占用起始周期*/
 				outStringLength += 4u;
-				LongToChar(newAxisSecData[deviceId].dwUtOccupyCycNum, &outString[outStringLength]);/*计轴最近坏车占用周期*/
+				LongToChar(pAxisSecDataCC[deviceId].dwUtOccupyCycNum, &outString[outStringLength]);/*计轴最近坏车占用周期*/
 				outStringLength += 4u;
-				ShortToChar(newAxisSecData[deviceId].wPosMonitorTrainId, &outString[outStringLength]);  /*监督有效的列车ID*/
+				ShortToChar(pAxisSecDataCC[deviceId].wPosMonitorTrainId, &outString[outStringLength]);  /*监督有效的列车ID*/
 				outStringLength += 2u;
 			}
 		}
@@ -2287,6 +2448,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength] = pNewTrainInfoData[deviceId].chTrainReportState;		/*列车汇报状态*/
 				outStringLength++;
 				outString[outStringLength++] = pNewTrainInfoData[deviceId].chEaCmdState;	/*区间疏散命令状态：0x55 有效；0xAA 无效*/
+
+				outString[outStringLength++] = pNewTrainInfoData[deviceId].chtrainControlMode;/*当前控车模式*/
+				outString[outStringLength++] = pNewTrainInfoData[deviceId].chTrainPostionMode; /*列车位置模式，0无位置，1使用IVOC位置，2使用VOBC位置*/
+				ShortToChar(pNewTrainInfoData[deviceId].wMinSafeHeadLink, &outString[outStringLength]);/*延时小前所处link*/
+				outStringLength += 2u;
+				LongToChar(pNewTrainInfoData[deviceId].dwMinSafeHeadOffset, &outString[outStringLength]);/*延时小前所处link偏移量*/
+				outStringLength += 4u;
+				outString[outStringLength++] = pNewTrainInfoData[deviceId].chMinSafeHeadDir;/* 延时小前方向 */
 			}
 
 
@@ -2705,17 +2874,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 			break;
 		}
 		pNonAutoReturnData = GetNonReturnData();
-
+		pNonReturnDataStruCC = GetNonReturnDataCC();
 		/*比较数据*/
 		deviceId = GetNonReturnId(ii);
 		comparaResult = DeviceCompara((UINT8*)(&Record_NonReturnDataStru[deviceId]), (UINT16)sizeof(NonAutoReturnDataStruct),
 			(UINT8*)(&pNonAutoReturnData[deviceId]), (UINT16)sizeof(NonAutoReturnDataStruct));
 
-		if (0u == comparaResult)
+		comparaResultCC = DeviceCompara((UINT8*)(&Record_NonReturnDataStruCC[deviceId]), (UINT16)sizeof(NonAutoReturnDataStructCC),
+			(UINT8*)(&pNonReturnDataStruCC[deviceId]), (UINT16)sizeof(NonAutoReturnDataStructCC));
+		if ((0U == comparaResult) && (0U == comparaResultCC))
 		{/*比较数据一致*/
 
 		}
-		else if (1u == comparaResult)
+		else if ((1U == comparaResult) || (1U == comparaResultCC))
 		{/*比较数据不一致*/
 
 			if (CI_ERROR == Flag)
@@ -2726,10 +2897,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 			{
 				/**************打印数据信息****************/
 				outString[outStringLength++] = pNonAutoReturnData[deviceId].IndicatorDevID;      /*指示灯设备ID*/
-				ShortToChar(pNonAutoReturnData[deviceId].cmdSetTrainId, &outString[outStringLength]);/*命令列车ID*/
+				ShortToChar(pNonReturnDataStruCC[deviceId].cmdSetTrainId, &outString[outStringLength]);/*命令列车ID*/
 				outStringLength += 2u;
-				outString[outStringLength++] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicFlashState; /*车载给联锁的无人折返指示灯闪灯状态*/
-				outString[outStringLength++] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicSteadyState; /*车载给联锁的无人折返指示灯稳灯状态*/
+				outString[outStringLength] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicFlashState; /*车载给联锁的无人折返指示灯闪灯状态*/
+				outStringLength++;
+				outString[outStringLength] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicSteadyState; /*车载给联锁的无人折返指示灯稳灯状态*/
+				outStringLength++;
 				ShortToChar(pNonAutoReturnData[deviceId].RtnRelayAdhesionState.AdhesionRealyId, &outString[outStringLength]);/*粘连继电器ID*/
 				outStringLength += 2u;
 				outString[outStringLength++] = pNonAutoReturnData[deviceId].RtnRelayAdhesionState.AdhesionState;      /*继电器粘连状态*/
@@ -2751,10 +2924,46 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	else
 	{
 #ifdef PLATFORM_2OO2
-		debug_infor_printf((const)"\nNonAutoReturnData:%d", (UINT16)sizeof(NonAutoReturnDataStruct), outStringLength);
+		debug_infor_printf((const)"\nNonAutoReturnData:%d, length:%d", (UINT16)sizeof(NonAutoReturnDataStruct), outStringLength);
 
 		debug_out_array(0xAA, outString, outStringLength);
 
+#endif
+
+		/*清空打印数据*/
+		CleanString(outString);
+		outStringLength = 0u;
+	}
+
+	/*************************************打印CBTC跨压数据********************************************/
+	/*打印CBTC跨压数据*/
+	deviceNum = GetCbtcCrossNumZc();/* 获取边界点数量 */
+
+	for (ii = 0U; ii < deviceNum; ii++)
+	{
+		if ((CI_SUCCESS != returnValue) || (NULL == pCbtcCrossStructZCStru))
+		{
+			returnValue = CI_ERROR;
+			break;
+		}
+
+		ShortToChar(pCbtcCrossStructZCStru[ii].wSignalId, &outString[outStringLength]);/*CBTC跨压信号机ID*/
+		outStringLength += 2u;
+		outString[outStringLength] = pCbtcCrossStructZCStru[ii].wTrainId; /*CBTC跨压列车ID*/
+		outStringLength++;
+	}
+
+	if (0u == outStringLength)
+	{
+		/*nothing*/
+		debug_infor_printf((const)"\nCbtcCrossData:0u");
+	}
+	else
+	{
+#ifdef PLATFORM_2OO2
+		debug_infor_printf((const)"\nCbtcCrossData:%d:", outStringLength);
+
+		debug_out_array(0xAA, outString, outStringLength);
 #endif
 
 		/*清空打印数据*/
@@ -2921,7 +3130,7 @@ UINT8 DeviceCompara(UINT8* deviceStruAddr1, const UINT16 deviceStruLen1,
 void GetVirCIKeyDataStru(void)
 {
 	UINT8 ii = 0u;
-	UINT8 jj = 0U;
+
 
 	for(ii=0u;ii<g_VirtualCIStructData.virtualCiNum;ii++)
 	{
@@ -2940,12 +3149,6 @@ void GetVirCIKeyDataStru(void)
 		newVirCIKeyDataStru[ii].ZfwValidCycNum = g_VirtualCIStructData.virtualCi[ii].ZfwValidCycNum; 
 
 		
-		for (jj = 0U; jj < RTNINDICATOR_SUM_MAX; jj++)
-		{
-			newVirCIKeyDataStru[ii].RtnIndicatorKeyData[jj].PrintVirCiIndicatorDevId = g_VirtualCIStructData.virtualCi[ii].VirCIRtnIndicatorStaData[jj].VirCiIndicatorDevId;
-			newVirCIKeyDataStru[ii].RtnIndicatorKeyData[jj].PrintVirCiFlashState = g_VirtualCIStructData.virtualCi[ii].VirCIRtnIndicatorStaData[jj].VirCiFlashState;
-			newVirCIKeyDataStru[ii].RtnIndicatorKeyData[jj].PrintVirCiSteadyState = g_VirtualCIStructData.virtualCi[ii].VirCIRtnIndicatorStaData[jj].VirCiSteadyState;
-		}
 		newVirCIKeyDataStru[ii].ZfwjHunXianFLag = g_VirtualCIStructData.virtualCi[ii].ZfwjHunXianFLag; 
 	}
 }

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,21 +589,31 @@ 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);
+			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))
 				{ /*双动道岔*/
-				SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE,routeId,GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁闭状态*/
+					SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, routeId, GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁闭状态*/
 				}
 				else
 				{
 				}
 #endif
 			}
+			else
+			{
+				/*防护道岔不在防护位置或防护道岔存在反向驱动，不设置防护锁闭*/
+			}
+		}
 	} 
 	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*/
@@ -1026,8 +1038,6 @@ 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))/*区故解可以由相邻虚拟联锁现地操作，不相邻不能操作*/
@@ -1037,12 +1047,6 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 				}	
 			}
 			else
-				{
-					/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令	*/	
-					AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK,phySectionId,0u,routeBelongCi);
-				}
-			}
-			else
 			{
                	/*异常情况，不处理区故解命令*/
 			}
@@ -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,7 +1495,7 @@ 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*/
 						retVal = CI_SUCCESS;
@@ -1513,30 +1522,16 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 					/*判断当前保护区段所属联锁控制模式是否可以响应锁闭保护区段命令*/
 					if (CI_SUCCESS == retVal)
 					{
-						virCIid= GetOverlapBelongVirCiId(expLkOverlapId);
-						if(FUNC_SWITCH_ON == includeVirFlag)
-						{
-							ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
-						}	
-						else
-						{
-							ciCtrModeFlag = GetCiModeFlag();	/*获取联锁控制模式*/
-						}
+						virCIid = GetOverlapBelongVirCiId(expLkOverlapId);
 
-						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)
-					{
-
-						routedLockOverlapId = GetRouteOverlapLockedId(routeId);	/*获取进路锁闭过保护区段ID*/
-
-						if (0u == routedLockOverlapId)
 					{
 						/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
 						routeState = GetRouteState(routeId);
@@ -1554,38 +1549,35 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 							(routeState == ROUTE_STATE_HALF_UNLOCK)
 							)
 						{/*设置指定ID进路的期望锁闭保护区段ID*/
-							    if(LABOR_LOCK_OVERLAP == lockType)/*人工锁闭*/
+							if (LABOR_LOCK_OVERLAP == lockType)/*人工锁闭*/
 							{
-									SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId,LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
-									SetOverlaplaborLockCmdFlag(expLkOverlapId,LOCK_OVERLAP_CMD_YES);/*设置人工锁闭标志，用于人工命令一次有效处理*/
+								SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
+								SetOverlaplaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置人工锁闭标志，用于人工命令一次有效处理*/
+								ClearPreLoaborUnlockState(expLkOverlapId);
 							}
-								else if(ATS_LOCK_OVERLAP == lockType)/*ATS锁闭*/
+							else if (ATS_LOCK_OVERLAP == lockType)/*ATS锁闭*/
 							{
 								phySectionId = GetRouteLastPhySectionId(routeId);
 								phySectionSta = GetPhySecCurMergeState(phySectionId);
-									if(SECTION_OCCUPY_YES==phySectionSta)
+								if (SECTION_OCCUPY_YES == phySectionSta)
 								{
-										SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId,LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志*/
+									SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志*/
 								}
 							}
 							else
 							{
 								/*什么也不做*/
 							}
-								SetRouteAtsExpLkOverlapId(routeId,expLkOverlapId);
+							SetRouteAtsExpLkOverlapId(routeId, expLkOverlapId);
 							SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_NO);/*清除标志*/
+							SetOverlapAtsLastTimeLockCyc(expLkOverlapId, dwCurCycNum);
 							retVal = CI_SUCCESS;
 						}
 						else
 						{
 							retVal = CI_ERROR;
 						}
-							
-
 					}
-						
-					}
-
 				}
 			}
 		}
@@ -1609,7 +1601,6 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 	UINT16 lockBelongRouteId = 0u;  /*区段锁闭所属进路ID*/
 	UINT8 reVal = CI_ERROR;
 	UINT8 belongvirCIid = 0u;
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 isErrLock = CI_ERROR;   
 	UINT8 phyLockState = 0U;
 
@@ -1635,8 +1626,7 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 	}
 	if(CI_SUCCESS == reVal)
 	{
-		if(FUNC_SWITCH_ON == includeVirFlag)
-		{
+	
 		belongvirCIid = GetRouteBelongVirCiId(lockBelongRouteId);
 		if(0u < virCIid)
 		{
@@ -1662,11 +1652,7 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 			reVal = CI_ERROR;
 		}
 
-		}
-		else  
-		{
-			reVal = CI_SUCCESS;
-		}
+		
 	}	
 
 	/*按顺序解锁进路异常锁闭*/
@@ -1927,6 +1913,18 @@ 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
+	{
+		/*不处理*/
+	}
 }
 
 /*
@@ -3400,14 +3398,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))
@@ -3441,21 +3437,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);
 			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
 		{
@@ -3476,7 +3466,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))
 	{
@@ -3499,8 +3488,7 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
 	}
 	if (CI_SUCCESS == reVal)
 	{
-		if (FUNC_SWITCH_ON == chIncludeVirFlag)
-		{
+		
 		chBelongvirCIid = GetRouteBelongVirCiId(wLockBelongRouteId);
 		if (0U < chVirCIid)
 		{
@@ -3527,11 +3515,6 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
 		}
 		
 	}
-		else
-		{
-			reVal = CI_SUCCESS;
-		}
-	}
 
 	return reVal;
 }
@@ -4488,7 +4471,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))
 	{
 		/*不做处理*/
@@ -4496,15 +4478,11 @@ void DriveLogRouteSignalClose(const UINT16 wLogSignalId)
 	else
 	{
 		/*虚拟联锁兼容*/
-		if (FUNC_SWITCH_ON == includeVirFlag)
-		{
+		
 		belongVirCIid = GetSignalBelongVirCiId(wLogSignalId);
 		allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCIid); /*全站亮灯标志*/
-		}
-		else
-		{
-			allSignalBrightFlag = GetAllSignalBrightFlag();  /*全站亮灯标志*/
-		}
+		
+		
 
 		/*无论什么时候，复示信号机关闭都驱动红灭*/
 		signalIsfushiFlag = GetSignalIsfushiFlag(wLogSignalId);
@@ -5103,7 +5081,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;
@@ -5112,11 +5089,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);
 
@@ -5179,14 +5156,8 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 			if (CI_SUCCESS == retVal)
 			{
 				virCIid = GetOverlapBelongVirCiId(expLkOverlapId);
-				if (FUNC_SWITCH_ON == includeVirFlag)
-				{
 				ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
-				}
-				else
-				{
-					ciCtrModeFlag = GetCiModeFlag();	/*获取联锁控制模式*/
-				}
+
 
 				if ((CI_MODE_CI_LOCAL == ciCtrModeFlag) || (0U == ciCtrModeFlag))/*处于联锁控或者获取错误，发送现地不能响应人工锁闭命令*/
 				{
@@ -5195,10 +5166,6 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 			}
 
 			if (CI_SUCCESS == retVal)
-			{
-				routedLockOverlapId = GetRouteOverlapLockedId(routeId);	/*获取进路锁闭过保护区段ID*/
-
-				if (0U == routedLockOverlapId)
 			{
 				/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
 				routeState = GetRouteState(routeId);
@@ -5214,7 +5181,8 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 					|| (ROUTE_STATE_NEAR_LOCKERR == routeState)
 					|| ((ROUTE_STATE_AUTO_UNLOCK == routeState) && (ROUTE_STATE_FLAG_YES == routeStateFlag))
 					)
-					{/*设置指定ID进路的期望锁闭保护区段ID*/
+				{
+					/*设置指定ID进路的期望锁闭保护区段ID*/
 					/*仅处理ATS办理保护区段，不处理人工办理保护区段*/
 					phySectionId = GetRouteLastPhySectionId(routeId);
 					phySectionSta = GetPhySecCurMergeState(phySectionId);
@@ -5231,6 +5199,7 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 
 					SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_YES);/*设置保护区段由进路连带标识*/
 
+					SetOverlapAtsLastTimeLockCyc(expLkOverlapId, dwCurCycNum);
 					retVal = CI_SUCCESS;
 				}
 				else
@@ -5244,8 +5213,6 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
 			}
 		}
 
-		}
-
 		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,6 +1147,34 @@ void OverlapZhaoChaRelayUpDateManage(void);
 * Create: fan 20250725
 */
 void TrainJumpBackApplyProc(void);
+/*
+* 功能描述： 办理联挂进路逻辑管理
+* 参数说明： const UINT16 wRouteId
+* 返回值  ： 无
+* Create: 20250917
+*/
+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);
 
 #ifdef __cplusplus
 }

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

@@ -189,7 +189,7 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
 	UINT8 routeReverseProperty = 0u;
 	UINT8 airShaftRouteType = 0u;
-
+	UINT8 chRouteCouplinkFlag = 0U;
 	/* 联锁逻辑检查 */
 	/* 进路监督模式为【CBTC】*/
 	
@@ -325,12 +325,22 @@ 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))
+		{ 
+			if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+			{
+				/* 反向联挂进路允许追踪，区段条件在OpenCbtcRouteSectionErrCheck */
+				/*存在联挂标志，不在查反向进路全部空闲，其他条件检查;风井进路设置不上联挂标志所以需要检查全部区段空闲*/
+			}
+			else
+			{
+				/*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
+			
 				/*风井进路不允许追踪办理，故开放条件需增加对进路内方所有区段的占用状态检查*/
 				devId = 0u;
 				devState = 0u;
-			checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
+				checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
 				if (checkResult == CI_SUCCESS)
 				{
 					/* 通过检查 */
@@ -339,10 +349,12 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 				else
 				{
 					/* 记录故障码 */
-				SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel); 
+					SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
 					/* 失败返回 */
 					reResult = CI_ERROR;
 				}
+			}
+			
 			/* 防护进路联锁条件检查 */
 			if (CI_SUCCESS == reResult)
 			{
@@ -763,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;
 
@@ -900,8 +912,16 @@ UINT8 OpenCbtcReturnRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	{
 		devId = 0u;
 		devState = 0u;
+		chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+		if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+		{
+			checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+		}
+		else
+		{
 			checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
-		if (checkResult == CI_SUCCESS)
+		}
+		if (CI_SUCCESS == checkResult)
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
@@ -1346,6 +1366,7 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
 	UINT16 trainEnteringRouteState = 0u;
 	UINT8 signalCrossState = 0u;
 	UINT8 rcWorkMode = 0U; /*rc工作模式*/
+	UINT8 chRouteCouplinkFlag = 0U;
 	rcWorkMode = GetLocalRcWorkMode();
 	/* 联锁逻辑检查 */
 
@@ -1471,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)
 			{
 				/* 通过检查 */
@@ -1856,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)
@@ -1990,8 +2021,17 @@ UINT8 KeepCbtcReturnRouteErrProcess(const UINT16 routeId)
 			}
 		}
 		else if(RC_WORK_MODE_CI == rcWorkMode)
+		{
+			chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+			if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+			{
+				checkResult = KeepCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+			}
+			else
 			{
 				checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
+			}
+			
 			if (CI_SUCCESS == checkResult)
 			{
 				/* 通过检查 */
@@ -3067,6 +3107,7 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 	UINT8 toOpenCheckFlag = 0u;/*恢复可重开信号的条件标志*/
 	UINT8 otherResult = 0u;/*其他联锁检查条件返回值*/
 	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
+	UINT8 cPsdExceptOpenState = 0U;  /*PSD异常打开状态*/
 
 	if (routeLevel == ROUTE_LEVEL_BLOC)
 	{
@@ -3120,12 +3161,20 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 					{
 						if (psdIdBuf[j] == tmpOtherCiDevInfo->DevId)
 						{
-							toOpenCheckFlag = 1u;
+							cPsdExceptOpenState = GePsdExceptState(tmpOtherCiDevInfo->DevId);
+							if (PSD_EXCEPT_NO == cPsdExceptOpenState)
+							{
+								toOpenCheckFlag = 1U;  /*PSD未异常，设置可自动重开*/
+							}
+							else
+							{
+								toOpenCheckFlag = 0U;  /*存在PSD异常，停止遍历，设置不可自动重开*/
 								break;
 							}
 						}
 					}
 				}
+			}
 			else
 			{
 				toOpenCheckFlag = 0u;
@@ -3584,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;
     
@@ -3627,7 +3679,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 			}
 		}
 
-		if(CI_TRADITION_RAILWAY == lineIdentity)
+		if (CI_TRADITION_RAILWAY == lineIdentity)
 		{
 			/*保护区段道岔【位置正确】*/
 			if (CI_SUCCESS == reResult)
@@ -3646,12 +3698,11 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 					reResult = CI_ERROR;
 				}
 			}
-
-
 		}
 		else
 		{
 			/* zt 删除单轨相关代码 2022-02-15 */
+			reResult = CI_ERROR;
 		}
 
 		/*保护区段 内所有道岔【未封锁】*/
@@ -3691,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)
 			{
 				/* 通过检查 */
@@ -3713,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)
 			{
 				/* 通过检查 */
@@ -3726,7 +3777,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 			}
 		}
 
-
 		if (CI_SUCCESS == reResult)
 		{
 			/*检查进路侵限条件状态*/
@@ -3742,15 +3792,23 @@ 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);
+				checkResult = OlapSideProtectConditionCheck(overlapId, 0U, 0U);
 				if (CI_ERROR == checkResult)
 				{
 					reResult = checkResult;
 				}
 			}
+			else
+			{
+				/*不处理*/
+			}
+		}
 
 		/*检查保护区段有效性*/
 		if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
@@ -3768,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;
@@ -3789,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;
@@ -4114,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既有逻辑处理*/
@@ -4265,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既有逻辑处理*/
@@ -4292,18 +4356,32 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 		}
 		else if (RC_WORK_MODE_CI == rcWorkMode)
 		{/*CI*/
-
-			/* 进路始端信号机【未跨压】且内方第一逻辑区段【空闲】*/
 			startSignalId = GetRouteStartSignalId(routeId);
+			chSigCrossState = GetSignalCrossState(startSignalId);
+			if (SIGNAL_CROSS_STATE_NO == chSigCrossState)
+			{
+				chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
+				if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
+				{
+					/*联挂进路区段占用检查*/
+					reResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
+				}
+				else
+				{
 					devId = GetRouteInFirstLogSecId(routeId);
 					devState = GetLogSecCurOccupyState(devId);
-			if ((GetSignalCrossState(startSignalId) == SIGNAL_CROSS_STATE_NO) &&
-				(devState == SECTION_OCCUPY_NO))
+					if (SECTION_OCCUPY_NO == devState)
 					{
 						/* 通过检查 */
 						reResult = CI_SUCCESS;
 					}
 					else
+					{
+						reResult = CI_ERROR;
+					}
+				}
+			}
+			else
 			{
 				reResult = CheckEngineerVehicleNear(routeId);/*检查是否是工程车接近的跨压*/
 			}

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

@@ -229,6 +229,7 @@ void NonRouteLogicProcess(void)
 		{ 
 			NonRouteCancelDeal(pNonRoute->NonRouteId); /*非进路取消处理*/
 		}
+
 	}
 }
 
@@ -240,21 +241,41 @@ 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); /*设置非进路为空闲*/
 			}
 
 		}
@@ -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,10 +6070,14 @@ void DTrainReturnUnlockP(void)
 		{
 			continue;
 		}
-
+		belongVirCIid = GetRouteBelongVirCiId(routeId);
+		chLocalVirCiType = GetLocalVirCiType(belongVirCIid);
+		if (CI_TYPE_CLD == chLocalVirCiType)
+		{
 			/*调车中途折返进路完整锁闭处理*/
 			DTrainReturnUnlockRouteAllLockP(routeId);
 		}
+	}
 
 	/*处理调车中途折返*/
     for (ii = 0u; ii < routeCurSum; ii++)
@@ -6068,10 +6095,14 @@ void DTrainReturnUnlockP(void)
 		{
 			continue;
 		}
-
+		belongVirCIid = GetRouteBelongVirCiId(routeId);
+		chLocalVirCiType = GetLocalVirCiType(belongVirCIid);
+		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])) &&
-							(SIGNAL_VIRTUAL_YES == GetSignalVirtualAttr(returnSigId)))
+						if ((ROUTE_STATE_IDLE == chRouteState) &&(CI_SUCCESS == chRoutePhysicalType))
 						{    
 							/*以并置信号机为始端的进路均为空闲且进路包含的区段均为列检库区段，且并置信号机为虚拟信号机,
-							该种算法目前只限制在库线中中途折返场景*/
+							该种算法目前只限制在库线中中途折返场景(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,75 +6538,94 @@ UINT16 GetRouteBingZhiSignalId(const UINT16 routeId)
 */
 UINT16 GetRouteChaZhiSignalId(const UINT16 routeId)
 {
-	UINT16 startSigId = 0u; /*始端信号机ID*/
-	UINT16 signalSum = 0u; /*信号机总数*/
-	UINT16 signalId = 0u; /*信号机ID*/
-	UINT16 routeSecSum = 0u; /*进路区段总数*/
-	RoutePhysicalSectionStruct *pRoutePhySecStru = NULL; /*进路区段数据*/
-	UINT16 returnOutSecId = 0u; /*折返信号机外方区段ID*/
-	UINT16 returnInSecId = 0u; /*折返信号机内方区段ID*/
-    UINT16 lockBelongRouteId = 0u; /*锁闭所属进路ID*/
-    UINT16 outSecId = 0u; /*外方区段ID*/
-	UINT16 ii = 0u;
-	UINT16 tmpSigId = 0u;
-
+	UINT16 startSigId = 0U; /*始端信号机ID*/
+	UINT16 signalSum = 0U; /*信号机总数*/
+	UINT16 signalId = 0U; /*信号机ID*/
+	UINT16 routeSecSum = 0U; /*进路区段总数*/
+	RoutePhysicalSectionStruct* pRoutePhySecStru = NULL; /*进路区段数据*/
+	UINT16 returnOutSecId = 0U; /*折返信号机外方区段ID*/
+	UINT16 returnInSecId = 0U; /*折返信号机内方区段ID*/
+    UINT16 lockBelongRouteId = 0U; /*锁闭所属进路ID*/
+    UINT16 outSecId = 0U; /*外方区段ID*/
+	UINT16 ii = 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)) &&
-				(startSigId != signalId))
+			if ((outSecId == wTempPhySecId) && (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)) &&
-				(lockBelongRouteId == GetPhySecRLockBelongRouteId(pRoutePhySecStru[0].PhysicalSectionId)))*/
+			if (1U == routeSecSum)
 			{
-				returnOutSecId = pRoutePhySecStru[0].PhysicalSectionId;/*折返信号机外方区段ID*/
+				returnOutSecId = pRoutePhySecStru[0U].PhysicalSectionId;/*折返信号机外方区段ID*/
 
 				tmpSigId = GetRouteStartSignalId(lockBelongRouteId);/*折返信号机内方区段ID*/
 
 				returnInSecId = GetSignalOutFirstPhySecId(tmpSigId);
 			}
-		}
-		else if (routeSecSum > 1u)
+			else if (1U < routeSecSum)
 			{
-			for (ii = 0u; ii < routeSecSum; ii++)
+				for (ii = 0U; ii < routeSecSum; ii++)
 				{
 
-				if ((PHYSICAL_SECTION_LOCK_NORMAL == GetPhySecLockState(pRoutePhySecStru[ii].PhysicalSectionId)) &&
-					(lockBelongRouteId == GetPhySecRLockBelongRouteId(pRoutePhySecStru[ii].PhysicalSectionId)))
+					chPhyLockState = GetPhySecLockState(pRoutePhySecStru[ii].PhysicalSectionId);
+					wLockRouteId = GetPhySecRLockBelongRouteId(pRoutePhySecStru[ii].PhysicalSectionId);
+					if ((PHYSICAL_SECTION_LOCK_NORMAL == chPhyLockState) &&
+						(lockBelongRouteId == wLockRouteId))
 					{ /*本进路第一个锁闭的区段*/
 
 						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;
@@ -6577,24 +6636,36 @@ UINT16 GetRouteChaZhiSignalId(const UINT16 routeId)
 			{
 				/*无操作*/
 			}
-		if ((0u == returnOutSecId) || (0u == returnInSecId))
-		{
-			return 0u;
 		}
 		
+		if ((0U == returnOutSecId) || (0U == returnInSecId))
+		{
+			/*无操作*/
+		}
+		else
+		{
 			for (ii = 0u; ii < signalSum; ii++)
 			{
 				signalId = GetSignalId(ii); /*获取信号机ID*/
-
-			if ((returnOutSecId == GetSignalOutFirstPhySecId(signalId)) &&
-				(returnInSecId == GetSignalInFirstPhySecId(signalId, routeId)))
+				wTempSigOutPhyId = GetSignalOutFirstPhySecId(signalId);
+				wTempSigInPhyId = GetSignalInFirstPhySecId(signalId, routeId);
+				if ((returnOutSecId == wTempSigOutPhyId) &&
+					(returnInSecId == wTempSigInPhyId))
 				{
-				return signalId;
+					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;
-	washMachineId = GetWashMachineId(0u);
-#if 0
-	SetCancelWashMachineFlag(washMachineId,CANCEL_WASH_FLAG_SET_YES);
-#endif
-	if (washMachineId >0u)
-	{/*收到现地取消洗车命令，直接把洗车同意按钮状逻辑态置为抬起*/
-		(void)SetWashmachineXTALogicState(washMachineId,XTA_STATE_RAISE_UP);
+{
+	UINT16 washMachineId = 0U; /*洗车机ID*/
+	UINT16 wDownWashRelateRouteFirstId = 0U; /*降级模式洗车线控制台表示灯1关联进路ID*/
+	UINT8 chRouteState = 0U;/*进路状态*/
+	UINT8 downWashAllowState = 0U;/*降级模式洗车同意状态(融合)*/
+	UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
+	washMachineId = GetWashMachineId(0U);
+
+	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);
+
 /*
 * 功能描述： 锁闭点式进路区段联锁条件检查
 * 参数说明：
@@ -1165,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_点式进路开放信号保护区段联锁条件检查 */
 /*
 * 功能描述： 点式进路开放信号保护区段联锁条件检查
@@ -1862,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);
+
 
 /*
 * 功能描述： 进路区段全部联络线设备条件满足检查
@@ -2204,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);
+
 
 /*
 * 功能描述： 部分进路区段全部联络线设备条件满足检查
@@ -2499,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区域属性
@@ -2613,7 +2623,7 @@ UINT8 CtTrainHeadSuspCheck(const UINT16 wTrainId, const UINT8 cLogSecSeqDir, con
 * 输出参数：无
 * 返回值  ：CI_ERROR 0 失败
 *           CI_SUCCESS 1 成功
-* Edit By cgh 2025.10.17
+* Created By LQ 2024.09.05
 */
 UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSecIdBuff, const UINT16 wTrainId, const UINT8 cFunctionId, const UINT8 cSendLevel);
 
@@ -2706,13 +2716,13 @@ UINT8 OtherCiOvlpRelProSwMovValCheck(const UINT16 wOverlapId);
 UINT8 OverlapProSwUsingCheck(const UINT16 wOverlapId, UINT16* pDevId, UINT8* pDevState, UINT8* pAlarmType);
 
 /*
-* 功能描述： 获取指定进路办理相邻控区道岔检查标志
-* 参数说明： const UINT16 routeId 进路ID
-* 返 回 值： 进路办理相邻控区道岔检查标志
-* 输出参数：UINT16* switchID道岔ID、UINT8* chSwitchState道岔状态
-* by cgh 20241202
+* 功能描述： 进路关联所有道岔位置正确检查
+* 参数说明： UINT16 const routeId,    进路号）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* BY CGH 20250224
 */
-UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId, UINT16* switchID, UINT8* chSwitchState);
+UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId);
 
 /*
 *函数功能：保护区段照查继电器检查
@@ -2761,28 +2771,276 @@ UINT8 RouteCldAttrCheck(UINT16 wRouteId);
 * Created By LQ 2025.08.18
 */
 UINT8 OverlapOccuUnlockCheck(UINT16 overlapId, UINT8 functionId);
+/*
+* 功能描述：办理联挂进路区段检查
+* 参数说明：const UINT16 wRouteId 进路ID
+*           UINT16* pDevId 设备ID
+*			UINT8* pDevState 设备状态
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By  2025.09.18
+*/
+UINT8 SetCouplinkRouteSecOccCheck(const UINT16 wRouteId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述：保持联挂进路区段占用检查
+* 参数说明：const UINT16 wRouteId 进路ID
+*           UINT16* pDevId 设备ID
+*			UINT8* pDevState 设备状态
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By  2025.09.18
+*/
+UINT8 KeepCouplinkRouteSecOccCheck(const UINT16 wRouteId, UINT16* pDevId, UINT8* pDevState);
 
 /*
-* 功能描述：列车占用完全在指定区段检查
-* 输入参数：const UINT16 wPhySecId 物理区段ID
-*           const UINT16 wTrainId  列车ID
-* 输出参数：无
-* 返回值  ：CI_ERROR 0 不完全在
-*           CI_SUCCESS 1 完全在
-* by cgh 20251017
+* 功能描述：单个侧防条件检查
+* 参数说明：SideProtecStru SidePretectData 一项侧防条件
+*			UINT16 wDevId 设备ID
+*           UINT8 cDevType 设备类型
+*           UINT8 functionId 函数ID
+*			UINT8 sendLevel 发送等级
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
 */
-UINT8 TrainOccSameSecCheck(const UINT16 wPhySecId, const UINT16 wTrainId);
+UINT8 SingleSideProtectCheck(SideProtecStru SidePretectData, UINT16 wDevId, UINT8 cDevType, UINT8 functionId, UINT8 sendLevel);
 
 /*
-* 功能描述：占用是否属于同一区段检查
-* 输入参数：const UINT16 wBasePhySecId 基准物理区段ID
-*           const UINT16 wCheckPhySecId 待检查物理区段ID
-* 输出参数：无
-* 返回值  ：CI_ERROR 0 不属于
-*           CI_SUCCESS 1 属于
-* by cgh 20251017
+* 功能描述：侧防道岔位置检查
+* 参数说明：SideProtecSwitchData* pSideProtecSwitchBuf 道岔侧防条件
+*           UINT8 chSideProtecSwitchNum 侧防道岔数量
+* 返 回 值：CI_ERROR 0 侧防道岔位置连通
+*           CI_SUCCESS 1 侧防道岔位置不连通
 */
-UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId);
+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

@@ -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 UINT32 dwOverlapUnlockStartCyc 保护区段自动解锁起始周期
+*            const UINT16 wRouteId 进路ID
 * 返回值  ： 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
@@ -824,6 +825,23 @@ UINT8 RouteLgcSecResReturnSecCheck(UINT16 wValidReturnSigId, const UINT16 wRoute
 */
 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);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -823,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)
 		{
 			/* 通过检查 */
@@ -831,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;
 		}
@@ -1034,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)
 		{
 			/* 通过检查 */
@@ -1042,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;
 		}
@@ -1298,46 +1296,39 @@ UINT8 LogRouteProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* p
 /*
 * 功能描述： 逻辑进路侧防条件满足检查
 * 参数说明： UINT16 routeId,    逻辑进路号
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
+*            UINT8 functionId,  函数ID
+*             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;           /* 循环变量 */
-	UINT16 devId = 0u;
+	UINT8 i = 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
 	{
-		/*开始检查*/
-		for (i = 0u; i < checkSum; i++)
-		{
-			devId = dataIdBuf[i];
-			reVal = LogicSecSwitchLtrlDfncCheck(devId, pDevId, pDevState);
-			if (CI_SUCCESS == reVal)
-			{
-				/* 通过检查*/
-			}
-			else
-			{
-				/*状态不一致返回故障状态*/
-				reVal = CI_ERROR;
-				break;
-			}
-		}
+		reVal = CI_SUCCESS;
+		/*功能预留*/
 	}
+
+
 	/*全部通过检查*/
 	return reVal;
 }
@@ -2800,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)
 		{
 			/* 通过检查 */
@@ -2808,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

@@ -138,12 +138,12 @@ UINT8 LogRouteProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* p
 /*
 * 功能描述： 逻辑进路侧防条件满足检查
 * 参数说明： UINT16 routeId,    逻辑进路号
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
+*            UINT8 functionId,  函数ID
+*             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,10 +28,32 @@ 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);
+	if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
+	{
+		/* 进路状态条件：进路状态空闲、进路初选、自动解锁正常、自动解锁异常（ARB）、初锁异常、预先锁闭、接近锁闭正常、接近锁闭异常都可以办理联挂进路 */
+		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且故障锁闭）*/
 		if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
 		{
@@ -45,6 +67,8 @@ UINT8 SetLTrainRouteP(const UINT16 routeId)
 			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
+	}
+	
 
 	/*信号联锁条件检查*/
 	/*if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLTrainRouteSignalCheck(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,16 +2227,35 @@ 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)
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
 		}
 		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,16 +3236,35 @@ 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)
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
 		}
 		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();
@@ -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 */
@@ -117,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使用)*/
@@ -138,9 +141,10 @@
 #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_EMERG_XIANSU         ((UINT8)0x9D)   /*定义逻辑区段紧急临时限速码位*/
+#define MASK_TYPE_LOGSEC_PB_TACS_ARB		        ((UINT8)0xB3)   /*定义逻辑区段PB_TACS_ARB状态码位*/
 
 
 /*保护区段相关码位*/
@@ -167,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)*/
 
 
 /*站台相关码位*/
@@ -181,7 +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_ONEPLAT_ESP_STATE                 ((UINT8)0xAB)    /*定义紧急关闭按钮同站紧急按钮激活状态码位*/
+#define MASK_TYPE_ONEPLAT_CUT_ESP_STATE             ((UINT8)0xAC)    /*定义紧急关闭按钮同站旁路按钮激活状态码位*/
 
 /*站台安全门相关码位*/
 #define MASK_TYPE_PSD_STATE                         ((UINT8)0x60)   /*定义站台安全门状态码位-ZC,LEU用*/
@@ -199,8 +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_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）*/
@@ -232,6 +243,10 @@
 /*洗车机相关码位*/
 #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为无粘连*/
 
 /*防淹门相关码位*/
 

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

@@ -16,6 +16,7 @@
 
 
 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);
 
 /*
 * 功能描述： 获取无人折返数据结构体指针

TSCP/src/APP/ciapp/NonRoute/NonRouteConfigDataManage.c

@@ -365,6 +365,24 @@ UINT16 GetSCXColAgreeTryRelayIdById(UINT8 nonRouteId)
 	return collAgreeTryTrainRelayId;
 }
 
+/*
+* 功能描述： 获取试车线采集的轨旁试车指示器继电器ID
+* 参数说明： UINT8 nonRouteId 非进路id
+* 返回值  ： 试车线采集的轨旁试车指示器继电器ID
+*/
+UINT16 GetWaysideTryTrainIndRelayId(UINT8 nonRouteId)
+{
+	UINT16 collAgreeTryTrainRelayId = 0u;
+
+	NonRouteConfigDataStruct* pNonRouteConfig = GetNonRouteConfigDataPtrById(nonRouteId);
+	if (pNonRouteConfig != NULL)
+	{
+		collAgreeTryTrainRelayId = pNonRouteConfig->ColWaysideTryTrainIndRelayId;  /* 试车线采集的轨旁试车指示器继电器ID */
+	}
+
+	return collAgreeTryTrainRelayId;
+}
+
 /*
 * 功能描述：根据道岔id查找对应的非进路
 * 参数说明：swId-道岔id

TSCP/src/APP/ciapp/NonRoute/NonRouteConfigDataManage.h

@@ -82,6 +82,7 @@ typedef struct S_NonRouteConfigDataStruct
 	UINT16 AgreeTryTrainRelayId; /*同意试车继电器ID (配置字段)*/
 	UINT16 DrvApplyTryTrainRelayId;	/* 试车线驱动的申请试车继电器ID */
 	UINT16 ColAgreeTryTrainRelayId;	/* 试车线采集的同意试车继电器ID */
+	UINT16 ColWaysideTryTrainIndRelayId; /* 试车线采集的轨旁试车指示器继电器ID */
 } NonRouteConfigDataStruct;
 
 /*******************************全局变量声明*******************************/
@@ -268,6 +269,14 @@ UINT8 GetnonRouteIdbelongVirCIid(UINT8 nonRouteId);
 */
 UINT8 GetnonRouteIdbelongCIid(UINT8 nonRouteId);
 
+
+/*
+* 功能描述： 获取试车线采集的轨旁试车指示器继电器ID
+* 参数说明： UINT8 nonRouteId 非进路id
+* 返回值  ： 试车线采集的轨旁试车指示器继电器ID
+*/
+UINT16 GetWaysideTryTrainIndRelayId(UINT8 nonRouteId);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Overlap/OverlapConfigDataManage.c

@@ -923,3 +923,72 @@ UINT16 GetOverlapThatZhaoChaRelayId(const UINT16 overlapId)
 
 	return reVal;
 }
+
+/*
+* 功能描述： 获取指定保护区段侧防条件
+* 参数说明： const UINT16 wRouteId, 进路ID
+* 返回值  ： 返回侧防条件数据
+*/
+SideProtecGroupStru GetOverlapSideProtecGroupData(const UINT16 wOverlapId)
+{
+	SideProtecGroupStru cRetVal = { 0u };
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetOverlapConfigBufIndex(wOverlapId);  /*获取数组下标*/
+
+	if (OVERLAP_SUM_MAX > bufIndex)
+	{
+		cRetVal = OverlapConfigDataStru[bufIndex].SideProtecGroupData;
+	}
+	else
+	{
+		/*无处理*/
+	}
+
+	return cRetVal;
+}
+
+/*
+* 功能描述： 获取保护区段指定道岔的防护锁闭位置
+* 参数说明： const UINT16 wOverlapId, 保护区段ID
+*            const UINT16 wSwitchId 道岔ID
+*
+* 返回值  ：1，2为道岔位置,0u 非法值
+*
+*/
+UINT8 GetOverlapThisPortecSwitchPos(const UINT16 wOverlapId, const UINT16 wSwitchId)
+{
+	UINT8 chRetVal = 0U;
+	UINT16 bufIndex = 0U;
+	UINT8 i = 0u;
+
+	bufIndex = GetOverlapConfigBufIndex(wOverlapId);  /*获取保护区段数组下标*/
+
+	if (OVERLAP_SUM_MAX > bufIndex)
+	{
+		for (i = 0u; i < OverlapConfigDataStru[bufIndex].ProtectSwitchSum; i++)
+		{
+			if (OverlapConfigDataStru[bufIndex].ProtectSwitchStru[i].ProtectSwitchId == wSwitchId)
+			{
+				chRetVal = OverlapConfigDataStru[bufIndex].ProtectSwitchStru[i].ProtectPosition;
+				break;
+			}
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	if ((SWITCH_POSITION_DINGWEI == chRetVal) || (SWITCH_POSITION_FANWEI == chRetVal))
+	{
+		/*校验通过*/
+	}
+	else
+	{
+		chRetVal = 0u;
+	}
+
+	return chRetVal;
+}
+

TSCP/src/APP/ciapp/Overlap/OverlapConfigDataManage.h

@@ -19,7 +19,7 @@
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
 #include "../System/SystemParameterManage.h"
-
+#include  "RouteConfigDataManage.h"
 
 
 #ifdef __cplusplus
@@ -74,6 +74,7 @@ typedef struct S_OverlapConfigDataStruct
 	UINT16 AxisSecFarId;                                						    /*保护区段最远端计轴区段ID*/
 	UINT16 wOverlapThisZhaoChaRelayId;                                              /*保护区段本端照查继电器ID*/
 	UINT16 wOverlapThatZhaoChaRelayId;                                              /*保护区段对端照查继电器ID*/
+	SideProtecGroupStru   SideProtecGroupData;                                 /*保护区段侧防条件*/
 } OverlapConfigDataStruct;
 
 extern OverlapConfigDataStruct OverlapConfigDataStru[OVERLAP_SUM_MAX];   /*定义OVERLAP数据配置结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
@@ -389,7 +390,21 @@ UINT16 GetOverlapThisZhaoChaRelayId(const UINT16 overlapId);
 * by cgh 20250617
 */
 UINT16 GetOverlapThatZhaoChaRelayId(const UINT16 overlapId);
-
+/*
+* 功能描述： 获取指定保护区段侧防条件
+* 参数说明： const UINT16 wRouteId, 进路ID
+* 返回值  ： 返回侧防条件数据
+*/
+SideProtecGroupStru GetOverlapSideProtecGroupData(const UINT16 wOverlapId);
+/*
+* 功能描述： 获取保护区段指定道岔的防护锁闭位置
+* 参数说明： const UINT16 wOverlapId, 保护区段ID
+*            const UINT16 wSwitchId 道岔ID
+*
+* 返回值  ：1，2为道岔位置,0u 非法值
+*
+*/
+UINT8 GetOverlapThisPortecSwitchPos(const UINT16 wOverlapId, const UINT16 wSwitchId);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Overlap/OverlapDataManage.c

@@ -15,7 +15,7 @@
 
 
 OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX];		/*定义OVERLAP数据结构体*/
-
+OverlapDataStructCC OverlapDataStruCC[OVERLAP_SUM_MAX];   /*定义OVERLAP数据结构体-车车*/
 
 
 /*
@@ -28,7 +28,16 @@ OverlapDataStruct *GetOverlapData(void)
 {
     return OverlapDataStru;
 }
-
+/*
+* 功能描述： 获取指定ID保护区段数据-车车
+* 参数说明：
+* 返回值  ：
+			OverlapDataStructCC *
+*/
+OverlapDataStructCC* GetOverlapDataCC(void)
+{
+	return OverlapDataStruCC;
+}
 /*
 * 功能描述： 获取指定ID保护区段所属进路ID
 * 参数说明： const UINT16 overlapId, 保护区段ID    
@@ -82,11 +91,13 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
 	UINT16 protectSwitchId = 0u;                               /*防护道岔ID*/
 	UINT8 overlapProtectSwitchSum = 0u; 	                      /*防护道岔数目*/
 	OverlapProtectSwitchStruct* overlapProtectSwitchStru = NULL;  /*防护道岔数据*/
+	UINT8 cSwitchCurPos = 0U;
+	UINT8 cFuncRet = CI_ERROR;
 	
 	overlapProtectSwitchSum = GetOverlapRelatedProtSwitSum(overlapId);      /*获取防护道岔数目*/
 	overlapProtectSwitchStru = GetOverlapRelatedProtSwitStru(overlapId);    /*获取防护道岔数据*/
 
-	if (0u == overlapProtectSwitchSum) 
+	if ((0U == overlapProtectSwitchSum) || (NULL == overlapProtectSwitchStru))
 	{
 		retVal = CI_ERROR;
 	}
@@ -107,18 +118,28 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
 		for (ii= 0u; ii < overlapProtectSwitchSum; ii++)
 		{
 			protectSwitchId = overlapProtectSwitchStru[ii].ProtectSwitchId;
-			SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP,overlapId,protectSwitchId, lockCommand);                        /*设置道岔防护锁闭状态*/
+			cSwitchCurPos = GetSwitchCurPosition(protectSwitchId);
+			cFuncRet = checkSwtLastValDrvPosStayorNot(protectSwitchId, overlapProtectSwitchStru[ii].ProtectPosition);
+			if ((SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+				|| ((SWITCH_LOCK_PROTECT_SET == lockCommand) && (cSwitchCurPos == overlapProtectSwitchStru[ii].ProtectPosition) && (CI_SUCCESS == cFuncRet)))
+			{
+				SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP, overlapId, protectSwitchId, lockCommand);  /*设置道岔防护锁闭状态*/
 				/*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
 #if 0
 				if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
 				{ /*双动道岔*/
-				SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP,overlapId,GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁 闭状态*/
+					SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP, overlapId, GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁 闭状态*/
 				}
 				else
 				{
 				}
 #endif
 			}
+			else
+			{
+				/*防护道岔不在防护位置或防护道岔存在反向驱动时，不设置防护锁闭*/
+			}
+		}
 	} 
 	else
 	{
@@ -265,7 +286,7 @@ void SetOverlapUnlockApplyFlag(const UINT16 overlapId, const UINT8 overlapUnlock
 * 功能描述：获取指定ID保护区段申请解锁的列车ID
 * 参数说明：const UINT16 overlapId, 保护区段ID
 * 返回值  ：0 获取失败 
-*           其它 列车ID（不带0x14）
+*           其它 列车ID（不带0x10）
 */
 UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId)
 {
@@ -276,7 +297,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId)
 
 	if (bufIndex < OVERLAP_SUM_MAX)
 	{
-		reVal = OverlapDataStru[bufIndex].wOverlapUnlockApplyTrainId;
+		reVal = OverlapDataStruCC[bufIndex].wOverlapUnlockApplyTrainId;
 	}
 	return reVal;
 }
@@ -285,7 +306,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId)
 /*
 * 功能描述： 设置指定ID保护区段申请解锁的列车ID
 * 参数说明： const UINT16 overlapId, 保护区段ID
-*			 const UINT16 wTrainId，列车ID（不带0x14）
+*			 const UINT16 wTrainId，列车ID（不带0x10）
 * 返回值  ： 无
 *
 */
@@ -297,7 +318,7 @@ void SetOverlapUnlockApplyTrainId(const UINT16 overlapId, const UINT16 wTrainId)
 
 	if (bufIndex < OVERLAP_SUM_MAX)
 	{
-		OverlapDataStru[bufIndex].wOverlapUnlockApplyTrainId = wTrainId; 
+		OverlapDataStruCC[bufIndex].wOverlapUnlockApplyTrainId = wTrainId;
 	}
 }
 
@@ -622,7 +643,7 @@ void SetReqIvocUnlockStartCycNum(const UINT16 overlapId, const UINT32 reqIvocUnl
 
 	if (bufIndex < OVERLAP_SUM_MAX)
 	{
-		OverlapDataStru[bufIndex].dwReqIvocUnLockStartCycNum = reqIvocUnlockStartCycNum;  /*人工解锁起始周期号*/
+		OverlapDataStruCC[bufIndex].dwReqIvocUnLockStartCycNum = reqIvocUnlockStartCycNum;  /*人工解锁起始周期号*/
 	}
 }
 
@@ -641,7 +662,7 @@ UINT32 GetReqIvocUnlockStartCycNum(const UINT16 overlapId)
 
 	if (bufIndex < OVERLAP_SUM_MAX)
 	{
-		reVal = OverlapDataStru[bufIndex].dwReqIvocUnLockStartCycNum;  /*人工解锁起始周期号*/
+		reVal = OverlapDataStruCC[bufIndex].dwReqIvocUnLockStartCycNum;  /*人工解锁起始周期号*/
 	}
 	return reVal;
 }
@@ -661,7 +682,7 @@ void SetOverlapIvocAllowUnlockFlag(const UINT16 overlapId, const UINT8 overlapIv
 
 	if ((bufIndex < OVERLAP_SUM_MAX) && ((IVOC_ALLOW_UNLOCK_OVERLAP_YES == overlapIvocUnlockFlag) || (IVOC_ALLOW_UNLOCK_OVERLAP_NO == overlapIvocUnlockFlag)))
 	{
-		OverlapDataStru[bufIndex].cIvocAllowUnlockFlag = overlapIvocUnlockFlag;
+		OverlapDataStruCC[bufIndex].cIvocAllowUnlockFlag = overlapIvocUnlockFlag;
 	}
 	else
 	{
@@ -685,7 +706,7 @@ UINT8 GetOverlapIvocAllowUnlockFlag(const UINT16 overlapId)
 
 	if (bufIndex < OVERLAP_SUM_MAX)
 	{
-		reVal = OverlapDataStru[bufIndex].cIvocAllowUnlockFlag;
+		reVal = OverlapDataStruCC[bufIndex].cIvocAllowUnlockFlag;
 	}
 	else
 	{
@@ -821,13 +842,13 @@ UINT8 GetOverlapFromSetRouteCmdFlag(const UINT16 overlapId)
 }
 
 /*
-* 功能描述： 清保护区段人工或ATS锁闭命令标志
+* 功能描述： 清除保护区段个别标志
 * 参数说明： const UINT16 routeId, 进路ID
 *            const UINT16 overlapId, 保护区段ID
 * 返回值:无
-* by cgh 20240920
+* by cgh 20260106
 */
-void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId)
+void CleanOverlapSpecificFlag(const UINT16 routeId, const UINT16 overlapId)
 {
 	UINT16 overlapRouteSum = 0U;     /*保护区段进路数量*/
 	UINT16* pOverlapRouteBuf = NULL; /*保护区段进路数据*/
@@ -835,6 +856,8 @@ void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId
 	UINT16 routeLastPhyId = 0U;      /*进路最后一个物理区段ID*/
 	UINT8 routeLastPhyState = 0U;   /*进路最后一个物理区段融合占用状态*/
 	UINT16 ii = 0U;                  /*游标*/
+	UINT32 dwUnlockStartCycNum = 0U; /*保护区段解锁起始周期号*/
+	UINT32 dwAtsLastTimeLockCyc = 0U; /*最近一次ATS锁闭保护区段周期号*/
 
 	overlapRouteSum = GetOverlapRouteIdSum(overlapId);  /*获取保护区段进路数量*/
 	pOverlapRouteBuf = GetOverlapRouteIdBuf(overlapId); /*获取保护区段进路数据*/
@@ -855,6 +878,32 @@ void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId
 	{
 		SetOverlapAtsOrlaborLockCmdFlag(overlapId, LOCK_OVERLAP_CMD_NO);
 	}
+
+	dwUnlockStartCycNum = GetOverlapUnlockStartCycNum(overlapId);
+	dwAtsLastTimeLockCyc = GetOverlapAtsLastTimeLockCyc(overlapId);
+
+	if (0U == dwUnlockStartCycNum)
+	{
+		/*说明是人工解锁，人工解锁就不保留之前的命令了*/
+		SetRouteAtsExpLkOverlapId(routeId, 0U);
+		SetOverlapFromSetRouteCmdFlag(overlapId, OVERLAP_ROUTE_FLAG_NO);/*清除保护区段建立命令由进路命令连带下发标志*/
+	}
+	else
+	{
+		atsExpLockOverlapId = GetRouteAtsExpLkOverlapId(routeId);
+
+		if ((dwAtsLastTimeLockCyc <= dwUnlockStartCycNum) && (0U < dwAtsLastTimeLockCyc)
+			&& (overlapId == atsExpLockOverlapId))
+		{
+			/*ATS最后一次下发锁闭保护区段命令时保护区段未自动解锁*/
+			SetRouteAtsExpLkOverlapId(routeId, 0U);
+			SetOverlapFromSetRouteCmdFlag(overlapId, OVERLAP_ROUTE_FLAG_NO);/*清除保护区段建立命令由进路命令连带下发标志*/
+		}
+		else
+		{
+			;
+		}
+	}
 }
 
 /*
@@ -976,3 +1025,262 @@ UINT8 GetOverlapProSwtCheckStartFlag(const UINT16 wOverlapId)
 
 	return cRetVal;
 }
+
+/*
+* 功能描述： 获取指定ID保护区段之前人工解锁状态
+* 参数说明： const UINT16 overlapId, 保护区段ID
+* 返回值  ： 0: 获取数据失败
+*			 >0:之前人工解锁状态
+* BY CGH 20250928
+*/
+UINT8 GetOverlapPreLoaborUnlockState(const UINT16 overlapId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 reVal = CI_ERROR;
+
+	bufIndex = GetOverlapConfigBufIndex(overlapId);  /*获取数组下标*/
+
+	if (bufIndex < OVERLAP_SUM_MAX)
+	{
+		reVal = OverlapDataStru[bufIndex].chPreLaborUnlockState;
+	}
+	else
+	{
+		;
+	}
+
+	return reVal;
+}
+
+
+/*
+* 功能描述： 设置指定ID保护区段之前人工解锁状态
+* 参数说明： const UINT16 overlapId, 保护区段ID
+*			 const UINT8 chPreLaborUnlockState, 之前人工解锁状态
+* 返回值  void
+* by cgh 20250928
+*/
+void SetOverlapPreLoaborUnlockState(const UINT16 overlapId, const UINT8 chPreLaborUnlockState)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetOverlapConfigBufIndex(overlapId);  /*获取数组下标*/
+
+	if ((bufIndex < OVERLAP_SUM_MAX)
+		&& ((PRO_PRE_LABOR_UNLOCK_STATE_YES == chPreLaborUnlockState)
+		|| (PRO_PRE_LABOR_UNLOCK_STATE_NO == chPreLaborUnlockState)))
+	{
+		OverlapDataStru[bufIndex].chPreLaborUnlockState = chPreLaborUnlockState;  /*设置解锁起始周期号*/
+	}
+	else
+	{
+		;
+	}
+}
+
+/*
+* 功能描述：保护区段锁闭所属进路检查
+* 参数说明： const UINT16 wOverlapId 进路ID
+* 返回值  ：CI_SUCCESS 所有进路均空闲
+*			CI_ERROR 存在进路不是空闲
+* by cgh 20250928
+*/
+UINT8 OverlapLockRouteCheck(const UINT16 wOverlapId)
+{
+	UINT8 chReval = CI_ERROR;
+	UINT16 dwOverlapRouteSum = 0U; /*保护区段进路数目*/
+	UINT16* pOverlapRouteBuf = NULL; /*保护区段进路数组*/
+	UINT16 jj = 0U;
+	UINT8 chRouteState = 0U; /*进路状态*/
+	UINT8 chFlag = 0U; /*检查标志*/
+
+	if ((0U < wOverlapId) && (OVERLAP_SUM_MAX > wOverlapId))
+	{
+		dwOverlapRouteSum = GetOverlapRouteIdSum(wOverlapId);
+		pOverlapRouteBuf = GetOverlapRouteIdBuf(wOverlapId);
+
+		if ((NULL != pOverlapRouteBuf))
+		{
+			for (jj = 0U; jj < dwOverlapRouteSum; jj++)
+			{
+				chRouteState = GetRouteState(pOverlapRouteBuf[jj]);
+
+				if ((ROUTE_STATE_IDLE != chRouteState))
+				{
+					chFlag = 1U;
+					break;
+				}
+				else
+				{
+					;
+				}
+			}
+
+			if (0U == chFlag)
+			{
+				chReval = CI_SUCCESS;
+			}
+			else
+			{
+				; /*存在不空闲的进路*/
+			}
+		}
+		else
+		{
+			;
+		}
+	}
+	else
+	{
+		;
+	}
+
+	return chReval;
+}
+
+/*
+* 功能描述：设置指定ID保护区段关联物理区段停准停稳状态
+* 参数说明：const UINT16 overlapId 保护区段ID
+*			const UINT8 chSetFlag 设置标志
+* 返回值  ：无
+*/
+void SetOverlapBelPhyStopSteadyFlag(const UINT16 wOverlapId, const UINT8 chSetFlag)
+{
+	UINT16 wOverlopBelRouteId = 0U; /*保护区段锁闭所属进路ID*/
+	UINT8 chRoutePhySecSum = 0U; /*进路包含的物理区段数目*/
+	RoutePhysicalSectionStruct* szRoutePhySecData = NULL; /*进路包含物理区段结构数组*/
+
+	if ((0U < wOverlapId) && (wOverlapId < OVERLAP_SUM_MAX)
+		&& ((PHYSICAL_SECTION_STOPSTEADY_NO == chSetFlag) || (PHYSICAL_SECTION_STOPSTEADY_YES == chSetFlag)))
+	{
+		wOverlopBelRouteId = GetOverlapBelongRouteId(wOverlapId);
+
+		if (0U != wOverlopBelRouteId)
+		{
+			chRoutePhySecSum = GetRoutePhysicalSectionSum(wOverlopBelRouteId);
+			szRoutePhySecData = GetRouteSectionData(wOverlopBelRouteId);
+
+			if (NULL != szRoutePhySecData)
+			{
+				/*设置车车的物理区段停稳状态*/
+				SetPhySecStopSteadyFlagCC(szRoutePhySecData[chRoutePhySecSum - 1U].PhysicalSectionId, chSetFlag);
+			}
+			else
+			{
+				;
+			}
+		}
+		else
+		{
+			/*无锁闭所属进路不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/* 功能描述：清除期望保护区段关联所有进路的所有保护区段人工锁闭过标志
+* 参数说明： const UINT16 expLkOverlapId, ATS或现地发送的期望锁闭区段ID
+* 返回值  ： 无
+* by cgh 20260106
+*/
+void ClearPreLoaborUnlockState(const UINT16 expLkOverlapId)
+{
+	UINT8 overlapSum = 0U;
+	UINT16* overlapIdBuf = NULL;
+	UINT16 ii = 0U;
+	UINT8 jj = 0U;
+	UINT8 localCiId = 0U;        /*本联锁集中区ID*/
+	UINT8 OverlapBelongCiId = 0U;
+	UINT16 overlapRouteSum = 0U;/*保护区段关联进路数量*/
+	UINT16* overlapRouteBuf = NULL;/*保护区段关联进路数据*/
+
+	overlapRouteSum = GetOverlapRouteIdSum(expLkOverlapId);/*获取保护区段关联进路总数*/
+	overlapRouteBuf = GetOverlapRouteIdBuf(expLkOverlapId);/*获取进路数据*/
+	localCiId = GetSystemParaLocalCiId();        /*获取本机联锁ID*/
+
+	if ((0U != overlapRouteSum) && (NULL != overlapRouteBuf))
+	{
+		for (ii = 0U; ii < overlapRouteSum; ii++)
+		{
+			overlapSum = GetRouteOverlapSum(overlapRouteBuf[ii]);  /*获取Overlap总数*/
+			overlapIdBuf = GetRouteOverlapIdBuf(overlapRouteBuf[ii]);  /*获取Overlap ID BUF*/
+
+			if ((0U == overlapSum) || (NULL == overlapIdBuf))
+			{
+				;/*数据异常*/
+			}
+			else
+			{
+				for (jj = 0U; jj < overlapSum; jj++)
+				{
+					OverlapBelongCiId = GetOverlapBelongCiId(overlapIdBuf[jj]);
+					if (OverlapBelongCiId == localCiId)
+					{
+						SetOverlapPreLoaborUnlockState(overlapIdBuf[jj], PRO_PRE_LABOR_UNLOCK_STATE_NO);
+					}
+					else
+					{
+						; /*相邻联锁的不处理*/
+					}
+				}
+
+			}
+		}
+	}
+	else
+	{
+		; /*不处理*/
+	}
+}
+
+/*
+* 功能描述： 获取指定ID保护区段最近一次ATS锁闭保护区段周期号
+* 参数说明： const UINT16 overlapId, 保护区段ID
+* 返回值  ： 最近一次ATS锁闭保护区段周期号
+* BY CGH 20260106
+*/
+UINT32 GetOverlapAtsLastTimeLockCyc(const UINT16 overlapId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT32 reVal = CI_ERROR;
+
+	bufIndex = GetOverlapConfigBufIndex(overlapId);  /*获取数组下标*/
+
+	if (bufIndex < OVERLAP_SUM_MAX)
+	{
+		reVal = OverlapDataStru[bufIndex].dwAtsLastTimeLockCyc;
+	}
+	else
+	{
+		;
+	}
+
+	return reVal;
+}
+
+
+/*
+* 功能描述： 设置指定ID保护区段最近一次ATS锁闭保护区段周期号
+* 参数说明： const UINT16 overlapId, 保护区段ID
+*			 const UINT32 dwAtsLastTimeLockCyc, 最近一次ATS锁闭保护区段周期号
+* 返回值  void
+* by cgh 20250928
+*/
+void SetOverlapAtsLastTimeLockCyc(const UINT16 overlapId, const UINT32 dwAtsLastTimeLockCyc)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetOverlapConfigBufIndex(overlapId);  /*获取数组下标*/
+
+	if (bufIndex < OVERLAP_SUM_MAX)
+	{
+		OverlapDataStru[bufIndex].dwAtsLastTimeLockCyc = dwAtsLastTimeLockCyc;  /*设置解锁起始周期号*/
+	}
+	else
+	{
+		;
+	}
+}

TSCP/src/APP/ciapp/Overlap/OverlapDataManage.h

@@ -35,9 +35,6 @@ typedef struct S_OverlapDataStruct
 	UINT32 UnlockStartCycNum;  /*保护区段解锁起始周期号 (动态字段)*/ 
 	UINT32 XuanPaiStartCycNum; /*保护区段选排开始周期号(动态字段)*/
 	UINT8 OverlapUnlockApplyFlag; /*向ZC申请解锁保护区段解锁标志，20181105*/
-	UINT16 wOverlapUnlockApplyTrainId;/* 申请保护区段解锁的列车ID（不带0x14）*/
-	UINT32 dwReqIvocUnLockStartCycNum;  /*向车申请解锁保护区段起始周期号*/
-	UINT8 cIvocAllowUnlockFlag;  /*列车允许解锁保护区段标志，0xAA同意解锁，0x55不同意解锁*/
 	UINT8 OverlapCanLaborUnlockFlag;/*保护区段可以人工解锁标志*/
 	UINT8 OverlapLaborUnlockSetState;/*保护区段人工解锁设置状态*/
 	UINT32 laborUnlockStartCycNum;/*人工解锁起始周期号*/
@@ -48,10 +45,21 @@ typedef struct S_OverlapDataStruct
 	UINT8 OverlapFromSetRouteCmdFlag;/*保护区段由进路办理时连带的标志*/
 	UINT8 cProSwitchCheckResultFlag;  /*跨控区防护道岔检查结果标志（0xFF：默认值，0x55：失败，0xAA：成功）*/
 	UINT8 cProSwitchCheckStartFlag;  /*跨控区防护道岔检查开始标志（0x55：检查开始，0xAA：检查停止）*/
+	UINT8 chPreLaborUnlockState; /*之前人工解锁状态*/
+	UINT32 dwAtsLastTimeLockCyc; /*最近一次ATS锁闭保护区段周期号*/
 } OverlapDataStruct;
 
+/*保护区段数据结构体*/
+typedef struct S_OverlapDataStructCC
+{
+	UINT16 OverlapId;					/*保护区段组ID (初始化字段)*/
+	UINT16 wOverlapUnlockApplyTrainId;	/*申请保护区段解锁的列车ID（不带0x10）*/
+	UINT32 dwReqIvocUnLockStartCycNum;  /*向车申请解锁保护区段起始周期号*/
+	UINT8 cIvocAllowUnlockFlag;			/*列车允许解锁保护区段标志，0xAA同意解锁，0x55不同意解锁*/
+}OverlapDataStructCC;
 /*******************************全局变量声明*******************************/
 extern OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX];   /*定义OVERLAP数据结构体*/
+extern OverlapDataStructCC OverlapDataStruCC[OVERLAP_SUM_MAX];   /*定义OVERLAP数据结构体-车车*/
 /*
 * 功能描述： 获取指定ID保护区段数据
 * 参数说明： 
@@ -59,6 +67,19 @@ extern OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX];   /*
             OverlapDataStruct *    
 */
 OverlapDataStruct *GetOverlapData(void);
+/*
+* 功能描述： 获取指定ID保护区段数据-车车
+* 参数说明：
+* 返回值  ：
+			OverlapDataStructCC *
+*/
+/*
+* 功能描述： 获取指定ID保护区段数据-车车
+* 参数说明：
+* 返回值  ：
+			OverlapDataStructCC *
+*/
+OverlapDataStructCC* GetOverlapDataCC(void);
 
 /*
 * 功能描述： 获取指定ID保护区段所属进路ID
@@ -69,7 +90,7 @@ OverlapDataStruct *GetOverlapData(void);
 UINT16 GetOverlapBelongRouteId(const UINT16 overlapId);
 
 /*
-* 功能描述： 设置指定ID保护区段组解锁起始周期号
+* 功能描述： 设置指定ID保护区段所属进路
 * 参数说明： const UINT16 overlapId, 保护区段ID
 *			 const UINT16 belongRouteId, 所属进路号
 * 返回值  ： 无
@@ -138,7 +159,7 @@ void SetOverlapUnlockApplyFlag(const UINT16 overlapId, const UINT8 overlapUnlock
 * 功能描述：获取指定ID保护区段申请解锁的列车ID
 * 参数说明：const UINT16 overlapId, 保护区段ID
 * 返回值  ：0 获取失败
-*           其它 列车ID（不带0x14）
+*           其它 列车ID（不带0x10）
 */
 UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId);
 
@@ -146,7 +167,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId);
 /*
 * 功能描述： 设置指定ID保护区段申请解锁的列车ID
 * 参数说明： const UINT16 overlapId, 保护区段ID
-*			 const UINT16 wTrainId，列车ID（不带0x14）
+*			 const UINT16 wTrainId，列车ID（不带0x10）
 * 返回值  ： 无
 *
 */
@@ -315,13 +336,13 @@ void SetOverlapFromSetRouteCmdFlag(const UINT16 overlapId, const UINT8 setFlag);
 UINT8 GetOverlapFromSetRouteCmdFlag(const UINT16 overlapId);
 
 /*
-* 功能描述： 清保护区段人工或ATS锁闭命令标志
+* 功能描述： 清除保护区段个别标志
 * 参数说明： const UINT16 routeId, 进路ID
 *            const UINT16 overlapId, 保护区段ID
 * 返回值:无
-* by cgh 20240920
+* by cgh 20260106
 */
-void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId);
+void CleanOverlapSpecificFlag(const UINT16 routeId, const UINT16 overlapId);
 
 /*
 * 功能描述：设置保护区段防护道岔检查结果标志
@@ -360,6 +381,65 @@ void SetOverlapProSwtCheckStartFlag(const UINT16 wOverlapId, const UINT8 cCheckS
 */
 UINT8 GetOverlapProSwtCheckStartFlag(const UINT16 wOverlapId);
 
+/*
+* 功能描述： 获取指定ID保护区段之前人工解锁状态
+* 参数说明： const UINT16 overlapId, 保护区段ID
+* 返回值  ： 0: 获取数据失败
+*			 >0:之前人工解锁状态
+* BY CGH 20250928
+*/
+UINT8 GetOverlapPreLoaborUnlockState(const UINT16 overlapId);
+
+/*
+* 功能描述： 设置指定ID保护区段之前人工解锁状态
+* 参数说明： const UINT16 overlapId, 保护区段ID
+*			 const UINT8 chPreLaborUnlockState, 之前人工解锁状态
+* 返回值  void
+* by cgh 20250928
+*/
+void SetOverlapPreLoaborUnlockState(const UINT16 overlapId, const UINT8 chPreLaborUnlockState);
+
+/*
+* 功能描述：保护区段锁闭所属进路检查
+* 参数说明： const UINT16 wOverlapId 进路ID
+* 返回值  ：CI_SUCCESS 所有进路均空闲
+*			CI_ERROR 存在进路不是空闲
+* by cgh 20250928
+*/
+UINT8 OverlapLockRouteCheck(const UINT16 wOverlapId);
+
+/*
+* 功能描述：设置指定ID保护区段关联物理区段停准停稳状态
+* 参数说明：const UINT16 overlapId 保护区段ID
+*			const UINT8 chSetFlag 设置标志
+* 返回值  ：无
+*/
+void SetOverlapBelPhyStopSteadyFlag(const UINT16 wOverlapId, const UINT8 chSetFlag);
+
+/* 功能描述：清除期望保护区段关联所有进路的所有保护区段人工锁闭过标志
+* 参数说明： const UINT16 expLkOverlapId, ATS或现地发送的期望锁闭区段ID
+* 返回值  ： 无
+* by cgh 20260106
+*/
+void ClearPreLoaborUnlockState(const UINT16 expLkOverlapId);
+
+/*
+* 功能描述： 获取指定ID保护区段最近一次ATS锁闭保护区段周期号
+* 参数说明： const UINT16 overlapId, 保护区段ID
+* 返回值  ： 最近一次ATS锁闭保护区段周期号
+* BY CGH 20260106
+*/
+UINT32 GetOverlapAtsLastTimeLockCyc(const UINT16 overlapId);
+
+/*
+* 功能描述： 设置指定ID保护区段最近一次ATS锁闭保护区段周期号
+* 参数说明： const UINT16 overlapId, 保护区段ID
+*			 const UINT32 dwAtsLastTimeLockCyc, 最近一次ATS锁闭保护区段周期号
+* 返回值  void
+* by cgh 20250928
+*/
+void SetOverlapAtsLastTimeLockCyc(const UINT16 overlapId, const UINT32 dwAtsLastTimeLockCyc);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Overlap/OverlapDefine.h

@@ -72,6 +72,10 @@
 #define PROSWITCH_CHECK_START_VALID       ((UINT8)0x55)  /*开始检查*/
 #define PROSWITCH_CHECK_START_INVALID     ((UINT8)0xAA)  /*停止检查*/
 
+/*保护区段之前人工解锁标志*/
+#define PRO_PRE_LABOR_UNLOCK_STATE_YES       ((UINT8)0x55)  /*之前成功人工解锁过*/
+#define PRO_PRE_LABOR_UNLOCK_STATE_NO        ((UINT8)0xAA)  /*之前未人工解锁过*/
+
 #define OVERLAP_USING_OVERTIME_CYC_NUM    10U  /*保护区段征用超时周期数*/
 
 #endif

TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c

@@ -1066,3 +1066,120 @@ UINT8 GetPsdControlType(const UINT16 doorId)
 
 	return retVal;
 }
+/*
+* 功能描述： 获取指定ID屏蔽门三编组驱动开门继电器ID
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 驱动开门继电器ID
+*/
+UINT16 GetThreeGroupPsdOpenDrvRelayId(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16 retVal = 0u;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdConfigDataStru[bufIndex].OpenThreeEditGroupDriveRelayId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门再次开门继电器ID2
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 再次开门继电器ID
+*/
+UINT16 GetPsdReOpenRelayId2(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdConfigDataStru[bufIndex].doorReopenRelayId2;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门包含ESB
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ：ESB ID数组
+*/
+UINT16* GetPsdIncloudeEsbIdBuf(const UINT16 psdId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16* retVal = NULL;
+
+	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdConfigDataStru[bufIndex].IncloudeEsbIdBuf;
+	}
+	else
+	{
+		retVal = NULL;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门包含ESB数量
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ：ESB ID数组
+*/
+UINT8 GetPsdIncloudeEsbNum(const UINT16 psdId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = NULL;
+
+	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdConfigDataStru[bufIndex].IncloudeEsbNum;
+	}
+	else
+	{
+		retVal = NULL;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮继电器ID
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*			>0: IBP盘发车按钮继电器ID
+*/
+UINT16 GetIbpConfmRelayId(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdConfigDataStru[bufIndex].wIbpRelayId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}

TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h

@@ -39,6 +39,7 @@ typedef struct S_PsdConfigDataStruct
 	UINT16 MutualLockRelayId;    											/*互锁解除继电器ID (配置字段)*/
 	UINT16 wMutualLockRelayId2;												/*互锁解除继电器ID2(配置字段) 迪斯尼*/
 	UINT16 CloseDriveRelayId;    											/*关门继电器ID (配置字段)*/
+	UINT16 OpenThreeEditGroupDriveRelayId;                                   /*打开三编组屏蔽门的驱动继电器(配置字段)*/
 	UINT16 OpenFourEditGroupDriveRelayId;                                   /*打开四编组屏蔽门的驱动继电器(配置字段)*/
 	UINT16 OpenSixEditGroupDriveRelayId;                                    /*打开六编组屏蔽门的驱动继电器(配置字段)*/
 	UINT16 OpenEightEditGroupDriveRelayId;                                  /*打开八编组屏蔽门的驱动继电器(配置字段)*/
@@ -46,6 +47,7 @@ typedef struct S_PsdConfigDataStruct
 	UINT16 wDoorStateRelayId2;												/*门开采集继电器ID2(配置字段) 迪斯尼*/
 	UINT16 wRelayDoorButtonId;                                              /*屏蔽门再关门按钮继电器*/
 	UINT16 doorReopenRelayId;												/*站台门再次开门继电器*/
+	UINT16 doorReopenRelayId2;												/*站台门再次开门继电器2*/
 	UINT16 departureConfirmRelayId;											/*发车确认继电器*/
 	UINT16 detectStartRelayId;												/*启动探测继电器*/
 	UINT16 detectStopRelayId;												/*停止探测继电器*/
@@ -68,6 +70,9 @@ typedef struct S_PsdConfigDataStruct
 	UINT16 wPsdSndProLinkId;                                                  /*屏蔽门防护link2ID*/
 	UINT16 wPsdTrdProLinkId;                                                  /*屏蔽门防护link3ID*/
 	UINT8 chPsdControlType;													  /*屏蔽门控制类型*/
+	UINT16 IncloudeEsbIdBuf[PSD_INCLUDE_ESB_NUM];                              /*屏蔽门包含ESB ID*/
+	UINT8 IncloudeEsbNum;                                                      /*包含ESB数量*/
+	UINT16 wIbpRelayId;												/*IBP盘发车按钮继电器ID*/	
 } PsdConfigDataStruct;
 
 
@@ -421,6 +426,40 @@ UINT8 CheckPsdBelSendRange(const UINT16 wCheckPsdId);
 * 返回值  ： UINT8 控制类型（0x55 OC-P控制  0xAA RCI控制）
 */
 UINT8 GetPsdControlType(const UINT16 doorId);
+/*
+* 功能描述： 获取指定ID屏蔽门三编组驱动开门继电器ID
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 驱动开门继电器ID
+*/
+UINT16 GetThreeGroupPsdOpenDrvRelayId(const UINT16 doorId);
+/*
+* 功能描述： 获取指定ID屏蔽门再次开门继电器ID2
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 再次开门继电器ID
+*/
+UINT16 GetPsdReOpenRelayId2(const UINT16 doorId);
+/*
+* 功能描述： 获取指定ID屏蔽门包含ESB数量
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ：ESB ID数组
+*/
+UINT8 GetPsdIncloudeEsbNum(const UINT16 psdId);
+/*
+* 功能描述： 获取指定ID屏蔽门包含ESB
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ：ESB ID数组
+*/
+UINT16* GetPsdIncloudeEsbIdBuf(const UINT16 psdId);
+
+/*
+* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮继电器ID
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*			>0: IBP盘发车按钮继电器ID
+*/
+UINT16 GetIbpConfmRelayId(const UINT16 doorId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/PSD/PSDDataManage.c

@@ -11,8 +11,10 @@
 
 #include "PSDDataManage.h"
 #include "../ParsePack/ParsePackDefine.h"
+#include "ESBDataManage.h"
 
-PsdDataStruct PsdDataStru[PSD_SUM_MAX];   /*定义屏蔽门数据结构体*/
+PsdDataStruct PsdDataStru[PSD_SUM_MAX] = { 0U };   /*定义屏蔽门数据结构体*/
+PsdDataStructCC PsdDataStruCC[PSD_SUM_MAX] = { 0U };   /*定义车车屏蔽门数据结构体*/
 
 /*
 * 功能描述： 获取指定ID屏蔽门数据
@@ -24,6 +26,16 @@ PsdDataStruct *GetPsdData(void)
     return PsdDataStru;
 }
 
+/*
+* 功能描述：获取指定ID屏蔽门数据CC
+* 参数说明：无
+* 返 回 值：车车屏蔽门动态数据
+*/
+PsdDataStructCC* GetPsdDataCC(void)
+{
+	return PsdDataStruCC;
+}
+
 /*
 * 功能描述： 获取指定ID屏蔽门互锁解除状态
 * 参数说明： const UINT16 doorId, 屏蔽门ID    
@@ -519,6 +531,9 @@ void ResetPsdData(const UINT16 psdId)
 
 		PsdDataStru[bufIndex].PsdDriveState=PSD_DRIVE_STATE_INVALID;
 		PsdDataStru[bufIndex].PsdPreDriveState=PSD_DRIVE_STATE_INVALID;
+
+		SetPsdVobcCmdCC(psdId,0u, PSD_DEFAULT_CONTROL_CMD,0u);
+		SetPsdEditGroupInfoDataCC(psdId, PSD_EDIT_GROUP_DEFAULT);  /*设置RC的PSD编组信息为默认值*/
 	}
 	else
 	{
@@ -937,6 +952,54 @@ UINT8 GetStopDetectionState(const UINT16 doorId)
 	}
 	return retVal;
 }
+
+/*
+* 功能描述：设置指定PSD停止探测周期号
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*            const UINT32 startCycNum, 起始周期号
+* 返回值  ： 无
+*            
+*/
+void SetStopDetectionCycNum(const UINT16 doorId, const UINT32 startCycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		PsdDataStru[bufIndex].StopDetectionCycNum = startCycNum;
+	}
+	else
+	{
+		/*不做处理*/
+	}
+}
+
+/*
+* 功能描述： 获取停止探测起始周期号
+* 参数说明： const UINT16 doorId, 进路ID
+* 返回值  ： 0: 获取数据失败
+*           >0: 起始周期号
+*/
+UINT32 GetStopDetectionCycNum(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].StopDetectionCycNum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
 #if 0
 /*
 * 功能描述： 设置因VOBC关PSD而需要被重开的进路
@@ -1502,7 +1565,6 @@ UINT8 GetPsdPlFlag(const UINT16 doorId)
 void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFlag)
 {
 	/*变量初始化*/
-	UINT8 i = 0u;
 	UINT8 transmitState = 0u;
 	UINT8 localCiId = 0u;
 	UINT8 psdCiId = 0u;
@@ -2512,21 +2574,21 @@ UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId)
 }
 
 /*
-* 功能描述：设置指定ID屏蔽门异常打开状态
+* 功能描述：设置指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-*			const UINT8 cExceptOpenState 屏蔽门异常打开状态
+*			const UINT8 cExceptOpenState 屏蔽门异常状态
 * 返 回 值：无
 * Created By LQ 2025.05.22
 */
-void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
+void SetPsdExceptState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
 {
 	UINT16 bufIndex = 0U;
 
 	bufIndex = GetPsdConfigBufIndex(wPsdId); /*获取屏蔽门数组下标*/
 
-	if ((PSD_SUM_MAX > bufIndex) && ((PSD_EXCEPT_OPEN_YES == cExceptOpenState) || (PSD_EXCEPT_OPEN_NO == cExceptOpenState)))
+	if ((PSD_SUM_MAX > bufIndex) && ((PSD_EXCEPT_YES == cExceptOpenState) || (PSD_EXCEPT_NO == cExceptOpenState)))
 	{
-		PsdDataStru[bufIndex].cPsdExceptOpenState = cExceptOpenState;  /*设置屏蔽门异常打开状态*/
+		PsdDataStru[bufIndex].cPsdExceptOpenState = cExceptOpenState;  /*设置屏蔽门异常状态*/
 	}
 	else
 	{
@@ -2535,16 +2597,16 @@ void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
 }
 
 /*
-* 功能描述：获取指定ID屏蔽门异常打开状态
+* 功能描述：获取指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-* 返 回 值：0x55 异常打开
-*           0xAA 未异常打开
+* 返 回 值：0x55 异常（曾异常打开未解除）
+*           0xAA 未异常
 * Created By LQ 2025.05.22
 */
-UINT8 GePsdExceptOpenState(const UINT16 wPsdId)
+UINT8 GePsdExceptState(const UINT16 wPsdId)
 {
 	UINT16 bufIndex = 0U;
-	UINT8 cRetVal = PSD_EXCEPT_OPEN_YES;
+	UINT8 cRetVal = PSD_EXCEPT_YES;
 
 	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/
 
@@ -2856,3 +2918,502 @@ void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum)
 		/*不处理*/
 	}
 }
+
+/*
+* 功能描述：获取指定ID屏蔽门编组信息CC
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值：0 无编组信息
+*			3 三编组
+*           4 四编组
+*           6 六编组
+*           8 八编组
+* Created By LQ 2025.11.05
+*/
+UINT16 GetPsdEditGroupInfoDataCC(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT16 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStruCC[bufIndex].psdEditGroupInfo;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门编组信息CC
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
+* 返 回 值：无
+* Created By LQ 2025.11.05
+*/
+void SetPsdEditGroupInfoDataCC(const UINT16 doorId, const UINT16 wPsdEditGroupInfo)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		if ((PSD_THREE_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_FOUR_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_SIX_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_EIGHT_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_EDIT_GROUP_DEFAULT == wPsdEditGroupInfo))
+		{
+			PsdDataStruCC[bufIndex].psdEditGroupInfo = wPsdEditGroupInfo;   /*不考虑FAO的特殊接口*/
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取PSD的VOBC控制命令CC
+* 参数说明：const UINT16 doorId,屏蔽门ID
+* 返 回 值：0x00-默认值
+*           0x55-打开PSD命令
+*           0xAA-关闭PSD命令
+*           0xFF-查询PSD命令
+* Created By LQ 2025.11.05
+*/
+UINT8 GetPsdVobcCmdCC(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 ctrlCmd = PSD_DEFAULT_CONTROL_CMD;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		ctrlCmd = PsdDataStruCC[bufIndex].PsdCmd;
+	}
+	else
+	{
+		ctrlCmd = PSD_DEFAULT_CONTROL_CMD;
+	}
+
+	return ctrlCmd;
+}
+
+/*
+* 功能描述： 获取当前控制该PSD的VOBC的编号CC
+* 参数说明： const UINT16 doorId,屏蔽门ID
+* 返 回 值： VOBC ID
+* Created By LQ 2025.11.05
+*/
+UINT16 GetPsdVobcIdCC(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT16 vobcId = 0U;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		vobcId = PsdDataStruCC[bufIndex].SrcVobcId;
+	}
+	else
+	{
+		vobcId = 0U;
+	}
+
+	return vobcId;
+}
+
+/*
+* 功能描述：获得该PSD的控制命令的设置周期CC
+* 参数说明：const UINT16 doorId,屏蔽门ID
+* 返 回 值：该PSD的控制命令的设置周期
+* Created By LQ 2025.11.05
+*/
+UINT32 GetPsdCmdSetCycleCC(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT32 setCycle = 0U;
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		setCycle = PsdDataStruCC[bufIndex].CmdSetCycle;
+	}
+	else
+	{
+		setCycle = 0U;
+	}
+
+	return setCycle;
+}
+
+/*
+* 功能描述：设置PSD的VOBC操作命令CC
+* 参数说明：const UINT16 doorId 屏蔽门ID
+*			const UINT16 vobcId 操作屏蔽门的VOBC ID
+*			const UINT8 operCmd 来自VOBC的开关门命令
+*			const UINT32 dwCycNum 周期号
+* 返 回 值：无
+* Created By LQ 2025.11.05
+*/
+void SetPsdVobcCmdCC(const UINT16 doorId, const UINT16 vobcId, const UINT8 operCmd, const UINT32 dwCycNum)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		if ((PSD_DEFAULT_CONTROL_CMD == operCmd)
+			|| (VOBCTOCI_COMMAND_TYPE_PSDOPEN == operCmd)
+			|| (VOBCTOCI_COMMAND_TYPE_PSDCLOSE == operCmd)
+			|| (VOBCTOCI_COMMAND_TYPE_PSDCHECK_FAOHLHT == operCmd))
+		{
+			if (PsdDataStruCC[bufIndex].SrcVobcId == vobcId)
+			{
+				PsdDataStruCC[bufIndex].PsdCmd = operCmd;
+			}
+			else
+			{
+				/*另一个VOBC开始操作该屏蔽门，对之前VOBC操作该屏蔽门产生的上下文进行复位*/
+				PsdDataStruCC[bufIndex].SrcVobcId = vobcId;
+				PsdDataStruCC[bufIndex].PsdCmd = operCmd;
+			}
+			PsdDataStruCC[bufIndex].CmdSetCycle = dwCycNum;
+		}
+		else
+		{
+			/*命令非法，不处理*/
+		}
+	}
+	else
+	{
+		/*不做处理*/
+	}
+}
+
+/*
+* 功能描述：获取指定ID屏蔽门编组信息CC
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值：0 无编组信息
+*			3 三编组
+*           4 四编组
+*           6 六编组
+*           8 八编组
+*/
+UINT16 GetPsdEditGroupInfoData(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT16 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].psdEditGroupInfo;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门编组信息
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
+* 返 回 值：无
+*/
+void SetPsdEditGroupInfoData(const UINT16 doorId, const UINT16 wPsdEditGroupInfo)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		if ((PSD_THREE_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_FOUR_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_SIX_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_EIGHT_EDIT_GROUP == wPsdEditGroupInfo)
+			|| (PSD_EDIT_GROUP_DEFAULT == wPsdEditGroupInfo))
+		{
+			PsdDataStru[bufIndex].psdEditGroupInfo = wPsdEditGroupInfo;   /*不考虑FAO的特殊接口*/
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+
+/*
+* 功能描述：获取指定ID屏蔽门间隙探测互锁解除故障状态
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值： 0 返回失败
+*           0< 间隙探测互锁解除故障状态
+*/
+UINT8 GetPsdJXTCMutualLockFaultState(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdDataStru[bufIndex].JXTCMutualLockFaultState;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门间隙探测互锁解除故障状态
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT8 wJXTCMutualLockFaultState 间隙探测互锁解除故障状态
+* 返 回 值：无
+*/
+void SetPsdJXTCMutualLockFaultState(const UINT16 doorId, const UINT8 wJXTCMutualLockFaultState)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		if ((JXTC_MUTUALLOCKFAULT_YES == wJXTCMutualLockFaultState)
+			|| (JXTC_MUTUALLOCKFAULT_NO == wJXTCMutualLockFaultState))
+		{
+			PsdDataStru[bufIndex].JXTCMutualLockFaultState = wJXTCMutualLockFaultState;   /*间隙探测互锁解除故障状态*/
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取指定ID屏蔽门间隙探测互锁解除时间
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值： 0 返回失败
+*           0< 屏蔽门间隙探测互锁解除时间
+*/
+UINT32 GetPsdJXTCMutualLockStartCycNum(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdDataStru[bufIndex].JXTCMutualLockStartCycNum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门间隙探测互锁解除起始时间
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT32 cycnum 互锁解除起始时间
+* 返 回 值：无
+*/
+void SetPsdJXTCMutualLockStartCycNum(const UINT16 doorId, const UINT32 cycnum)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		PsdDataStru[bufIndex].JXTCMutualLockStartCycNum = cycnum;
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+
+/*
+* 功能描述： 设置指定ID屏蔽门IBP盘发车按钮状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*            UINT8 setFlag  需设置的按钮状态
+* 返回值  ： CI_ERROR    失败
+*           CI_SUCCESS  成功	
+*/
+UINT8 SetPsdButtonIbpState(const UINT16 doorId, const UINT8 setFlag)
+{
+	UINT16 bufIndex = 0u;                      /*数组下标*/
+	UINT8 retVal = 0u;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		if ((PLATFORM_DEPAR_BUTTON_STATE_VALID == setFlag) || (PLATFORM_DEPAR_BUTTON_STATE_INVALID == setFlag)
+			||(PLATFORM_DEPAR_BUTTON_STATE_FAULT == setFlag))
+		{
+			PsdDataStru[bufIndex].ibpButtonState = setFlag;   /*设置按钮状态*/
+			retVal = CI_SUCCESS;
+		}
+		else
+		{
+			retVal = CI_ERROR;
+		}
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ：0: 获取数据失败
+*			>0: IBP盘发车按钮状态
+*/
+UINT8 GetPsdButtonIbpState(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;                      /*数组下标*/
+	UINT8 retVal = 0u;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].ibpButtonState;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门IBP按下起始周期号
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*            const UINT32 startCycNum, 起始周期号
+* 返回值  ： 0: 设置数据失败
+*           >0: 设置数据成功
+*/
+UINT8 SetIBPPressCycNum(const UINT16 doorId, const UINT32 startCycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		PsdDataStru[bufIndex].IBPPressCycNum = startCycNum;
+		retVal = CI_SUCCESS;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+/*
+* 功能描述： 获取指定ID屏蔽门IBP按下起始周期号
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*           >0: 起始周期号
+*/
+UINT32 GetIBPPressCycNum(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].IBPPressCycNum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门状态给 VOBC
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ：屏蔽门状态
+*/
+UINT8 GetPsdStateToVobc(const UINT16 doorId)
+{
+	UINT8 chPsdState = 0U;
+	UINT8 chPsdPlState = 0U;
+	UINT8 chExceptOpenState = 0U;
+	UINT8 chRet = 0U;
+	chPsdPlState = GetPsdMutualLockRemoveState(doorId); /*屏蔽门互锁解除*/
+	if ((PSD_MUTUALLOCK_REMOVE_YES == chPsdPlState) || (PSD_ATS_MUTUALLOCK_REMOVE_YES == chPsdPlState) || (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == chPsdPlState))
+	{
+		/*屏蔽门互锁解除*/
+		chRet = CI_IVOC_PSD_STATE_PANGLU;
+	}
+	else
+	{
+		chPsdState = GetPsdState(doorId);
+		if (PSD_STATE_CLOSE == chPsdState)
+		{/*屏蔽门关*/
+			chRet = CI_IVOC_PSD_STATE_CLOSE;
+		}
+		else
+		{
+			/*屏蔽门开, 判断是否异常*/
+			chExceptOpenState = GePsdExceptState(doorId);
+			if (PSD_EXCEPT_NO == chExceptOpenState)
+			{
+				chRet = CI_IVOC_PSD_STATE_OPEN;
+			}
+			else
+			{
+				/*屏蔽门异常打开*/
+				chRet = CI_IVOC_PSD_STATE_OPEN_EXCEPT;
+			}
+		}
+	}
+	return chRet;
+}

TSCP/src/APP/ciapp/PSD/PSDDataManage.h

@@ -22,6 +22,7 @@
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
 #include "../Relay/RelayConfigDataManage.h"
+#include "CiInterfaceDefine.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -58,6 +59,7 @@ typedef struct S_PsdDataStruct
 	UINT32 StartDetectionCycNum; /*开启探测周期*/
 	UINT8 StartDetectionState;   /*启动探测状态*/
 	UINT8 StopDetectionState;    /*停止探测状态*/
+	UINT32 StopDetectionCycNum;  /*停止探测周期*/
 	UINT8 VOBCDoorState;         /*VOBC车门状态*/
 	UINT32 PCBPressCycNum; /*PCB按下起始周期*/
 	UINT32 POBPressCycNum; /*POB按下起始周期*/
@@ -91,9 +93,25 @@ typedef struct S_PsdDataStruct
 	UINT8 psdCloseErrState;		/*关门故障状态*/
 	UINT8 cPsdExceptOpenState;  /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
 	UINT32 dwPsdRelayDownCycNum; /*PSD门关继电器落下起始周期*/
+
+	UINT8 JXTCMutualLockFaultState;  			/*间隙探测互锁解除按钮故障状态 (动态字段)*/
+	UINT32 JXTCMutualLockStartCycNum;  			/*间隙探测互锁解除起始时间*/
+	UINT8 ibpButtonState;            /*IBP盘发车按钮状态(动态字段)*/
+	UINT32 IBPPressCycNum;			/*IBP按下起始周期*/
 } PsdDataStruct;
 
+/*屏蔽门数据结构体*/
+typedef struct S_PsdDataStructCC
+{
+	UINT16 PsdId;     /*屏蔽门ID (初始化字段)*/
+	UINT16 psdEditGroupInfo;  /*屏蔽门编组信息CC(0-默认值，3-三编组，4-四编组，6-六编组，8-八编组)*/
+	UINT16 SrcVobcId;  /*操作该屏蔽门的当前VOBC编号CC*/
+	UINT8 PsdCmd;  /*操作屏蔽门的命令CC(0x00-默认值，0x55-打开PSD命令，0xAA-关闭PSD命令，0xFF-查询PSD命令)*/
+	UINT32 CmdSetCycle;/*命令设置周期CC*/
+} PsdDataStructCC;
+
 extern PsdDataStruct PsdDataStru[PSD_SUM_MAX];   /*定义屏蔽门数据结构体*/
+extern PsdDataStructCC PsdDataStruCC[PSD_SUM_MAX];   /*定义车车屏蔽门数据结构体*/
 
 /*
 * 功能描述： 设置PSD的VOBC操作命令
@@ -169,6 +187,13 @@ void ResetPsdData(const UINT16 psdId);
 */
 PsdDataStruct *GetPsdData(void);
 
+/*
+* 功能描述：获取指定ID屏蔽门数据CC
+* 参数说明：无
+* 返 回 值：车车屏蔽门动态数据
+*/
+PsdDataStructCC* GetPsdDataCC(void);
+
 /*
 * 功能描述： 获取指定ID屏蔽门互锁解除状态
 * 参数说明： const UINT16 doorId, 屏蔽门ID    
@@ -387,6 +412,23 @@ void SetStopDetectionState(const UINT16 doorId, const UINT32 detectionState);
 */
 UINT8 GetStopDetectionState(const UINT16 doorId);
 
+/*
+* 功能描述：设置指定PSD停止探测周期号
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*            const UINT32 startCycNum, 起始周期号
+* 返回值  ： 无
+*            
+*/
+void SetStopDetectionCycNum(const UINT16 doorId, const UINT32 startCycNum);
+
+/*
+* 功能描述： 获取停止探测起始周期号
+* 参数说明： const UINT16 doorId, 进路ID
+* 返回值  ： 0: 获取数据失败
+*           >0: 起始周期号
+*/
+UINT32 GetStopDetectionCycNum(const UINT16 doorId);
+
 /*
 * 功能描述： 获取指定ID屏蔽门开门按钮状态
 * 参数说明： const UINT16 doorId, 屏蔽门ID    
@@ -883,22 +925,22 @@ void SetPsdVideoQkRelateVobcId(const UINT16 wPsdId, const UINT16 wVobcId);
 UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId);
 
 /*
-* 功能描述：设置指定ID屏蔽门异常打开状态
+* 功能描述：设置指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-*			const UINT8 cExceptOpenState 屏蔽门异常打开状态
+*			const UINT8 cExceptOpenState 屏蔽门异常状态
 * 返 回 值：无
 * Created By LQ 2025.05.22
 */
-void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState);
+void SetPsdExceptState(const UINT16 wPsdId, const UINT8 cExceptOpenState);
 
 /*
-* 功能描述：获取指定ID屏蔽门异常打开状态
+* 功能描述：获取指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-* 返 回 值：0x55 异常打开
-*           0xAA 未异常打开
+* 返 回 值：0x55 异常（曾异常打开未解除）
+*           0xAA 未异常
 * Created By LQ 2025.05.22
 */
-UINT8 GePsdExceptOpenState(const UINT16 wPsdId);
+UINT8 GePsdExceptState(const UINT16 wPsdId);
 
 /*
 * 功能描述： 设置指定ID屏蔽门故障隔离信息
@@ -1002,6 +1044,147 @@ UINT32 GetPsdRelayDownCycNum(const UINT16 doorId);
 */
 void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum);
 
+/*
+* 功能描述：获取指定ID屏蔽门编组信息CC
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值：0 无编组信息
+*			3 三编组
+*           4 四编组
+*           6 六编组
+*           8 八编组
+* Created By LQ 2025.11.05
+*/
+UINT16 GetPsdEditGroupInfoDataCC(const UINT16 doorId);
+
+/*
+* 功能描述：设置指定ID屏蔽门编组信息CC
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
+* 返 回 值：无
+* Created By LQ 2025.11.05
+*/
+void SetPsdEditGroupInfoDataCC(const UINT16 doorId, const UINT16 wPsdEditGroupInfo);
+
+/*
+* 功能描述：获取PSD的VOBC控制命令CC
+* 参数说明：const UINT16 doorId,屏蔽门ID
+* 返 回 值：0x00-默认值
+*           0x55-打开PSD命令
+*           0xAA-关闭PSD命令
+*           0xFF-查询PSD命令
+* Created By LQ 2025.11.05
+*/
+UINT8 GetPsdVobcCmdCC(const UINT16 doorId);
+
+/*
+* 功能描述： 获取当前控制该PSD的VOBC的编号CC
+* 参数说明： const UINT16 doorId,屏蔽门ID
+* 返 回 值： VOBC ID
+* Created By LQ 2025.11.05
+*/
+UINT16 GetPsdVobcIdCC(const UINT16 doorId);
+
+/*
+* 功能描述：获得该PSD的控制命令的设置周期CC
+* 参数说明：const UINT16 doorId,屏蔽门ID
+* 返 回 值：该PSD的控制命令的设置周期
+* Created By LQ 2025.11.05
+*/
+UINT32 GetPsdCmdSetCycleCC(const UINT16 doorId);
+
+/*
+* 功能描述：设置PSD的VOBC操作命令CC
+* 参数说明：const UINT16 doorId 屏蔽门ID
+*			const UINT16 vobcId 操作屏蔽门的VOBC ID
+*			const UINT8 operCmd 来自VOBC的开关门命令
+*			const UINT32 dwCycNum 周期号
+* 返 回 值：无
+* Created By LQ 2025.11.05
+*/
+void SetPsdVobcCmdCC(const UINT16 doorId, const UINT16 vobcId, const UINT8 operCmd, const UINT32 dwCycNum);
+
+/*
+* 功能描述：获取指定ID屏蔽门编组信息CC
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值：0 无编组信息
+*			3 三编组
+*           4 四编组
+*           6 六编组
+*           8 八编组
+*/
+UINT16 GetPsdEditGroupInfoData(const UINT16 doorId);
+/*
+* 功能描述：设置指定ID屏蔽门编组信息
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
+* 返 回 值：无
+*/
+void SetPsdEditGroupInfoData(const UINT16 doorId, const UINT16 wPsdEditGroupInfo);
+/*
+* 功能描述：获取指定ID屏蔽门间隙探测互锁解除故障状态
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值： 0 返回失败
+*           0< 间隙探测互锁解除故障状态
+*/
+UINT8 GetPsdJXTCMutualLockFaultState(const UINT16 doorId);
+/*
+* 功能描述：设置指定ID屏蔽门间隙探测互锁解除故障状态
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT8 wJXTCMutualLockFaultState 间隙探测互锁解除故障状态
+* 返 回 值：无
+*/
+void SetPsdJXTCMutualLockFaultState(const UINT16 doorId, const UINT8 wJXTCMutualLockFaultState);
+/*
+* 功能描述：获取指定ID屏蔽门间隙探测互锁解除时间
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+* 返 回 值： 0 返回失败
+*           0< 屏蔽门间隙探测互锁解除时间
+*/
+UINT32 GetPsdJXTCMutualLockStartCycNum(const UINT16 doorId);
+/*
+* 功能描述：设置指定ID屏蔽门间隙探测互锁解除起始时间
+* 参数说明：const UINT16 doorId, 屏蔽门ID
+*           const UINT32 cycnum 互锁解除起始时间
+* 返 回 值：无
+*/
+void SetPsdJXTCMutualLockStartCycNum(const UINT16 doorId, const UINT32 cycnum);
+
+/*
+* 功能描述： 设置指定ID屏蔽门IBP盘发车按钮状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*            UINT8 setFlag  需设置的按钮状态
+* 返回值  ： PSD_BUTTON_PANGLU_STATE_VALID    0x55  有效
+*            PSD_BUTTON_PANGLU_STATE_INVALID  0xaa  无效
+*/
+UINT8 SetPsdButtonIbpState(const UINT16 doorId, const UINT8 setFlag);
+/*
+* 功能描述： 获取指定ID屏蔽门IBP按下起始周期号
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ： 0: 获取数据失败
+*           >0: 起始周期号
+*/
+UINT32 GetIBPPressCycNum(const UINT16 doorId);
+/*
+* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ：0: 获取数据失败
+*			>0: IBP盘发车按钮状态
+*/
+UINT8 GetPsdButtonIbpState(const UINT16 doorId);
+/*
+* 功能描述：设置指定ID屏蔽门IBP按下起始周期号
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*            const UINT32 startCycNum, 起始周期号
+* 返回值  ： 0: 设置数据失败
+*           >0: 设置数据成功
+*/
+UINT8 SetIBPPressCycNum(const UINT16 doorId, const UINT32 startCycNum);
+/*
+* 功能描述： 获取指定ID屏蔽门状态给 VOBC
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ：屏蔽门状态
+*/
+UINT8 GetPsdStateToVobc(const UINT16 doorId);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/PSD/PSDDefine.h

@@ -17,7 +17,7 @@
 
 
 /*屏蔽门总数最大值*/
-#define PSD_SUM_MAX                        ((UINT16)90U)     /*定义屏蔽门数量最大值*/
+#define PSD_SUM_MAX                        ((UINT16)150U)     /*定义屏蔽门数量最大值*/
 
 /*和屏蔽门关联的出站进路数目最大值*/
 #define RALATED_OUT_STATION_ROUTE_SUM_MAX  ((UINT16)10U)     /*屏蔽门关联的出站进路数目最大值*/
@@ -92,9 +92,11 @@
 #define PSD_SIX_EDIT_GROUP_FAO_YF                ((UINT8)0x02U)            /*六编组*/
 
 /*屏蔽门编组信息定义*/
-#define PSD_FOUR_EDIT_GROUP               ((UINT8)0x04U)            /*四编组*/
-#define PSD_SIX_EDIT_GROUP                ((UINT8)0x06U)            /*六编组*/
-#define PSD_EIGHT_EDIT_GROUP              ((UINT8)0x08U)            /*八编组*/
+#define PSD_EDIT_GROUP_DEFAULT            ((UINT16)0x00U)            /*默认值*/
+#define PSD_THREE_EDIT_GROUP              ((UINT16)0x03U)            /*三编组*/
+#define PSD_FOUR_EDIT_GROUP               ((UINT16)0x04U)            /*四编组*/
+#define PSD_SIX_EDIT_GROUP                ((UINT16)0x06U)            /*六编组*/
+#define PSD_EIGHT_EDIT_GROUP              ((UINT16)0x08U)            /*八编组*/
 
 /*办理出来的出站进路信号关闭是否在屏蔽门打开之前的标志*/
 #define PSD_OPEN_BEFORE_SIG_CLOSE_YES     ((UINT8)0xaaU)     /*屏蔽门打开之前信号关闭*/
@@ -133,6 +135,7 @@
 #define PLATFORM_DEPAR_BUTTON_STATE_VALID              ((UINT8)0x55U)   /*有效*/
 #define PLATFORM_DEPAR_BUTTON_STATE_INVALID			   ((UINT8)0xaaU)   /*无效*/
 #define PLATFORM_DEPAR_BUTTON_NO		               ((UINT8)0xccU)   /*无站台发车按钮*/
+#define PLATFORM_DEPAR_BUTTON_STATE_FAULT	           ((UINT8)0xffU)   /*站台发车按钮故障（IBP）*/
 
 /*站台按钮旁路状态*/
 #define PSD_BUTTON_PANGLU_STATE_VALID              ((UINT8)0x55U)   /*有效*/
@@ -195,9 +198,13 @@
 #define VIDEO_QK_DRIVE_STATE_TESTING  ((UINT8)0xccU)  /*视频清客驱动状态—检测中*/
 #define VIDEO_QK_DRIVE_STATE_INVALID  ((UINT8)0xffU)  /*视频清客驱动状态—无效*/
 
-/*屏蔽门异常打开状态*/
-#define PSD_EXCEPT_OPEN_NO            ((UINT8)0xAAU)   /*未异常打开*/
-#define PSD_EXCEPT_OPEN_YES           ((UINT8)0x55U)   /*异常打开*/
+/*屏蔽门异常状态*/
+#define PSD_EXCEPT_NO            ((UINT8)0xAAU)   /*未异常*/
+#define PSD_EXCEPT_YES           ((UINT8)0x55U)   /*异常(曾异常打开未取消)*/
+
+/*屏蔽门异常取消方式*/
+#define PSD_EXCEPT_CANCLE_ATS            ((UINT8)0xAAU)   /*ATS命令取消*/
+#define PSD_EXCEPT_CANCLE_RCI            ((UINT8)0x55U)   /*未异常打开时联锁自动取消异常*/
 
 /*OC-P旁路状态确认*/
 #define OC_PSC_PL_CONFIRM_YES  ((UINT8)0xaaU)  /*OC-P旁路状态已确认*/
@@ -207,4 +214,18 @@
 #define HIGH_FOUR_CHAR			((UINT8)0U)		/*高四字节*/
 #define LOW_FOUR_CHAR			((UINT8)1U)		/*低四字节*/
 
+
+/*间隙探测互锁解除故障状态*/
+#define JXTC_MUTUALLOCKFAULT_YES		((UINT8)0x55U)		/*间隙探测互锁解除按钮故障*/
+#define JXTC_MUTUALLOCKFAULT_NO			((UINT8)0xaaU)		/*间隙探测互锁解除按钮未故障*/
+#define JXTC_MUTUALLOCKFAULT_NOCHECK	((UINT8)0xFFU)		/*间隙探测互锁解除按钮未检测*/
+
+
+#define PSD_INCLUDE_ESB_NUM			((UINT8)10U)		/*ESB个数*/
+
+/*CI-VOBC屏蔽门状态*/
+#define CI_IVOC_PSD_STATE_CLOSE			((UINT8)0xAAU)		  /*CI到IVOC屏蔽门关闭*/
+#define CI_IVOC_PSD_STATE_OPEN			((UINT8)0x55U)		  /*CI到IVOC屏蔽门打开*/
+#define CI_IVOC_PSD_STATE_PANGLU		((UINT8)0xCCU)		  /*CI到IVOC屏蔽门互锁解除*/
+#define CI_IVOC_PSD_STATE_OPEN_EXCEPT	((UINT8)0x33U)		  /*CI到IVOC屏蔽门异常打开*/
 #endif

TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h

@@ -107,7 +107,7 @@
 #define ATS_CMD_SECTION_FENGSUO_CANCEL                  ((UINT8)0x61)        /*区段解封*/
 #define ATS_CMD_PHYSEC_PRE_RESET_ONE					((UINT8)0x62)        /*计轴预复位一次*/
 #define ATS_CMD_PHYSEC_PRE_RESET_TWO					((UINT8)0x63)        /*计轴预复位二次*/
-#define ATS_CMD_CANCEL_XICHE							((UINT8)0x64)        /*现地取消洗车命令*/
+#define ATS_CMD_CANCEL_XICHE							((UINT8)0x64)        /*取消降级模式洗车命令*/
 #define ATS_CMD_PHYSEC_GENERAL_RESET_SET                ((UINT8)0x65)        /*计轴总复位命令*/
 #define ATS_CMD_PHYSEC_GENERAL_RESET_CANCEL  			((UINT8)0x66)        /*取消计轴总复位命令*/
 #define	ATS_CMD_CICI_NET_TO_RELAY_ONE					((UINT8)0x68)			/*联锁与联锁网络接口转继电接口一次命令*/
@@ -118,7 +118,6 @@
 #define ATS_CMD_QUXIAO_PSC_PL_TWO                       ((UINT8)0x73)         /*取消PSC旁路二次命令*/
 #define ATS_CMD_ROUTE_GROUP_AUTO_SET                    ((UINT8)0x74)         /*办理组合自动进路命令*/
 #define ATS_CMD_ROUTE_GROUP_AUTO_CANCLE                 ((UINT8)0x75)         /*取消组合自动进路命令*/
-
 #define ATS_CMD_SIGNALMAINTAINSTATE_ONE                  ((UINT8)0x76)          /*信号机维修点灯一次*/
 #define ATS_CMD_SIGNALMAINTAINSTATE_TWO                  ((UINT8)0x77)          /*信号机维修点灯二次*/
 #define ATS_CMD_CANCEL_SIG_MAINTAIN_ONE                  ((UINT8)0x78)     /*取消信号机维修点灯一次*/       
@@ -127,17 +126,12 @@
 #define ATS_CMD_CANCEL_SW_ALARM_TWO                      ((UINT8)0x7b)           /*取消转辙机封连报警二次命令*/
 #define ATS_CMD_RECOVER_SW_ALARM_ONE            ((UINT8)0x7c)          /*恢复转辙机封连报警一次命令*/
 #define ATS_CMD_RECOVER_SW_ALARM_TWO            ((UINT8)0x7d)          /*恢复转辙机封连报警二次命令*/
-
 #define LABOR_CMD_CANCEL_OVERLAP_ONE					     ((UINT8)0x7e)		/* 人工取消保护区段一次命令 */
 #define LABOR_CMD_CANCEL_OVERLAP_TWO					     ((UINT8)0x7f)		/* 人工取消保护区段二次命令 */
 #define LABOR_CMD_SET_UP_OVERLAP					     ((UINT8)0x80)		/* 人工建立保护区段命令,合代码暂时改成80 */
-
 #define ATS_CMD_ROUTE_APPLY								 ((UINT8)0x92)			/*申请路径*/
 #define ATS_CMD_ROUTE_APPLY_CANCLE					     ((UINT8)0x93)			/*取消申请路径*/
 #define ATS_CMD_ROUTE_PART_APPLY						 ((UINT8)0x94)			/*申请部分路径*/
-#define ATS_CMD_ROUTE_PART_APPLY_CANCEL					 ((UINT8)0x95)			/*取消申请部分路径*/
-#define ATS_CMD_AUTO_RETURN_SET_ONE						 ((UINT8)0x96)          /*自动折返一次有效命令*/
-#define ATS_CMD_AUTO_RETURN_CMD_CANCEL					 ((UINT8)0x97)			/*取消自动折返命令*/
 #define ATS_CMD_SET_PHYSEC_ERR							 ((UINT8)0x98)			/*物理区段故障占用设置命令*/
 #define ATS_CMD_CANCEL_PHYSEC_FIRST						 ((UINT8)0x99)			/*物理区段故障占用取消一次命令*/
 #define ATS_CMD_CANCEL_PHYSEC_SECOND					 ((UINT8)0x9a)			/*物理区段故障占用取消二次命令*/
@@ -146,25 +140,30 @@
 #define ATS_CMD_OPEN_XIANSU_SIGNAL_FIRST				 ((UINT8)0x9d)			/*开放限速信号一次*/
 #define ATS_CMD_OPEN_XIANSU_SIGNAL_SECOND				 ((UINT8)0x9e)			/*开放限速信号二次*/
 #define ATS_CMD_OPEN_XIANSU_SIGNAL_SPECIAL				 ((UINT8)0xa6)			/*限速信号特殊开放*/
-
 #define ATS_CMD_OC_P_PL_ONE                              ((UINT8)0xa8)         /*设置OC-P旁路一次命令*/
 #define ATS_CMD_OC_P_PL_TWO                              ((UINT8)0xa9)         /*设置OC-P旁路二次命令*/
 #define ATS_CMD_QUXIAO_OC_P_PL_ONE                       ((UINT8)0xaa)         /*取消OC-P旁路一次命令*/
 #define ATS_CMD_QUXIAO_OC_P_PL_TWO                       ((UINT8)0xab)         /*取消OC-P旁路二次命令*/
-
 #define ATS_CMD_GET_CTRL_POWER  						 ((UINT8)0x81)		/* 获取联锁控制权*/
 #define ATS_CMD_RELEASE_CTRL_POWER  					 ((UINT8)0x82)		/* 释放联锁控制权*/
-
 #define ATS_CMD_ROUTE_AUTO_TRIGGER_SET						(UINT8)0x83		/*单个进路自动触发进路办理 */
 #define ATS_CMD_ROUTE_CANCLE_AUTO_TRIGGER					(UINT8)0x84		/*单个进路取消自动触发进路 */
 #define ATS_CMD_SWITCH_DINGWEI_TEST_ONE  				 ((UINT8)0x85)		/* 道岔定位测试一次命令*/
 #define ATS_CMD_SWITCH_DINGWEI_TEST_TWO  				 ((UINT8)0x86)		/* 道岔定位测试二次命令*/
 #define ATS_CMD_SWITCH_FANWEI_TEST_ONE  				 ((UINT8)0x87)		/* 道岔反位测试一次命令*/
 #define ATS_CMD_SWITCH_FANWEI_TEST_TWO  				 ((UINT8)0x88)		/*道岔反位测试二次命令*/
-
 #define SCX_ATS_CMD_ESS_GO_POSITION 						(UINT8)0x89		/*ESS去位命令*/
 #define SCX_ATS_CMD_ESS_STOP_POSITION							(UINT8)0x90		/*ESS停位命令*/
 #define ATS_CMD_STATION_QK_SET					            (UINT8)0x91		/*站台清客标志设置 */
+#define ATS_CMD_EMERG_XS_SET_ONE							(UINT8)0xAC		/*设置紧急临时限速一次命令 */
+#define ATS_CMD_EMERG_XS_SET_TWO							(UINT8)0xAD		/*设置紧急临时限速二次命令 */
+#define ATS_CMD_EMERG_XS_CANCEL_ONE							(UINT8)0xAE		/*取消紧急临时限速一次命令 */
+#define ATS_CMD_EMERG_XS_CANCEL_TWO							(UINT8)0xAF		/*取消紧急临时限速二次命令 */
+#define ATS_CMD_COUPLING_ROUTE_SET							(UINT8)0xB0		/*联挂进路办理 */
+#define ATS_CMD_APPLY_XICHE                             ((UINT8)0xB1)         /*降级模式洗车请求*/
+#define ATS_CMD_APPLY_PASSXICHE                         ((UINT8)0xB2)         /*现地请求反向洗车命令-降级模式*/
+#define ATS_CMD_CANCEL_PASSXICHE                        ((UINT8)0xB3)         /*现地取消反向洗车命令-降级模式*/
+#define ATS_CMD_CANCEL_PSD_EXCEPT                        ((UINT8)0xBA)         /*现地取消站台门异常状态*/
 
 /****联锁到其他联锁的命令宏定义****/
 #define CI_CMD_PHYSEC_USING_APPLY				((UINT16)0x0001)        /*物理区段征用申请*/
@@ -237,7 +236,7 @@
 #define  CI_BACK_ROUTE_LOCK_NOTALL         ((UINT8)0x06)        /*进路不完整锁闭?新增?*/
 
 #define  CI_BACK_ROUTE_LEVEL_CBTC          ((UINT8)0x08)        /*进路监督级别不为点式?未使用?*/
-#define  CI_BACK_ROUTE_LEVEL_BLOC          ((UINT8)0x00)        /*进路监督级别不为CBTC?未使用?*/
+#define  CI_BACK_ROUTE_LEVEL_BLOC          ((UINT8)0xBA)        /*进路监督级别不为CBTC*/
 #define  CI_BACK_ROUTE_TYPE_ERROR          ((UINT8)0x00)        /*进路类型异常?未使用?*/
 #define  CI_BACK_ROUTE_STATE_ERROR         ((UINT8)0x59)        /*进路建立条件不满足*/
 #define  CI_BACK_RETURN_ROUTE_STATE_ERROR  ((UINT8)0x5A)        /*折返进路不允许追踪办理*/
@@ -249,6 +248,7 @@
 
 #define  CI_BACK_AUTO_TRIGGER_SET_ERR  (UINT8)0x85         /*进路的自动触发标志设置失败*/
 #define  CI_BACK_LEAD_ROUTE_CANCEL         ((UINT8)0xA4)	/*引导进路无法使用总取消解锁反馈*/
+#define  CI_BACK_COUPLINK_ROUTE_IDLE       ((UINT8)0xAF)	/*联挂进路内无被联挂车*/
 
 /*信号机故障反馈*/
 #define  CI_BACK_SIG_START_OPEN            ((UINT8)0x11)        /*进路始端信号机开放*/
@@ -289,6 +289,7 @@
 #define  CI_BACK_PSEC_RESET_IN_CT          ((UINT8)0x58)        /*计轴复位中CT占用*/
 #define  UNLOCK_OVELAP_CANNOT          (UINT8)0x80        /*解锁保护区段条件不满足*/
 #define  LOCK_OVELAP_OUT_CANNOT           (UINT8)0x81        /*保护区段锁闭条件不满足*/
+#define  CI_BACK_PSEC_RESET_ING          ((UINT8)0xAE)        /*物理区段正在计轴复位*/
 
 /*道岔故障反馈*/
 #define  CI_BACK_SWT_YLOCK_YES             ((UINT8)0x31)        /*道岔引导总锁*/
@@ -337,6 +338,14 @@
 #define CI_BACK_OTHER_ROUTE_NOT_OPEN	        ((UINT8)0x9D)	/*进路其他联锁条件需开放进路未开放*/
 #define CI_BACK_WASH_PASS_ALLOW_NOT	            ((UINT8)0x9E)	/*洗车库/线未同意通过*/
 
+#define CI_BACK_WASH_APPLY_NOT					((UINT8)0xB3)   /*洗车机洗车请求有效，请勿重复操作*/
+#define CI_BACK_WASH_PASSAPPLY_NOT				((UINT8)0xB4)   /*洗车机反向通过请求有效，请勿重复操作*/
+#define CI_BACK_ROUTE_IDLE_NOT				    ((UINT8)0xB5)   /*进路未空闲，请先取消进路*/
+#define CI_BACK_WASH_BUTTON_PRESS_NOT		    ((UINT8)0xB6)   /*洗车同意按钮未按下，不需要取消*/
+#define CI_BACK_WASH_PASSBUTTON_PRESS_NOT		((UINT8)0xB7)   /*洗车反向通过同意按钮未按下，不需要取消*/
+#define CI_BACK_WASH_APPLY_BUTTON_NOT		    ((UINT8)0xB8)   /*洗车机XXX洗车同意按钮在规定时间内未按下，洗车请求失效*/
+#define CI_BACK_WASH_PASS_BUTTON_NOT		    ((UINT8)0xB9)   /*洗车机XXX反向同意按钮在规定时间内未按下，反向通过请求失效*/
+
 /* 设置与取消物理区段故障列车占用反馈 */
 #define CI_BACK_SPE_TRAIN_DIR_ERR				((UINT8)0x86)	/*设置物理区段故障车占用：与已存在的故障车方向不一致*/
 #define CI_BACK_SPE_LOOK_DIR_ERR				((UINT8)0x87)	/*设置物理区段故障车占用：与物理区段锁闭方向不一致*/
@@ -448,15 +457,17 @@
 
 #define  CI_BACK_AUTO_ROUTE_HAVE_BLOCK					((UINT8)0x95)        /*自动通过进路自动进路存在封锁*/
 #define  CI_BACK_AUTO_ROUTE_FLOOD_STATE_ERR             ((UINT8)0x96)        /*自动通过进路存在防淹门不满足*/
+#define  CI_BACK_AUTO_ROUTE_COUPROUTE_SET               ((UINT8)0xB0)		 /*自动通过联挂进路已办理*/
+
 
 
 #define  CI_BACK_AUTO_RETURN_HAVE_BLOCK					((UINT8)0x98)        /*自动折返进路存在封锁*/
 #define  CI_BACK_AUTO_RETURN_FLOOD_STATE_ERR            ((UINT8)0x99)        /*自动折返进路存在防淹门不满足*/
-
+#define  CI_BACK_AUTO_RETURN_COUPROUTE_SET              ((UINT8)0xB1)		 /*自动折返联挂进路已办理*/
 
 #define  CI_BACK_ALLAUTO_RETURN_HAVE_BLOCK				((UINT8)0x9B)        /*全自动折返进路存在封锁*/
 #define  CI_BACK_ALLAUTO_RETURN_FLOOD_STATE_ERR         ((UINT8)0x9C)        /*全自动折返进路存在防淹门不满足*/
-
+#define  CI_BACK_ALLAUTO_RETURN_COUPROUTE_SET           ((UINT8)0xB2)		 /*全自动折返联挂进路已办理*/
 
 
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h

@@ -69,6 +69,17 @@
 #define OC_TO_ATS_SWITCH_ZZJ_NORMAL ((UINT8)0x55)	/*OC给ATS的多机牵引对应道岔状态-正常*/
 #define OC_TO_ATS_SWITCH_ZZJ_ALARM ((UINT8)0xAA)	/*OC给ATS的多机牵引对应道岔状态-故障*/
 
+#define ATS_CI_INTERFACE_INFOTYPE	     ((UINT16)0x0407U)		/*ATS-联锁接口类型*/
+#define RCI_ATS_INFO_TYPE_COMMON_STATE	 ((UINT16)0x0201U)		/*RCI->ATS通用状态信息，周期发送*/
+#define RCI_ATS_INFO_TYPE_STATION_STATE	 ((UINT16)0x0202U)		/*RCI->ATS站场状态信息，间隔1周期发送*/
+#define RCI_ATS_INFO_TYPE_DEVICE_STATE	 ((UINT16)0x0203U)		/*RCI->ATS设备状态信息，间隔1周期发送*/
+#define ATS_CI_INFO_TYPE_HEART_STATE	 ((UINT16)0x0204U)		/*ATS->CI心跳状态信息，周期发送*/
+#define ATS_CI_INFO_TYPE_CMD_CONTROL	 ((UINT16)0x0205U)		/*ATS->CI命令控制信息，ATS触发发送*/
+
+#define SHOW_2OO2_STATE_MAIN     ((UINT8)0x55U)    /*显示主备系状态-主系*/
+#define SHOW_2OO2_STATE_BACKUP   ((UINT8)0xaaU)    /*显示主备系状态-备系*/
+#define SHOW_2OO2_STATE_UNKNOW   ((UINT8)0xFFU)    /*显示主备系状态-未知*/
+
 /*执行电插箱相关信息*/
 typedef struct s_PlusBoxDataSendATS
 {
@@ -106,6 +117,14 @@ typedef struct s_SwitchZzjDataSendATS
 	UINT8 szSwitchIncldeZzjState[MAX_OC_SWITCH_INCLUDE_ZZJ_NUM]; /*给ATS组包的道岔对应转辙机状态*/
 }OcToATSSwitchZzjData;
 
+/*最近一次收到ATS命令数据的周期号信息*/
+typedef struct s_ReciveAtsCmdDataCycInfo
+{
+	UINT8 chDeviceType;	/*设备类型*/
+	UINT8 chDeviceId;	/*设备ID*/
+	UINT32 dwReciveCmdDataAtsCycNum; /*收到ATS命令数据时ATS周期号*/
+}ReciveAtsCmdDataCycInfo;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -121,26 +140,32 @@ extern CommandDataStruct CiSendBackDataTempStru[CI_TO_ATSORXIANDI_CMD_DATA_STRU_
 extern UINT16 CiSendBackDataTempStruSum;
 extern UINT8 LastCmdSourceSysType;
 extern UINT32 FirstCmdId;      /*首次操作确认的命令ID号*/
+extern ReciveAtsCmdDataCycInfo szReciveAtsCmdDataCycInfo[ATS_SUM_MAX * 2U]; /*收到ATS命令数据周期号信息数组*/
+extern UINT16 gReciveAtsCmdDataDeviceSum; /*收到ATS命令数据设备数目*/
 
 /*
 * 功能描述： 解析操作命令数据帧
 * 参数说明： const UINT8* dataBuf, 数据缓冲区
 *            const UINT16 dataLength, 数据长度
+*	         const UINT8 chDevType 设备类型
+*            const UINT8 chDeciveId 设备ID
 * 返回值  ： 0: 数据解析失败
 *			 1: 数据解析成功
+* edit by cgh 20251104
 */
-UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength);
+UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 chDevType, const UINT8 chDeciveId);
 
 /*
 * 功能描述： 组ATS或现地数据
-* 参数说明： 
+* 参数说明： QueueStruct* ciToAtsDataQueue, 组包发送队列地址
 *            const UINT8 deviceId, 目标系统ID
 *            const UINT8 targetDevType, 目标系统类型
 *            const UINT8 frame,帧类型
+*            UINT8* chSendXiandiorAtsBuf 码位数据数组首地址
 * 返回值  ： 0: 组包失败
 *			 1: 组包成功
 */
-UINT8 PackCiToAtsOrXianDiData( const UINT8 deviceId, const UINT8 targetDevType,const UINT8 frame);
+UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, const UINT8 frame, UINT8* chSendXiandiorAtsBuf);
 
 /*
 * 功能描述： 获取CI接收的操作命令结构体数组长度
@@ -408,6 +433,102 @@ UINT8 GetOcPscConfirmFlag(UINT8 index);
 */
 void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
 
+/*
+* 功能描述：向ATS组相邻RC/CI的通信状态（双系统使用）
+* 参数说明：UINT8* ciToXianDiDataBuffer 存放信息的buffer（出参）
+*			UINT16* ii 偏移量（出参）
+* 返 回 值：无
+* Created By LQ 2026.01.05
+*/
+void PackNearRciCommStateToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
+
+/*
+* 功能描述：向ATS组通信表示灯（双系统使用）
+* 参数说明：UINT8* ciToXianDiDataBuffer 存放信息的buffer（出参）
+*			UINT16* ii 偏移量（出参）
+* 返 回 值：无
+* Created By LQ 2026.01.05
+*/
+void PackCommIndicatorToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
+
+/*
+* 功能描述：检查指定类型表示灯是否需要向ATS组包（双系统使用）
+* 参数说明：UINT8 cIndicatorType 表示灯类型
+* 返 回 值：0 不需要组包
+*           1 需要组包
+* Created By LQ 2026.01.05
+*/
+UINT8 AtsIndicatorPackCheck(UINT8 cIndicatorType);
+
+/**
+* @brief RC/CI设备通用状态处理
+* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
+* @param[in] UINT16* ii  CI组包给ATS或现地的数据索引
+* @return 无
+* @note by cgh 20251103
+*/
+void RcOrCiDeciveCommonStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* ii);
+
+/**
+* @brief 发送ATS通用设备状态处理
+* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
+* @param[in] UINT16* wDataIndex  CI组包给ATS或现地的数据索引
+* @param[in] const UINT8 chDeviceId, 目标系统ID
+* @param[in] const UINT8 chTargetDevType, 目标系统类型
+* @return 无
+* @note by cgh 20251103
+*/
+void SendAtsCommonDeviceStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* wDataIndex, const UINT8 chDeviceId, const UINT8 chTargetDevType);
+
+/**
+* @brief 发送ATS通用站场状态处理
+* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
+* @param[in] UINT16* wDataIndex  CI组包给ATS或现地的数据索引
+* @param[in] const UINT8 chDeviceId, 目标系统ID
+* @param[in] const UINT8 chTargetDevType, 目标系统类型
+* @param[in] UINT8* chSendXiandiorAtsBuf 码位数据数组首地址
+* @return 无
+* @note by cgh 20251103
+*/
+void SendAtsCommonStationStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* wDataIndex, const UINT8 chDeviceId, const UINT8 chTargetDevType, UINT8* chSendXiandiorAtsBuf);
+
+/**
+* @brief 收到ATS命令处理
+* @param[in] const UINT8* dataBuf, 数据缓冲区
+* @param[in]  UINT16* dataIndex, 数据索引
+* @param[in]  const UINT16 dataLength, 数据长度
+* @return CI_ERROR 失败   CI_SUCCESS 成功
+* @note by cgh 20251104
+*/
+UINT8 ReciveAtsCmdDeal(const UINT8* dataBuf, UINT16* dataIndex, const UINT16 wDataLength);
+
+/**
+* @brief 更新ATS命令数据周期号信息
+* @param[in] UINT8 chDeviceType 设备类型
+* @param[in] UINT8 chDeviceId 设备ID
+* @return 无
+* @note by cgh 20251105
+*/
+void UpdateAtsCmdDataCycInfo(UINT8 chDeviceType, UINT8 chDeviceId);
+
+/**
+* @brief 获取收到ATS命令数据时ATS周期号
+* @param[in] UINT8 chDeviceType 设备类型
+* @param[in] UINT8 chDeviceId 设备ID
+* @return UINT32 收到ATS命令数据时ATS周期号
+* @note by cgh 20251105
+*/
+UINT32 GetReciveCmdDataAtsCycNum(UINT8 chDeviceType, UINT8 chDeviceId);
+
+/**
+* @brief 组包RC/CI设备通用状态信息
+* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
+* @param[in] UINT16* ii  CI组包给ATS或现地的数据索引
+* @return 无
+* @note by cgh 20251111
+*/
+void PackRcOrCiDeciveCommonState(UINT8* ciToXianDiDataBuffer, UINT16* ii);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackAxleData.c

@@ -124,7 +124,7 @@ UINT8 InitAxleToCiDataStru(void)
 	UINT8 deviceSum = 0u;               /*设备总数*/
 	UINT8* deviceIdBuf = NULL;         /*设备ID数组*/
 	UINT8 i = 0u; /*用于循环*/
-	UINT8 j = 0u; /*用于循环*/
+	UINT16 j = 0u; /*用于循环*/
 	UINT8 ciId = 0u; /*本CI ID*/
 	UINT8 axleId = 0u; /*计轴ID*/
 	UINT16 axleName = 0u; /*计轴设备名称：类型+ID*/
@@ -137,14 +137,18 @@ UINT8 InitAxleToCiDataStru(void)
 	UINT8 belongAxleSysId = 0u; /*物理区段所属计轴ID*/
 	UINT16 axlePhySecSum = 0u; /*计轴系统包含物理区段数目*/
 	UINT8 pyhIsThisLine = 0u;
+	UINT8 chAxisLogId = 0U;
 
 	ciId = GetSystemParaLocalCiId();
-	ciName = (CI_SYSTEM_TYPE_CI) * 256U + ciId;
-	rtn = DsuRsspInitWl((const)DataPath,0,NULL,ciName, 0, &dsuRsspInfo);
+	ciName = (CI_SYSTEM_TYPE_RCI) * 256U + ciId;
+	rtn = DsuRsspInitWl((const)DataPath, 0, NULL, ciName, 0, &dsuRsspInfo);
+
 	if (CI_SUCCESS == rtn)
 	{
 		deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备总数*/
 		deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备ID数组*/
+		chAxisLogId = GetAxisLogId();
+
 		if ((deviceSum > 0u) && (deviceIdBuf != NULL))
 		{
 			phySecCurSum = GetPhySecCurSum();
@@ -153,21 +157,26 @@ UINT8 InitAxleToCiDataStru(void)
 				axleId = deviceIdBuf[i];
 				axleName = (CI_SYSTEM_TYPE_AXIS) * 256u + axleId;
 
-				rtn = dquDevName2HlhtId(axleName, 0U, &axieEtcsId);  /*获取计轴互联互通ID*/
-				rtn &= dquDevName2HlhtId(ciName, 0U, &ciEtcsId);  /*获取CI互联互通ID*/
+				rtn = dquDevName2HlhtId(axleName, chAxisLogId, &axieEtcsId);  /*获取计轴互联互通ID*/
+
+				rtn &= dquDevName2HlhtId(ciName, 0U, &ciEtcsId);  /*获取联锁互联互通ID*/
 
 				if (CI_SUCCESS == rtn) /*GAL层互联互通ID获取成功*/
 				{
-					if (axleId >= AXIS_TO_CI_SUM_MAX)
+					if ((UINT16)axleId >= AXIS_TO_CI_SUM_MAX)
 					{
+						rtn = CI_ERROR;
 						break;/*防护代码，防止越界*/
 					}
+					else
+					{
 						axisToCiDataStru[axleId].deviceType = CI_SYSTEM_TYPE_AXIS;
 						axisToCiDataStru[axleId].axisSystemId = deviceIdBuf[i];
 						axisToCiDataStru[axleId].axisEtcsId = axieEtcsId;
 						axisToCiDataStru[axleId].ciEtcsId = ciEtcsId;
 
-					(void)memset(axisToCiDataStru[axleId].PhySecIdx, (INT)AXISDATASTR_IDX, PHYSICAL_SECTION_SUM_MAX); /*默认设置下标为无效位置*/
+						(void)CommonMemSet((void*)&axisToCiDataStru[axleId].PhySecIdx, (UINT32)sizeof(UINT8) * PHYSICAL_SECTION_SUM_MAX, AXISDATASTR_IDX, (UINT32)sizeof(UINT8) * PHYSICAL_SECTION_SUM_MAX);
+
 						for (j = 0u; j < phySecCurSum; j++) /*遍历物理区段*/
 						{
 							phySecId = GetPhySecId(j);
@@ -190,8 +199,10 @@ UINT8 InitAxleToCiDataStru(void)
 									axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chDirectResetRst = RELAY_STATE_DOWN;
 									axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chDirectResetBack = RELAY_STATE_UP;
 									axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].State = RELAY_STATE_DOWN;
+									axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chResetCmdTagBack = 0U;
 
 									axisToCiDataStru[axleId].PhySecIdx[phySecId] = (UINT8)(axlePhySecSum);
+									axisToCiDataStru[axleId].dwLastRecvDataCycNum = 0U;
 
 									axisToCiDataStru[axleId].SectionSum++;		
 								}
@@ -201,18 +212,37 @@ UINT8 InitAxleToCiDataStru(void)
 									break;
 								}
 							}
+							else
+							{
+								; /*不处理*/
 							}
 						}
 					}
 				}
 				else
 				{
-			rtn = CI_SUCCESS;
-		}
+					;
 				}
+
 				if (CI_ERROR == rtn)
 				{
-		debug_infor_printf((const)"InitAxleToCiDataStru fail.\r\n");
+					debug_infor_printf((const)"InitAxleToCiDataStru fail,dquDevName2HlhtId error\r\n");
+					break;
+				}
+				else
+				{
+					; /*继续初始化*/
+				}
+			}
+		}
+		else
+		{
+			;
+		}
+	}
+	else
+	{
+		debug_infor_printf((const)"InitAxleToCiDataStru fail,DsuRsspInitWl error\r\n");
 	}
 
 	return rtn;
@@ -251,6 +281,9 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 	UINT16 axisDevName = 0U; /*计轴名称：类型+ID*/
 	UINT16 wPhySecCurSum = 0U; /*本控区物理区段数目*/
 	UINT16 wIndexInAxle = 0U; /*物理区段的索引号*/
+	UINT8 chResetCmdTag = 0U; /*复位命令标签反馈*/
+	UINT8 chCurSystemAreaState = 0U; /*当前系统区域状态*/
+	UINT32 dwSystemUpdateMainUseCycNum = 0U; /*系统主用起始周期号*/
 
 	deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备总数*/
 	deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备ID数组*/
@@ -309,7 +342,7 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 		galPrtclVer = GetCiAndAxisPrtclCheckVer();   /*获取联锁与计轴系统协议版本号*/
 		galAxisDataVer = GetCiTranAxisDataCheckVer(localCiId, axisDevName); /*获取计轴系统数据版本号*/
 		headRet = GalHeadCheck(axisToCiDataStru[systemId].axisEtcsId, axisToCiDataStru[systemId].ciEtcsId, GAL_INTERFACE, galPrtclVer, galAxisDataVer, &hlhtGalHead, &errCode);
-		debug_infor_printf((const)"\nAXLE %d GAL Check Result:%d errCode:%d", systemId, headRet, errCode);	/*0x55正确，0xaa错误，0x33初始通信帧*/
+		debug_infor_printf((const)"\nAXLE %d GAL Check Result:%d errCode:%d\n", systemId, headRet, errCode);	/*0x55正确，0xaa错误，0x33初始通信帧*/
 
 		if (HLHT_HEAD_SUCCESS == headRet)
 		{
@@ -605,6 +638,101 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 						debug_infor_printf((const)"\nAxis phySecNum:%d ERROR,RC wPhySecCurSum::%d\n", phySecNum, wPhySecCurSum);
 					}				
 				}
+				else if (AXIS_TYPE_STANDARD_INTERFACE == acFty)
+				{
+					if (0XAAU == dataBuf[ii])
+					{
+						ii++; /*包类型*/
+						phySecNum = ShortFromChar(&dataBuf[ii]); /*获取计轴区段数量*/
+						ii += 2U;;
+						wPhySecCurSum = axisToCiDataStru[systemId].SectionSum;
+
+						if ((AXIS_TO_CI_SECTION_SUM_MAX > phySecNum) && (wPhySecCurSum == phySecNum))
+						{
+							for (jj = 0u; jj < phySecNum; jj++)
+							{
+								wIndexInAxle += 1U;
+								retVal = GetInAxlePhySecIdx(systemId, wIndexInAxle, &axisDataStrIdx);
+
+								if (CI_SUCCESS == retVal)
+								{
+									if (0x02U == (dataBuf[ii] & 0x03U))
+									{
+										/*10B:区段空闲*/
+										axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].gdRelayState = RELAY_STATE_UP;
+									}
+									else
+									{	/*01B:区段占用 11B:异常占用 00B:未知*/
+										axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].gdRelayState = RELAY_STATE_DOWN;
+									}
+								}
+								else
+								{
+									;
+								}
+
+								if (CI_SUCCESS == retVal)
+								{
+									if (0x01U == ((dataBuf[ii] >> 2U) & 0x03U))
+									{
+										/*计轴预复位成功*/
+										axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].PreResetRst = RELAY_STATE_UP;
+									}
+									else
+									{
+										/*计轴预复位未执行或者执行未成功*/
+										axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].PreResetRst = RELAY_STATE_DOWN;
+									}
+								}
+								else
+								{
+									;
+								}
+
+								if (CI_SUCCESS == retVal)
+								{
+									chResetCmdTag = (dataBuf[ii] >> 4U);
+									if (PHY_SEC_RESET_CMD_FLAG_SUM_MAX >= chResetCmdTag)
+									{
+										/*计轴预复位成功*/
+										axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chResetCmdTagBack = chResetCmdTag;
+									}
+									else
+									{
+										retVal = CI_ERROR;
+										debug_infor_printf((const)"\nAxis chResetCmdTag:%d ERROR\n", chResetCmdTag);
+									}
+									
+									ii++;
+								}
+								else
+								{
+									;
+								}
+
+								if (CI_SUCCESS != retVal)
+								{
+									retVal = CI_ERROR;
+									break;  /*解析失败，停止解析，返回失败*/
+								}
+								else
+								{
+									/*继续解析*/
+								}
+							}
+						}
+						else
+						{
+							retVal = CI_ERROR;
+							debug_infor_printf((const)"\nAxis phySecNum:%d ERROR,RC wPhySecCurSum::%d\n", phySecNum, wPhySecCurSum);
+						}
+					}
+					else
+					{
+						retVal = CI_ERROR;
+						debug_infor_printf((const)"\nAxis PackageType:%d ERROR\n", dataBuf[ii]);
+					}
+				}
 				else
 				{
 					retVal = CI_ERROR;
@@ -613,7 +741,7 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 			else /*无效*/
 			{
 				retVal = CI_ERROR;
-				debug_infor_printf((const)"\naxleSys gal check err.axleSysId=%d,remainValidiy=%d,curCycle=%d,RSN=%d,TSN=%d,LTSN=%d", systemId, remainValidiy, curCycleNo, hlhtGalHead.recvOppMsgSN, hlhtGalHead.crntOwnMsgSN, hlhtGalHead.preOwnMsgSN);
+				debug_infor_printf((const)"\naxleSys gal check err.axleSysId=%d,remainValidiy=%d,curCycle=%d,RSN=%d,TSN=%d,LTSN=%d\n", systemId, remainValidiy, curCycleNo, hlhtGalHead.recvOppMsgSN, hlhtGalHead.crntOwnMsgSN, hlhtGalHead.preOwnMsgSN);
 			}
 
 			if (CI_SUCCESS == retVal)
@@ -624,6 +752,21 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 				SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_AXIS, systemId, hlhtGalHead.recvOppMsgSN);
 				SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_AXIS, systemId, hlhtGalHead.preOwnMsgSN);
 				SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_AXIS, systemId, curCycleNo);
+
+				chCurSystemAreaState = GetLocalCiBackUpPattern();
+				dwSystemUpdateMainUseCycNum = GetSystemUpdateMainUseCycNum();
+				/*通用报文头校验合法*/
+				if ((SYSTEM_WORK_MODE_MAIN != chCurSystemAreaState)
+					|| ((SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState) && (hlhtGalHead.recvOppMsgSN < dwSystemUpdateMainUseCycNum)))
+				{
+					/*当前备用或主用但还未回复主用时发给计轴的数据，只存储通用报文头，不更新收到*/
+					debug_infor_printf((const)"\nnot deal axleSysId=%d data,because chCurSystemAreaState %d or hlhtGalHead.recvOppMsgSN %d < dwSystemUpdateMainUseCycNum,\n", systemId, chCurSystemAreaState, hlhtGalHead.recvOppMsgSN);
+					
+				}
+				else
+				{
+					axisToCiDataStru[systemId].dwLastRecvDataCycNum = curCycleNo;
+				}
 			}
 		}
 		else if (HLHT_HEAD_INIT == headRet)
@@ -686,17 +829,6 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 	return retVal;
 }
 
-/*
-* 功能描述： 获取计轴采集数据结构体数组
-* 参数说明： void    
-* 返回值  ： NULL: 获取失败
-*           !NULL: 采集板结构体数组指针      
-*/
-AxisToCiDataStruct* GetCollAxisDataStruct(void)
-{
-	return axisToCiDataStru;
-}
-
 /*
 * 功能描述： 清除Axis数据
 * 参数说明： void
@@ -755,6 +887,9 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
 	UINT8 chOffset = 0U;/*偏移量*/
 	UINT8 chSecResetBackState = 0U;/*区段复位状态*/
 	UINT16 wIndexInAxle = 0U; /*物理区段的索引号*/
+	UINT8 chResetCmdTagBack = 0U; /*命令标签反馈*/
+	UINT8 chResetCmdTag = 0U; /*命令标签*/
+	UINT8 chAxisLogId = 0U; /*逻辑ID*/
 
 	axisDevName = (CI_SYSTEM_TYPE_AXIS) * 256U + axisSysId;
 	if (AXIS_TO_CI_SUM_MAX > axisSysId)
@@ -1054,6 +1189,65 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
 				; /*不继续组包*/
 			}
 		}
+		else if (AXIS_TYPE_STANDARD_INTERFACE == acFty)
+		{
+			CiToAxisDataBuffer[ii] = 0X55U;
+			ii++;
+
+			phyCount = axisToCiDataStru[axisSysId].SectionSum;
+			ShortToChar(phyCount, &CiToAxisDataBuffer[ii]);
+			ii += 2U;
+
+			for (jj = 0U; jj < phyCount; jj++)
+			{
+				wIndexInAxle += 1U;
+				phySecId = GetPhyIdByIndexInAxle(axisSysId, wIndexInAxle); /*区段ID*/
+				fwCycle = GetPhySecResetStartCycNum(phySecId);
+				chResetCmdTagBack = GetPhySecResetCmdTagBack(phySecId);
+				chResetCmdTag = GetPhySecResetCmdTag(phySecId);
+
+				if (0U < fwCycle)
+				{
+					if (chResetCmdTagBack == chResetCmdTag)
+					{
+						CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X00U);
+					}
+					else
+					{
+						resetType = GetPhySecSectionResetType(phySecId);
+						if (PHYSICAL_SECTION_PRE_RESET_NO == resetType)
+						{
+							CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X0AU);
+						}
+						else if (PHYSICAL_SECTION_PRE_RESET_YES == resetType)
+						{
+							CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X05U);
+						}
+						else
+						{
+							retVal = CI_ERROR;
+						}
+					}
+				}
+				else
+				{
+					/*不发送*/
+					CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X00U);			
+				}
+
+				CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | ((UINT8)(chResetCmdTag << 4U));
+				ii++;
+
+				if (CI_ERROR == retVal)
+				{
+					break;
+				}
+				else
+				{
+					; /*继续*/
+				}
+			}
+		}
 		else
 		{
 			retVal = CI_ERROR;
@@ -1081,7 +1275,8 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
 		if (CI_SUCCESS == retVal)/*如果之前的操作是成功的*/
 		{
 			dstDevId = (((UINT16)(CI_SYSTEM_TYPE_AXIS << 8u)) | ((UINT16)axisSysId));
-			outnetSafeSendRtn = OutnetSafeSend(dstDevId, 1U, &CiToAxisDataBuffer[0], ii);
+			chAxisLogId = GetAxisLogId();
+			outnetSafeSendRtn = OutnetSafeSend(dstDevId, chAxisLogId, &CiToAxisDataBuffer[0], ii);
 			if (1u == outnetSafeSendRtn)
 			{ /*写队列成功*/
 #ifdef LOGPRINT/*日志打印宏*/			
@@ -1305,3 +1500,37 @@ UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8*
 
 	return ret;
 }
+
+/*
+* 功能描述： 获取计轴系统逻辑ID
+* 参数说明：
+* 返回值  ：计轴系统逻辑ID
+* by cgh 20250903
+*/
+UINT8 GetAxisLogId(void)
+{
+	UINT8 rtn = CI_ERROR; /*返回值*/
+	UINT8 chSystemWorkMode = 0U; /*系统工作模式*/
+	UINT8 chSystemWorkType = 0U; /*系统工作类型*/
+
+	chSystemWorkMode = GetLocalRcWorkMode();
+	chSystemWorkType = GetSystemWorkType();
+
+	if (SYSTEM_WORK_MODE_ALL == chSystemWorkType)
+	{
+		if (RC_WORK_MODE_CI == chSystemWorkMode)
+		{
+			rtn = 1U;
+		}
+		else
+		{
+			rtn = 2U;
+		}
+	}
+	else
+	{
+		rtn = 1U;
+	}
+
+	return rtn;
+}

TSCP/src/APP/ciapp/ParsePack/ParsePackAxleData.h

@@ -56,7 +56,7 @@ typedef struct S_AxisDataStruct
 	UINT8 chDirectResetRst; /*直接复位结果*/
 	UINT8 chDirectResetBack; /*直接复位命令反馈*/
 	UINT8 State; /*状态*/
-
+	UINT8 chResetCmdTagBack; /*复位命令标签反馈*/
 } AxisCollDataStruct;
 
 typedef struct S_AxisToCiDataStruct
@@ -68,6 +68,7 @@ typedef struct S_AxisToCiDataStruct
 	UINT8 SectionSum;                              				   /*区段数量: 动态字段*/
 	UINT8 PhySecIdx[PHYSICAL_SECTION_SUM_MAX]; /*物理区段在计轴区段信息结构体数组中位置数组*/
 	AxisCollDataStruct  axisDataStr[CI_INCLUDE_AXIS_MAX_SUM];  	   /*计轴区段信息结构体数组*/
+	UINT32 dwLastRecvDataCycNum; /*最后收到数据周期号*/
 }AxisToCiDataStruct;
 
 
@@ -88,14 +89,6 @@ extern "C" {
 */
 UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 systemId);
 
-/*
-* 功能描述： 获取计轴采集数据结构体数组
-* 参数说明： void    
-* 返回值  ： NULL: 获取失败
-*           !NULL: 采集板结构体数组指针      
-*/
-AxisToCiDataStruct* GetCollAxisDataStruct(void);
-
 #if 0
 /*
 * 功能描述： 解析处理计轴通信采集数据
@@ -140,6 +133,14 @@ UINT8 InitAxleToCiDataStru(void);
 */
 UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8* pAxleDataStrIdx);
 
+/*
+* 功能描述： 获取计轴系统逻辑ID
+* 参数说明：
+* 返回值  ：计轴系统逻辑ID
+* by cgh 20250903
+*/
+UINT8 GetAxisLogId(void);
+
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/ParsePack/ParsePackCiData.h

@@ -85,12 +85,20 @@
 #define BIT_VAL_00000001B ((UINT8)0X01)
 #define BIT_VAL_00000010B ((UINT8)0X02)
 #define BIT_VAL_00000011B ((UINT8)0X03)
+#define BIT_VAL_00000100B ((UINT8)0x04)
+#define BIT_VAL_00000101B ((UINT8)0x05)
+#define BIT_VAL_00000110B ((UINT8)0x06)
 #define BIT_VAL_00010001B ((UINT8)0x11)
 #define BIT_VAL_00010010B ((UINT8)0x12)
 #define BIT_VAL_00010100B ((UINT8)0x14)
 #define BIT_VAL_00011000B ((UINT8)0x18)
 #define BIT_VAL_11111111B ((UINT8)0xFF)
 
+#define BIT_PALCE11000000 ((UINT8)0xC0)
+#define BIT_PALCE00110000 ((UINT8)0x30)
+#define BIT_PALCE00001100 ((UINT8)0x0C)
+#define BIT_PALCE00000011 ((UINT8)0x03)
+
 /*物理区段上电锁闭设置标志*/
 #define HLHT_STARTLOCK_SET_NO					((UINT8)0xaa)	/*未设置*/
 #define HLHT_STARTLOCK_SET_YES					((UINT8)0x55)	/*设置*/
@@ -100,15 +108,17 @@
 #define PHYSEC_LOCKDIRECTION_OPPST_YES					((UINT8)0xAA)	/*取反*/
 #define PHYSEC_LOCKDIRECTION_OPPST_DEFAULT				((UINT8)0xFF)	/*默认值*/
 
-#define CICI_VERSION					((UINT16)29) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.09.22*/
-#define CICI_BEGIN_TO_STATION_LEN		((UINT16)16) /*从开始到站场长度止  cgh增加4个字节CI-CI校验信息*/
+#define CICI_VERSION					((UINT8)32) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2026.03.10*/
+#define CICI_BEGIN_TO_STATION_LEN		((UINT16)31) /*20251104更新为HLHT头长度+应用层保温内容前6字节*/
+#define CICI_CICIVERINDEX (CICI_BEGIN_TO_STATION_LEN-3U) /*20251104更新后CI接口版本信息索引*/
 #define CICI_ONE_SWITCH_LEN				((UINT16)13) /*一个道岔数据长度*/
-#define CICI_ONE_PHYSEC_LEN				((UINT16)23U)/*一个物理区段数据长度*/
-#define CICI_ONE_LOGSEC_LEN				((UINT16)10)/*一个逻辑区段数据长度*/
+#define CICI_ONE_PHYSEC_LEN				((UINT16)12U)/*一个物理区段数据长度*/
+#define CICI_ONE_PHYSEC_UT_LEN				((UINT16)1U)/*一个物理区段坏车占用数据长度*/
+#define CICI_ONE_LOGSEC_LEN				((UINT16)6)/*一个逻辑区段数据长度*/
 #define CICI_ONE_SIGNAL_LEN				((UINT16)11)/*一个信号机数据长度*/
 #define CICI_ONE_PSD_LEN				((UINT16)5)/*一个屏蔽门数据长度*/
 #define CICI_ONE_ESB_LEN				((UINT16)4)/*一个ESB数据长度*/
-#define CICI_ONE_ROUTE_LEN				((UINT16)12)/*一个进路数据长度*/
+#define CICI_ONE_ROUTE_LEN				((UINT16)13)/*一个进路数据长度*/
 #define CICI_ONE_PHYSEC_LOCKSTATE_LEN	((UINT16)10)/*一个物理区段锁闭状态数据长度*/
 #define CICI_ONE_SPKS_LEN				((UINT16)4)	/*一个SPKS数据长度*/
 #define CICI_ONE_VIRTUAL_RELAY_LEN		((UINT16)3)	/*一个虚拟SPKS数据长度*/
@@ -125,6 +135,26 @@
 #define CICI_DR_CMD_FULL					((UINT8)0xaa)	/*完整子进路*/
 #define CICI_DR_CMD_LOGIC					((UINT8)0xbb)	/*逻辑子进路*/
 
+#define LOCAL_CI_RC_INTER_TYPE              ((UINT16)0x0306U)   /*本控区CI-RC接口类型*/
+#define LOCAL_RC_TO_CI_INFO_DEV_STATE       ((UINT16)0x0301U)   /*本控区RC发送本控区CI设备状态帧*/
+#define LOCAL_CI_TO_RC_INFO_HEART           ((UINT16)0x0302U)   /*本控区CI发送本控区RC心跳帧*/
+#define NEAR_RCI_GENERAL_DEV_INFO           ((UINT16)0x0303U)   /*通用设备信息帧（相邻主用RC与主用CI间）*/
+#define NEAR_RCI_PBTACS_DEV_INFO            ((UINT16)0x0304U)   /*PBTACS接口特有设备信息帧（相邻RC间）*/
+#define NEAR_RCI_HEART_INFO                 ((UINT16)0x0305U)   /*心跳帧（相邻备用RC与主用CI间）*/
+
+#define LOCAL_CI_RC_PRTCL_VER			    ((UINT8)0x01U)		/*本控区CI-RC协议版本号*/
+#define TMP_PACKBUF_LEN 	(UINT16)(10000)/*临时组包数组长度*/
+
+/*给相邻RC/CI组包类型*/
+#define RCCI_PACK_TYPE_HEART					((UINT8)0U)	/*组心跳帧*/
+#define RCCI_PACK_TYPE_GENERAL					((UINT8)0x55U)	/*组通用设备信息帧*/
+#define RCCI_PACK_TYPE_PBTACS					((UINT8)0xAAU)	/*组PB-TACS特有设备信息帧*/
+#define RCCI_PACK_TYPE_ALL_DEV					((UINT8)0xFFU)	/*组通用设备信息帧+PB-TACS特有设备信息帧*/
+
+/*相邻RC/CI间命令类型*/
+#define RCCI_CMD_TYPE_GENERAL					((UINT8)0x55U)	/*通用命令*/
+#define RCCI_CMD_TYPE_PBTACS					((UINT8)0xAAU)	/*PB-TACS特有命令*/
+
 /*物理区段数据结构体*/
 typedef struct S_IntconPhySecDataStruct
 {
@@ -201,6 +231,12 @@ extern "C" {
 		UINT16 szNeedCheckProSwtStateOlpIdBuf[OVERLAP_SUM_MAX];  /*需要检查防护道岔状态的保护区段ID数组*/
 		UINT16 wSwitchSumOfOtherCi;  /*涉及到保护区段征用的其它控区道岔数量*/
 		UINT16 szSwitchIdBufOfOtherCi[SWITCH_SUM_MAX];  /*涉及到保护区段征用的其它控区道岔数量*/
+
+		/*互联互通增加分界数据类型*/
+		UINT16 wSwitchPhySecNum;							/*道岔所在物理区段数量*/
+		UINT16 wSwitchPhySecBuf[PHYSICAL_SECTION_SUM_MAX];	/*道岔所在物理区段数组*/
+		UINT16 wXianSuLogSecNum;						/*限速逻辑区段数量*/
+		UINT16 wXianSuLogSecBuf[LOGIC_SECTION_SUM_MAX]; /*限速逻辑区段数组*/
 	} CiTransmitStruct;
 
 	/* 相邻TIOC发来的通信车 */
@@ -250,6 +286,15 @@ extern "C" {
 		UINT16 wAreaIteCutId[CI_TO_CI_AREA_SNOW_SUM_MAX];  /*区间ID数组*/
 	} ToCiAreaIteCutStruct;
 
+	/*相邻RC发送的帧类型*/
+	typedef struct S_NeighborCiInfoStruct
+	{
+		UINT8 cSourceRcId;  /*发送方ID*/
+		UINT16 cIRctoCInfoType;  /*RC发送的帧类型*/
+		UINT8 cMainUseMode;  /*相邻联锁主用方*/
+		UINT32 dwMainUseCurCyc;  /*主用方周期号*/
+	} NeighborCiInfoStruct;
+
 	/*******************************全局变量声明*******************************/
 	extern ToCiCommandDataStruct RecvCiCmdDataStru[RECVCI_CMD_DATA_STRU_SUM_MAX];
 	extern UINT16 RecvCiCmdDataStruCurSum;
@@ -268,42 +313,412 @@ extern "C" {
 	extern ToCiAreaSnowStruct szSendCiAreaSnow[CI_COM_CI_MAX_NUM];
 	extern ToCiAreaIteCutStruct szRecvCiAreaIteCut[CI_COM_CI_MAX_NUM];
 	extern ToCiAreaIteCutStruct szSendCiAreaIteCut[CI_COM_CI_MAX_NUM];
-
-/*
-* 功能描述： 解析CI数据
-* 参数说明： void    
-* 返回值  ： 0: 解析失败
-*			 1: 解析成功        
-*/
-UINT8 ParseCiToCiData(void);
+	extern NeighborCiInfoStruct szNeighborCiInfo[CI_COM_CI_MAX_NUM];  /*接收来自相邻RC的帧类型*/
 
 /*
 * 功能描述： 解析CI单帧数据
-* 参数说明： void    
+* 参数说明： UINT8* dataBuf 解析数据, UINT16 dataLength 长度,UINT16 wSourceDevId  发送方id
 * 返回值  ： 0:解析失败
 *			 1:解析成功
+* @note 内部优化 20220419 wqm
+1、编码规范：函数dsuCheckSameLoc返回值需要变量承接
+2、增加返回值判断
+3、适配北京10相邻联锁
 */
-UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength);
+UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT16 wSourceDevId);
 
 /*
 * 功能描述： 校验相邻CI间单帧数据
 * 参数说明： UINT8* dataBuf		输入数据信息
 *			 UINT16 dataLength   输入数据长度
+*			 UINT16 srcDevTypeId   发送方设备
 *			 UINT8 *errNo		校验失败故障码
 * 返回值  ： CI_ERROR:校验失败
 *			 CI_SUCCESS:校验成功
 */
-UINT8 ParseCiToCiDataCheck(UINT8* dataBuf, UINT16 dataLength, UINT8 *errNo);
+UINT8 ParseCiToCiDataCheck(UINT8* dataBuf, UINT16 dataLength, UINT8 *errNo, UINT16 srcDevTypeId);
 
 /*
-* 功能描述： 组CI数据
-* 参数说明： UINT8 targetDeviceId, 目标设备ID  
-* 返回值  ： 0: 组包失败
+* 功能描述：组CI数据
+* 参数说明：UINT8 targetDeviceType 目标设备类型
+*           UINT8 targetDeviceId, 目标设备ID
+* 返回值  ：0: 组包失败
 *			1: 组包成功
 */
-UINT8 PackCiToCiData(UINT8 targetDeviceId);
+UINT8 PackCiToCiData(UINT8 targetDeviceType, UINT8 targetDeviceId);
 
+/*
+* 功能描述：获取本RC/CI需要给相邻RC/CI组包的帧类型
+* 参数说明：UINT8 targetDeviceType 目标设备类型
+*           UINT8 targetDeviceId 目标设备ID
+* 返 回 值：0 组心跳帧
+*           0x55 组通用设备信息帧
+*           0xAA 组PB-TACS特有设备信息帧
+*			0xFF 组通用设备信息帧+PB-TACS特有设备信息帧
+* Created By LQ 2026.01.04
+*/
+UINT8 GetSendToNearRciInfoType(UINT8 targetDeviceType, UINT8 targetDeviceId);
 
+/*
+* 功能描述：更新需要发送给相邻RC/CI的区段征用命令信息
+* 参数说明：UINT8 targetDeviceId 目标设备ID
+* 返 回 值：无
+* Created By LQ 2026.01.04
+*/
+void UpdateSendToRciSecUseCmd(UINT8 targetDeviceId);
+
+/*
+* 功能描述：更新需要发送给相邻RC/CI的道岔征用命令信息
+* 参数说明：UINT8 targetDeviceId 目标设备ID
+* 返 回 值：无
+* Created By LQ 2026.01.04
+*/
+void UpdateSendToRciSwtUseCmd(UINT8 targetDeviceId);
+
+/*
+* 功能描述：更新需要发送给相邻RC/CI的试车命令信息
+* 参数说明：UINT8 targetDeviceId 目标设备ID
+* 返 回 值：无
+* Created By LQ 2026.01.04
+*/
+void UpdateSendToRciTrainTestCmd(UINT8 targetDeviceId);
+
+/*
+* 功能描述：相邻RC/CI间组心跳帧应用层信息
+* 参数说明：UINT8* dataFrame 待填充的数组（出参）
+*           UINT16* dataLength 已组包长度地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciHeartAppInfo(UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组通用设备信息帧应用层信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Modefied By LQ 2026.01.05
+*/
+UINT8 PackNearRciGeneralAppInfo(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组道岔信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciSwitchData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组物理区段坏车占用信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.16
+*/
+UINT8 PackNearRciPhySecUtOccData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组物理区段状态信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciPhySecStateData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：校验相邻CI发送的待解析的物理区段坏车占用信息
+* 参数说明：const UINT8* dataBuf 待解析的数据；
+*           UINT16* index 索引
+* 返回值  ：0 校验失败
+*           1 校验成功
+*/
+UINT8 CheckCiToCiPhySecUtOccData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：相邻RC/CI间组逻辑区段状态信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciLogSecStateData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组信号机信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciSignalData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组屏蔽门信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciPsdData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组紧急停车按钮信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciEsbData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组进路信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciRouteData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组物理区段锁闭信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciPhySecLockData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组SPKS信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciSpksData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组虚拟继电器信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciVirtualRelayData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组防淹门信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciFloodGateData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组保护区段信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciOverlapData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组自动通过进路信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciAutoRouteData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组逻辑区段锁闭信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciLogSecLockData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组区间湿轨信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciAreaSnowData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组区间ITE切除信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciAreaIteCutData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组离去逻辑区段信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciLeaveLogSecData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组其它控区进路的道岔检查结果
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciRouteSwtCheckData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组其它控区保护区段的防护道岔检查结果
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciOlapProSwtCheckData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组防护道岔防护锁闭信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*			UINT8* dataFrame 存数据Buf（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.05
+*/
+UINT8 PackNearRciProSwtProLockData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组通用命令信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*	        UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciGeneralCmdData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组PB-TACS特有设备信息帧应用层信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*	        UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciPbtacsAppInfo(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组逻辑区段资源可用信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*	        UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciLogSecResUseData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组逻辑区段资源锁闭信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*	        UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciLogSecResLockData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组分界点信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*	        UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciCfpData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：相邻RC/CI间组PB-TACS特有命令信息
+* 参数说明：UINT8 dstCiId 目标RC/CI编号
+*	        UINT8* dataFrame 待填充的数组（出参）
+*			UINT16* dataLength 数据总长度的地址（出参）
+* 返 回 值：0 组包失败
+*           1 组包成功
+* Created By LQ 2026.01.04
+*/
+UINT8 PackNearRciPbtacsCmdData(UINT8 dstCiId, UINT8* dataFrame, UINT16* dataLength);
+
+/*
+* 功能描述：判断相邻RC/CI间指定ID命令的命令类型（通用命令或PB-TACS特有命令）
+* 参数说明：UINT16 wCmdId 命令ID
+* 返 回 值：0 失败
+*           0x55 通用命令
+*           0xAA PB-TACS特有命令
+* Created By LQ 2026.01.04
+*/
+UINT8 CheckNearRciCmdType(UINT16 wCmdId);
 
 /*
 * 功能描述： 获取本联锁具有锁闭状态管理权的物理区段ID数组总数
@@ -548,7 +963,7 @@ void ClearCiRevCiDrCmdData(void);
 * 返回值  ： CI_ERROR:校验失败
 *			 CI_SUCCESS:校验成功
 */
-UINT8 CheckCiIDAndVer(const UINT8* dataBuf, UINT8* Index);
+UINT8 CheckCiIDAndVer(const UINT8* dataBuf, UINT16* Index);
 
 /*
 * 功能描述：校验相邻CI发送的待解析的道岔数据
@@ -577,6 +992,16 @@ UINT8 CheckCiToCiPhySecData(const UINT8* dataBuf, UINT16* index);
 */
 UINT8 CheckCiToCiLogSecData(const UINT8* dataBuf, UINT16* index);
 
+/*
+* 功能描述：校验相邻RC发送的的特有逻辑区段数据
+* 参数说明：const UINT8* dataBuf 待解析的数据；
+*           UINT16* index 索引
+* 返回值  ：0 校验失败
+*           1 校验成功
+*Create fan 2026.01.04
+*/
+UINT8 CheckCiToCiLogSecDataRcOnly(const UINT8* dataBuf, UINT16* index);
+
 /*
 * 功能描述：校验相邻CI发送的待解析的信号机数据
 * 参数说明：const UINT8* dataBuf 待解析的数据；
@@ -595,6 +1020,15 @@ UINT8 CheckCiToCiSignalData(const UINT8* dataBuf, UINT16* index);
 */
 UINT8 CheckCiToCiCommandData(const UINT8* dataBuf, UINT16* index);
 
+/*
+* 功能描述：校验相邻CI发送的待解析的命令数据
+* 参数说明：const UINT8* dataBuf 待解析的数据；
+*           UINT16* index 索引
+* 返回值  ：0 校验失败
+*           1 校验成功
+*Create fan 2026.01.04
+*/
+UINT8 CheckCiToCiCommandDataRcOnly(const UINT8* dataBuf, UINT16* index);
 
 /*
 * 功能描述：校验相邻CI发送的待解析的防淹门数据
@@ -633,6 +1067,16 @@ UINT8 CheckCiToCiAutoRouteData(const UINT8* dataBuf, UINT16* index);
 */
 UINT8 CheckCiToCiLogicLockData(const UINT8* dataBuf, UINT16* index);
 
+/*
+* 功能描述：校验相邻CI发送的本联锁中由其他联锁管理的逻辑区段锁闭数据
+* 参数说明：const UINT8* dataBuf 待解析的数据；
+*           UINT16* index 索引
+* 返回值  ：0 校验失败
+*           1 校验成功
+*Create fan 2026.0.1.04
+*/
+UINT8 CheckCiToCiLogicLockDataRcOnly(const UINT8* dataBuf, UINT16* index);
+
 /*
 * 功能描述：校验动态进路命令信息
 * 参数说明：const UINT8* dataBuf 待解析的数据；
@@ -1005,11 +1449,184 @@ UINT8 PackManufacDefPacket(UINT8* pInputBuf, UINT16* pItemLen, const UINT8 dstCi
 * 参数说明：const UINT8 *pInputData 输入数据指针
 *           UINT16 *pItemLen 该项数据在输入数据中的长度
 *           const UINT8 srcCiId 源联锁ID
+*			const UINT16 packetLen 报文长度
 * 返 回 值：CI_SUCCESS 1 解析成功
 *           CI_ERROR 0 解析失败
 * Created By LQ 2025.05.26
 */
-UINT8 ParseManufacDefPacket(const UINT8* pInputData, UINT16* pItemLen, const UINT8 srcCiId);
+UINT8 ParseManufacDefPacket(const UINT8* pInputData, UINT16* pItemLen, const UINT8 srcCiId, const UINT16 packetLen);
+
+/*
+* 功能描述：组CI到本控区RC单帧数据
+* 参数说明：const UINT8 cRcId 目标RC ID
+* 返 回 值：CI_ERROR 0 组数据失败
+*			CI_SUCCESS 1:组数据成功
+* Created By LQ 2025.11.04
+*/
+UINT8 PackCiToLocalRcDataFrame(const UINT8 cRcId);
+
+/*
+* 功能描述：解析CI到本控区RC单帧数据
+* 参数说明：const UINT8* dataBuf 数据缓冲区
+*           const UINT16 dataLength 数据长度
+*           const UINT8 systemId 源设备ID
+* 返 回 值：CI_ERROR 0 组数据失败
+*			CI_SUCCESS 1 组数据成功
+* Created By LQ 2025.11.04
+*/
+UINT8 ParseCiToLocalRcDataFrame(const UINT8* pDataBuf, const UINT16 dataLength, const UINT8 systemId);
+
+/*
+* 功能描述：组RC到本控区CI单帧数据
+* 参数说明：const UINT8 cCiId 目标CI ID
+* 返 回 值：CI_ERROR 0 组数据失败
+*			CI_SUCCESS 1 组数据成功
+* Created By LQ 2025.11.05
+*/
+UINT8 PackRcToLocalCiDataFrame(const UINT8 cCiId);
+
+/*
+* 功能描述：解析RC到本控区CI单帧数据
+* 参数说明：const UINT8* dataBuf 数据缓冲区
+*           const UINT16 dataLength 数据长度
+*           const UINT8 systemId 源设备ID
+* 返 回 值：CI_ERROR 0 组数据失败
+*			CI_SUCCESS 1 组数据成功
+* Created By LQ 2025.11.05
+*/
+UINT8 ParseRcToLocalCiDataFrame(const UINT8* pDataBuf, const UINT16 dataLength, const UINT8 systemId);
+
+/*
+* 功能描述：校验本控区RC发给CI的单帧数据
+* 参数说明：UINT8* pDataBuf 输入数据信息
+*			UINT16 dataLength 输入数据长度
+*			UINT8 *pErrNo 校验失败故障码
+* 返 回 值：CI_ERROR 0 校验失败
+*			CI_SUCCESS 0 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 ParseRcToLocalCiDataCheck(UINT8* pDataBuf, UINT16 dataLength, UINT8* pErrNo);
+
+/*
+* 功能描述：校验本控区RC发给CI的进路数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiRouteData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：校验本控区RC发给CI的信号机数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiSignalData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：校验本控区RC发给CI的计轴区段数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiAxisSecData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：校验本控区RC发给CI的逻辑区段数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiLogSecData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：校验本控区RC发给CI的物理区段数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiPhySecData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：校验本控区RC发给CI的屏蔽门数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiPsdData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述：校验本控区RC发给CI的雨雪数据
+* 参数说明：const UINT8* dataBuf 待解析的数据
+*           UINT16* index 索引
+* 返 回 值：0 校验失败
+*           1 校验成功
+* Created By LQ 2025.11.05
+*/
+UINT8 CheckLocalRcToCiSnowData(const UINT8* dataBuf, UINT16* index);
+
+/*
+* 功能描述： 解析相邻RC间TB-TACS特有单帧数据
+* 参数说明： UINT8* dataBuf 解析数据, UINT16 dataLength 长度
+* 返回值  ： 0:解析失败
+*			 1:解析成功
+* Create Fan 2025.12.31
+*/
+UINT8 ParseRcToRcPbTacsDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 sourceId);
+
+/*
+* 功能描述：获取相邻RC发送本CI的帧类型
+* 参数说明：const UINT8 cTargetRcId 目标RC ID
+* 返 回 值：相邻RC发送本CI的帧类型
+* Created By LQ 2026.01.04
+*/
+UINT16 GetNearRcSendInfoType(const UINT8 cTargetRcId);
+
+/*
+* 功能描述：设置相邻RC发送本CI的帧类型
+* 参数说明：const UINT8 cTargetRcId 目标RC ID
+*           const UINT16 cIRctoCInfoType 帧类型
+* 返 回 值：无
+* Created By LQ 2026.01.04
+*/
+void SetNearRcSendInfoType(const UINT8 cTargetRcId, const UINT16 cInfoType);
+
+/*
+* 功能描述：功能描述：获取相邻RC发送本CI的主用模式类型（发送通用信息帧的模式）
+* 参数说明：const UINT8 cTargetRcId 目标RC ID
+* 返 回 值：相邻RC发送本CI的帧类型
+* Created By fan 2026.01.04
+*/
+UINT8 GetNearRCISendMainUseMode(const UINT8 cTargetRcId);
+
+/*
+* 功能描述：设置相邻联锁发送通用信息帧的模式
+* 参数说明：const UINT8 cTargetRcId 目标RC ID
+*           const UINT8 chMode 类型 UINT32 dwMainCyc主用方CYC
+* 返 回 值：无
+* Created By fan 2026.01.04
+*/
+void SetNearRCISendMainUseMode(const UINT8 cTargetRcId, const UINT8 chMode,const UINT32 dwMainCyc);
+
+/*
+* 功能描述：清除相邻联锁模式信息（中断处理）
+* 参数说明：const UINT8 cTargetRcId 目标RC ID 待清除模式
+* 返 回 值：无
+* Created By fan 2026.01.04
+*/
+void ClearNearRCISendInfo(const UINT8 cTargetRcId, const UINT8 chMode);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c

@@ -31,7 +31,8 @@
 
 PlatHeartDataStruct RecvHeartDataStru = { 0U };  /*平台心跳帧数据结构*/
 PlatGPIODataStruct RecvPlatDataStruGPIO = { 0U };/*平台0x2D帧数据结构 GPIO采集状态*/
-PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍记录数据*/
+PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍*/
+
 
 /*
 * 功能描述： 信号机相关码位处理
@@ -523,7 +524,11 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	UINT16 indexFind = 0U;
 	UINT8 devBelongThisLine = 0U;
 	UINT8 switchBoardNum = 0U;
-	UINT8 switchStateCheck = CI_ERROR;
+	UINT8 chLocalCiOCSswitch = 0U;
+	UINT8 chMainCotrolOCId = 0U;
+
+	chLocalCiOCSswitch = GetLocalCiOCSswitch();
+
 
 	switchLockStatus = GetSwitchLockStatus(DeviceId);
 
@@ -698,15 +703,19 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 		}
 		break;
 	case MASK_TYPE_SWITCH_OPEN_CAP:
+		chMainCotrolOCId = GetSwitchMainCotrolOCId(DeviceId);/*获取主控OC*/
 		for (i = 0u; i < m_SwitchNum; i++)
 		{
 			if (m_Switches[i].DeviceId == DeviceId)
 			{
+				if ((chMainCotrolOCId == m_Switches[i].OcId) || (OC_S_OFF == chLocalCiOCSswitch))
+				{/*当前有主控OC或OC-S功能关闭*/
 					flagFind = 1u;
 					indexFind = i;
 					break;
 				}
 			}
+		}
 		if (1u == flagFind)
 		{
 			/*板卡状态有一系是开盖状态*/
@@ -797,6 +806,7 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 	UINT8 phySecStopSteadyFlag = 0u;
 	UINT8 chPhyFree = CI_ERROR;
 	UINT8 gdDLline = 0u;  /*线路是否采用轨道电路*/
+	UINT8 cFuncRet = CI_ERROR;
  	funcSwitchJumpLockDriveSwitch = GetCiFunctionSwitchConfig(FUNC_SWITCH_JUMPLOCK_DRIVE_SWITCH);
 	/*判断是否采用轨道电路*/
 	gdDLline = GetCiFunctionSwitchConfig(FUNC_CLD_GD_DIANLU_LINE);
@@ -831,16 +841,24 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 		phySecLockState = GetPhySecLockState(DeviceId);
 		localCiType = GetLocalCiType();
 		phyIntruSecVainCheck = PhysicalIntruSecVainCheck(DeviceId);
+
 		if (((PHYSICAL_SECTION_LOCK_NORMAL == phySecLockState) ||
 			(PHYSICAL_SECTION_LOCK_DELAY == phySecLockState) ||
 			(PHYSICAL_SECTION_LOCK_FAULTDELAY == phySecLockState) ||
 			((PHYSICAL_SECTION_LOCK_EXCEPT == phySecLockState) && (CI_TYPE_CLD == localCiType)))
 			&& (CI_SUCCESS == phyIntruSecVainCheck))
 		{/*正常锁闭或延时解锁或区故解延时,车辆段且异常锁闭也发送锁闭状态,当该区段对应的侵限条件成立，则向ZC发送未锁闭，20190308*/
-
+			cFuncRet = PhySecLockMaskSideProtectCheck(DeviceId);  /*侧防条件检查*/
+			if (CI_SUCCESS== cFuncRet)
+			{
 				SetMaskValue(MaskId, dataBuf);
 			}
 			else
+			{
+				/*侧防条件不满足，发0未锁闭*/
+			}
+		}
+		else
 		{
 
 		}
@@ -1168,6 +1186,42 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 			;
 		}
 		break;
+		case MASK_TYPE_PHYSECTION_INTRUSION:
+		/* 物理区段侵限状态码位 */
+		phyIntruSecVainCheck = PhysicalIntruSecVainCheck(DeviceId);
+		if (CI_SUCCESS == phyIntruSecVainCheck)
+		{			
+			/*未侵限，发1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+			/*侵限，发0*/
+		}
+		break;
+	case MASK_TYPE_PHYSECTION_ATS_FLOCK:
+		/* 物理区段由ATS封锁状态码位 */
+		/*封锁状态码位(ATS设置) 封锁发0 未封锁以及SPKS命令封锁发1*/
+		phySecState = GetPhySecFLockState(DeviceId);
+		if (PHYSICAL_SECTION_FLOCK_NO != phySecState)
+		{
+			phySecLockType = GetPhySecFLockType(DeviceId);
+			if (PHY_SEC_FLOCK_TYPE_SPKS != phySecLockType)
+			{
+				/*除了SPKS封锁  都发0*/
+			}
+			else
+			{
+				/*SPKS命令的封锁 发1*/
+				SetMaskValue(MaskId, dataBuf);
+			}
+		}
+		else
+		{
+			/*未封锁 发1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
 
 	default:
 		returnValue = CI_ERROR;
@@ -1194,12 +1248,15 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 	UINT16 logLockBelongRoute = 0U;/*逻辑区段锁闭所属进路*/
 	UINT16 logProtectLockRoute = 0U;/*逻辑区段防护锁闭所属进路*/
 	UINT8 chJumpLockState = 0U;/*逻辑区段锁闭状态*/
-	UINT8 cLogArbState = 0U;	/* 逻辑区段ARB状态 */
+	UINT8 cLogCbtcArbState = 0U;	/* 逻辑区段CBTC_ARB状态 */
+	UINT8 cLogPbTacsArbState = 0U;	/* 逻辑区段PB_TACS_ARB状态 */
 	UINT8 chLogSecLockDirOpposedFlag = CI_ERROR;/*逻辑区段锁闭方向是否取反标志*/
 	UINT8 cLogSpksFlockState = 0U;	/* 逻辑区段SPKS封锁状态 */
 	UINT8 cLogSecLogicLockState = LOG_SECTION_LOCK_NO;  /*逻辑区段逻辑锁闭状态*/
 	UINT8 cLogSecLockDir = CI_SYSTEM_DIRECTION_NONE;  /*逻辑区段锁闭方向*/
 	UINT8 chLogSecBelLogRouteSum = 0U;/*逻辑区段所属逻辑进路数目*/
+	UINT8 chLogSecEmergXianSu = 0U;/*逻辑区段紧急临时限速状态*/
+	UINT8 chRcWorkMode = 0U; /*RC工作模式*/
 
 	switch (MaskType)
 	{
@@ -1354,15 +1411,33 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 			SetMaskValue(MaskId, dataBuf);
 		}
 		break;
-	case MASK_TYPE_LOGICSECTION_ARB:
-		/* 逻辑区段ARB状态 */
-		cLogArbState = GetLgcArbState(DeviceId);
-		/*区段ARB*/
-		if (LGC_SECTION_ARB_YES == cLogArbState)
+	case MASK_TYPE_LOGSEC_CBTC_ARB:
+		/* 逻辑区段CBTC_ARB状态 */
+		cLogCbtcArbState = GetLogSecCbtcArbState(DeviceId);
+		/*当前系统为CI，获取逻辑区段ARB状态*/
+		if (LGC_SECTION_ARB_YES == cLogCbtcArbState)
 		{
 			/*设置码位为1*/
 			SetMaskValue(MaskId, dataBuf);
 		}
+		else
+		{
+			;
+		}
+		break;
+	case MASK_TYPE_LOGSEC_PB_TACS_ARB:
+		/* 逻辑区段PC_TACS_ARB状态 */
+		cLogPbTacsArbState = GetLogSecPbTacsArbState(DeviceId);
+		/*当前系统为RC，获取逻辑区段ARB状态*/
+		if (LGC_SECTION_ARB_YES == cLogPbTacsArbState)
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+			;
+		}
 		break;
 	case MASK_TYPE_LOGICSECTION_SPKS_FLOCK:
 		/* 逻辑区段SPKS封锁状态 */
@@ -1378,6 +1453,19 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 			SetMaskValue(MaskId, dataBuf);
 		}
 
+		break;
+	case MASK_TYPE_LOGICSECTION_EMERG_XIANSU:
+		/* 逻辑区段紧急临时限速状态 */
+		chLogSecEmergXianSu = GetLogSecEmergXianSu(DeviceId);
+		if (LOGSEC_EMERG_XS_SET_NO == chLogSecEmergXianSu)
+		{
+			/*未设置限速码位为0*/
+		}
+		else
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
 		break;
 	default:
 		returnValue = CI_ERROR;
@@ -1493,6 +1581,8 @@ UINT8 OverlapMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* d
 						returnValue = CI_ERROR;
 					}
 
+
+
 					if (CI_SUCCESS == returnValue)
 					{
 						SetMaskValue(MaskId, dataBuf);
@@ -1551,6 +1641,10 @@ UINT8 OverlapMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* d
 UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dataBuf)
 {
 	UINT8 returnValue = CI_SUCCESS;              /*返回值默认成功*/
+	UINT8 chVirCiId = 0u;
+	UINT8 chVirCiType = 0u;
+	UINT8 ciTrainTestState = 0u;	/*试车线联锁状态*/
+	UINT32 xuanpaiStartCycNum = 0u;/*进路选排开始周期数*/
 	UINT8 routeState = GetRouteState(DeviceId);  /*获取进路状态*/
 	UINT8 routeLevel = GetRouteLevel(DeviceId);
 	UINT16 lastPhyLockId = GetRouteLastPhySectionId(DeviceId);   /*获取指定ID进路最后一个物理区段ID*/
@@ -1559,10 +1653,11 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 	UINT8 dcQState = GetRouteDCQState(DeviceId);/*进路调车请求状态*/
 	UINT8 dcTState = GetRouteDCTYState(DeviceId);/*进路调车同意状态*/
 	UINT8 chDCAgreeBtnErrState = GetRouteDcAgreeButtonErrState(DeviceId);/*进路调车同意按钮故障状态*/
-	UINT8 RouteCiId = 0u;	/*进路所属联锁*/
-	UINT8 CiTypeOfRoute = 0u;		/*当前进路所属联锁类型*/
-	UINT8 ciTrainTestState = 0u;	/*试车线联锁状态*/
+
 	UINT8 routeAutoTriggerFlag = GetRouteAutoTriggerFlag(DeviceId);     /*获取进路自动触发标志*/
+
+
+	xuanpaiStartCycNum = GetRouteXuanPaiStartCycNum(DeviceId);/*进路选排开始周期数*/
 	switch (MaskType)
 	{
 	case MASK_TYPE_ROUTE_IDLE:/*进路空闲码位*/
@@ -1576,7 +1671,8 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 		}
 		break;
 	case MASK_TYPE_ROUTE_XUANPAI:/*进路选排码位*/
-		if (ROUTE_STATE_XUANPAI == routeState)
+		/* 处于选排周期号有效即可发送码位*/
+		if (xuanpaiStartCycNum > 0u)
 		{
 			SetMaskValue(MaskId, dataBuf);
 		}
@@ -1648,10 +1744,11 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 		break;
 	case MASK_TYPE_ROUTE_LOCKSTATE:/*CI-ZC码位，基本进路锁闭状态码位:根据接口说明，进路属于办理状态，引导进路均发送0,当进路状态为预选或选排且最后一个区段为锁闭状态则仍发1，解决CBTC模式进路追踪办理动道岔期间不给ZC发进路建立状态*/
 		/*获取进路所属CI*/
-		RouteCiId = GetRouteBelongCiId(DeviceId);
+		chVirCiId = GetRouteBelongVirCiId(DeviceId);
+		chVirCiType = GetLocalVirCiType(chVirCiId);
 		/*获取联锁类型*/
-		CiTypeOfRoute = GetCiType(RouteCiId);
-		if ((0u != RouteCiId) && (0u != CiTypeOfRoute))
+
+		if ((0u != chVirCiId) && (0u != chVirCiType))
 		{
 			if ((ROUTE_STATE_IDLE != routeState)
 				&& (ROUTE_STATE_FIRST_XUANPAI != routeState)
@@ -1668,7 +1765,7 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 				)
 			{
 				ciTrainTestState = GetCiTrainTestStatus();
-				if ((CI_TYPE_SCX == CiTypeOfRoute) && (CI_TRAIN_TEST_ON != ciTrainTestState))
+				if ((CI_TYPE_SCX == chVirCiType) && (CI_TRAIN_TEST_ON != ciTrainTestState))
 				{
 					;
 				}
@@ -1856,7 +1953,6 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 	UINT8 mutualLockState = 0u;
 	UINT8 psdState = 0u;
 
-	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
 	UINT8 RelayCollState = 0u;
 	UINT8 localCi = GetSystemParaLocalCiId();
 	UINT8 virtualZDZFBelongCiId = 0U;
@@ -1876,13 +1972,18 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 	UINT8 esbErrFlag = ESB_ERROR_FLAG_NO;  /*紧急关闭按钮故障标志*/
 	UINT8 chCleFarePDBFlaLigFlag = 0U;/*清客确认箱PDB按钮闪灯状态*/
 	UINT8 chPsdVideoQkDriveState = 0U;/*清客确认箱视频清客驱动状态*/
-	UINT8 chRtnIndicatorDevId = 0U;/*无人折返报警灯设备ID*/
+	UINT16 wRtnIndicatorDevId = 0U;/*无人折返报警灯设备ID*/
 	UINT8 chNonRrnAdhesionState = 0U;/*无人折返按钮粘连状态*/
 	UINT8 cEsbCutErrFlag = ESB_ERROR_FLAG_NO;  /*紧急关闭旁路按钮故障标志*/
-	UINT16 wEsbCollRelayId = 0U;  /*ESB采集继电器ID*/
-	UINT8 cPsdExceptOpenState = 0U;  /*屏蔽门异常打开状态*/
+	UINT8 cPsdExceptState = 0U;  /*屏蔽门异常状态*/
+	UINT8 chJXTCMutualLockFaultState = 0U; /*间隙探测按钮故障状态*/
+	UINT8 chIBPBtnState = 0U; /*IBP按钮状态*/
+	UINT8 chIBPBtnFaultState = 0U; /*IBP按钮故障状态*/
+	UINT8 cEsbCutBtnState = 0U;  /*紧急关闭旁路按钮激活状态*/
+	UINT8 cOnePlatEsbState = 0U;  /*同站紧急按钮激活状态*/
+	UINT8 cOnePlatEsbCutState = 0U;  /*同站紧急旁路按钮激活状态*/
 
-	chRtnIndicatorDevId = GetIndicatorRelNonReturnId(DeviceId);
+	wRtnIndicatorDevId = GetIndicatorRelNonReturnId(DeviceId);
 	virtualZDZFBelongCiId = GetVirtualZDZFBelongCiId();
 	virtualZDZFDevType = GetVirtualZDZFDevType();
 	virtualZDZFButtonState = GetVirtualZDZFButtonState();
@@ -1890,12 +1991,7 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 	switch (MaskType)
 	{
 	case MASK_TYPE_PLAT_AUTORETURNSIG_BUTTONSTAT:/*站台无人折返按钮激活状态码位*/
-		if (FUNC_SWITCH_ON == includeVirFlag)
-		{
-			DealAutoReturnButtonMask_Vir(DeviceId, MaskId, dataBuf);/*若配置虚拟联锁，则DeviceId为指示灯表的行ID*/
-		}
-		else
-		{/*若未配置虚拟联锁，则DeviceId为指示灯ID*/
+		/*若未配置虚拟联锁，则DeviceId为指示灯ID*/
 		for (ii = 0u; ii < GetIndicatorCurSum(); ii++)
 		{
 			if ((DeviceId == GetIndicatorId(ii))
@@ -1921,7 +2017,7 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 					else
 					{
 						RelayCollState = GetRelayCollState(relayIdBuf[2]);
-							chNonRrnAdhesionState = GetNonRtnAdhesionState(chRtnIndicatorDevId);
+						chNonRrnAdhesionState = GetNonRtnAdhesionState(wRtnIndicatorDevId);
 
 						if ((RELAY_STATE_UP == RelayCollState) && (RTN_RELAY_ADHESION_NO == chNonRrnAdhesionState))
 						{/*无人折返按钮继电器吸起*/
@@ -1935,7 +2031,6 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 
 			}
 		}
-		}
 
 		break;
 
@@ -2003,16 +2098,41 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 			/*码位值发0*/
 		}
 		break;
-	case MASK_TYPE_ESP_PRESS_STATE:
-		wEsbCollRelayId = GetEsbRelayId(DeviceId);  /*获取ESB采集继电器*/
-		RelayCollState = GetRelayCollState(wEsbCollRelayId);  /*获取ESB采集继电器状态*/
-		if (RELAY_STATE_UP == RelayCollState)
+	case MASK_TYPE_CUT_ESP_STATE:
+		/*紧急关闭按钮旁路按钮激活状态*/
+		cEsbCutBtnState = GetEsbCutState(DeviceId);
+		if (ESB_CUT_YES == cEsbCutBtnState)
 		{
-			SetMaskValue(MaskId, dataBuf);  /*ESB未按下，发1*/
+			SetMaskValue(MaskId, dataBuf);  /*旁路有效，码位发1*/
 		}
 		else
 		{
-			/*ESB按下，发0*/
+			/*旁路无效，码位发0*/
+		}
+		break;
+	case MASK_TYPE_ONEPLAT_ESP_STATE:
+		/*紧急关闭按钮同站紧急按钮激活状态*/
+		cOnePlatEsbState = GetOnePlatEsbState(DeviceId);
+		cOnePlatEsbCutState = GetOnePlatEsbCutState(DeviceId);
+		if ((ESB_STATE_VALID_NO == cOnePlatEsbState) || (ESB_CUT_YES == cOnePlatEsbCutState))
+		{
+			SetMaskValue(MaskId, dataBuf);  /*紧急无效或旁路有效，码位发1*/
+		}
+		else
+		{
+			/*紧急有效，码位发0*/
+		}
+		break;
+	case MASK_TYPE_ONEPLAT_CUT_ESP_STATE:
+		/*紧急关闭按钮同站旁路按钮激活状态*/
+		cOnePlatEsbCutState = GetOnePlatEsbCutState(DeviceId);
+		if (ESB_CUT_YES == cOnePlatEsbCutState)
+		{
+			SetMaskValue(MaskId, dataBuf);  /*同站旁路有效，码位发1*/
+		}
+		else
+		{
+			/*同站旁路无效，码位发0*/
 		}
 		break;
 	case MASK_TYPE_PSD_STATE_ATS:/*站台屏蔽门状态码位;给ATS*/
@@ -2089,6 +2209,30 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 			else
 			{/*未开始计时或计时未到，给现地和ATS发送无障碍物*/
 			}
+			/* 间隙探测停止时间内，继续采信间隙探测结果*/
+			if(CI_TIME_OUT == SystemOverTimeCheck(GetStopDetectionCycNum(DeviceId), GetwJXTCStopDetectTime()))
+			{
+				/*间隙探测停止时间已经到了，不在继续采信间隙探测结果*/
+			}
+			else
+			{
+				if(0u == GetStopDetectionCycNum(DeviceId))
+				{
+					/*未开始计时*/
+				}
+				else
+				{
+					/* 间隙探测停止时间未到，继续采信间隙探测结果*/
+					if (PSD_REMORA_YES == GetPsdRemoraState(DeviceId))
+					{/*1表示间隙探测有障碍物*/
+						SetMaskValue(MaskId, dataBuf);
+					}
+					else
+					{/*0表示间隙探测无障碍物*/
+					}
+				}
+				
+			}
 		}
 		break;
 	case MASK_TYPE_PSD_JXTC_PANGLU:
@@ -2232,15 +2376,82 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 			/*视频清客驱动状态为无人或者无效，红灯码位无效*/
 		}
 		break;
-	case MASK_TYPE_PSD_EXCEPT_OPEN:  /*站台屏蔽门异常打开状态码位-给ZC/ATS用*/
-		cPsdExceptOpenState = GePsdExceptOpenState(DeviceId);
-		if (PSD_EXCEPT_OPEN_NO == cPsdExceptOpenState)
+	case MASK_TYPE_PSD_EXCEPT:  /*站台屏蔽门异常状态码位-给ATS/ZC用*/
+		cPsdExceptState = GePsdExceptState(DeviceId);
+		if (PSD_EXCEPT_NO == cPsdExceptState)
 		{
-			SetMaskValue(MaskId, dataBuf);  /*PSD未异常打开，码位组1*/
+			SetMaskValue(MaskId, dataBuf);  /*PSD未异常，码位组1*/
 		}
 		else
 		{
-			/*PSD异常打开，码位组0*/
+			/*PSD异常，码位组0*/
+		}
+		break;
+	case MASK_TYPE_PSD_JXTCPANGLU_FAULT:
+		chJXTCMutualLockFaultState= GetPsdJXTCMutualLockFaultState(DeviceId);
+		if (JXTC_MUTUALLOCKFAULT_YES == chJXTCMutualLockFaultState)
+		{/*间隙探测互锁解除按钮故障*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{/*间隙探测互锁解除按钮未故障*/
+
+		}
+		break;
+	case MASK_TYPE_PSD_IBP_STATE:
+		chIBPBtnState= GetPsdButtonIbpState(DeviceId);
+		if (PLATFORM_DEPAR_BUTTON_STATE_VALID == chIBPBtnState)
+		{/*IBP盘发车按钮有效*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{/*IBP盘发车按钮无效*/
+
+		}
+		break;	
+	case MASK_TYPE_PSD_IBP_FAULT:
+		chIBPBtnFaultState= GetPsdButtonIbpState(DeviceId);
+		if (PLATFORM_DEPAR_BUTTON_STATE_FAULT == chIBPBtnFaultState)
+		{/*IBP盘发车按钮故障*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{/*IBP盘发车按钮未故障*/
+
+		}
+		break;	
+	case MASK_TYPE_PSD_JXTC_STATE:
+		if (JXTC_MUTUALLOCK_REMOVE_YES == GetJXTCMutualLockState(DeviceId))
+		{/*间隙探测互锁解除*/
+		}
+		else
+		{/*间隙探测未互锁解除*/
+			if (CI_TIME_OUT == SystemOverTimeCheck(GetStartDetectionCycNum(DeviceId), GetGapDetectCount()))
+			{
+				/*间隙探测开始探测有效*/
+				SetMaskValue(MaskId, dataBuf);
+			}
+			else
+			{
+				/*未开始计时或计时未到，给现地和ATS发送未启动*/
+			}
+			/* 间隙探测停止时间内*/
+			if(CI_TIME_OUT == SystemOverTimeCheck(GetStopDetectionCycNum(DeviceId), GetwJXTCStopDetectTime()))
+			{
+				/*间隙探测停止时间已经到了*/
+			}
+			else
+			{
+				if(0u == GetStopDetectionCycNum(DeviceId))
+				{
+					/*未开始计时*/
+				}
+				else
+				{
+					/* 间隙探测停止时间未到*/
+					SetMaskValue(MaskId, dataBuf);
+				}
+			}
 		}
 		break;
 	default:
@@ -2317,6 +2528,11 @@ UINT8 WashManchineMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 {
 	UINT8 returnValue = CI_SUCCESS;/*返回值默认成功*/
 	UINT8 chWashMachineReadyState = 0U;/*洗车机就绪状态*/
+	UINT8 washAdhesionState = 0U; /*洗车线洗车同意按钮粘连状态*/
+	UINT8 dccWashAdhesionState = 0U; /*DCC洗车同意按钮粘连状态*/
+	UINT8 passWashAdhesionState = 0U; /*洗车线反向通过同意按钮粘连状态*/
+	UINT8 dccPassWashAdhesionState = 0U; /*DCC反向通过同意按钮粘连*/
+	
 	UINT8 chWashModeState = 0U;/*洗车机工作模式*/
 
 	switch (MaskType)
@@ -2342,6 +2558,50 @@ UINT8 WashManchineMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 		{
 		}
 		break;
+	case MASK_TYPE_WASHMACHINE_ZNTBUTTN:
+		/*降级模式洗车线洗车同意按钮粘连码位*/
+		washAdhesionState = GetDownWashAllowErrState(DeviceId);
+		if (WASH_BUTTON_STATE_ERR_NO == washAdhesionState)
+		{
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+		}
+		break;
+	case MASK_TYPE_DCCWASHACHINE_ZNTBUTTN:
+		/*降级模式DCC洗车同意按钮粘连码位*/
+		dccWashAdhesionState = GetDownDccWashAllowErrState(DeviceId);
+		if (WASH_BUTTON_STATE_ERR_NO == dccWashAdhesionState)
+		{
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+		}
+		break;
+	case MASK_TYPE_PASSWASHMACHINE_ZNTBUTTN:
+		/*降级模式洗车线洗车反向通过同意按钮粘连码位*/
+		passWashAdhesionState = GetDownWashAllowPassErrState(DeviceId);
+		if (WASH_BUTTON_STATE_ERR_NO == passWashAdhesionState)
+		{
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+		}
+		break;
+	case MASK_TYPE_DCCPASSWASHMACHINE_ZNTBUTTN:
+		/*降级模式DCC洗车反向通过同意按钮粘连码位*/
+		dccPassWashAdhesionState = GetDownDccWashAllowPassErrState(DeviceId);
+		if (WASH_BUTTON_STATE_ERR_NO == dccPassWashAdhesionState)
+		{
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+		}
+		break;
 	default:
 		returnValue = CI_ERROR;
 		break;
@@ -2765,10 +3025,8 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 	OverlapConditionSwitchStruct* condSwiDataIdBuf = NULL;
 	/* overlap防护道岔 */
 	UINT8 protectSwitchSum = 0u;
-	UINT8 lockStatus = 0u;
 	UINT8 ylockStatus = 0u;/*临时变量：引导总锁状态*/
 	UINT8 fengsuoStateus = 0u;/*临时变量：封锁状态*/
-	UINT8 switchPos = 0u;/*临时变量：道岔位置*/
 	OverlapProtectSwitchStruct* protSwiDataIdBuf = NULL;
 
 	/*防淹门*/
@@ -2777,6 +3035,9 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 	UINT8  devState = 0u;
 	UINT32 laborUnlockStartCycNum = 0u;
 	UINT8 functionId = EFUNC_OVERLAP_VALIDMASK_CHECK;
+	UINT8 cSndSideProFuncSwitch = 0U;
+
+	cSndSideProFuncSwitch = GetSndSideProtectFuncSwitch();  /*二级侧防功能开关*/
 
 	if (0u != rtOverlapLockedId)
 	{
@@ -2797,6 +3058,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 				returnValue = CI_ERROR;
 				break;
 			}
+			else
+			{
+				/*不处理*/
+			}
 		}
 
 		if (ii == overlapPhySecSum)
@@ -2812,13 +3077,15 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 		{				/* overlap道岔 */
 			checkSum = GetOverlapSwitchSum(rtOverlapLockedId);
 			condSwiDataIdBuf = GetOverlapCondSwitchStruct(rtOverlapLockedId);
-			for (ii = 0u; ii < checkSum; ii++)
+			if (NULL != condSwiDataIdBuf)
+			{
+				for (ii = 0U; ii < checkSum; ii++)
 				{
 					if ((SWITCH_LOCK_YINZONG_NO == GetSwitchYLockState(condSwiDataIdBuf[ii].SwitchId)) &&
 						(SWITCH_LOCK_FENGSUO_NO == GetSwitchFLockState(condSwiDataIdBuf[ii].SwitchId)) &&
 						(condSwiDataIdBuf[ii].SwitchPosition == GetSwitchCurPosition(condSwiDataIdBuf[ii].SwitchId)))
 					{
-					/* 保护区段所包含的道岔为：非引导总锁且未封锁且道岔位置正确，才发送码位*/
+						/* 保护区段所包含的道岔为：非引导总锁且未封锁且道岔位置正确，非连通位置不存在侵入，才发送码位*/
 
 					}
 					else
@@ -2829,24 +3096,31 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 					}
 				}
 			}
+			else
+			{
+				returnValue = CI_ERROR;
+				/*异常分支，返回失败*/
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
 
 		if (CI_SUCCESS == returnValue)
-		{	/*保护区段关联防护道岔*/
+		{
+			/*检查保护区段关联防护道岔未引导总锁、未封锁*/
 			protectSwitchSum = GetOverlapRelatedProtSwitSum(rtOverlapLockedId);
 			protSwiDataIdBuf = GetOverlapRelatedProtSwitStru(rtOverlapLockedId);
-			for (ii = 0u; ii < protectSwitchSum; ii++)
+			if (NULL != protSwiDataIdBuf)
+			{
+				for (ii = 0U; ii < protectSwitchSum; ii++)
 				{
-				lockStatus = GetSwitchLockStatus(protSwiDataIdBuf[ii].ProtectSwitchId);
 					ylockStatus = GetSwitchYLockState(protSwiDataIdBuf[ii].ProtectSwitchId);
-				switchPos = GetSwitchCurPosition(protSwiDataIdBuf[ii].ProtectSwitchId);
 					fengsuoStateus = GetSwitchFLockState(protSwiDataIdBuf[ii].ProtectSwitchId);
-
-				if ((SWITCH_LOCK_YINZONG_NO == ylockStatus)
-					&& ((SWITCH_LOCK_STATUS_PROTECT == lockStatus) || (SWITCH_LOCK_STATUS_DAP == lockStatus))
-					&& (protSwiDataIdBuf[ii].ProtectPosition == switchPos)
-					&& (SWITCH_LOCK_FENGSUO_NO == fengsuoStateus))
+					if ((SWITCH_LOCK_YINZONG_NO == ylockStatus) && (SWITCH_LOCK_FENGSUO_NO == fengsuoStateus))
 					{
-					/* 保护区段关联防护道岔：非引导总锁且防护锁闭且道岔位置正确且未封锁，才发送码位*/
+						/*防护道岔未引导总锁、未封锁*/
 					}
 					else
 					{
@@ -2855,6 +3129,62 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 					}
 				}
 			}
+			else
+			{
+				returnValue = CI_ERROR;
+				/*异常分支，返回失败*/
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+
+		/*保护区段关联防护道岔【位置正确】*/
+		if (CI_SUCCESS == returnValue)
+		{
+			devId = 0U;
+			devState = 0U;
+			returnValue = OvlpRelatedProtSwitchPosCheck(rtOverlapLockedId, &devId, &devState);
+			if (CI_SUCCESS == returnValue)
+			{
+				/* 通过检查 */
+			}
+			else
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, ESEND_LEVEL_ZERO);
+				/* 失败返回 */
+				returnValue = CI_ERROR;
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+
+		/*保护区段关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
+		if (CI_SUCCESS == returnValue)
+		{
+			devId = 0U;
+			devState = 0U;
+			returnValue = OvlpRelatedProtSwitchLockCheck(rtOverlapLockedId, &devId, &devState);
+			if (CI_SUCCESS == returnValue)
+			{
+				/* 通过检查 */
+			}
+			else
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, ESEND_LEVEL_ZERO);
+				/* 失败返回 */
+				returnValue = CI_ERROR;
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
 
 		if (CI_SUCCESS == returnValue)
 		{
@@ -2868,6 +3198,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 				returnValue = CI_ERROR;
 			}
 		}
+		else
+		{
+			/*不处理*/
+		}
 
 		if (CI_SUCCESS == returnValue)
 		{
@@ -2880,6 +3214,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 				returnValue = CI_ERROR;
 			}
 		}
+		else
+		{
+			/*不处理*/
+		}
 
 		/*检查保护区段关联防淹门状态*/
 		if (CI_SUCCESS == returnValue)
@@ -2889,7 +3227,16 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 			{
 				SetErrorData(functionId, CI_DEVICE_TYPE_FLOODGATE, devId, devStateType, devState, ESEND_LEVEL_ZERO);
 			}
+			else
+			{
+				/*不处理*/
 			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+
 		/*检查人工解锁保护区段是否处于倒计时过程中，倒计时过程中发ZC,LEU未建立*/
 		if (CI_SUCCESS == returnValue)
 		{
@@ -2898,6 +3245,14 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 			{
 				returnValue = CI_ERROR;
 			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+		else
+		{
+			/*不处理*/
 		}
 
 		/*检查照查继电器状态*/
@@ -2915,6 +3270,28 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 				returnValue = CI_ERROR; 
 			}
 		}
+		else
+		{
+			/*不处理*/
+		}
+
+		if (CI_SUCCESS == returnValue)
+		{
+			if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
+			{
+				/*仅在二级侧防开关配置为支持二级侧防时才进行侧防条件检查*/
+				returnValue = OlapSideProtectConditionCheck(rtOverlapLockedId, 0U, 0U);/*检查保护区段侧防条件*/
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+
 	}
 	else
 	{
@@ -2950,12 +3327,21 @@ void PackCiToCimCommData(void)
 	UINT8 cCommVobcNum = 0U;  /*通信车数量*/
 	UINT8 cVobcToCiDataSum = 0U;
 	VobcToCiDataStruct* pstrVobcToCiData = NULL;
+	UINT8 chlocalMode = RC_WORK_MODE_TO_AIM_CI;
 	UINT32 dwCommBadCycCount = 0U;
 
 	cLocalWorkMode = GetLocalRcWorkMode();
 	cLocalCiId = GetSystemParaLocalCiId();
 	dwCurCycNum = Get2oo2CurCycleNum();
-	ciToCimDataBuffer[i++] = cLocalWorkMode;
+	if (RC_WORK_MODE_CI == cLocalWorkMode)
+	{
+		chlocalMode = RC_WORK_MODE_TO_AIM_CI;
+	}
+	else
+	{
+		chlocalMode = RC_WORK_MODE_TO_AIM_TIOC;
+	}
+	ciToCimDataBuffer[i++] = chlocalMode;
 	ciToCimDataBuffer[i++] = cLocalCiId;
 
 	transmitDevIndex = i;
@@ -3163,22 +3549,22 @@ void PackCiToCimCommData(void)
 
 
 	/*相邻CI系统通信状态*/
-	deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_CI);
-	pDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_CI);
+	deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_RCI);
+	pDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RCI);
 
 	if ((NULL != pDeviceIdBuf) && (0u != deviceSum))
 	{
 		for (j = 0u; j < deviceSum; j++)
 		{
-			transmitState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_CI, j);
+			transmitState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_RCI, j);
 			/*填ID*/
 
 			transmitDevSum++;
-			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_CI;
+			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_RCI;
 			ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
 
 			/*组相邻RC/CI通信冗余周期*/
-			dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_CI, pDeviceIdBuf[j]);
+			dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_RCI, pDeviceIdBuf[j]);
 			if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
 			{
 				ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum);  /*组通信设备冗余周期*/
@@ -3476,10 +3862,10 @@ void DealAutoReturnButtonMask_Vir(UINT16 DeviceId, UINT16 MaskId, UINT8* pdataBu
 	UINT8 virtualZDZFBelongCiId = 0U;
 	UINT8 virtualZDZFDevType = 0U;
 	UINT8 virtualZDZFButtonState = 0U;
-	UINT8 chRtnIndicatorDevId = 0U;/*无人折返报警灯设备ID*/
+	UINT16 wRtnIndicatorDevId = 0U;/*无人折返报警灯设备ID*/
 	UINT8 chNonRrnAdhesionState = 0U;/*无人折返按钮粘连状态*/
 
-	chRtnIndicatorDevId = GetIndicatorRelNonReturnId(DeviceId);
+	wRtnIndicatorDevId = GetIndicatorRelNonReturnId(DeviceId);
 	virtualZDZFBelongCiId = GetVirtualZDZFBelongCiId();
 	virtualZDZFDevType = GetVirtualZDZFDevType();
 	virtualZDZFButtonState = GetVirtualZDZFButtonState();
@@ -3512,7 +3898,7 @@ void DealAutoReturnButtonMask_Vir(UINT16 DeviceId, UINT16 MaskId, UINT8* pdataBu
 				else
 				{
 					RelayCollState = GetRelayCollState(pRelayIdBuf[2]);
-					chNonRrnAdhesionState = GetNonRtnAdhesionState(chRtnIndicatorDevId);
+					chNonRrnAdhesionState = GetNonRtnAdhesionState(wRtnIndicatorDevId);
 					if ((RELAY_STATE_UP == RelayCollState) && (RTN_RELAY_ADHESION_NO == chNonRrnAdhesionState))
 					{/*无人折返按钮继电器吸起*/
 						SetMaskValue(MaskId, pdataBuf);
@@ -3943,7 +4329,9 @@ void PackCiToCimDeviceData(void)
 	PhysicalSectionDataStruct* pPhysicalData = NULL;
 	WashMachineDataStruct* pWashMachineData = NULL;
 	GaragedoorDataStruct* pGrageDoorData = NULL;
+	GaragedoorDataStructCC* pGrageDoorDataCC = NULL;
 	FloodGateDataStruct* pFloodGateData = NULL;
+	FloodGateDataStructCC* pFloodGateDataCC = NULL;
 	UINT8 cRcWorkMode = GetLocalRcWorkMode();
 	UINT8 chSwitchJichaState = 0U;
 	UINT8 chSwitchCurPos = 0U;
@@ -4079,6 +4467,7 @@ void PackCiToCimDeviceData(void)
 		ii += 2u;
 		ciToCimDataBuffer[ii] = pPsdData[deviceId].cPsdExceptOpenState; /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
 		ii++;
+		ciToCimDataBuffer[ii++] = pPsdData[deviceId].ibpButtonState; /*IBP盘发车按钮状态*/
 
 	}
 
@@ -4184,9 +4573,18 @@ void PackCiToCimDeviceData(void)
 		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].WashMachineWorkModeDrvtState;/*洗车机工作模式设置驱动状态(动态字段:驱动)*/
 		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].WashModeState;/*洗车模式(动态字段:采集)*/
 		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chSetWashWorkModeBack;/*设置洗车机工作模式反馈*/
-		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowState;/*降级模式洗车同意状态(动态字段:采集)*/
-		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowPassState;/*降级模式洗车同意通过状态(动态字段:采集)*/
-
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowState;/**降级模式洗车同意状态(动态字段:融合)*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowPassState;/*降级模式洗车同意通过状态(动态字段:融合)*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashReqState;/*降级模式洗车请求状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashPassReqState;/*降级模式反向洗车请求状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowColState;/*降级模式洗车线洗车同意状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownDccWashAllowColState;/*降级模式DCC洗车同意状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowErrState;/*降级模式洗车线洗车同意粘连状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownDccWashAllowErrState;/*降级模式DCC洗车同意粘连状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowPassColState;/*降级模式洗车线洗车同意反向通过状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownDccWashAllowPassColState;/*降级模式DCC洗车同意反向通过状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownWashAllowPassErrState;/*降级模式洗车线洗车同意反向通过粘连状态*/
+		ciToCimDataBuffer[ii++] = pWashMachineData[deviceId].chDownDccWashAllowPassErrState;/*降级模式DCC洗车同意反向通过粘连状态*/
 	}
 
 
@@ -4194,6 +4592,7 @@ void PackCiToCimDeviceData(void)
 	/*打印车库门数据*/
 	deviceNum = GetGaragedoorSum();
 	pGrageDoorData = GetGaragedoorData();
+	pGrageDoorDataCC = GetGaragedoorDataCC();
 	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*车库门数量*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)
@@ -4207,7 +4606,7 @@ void PackCiToCimDeviceData(void)
 		ii += 2u;
 		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorState;      /*车库门状态 (动态字段)*/
 		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorAllowCloseFlag; /*车库门允许关门标志 ZC*/
-		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志 IVOC*/
+		ciToCimDataBuffer[ii++] = pGrageDoorDataCC[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志 IVOC*/
 		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorModeState;       /*车库门模式状态*/
 		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorFaultState;	/*车库门故障状态*/
 		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorPangLuState;    /*车库门旁路状态*/;
@@ -4215,7 +4614,7 @@ void PackCiToCimDeviceData(void)
 		ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].cmdProcessState;			/* 命令处理状态 */
 		LongToChar(pGrageDoorData[deviceId].waiteZCResponseStartCycNum, &ciToCimDataBuffer[ii]);/* 等待ZC反馈开始时间 */
 		ii += 4u;
-		LongToChar(pGrageDoorData[deviceId].waiteIVOCResponseStartCycNum, &ciToCimDataBuffer[ii]);/* 等待IVOC反馈开始时间 */
+		LongToChar(pGrageDoorDataCC[deviceId].waiteIVOCResponseStartCycNum, &ciToCimDataBuffer[ii]);/* 等待IVOC反馈开始时间 */
 		ii += 4u;
 		LongToChar(pGrageDoorData[deviceId].GaragedoorOpenStartCycNum, &ciToCimDataBuffer[ii]);/* 车库门打开开始周期 */
 		ii += 4u;
@@ -4227,6 +4626,7 @@ void PackCiToCimDeviceData(void)
 	/*打印防淹门数据*/
 	deviceNum = GetFloodGateCurSum();
 	pFloodGateData = GetFloodGateData();
+	pFloodGateDataCC = GetFloodGateDataCC();
 	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*防淹门数量*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)
@@ -4254,9 +4654,9 @@ void PackCiToCimDeviceData(void)
 		ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].CurAgreeCloseStateOut;	/* 当前同意关门输出状态（动态字段）*/
 		LongToChar(pFloodGateData[deviceId].CurFloodGateDelayCloseStartCyc, &ciToCimDataBuffer[ii]);/* 防淹门接近区段占压延时关门开始时间 */
 		ii += 4u;
-		ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].FloodGateCloseApplyIvocSum;  /*防淹门关门申请列车数量*/
-		ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].FloodGateCloseAnsIvocSum;   /*防淹门关门允许，列车回复数量*/
-		ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].FloodGateAccessUTFlag;   /*防淹门接近区段是否有非通信车标志*/
+		ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum;  /*防淹门关门申请列车数量*/
+		ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum;   /*防淹门关门允许，列车回复数量*/
+		ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateAccessUTFlag;   /*防淹门接近区段是否有非通信车标志*/
 
 
 	}
@@ -4501,6 +4901,7 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 	UINT16 curCoup = 0U;
 	UINT32 tempera = 0U;
 	UINT8 flagEEPROM = 0U;
+	UINT32 ccuSyn = 0u;/*通控请求序列号*/
 	UINT32 crcRecv = 0U;
 	
 	/*接收到平台心跳帧*/
@@ -4542,6 +4943,9 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 		/*EEPROM存储检验*/
 		flagEEPROM = dataBuf[ii];
 		ii += 1u;
+		/*通控请求序列号*/
+		ccuSyn = LongFromChar(&dataBuf[ii]);
+		ii += 4u;
 		/*CRC校验码*/
 		crcRecv = LongFromChar(&dataBuf[ii]);		/*获取CRC*/
 		ii += 4u;
@@ -4551,7 +4955,7 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 		{
 
 			/*计算CRC校验码,除长度2和CRC4*/
-			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 22U);
+			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 26U);
 
 			
 			if (crcCheck == crcRecv)
@@ -4642,6 +5046,7 @@ UINT8 ParasePlantSEBHeartFrame(UINT8* dataBuf)
 
 	UINT8 boardSEBId = 0U;/*扩展板ID */
 	UINT16 dataLengthRcv = 0U; /*帧长度*/
+	UINT32 sebSyn = 0u;	/*串口请求序列号*/
 	UINT32 crcRecv = 0U;  /*CRC校验码*/
 	UINT32 rcvCyc = 0U;  /*周期号*/
 	/*接收到平台心跳帧*/
@@ -4665,17 +5070,20 @@ UINT8 ParasePlantSEBHeartFrame(UINT8* dataBuf)
 		/*数据内容 3字节*/
 		ii += 5U;
 
+		/*串口请求序列号*/
+		sebSyn = LongFromChar(&dataBuf[ii]);
+		ii += 4U;
 
 		/*CRC校验码*/
 		crcRecv = LongFromChar(&dataBuf[ii]);		/*获取CRC*/
 		ii += 4u;
 
-		/*长度校验*/  /*总长度16字节*/
+		/*长度校验*/  /*总长度20字节*/
 		if (dataLengthRcv == ii - 2U)
 		{
 
 			/*计算CRC校验码,除长度2和CRC4*/
-			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 10U);
+			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 14U);
 
 
 			if (crcCheck == crcRecv)
@@ -5068,7 +5476,7 @@ void PackCiToCimFlyProtectData(void)
 		pFlyData = GetFlyProtectData(chIndex);
 		wTrainId = pFlyData->wTrainId;
 		TrainFlyAxis = pFlyData->flyProtectSecCnt;
-		(void)dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_VOBC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/
+		(void)dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_IVOC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/
 		LongToChar(dwTrainId, &ciToCimDataBuffer[ii]);		/* 列车ID */
 		ii += 4u;
 
@@ -5136,8 +5544,8 @@ void PackCiToCimCollDiffData(void)
 	{/*不处理*/
 	}
 
-	debug_infor_printf((const)"IO Compare Diff OCnum = %d\n", gDiffDataOcNum);
-	debug_out_array(0xAA, ciToCimDataBuffer, ii);
+	(void)debug_infor_printf((const)"IO Compare Diff OCnum = %d\n", gDiffDataOcNum);
+	(void)debug_out_array(0xAA, ciToCimDataBuffer, ii);
 
 	/*发送维护机*/
 	(void)DarkInfoPack(CIM_INFO_IO_COLL_DIFF_ALARM, ciToCimDataBuffer, ii);