[9.3.101] 9.3.101首版二回代码，基线版本

数据提交

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               118   /*集成次数编号*/
 
 #endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/

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

@@ -16,6 +16,7 @@
 #include "NonAutoReturnDataManage.h"
 #include "DynamicRouteDataManage.h"
 #include "../Deployment/DeploymentExtern.h"
+#include "SpeedLimitSecDataManage.h"
 /*交换变量*/
 extern UINT16 TransmitStateDataCurSum;	/*通信关系状态数据当前总数*/
 extern UINT8 ComCycNumForCiToAts;		/*联锁到ATS通信周期记录*/
@@ -812,14 +813,38 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, &g_cTsrSureFlag, sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-		/*拷贝全线临时限速状态*/
+		/*拷贝ZC全线临时限速状态*/
 		(void)memcpy(pCiAppDataPointer + curIndex, &g_AllLineTsrState, sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-		/*拷贝全线临时限速速度*/
+		/*拷贝ZC全线临时限速速度*/
 		(void)memcpy(pCiAppDataPointer + curIndex, &g_AllLineTsrSpeed, sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 
+		/*拷贝TMC全线限速状态*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&gCacheAllSpeedState), (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+		/*拷贝TMC全线限速速度*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&gCacheAllSpeedNum), (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+		/*拷贝台风限速信息*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(TyphoonSpeedDataStruct), (const void*)(&gTyphSpeedInfo), (UINT32)sizeof(TyphoonSpeedDataStruct));
+		curIndex = curIndex + (UINT32)sizeof(TyphoonSpeedDataStruct);
+
+		/*拷贝临时限速数量*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_TsrTMCSum), (const void*)(&g_TsrTMCSum), (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+		
+		/*拷贝临时限速数据结构体*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(TsrTMCDataStruct)* TSR_MAX_SUM, (const void*)(&g_TsrTMCDataStru), (UINT32)sizeof(TsrTMCDataStruct)* TSR_MAX_SUM);
+		curIndex = curIndex + (UINT32)sizeof(TsrTMCDataStruct) * TSR_MAX_SUM;
+
+		/*拷贝限速区段信息结构体*/		
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(SpeedLimitSecInfo)* MAX_LINE_SEC_NUM, (const void*)(&gSpeedLimitSecData), (UINT32)sizeof(SpeedLimitSecInfo)* MAX_LINE_SEC_NUM);
+		curIndex = curIndex + (UINT32)sizeof(SpeedLimitSecInfo) * MAX_LINE_SEC_NUM;
+
         /*拷贝进路数据结构体*/
 		curResult = CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void *)RouteDataStru, ROUTE_SUM_MAX, (UINT16)sizeof(RouteDataStruct));
 		curIndex = curIndex + curResult;
@@ -1159,7 +1184,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		debug_infor_printf((const)"2oo2 m_OcConvertedPtDataArr-CiSendBackDataTempStruSum CRC:%x, Length:%d\n", crcResult, crcLength);
 		crcIndex = curIndex;
 
-#if 1
 		/* 拷贝排序信息 */
 		curIndex = as_GetTransferData(pCiAppDataPointer, curIndex);
 
@@ -1352,14 +1376,131 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (void*)(&SendCiDrCmdDataStru), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
 		curIndex = curIndex + (UINT32)(sizeof(ToCiDrCmdDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
 
-		/*拷贝平台IO电源采集容忍数据*/
+		/*拷贝SSKS闪灯稳灯继电器数据*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(PlatGPIOToleranceDataStruct), (void*)(&gPlatDataGPIOTolercance), (UINT32)sizeof(PlatGPIOToleranceDataStruct));
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(SsksLightRelayDataStruct) * SSKS_LIGHT_RELAY_SUM_MAX), (void*)(&gSsksLightRelayData), (UINT32)(sizeof(SsksLightRelayDataStruct) * SSKS_LIGHT_RELAY_SUM_MAX));
-		curIndex = curIndex + (UINT32)sizeof(PlatGPIOToleranceDataStruct);
+		curIndex = curIndex + (UINT32)(sizeof(SsksLightRelayDataStruct) * SSKS_LIGHT_RELAY_SUM_MAX);
+
+		/*拷贝联络线旁路继电器数据*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ConnectOverrideDataStru) * CONNECT_OVERRIDE_RELAY_SUM_MAX), (void*)(&gConnectOverrideData), (UINT32)(sizeof(ConnectOverrideDataStru) * CONNECT_OVERRIDE_RELAY_SUM_MAX));
+		curIndex = curIndex + (UINT32)(sizeof(ConnectOverrideDataStru) * CONNECT_OVERRIDE_RELAY_SUM_MAX);
+		
+		/*拷贝接触网信息*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(OhlDataStruct)* OHL_MAX_NUM), (void*)(&OhlDataStru), (UINT32)(sizeof(OhlDataStruct)* OHL_MAX_NUM));
+		curIndex = curIndex + (UINT32)(sizeof(OhlDataStruct) * OHL_MAX_NUM);
+
+		/*拷贝全线区段封锁*/
+		(void)CommonMemCpy(pCiAppDataPointer + curIndex, (UINT32)sizeof(UINT8),&g_AllSecFlockState, (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockMsgFst), (const void *)(&g_strAtsAllFlockMsgFst), (UINT32)sizeof(g_strAtsAllFlockMsgFst));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockMsgFst);
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockCfmFst), (const void *)(&g_strAtsAllFlockCfmFst), (UINT32)sizeof(g_strAtsAllFlockCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockCfmFst);
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockMsgSnd), (const void *)(&g_strAtsAllFlockMsgSnd), (UINT32)sizeof(g_strAtsAllFlockMsgSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockMsgSnd);
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockCfmSnd), (const void *)(&g_strAtsAllFlockCfmSnd), (UINT32)sizeof(g_strAtsAllFlockCfmSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockCfmSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(&g_strSndAtsAllFlockCfmFst), (UINT32)sizeof(AtsMsgCfmStru));
+		curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
+
+		/*拷贝ECS动态数据*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ECSDataStruct)* ECS_MAX_NUM), (const void*)(&ECSDataStru), (UINT32)(sizeof(ECSDataStruct)* ECS_MAX_NUM));
+		curIndex = curIndex + (UINT32)(sizeof(ECSDataStruct) * ECS_MAX_NUM);  /*计算一次CRC*/
+
+		/*二乘拷贝全线牵引加速度信息*/
+		pCiAppDataPointer[curIndex] = gAllLineAccelerationState;
+		curIndex += 1U;
+
+		pCiAppDataPointer[curIndex] = gAllLineAccelerationValue;
+		curIndex += 1U;
+
+		/*二乘拷贝全线制动率信息*/
+		pCiAppDataPointer[curIndex] = gAllLineBrakeRateState;
+		curIndex += 1U;
+
+		pCiAppDataPointer[curIndex] = gAllLineBrakeRateValue;
+		curIndex += 1U;
+
+		/*二乘拷贝区间牵引加速度信息*/
+		pCiAppDataPointer[curIndex] = gLocalAreaAccelerationNum;
+		curIndex += 1U;
+
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(AreaAccelerationInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX), (const void*)(gszLocalAreaAcceleration), (UINT32)(sizeof(AreaAccelerationInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX));
+		curIndex = curIndex + (UINT32)(sizeof(AreaAccelerationInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX);
+
+		/*二乘拷贝区间制动率信息*/
+		pCiAppDataPointer[curIndex] = gLocalAreaBrakeRateNum;
+		curIndex += 1U;
+
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(AreaBrakeRateInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX), (const void*)(gszLocalAreaBrakeRate), (UINT32)(sizeof(AreaBrakeRateInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX));
+		curIndex = curIndex + (UINT32)(sizeof(AreaBrakeRateInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX);
+
+		/*拷贝CESB封锁*/
+		(void)CommonMemCpy(pCiAppDataPointer + curIndex, (UINT32)sizeof(UINT8), &g_CesbFlockState, (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+		(void)CommonMemCpy(pCiAppDataPointer + curIndex, (UINT32)sizeof(UINT8), &g_ScxCesbData, (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+		(void)CommonMemCpy(pCiAppDataPointer + curIndex, (UINT32)sizeof(UINT8), &g_ScxCesbCutData, (UINT32)sizeof(UINT8));
+		curIndex = curIndex + (UINT32)sizeof(UINT8);
+		/*CESB网关信息*/
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbMsgFst), (const void *)(&g_strAtsCesbMsgFst), (UINT32)sizeof(g_strAtsCesbMsgFst));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbMsgFst);
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbCfmFst), (const void *)(&g_strAtsCesbCfmFst), (UINT32)sizeof(g_strAtsCesbCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbCfmFst);
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbMsgSnd), (const void *)(&g_strAtsCesbMsgSnd), (UINT32)sizeof(g_strAtsCesbMsgSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbMsgSnd);
+		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbCfmSnd), (const void *)(&g_strAtsCesbCfmSnd), (UINT32)sizeof(g_strAtsCesbCfmSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbCfmSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(&g_strSndAtsCesbCfmFst), (UINT32)sizeof(AtsMsgCfmStru));
+		curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
+
+
+
+		/*ATS网关下发的解封解锁信息*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_JieFengJieSuoMsgFst), (const void*)(&g_JieFengJieSuoMsgFst), (UINT32)sizeof(g_JieFengJieSuoMsgFst));
+		curIndex = curIndex + (UINT32)sizeof(g_JieFengJieSuoMsgFst);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmFst), (const void*)(&g_strAtsJieFengJieSuoCfmFst), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsJieFengJieSuoCfmFst);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_JieFengJieSuoMsgSnd), (const void*)(&g_JieFengJieSuoMsgSnd), (UINT32)sizeof(g_JieFengJieSuoMsgSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_JieFengJieSuoMsgSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmSnd), (const void*)(&g_strAtsJieFengJieSuoCfmSnd), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_strAtsJieFengJieSuoCfmSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SndAtsJieFengJieSuoCfmFst), (const void*)(&g_SndAtsJieFengJieSuoCfmFst), (UINT32)sizeof(g_SndAtsJieFengJieSuoCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_SndAtsJieFengJieSuoCfmFst);
+
+		/*ATS网关下发的道岔强转信息*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceMsgFst), (const void*)(&g_SwitchForceMsgFst), (UINT32)sizeof(g_SwitchForceMsgFst));
+		curIndex = curIndex + (UINT32)sizeof(g_SwitchForceMsgFst);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceCfmFst), (const void*)(&g_SwitchForceCfmFst), (UINT32)sizeof(g_SwitchForceCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_SwitchForceCfmFst);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceMsgSnd), (const void*)(&g_SwitchForceMsgSnd), (UINT32)sizeof(g_SwitchForceMsgSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_SwitchForceMsgSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceCfmSnd), (const void*)(&g_SwitchForceCfmSnd), (UINT32)sizeof(g_SwitchForceCfmSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_SwitchForceCfmSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SndAtsSwitchForceCfmFst), (const void*)(&g_SndAtsSwitchForceCfmFst), (UINT32)sizeof(g_SndAtsSwitchForceCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_SndAtsSwitchForceCfmFst);
+
+
+		/*ATS网关下发的计轴预复位信息*/
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetMsgFst), (const void*)(&g_PhyPreResetMsgFst), (UINT32)sizeof(g_PhyPreResetMsgFst));
+		curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetMsgFst);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetCfmFst), (const void*)(&g_PhyPreResetCfmFst), (UINT32)sizeof(g_PhyPreResetCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetCfmFst);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetMsgSnd), (const void*)(&g_PhyPreResetMsgSnd), (UINT32)sizeof(g_PhyPreResetMsgSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetMsgSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetCfmSnd), (const void*)(&g_PhyPreResetCfmSnd), (UINT32)sizeof(g_PhyPreResetCfmSnd));
+		curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetCfmSnd);
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SndAtsPhyPreResetCfmFst), (const void*)(&g_SndAtsPhyPreResetCfmFst), (UINT32)sizeof(g_SndAtsPhyPreResetCfmFst));
+		curIndex = curIndex + (UINT32)sizeof(g_SndAtsPhyPreResetCfmFst);
+
+		/*获取本控区RC和计轴通信中断设置ARB标志*/
+		pCiAppDataPointer[curIndex] = aam_GetLocalAllAxisSecArbFlag();
+		curIndex += 1U;
+
 
-		/*计算一次CRC*/
 		crcLength = curIndex - crcIndex;
 		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 Deploy_GetTransferData-g_LocalSnowModel CRC:%x, Length:%d\n", crcResult, crcLength);
+		debug_infor_printf((const)"2oo2 Deploy_GetTransferData-g_SndAtsPhyPreResetCfmFst CRC:%x, Length:%d\n", crcResult, crcLength);
 	}
 	return curIndex;
 }
@@ -1490,14 +1631,38 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)memcpy(&g_cTsrSureFlag, pCiAppDataPointer + curIndex, sizeof(UINT8));
 			curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-			/*拷贝全线临时限速状态*/
+			/*拷贝ZC全线临时限速状态*/
 			(void)memcpy(&g_AllLineTsrState, pCiAppDataPointer + curIndex, sizeof(UINT8));
 			curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-			/*拷贝全线临时限速速度*/
+			/*拷贝ZC全线临时限速速度*/
 			(void)memcpy(&g_AllLineTsrSpeed, pCiAppDataPointer + curIndex, sizeof(UINT8));
 			curIndex = curIndex + (UINT32)sizeof(UINT8);
 
+			/*拷贝TMC全线限速状态*/			
+			(void)CommonMemCpy((void*)(&gCacheAllSpeedState), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			/*拷贝TMC全线限速速度*/
+			(void)CommonMemCpy((void*)(&gCacheAllSpeedNum), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			/*拷贝台风限速信息*/
+			(void)CommonMemCpy((void*)(&gTyphSpeedInfo), (UINT32)sizeof(TyphoonSpeedDataStruct), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(TyphoonSpeedDataStruct));
+			curIndex = curIndex + (UINT32)sizeof(TyphoonSpeedDataStruct);
+			
+			/*拷贝临时限速数量*/
+			(void)CommonMemCpy((void*)(&g_TsrTMCSum), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+			
+			/*拷贝临时限速数据结构体*/
+			(void)CommonMemCpy((void*)(g_TsrTMCDataStru), (UINT32)(sizeof(TsrTMCDataStruct)* TSR_MAX_SUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(TsrTMCDataStruct)* TSR_MAX_SUM));
+			curIndex = curIndex + (UINT32)(sizeof(TsrTMCDataStruct) * TSR_MAX_SUM);
+			
+			/*拷贝限速区段数据结构体*/
+			(void)CommonMemCpy((void*)(gSpeedLimitSecData), (UINT32)(sizeof(SpeedLimitSecInfo)* MAX_LINE_SEC_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(SpeedLimitSecInfo)* MAX_LINE_SEC_NUM));
+			curIndex = curIndex + (UINT32)(sizeof(SpeedLimitSecInfo) * MAX_LINE_SEC_NUM);
+
 			/*拷贝进路数据结构体*/
 			curResult = CopyValidSetDataStru(pCiAppDataPointer + curIndex, (void *)&RouteDataStru[0], ROUTE_SUM_MAX, (UINT16)sizeof(RouteDataStruct));
 			curIndex = curIndex + curResult;
@@ -1797,7 +1962,6 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)CommonMemCpy((const void*)(gSzLocalAreaIteCutId), (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX));
 			curIndex = curIndex + (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX);
 
-#if 1
 			/* 拷贝排序信息 */
 			curIndex = as_SetTransferData(pCiAppDataPointer, curIndex);
 
@@ -1909,7 +2073,6 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)CommonMemCpy((void*)(LeuToCiDataStru), (UINT32)sizeof(LeuToCiDataStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(LeuToCiDataStru));
 			curIndex = curIndex + (UINT32)sizeof(LeuToCiDataStru);
 
-#endif
 			/*拷贝停止运营信息*/
 			curIndex = Deploy_SetTransferData(pCiAppDataPointer, curIndex);
 			
@@ -1980,10 +2143,127 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)CommonMemCpy((void*)(&SendCiDrCmdDataStru), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
 			curIndex = curIndex + (UINT32)(sizeof(ToCiDrCmdDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
 
-			/*拷贝平台IO电源采集容忍数据*/
+			/*同步SSKS闪灯稳灯继电器数据*/
-			(void)CommonMemCpy((void*)(&gPlatDataGPIOTolercance), (UINT32)sizeof(PlatGPIOToleranceDataStruct), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(PlatGPIOToleranceDataStruct));
+			(void)CommonMemCpy((void*)(&gSsksLightRelayData), (UINT32)(sizeof(SsksLightRelayDataStruct)* SSKS_LIGHT_RELAY_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(SsksLightRelayDataStruct)* SSKS_LIGHT_RELAY_SUM_MAX));
-			curIndex = curIndex + (UINT32)sizeof(PlatGPIOToleranceDataStruct);
+			curIndex = curIndex + (UINT32)(sizeof(SsksLightRelayDataStruct) * SSKS_LIGHT_RELAY_SUM_MAX);
-#endif
+
+			/*拷贝联络线旁路继电器数据*/
+			(void)CommonMemCpy((void*)(&gConnectOverrideData), (UINT32)(sizeof(ConnectOverrideDataStru)* CONNECT_OVERRIDE_RELAY_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ConnectOverrideDataStru)* CONNECT_OVERRIDE_RELAY_SUM_MAX));
+			curIndex = curIndex + (UINT32)(sizeof(ConnectOverrideDataStru) * CONNECT_OVERRIDE_RELAY_SUM_MAX);
+			
+			/*拷贝接触网信息*/
+			(void)CommonMemCpy((void*)(&OhlDataStru), (UINT32)(sizeof(OhlDataStruct)* OHL_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(OhlDataStruct)* OHL_MAX_NUM));
+			curIndex = curIndex + (UINT32)(sizeof(OhlDataStruct) * OHL_MAX_NUM);
+			/*设置全线区段封锁标志*/
+			g_AllSecFlockState = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+			/*设置全线区段封锁信息*/
+			(void)CommonMemCpy((void *)(&g_strAtsAllFlockMsgFst), (UINT32)sizeof(g_strAtsAllFlockMsgFst), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockMsgFst));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockMsgFst);
+			(void)CommonMemCpy((void *)(&g_strAtsAllFlockCfmFst), (UINT32)sizeof(g_strAtsAllFlockCfmFst), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockCfmFst);
+			(void)CommonMemCpy((void *)(&g_strAtsAllFlockMsgSnd), (UINT32)sizeof(g_strAtsAllFlockMsgSnd), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockMsgSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockMsgSnd);
+			(void)CommonMemCpy((void *)(&g_strAtsAllFlockCfmSnd), (UINT32)sizeof(g_strAtsAllFlockCfmSnd), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsAllFlockCfmSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsAllFlockCfmSnd);
+			(void)CommonMemCpy((void*)(&g_strSndAtsAllFlockCfmFst), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru));
+			curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
+
+			/*同步ECS动态数据*/
+			(void)CommonMemCpy((void*)(&ECSDataStru), (UINT32)(sizeof(ECSDataStruct)* ECS_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ECSDataStruct)* ECS_MAX_NUM));
+			curIndex = curIndex + (UINT32)(sizeof(ECSDataStruct) * ECS_MAX_NUM);
+
+			/*二乘同步全线牵引加速度信息*/
+			gAllLineAccelerationState = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+			gAllLineAccelerationValue = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+			/*二乘同步全线制动率信息*/
+			gAllLineBrakeRateState = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+			gAllLineBrakeRateValue = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+
+			/*二乘同步区间牵引加速度信息*/
+			gLocalAreaAccelerationNum = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+			(void)CommonMemCpy((void*)(gszLocalAreaAcceleration), (UINT32)(sizeof(AreaAccelerationInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(AreaAccelerationInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX));
+			curIndex = curIndex + (UINT32)(sizeof(AreaAccelerationInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX);
+
+			/*二乘同步区间制动率信息*/
+			gLocalAreaBrakeRateNum = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+
+			(void)CommonMemCpy((void*)(gszLocalAreaBrakeRate), (UINT32)(sizeof(AreaBrakeRateInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(AreaBrakeRateInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX));
+			curIndex = curIndex + (UINT32)(sizeof(AreaBrakeRateInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX);
+
+			/*设置CESB状态标志*/
+			g_CesbFlockState = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+			g_ScxCesbData = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+			g_ScxCesbCutData = pCiAppDataPointer[curIndex];
+			curIndex += 1U;
+			/*同步CESB网关消息*/
+			(void)CommonMemCpy((void *)(&g_strAtsCesbMsgFst), (UINT32)sizeof(g_strAtsCesbMsgFst), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbMsgFst));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbMsgFst);
+			(void)CommonMemCpy((void *)(&g_strAtsCesbCfmFst), (UINT32)sizeof(g_strAtsCesbCfmFst), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbCfmFst);
+			(void)CommonMemCpy((void *)(&g_strAtsCesbMsgSnd), (UINT32)sizeof(g_strAtsCesbMsgSnd), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbMsgSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbMsgSnd);
+			(void)CommonMemCpy((void *)(&g_strAtsCesbCfmSnd), (UINT32)sizeof(g_strAtsCesbCfmSnd), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsCesbCfmSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsCesbCfmSnd);
+			(void)CommonMemCpy((void*)(&g_strSndAtsCesbCfmFst), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru));
+			curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
+
+
+			/*同步ATS网关全站解封解锁消息*/
+			(void)CommonMemCpy((void*)(&g_JieFengJieSuoMsgFst), (UINT32)sizeof(g_JieFengJieSuoMsgFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_JieFengJieSuoMsgFst));
+			curIndex = curIndex + (UINT32)sizeof(g_JieFengJieSuoMsgFst);
+			(void)CommonMemCpy((void*)(&g_strAtsJieFengJieSuoCfmFst), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsJieFengJieSuoCfmFst);
+			(void)CommonMemCpy((void*)(&g_JieFengJieSuoMsgSnd), (UINT32)sizeof(g_JieFengJieSuoMsgSnd), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_JieFengJieSuoMsgSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_JieFengJieSuoMsgSnd);
+			(void)CommonMemCpy((void*)(&g_strAtsJieFengJieSuoCfmSnd), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmSnd), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsJieFengJieSuoCfmSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_strAtsJieFengJieSuoCfmSnd);
+			(void)CommonMemCpy((void*)(&g_SndAtsJieFengJieSuoCfmFst), (UINT32)sizeof(g_SndAtsJieFengJieSuoCfmFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SndAtsJieFengJieSuoCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_SndAtsJieFengJieSuoCfmFst);
+
+
+			/*同步ATS网关道岔强转消息*/
+			(void)CommonMemCpy((void*)(&g_SwitchForceMsgFst), (UINT32)sizeof(g_SwitchForceMsgFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceMsgFst));
+			curIndex = curIndex + (UINT32)sizeof(g_SwitchForceMsgFst);
+			(void)CommonMemCpy((void*)(&g_SwitchForceCfmFst), (UINT32)sizeof(g_SwitchForceCfmFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_SwitchForceCfmFst);
+			(void)CommonMemCpy((void*)(&g_SwitchForceMsgSnd), (UINT32)sizeof(g_SwitchForceMsgSnd), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceMsgSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_SwitchForceMsgSnd);
+			(void)CommonMemCpy((void*)(&g_SwitchForceCfmSnd), (UINT32)sizeof(g_SwitchForceCfmSnd), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SwitchForceCfmSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_SwitchForceCfmSnd);
+			(void)CommonMemCpy((void*)(&g_SndAtsSwitchForceCfmFst), (UINT32)sizeof(g_SndAtsSwitchForceCfmFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SndAtsSwitchForceCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_SndAtsSwitchForceCfmFst);
+
+			/*同步ATS网关计轴预复位消息*/
+			(void)CommonMemCpy((void*)(&g_PhyPreResetMsgFst), (UINT32)sizeof(g_PhyPreResetMsgFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetMsgFst));
+			curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetMsgFst);
+			(void)CommonMemCpy((void*)(&g_PhyPreResetCfmFst), (UINT32)sizeof(g_PhyPreResetCfmFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetCfmFst);
+			(void)CommonMemCpy((void*)(&g_PhyPreResetMsgSnd), (UINT32)sizeof(g_PhyPreResetMsgSnd), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetMsgSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetMsgSnd);
+			(void)CommonMemCpy((void*)(&g_PhyPreResetCfmSnd), (UINT32)sizeof(g_PhyPreResetCfmSnd), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_PhyPreResetCfmSnd));
+			curIndex = curIndex + (UINT32)sizeof(g_PhyPreResetCfmSnd);
+			(void)CommonMemCpy((void*)(&g_SndAtsPhyPreResetCfmFst), (UINT32)sizeof(g_SndAtsPhyPreResetCfmFst), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_SndAtsPhyPreResetCfmFst));
+			curIndex = curIndex + (UINT32)sizeof(g_SndAtsPhyPreResetCfmFst);
+
+			/*设置本控区RC和计轴通信中断设置ARB标志*/
+			aam_SetLocalAllAxisSecArbFlag(pCiAppDataPointer[curIndex]);
+			curIndex += 1U;
+
 			rtn = 1u;
 		}
 		

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

@@ -56,6 +56,8 @@
 #include "../Route/LogicalRouteDataManage.h"
 #include "../Route/LongRouteDataManage.h"
 #include "../ReverseCut/ReverseCutDataManage.h"
+#include "../SsksLightRelay/SsksLightRelayDataManage.h"
+#include "AxisAssertManageAPI.h"
 
 #ifdef __cplusplus
 extern "C" {

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

@@ -1074,11 +1074,10 @@ UINT8 InnetChannelIODataRecv(UINT8* ioData)
 
 /*
 * 功能描述： 将队列中的数据传输出去
-* 参数说明： UINT8* thisString, 本周期数据
+* 参数说明： 无
-* 返回值  ： 0: 打印失败
+* 返回值  ： 无
-*			 1: 打印成功
 */
-void SendOut_LogBuff()
+void SendOut_LogBuff(void)
 {
 #if (kPLATFORM==kVXWORKS)
 

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

@@ -374,11 +374,10 @@ QueueStruct* Get2oo2CiToAxisDataQueue(void);
 
 /*
 * 功能描述： 将队列中的数据传输出去
-* 参数说明： UINT8* thisString, 本周期数据
+* 参数说明： 无
-* 返回值  ： 0: 打印失败
+* 返回值  ： 无
-*			 1: 打印成功
 */
-void SendOut_LogBuff();
+void SendOut_LogBuff(void);
 
 
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -164,6 +164,19 @@ typedef struct S_LineCommTrainStruct
 	UINT16 szCommTrainNumID[TRAIN_SUM_MAX];	 /*全线通信车ID数组*/
 }LineCommTrainStruct;
 
+/*区间牵引加速度信息结构体*/
+typedef struct S_AreaAccelerationInfoStruct
+{
+	UINT16 wAreaId;	 /*区间ID*/
+	UINT8 cAreaAccelerationValue;  /*区间牵引加速度值*/
+} AreaAccelerationInfoStruct;
+
+/*区间制动率信息结构体*/
+typedef struct S_AreaBrakeRateInfoStruct
+{
+	UINT16 wAreaId;	 /*区间ID*/
+	UINT8 cAreaBrakeRateValue;  /*区间制动率值*/
+} AreaBrakeRateInfoStruct;
 
 /*******************************全局变量声明*******************************/
 extern UINT8 AllSignalBrightFlag;					                  /*全站亮灯标志*/
@@ -240,6 +253,18 @@ extern UINT8 g_LocalSnowModel;     /*
 extern UINT8 gLocalAreaIteCutNum;  /*本地区间ITE切除数量*/
 extern UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*本地区间ITE切除ID数组*/
 
+extern UINT8 gAllLineAccelerationState;  /*全线牵引加速度设置状态：0x55-未设置；0xAA-已设置*/
+extern UINT8 gAllLineAccelerationValue;  /*全线牵引加速度设置值*/
+
+extern UINT8 gAllLineBrakeRateState;  /*全线制动率设置状态：0x55-未设置；0xAA-已设置*/
+extern UINT8 gAllLineBrakeRateValue;  /*全线制动率设置值*/
+
+extern UINT8 gLocalAreaAccelerationNum;  /*本地区间牵引加速度数量*/
+extern AreaAccelerationInfoStruct gszLocalAreaAcceleration[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间牵引加速度数组*/
+
+extern UINT8 gLocalAreaBrakeRateNum;  /*本地区间制动率数量*/
+extern AreaBrakeRateInfoStruct gszLocalAreaBrakeRate[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间制动率数组*/
+
 /******************************联锁标志数据管理****************************/
 
 /*
@@ -1769,7 +1794,7 @@ AreaSnowInfoStruct* GetLocalAreaSnow(void);
 * 返回值  ：  0 第一个锁闭的区段不是故障锁闭
 *            1 第一个锁闭的区段是故障锁闭
 */
-UINT8 RouteFirstLockErrCheck(UINT16 routeId);
+UINT8 RouteFirstLockErrCheck(UINT16 routeId, UINT16 *pPhySecId);
 
 /*
 * 功能描述：获取全线通信车数据
@@ -1898,4 +1923,162 @@ void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCut
 */
 UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId);
 
+/*
+* 功能描述： 道岔单操可动作物理区段检查
+* 参数说明： UINT16 phySecId，物理区段Id
+*			 UINT8	oper_src,操作来源
+*			 UINT8 sendLevel，发送级别
+* 返回值  ： CI_SUCCESS: 检查成功
+*			 CI_ERROR: 检查失败
+*/
+UINT8 GetDanCaoPhySecValidState(UINT16 phySecId, UINT8 oper_src, UINT8 sendLevel);
+
+/*
+* 功能描述： 道岔强扳可动作物理区段检查
+* 参数说明： UINT16 phySecId，物理区段Id
+*			 UINT8 sendLevel，发送级别
+* 返回值  ： CI_SUCCESS: 检查成功
+*			 CI_ERROR: 检查失败
+*/
+UINT8 GetForcePhySecValidState(UINT16 phySecId, UINT8 sendLevel);
+
+/*
+* 功能描述： 道岔常态位置检查
+* 参数说明： UINT16 wSwitchId，道岔Id
+* 返回值  ： 无
+*/
+void CheckSwitchNomalPosProc(const UINT16 wSwitchId);
+
+/*
+* 功能描述： 道岔定反操互斥条件检查
+* 参数说明： const UINT16 wSwitchId, 道岔ID
+* 返回值  ：CI_SUCCESS: 检查成功
+*			 CI_ERROR: 检查失败
+*/
+UINT8 CheckSwitchDFMulValid(const UINT16 wSwitchId, const UINT8 chSwitchPos);
+
+/*
+* 功能描述： 道岔常态位置检查道岔封锁和道岔区段(包含额外物理区段)封锁
+* 参数说明： UINT16 wSwitchId，道岔Id
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*/
+UINT8 GetSwitchAndSecFLockState(const UINT16 wSwitchId);
+
+/*
+* 功能描述：获取全线牵引加速度设置状态
+* 参数说明：无
+* 返 回 值：0x55 未设置
+*           0xAA 已设置
+* Created By LQ 2026.02.04
+*/
+UINT8 GetAllLineAccelerationState(void);
+
+/*
+* 功能描述：获取全线牵引加速度设置状态
+* 参数说明：UINT8 setState 全线牵引加速度设置状态
+* 返 回 值：无
+* Created By LQ 2026.02.04
+*/
+void SetAllLineAccelerationState(UINT8 setState);
+
+/*
+* 功能描述：获取全线牵引加速度设置值
+* 参数说明：无
+* 返 回 值：全线牵引加速度设置值
+* Created By LQ 2026.02.04
+*/
+UINT8 GetAllLineAccelerationValue(void);
+
+/*
+* 功能描述：设置全线牵引加速度设置值
+* 参数说明：UINT8 setValue 全线牵引加速度设置值
+* 返 回 值：无
+* Created By LQ 2026.02.04
+*/
+void SetAllLineAccelerationValue(UINT8 setValue);
+
+/*
+* 功能描述：获取全线制动率设置状态
+* 参数说明：无
+* 返 回 值：0x55 未设置
+*           0xAA 已设置
+* Created By LQ 2026.02.04
+*/
+UINT8 GetAllLineBrakeRateState(void);
+
+/*
+* 功能描述：设置全线制动率设置状态
+* 参数说明：UINT8 setState 全线制动率设置状态
+* 返 回 值：无
+* Created By LQ 2026.02.04
+*/
+void SetAllLineBrakeRateState(UINT8 setState);
+
+/*
+* 功能描述：获取全线牵引加速度设置值
+* 参数说明：无
+* 返 回 值：全线牵引加速度设置值
+* Created By LQ 2026.02.04
+*/
+UINT8 GetAllLineBrakeRateValue(void);
+
+/*
+* 功能描述：设置全线牵引加速度设置值
+* 参数说明：UINT8 setValue 全线牵引加速度设置值
+* 返 回 值：无
+* Created By LQ 2026.02.04
+*/
+void SetAllLineBrakeRateValue(UINT8 setValue);
+
+/*
+* 功能描述：设置本地区间牵引加速度信息
+* 参数说明：const UINT8 cAreaNum 区间数量
+*			const AreaAccelerationInfoStruct pAreaAccBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间牵引加速度数组
+* 返 回 值：无
+* Created By LQ 2026.02.04
+*/
+void SetLocalAreaAccelerationInfo(const UINT8 cAreaNum, const AreaAccelerationInfoStruct pAreaAccBuf[LOCAL_AREA_SNOW_SUM_MAX]);
+
+/*
+* 功能描述：获取本地区间牵引加速度数量
+* 参数说明：无
+* 返 回 值：区间牵引加速度数量
+* Created By LQ 2026.02.04
+*/
+UINT8 GetLocalAreaAccelerationNum(void);
+
+/*
+* 功能描述：获取本地区间牵引加速度信息
+* 参数说明：无
+* 返 回 值：区间牵引加速度信息
+* Created By LQ 2026.02.04
+*/
+AreaAccelerationInfoStruct* GetLocalAreaAcceleration(void);
+
+/*
+* 功能描述：设置本地区间制动率信息
+* 参数说明：const UINT8 cAreaNum 区间数量
+*			const AreaBrakeRateInfoStruct pAreaBrakeBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间制动率数组
+* 返 回 值：无
+* Created By LQ 2026.02.04
+*/
+void SetLocalAreaBrakeRateInfo(const UINT8 cAreaNum, const AreaBrakeRateInfoStruct pAreaBrakeBuf[LOCAL_AREA_SNOW_SUM_MAX]);
+
+/*
+* 功能描述：获取本地区间制动率数量
+* 参数说明：无
+* 返 回 值：区间制动率数量
+* Created By LQ 2026.02.04
+*/
+UINT8 GetLocalAreaBrakeRateNum(void);
+
+/*
+* 功能描述：获取本地区间制动率信息
+* 参数说明：无
+* 返 回 值：区间制动率信息
+* Created By LQ 2026.02.04
+*/
+AreaBrakeRateInfoStruct* GetLocalAreaBrakeRate(void);
+
 #endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -189,6 +189,13 @@
 #define EFUNC_OpenLogRouteSignalProcess	((UINT8)0xC5)	/*LogRouteSignalProcess开放逻辑进路信号条件检查*/
 #define EFUNC_LOGROUTE_LOGIC_RES_APP_CHECK	((UINT8)0xC6)	/*逻辑进路逻辑区段资源可用性检查*/
 #define EFUNC_LogRoureUsingStateCheck	((UINT8)0xC7)	/*LogRoutePhySecUseLogicProcess*/
+/*联络线相关报警函数*/
+#define EFUNC_ConnectOverrideSetProc	((UINT8)0xCA)			/*ConnectOverrideSetProc*/
+#define EFUNC_ConnectSwitchAlarmProc	((UINT8)0xCB)			/*LogSecConnectSwitchAlarmProc*/
+#define EFUNC_GetDisneyGJDriveState		((UINT8)0xCC)			/*GetDisneyGJDriveState*/
+#define EFUNC_DsnConnectOtherCi			((UINT8)0xCD)			/*DsnConnectOtherCiValidCheck*/
+#define EFUNC_LogSecDsnConnectCheck		((UINT8)0xCE)			/*LogSecDsnConnectCheck*/
+#define EFUNC_RouteCbtcTiranEnterCheck	((UINT8)0xCF)			/*RouteCbtcTiranEnterCheck*/
 /*其他函数*/
 #define EFUNC_LOGIC_MANAGE_SYETEM           ((UINT8)0xF0)    /* Logicmanage.c中导致宕机异常 */
 #define EFUNC_CHECK_ROUTE_SEC_FLOCK         ((UINT8)0xF1)    /* RouteSecFlockVainCheck */
@@ -234,7 +241,10 @@
 #define ETYPE_ROUTE_APPLY_SWITCH_CHECK		((UINT8)0x0b)	/*进路办理道岔状态检查*/
 #define ETYPE_ROUTE_XUANPAI_OVERTIME		((UINT8)0x10)	/*进路选排超时*/
 #define ETYPE_GROUP_AUTO_ROUTE_STATE		((UINT8)0x16)	/*组合自动进路*/
+#define ETYPE_ROUTE_CONNECT_OVERRIME		((UINT8)0x18)	/*（联络线）进路办理超时*/
 #define ETYPE_ROUTE_APPLY_SWITCH_MOVE		((UINT8)0xA4)	/*进路道岔单操中*/
+#define ETYPE_ROUTE_DSNCONNECT				((UINT8)0x19)	/*迪士尼联络线联锁条件*/
+#define ETYPE_ROUTE_DSNCONNECT_CROSS		((UINT8)0x1A)	/*迪士尼联络线跨压*/
 
 
 #define ETYPE_COMM_WITH_VOBC		((UINT8)0x11)	/*与VOBC通信*/
@@ -310,6 +320,8 @@
 #define ETYPE_SWT_USE_STATE     		((UINT8)0x6aU)		/*道岔征用*/
 #define ETYPE_SWT_MOVE_STATE     		((UINT8)0x6bU)		/*道岔搬动状态*/
 #define ETYPE_SWT_MOVE_CHECK_RESULT     ((UINT8)0x6cU)		/*道岔可动性检查结果*/
+#define ETYPE_SWT_WAIT_MOVE             ((UINT8)0x6dU)		/*等待道岔动作完成*/
+#define ETYPE_SWT_CONNECT_RET_FAIL		((UINT8)0x6Eu)		/* Point failed to move to normal within 20 seconds of the over switch block being cleared */
 
 /* 继电器故障类型编码 (UINT8)0x81-(UINT8)0x8f */
 /* 设备类型 CI_DEVICE_TYPE_RELAY */
@@ -386,6 +398,9 @@
 #define ETYPE_LOGSEC_FIRSTLOCK_STATE                ((UINT8)0xC6)       /*逻辑区段为第一个锁闭区段检查*/
 #define ETYPE_LOGSEC_CBTC_PROPERTY                  ((UINT8)0xC7)       /*逻辑区段CBTC属性检查*/
 #define ETYPE_LOGSEC_CONTINUOUS                     ((UINT8)0xC8)       /*逻辑区段连续性检查*/
+#define ETYPE_LOGSEC_CT_OVERRIDE_FAIL				((UINT8)0xC9)       /*逻辑区段有CT列车占用，旁路无效*/
+#define ETYPE_LOGSEC_EA_BUILD						((UINT8)0xCA)		/*逻辑区段防护区建立*/
+#define ETYPE_LOGSEC_DIRLOC_FAIL					((UINT8)0xCB)		/*逻辑区段继电器检查条件不满足（迪士尼联络线）*/
 
 /*动态路径故障类型*/
 #define ETYPE_PART_ROUTE_RES             ((UINT8)0xD0)       /*动态路径资源检查*/

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

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

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

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

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

@@ -11,9 +11,12 @@
 
 #include "ESBDataManage.h"
 #include "ESBConfigDataManage.h"
-
+#include "../ParsePack/ParsePackGateWayData.h"
+#include "../QueryFiles/dquCIInterFace.h"
 EsbDataStruct EsbDataStru[ESB_SUM_MAX];   /*定义ESB数据结构体*/
-
+UINT8 g_CesbFlockState = CESB_STATE_VALID_NO;	/* 全线区段CESB封锁状态 */
+UINT8 g_ScxCesbData = CESB_STATE_VALID_NO; /*试车线CESB状态*/
+UINT8 g_ScxCesbCutData = ESB_CUT_NO;/*试车线CESB旁路状态*/
 
 /*
 * 功能描述： 获取指定ESB数据
@@ -1073,3 +1076,376 @@ UINT8 GetEsbRelayDownState(const UINT16 esbId)
 
 	return reVal;
 }
+
+/**
+* @brief 设置全线区段CESB封锁全局变量状态
+* @param const UINT8 chState 全线区段CESB封锁状态
+* @return 无
+* @note 当输入参数不合法时，设置全线区段CESB封锁
+* Created By fan 2026.02.04
+*/
+void SetAllSecCesbState(const UINT8 chState)
+{
+	if (CESB_STATE_VALID_NO == chState)
+	{
+		g_CesbFlockState = chState;
+	}
+	else
+	{
+		g_CesbFlockState = CESB_STATE_VALID_YES;
+	}
+}
+
+/**
+* @brief 获取全线区段CESB封锁全局变量状态
+* @param 无
+* @return CESB_STATE_VALID_NO:未全线CESB封锁；CESB_STATE_VALID_YES :全线CESB封锁
+* Created By fan 2026.02.04
+*/
+UINT8 GetAllSecCesbState(void)
+{
+	return g_CesbFlockState;
+}
+
+/**
+* @brief 全线CEsb封锁取消主处理函数
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void CancleCesbFlockCmdProc(void)
+{
+	AtsCESBCancleMsgStru * strMsgFst = NULL;
+	AtsCESBCancleMsgStru * strMsgSnd = NULL;
+
+	/*以下消息获取不会返回NULL*/
+	strMsgFst = GetAtsCesbMsgFst();
+	strMsgSnd = GetAtsCesbMsgSnd();
+
+	if ((strMsgFst->chFlag != FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET))
+	{
+		; /* 没有消息，什么也不做 */
+	}
+	else if ((strMsgFst->chFlag == FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET))
+	{/* 一次消息 */
+		CancelCesbFlockAtsCmdFst();
+	}
+	else
+	{/* 二次消息 */
+		CancelCesbFlockAtsCmdSnd();
+	}
+}
+
+/**
+* @brief 全线CESB首次命令处理函数
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void CancelCesbFlockAtsCmdFst(void)
+{
+	AtsCESBCancleMsgStru * strMsgFst = NULL;
+	AtsMsgCfmStru * strCfmFst = NULL;
+	UINT32 dwCycle = 0u;
+	UINT8 chLocalId = 0u;
+	UINT8 szCrcTmp[1024] = { 0u };
+	UINT32 ii = 0u;
+	UINT8 chFunRtn = CI_TIME_OUT;
+	UINT8 chState = 0U;  /*全线区段CESB封锁状态*/
+	UINT16 wCesbRelayId = 0u;/*CESB继电器*/
+	UINT8 chCesbState = 0U;/*CESB激活状态*/
+	UINT16 wCesbCutRelayId = 0u;/*CESB旁路继电器*/
+	UINT8 chCesbCutState = 0U;/*CESB旁路状态*/
+	UINT8 localCiType = 0U;/*联锁类型*/
+	chLocalId = GetSystemParaLocalCiId();
+	dwCycle = Get2oo2CurCycleNum();
+	/*以下消息获取不会返回NULL*/
+	strMsgFst = GetAtsCesbMsgFst();
+	strCfmFst = GetAtsCesbCfmFst();
+	chState = GetAllSecCesbState();
+	if (strMsgFst->dwCycle == dwCycle)
+	{
+		strCfmFst->chFlag = FLAG_SET;
+		strCfmFst->chTiocId = chLocalId;
+		strCfmFst->chStation = strMsgFst->chStation;
+		strCfmFst->wIndex = strMsgFst->wIndex;
+		strCfmFst->dwTime = dwCycle;
+		
+		/* 取消全线区段CESB封锁 */
+		if (CESB_STATE_VALID_NO == chState)
+		{/* 当前未设置 */
+			strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_FST_UNSET;
+		}
+		else
+		{
+			localCiType = GetLocalCiType();/*获取联锁类型*/
+			if (CI_TYPE_SCX == localCiType)
+			{
+				/*获取试车线旁路及激活命令状态*/
+				chCesbState = GetScxCesbCmdState();
+				chCesbCutState = GetScxCesbCutCmdState();
+				/*旁路或未激活*/
+				if ((CESB_STATE_VALID_NO == chCesbState) || (ESB_CUT_YES == chCesbCutState))
+				{
+					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_FST_SUCCESS;
+				}
+				else
+				{
+					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;
+				}
+			}
+			else
+			{
+				wCesbRelayId = GetCesbRelayId();
+				chCesbState = GetRelayCollState(wCesbRelayId);
+				wCesbCutRelayId = GetCesbCutRelayId();
+				chCesbCutState = GetRelayCollState(wCesbCutRelayId);
+				if ((RELAY_STATE_UP == chCesbCutState) || (RELAY_STATE_UP == chCesbState))
+				{
+					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_FST_SUCCESS;
+				}
+				else
+				{
+					strCfmFst->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;
+				}
+			}
+		}
+
+		szCrcTmp[ii] = strMsgFst->chAtsId;
+		ii++;
+		szCrcTmp[ii] = strMsgFst->chStation;
+		ii++;
+		ShortToChar(strMsgFst->wIndex, &szCrcTmp[ii]);
+		ii += 2U;
+		LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]);
+		ii += 4u;
+		strCfmFst->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii);	/* ATS编号、车站编号、操作站编号、下发时间、命令类型计算CRC */
+
+		if (CONFIRM_CANCLE_CESB_FST_SUCCESS != strCfmFst->chOpStatus)
+		{
+			ClearAtsCesbMsgFirst(); /*处理不成功，需清除一次命令 */
+		}
+		else
+		{
+			;
+		}
+	}
+	else
+	{/* 接收到ATS一次消息非本周期，超时判断 */
+		chFunRtn = SystemOverTimeCheck(strMsgFst->dwCycle, CONFIRM_TIMEOUT_CC);
+		if (CI_TIME_OUT == chFunRtn)
+		{
+			ClearAtsCesbMsgFirst();
+		}
+		else
+		{
+			;
+		}
+	}
+}
+
+/**
+* @brief 取消CESB封锁二次命令处理函数
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void CancelCesbFlockAtsCmdSnd(void)
+{
+	AtsCESBCancleMsgStru * strMsgFst = NULL;
+	AtsCESBCancleMsgStru * strMsgSnd = NULL;
+	AtsMsgCfmStru * strCfmFst = NULL;
+	AtsMsgCfmStru * strCfmSnd = NULL;
+	UINT32 dwCycle = 0u;
+	UINT8 chLocalId = 0u;
+	UINT8 chFlag = FLAG_UNSET;
+	UINT8 szCrcTmp[1024] = { 0u };
+	UINT32 ii = 0u;
+	UINT32 dwCrc = 0u;
+	UINT16 wCesbRelayId = 0u;/*CESB继电器*/
+	UINT8 chCesbState = 0U;/*CESB激活状态*/
+	UINT16 wCesbCutRelayId = 0u;/*CESB旁路继电器*/
+	UINT8 chCesbCutState = 0U;/*CESB旁路状态*/
+	UINT8 localCiType = 0U;/*联锁类型*/
+	chLocalId = GetSystemParaLocalCiId();
+	dwCycle = Get2oo2CurCycleNum();
+	strMsgFst = GetAtsCesbMsgFst();
+	strMsgSnd = GetAtsCesbMsgSnd();
+	strCfmFst = GetAtsCesbCfmFst();
+	strCfmSnd = GetAtsCesbCfmSnd();
+
+	if ((NULL != strMsgFst)
+		&& (NULL != strMsgSnd)
+		&& (NULL != strCfmFst)
+		&& (NULL != strCfmSnd))
+	{
+		if (strMsgSnd->dwCycle == dwCycle)
+		{
+			strCfmSnd->chFlag = FLAG_SET;
+			strCfmSnd->chTiocId = chLocalId;
+			strCfmSnd->chStation = strMsgSnd->chStation;
+			strCfmSnd->wIndex = strMsgSnd->wIndex;
+			strCfmSnd->dwTime = dwCycle;
+
+			if (FLAG_SET != strMsgFst->chFlag)
+			{
+				strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_FIRST;  /* 一次命令未执行，返回未执行首次取消 */
+				chFlag = FLAG_SET;
+			}
+			else if ((strMsgSnd->chAtsId != strMsgFst->chAtsId)
+				|| (strMsgSnd->chStation != strMsgFst->chStation)
+				|| (strMsgSnd->wIndex != strMsgFst->wIndex))
+			{
+				strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_UNKNOWN;  /* ATS一二次命令帧头输入不一致，返回未知 */
+				chFlag = FLAG_SET;
+			}
+			else
+			{
+				localCiType = GetLocalCiType();/*获取联锁类型*/
+				if (CI_TYPE_SCX == localCiType)
+				{
+					/*获取试车线旁路及激活命令状态*/
+					chCesbState = GetScxCesbCmdState();
+					chCesbCutState = GetScxCesbCutCmdState();
+					/*旁路或未激活成功*/
+					if ((CESB_STATE_VALID_YES == chCesbState) && (ESB_CUT_NO == chCesbCutState))
+					{
+						strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;  /* 未旁路且CESB仍然有效*/
+						chFlag = FLAG_SET;
+					}
+					else
+					{
+						;/*不处理*/
+					}
+				}
+				else
+				{
+					/*正线看继电器状态*/
+					wCesbRelayId = GetCesbRelayId();
+					chCesbState = GetRelayCollState(wCesbRelayId);
+					wCesbCutRelayId = GetCesbCutRelayId();
+					chCesbCutState = GetRelayCollState(wCesbCutRelayId);
+					if ((RELAY_STATE_UP != chCesbCutState) && (RELAY_STATE_UP != chCesbState))
+					{
+						strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_RELAY_ACTIVE;  /* 未旁路且CESB仍然有效*/
+						chFlag = FLAG_SET;
+					}
+					else
+					{
+						/*不处理*/
+						;
+					}
+				}
+			}
+
+			if (FLAG_UNSET == chFlag)
+			{
+				szCrcTmp[ii] = strMsgSnd->chTiocId;
+				ii++;
+				LongToChar(strCfmFst->dwTime, &szCrcTmp[ii]);
+				ii += 4u;
+				dwCrc = Tioc_CommonCrc32(szCrcTmp, ii);
+
+				if (dwCrc != strMsgSnd->dwCrc32)
+				{
+					strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_CHECKFAIL;  /* 计算的CRC32与ATS二次消息CRC32不一致 */
+					chFlag = FLAG_SET;
+				}
+				else
+				{
+					;
+				}
+			}
+			else
+			{
+				;
+			}
+
+			ii = 0u;
+			szCrcTmp[ii++] = strMsgSnd->chAtsId;
+			szCrcTmp[ii++] = strMsgSnd->chStation;
+			ShortToChar(strMsgSnd->wIndex, &szCrcTmp[ii]);
+			ii += 2U;
+			LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]);
+			ii += 4u;
+			LongToChar(strMsgSnd->dwTime, &szCrcTmp[ii]);
+			ii += 4u;
+			strCfmSnd->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii);
+			if (FLAG_UNSET == chFlag)
+			{
+				strCfmSnd->chOpStatus = CONFIRM_CANCLE_CESB_SND_SUCCESS;  /* 检查通过，反馈确认成功 */
+				SetAllSecCesbState(CESB_STATE_VALID_NO);  /*设置CESB封锁无效*/
+			}
+			else
+			{
+				;
+			}
+		}
+		else
+		{
+			; /** 非本周期消息，不处理 */
+		}
+		ClearAtsCesbMsgFirst();
+		ClearAtsCesbMsgSecond();
+	}
+	else
+	{
+		; /**不可能分支 不处理 */
+	}
+}
+
+/**
+* @brief 获取试车线CESB命令设置状态
+* @param 无
+* @return CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+* Created By fan 2026.03.10
+*/
+UINT8 GetScxCesbCmdState(void)
+{
+	return g_ScxCesbData;
+}
+
+/**
+* @brief 设置试车线CESB命令状态
+* @input  CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+* Created By fan 2026.03.10
+*/
+void SetScxCesbCmdState(UINT8 chCesbCmd)
+{
+	if ((CESB_STATE_VALID_NO == chCesbCmd)||(CESB_STATE_VALID_YES == chCesbCmd))
+	{
+		g_ScxCesbData = chCesbCmd;
+	}
+	else
+	{
+		;/*不处理*/
+	}
+}
+
+/**
+* @brief 获取全线区段试车线CESB旁路命令设置状态
+* @param 无
+* @return ESB_CUT_NO:试车线未CESB旁路；ESB_CUT_YES 试车线CESB旁路有效
+* Created By fan 2026.03.10
+*/
+UINT8 GetScxCesbCutCmdState(void)
+{
+	return g_ScxCesbCutData;
+}
+
+/**
+* @brief 设置试车线CESB旁路命令状态
+* @input ESB_CUT_NO: 试车线未CESB旁路；ESB_CUT_YES : 试车线CESB旁路
+* Created By fan 2026.03.10
+*/
+void SetScxCesbCutCmdState(UINT8 chCesbCmd)
+{
+	if ((ESB_CUT_NO == chCesbCmd) || (ESB_CUT_YES == chCesbCmd))
+	{
+		g_ScxCesbCutData = chCesbCmd;
+	}
+	else
+	{
+		;/*不处理*/
+	}
+}

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

@@ -19,6 +19,7 @@
 #include "ESBConfigDataManage.h"
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
+#include "../Section/SectionDefine.h"
 
 
 #ifdef __cplusplus
@@ -51,9 +52,14 @@ typedef struct S_EsbDataStruct
 	UINT8 EsbCutRelayDownState;  /*紧急关闭旁路按钮采集继电器落下状态，0x55-正常采集落下，0xaa-通信异常落下*/
 } EsbDataStruct;
 
+
+
+
 /*******************************全局变量声明*******************************/
 extern EsbDataStruct EsbDataStru[ESB_SUM_MAX];   /*定义ESB数据结构体*/
-
+extern UINT8 g_CesbFlockState ;	/* 全线区段CESB封锁状态 */
+extern UINT8 g_ScxCesbData;/*试车线CESB状态*/
+extern UINT8 g_ScxCesbCutData;/*试车线CESB旁路状态*/
 
 /*
 * 功能描述： 获取指定ESB数据
@@ -407,6 +413,77 @@ void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState);
 */
 UINT8 GetEsbRelayDownState(const UINT16 esbId);
 
+/**
+* @brief 设置全线区段CESB封锁全局变量状态
+* @param const UINT8 chState 全线区段CESB封锁状态
+* @return 无
+* @note 当输入参数不合法时，设置全线区段CESB封锁
+* Created By fan 2026.02.04
+*/
+void SetAllSecCesbState(const UINT8 chState);
+
+/**
+* @brief 获取全线区段CESB封锁全局变量状态
+* @param 无
+* @return CESB_STATE_VALID_NO:未全线CESB封锁；CESB_STATE_VALID_YES :全线CESB封锁
+* Created By fan 2026.02.04
+*/
+UINT8 GetAllSecCesbState(void);
+
+/**
+* @brief 全线CEsb封锁取消主处理函数
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void CancleCesbFlockCmdProc(void);
+
+/**
+* @brief 全线CESB首次命令处理函数
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void CancelCesbFlockAtsCmdFst(void);
+
+/**
+* @brief 取消CESB封锁二次命令处理函数
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void CancelCesbFlockAtsCmdSnd(void);
+
+/**
+* @brief 获取试车线CESB命令设置状态
+* @param 无
+* @return CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+* Created By fan 2026.03.10
+*/
+UINT8 GetScxCesbCmdState(void);
+
+/**
+* @brief 设置试车线CESB命令状态
+* @input  CESB_STATE_VALID_NO 试车线CESB未激活；CESB_STATE_VALID_YES :试车线CESB激活
+* Created By fan 2026.03.10
+*/
+void SetScxCesbCmdState(UINT8 chCesbCmd);
+
+/**
+* @brief 获取全线区段试车线CESB旁路命令设置状态
+* @param 无
+* @return ESB_CUT_NO:试车线未CESB旁路；ESB_CUT_YES 试车线CESB旁路有效
+* Created By fan 2026.03.10
+*/
+UINT8 GetScxCesbCutCmdState(void);
+
+/**
+* @brief 设置试车线CESB旁路命令状态
+* @input ESB_CUT_NO: 试车线未CESB旁路；ESB_CUT_YES : 试车线CESB旁路
+* Created By fan 2026.03.10
+*/
+void SetScxCesbCutCmdState(UINT8 chCesbCmd);
+
 #ifdef __cplusplus
 }
 #endif

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

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

TSCP/src/APP/ciapp/EnvelopeManage/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
 				{
-					; /*未超过冗余时间或列车通信中断*/
+					; /*未超过冗余时间*/
 				}
 			}
 		}
@@ -1527,8 +1511,6 @@ void elm_MaintenanceInfo(void)
 			outStringLength++;
 			outString[outStringLength] = pAcAssertInfo->redunOverCanArb;  /*冗余结束可判ARB标志*/
 			outStringLength++;
-			outString[outStringLength] = pAcAssertInfo->AxisCommBadArbFlag;  /*计轴通信中断可判ARB标志*/
-			outStringLength++;
 			outString[outStringLength] = pAcAssertInfo->passTrainFlag;  /*计轴区段好车通过标志*/
 			outStringLength++;
 			ShortToChar(pAcAssertInfo->passTrainID, &outString[outStringLength]);  /*计轴区段好车通过的列车ID*/
@@ -3064,13 +3046,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 +3094,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/EnvelopeScreen.c

@@ -6,6 +6,8 @@
 #include "EnvelopeLogicProcess.h"
 #include "WholeLineScreenAPI.h"
 #include "TrainDataManage.h"
+#include "SystemParameterManage.h"
+#include "DeviceDataManage.h"
 
 
 /*================================静态函数声明区==============================*/
@@ -563,6 +565,12 @@ void elm_TrainScreen(void)
 	UINT32 errorCode = 0u;
 	UINT8 comstatus = 0U;
 	const EnvelopeStruct* pEnvelop = NULL;
+	UINT8 cLocalCiType = 0U;
+	UINT8 cDsnFuncSwitch = 0U;  /*迪士尼功能开关*/
+	UINT8 cCurTrainTestStatus = 0U;  /*当前试车状态*/
+	UINT8 cFuncRetVal = CI_ERROR;
+	UINT8 cAcNum = 0U;  /*车身占用的计轴区段数量*/
+	UINT16 szAcId[MAX_AC_IN_TRAIN] = { 0U };  /*车身占用的计轴区段ID数组*/
 
 	for (cycle = 1u; cycle < ENVELOPE_SUM_MAX; cycle++)
 	{
@@ -579,7 +587,23 @@ void elm_TrainScreen(void)
 			/** 获取列车的通信状态 */
 			comstatus = elm_PrepareTrainCommStatus(pEnvelop->trainID[0u]);
 			/*CT包络且通信正常，才进行筛选*/
-			if ((TYPE_CT_ENVELOPE == pEnvelop->envelopeType)&&(ELM_COM_STATUS_OK ==comstatus))
+			if ((TYPE_CT_ENVELOPE == pEnvelop->envelopeType) && (ELM_COM_STATUS_OK == comstatus))
+			{
+				cLocalCiType = GetLocalCiType();
+				cDsnFuncSwitch = GetCiFunctionSwitchConfig(FUNC_DSN_LINE_SWITCH);
+				cCurTrainTestStatus = GetCiTrainTestStatus();  /*获取试车状态*/
+				cFuncRetVal = CheckTrainIsCompletelyLocal(pEnvelop->trainID[0U], &cAcNum, szAcId);  /*判断列车是否完全在本控区*/
+
+				if ((CI_TYPE_SCX == cLocalCiType)
+					&& (FUNC_SWITCH_ON == cDsnFuncSwitch)
+					&& (CI_TRAIN_TEST_ON == cCurTrainTestStatus)
+					&& (CI_SUCCESS == cFuncRetVal))
+				{
+					/*DSN试车线在试车中时，RC设置本控区内的通信车无前后端可疑*/
+					(void)elm_SetEnvelopeHeadTrainID(pEnvelop->id, 0U);
+					(void)elm_SetEnvelopeTailTrainID(pEnvelop->id, 0U);
+				}
+				else
 				{
 					/** 判断前端是否可疑 */
 					if (0u != pEnvelop->headTrainID)
@@ -602,6 +626,7 @@ void elm_TrainScreen(void)
 					{
 						/** 无需处理 */
 					}
+				}
 
 			}
 			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) 
+			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink)))
-				&& ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink))
+			{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
-				&& (1U == ptemp->ACCnt))
-			{/* 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) 
+			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink)))
-				&& ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink))
+			{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
-				&& (1U == ptemp->ACCnt))
-			{/* 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/IO/DeviceRelayDataProcess.h

@@ -44,8 +44,10 @@
 #include "../WashMachine/WashMachineConfigDataManage.h"
 #include "../WashMachine/WashMachineDataManage.h"
 #include "../ParsePack/ParsePackOcData.h"
+#include "../OHL/OHLDataManage.h"
 #include "ReverseCutDataManage.h"
 #include "ReverseCutConfigDataManage.h"
+#include "../SsksLightRelay/SsksLightRelayDefine.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -758,6 +760,43 @@ UINT8 CheckRelayDriveOutTime(const UINT16 wRelayId, const UINT32 dwTimeOutCycCou
 */
 void SGBJDriveOutputProc(void);
 
+/*
+* 功能描述：SSKS闪灯稳灯输出处理
+* 参数说明：void
+* 返 回 值：void
+* Created By LQ 2025.12.16
+*/
+void SsksFlashSteadyLightOutputProc(void);
+
+/*
+* 功能描述：SSKS关联驶入存车线进路标志处理
+* 参数说明：UINT16 wRelayId SSKS闪灯稳灯继电器ID
+*           UINT8 cEnterRouteNum 驶入存车线进路数量
+*           UINT16 szEnterRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX] 驶入存车线进路ID数组
+* 返 回 值：void
+* Created By LQ 2025.12.16
+*/
+void SsksRelEnterRouteFlagProc(UINT16 wRelayId, UINT8 cEnterRouteNum, UINT16 szEnterRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX]);
+
+/*
+* 功能描述：检查进路内方最后一个物理区段的上一个区段是否空闲且解锁
+* 参数说明：UINT16 wRouteId 进路ID
+* 返 回 值：0 失败（区段锁闭或占用）
+*           1 成功（区段未锁闭且空闲）
+* Created By LQ 2026.03.11
+*/
+UINT8 CheckRouteLastPSUnlockAndIdle(UINT16 wRouteId);
+
+/*
+* 功能描述：SSKS关联驶出存车线进路标志处理
+* 参数说明：UINT16 wRelayId SSKS闪灯稳灯继电器ID
+*           UINT8 cExportRouteNum 驶出存车线进路数量
+*           UINT16 szExportRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX] 驶出存车线进路ID数组
+* 返 回 值：void
+* Created By LQ 2025.12.16
+*/
+void SsksRelExportRouteFlagProc(UINT16 wRelayId, UINT8 cExportRouteNum, UINT16 szExportRouteId[SSKS_LIGHT_RELAY_ROUTE_MAX]);
+
 /*
 * 功能描述： 设置继电器驱动起始周期
 * 参数说明： const UINT16 relayId 继电器ID
@@ -984,6 +1023,47 @@ UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
 */
 UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
 
+/*
+* 功能描述： 更新接触网状态
+* 参数说明： void
+* 返回值  ： 无
+*/
+void OhlRelayToDeviceStateProc(void);
+
+/*
+* 功能描述：迪士尼屏蔽门旁路按钮按下状态处理
+* 参数说明：const UINT16 wPsbId  ID
+*           const UINT16 wMutualLockRelayId 旁路按钮采集继电器ID
+* 返回值  ：无
+* Created By fan 2025.12.17
+*/
+void PsdDsnPsdCutBtnPressStateProc(const UINT16 wPsdId, const UINT16 wMutualLockRelayId);
+
+/*
+* 功能描述： 处理迪士尼屏蔽门互锁解除继电器状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* Created By fan 2025.12.15
+* 返回值  ： 无
+*/
+void DsnPsdMutualLockStateUpdate(const UINT16 doorId);
+
+/*
+* 功能描述： 根据PSD状态更新区段的站台门异常打开封锁状态
+* 参数说明： 无
+* 返回值  ： 无
+* by fan 20260127
+*/
+void PsdRelayToSecFlockStatus(void);
+
+/*
+* 功能描述： 更新全线紧急停车逻辑状态
+* 参数说明： void
+* 返回值  ： 0u: 更新失败
+*			 1: 更新成功
+* Created By fan 2026.03.10
+*/
+void CesbStateUpdateProc(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -466,6 +466,22 @@ void ProcessOCToCiPsdData(void);
 */
 void ProcessOcToCiRelayDiffData(void);
 
+/*
+* 功能描述：迪士尼试车线试车状态处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2026.01.23
+*/
+void DsnScxStateProc(void);
+
+/*
+* 功能描述：迪士尼试车线物理区段采集占用状态处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2026.01.23
+*/
+void DsnScxPhySecColOccProc(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -21,7 +21,7 @@
 #include "../RemoteRM/RRMDataPrepare.h"
 #include "NonAutoReturnDataManage.h"
 #include "InputDataProcess.h"
-
+#include "../ECS/ECSDataManage.h"
 
 
 /*
@@ -137,6 +137,12 @@ void OutputDataProcess(void)
 
 		/*声光报警器输出处理*/
 		SGBJDriveOutputProc();
+
+		/*SSKS闪灯稳灯输出处理*/
+		SsksFlashSteadyLightOutputProc();
+
+		/*道岔反位使能请求输出处理*/
+		SwitchReverseEnableDriveProc();
 	}
 	else
 	{
@@ -194,6 +200,9 @@ void OutputDataProcess(void)
 	/*无人折返继电器粘连状态处理*/
 	RtnRealyAdhesionStatePro();
 
+	/*ECS监督处理*/
+	EcsMonitorProc();
+
 	/*虚拟设备输出处理*/
 	VirtualDeviceOutputProc();
 	
@@ -221,6 +230,9 @@ void OutputDataProcess(void)
 	/*更新照查联锁条件检查照查驱动*/
 	UpdateZhaoChaCheckZhaoChaDrive();
 
+	/*联络线进路协议继电器驱动*/
+	RouteConnectPrtlRelayDriveProc();
+
 	/*设置驱动继电器混线状态*/
 	SetDriveRelayHunXianState();
 
@@ -587,6 +599,10 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
 
 		break;
 	}
+
+	case ETYPE_SWT_WAIT_MOVE:	/*等待道岔动作完成*/
+		returnValue = CI_BACK_SWT_WAIT_MOVE;
+		break;
 		/* zt 删除单轨相关代码 2022-02-15 */
 
 		/*继电器故障反馈*/
@@ -929,6 +945,15 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
 	case ETYPE_PART_ROUTE_TRAIN_POS:
 		returnValue = CI_BACK_DYM_ROUTE_TRAIN_POS;
 		break;
+	case ETYPE_LOGSEC_CT_OVERRIDE_FAIL:
+		returnValue = CI_BACK_OVERRIDE_CT_OCCUPY;
+		break;
+	case ETYPE_ROUTE_CONNECT_OVERRIME:
+		returnValue = CI_BACK_CONNECT_ROUTE_OVERRIME;
+		break;
+	case ETYPE_SWT_CONNECT_RET_FAIL:
+		returnValue = CI_BACK_CONNECT_SWITCH_RET_FAIL;
+		break;
 	default:/*数据错误*/
 		returnValue = 0U;
 		break;
@@ -1046,6 +1071,10 @@ void IndicatorStateProc(void)
 	UINT8 cCommAxisNum = 0U;  /*与本控区具有通信关系的计轴子系统数量*/
 	UINT8* pAxisSysIdBuf = NULL;
 	UINT8 mm = 0U;
+	UINT16 wCutRelayId = 0u;/*旁路继电器ID*/
+	UINT8 chCutRelayState = 0u;/*旁路状态*/
+	UINT8 chScxCesbState = 0U;/*试车线CESB状态*/
+	UINT8 chScxCesbCutState = 0U;/*试车线CESB旁路状态*/
 
 	dianshiLinshixiansuFlag = GetCiFunctionSwitchConfig(FUNC_DIANSHI_LINSHIXIANSU_FLAG);
 	devCurSum = GetIndicatorCurSum(); /*获取指示器当前总数*/
@@ -2159,6 +2188,118 @@ void IndicatorStateProc(void)
 				SetIndicatorState(devId, INDICATOR_SHOW_COMM_RED);
 			}
 		}
+		else if (INDICATOR_TYPE_ALLSEC_FLOCK == devType)
+		{
+			chDevStateRtn = GetAllSecFlockState();
+			SetIndicatorState(devId, INDICATOR_SHOW_YES); /*初始化无封锁*/
+			if (ALLFLOCK_SET_YES == chDevStateRtn)
+			{
+				SetIndicatorState(devId, INDICATOR_SHOW_NO);
+			}
+		}
+		else if (INDICATOR_TYPE_SCX_SHD_ESS == devType)
+		{
+			devRelaySum = GetIndicatorRelaySum(devId); /*获取相关继电器总数*/
+			devRelayIdBuf = GetIndicatorRelayIdBuf(devId); /*获取相关继电器ID buf*/
+			if ((0U == devRelaySum) || (NULL == devRelayIdBuf))
+			{
+				SetIndicatorState(devId, INDICATOR_SHOW_YES); /*设置亮红灯*/
+			}
+			else
+			{
+				relayCollState = GetRelayCollState(devRelayIdBuf[0]);
+				if (RELAY_STATE_UP == relayCollState)
+				{
+					SetIndicatorState(devId, INDICATOR_SHOW_NO); /*ESS继电器吸起，试车中，设置亮绿灯*/
+				}
+				else
+				{
+					SetIndicatorState(devId, INDICATOR_SHOW_YES); /*ESS继电器落下，未试车，设置亮红灯*/
+				}
+			}
+		}
+		else if (INDICATOR_TYPE_CESB == devType)
+		{
+			/*旁路有效时发送旁路*/
+			chDevStateRtn = GetAllSecCesbState();/*CESB封锁设置状态*/
+			SetIndicatorState(devId, INDICATOR_CESB_INACTIVE_NOFLOCK); /*初始化未激活 无封锁*/
+			if (CI_TYPE_SCX == chLocalCiType)
+			{
+				/*试车线根据命令设置指示灯*/
+				chScxCesbState = GetScxCesbCmdState();
+				chScxCesbCutState = GetScxCesbCutCmdState();
+				if (ESB_CUT_YES == chScxCesbCutState)
+				{
+					if (CESB_STATE_VALID_NO == chDevStateRtn)
+					{
+						SetIndicatorState(devId, INDICATOR_CESB_CUT_NOFLOCK); /*设置CESB旁路有效 无封锁*/
+					}
+					else
+					{
+						SetIndicatorState(devId, INDICATOR_CESB_CUT_FLOCK); /*设置CESB旁路有效 存在封锁*/
+					}
+				}
+				else if (CESB_STATE_VALID_NO == chScxCesbState)
+				{
+					/*CESB未激活*/
+					if (CESB_STATE_VALID_NO == chDevStateRtn)
+					{
+						SetIndicatorState(devId, INDICATOR_CESB_INACTIVE_NOFLOCK); /*设置未激活 无封锁*/
+					}
+					else
+					{
+						SetIndicatorState(devId, INDICATOR_CESB_INACTIVE_FLOCK); /*设置未激活 存在封锁*/
+					}
+				}
+				else
+				{
+					/*未旁路、CESB激活*/
+					SetIndicatorState(devId, INDICATOR_CESB_ACTIVE_FLOCK); /*设置激活*/
+				}
+			}
+			else
+			{
+				wCutRelayId = GetCesbCutRelayId();
+				chCutRelayState = GetRelayCollState(wCutRelayId);/*旁路状态*/
+				RelayId = GetCesbRelayId();
+				relayCollState = GetRelayCollState(RelayId);       /*继电器采集状态*/
+				if (0U != RelayId)
+				{
+					if (RELAY_STATE_UP == chCutRelayState)
+					{ /*旁路继电器吸起,旁路有效*/
+						if (CESB_STATE_VALID_NO == chDevStateRtn)
+						{
+							SetIndicatorState(devId, INDICATOR_CESB_CUT_NOFLOCK); /*设置CESB旁路有效 无封锁*/
+						}
+						else
+						{
+							SetIndicatorState(devId, INDICATOR_CESB_CUT_FLOCK); /*设置CESB旁路有效 存在封锁*/
+						}
+					}
+					else if (RELAY_STATE_UP == relayCollState)
+					{
+						/*吸起 CESB未激活*/
+						if (CESB_STATE_VALID_NO == chDevStateRtn)
+						{
+							SetIndicatorState(devId, INDICATOR_CESB_INACTIVE_NOFLOCK); /*设置未激活 无封锁*/
+						}
+						else
+						{
+							SetIndicatorState(devId, INDICATOR_CESB_INACTIVE_FLOCK); /*设置未激活 存在封锁*/
+						}
+					}
+					else
+					{
+						/*未旁路、CESB激活*/
+						SetIndicatorState(devId, INDICATOR_CESB_ACTIVE_FLOCK); /*设置激活*/
+					}
+				}
+				else
+				{
+					;/*未配置CESB继电器时，维持未激活无封锁*/
+				}
+			}
+		}
 		else
 		{
 		/*不做处理*/
@@ -7192,7 +7333,7 @@ void AddXiansuPhySecData(const UINT16 wLogSecId,const UINT16 wTrainId)
 			chPhySecFlockType = GetPhySecFLockType(wLogSecRelPhySecId);
 			chPhySecAreaUrgentState = GetPhySecAreaUrgentState(wLogSecRelPhySecId);
 
-			if (((PHYSICAL_SECTION_FLOCK_YES == chPhySecFlockState) && ((PHY_SEC_FLOCK_TYPE_CMD == chPhySecFlockType) || (PHY_SEC_FLOCK_TYPE_SPKSCMD == chPhySecFlockType)))
+			if (((PHYSICAL_SECTION_FLOCK_YES == chPhySecFlockState) && (SEC_FLOCK_TYPE_CMD == (SEC_FLOCK_TYPE_CMD & chPhySecFlockType)))
 				|| (PHYSEC_AREA_URGENT_YES == chPhySecAreaUrgentState))
 			{
 				chAddFlag = CI_SUCCESS;
@@ -8573,3 +8714,73 @@ void RtnRealyAdhesionStatePro(void)
 	}
 }
 
+/*
+* 功能描述：ECS监督处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2026.01.26
+*/
+void EcsMonitorProc(void)
+{
+	UINT16 wEcsNum = 0U;  /*ECS数量*/
+	UINT16 ii = 0U;
+	UINT16 wEcsId = 0U;  /*ECS ID*/
+	UINT8 cLocalCiId = 0U;
+	UINT8 cEcsBelongCiId = 0U;  /*ECS所属CI*/
+	UINT8 cEcsAutoTrigState = 0U;  /*ECS监督状态*/
+	UINT16 wFanUpRelayId = 0U;  /*风向为逻辑正方向的继电器ID*/
+	UINT16 wFanDownRelayId = 0U;  /*风向为逻辑反方向的继电器ID*/
+	UINT16 wRelTrainId = 0U;  /*ECS关联列车ID*/
+	UINT16 wBufIndex = 0U;
+
+	cLocalCiId = GetSystemParaLocalCiId();
+	wEcsNum = GetEcsCurSum();
+	for (ii = 0U; ii < wEcsNum; ii++)
+	{
+		wEcsId = GetEcsId(ii);
+		cEcsBelongCiId = GetEcsBelongCiId(wEcsId);
+		if (cEcsBelongCiId == cLocalCiId)
+		{
+			wFanUpRelayId = GetEcsRelFanUpRelayId(wEcsId);  /*获取控制风机方向的继电器ID*/
+			wFanDownRelayId = GetEcsRelFanDownRelayId(wEcsId);
+
+			cEcsAutoTrigState = GetEcsAutoTrigState(wEcsId);
+			if (ECS_AUTOTRIG_YES == cEcsAutoTrigState)
+			{
+				/*ECS自动触发启用时，需要周期监督隧道内的拥堵状态，进而驱动相应的继电器吸起/落下*/
+				/*1.更新ECS隧道关联的列车ID（该列车ID用于判断隧道内是通信车还是非通信车）*/
+				UpdateEcsRelTrain(wEcsId);
+
+				/*2.监督ECS隧道内的停车状态*/
+				wRelTrainId = GetEcsRelTrainId(wEcsId);  /*获取ECS关联列车ID*/
+				wBufIndex = GetTrainBufIndex(wRelTrainId);
+				if (TRAIN_SUM_MAX > wBufIndex)
+				{
+					/*关联列车ID有效，隧道内存在通信车，按照通信车监督隧道列车停车状态*/
+					MonitorEcsTrainByCommTrain(wEcsId);
+				}
+				else
+				{
+					/*关联列车ID无效，隧道内不存在通信车，按照非通信车监督隧道列车停车状态*/
+					MonitorEcsTrainByBadTrain(wEcsId);
+				}
+
+				/*3.更新ECS隧道拥堵状态*/
+				UpdateEcsJamState(wEcsId);
+
+				/*4.根据ECS隧道拥堵状态，设置继电器驱动状态*/
+				EcsFanRelayDriveProc(wEcsId);
+			}
+			else
+			{
+				/*ESC自动触发停用时，需要周期设置控制风机方向的继电器落下，其它相关状态已在ATS命令处理时清除*/
+				(void)SetRelayDriveState(wFanUpRelayId, RELAY_DRIVE_STATE_DOWN);
+				(void)SetRelayDriveState(wFanDownRelayId, RELAY_DRIVE_STATE_DOWN);
+			}
+		}
+		else
+		{
+			/*非本控区ECS，不处理*/
+		}
+	}
+}

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

@@ -456,6 +456,14 @@ UINT8 FindRouteLeaveAxis(const UINT16 routeId);
 */
 void RtnRealyAdhesionStatePro(void);
 
+/*
+* 功能描述：ECS监督处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2026.01.26
+*/
+void EcsMonitorProc(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -457,3 +457,44 @@ UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId)
 
 	return wRetVal;
 }
+
+/*
+* 功能描述：通过表示灯类型获取表示灯ID
+* 参数说明：UINT8 cDevType 表示灯类型
+* 返 回 值：0 获取数据失败
+*           其它 表示灯ID
+* Created By LQ 2026.01.23
+*/
+UINT16 GetIndicatorIdByDevType(UINT8 cDevType)
+{
+	UINT16 wRetVal = 0U;
+	UINT16 wDevCurSum = 0U;  /*表示灯总数*/
+	UINT16 ii = 0U;
+	UINT16 wDevId = 0U;  /*表示灯ID*/
+	UINT8 cIndicatorType = 0U;  /*表示灯类型*/
+	
+	if (0U != cDevType)
+	{
+		wDevCurSum = GetIndicatorCurSum(); /*获取指示器当前总数*/
+		for (ii = 0U; ii < wDevCurSum; ii++)
+		{
+			wDevId = GetIndicatorId(ii);  /*获取表示灯ID*/
+			cIndicatorType = GetIndicatorType(wDevId);  /*获取表示灯类型*/
+			if (cDevType == cIndicatorType)
+			{
+				wRetVal = wDevId;
+				break;  /*找到目标类型，停止遍历*/
+			}
+			else
+			{
+				/*继续遍历查找*/
+			}
+		}
+	}
+	else
+	{
+		/*入参非法，返回0*/
+	}
+
+	return wRetVal;
+}

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

@@ -185,6 +185,15 @@ UINT8 GetIndicatorDevId(UINT16 indicatorId);
 */
 UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId);
 
+/*
+* 功能描述：通过表示灯类型获取表示灯ID
+* 参数说明：UINT8 cDevType 表示灯类型
+* 返 回 值：0 获取数据失败
+*           其它 表示灯ID
+* Created By LQ 2026.01.23
+*/
+UINT16 GetIndicatorIdByDevType(UINT8 cDevType);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -132,6 +132,9 @@
 #define INDICATOR_TYPE_RELAY_HUNXIAN                   ((UINT8)0x92) /*继电器混线表示灯*/
 #define INDICATOR_TYPE_AUTORTN_ADHESION   	  		((UINT8)0x62)  /*无人折返按钮粘连状态指示灯*/
 #define INDICATOR_TYPE_COMM_AXIS                  ((UINT8)0x96) /*与计轴通信状态：1-所有计轴通信正常；3-存在计轴通信异常*/
+#define INDICATOR_TYPE_ALLSEC_FLOCK   	  		((UINT8)0x65)  /*홍窟혐뙈룐傑寧刻됐*/
+#define INDICATOR_TYPE_CESB   	  		((UINT8)0x98)  /*CESB寧刻됐*/
+#define INDICATOR_TYPE_SCX_SHD_ESS   	  		((UINT8)0x97U)  /*둑却콩桿났窟SHD-ESS榴檄깊刻됐*/
 
 
 /*指示灯显示状态*/
@@ -181,6 +184,12 @@
 #define INDICATOR_SHOW_SC_NO  		  		        ((UINT8)0x55)  /*试车指示灯显示无效*/
 #define INDICATOR_SHOW_SC_YES  		  		        ((UINT8)0xaa)  /*试车指示灯显示有效*/
 
+#define INDICATOR_CESB_INACTIVE_NOFLOCK				((UINT8)0x01)		/* CESB灌샴삶灌룐傑*/
+#define INDICATOR_CESB_INACTIVE_FLOCK				((UINT8)0x02)		/* CESB灌샴삶할룐傑*/
+#define INDICATOR_CESB_ACTIVE_FLOCK				((UINT8)0x03)		/* CESB샴삶할룐傑*/
+#define INDICATOR_CESB_CUT_FLOCK				((UINT8)0x04)		/* CESB텃쨌할룐傑*/
+#define INDICATOR_CESB_CUT_NOFLOCK				((UINT8)0x05)		/* CESB텃쨌할灌룐傑*/
+
 #define INDIC_POWER_I_1       ((UINT8)0x01)   /*一路电源1*/
 #define INDIC_POWER_I_2       ((UINT8)0x02)    /*一路电源2*/
 #define INDIC_POWER_II_1       ((UINT8)0x03)   /*二路电源1*/

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

@@ -129,6 +129,9 @@ UINT8 InitAllStaticDataStr(void)
 	/*声光报警器配置数据结构体*/
 	chRtn &= CommonMemSet(SGBJConfigDataStru, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)), 0u, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)));
 
+	/*ECS配置数据结构体*/
+	chRtn &= CommonMemSet(ECSConfigDataStru, (UINT32)(ECS_MAX_NUM * sizeof(ECSConfigDataStruct)), (UINT8)0U, (UINT32)(ECS_MAX_NUM * sizeof(ECSConfigDataStruct)));
+
 	return chRtn;
 }
 
@@ -667,7 +670,6 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 
-
 			if (0u == rtnVal)
 			{
 				InvSecSum = ReadInvaSectionConfigData(LocalCiId, InvSecConfigDataStru);							/*读侵入区段配置数据*/
@@ -772,6 +774,44 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 
+			/*读SSKS闪灯稳灯继电器配置数据*/
+			if (0U == rtnVal)
+			{
+				gSsksLightRelaySum = ReadSsksLightRelayCfgData(LocalCiId, gSsksLightRelayCfgStr);
+				if (-1 == gSsksLightRelaySum)
+				{
+					rtnVal = 40U;  /*读取SSKS闪灯稳灯继电器配置数据失败*/
+					debug_infor_printf((const)"\nReadSsksLightRelayCfgData fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+			else
+			{
+				; /*不处理*/
+			}
+
+			/*读联络线旁路继电器配置数据*/
+			if (0U == rtnVal)
+			{
+				gConnectOverrideRelaySum = ReadConnectOverrideCfgData(LocalCiId, gConnectOverrideRelayCfgStr);
+				if (-1 == gConnectOverrideRelaySum)
+				{
+					rtnVal = 46U;  /*读取联络线旁路继电器配置数据失败*/
+					debug_infor_printf((const)"\nReadConnectOverrideCfgData fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+			else
+			{
+				; /*不处理*/
+			}
+
 			/*读声光报警器配置数据*/
 			if (0u == rtnVal)
 			{
@@ -791,6 +831,56 @@ UINT8 ReadConfigureData(void)
 				; /*不处理*/
 			}
 			
+			if (0u == rtnVal)
+			{
+				OhlCurSum = ReadOhlConfigData(LocalCiId, OhlConfigDataStru);
+				if (-1 == OhlCurSum)
+				{
+					rtnVal = 39U;/*读取接触网数据失败*/
+					debug_infor_printf((const)"ReadOhlConfigData fail.");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+			else
+			{
+				; /*不处理*/
+			}
+
+			if (0U == rtnVal)
+			{
+				ECSCurSum = ReadEcsConfigData(LocalCiId, ECSConfigDataStru);
+				if (-1 == ECSCurSum)
+				{
+					rtnVal = 43U;/*读取ECS数据失败*/
+					debug_infor_printf((const)"\nReadEcsConfigData fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+			else
+			{
+				; /*不处理*/
+			}
+
+			if (0U == rtnVal)
+			{
+				RtnTemp = ReadLocalCesbConfigData(LocalCiId, &LocalCesbConfigDataStru);
+				if (0U == RtnTemp)
+				{
+					rtnVal = 45U;/*读取CESB数据失败*/
+					debug_infor_printf((const)"\nReadCesbConfigData fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+
 			if (0u == rtnVal)
 			{
 				/*读系统参数配置数据*/
@@ -979,7 +1069,13 @@ UINT8 ReadConfigureData(void)
 					if (CI_SUCCESS == retValue)
 					{
 						/*读取联络线数据*/
-						g_ret = OcConnectConfigDataToDevStruct(SignalConfigDataStru, PhysicalSectionConfigDataStru, SwitchConfigDataStru, OcConnetDataCfgStru, RelayConfigDataStru);
+						g_ret = OcConnectConfigDataToDevStruct(SignalConfigDataStru, 
+							PhysicalSectionConfigDataStru, 
+							SwitchConfigDataStru, 
+							OcConnetDataCfgStru, 
+							RelayConfigDataStru, 
+							RouteConfigDataStru,
+							LogicSectionConfigDataStru);
 						if (-1 == g_ret)
 						{
 							rtnVal = 35u;
@@ -1071,6 +1167,68 @@ UINT8 ReadConfigureData(void)
 			{
 				; /*不处理*/
 			}
+			
+			if (0U == rtnVal)
+			{
+				/*ECS关联物理区段初始化*/
+				RtnTemp = EcsIncPhySecInfoInit(ECSConfigDataStru);  /*需要在Link后面初始化*/
+				if (0U == RtnTemp)
+				{
+					rtnVal = 44U;  /*ECS关联物理区段初始化失败*/
+					debug_infor_printf((const)"\nEcsIncPhySecInfoInit fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+			else
+			{
+				; /*不处理*/
+			}
+
+			if (0u == rtnVal)
+			{
+				/*迪士尼联络线逻辑区段继电器条件读取*/
+				retValue = OcConnectLogSecCondInit();
+				if (1u == retValue)
+				{
+					ConnectLogSecCondRelayInit(ConnectLogSecCondCfgStru, LogicSectionConfigDataStru);
+				}
+				else
+				{
+					rtnVal = 47u;
+					debug_infor_printf((const)"OcConnectLogSecCondInit errcode =%d, OcConnectLogSecCondInit", rtnVal);
+				}
+			}
+			if (0u == rtnVal)
+			{
+				/*迪士尼共用道岔的逻辑区段整理*/
+				retValue = InitLogSecSwitchShareStatusByPhysec();
+				if (0U == retValue)
+				{
+					rtnVal = 48U;  
+					debug_infor_printf((const)"\InitLogSecSwitchShareStatusByPhysec fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
+
+			if (0u == rtnVal)
+			{
+				retValue = InitSpeedLimitSecConfigData();
+				if (0U == retValue)
+				{
+					rtnVal = 49U;
+					debug_infor_printf((const)"\InitSpeedLimitSecConfigData fail.\n");
+				}
+				else
+				{
+					; /*不处理*/
+				}
+			}
 		}
 		else
 		{
@@ -1267,6 +1425,33 @@ UINT8 DeviceDataManage(void)
 		}
 	}
 
+	if (0U == rtValue)
+	{
+		reval = OhlConfigDataManage();
+		if (CI_ERROR == reval)
+		{
+			rtValue = 1u;
+		}
+	}
+
+	if (0U == rtValue)
+	{
+		/*读取本地ECS ID*/
+		reval = EcsConfigDataManage();
+		if (CI_ERROR == reval)
+		{
+			rtValue = 1U;
+		}
+		else
+		{
+			/*返回成功*/
+		}
+	}
+	else
+	{
+		/*返回失败*/
+	}
+
     return rtValue;
 }
 /*
@@ -1922,18 +2107,26 @@ UINT8 CheckCiHaveZcSumErr(const UINT8 ciId)
 *            OcConnetDataCfgStruct* pConnectCfgData 联络线数据结构体
 *			 RelayConfigDataStruct* pRelayCfgData	继电器结构体
 * 返回值  ： 0，成功；-1，失败
-* NOTE£º¼¯³Ébug YF0083-224		      
+* NOTE：
 */
-INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, PhysicalSectionConfigDataStruct* pPhyCfgData, SwitchConfigDataStruct* pSwitchCfgData, OcConnetDataCfgStruct* pConnectCfgData, RelayConfigDataStruct* pRelayCfgData)
+INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, 
+	PhysicalSectionConfigDataStruct* pPhyCfgData, 
+	SwitchConfigDataStruct* pSwitchCfgData, 
+	OcConnetDataCfgStruct* pConnectCfgData, 
+	RelayConfigDataStruct* pRelayCfgData, 
+	RouteConfigDataStruct *pRouteCfgData,
+	LogicSectionConfigDataStruct *pLogSecCfgData)
 {
 	/*变量初始化*/
 	UINT16 i = 0u;
 	UINT16 j = 0u;
 	UINT16 k = 0u;
 	UINT16 m = 0U;
+	UINT16 n = 0U;
 	INT8 retValue = -1;
 
-	if ((NULL != pSignalCfgData) && (NULL != pPhyCfgData) && (NULL != pSwitchCfgData) && ((NULL != pConnectCfgData)))
+	if ((NULL != pSignalCfgData) && (NULL != pPhyCfgData) && (NULL != pSwitchCfgData) 
+		&& (NULL != pConnectCfgData) && (NULL != pRelayCfgData) && (NULL != pRouteCfgData) && (NULL != pLogSecCfgData))
 	{
 		retValue = 0;
 		for (i = 0u; i < OcConnetDataDevNum; i++)
@@ -2035,11 +2228,68 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, Phys
 								pSwitchCfgData[j].DsHRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 								pSwitchCfgData[j].DsDrvHRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
 							}
-							/*PYPASS*/
+							/*BYPASS*/
 							else if (SWITCH_BYPASSJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
 							{
 								pSwitchCfgData[j].ByPassRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
 							}
+							/*反位使能请求RWM*/
+							else if (SWITCH_RWM_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSwitchCfgData[j].RwmRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
+								
+								/*给迪士尼联络线进路添加关键道岔，遍历所有进路*/
+								for (m = 0u; m < ROUTE_SUM_MAX; m++)
+								{
+									/*判断迪士尼联络线进路类型*/
+									if ((ROUTE_DISNEY_CONNECT_ENDMINE == pRouteCfgData[m].cDisneyConnectRouteAttr)
+										|| (ROUTE_DISNEY_CONNECT_STARTMINE == pRouteCfgData[m].cDisneyConnectRouteAttr))
+									{
+										/*后半段属于本线，或者前半段属于本线，遍历所有道岔*/
+										for (n = 0u; n < (UINT16)pRouteCfgData[m].RouteSwitchSum; n++)
+										{
+											/*判断道岔ID是否为当前RWM继电器对应道岔ID*/
+											if (pRouteCfgData[m].RouteSwitchStru[n].SwitchId == pSwitchCfgData[j].SwitchId)
+											{
+												/*道岔ID一致，赋值联络线关键道岔ID*/
+												pRouteCfgData[m].wRelConnectSwitchId = pSwitchCfgData[j].SwitchId;
+												break;
+											}
+											else
+											{
+												/*继续遍历*/
+											}
+										}
+									}
+									else
+									{
+										/*类型不满足，无需添加关键道岔，继续遍历*/
+									}
+								}
+
+								for (m = 0u; m < LOGIC_SECTION_SUM_MAX; m++)
+								{
+									for (n = 0u; n < pLogSecCfgData[m].chLogsecSwitchSum; n++)
+									{
+										if ((pLogSecCfgData[m].LogsecSwitchIdStru[n].SwitchId == pSwitchCfgData[j].SwitchId)
+											&& (SWITCH_POSITION_FANWEI == pLogSecCfgData[m].LogsecSwitchIdStru[n].SwitchPosition))
+										{
+											/*逻辑区段反位包含该继电器，记录联络线道岔ID*/
+											pLogSecCfgData[m].wConnectSwticthId = pSwitchCfgData[j].SwitchId;
+											break;
+										}
+										else
+										{
+											/*继续遍历*/
+										}
+									}
+								}
+							}
+							/*反位使能旁路ENABLE BYPASS*/
+							else if (SWITCH_ENABLE_BYPASS_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
+							{
+								pSwitchCfgData[j].EnableBypassRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
+							}
 							else
 							{
 								/*不做处理*/
@@ -2107,7 +2357,6 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, Phys
 	return(retValue);
 }
 
-
 /*********************************************
 *函数功能：初始化OC 联络线接口继电器配置表数据
 *参数说明：void
@@ -2187,6 +2436,132 @@ UINT8 OcConnectConfigDataStructInit(void)
 	return(rtnValue);
 }
 
+/*********************************************
+*函数功能：初始化联络线逻辑区段继电器条件器配置表数据
+*参数说明：void
+*返回值：1，成功；0，失败
+*********************************************/
+UINT8 OcConnectLogSecCondInit(void)
+{
+	UINT8 funcRtn = 0u;
+	UINT8* pDataAddr = NULL;         /*数据地址*/
+	UINT32 DataSize = 0u;          /*数据大小（字节数）*/
+	UINT16 i = 0u;
+	UINT16 j = 0u;
+	UINT16 realRowCount = 0u; /*实际表数据的行数*/
+	UINT8 rtnValue = 0u;
+
+
+	/*读取数据*/
+	/*读取 默认行车序列  数据*/
+	funcRtn = dquGetConfigDataNew((const)DataPath, OC_DATA_TYPE, CONNECT_LOGSEC_COND_ID, &pDataAddr, &DataSize, &realRowCount);
+	if (0u == funcRtn)
+	{
+		/*函数调用失败*/
+		rtnValue = 1u;
+		debug_infor_printf((const)"\nCONNECT_LOGSEC_COND_ID NO IN FS\n");
+	}
+	else
+	{
+		rtnValue = 1u;
+		/*数据正常*/
+		if ((0u != DataSize) && (0u != realRowCount))
+		{
+			if (0u != (DataSize % realRowCount))
+			{
+				debug_infor_printf((const)"\n OC_DATA_TYPE,CONNECT_LOGSEC_COND_ID len %d %d not equal to fs\n", DataSize, realRowCount);
+				DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, ((UINT32)CI_DATA_TYPE << 8) + CONNECT_LOGSEC_COND_ID, PRINT_ONCE);
+				rtnValue = 0u;
+			}
+			else
+			{
+				/*填写设备数量*/
+				ConnectLogSecCondDevNum = realRowCount;
+				/*内存先设为无效*/
+				(void)CommonMemSet(ConnectLogSecCondCfgStru, sizeof(ConnectLogSecDataCfgStru) *OC_CONNECT_LOGSEC_COND_SUM_MAX,
+					0x00u, sizeof(ConnectLogSecDataCfgStru) *OC_CONNECT_LOGSEC_COND_SUM_MAX);
+
+				for (i = 0u; i < realRowCount; i++)
+				{
+					if (OC_CONNECT_LOGSEC_COND_SUM_MAX > i)
+					{
+						ConnectLogSecCondCfgStru[i].LogSecId = dquCiShortFromChar(pDataAddr);
+						pDataAddr += 2u;
+						ConnectLogSecCondCfgStru[i].RelSecDirLockRelayId = ShortFromChar(pDataAddr);
+						pDataAddr += 2u;
+						ConnectLogSecCondCfgStru[i].RelRoutePrtlRelayId = ShortFromChar(pDataAddr);
+						pDataAddr += 2u;
+					}
+					else
+					{
+						/*无操作*/
+					}
+				}
+			}
+		}
+		else
+		{
+			/*不做处理*/
+		}
+	}
+	return(rtnValue);
+}
+
+/*
+* 功能描述： 将联络线逻辑区段继电器条件数据初始化到对应设备
+* 参数说明： ConnectLogSecDataCfgStru *pConnectLogSecCondCfgStru 联络线逻辑区段继电器条件配置数据结构体
+*            LogicSectionConfigDataStruct *pLogicSectionConfigDataStru 逻辑区段配置数据结构体
+* 返回值  ： 0，成功；-1，失败
+* NOTE：集成bug YF0083-224
+*/
+INT8 ConnectLogSecCondRelayInit(ConnectLogSecDataCfgStru *pConnectLogSecCondCfgStru, 
+	LogicSectionConfigDataStruct *pLogicSectionConfigDataStru)
+{
+	/*变量初始化*/
+	UINT16 i = 0u;			/*循环变量*/
+	UINT16 j = 0u;			/*循环变量*/
+	INT8 retValue = -1;		/*返回值*/
+
+	if ((NULL != pConnectLogSecCondCfgStru) && (NULL != pLogicSectionConfigDataStru))
+	{
+		retValue = 0;
+		for (i = 0u; i < ConnectLogSecCondDevNum; i++)
+		{
+			for (j = 0u; j < LOGIC_SECTION_SUM_MAX; j++)
+			{
+				if (pLogicSectionConfigDataStru[j].LogicSectionId == pConnectLogSecCondCfgStru[i].LogSecId)
+				{
+					pLogicSectionConfigDataStru[j].wRelSecDirLockRelayId = pConnectLogSecCondCfgStru[i].RelSecDirLockRelayId;
+					pLogicSectionConfigDataStru[j].wRelRoutePrtlRelayId = pConnectLogSecCondCfgStru[i].RelRoutePrtlRelayId;
+					break;
+				}
+				else
+				{
+					/*继续遍历*/
+				}
+			}
+
+			if (LOGIC_SECTION_SUM_MAX == j)
+			{
+				/*联络线逻辑区段继电器条件表配置的逻辑区段未在电子地图找到，返回失败*/
+				retValue = -1;
+				break;
+			}
+			else
+			{
+				/*继续遍历*/
+			}
+		}
+	}
+	else
+	{
+		/*返回失败*/
+		retValue = -1;
+	}
+
+	return(retValue);
+}
+
 /*********************************************
 *函数功能：获取静态数据
 *参数说明：UINT32* pConfigDataAdderBuf 静态数据存放地址,UINT16 pConfigDataLenBuf 静态数据长度存放地址,UINT16 wBufMaxLen数组容量

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

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

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

@@ -20,6 +20,7 @@
 #include "NonAutoReturnConfigDataManage.h"
 #include "../Deployment/DeploymentExtern.h"
 #include "NonAutoReturnDataManage.h"
+#include "../ECS/ECSDataManage.h"
 
 /****************************初始化动态数据队列********************************************/
 extern TransmitRelationDataStruct TransmitRelaDataStru[TRANSMIT_OBJECT_SUM_MAX];								   /*引用已定义通信关系数据结构体*/
@@ -448,6 +449,12 @@ UINT8 InitialProcess(void)
 
 		ret = InitAxleToCiDataStru();
 	}
+
+	if (CI_SUCCESS == ret)
+	{
+		ret = InitAxisSecClassData();
+	}
+
 	if (CI_SUCCESS == ret)
 	{/*cgh-合并CID-3037-3：*/
 		/*初始化中央联锁结构体*/
@@ -456,6 +463,26 @@ UINT8 InitialProcess(void)
 		ret = InitialOCStationIndicStaData();
 	}
 
+	if (CI_SUCCESS == ret)
+	{
+		/*初始化SSKS闪灯稳灯继电器动态数据*/
+		ret = InitSsksLightRelayData();
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	if (CI_SUCCESS == ret)
+	{
+		/*初始化联络线旁路继电器动态数据*/
+		ret = InitConnectOverrideData();
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	if (CI_SUCCESS == ret)
 	{
 		/*初始化无人折返指示灯状态数据*/
@@ -472,6 +499,33 @@ UINT8 InitialProcess(void)
 	{/*初始化LEU数据*/
 		(void)InitLEUDataStru();
 	}
+
+	if (CI_SUCCESS == ret)
+	{/*初始化接触网数据*/
+		(void)InitOhlDataStru();
+	}
+
+	if (CI_SUCCESS == ret)
+	{
+		/*初始化ECS数据*/
+		(void)InitialEcsData();
+	}
+	else
+	{
+		/*返回失败*/
+	}
+
+	if (CI_SUCCESS == ret)
+	{
+		/*初始化限速区段数据*/
+		(void)InitTSRSecInfo();
+	}
+	else
+	{
+		/*返回失败*/
+	}
+	
+
     /*初始化设备打印数据*/
     (void)RecordDeviceDataLog(CI_ERROR);
 
@@ -602,6 +656,7 @@ UINT8 InitialSignalData(void)
 			SignalDataStru[signalId].cDetCutBtnRelayDownState = SIGNAL_RELAY_ERROR_DOWN_YES;   /*扣车旁路按钮采集继电器落下状态初始化为异常落下*/
 			/*初始化信号机临时限速状态有效*/
 			SignalDataStru[signalId].LinShiXianSuSetFlag = SIGNAL_LINSHIXIANSUSET_STATE_YES;/*临时限速有效*/
+			SignalDataStru[signalId].cTrainCrossRedSignalFlag = SIGNAL_TRAIN_CROSS_RED_NO;  /*初始化闯红灯标志无效*/
 			
 			
 			routeSum = GetRouteCurSum();
@@ -769,6 +824,7 @@ UINT8 InitialSwitchData(void)
 			SwitchDataStru[switchId].SingleSwitchCurPosition = SWITCH_POSITION_SIKAI;
 			SwitchDataStru[switchId].SwitchDrivePos = SWITCH_DRIVE_POS_INVALID;
 			SwitchDataStru[switchId].SwitchExpDrvPos = SWITCH_DRIVE_POS_INVALID;
+			SwitchDataStru[switchId].SwitchReverseEnable = SWITCH_DRIVE_POS_INVALID;
 			SwitchDataStru[switchId].switchPreExpDrvPos = SWITCH_DRIVE_POS_INVALID;
 			SwitchDataStru[switchId].SwitMoveStartCycNum = 0u;
 			SwitchDataStru[switchId].SwitDriveStartCycNum = 0u;
@@ -798,6 +854,9 @@ UINT8 InitialSwitchData(void)
 			SwitchDataStru[switchId].SwitchCollTolerateCycNum = 0U;
 			SwitchDataStru[switchId].SwitchColPosition = SWITCH_POSITION_SIKAI;
 			SwitchDataStru[switchId].switchFaultState = SWITCH_FAULT_STATE_YES; /*置为板卡故障*/
+			SwitchDataStru[switchId].switchNormalPosCycNum = 0u;
+			SwitchDataStru[switchId].switchUnusualLogSecFlag = SWITCH_UNUSUAL_INVALID;
+			SwitchDataStru[switchId].switchMutDrvCycNum = 0u;
 			/*初始化被防护锁闭的进路、保护区段、非进路数量及数组*/
 			for (jj=0; jj<SWITCH_MAX_PROTECT_LOCKED_NUM;jj++)
 			{
@@ -850,6 +909,7 @@ UINT8 InitialPhySectionData(void)
 
 		PhysicalSectionDataStru[ii].StopSteadyFlag = PHYSICAL_SECTION_STOPSTEADY_NO;
 		PhysicalSectionDataStru[ii].SecColOccupyStartCycNum = 0u;
+		PhysicalSectionDataStru[ii].SecMergeOccupyStartCycNum = 0U;
 		PhysicalSectionDataStru[ii].SecCurOccupyStartCycNum = 0u;
 		PhysicalSectionDataStru[ii].SecOccuToClearStartCycNum = 0u;
 		PhysicalSectionDataStru[ii].AutoUnlockStartCycNum = 0u;
@@ -859,7 +919,7 @@ UINT8 InitialPhySectionData(void)
 		PhysicalSectionDataStru[ii].JumpLockState = PHYSICAL_SECTION_JUMP_LOCK_NO;
 		PhysicalSectionDataStru[ii].SecJumpDelayUnlockStartCycNum = 0u;
 		PhysicalSectionDataStru[ii].JumpLockDelayUnlockFlag = PHYSICAL_JUMPUNLOCK_DELAY_SET_NO;
-		PhysicalSectionDataStru[ii].FLockType = PHY_SEC_FLOCK_TYPE_NONE;
+		PhysicalSectionDataStru[ii].FLockType = SEC_FLOCK_TYPE_NONE;
 		PhysicalSectionDataStru[ii].UtOrCtOccFlag = SECTION_OCCUPY_YES;
 		PhysicalSectionDataStru[ii].UtOrCtOccuStartCycNum = 0u;
 		PhysicalSectionDataStru[ii].PhySecPreResetState = PHYSICAL_SECTION_PRE_RESET_NO;
@@ -874,6 +934,7 @@ UINT8 InitialPhySectionData(void)
 		PhysicalSectionDataStru[ii].chPreABLTrainFlag = PHYSICAL_SECTION_ABLOCCUPY_DEFAULT;
 		PhysicalSectionDataStru[ii].dwAblTagSetCyc = 0U;
 		PhysicalSectionDataStru[ii].cPhySecInHumidRailFlag = PHYSEC_IN_HUMID_RAIL_NO;
+		PhysicalSectionDataStru[ii].dwMerOccToIdleStartCycNum = 0U;
 	}
 
 	for (ii = 0u; ii < phySectionDataSum; ii++)
@@ -1034,6 +1095,8 @@ UINT8 InitialLogicSectionData(void)
 			LogicSectionDataStru[logicSectionId].chLogicSpksFLockState = LOGIC_SECTION_SPKS_FLOCK_NO;/*仅用于ATS显示；逻辑区段不一定关联SPKS，如果初始化成封锁，无法获取SPKS状态，此逻辑区段会一直为封锁状态*/
 			LogicSectionDataStru[logicSectionId].chAblRelLogSecUsableFlag = LOGIC_ABLNEAR_USE_FLAG_NO;		/*初始化ABL接近逻辑区段可用标志*/
 			LogicSectionDataStru[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO;   /*离去区段ABL列车检查不通过*/
+			LogicSectionDataStru[logicSectionId].chLogSecProhibitFAOFlag = LOGSEC_PROHIBIT_FAO_NO;		/*逻辑区段允许FAO运行*/
+			LogicSectionDataStru[logicSectionId].chLogSecFlockType = SEC_FLOCK_TYPE_NONE;/*未封锁*/
 			LogicSectionDataStru[logicSectionId].chLinShiXianSuSetSpeed = 0U;		/*逻辑区段临时限速设置速度值*/
 			for (jj = 0U; jj < LOGIC_SECTION_RES_SUM_MAX; jj++)
 			{
@@ -1055,34 +1118,16 @@ UINT8 InitialLogicSectionData(void)
 			LogicSectionDataStru[logicSectionId].LogSecLogLockState = LOG_SECTION_LOGLOCK_NO;
 		}
 
-
+		if (RC_WORK_MODE_TIOC == RcWorkMode)
-		if (RC_WORK_MODE_TIOC == RcWorkMode)		/*RC工作模式为TIOC工作模式*/
 		{
 			/* 初始化逻辑区段未设置临时限速 */
 			for (ii = 0u; ii < logicSectionDataSum; ii++)
 			{
 				logicSectionId = GetLogicSecId(ii);
-				if (FUNC_SWITCH_OFF == chTmcSwitch)
-				{
 				LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
 			}
-				else
-				{
-					LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
 		}
 
-			}
-			/* 初始化临时限速信息 */
-			SetTsrSum(0u);
-			if (FUNC_SWITCH_OFF == chTmcSwitch)
-			{
-				SetTsrSureFlag(CI_TSR_SURE_YES);
-			}
-			else
-			{
-				SetTsrSureFlag(CI_TSR_SURE_NO);
-			}
-		}
 		else if (RC_WORK_MODE_CI == RcWorkMode)
 		{
 			/*RC工作模式为联锁工作模式*/
@@ -1384,6 +1429,11 @@ UINT8 InitialPsdData(void)
 		
 		PsdDataStru[psdId].cPsdExceptOpenState = PSD_EXCEPT_OPEN_YES;  /*初始化为PSD异常打开*/
 		PsdDataStru[psdId].dwPsdRelayDownCycNum = 0U;  /*PSD门关继电器落下起始周期*/
+		PsdDataStru[psdId].dwPsdMutualLockCollStartCyc = 0U;  /*PSD旁路按钮按下起始周期*/
+		PsdDataStru[psdId].dwPsdMutualLockErrCollCyc = 0U;/*PSD旁路按钮误触发按下周期*/
+		PsdDataStru[psdId].dwPsdMutualLockStartCyc = 0U;  /*PSD旁路起效周期*/
+		PsdDataStru[psdId].cPsdMutualLockBtnErrState = PSD_BTN_ERROR_FLAG_NO;  /*屏蔽门互锁解除按钮故障状态*/
+		PsdDataStru[psdId].cPsdMutualLockBtnErrDownState = PSD_BTN_ERROR_FLAG_NO;  /*屏蔽门互锁解除按钮故障落下状态*/
 	}
 	reVal = CI_SUCCESS;
 	return reVal;
@@ -1591,11 +1641,10 @@ UINT8 InitialRouteData(void)
 				RouteDataStru[routeId].cRouteDrivedSGBJFlag = ROUTE_HAS_DRIVED_SGBJ_INVALID;		/*初始化进路未驱动过声光报警*/
 				RouteDataStru[routeId].chRouteNearSecSearchState = ROUTE_NEAR_SEC_HAVE_UT;			/*初始化进路接近区段查询状态为有故障车*/
 				RouteDataStru[routeId].chRouteApplySwitchCheckFlag = ROUTE_APPLY_SWITCH_CHECK_DEF;	/*初始化进路办理相邻控区道岔检查标志*/
-				RouteDataStru[routeId].OtherCiRecordDevID = 0U;
-				RouteDataStru[routeId].OtherCiRecordDevState = 0U;
-				RouteDataStru[routeId].OtherCiRecordDevType = 0U;
-				RouteDataStru[routeId].OtherCiRecordErrorType = 0U;
 				RouteDataStru[routeId].cRouteToLeadFlag = ROUTE_TO_LEAD_FLAG_NO;		/*初始化普通进路转引导进路标志为无效*/
+				RouteDataStru[routeId].cRouteRequestDrvState = RELAY_STATE_DOWN;		/*初始化URR驱动落下*/
+				RouteDataStru[routeId].cRouteReleaseDrvState = RELAY_STATE_UP;			/*初始化UCL驱动吸起*/
+				RouteDataStru[routeId].cRouteAckDrvState = RELAY_STATE_DOWN;			/*初始化UAR驱动落下*/
 			}
 		}
 
@@ -2073,6 +2122,9 @@ void ResetDynamicState(const UINT8 ciId)
 			SwitchDataStru[devId].SwitchCollTolerateCycNum = 0U; /*不使用容忍*/
 			SwitchDataStru[devId].SwitchColPosition = SWITCH_POSITION_SIKAI;
 			SwitchDataStru[devId].switchFaultState = SWITCH_FAULT_STATE_YES; /*置为板卡故障*/
+			SwitchDataStru[devId].switchNormalPosCycNum = 0u;/*常态位置周期*/
+			SwitchDataStru[devId].switchUnusualLogSecFlag = SWITCH_UNUSUAL_INVALID;/*道岔非常态位置逻辑区段延时解锁标志无效*/
+			SwitchDataStru[devId].switchMutDrvCycNum = 0u;/*道岔定反操互斥驱动起始周期*/
    	    }
 	}
 
@@ -2132,11 +2184,13 @@ void ResetDynamicState(const UINT8 ciId)
 				PhysicalSectionDataStru[ii].CurAndMergeOccupyState = SECTION_OCCUPY_YES;
 				PhysicalSectionDataStru[ii].PreOccupyState = SECTION_OCCUPY_YES;
 				PhysicalSectionDataStru[ii].CurOccupyState = SECTION_OCCUPY_YES;
+				SetSecMergeOccupyStartCycNum(devId, dwCurCyc);  /*与相邻RC/CI通信中断时，设置物理区段融合占用起始周期（不考虑跨线区段）*/
+				SetPhySecMerIdleStartCycNum(devId, 0U);
 			}
 
 			PhysicalSectionDataStru[ii].ArbState = AXIS_SECTION_ARB_NO;
 			PhysicalSectionDataStru[ii].JumpLockState = PHYSICAL_SECTION_JUMP_LOCK_NO;
-			PhysicalSectionDataStru[ii].FLockType = PHY_SEC_FLOCK_TYPE_NONE;
+			PhysicalSectionDataStru[ii].FLockType = SEC_FLOCK_TYPE_NONE;
 			PhysicalSectionDataStru[ii].JumpLockStateToZC = PHYSICAL_SECTION_JUMP_LOCK_NO;
 			PhysicalSectionDataStru[ii].wPhyErrUnlockTime = 0U;
 
@@ -2280,6 +2334,9 @@ void ResetDynamicState(const UINT8 ciId)
 			}
 			PsdDataStru[devId].MutualLockRemoveState = PSD_MUTUALLOCK_REMOVE_NO;
 			PsdDataStru[devId].cPsdExceptOpenState = PSD_EXCEPT_OPEN_YES;  /*重置为PSD异常打开*/
+			PsdDataStru[devId].dwPsdMutualLockCollStartCyc = 0U;/*清除旁路采集起始时间*/
+			PsdDataStru[devId].dwPsdMutualLockErrCollCyc = 0U;/*清除误触发采集*/
+			PsdDataStru[devId].dwPsdMutualLockStartCyc = 0U;/*清除旁路有效时间*/
    	    }
 	}
 
@@ -2850,7 +2907,6 @@ void InitOcData(void)
 			for (k = 0U; k < OC_COLL_BOARD_POS_NUM; k++)
 			{
 				m_OcConvertedPtDataArr[i].BoardDatas[j].PosValueBuf[k] = 0u;
-				m_OcConvertedPtDataArr[i].BoardDatas[j].TolerateCycNum[k] = 0u;
 			}
 
 		}
@@ -3134,6 +3190,79 @@ UINT8 InitLEUDataStru(void)
 	return reVal;
 }
 
+/*
+* 功能描述：SSKS闪灯稳灯继电器动态数据初始化
+* 参数说明：无
+* 返 回 值：0 失败
+*			1 成功
+* Created By LQ 2025.12.15
+*/
+UINT8 InitSsksLightRelayData(void)
+{
+	UINT8 ret = CI_ERROR;
+	SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStr = NULL;
+	UINT16 wSsksLightRelaySum = 0U;
+	UINT16 ii = 0U;
+
+	wSsksLightRelaySum = GetSsksLightRelaySum();
+	pSsksLightRelayCfgStr = GetSsksLightRelayCfgStr();
+	if (NULL != pSsksLightRelayCfgStr)
+	{
+		ret = CI_SUCCESS;
+		for (ii = 0U; ii < wSsksLightRelaySum; ii++)
+		{
+			gSsksLightRelayData[ii].SsksLightRelayId = pSsksLightRelayCfgStr[ii].SsksLightRelayId;
+			gSsksLightRelayData[ii].RelEnterRouteLockFlag = SSKS_LIGHT_ROUTE_LOCK_NO;
+			gSsksLightRelayData[ii].RelExportRouteLockFlag = SSKS_LIGHT_ROUTE_LOCK_NO;
+			gSsksLightRelayData[ii].dwSteadyLightDelayStartCycNum = 0U;
+		}
+	}
+	else
+	{
+		ret = CI_ERROR;
+	}
+
+	return ret;
+}
+
+/*
+* 功能描述：联络线旁路继电器动态数据初始化
+* 参数说明：无
+* 返 回 值：0 失败
+*			1 成功
+* Created By wyd 20260311
+*/
+UINT8 InitConnectOverrideData(void)
+{
+	UINT8 ret = CI_ERROR;
+	ConnectOverrideCfgDataStru* pConnectOverrideCfgStr = NULL;
+	UINT16 wConnectOverrideSum = 0U;
+	UINT16 ii = 0U;
+
+	wConnectOverrideSum = GetConnectOverrideRelaySum();
+	pConnectOverrideCfgStr = GetConnectOverrideRelayCfgStr();
+	if (NULL != pConnectOverrideCfgStr)
+	{
+		ret = CI_SUCCESS;
+		for (ii = 0U; ii < wConnectOverrideSum; ii++)
+		{
+			gConnectOverrideData[ii].ConnectOverrideId = pConnectOverrideCfgStr[ii].ConnectOverrideId;
+			gConnectOverrideData[ii].OverrideState = CONNECT_OVERRIDE_STATE_NO;
+			gConnectOverrideData[ii].OverrideReason = OVERRIDE_REASON_NONE;
+			gConnectOverrideData[ii].OverridePressStartCyc = 0u;
+			gConnectOverrideData[ii].OverrideErrTrigStartCyc = 0u;
+			gConnectOverrideData[ii].OverrideErrDownState = CONNECT_OVERRIDE_ERRDOWN_NO;
+			gConnectOverrideData[ii].OverrideErrTrigState = CONNECT_OVERRIDE_ERRTRIG_NO;
+		}
+	}
+	else
+	{
+		ret = CI_ERROR;
+	}
+
+	return ret;
+}
+
 /*
 * 功能描述： 初始化无人折返指示灯状态数据
 * 参数说明： void
@@ -3245,3 +3374,90 @@ UINT8 InitialRtnIndicStaData(void)
 
 	return chReval;
 }
+
+/*
+* 功能描述：初始化接触网数据
+* 参数说明：void
+* 返回值  ：返回初始化结果
+*/
+UINT8 InitOhlDataStru(void)
+{
+	UINT16 wOhlCurSum = 0u;/*接触网当前分区数量*/
+	UINT16 ii = 0u;			/*游标*/
+	UINT8 chReval = CI_ERROR;
+	UINT16 ohlId = 0u;
+	UINT8 chLocalCiId = 0U;              /*本地联锁ID*/
+	UINT8 devBlongCiId = 0U;             /*设备所属联锁ID*/
+
+	chLocalCiId = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
+	wOhlCurSum = GetOhlCurSum();
+	if (OHL_MAX_NUM > wOhlCurSum)
+	{
+		chReval = CI_SUCCESS;
+		for (ii = 0u; ii < wOhlCurSum; ii++)
+		{
+			ohlId = GetOhlId(ii);
+			devBlongCiId = GetOhlBelongCiId(ohlId); /*获取设备所属联锁ID*/
+
+			if ((0u != ohlId) && (0U != chLocalCiId) && (chLocalCiId == devBlongCiId))
+			{/*初始化本控区*/
+				OhlDataStru[ohlId].wOhlId = ohlId;
+				OhlDataStru[ohlId].chPowerState = OHL_POWER_ENERGIZED;	/*接触网供电状态*/
+				OhlDataStru[ohlId].dwOhlDeEnerCycNum = 0u;	/*接触网断电起始周期*/
+				OhlDataStru[ohlId].dwOhlUnknowCycNum = 0u;	/*接触网未知起始周期*/
+				OhlDataStru[ohlId].chOhlBypassFlag = OHL_BYPASS_NO;/*接触网旁路状态*/
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+	}
+	else
+	{
+		;/*返回失败*/
+	}
+
+	return chReval;
+}
+
+/*
+* 功能描述：初始化ECS数据
+* 参数说明：void
+* 返 回 值：0 初始化失败
+*			1 初始化成功
+* Created By LQ 2026.01.26
+*/
+UINT8 InitialEcsData(void)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 wEcsSum = 0U;					/*防淹门总数*/
+	UINT16 wEcsId = 0U;						/*防淹门ID*/
+	UINT16 ii = 0U;							/*游标*/
+
+	wEcsSum = GetEcsCurSum();
+
+	for (ii = 0U; ii < wEcsSum; ii++)
+	{
+		wEcsId = GetEcsId(ii);
+
+		if ((0U < wEcsId) && (ECS_MAX_NUM > wEcsId))
+		{
+			ECSDataStru[wEcsId].wEcsId = wEcsId;
+			ECSDataStru[wEcsId].cAutoTrigState = ECS_AUTOTRIG_YES;
+			ECSDataStru[wEcsId].wRelTrainId = 0U;
+			ECSDataStru[wEcsId].dwTrainStopStartCycNum = 0U;
+			ECSDataStru[wEcsId].dwTrainMoveStartCycNum = 0U;
+			ECSDataStru[wEcsId].cJamState = ECS_JAM_NO;
+			ECSDataStru[wEcsId].cOccPhySecNum = 0U;
+			(void)CommonMemSet(ECSDataStru[wEcsId].szOccPhySecId, (UINT32)(sizeof(UINT16) * ECS_REL_PHYSEC_MAX_NUM), (UINT8)0U, (UINT32)(sizeof(UINT16) * ECS_REL_PHYSEC_MAX_NUM));
+		}
+		else
+		{
+			cRetVal = CI_ERROR;
+			break;
+		}
+	}
+
+	return cRetVal;
+}

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

@@ -73,6 +73,9 @@
 #include "../AutoRoute/AutoRouteDataManage.h"
 #include "../NonAutoReturn/NonAutoReturnDataManage.h"
 #include "../VirtualDevice/VirtualDevDataManage.h"
+#include "../SsksLightRelay/SsksLightRelayDataManage.h"
+#include "../ConnectOverride/ConnectOverrideDataMg.h"
+#include "SpeedLimitSecDataManage.h"
 
 #ifdef SCADE_MODE 
 #include "../LogicManage/General/LogicManageScadeInterface.h"
@@ -321,6 +324,24 @@ void InitPlatDataStru(void);
 */
 UINT8 InitLEUDataStru(void);
 
+/*
+* 功能描述：SSKS闪灯稳灯继电器动态数据初始化
+* 参数说明：无
+* 返 回 值：0 失败
+*			1 成功
+* Created By LQ 2025.12.15
+*/
+UINT8 InitSsksLightRelayData(void);
+
+/*
+* 功能描述：联络线旁路继电器动态数据初始化
+* 参数说明：无
+* 返 回 值：0 失败
+*			1 成功
+* Created By wyd 20260311
+*/
+UINT8 InitConnectOverrideData(void);
+
 /*
 * 功能描述： 初始化无人折返指示灯状态数据
 * 参数说明： void
@@ -330,6 +351,22 @@ UINT8 InitLEUDataStru(void);
 */
 UINT8 InitialRtnIndicStaData(void);
 
+/*
+* 功能描述：初始化接触网数据
+* 参数说明：void
+* 返回值  ：返回初始化结果
+*/
+UINT8 InitOhlDataStru(void);
+
+/*
+* 功能描述：初始化ECS数据
+* 参数说明：void
+* 返 回 值：0 初始化失败
+*			1 初始化成功
+* Created By LQ 2026.01.26
+*/
+UINT8 InitialEcsData(void);
+
 #ifdef __cplusplus
 }
 #endif

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

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

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

@@ -36,12 +36,17 @@ OverlapDataStruct Record_OverlapDataStru[OVERLAP_SUM_MAX];/*
 VirCIKeyDataStru Record_VirCIKeyDataStru[VIRTUAL_CI_MAX]= {0u};/*记录虚拟联锁关键数据*/
 VirCIKeyDataStru newVirCIKeyDataStru[VIRTUAL_CI_MAX]= {0u};
 SpksDataStruct Record_spksDataBuff[SPKS_SUM_MAX] = { 0u };
+SsksLightRelayDataStruct Record_SsksLightRelayDataStr[SSKS_LIGHT_RELAY_SUM_MAX] = { 0U };  /*SSKS闪灯稳灯继电器数据*/
 TrainInfoStru Record_TrainInfo[TRAIN_SUM_MAX] = { 0u };
 CfpDataStru Record_CfpInfo[CUTOFF_POINT_SUM_MAX] = { 0u };
 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 };
+OhlDataStruct Record_OhlDataStru[OHL_MAX_NUM] = { 0U };
+ECSDataStruct Record_EcsDataStru[ECS_MAX_NUM] = { 0U };
+ConnectOverrideDataStru Record_ConnectOverrideData[CONNECT_OVERRIDE_RELAY_SUM_MAX] = { 0U };
+SpeedLimitSecInfo Record_TRSDataStru[MAX_LINE_SEC_NUM] = { 0U };
 
 UINT8 outString[1024*1024] = {0u};/*比较后的设备打印数据缓冲*/
 extern QueueStruct logPrintfQue;    /*日志打印缓存队列*/
@@ -475,6 +480,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	TsrDataStruct* pNewTsrInfo = GetTsrData();			/* 临时限速信息 */
 	CfpDataStru * pNewCfpData = GetCfpData();
 	SpksDataStruct* pNewSpksData = GetSpksData();
+	SsksLightRelayDataStruct* pSsksLightRelayData = NULL;
 	OCStationIndicDataStru* pNewOCStationIndicData = GetOCStationIndicDataStru();
 	EsbDataStruct* pNewEsbData = GetEsbData();
 	LogicalRouteDataStruct* pNewLogicalRouteDataStru = GetLogicalRouteStr();
@@ -482,10 +488,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	UINT8 chEnIndex = 0u;
 	UINT8 chTrainIndex = 0u;
 	UINT16 deviceNum = 0u; 
+	UINT16 tsrSecInfoNums = 0u;
 	UINT8 localCiType = 0u;
 	UINT16 wNonAutoReturnCurSum = 0U;/*无人折返按钮当前总数*/
 	NonAutoReturnDataStruct* pNonAutoReturnData = NULL;/*无人折返数据结构体指针*/
-
+	OhlDataStruct* pOhlDataStruct = NULL;/*接触网数据结构体指针*/
+	ECSDataStruct* pEcsDataStruct = NULL;/*ECS数据结构体指针*/
+	SpeedLimitSecInfo* tsrSecInfo = NULL;/*限速区段数据结构体指针*/
+	ConnectOverrideDataStru *pConnectOverrideInfo = NULL;	/*联络线旁路数据结构体指针*/
 
     /*************************************打印物理区段数据********************************************/
     /*打印区段数据*/
@@ -543,10 +553,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
 				LongToChar(newPhysicalSectionData[deviceId].SecColOccupyStartCycNum, &outString[outStringLength]);/*区段采集占用开始周期*/
 				outStringLength += 4u;
+				LongToChar(newPhysicalSectionData[deviceId].SecMergeOccupyStartCycNum, &outString[outStringLength]);/*区段融合占用开始周期*/
+				outStringLength += 4U;
 				LongToChar(newPhysicalSectionData[deviceId].SecCurOccupyStartCycNum,&outString[outStringLength]);/*区段当前占用开始周期*/
 				outStringLength += 4u;
 				LongToChar(newPhysicalSectionData[deviceId].SecOccuToClearStartCycNum,&outString[outStringLength]);/*区段占用变空闲开始周期*/
 				outStringLength += 4u;
+				LongToChar(newPhysicalSectionData[deviceId].dwMerOccToIdleStartCycNum, &outString[outStringLength]);/*区段融合空闲开始周期*/
+				outStringLength += 4U;
 				LongToChar(newPhysicalSectionData[deviceId].AutoUnlockStartCycNum,&outString[outStringLength]);/*自动解锁延时开始周期*/
 				outStringLength += 4u;
 				LongToChar(newPhysicalSectionData[deviceId].FaultUnlockStartCycNum,&outString[outStringLength]);/*区故解解锁延时开始周期*/
@@ -713,6 +727,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength++;
 				outString[outStringLength] = newSignalData[deviceId].cDetCutBtnRelayDownState;  /*扣车旁路按钮采集继电器落下状态：0x55：正常采集落下，0xaa：通信异常落下*/
 				outStringLength++;
+				outString[outStringLength] = newSignalData[deviceId].cTrainCrossRedSignalFlag;  /*列车闯红灯标志：0x55-无效，0xAA-有效*/
+				outStringLength++;
             }
         }
         else
@@ -915,6 +931,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newSwitchData[deviceId].chSwitchJichaState;   /*道岔挤岔状态*/
 				LongToChar(newSwitchData[deviceId].SwitchCollTolerateCycNum, &outString[outStringLength]);/*容忍周期号*/
 				outStringLength += 4u; 
+				LongToChar(newSwitchData[deviceId].switchNormalPosCycNum, &outString[outStringLength]);/*道岔开始判断常态位置起始周期号*/
+				outStringLength += 4u;
+				LongToChar(newSwitchData[deviceId].switchMutDrvCycNum, &outString[outStringLength]);/*道岔驱动起始周期号-定反操互斥*/
+				outStringLength += 4u;
+				outString[outStringLength++] = newSwitchData[deviceId].switchUnusualLogSecFlag;/*道岔非常态位置逻辑区段延时锁闭标志*/
+				outString[outStringLength++] = newSwitchData[deviceId].SwitchReverseEnable;/*道岔反位使能请求（迪士尼联络线）*/
             }
         }
         else
@@ -1125,6 +1147,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newRouteData[deviceId].cRouteDrivedSGBJFlag;  /*进路驱动声光报警标志：0x55 未驱动过；0xAA 已驱动过*/
 				outString[outStringLength++] = newRouteData[deviceId].chRouteNearSecSearchState;  /*进路接近区段查询状态是否有故障车*/
 				outString[outStringLength++] = newRouteData[deviceId].chRouteApplySwitchCheckFlag;  /*进路办理相邻控区道岔检查标志*/
+				outString[outStringLength++] = newRouteData[deviceId].cRouteRequestDrvState;	/*迪士尼联络线进路请求继电器（URR）驱动状态*/
+				outString[outStringLength++] = newRouteData[deviceId].cRouteReleaseDrvState;	/*迪士尼联络线进路释放继电器（UCL）驱动状态*/
+				outString[outStringLength++] = newRouteData[deviceId].cRouteAckDrvState;		/*迪士尼联络线进路已设置保留继电器（UAR）驱动状态*/
             }
         }
 		else
@@ -1356,6 +1381,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newLogicSecData[deviceId].chLinShiXianSuSetSpeed;  /*逻辑区段临时限速值*/
 				outString[outStringLength++] = newLogicSecData[deviceId].chAblRelLogSecUsableFlag;  /*ABL列车关联逻辑区段允许使用标志*/
 				outString[outStringLength++] = newLogicSecData[deviceId].cRouteLeaveLogFlag;  /*离去区段ABL列车检查标志*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecFlockType;  /*逻辑区段封锁类型*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecProhibitFAOFlag;/*逻辑区段禁止FAO运行状态*/
 			}
         }
         else
@@ -1561,6 +1588,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength++;
 				LongToChar(newPsdData[deviceId].dwPsdRelayDownCycNum, &outString[outStringLength]);  /*PSD门关继电器落下起始周期*/
 				outStringLength += 4U;
+				LongToChar(newPsdData[deviceId].dwPsdMutualLockCollStartCyc, &outString[outStringLength]);  /*PSD旁路继电器吸起起始周期*/
+				outStringLength += 4U;
+				LongToChar(newPsdData[deviceId].dwPsdMutualLockErrCollCyc, &outString[outStringLength]);  /*PSD旁路继电器故障按下周期*/
+				outStringLength += 4U;
+				LongToChar(newPsdData[deviceId].dwPsdMutualLockStartCyc, &outString[outStringLength]);  /*PSD旁路起始周期起始周期*/
+				outStringLength += 4U;
+				outString[outStringLength++] = newPsdData[deviceId].cPsdMutualLockBtnErrState;     /*旁路按钮故障状态*/
+				outString[outStringLength++] = newPsdData[deviceId].cPsdMutualLockBtnErrDownState;  /*屏蔽门旁路按钮故障落下状态：0x55-未故障，0xAA-故障*/
 			}
 		}
 		else
@@ -2195,6 +2230,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				ShortToChar(pNewTrainInfoData[deviceId].wNextTioc, &outString[outStringLength]);/*下一TIOC编号，用作RRM*/
 				outStringLength += 2u;
 				outString[outStringLength++] = pNewTrainInfoData[deviceId].chDerailment;			/*脱轨状态*/
+				outString[outStringLength++] = pNewTrainInfoData[deviceId].chIntegrityState;		/*完整性状态*/
+				outString[outStringLength++] = pNewTrainInfoData[deviceId].chEscapeDoorState;		/*逃生门状态*/
 				ShortToChar(pNewTrainInfoData[deviceId].wHeadAxisId, &outString[outStringLength]);/*前方计轴编号*/
 				outStringLength += 2u;
 				outString[outStringLength++] = pNewTrainInfoData[deviceId].wHeadITEResult;			/*前方ITE识别结果*/
@@ -2762,6 +2799,342 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 		outStringLength = 0u;
 	}
 
+	/*************************************打印SSKS闪灯稳灯数据******************************************************/
+	pSsksLightRelayData = GetSsksLightRelayData();
+	deviceNum = GetSsksLightRelaySum();
+	for (ii = 0U; ii < deviceNum; ii++)
+	{
+		/*比较数据*/
+		comparaResult = DeviceCompara((UINT8*)(&Record_SsksLightRelayDataStr[ii]), (UINT16)sizeof(SsksLightRelayDataStruct),
+			(UINT8*)(&pSsksLightRelayData[ii]), (UINT16)sizeof(SsksLightRelayDataStruct));
+
+		if (0U == comparaResult)
+		{
+			/*比较数据一致*/
+		}
+		else if (1U == comparaResult)
+		{
+			/*比较数据不一致*/
+			if (CI_ERROR == Flag)
+			{
+				/*不打印设备数据*/
+			}
+			else
+			{
+				/**************打印数据信息****************/
+				ShortToChar(pSsksLightRelayData[ii].SsksLightRelayId, &outString[outStringLength]);  /*SSKS闪灯稳灯继电器ID*/
+				outStringLength += 2U;
+				outString[outStringLength] = pSsksLightRelayData[ii].RelEnterRouteLockFlag;  /*关联驶入存车线进路锁闭标志：0x55-无效，0xAA-有效*/
+				outStringLength++;
+				outString[outStringLength] = pSsksLightRelayData[ii].RelExportRouteLockFlag;  /*关联驶出存车线进路锁闭标志：0x55-无效，0xAA-有效*/
+				outStringLength++;
+				LongToChar(pSsksLightRelayData[ii].dwSteadyLightDelayStartCycNum, &outString[outStringLength]);  /*延时驱稳灯起始周期*/
+				outStringLength += 4U;
+			}
+		}
+		else
+		{
+			returnValue = CI_ERROR;
+			break;
+		}
+	}
+
+	if (outStringLength == 0U)
+	{
+	}
+	else
+	{
+#ifdef PLATFORM_2OO2
+		debug_infor_printf((const)"\nSsksLightRelayData:%d\nSsksLightRelayId(2)-RelEnterRouteLockFlag-RelExportRouteLockFlag-dwSteadyLightDelayStartCycNum(4):%d", (UINT16)sizeof(SsksLightRelayDataStruct), outStringLength);
+
+		debug_out_array(0xAAU, outString, outStringLength);
+
+#endif
+		/*清空打印数据*/
+		CleanString(outString);
+		outStringLength = 0U;
+	}
+
+	/*************************************打印接触网数据******************************************************/
+	pOhlDataStruct = GetOhlData();
+	deviceNum = GetOhlCurSum();
+	for (ii = 0U; ii < deviceNum; ii++)
+	{
+		/*比较数据*/
+		deviceId = GetOhlId(ii);
+
+		comparaResult = DeviceCompara((UINT8*)(&Record_OhlDataStru[deviceId]), (UINT16)sizeof(OhlDataStruct),
+			(UINT8*)(&pOhlDataStruct[deviceId]), (UINT16)sizeof(OhlDataStruct));
+
+		if (0U == comparaResult)
+		{
+			/*比较数据一致*/
+		}
+		else if (1U == comparaResult)
+		{
+			/*比较数据不一致*/
+			if (CI_ERROR == Flag)
+			{
+				/*不打印设备数据*/
+			}
+			else
+			{
+				/**************打印数据信息****************/
+				ShortToChar(pOhlDataStruct[deviceId].wOhlId, &outString[outStringLength]);  /*接触网分区ID*/
+				outStringLength += 2U;
+				outString[outStringLength] = pOhlDataStruct[deviceId].chPowerState;  /*接触网供电状态：0x55-有电，0xAA-无电，0xFF-未知*/
+				outStringLength++;
+				LongToChar(pOhlDataStruct[deviceId].dwOhlDeEnerCycNum, &outString[outStringLength]);  /*接触网断电起始周期*/
+				outStringLength += 4U;
+				LongToChar(pOhlDataStruct[deviceId].dwOhlUnknowCycNum, &outString[outStringLength]);  /*接触网未知起始周期*/
+				outStringLength += 4U;
+				outString[outStringLength] = pOhlDataStruct[deviceId].chOhlBypassFlag;  /*接触网旁路状态：0x55-未旁路，0xAA-旁路*/
+				outStringLength++;
+			}
+		}
+		else
+		{
+			returnValue = CI_ERROR;
+			break;
+		}
+	}
+
+	if (outStringLength == 0U)
+	{
+	}
+	else
+	{
+#ifdef PLATFORM_2OO2
+		debug_infor_printf((const)"\nOhlData:%d\nwOhlId(2)-chPowerState-dwOhlDeEnerCycNum(4)-dwOhlUnknowCycNum(4)-chOhlBypassFlag:%d", (UINT16)sizeof(OhlDataStruct), outStringLength);
+
+		debug_out_array(0xAAU, outString, outStringLength);
+
+#endif
+		/*清空打印数据*/
+		CleanString(outString);
+		outStringLength = 0U;
+	}
+
+	/*************************************打印ECS数据******************************************************/
+	pEcsDataStruct = GetEcsData();
+	deviceNum = GetEcsCurSum();
+	for (ii = 0U; ii < deviceNum; ii++)
+	{
+		/*比较数据*/
+		deviceId = GetEcsId(ii);
+
+		comparaResult = DeviceCompara((UINT8*)(&Record_EcsDataStru[deviceId]), (UINT16)sizeof(ECSDataStruct),
+			(UINT8*)(&pEcsDataStruct[deviceId]), (UINT16)sizeof(ECSDataStruct));
+
+		if (0U == comparaResult)
+		{
+			/*比较数据一致*/
+		}
+		else if (1U == comparaResult)
+		{
+			/*比较数据不一致*/
+			if (CI_ERROR == Flag)
+			{
+				/*不打印设备数据*/
+			}
+			else
+			{
+				/**************打印数据信息****************/
+				ShortToChar(pEcsDataStruct[deviceId].wEcsId, &outString[outStringLength]);  /*ECS/隧道 ID*/
+				outStringLength += 2U;
+				outString[outStringLength] = pEcsDataStruct[deviceId].cAutoTrigState;  /*ECS自动触发状态：0x55-启用，0xAA-停用*/
+				outStringLength++;
+				ShortToChar(pEcsDataStruct[deviceId].wRelTrainId, &outString[outStringLength]);  /*隧道关联列车ID*/
+				outStringLength += 2U;
+				LongToChar(pEcsDataStruct[deviceId].dwTrainStopStartCycNum, &outString[outStringLength]);  /*关联列车停车起始周期号*/
+				outStringLength += 4U;
+				LongToChar(pEcsDataStruct[deviceId].dwTrainMoveStartCycNum, &outString[outStringLength]);  /*关联列车移动起始周期号*/
+				outStringLength += 4U;
+				outString[outStringLength] = pEcsDataStruct[deviceId].cJamState;  /*隧道拥堵状态：0x55-拥堵，0xAA-不拥堵*/
+				outStringLength++;
+
+				if (ECS_REL_PHYSEC_MAX_NUM >= pEcsDataStruct[deviceId].cOccPhySecNum)
+				{
+					outString[outStringLength++] = pEcsDataStruct[deviceId].cOccPhySecNum;  /*隧道内占用的物理区段数量*/
+					for (jj = 0U; jj < pEcsDataStruct[deviceId].cOccPhySecNum; jj++)
+					{
+						ShortToChar(pEcsDataStruct[deviceId].szOccPhySecId[jj], &outString[outStringLength]);  /*隧道内占用的物理区段ID数组*/
+						outStringLength += 2U;
+					}
+				}
+				else
+				{
+					outString[outStringLength++] = 0U;  /*逻辑进路列车脚下逻辑区段数量超限，不打印*/
+				}
+			}
+		}
+		else
+		{
+			returnValue = CI_ERROR;
+			break;
+		}
+	}
+
+	if (outStringLength == 0U)
+	{
+	}
+	else
+	{
+#ifdef PLATFORM_2OO2
+		debug_infor_printf((const)"\nECSData:%d\nwEcsId(2)-cAutoTrigState-wRelTrainId(2)-dwTrainStopStartCycNum(4)-dwTrainMoveStartCycNum(4)-cJamState-cOccPhySecNum-szOccPhySecId(2*Num):%d", (UINT16)sizeof(ECSDataStruct), outStringLength);
+
+		debug_out_array(0xAAU, outString, outStringLength);
+
+#endif
+		/*清空打印数据*/
+		CleanString(outString);
+		outStringLength = 0U;
+	}
+
+	/*************************************打印联络线旁路数据******************************************************/
+	pConnectOverrideInfo = GetConnectOverrideData();
+	deviceNum = GetConnectOverrideRelaySum();
+	if (NULL == pConnectOverrideInfo)
+	{
+		/*异常，nothing*/
+	}
+	else
+	{
+		for (ii = 0U; ii < deviceNum; ii++)
+		{
+			/*比较数据*/
+			deviceId = pConnectOverrideInfo[ii].ConnectOverrideId;
+
+			comparaResult = DeviceCompara((UINT8*)(&Record_ConnectOverrideData[ii]), (UINT16)sizeof(ConnectOverrideDataStru),
+				(UINT8*)(&pConnectOverrideInfo[ii]), (UINT16)sizeof(ConnectOverrideDataStru));
+
+			if (0U == comparaResult)
+			{
+				/*比较数据一致*/
+			}
+			else if (1U == comparaResult)
+			{
+				/*比较数据不一致*/
+				if (CI_ERROR == Flag)
+				{
+					/*不打印设备数据*/
+				}
+				else
+				{
+					/**************打印数据信息****************/
+					ShortToChar(pConnectOverrideInfo[ii].ConnectOverrideId, &outString[outStringLength]);
+					outStringLength += 2u;
+					outString[outStringLength] = pConnectOverrideInfo[ii].OverrideState;
+					outStringLength += 1u;
+					outString[outStringLength] = pConnectOverrideInfo[ii].OverrideReason;
+					outStringLength += 1u;
+					LongToChar(pConnectOverrideInfo[ii].OverridePressStartCyc, &outString[outStringLength]);
+					outStringLength += 4u;
+					LongToChar(pConnectOverrideInfo[ii].OverrideErrTrigStartCyc, &outString[outStringLength]);
+					outStringLength += 4u;
+					outString[outStringLength] = pConnectOverrideInfo[ii].OverrideErrTrigState;
+					outStringLength += 1u;
+					outString[outStringLength] = pConnectOverrideInfo[ii].OverrideErrDownState;
+					outStringLength += 1u;
+				}
+			}
+			else
+			{
+				returnValue = CI_ERROR;
+				break;
+			}
+		}
+
+		if (0u == outStringLength)
+		{
+			/*nothing*/
+		}
+		else
+		{
+#ifdef PLATFORM_2OO2
+			debug_infor_printf((const)"\nConnectOverrideData:%d\nId(2)-State(1)-Reason(1)-PressCyc(4)-ErrTrigCyc(4)-ErrTrigStt(1)-ErrDownStt(1):%d", (UINT16)sizeof(ConnectOverrideDataStru), outStringLength);
+
+			debug_out_array(0xAAU, outString, outStringLength);
+
+#endif
+			/*清空打印数据*/
+			CleanString(outString);
+			outStringLength = 0U;
+		}
+	}
+
+	/*************************************打印SpeedLimitSec数据******************************************************/
+	tsrSecInfo = GetSpeedLimitSecInfo();
+	tsrSecInfoNums = GetSpeedLimitSectionSum();
+
+	for (ii = 0; ii < tsrSecInfoNums; ii++)
+	{
+		/*比较数据*/
+		deviceId = GetSpeedLimitSecId(ii);
+		comparaResult = DeviceCompara((UINT8*)(&Record_TRSDataStru[deviceId]), (UINT16)sizeof(SpeedLimitSecInfo),
+			(UINT8*)(&tsrSecInfo[deviceId]), (UINT16)sizeof(SpeedLimitSecInfo));
+
+		if (0U == comparaResult)
+		{
+			/*比较数据一致*/
+		}
+		else if (1U == comparaResult)
+		{
+			/*比较数据不一致*/
+			if (CI_ERROR == Flag)
+			{
+				/*不打印设备数据*/
+			}
+			else
+			{
+				/**************打印数据信息****************/
+				ShortToChar(tsrSecInfo[deviceId].secID, &outString[outStringLength]);  /*限速区段ID*/
+				outStringLength += 2U;
+				outString[outStringLength] = tsrSecInfo[deviceId].chTSRSetFlag;   /*临时限速设置标志位，0x55设置，0xaa 未设置*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chNRSRSetFlag;  /*NR限速设置标志位，0x55设置，0xaa 未设置*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chTFSRSetFlag;  /*台风限速设置标志位，0x55设置，0xaa 未设置*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chAllSRSetFlag;  /*全线限速设置标志位，0x55设置，0xaa 未设置*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chTSRSetValue;  /*临时限速值*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chNRSRSetValue;  /*NR限速值*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chTFSRSetValue;  /*台风限速值*/
+				outStringLength++;
+				outString[outStringLength] = tsrSecInfo[deviceId].chAllSRSetValue;  /*全线限速值*/
+				outStringLength++;
+					
+			}
+		}
+		else
+		{
+			returnValue = CI_ERROR;
+			break;
+		}
+
+	}
+
+	if (outStringLength == 0U)
+	{
+
+	}
+	else
+	{
+#ifdef PLATFORM_2OO2
+		debug_infor_printf((const)"\nSLSData:%d\nsecID(2)--TSRSetFlag-NRSRSetFlag-TFSRSetFlag-AllSRSetFlag:%d", (UINT16)sizeof(SpeedLimitSecInfo), outStringLength);
+
+		debug_out_array(0xAAU, outString, outStringLength);
+
+#endif
+		/*清空打印数据*/
+		CleanString(outString);
+		outStringLength = 0U;
+	}
+
+
     return returnValue;
 
 }

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

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

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

@@ -878,7 +878,7 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 							*/
 
 							/*正常情况下区故解绿光带*/
-							phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId);
+							phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId, CI_ERROR);
 							if (CI_SUCCESS == phyFaultUnLockRes)
 							{ /*成功*/
 								routeDir = GetRouteDirection(lockBelongRouteId);
@@ -993,7 +993,7 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
 				(CICI_RELAY_INTERFACE_CONFIRM_YES == confirmRelayInterfaceFlag)&&
 				(FUNC_SWITCH_ON == funcSwitchSupportRelayInterface))
 			{
-				phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId);
+				phyFaultUnLockRes = PhySecFaultUnlockLogicProcess(phySectionId, CI_ERROR);
 				if (CI_SUCCESS == phyFaultUnLockRes)
 				{ /*成功*/
 					routeDir = GetRouteDirection(lockBelongRouteId);
@@ -1607,6 +1607,7 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
 UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 {
 	UINT16 lockBelongRouteId = 0u;  /*区段锁闭所属进路ID*/
+	UINT16 wTempPhySecId = 0u;
 	UINT8 reVal = CI_ERROR;
 	UINT8 belongvirCIid = 0u;
 	UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
@@ -1672,7 +1673,7 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
 	/*按顺序解锁进路异常锁闭*/
 	if (CI_SUCCESS == reVal)
 	{
-		isErrLock = RouteFirstLockErrCheck(lockBelongRouteId);
+		isErrLock = RouteFirstLockErrCheck(lockBelongRouteId, &wTempPhySecId);
 		phyLockState = GetPhySecLockState(phySectionId);
 		/*第一个锁闭的区段是故障锁闭*/
 		if (CI_SUCCESS == isErrLock )

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

@@ -1156,6 +1156,61 @@ void OverlapZhaoChaRelayUpDateManage(void);
 */
 void TrainJumpBackApplyProc(void);
 
+/*
+* @brief 逻辑区段禁止FAO运行处理
+* @param const UINT8 setFlag 禁止FAO运行的标志
+*		 const UINT8 cLogSecSum 逻辑区段数量
+*        const UINT16 pLogSecIdBuff[] 逻辑区段序列
+*/
+void LogSecProhibitFAOManage(const UINT8 setFlag, const UINT8 cLogSecSum, const UINT16 pLogSecIdBuff[]);
+
+/*
+* 功能描述：信号机列车闯红灯处理
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.12.12
+*/
+void SignalTrainCrossRedPro(void);
+
+/*
+* @brief 接触网旁路处理
+* @param const UINT16 ohlId 接触网分区ID
+*		 const UINT8 setState 旁路标志
+*/
+void OhlBypassManage(const UINT16 ohlId, const UINT8 setState);
+
+/*
+* @brief 设置逻辑区段封锁命令处理
+*		 const UINT8 cLogSecSum 逻辑区段数量
+*        const UINT16 pLogSecIdBuff[] 逻辑区段序列
+* Created By fan 2026.01.22
+*/
+void LogSecFlockCmdSetManage(const UINT8 cLogSecSum, const UINT16 pLogSecIdBuff[]);
+
+/*
+* @brief 取消逻辑区段封锁命令处理
+*		 const UINT8 cLogSecSum 逻辑区段数量
+*        const UINT16 pLogSecIdBuff[] 逻辑区段序列
+* Created By fan 2026.01.22
+*/
+void LogSecFlockCmdCancleManage(const UINT8 cLogSecSum, const UINT16 pLogSecIdBuff[]);
+
+/*
+* 功能描述：ECS自动触发命令处理
+* 参数说明：const UINT16 EcsId ECS ID
+*           const UINT8 setState 待设置的状态
+* 返 回 值：无
+* Created By LQ 2026.01.26
+*/
+void EcsAutoTrigCmdPro(const UINT16 EcsId, const UINT8 setState);
+
+/*
+* 功能描述：道岔常态位置逻辑处理
+* 参数说明：const UINT16 EcsId ECS ID
+* 返 回 值：无
+*/
+void SwitchNormalPosProc(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -189,6 +189,9 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
 	UINT8 routeReverseProperty = 0u;
 	UINT8 airShaftRouteType = 0u;
+	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
+
+	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 
 	/* 联锁逻辑检查 */
 	/* 进路监督模式为【CBTC】*/
@@ -501,6 +504,37 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	{
 	    ;
 	}
+
+	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
+	{
+		/*迪士尼联络线其他联锁条件检查*/
+		checkResult = DsnConnectOtherCiValidCheck(routeId);
+		if (CI_ERROR == checkResult)
+		{
+			reResult = checkResult;
+		}
+		else
+		{
+			/*nothing*/
+		}
+	}
+	else
+	{
+		/*nothing*/
+	}
+
+	if ((CI_ERROR == reResult)
+		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr)
+			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
+	{
+		/*始端不在本线的迪士尼联络线进路，自动重开*/
+		reResult = CI_ROUTE_RECOVER_ERR;
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	return reResult;
 }
 
@@ -523,16 +557,16 @@ UINT8 OpenBlocLTrainRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
 	UINT8 devState = 0u;                 /*设备状态*/
-	UINT16 devId = 0u;                 /*设备ID*/
 
-
-										/* 进路内设备数据 */
 	/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
 
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
+	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
+
+	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 
 	/* 联锁逻辑检查 */
 	/* 进路监督模式为【点式】*/
@@ -734,6 +768,37 @@ UINT8 OpenBlocLTrainRouteErrProcess(const UINT16 routeId)
 			reResult = checkResult;
 		}
 	}
+
+	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
+	{
+		/*迪士尼联络线其他联锁条件检查*/
+		checkResult = DsnConnectOtherCiValidCheck(routeId);
+		if (CI_ERROR == checkResult)
+		{
+			reResult = checkResult;
+		}
+		else
+		{
+			/*nothing*/
+		}
+	}
+	else
+	{
+		/*nothing*/
+	}
+
+	if ((CI_ERROR == reResult)
+		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr)
+			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
+	{
+		/*始端不在本线的迪士尼联络线进路，自动重开*/
+		reResult = CI_ROUTE_RECOVER_ERR;
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	/* 返回 */
 	return reResult;
 }
@@ -1096,7 +1161,6 @@ UINT8 OpenBlocReturnRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
 	UINT8 devState = 0u;                 /*设备状态*/
-	UINT8 devId = 0u;                 /*设备Id*/
 
 										/* 进路内设备数据 */
 										/* 取消标志 */
@@ -1105,8 +1169,6 @@ UINT8 OpenBlocReturnRouteErrProcess(const UINT16 routeId)
 
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
-	UINT16 endSigId = 0u;				/*获取中途折返信号机ID*/
-	UINT8 endSigState = SIGNAL_OPEN;
 
 	/* 联锁逻辑检查 */
 
@@ -1346,6 +1408,9 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
 	UINT16 trainEnteringRouteState = 0u;
 	UINT8 signalCrossState = 0u;
 	UINT8 rcWorkMode = 0U; /*rc工作模式*/
+	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
+
+	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 	rcWorkMode = GetLocalRcWorkMode();
 	/* 联锁逻辑检查 */
 
@@ -1597,6 +1662,36 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
 		}
 	}
 
+	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
+	{
+		/*迪士尼联络线其他联锁条件检查*/
+		checkResult = DsnConnectOtherCiValidCheck(routeId);
+		if (CI_ERROR == checkResult)
+		{
+			reResult = checkResult;
+		}
+		else
+		{
+			/*nothing*/
+		}
+	}
+	else
+	{
+		/*nothing*/
+	}
+
+	if ((CI_ERROR == reResult)
+		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr)
+			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
+	{
+		/*始端不在本线的迪士尼联络线进路，自动重开*/
+		reResult = CI_ROUTE_RECOVER_ERR;
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	/* 返回 */
 	return reResult;
 }
@@ -1620,13 +1715,12 @@ UINT8 KeepBlocLTrainRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;				/*检查结果*/
 
 	UINT8 devState = 0u;						/*设备状态*/
-	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 cDisneyConnectAttr = CI_ERROR;	/*联络线进路类型（迪士尼）*/
-
-										/* 进路内设备数据 */
 	/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
 
+	cDisneyConnectAttr = GetRouteDisneyConnectAttr(routeId);
 	/*故障发送级别*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;
 
@@ -1823,6 +1917,36 @@ UINT8 KeepBlocLTrainRouteErrProcess(const UINT16 routeId)
 		}
 	}
 
+	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
+	{
+		/*迪士尼联络线其他联锁条件检查*/
+		checkResult = DsnConnectOtherCiValidCheck(routeId);
+		if (CI_ERROR == checkResult)
+		{
+			reResult = checkResult;
+		}
+		else
+		{
+			/*nothing*/
+		}
+	}
+	else
+	{
+		/*nothing*/
+	}
+
+	if ((CI_ERROR == reResult)
+		&& ((ROUTE_DISNEY_CONNECT_ALLOTHER == cDisneyConnectAttr) 
+			|| (ROUTE_DISNEY_CONNECT_ENDMINE == cDisneyConnectAttr)))
+	{
+		/*始端不在本线的迪士尼联络线进路，自动重开*/
+		reResult = CI_ROUTE_RECOVER_ERR;
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	/* 返回 */
 	return reResult;
 }
@@ -2142,9 +2266,7 @@ UINT8 KeepBlocReturnRouteErrProcess(const UINT16 routeId)
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
 	UINT8 devState = 0u;                 /*设备状态*/
-	UINT16 devId = 0u;                   /*设备ID*/
 
-										/* 进路内设备数据 */
 	/* 取消标志 */
 	UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
 	UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
@@ -3059,11 +3181,6 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 	UINT8  devState = 0u;
 	UINT8 ret = CI_SUCCESS;
 
-	/*进路始端信号机关联的PSD*/
-	UINT16 rtStartSigId = 0u;/*进路始端信号机ID*/
-	UINT8 psdSum = 0u;/*进路始端信号机关联的PSD数量*/
-	UINT16 *psdIdBuf = NULL;/*进路始端信号机关联的PSD ID数组*/
-	UINT16 j = 0u;/*遍历进路始端信号机关联的PSD ID数组的下标*/
 	UINT8 toOpenCheckFlag = 0u;/*恢复可重开信号的条件标志*/
 	UINT8 otherResult = 0u;/*其他联锁检查条件返回值*/
 	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
@@ -3088,17 +3205,13 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 	/* 开始检查 */
 	if ((0u != checkSum) && (NULL != dataOtherCiDevBuf))
 	{
-		rtStartSigId = GetRouteStartSignalId(routeId);/*获得进路始端信号机*/
-		psdSum = GetSignalRelatedPsdSum(rtStartSigId);/*获得进路始端信号机关联的PSD数量*/
-		psdIdBuf = GetSignalRelatedPsdBuf(rtStartSigId);/*获得进路始端信号机关联的PSD ID数组*/
-
 		/*开始检查*/
 		for (i = 0u; i < checkSum; i++)
 		{
 			tmpOtherCiDevInfo = &dataOtherCiDevBuf[i];
 
 			toOpenCheckFlag = 0u;/*默认为恢复不可重开*/
-								/*判断检查条件为SPKS或是本信号机关联的PSD*/
+			/*判断检查条件为SPKS或是进站、出战关联的PSD*/
 			if (CI_DEVICE_TYPE_SPKS == tmpOtherCiDevInfo->DevType)
 			{
 				cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
@@ -3114,17 +3227,11 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 			}
 			else if (CI_DEVICE_TYPE_PSD == tmpOtherCiDevInfo->DevType)
 			{
-				if ((NULL != psdIdBuf) && (0u < psdSum))
+				toOpenCheckFlag = 1U;
-				{
-					for (j = 0u;j < psdSum;j++)
-					{
-						if (psdIdBuf[j] == tmpOtherCiDevInfo->DevId)
-						{
-							toOpenCheckFlag = 1u;
-							break;
-						}
-					}
 			}
+			else if (CI_DEVICE_TYPE_ESB == tmpOtherCiDevInfo->DevType)
+			{
+				toOpenCheckFlag = 1U;
 			}
 			else
 			{
@@ -3175,10 +3282,13 @@ static UINT8 RouteSecFLockErrCheck(UINT16 const routeId)
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8 ret = CI_SUCCESS;
-	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;/*物理区段封锁类型变量*/
+	UINT8 cRouteFlockCheck = CI_ERROR;  /*封锁检查*/
-	UINT8 cRouteLevel = ROUTE_LEVEL_BLOC;  /*进路级别*/
+	UINT8 chFlockType = 0U;/*区段封锁类型*/
-	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
+	UINT8 chPassFlockType = SEC_FLOCK_CBTCLASTSEC_PASS;/*不检查的类型*/
-
+	UINT8 chPassLastFlock = ROUTE_PASS_LAST_FLOCK_NO;/*跳过最后区段配置*/
+	UINT8 	chRouteLevel = 0U;/*进路等级*/
+	chRouteLevel = GetRouteLevel(routeId);
+	chPassLastFlock = GetRoutePassLastFlockProperty(routeId);
 	if (0u == checkSum) 
 	{
 		/*区段数据错误*/
@@ -3191,40 +3301,31 @@ static UINT8 RouteSecFLockErrCheck(UINT16 const routeId)
 		{
 			devId = dataIdBuf[i].PhysicalSectionId;
 			devState = GetPhySecFLockState(devId);
+			chFlockType = GetPhySecFLockType(devId);
 
 			/* 状态如果不是未封锁状态，则认为检查失败 */
 			if (PHYSICAL_SECTION_FLOCK_NO == devState)
 			{
 				/*不处理*/
 			}
+			else if ((ROUTE_LEVEL_CBTC == chRouteLevel)
+				&& (ROUTE_PASS_LAST_FLOCK_YES == chPassLastFlock)
+				&& ((checkSum - 1U) == i)
+				&& (chPassFlockType == (chPassFlockType | chFlockType)))
+			{
+				;/*CBTC进路最后区段 具备不检查ESB/APG/SPKS封锁属性/*/
+			}
 			else if (PHYSICAL_SECTION_FLOCK_YES ==devState )
 			{
-				fLockType = GetPhySecFLockType(devId);/*获得物理区段封锁类型*/
+				cRouteFlockCheck = SectionFlockReOpenCheck(devId, routeId);
-
+				if ((CI_SUCCESS == cRouteFlockCheck)&&(CI_ERROR != ret))
-				if (PHY_SEC_FLOCK_TYPE_SPKS == fLockType)
 				{
-					if (CI_ERROR != ret)
-					{
-						cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
-						cRouteLevel = GetRouteLevel(routeId);
-						if ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel)))
-						{
-							/*SPKS信号重开检查进路级别开关打开或（关闭且进路级别为CBTC）*/
 					ret = CI_ROUTE_RECOVER_ERR;
 				}
 				else
 				{
 					ret = CI_ERROR;
-						}
+					break;
-					}
-					else
-					{
-					    ;
-					}
-				}
-				else
-				{
-					ret = CI_ERROR;
 				}
 			}
 			else
@@ -3256,10 +3357,7 @@ static UINT8 OverlapAllSecFLockValidErrCheck(UINT16 const overlapId)
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8 ret = CI_SUCCESS;
-
+	UINT8 fLockOpenCheck = CI_ERROR;/*物理区段封锁类型变量*/
-	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;/*物理区段封锁类型变量*/
-	UINT8 cRouteLevel = ROUTE_LEVEL_BLOC;  /*进路级别*/
-	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号重开检查进路级别开关*/
 	UINT16 wBelongRouteId = 0U;  /*保护区段锁闭所属进路*/
 
 	if ((0U != overlapId) && (OVERLAP_SUM_MAX != overlapId))
@@ -3280,19 +3378,12 @@ static UINT8 OverlapAllSecFLockValidErrCheck(UINT16 const overlapId)
 					/*不处理*/
 				}
 				else if (PHYSICAL_SECTION_FLOCK_YES == devState)
-				{
-					fLockType = GetPhySecFLockType(devId);/*获得物理区段封锁类型*/
-
-					if (PHY_SEC_FLOCK_TYPE_SPKS == fLockType)
 				{
 					wBelongRouteId = GetOverlapBelongRouteId(overlapId);
-						if ((CI_ERROR != ret) && (CI_ERROR != wBelongRouteId))
+					fLockOpenCheck = SectionFlockReOpenCheck(devId, wBelongRouteId);/*获得物理区段封锁重开检查*/
+
+					if ((CI_ERROR != fLockOpenCheck)&&(CI_ERROR != ret))
 					{
-							cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
-							cRouteLevel = GetRouteLevel(wBelongRouteId);
-							if ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel)))
-							{
-								/*SPKS信号重开检查进路级别开关打开或（关闭且进路级别为CBTC）*/
 						ret = CI_ROUTE_RECOVER_ERR;
 					}
 					else
@@ -3301,16 +3392,6 @@ static UINT8 OverlapAllSecFLockValidErrCheck(UINT16 const overlapId)
 					}
 				}
 				else
-						{
-							;
-						}
-					}
-					else
-					{
-						ret = CI_ERROR;
-					}
-				}
-				else
 				{
 					ret = CI_ERROR;
 				}
@@ -4223,6 +4304,28 @@ static UINT8 KeepCbtcRouteSectionErrCheck(const UINT16 routeId)
 	
 #endif
 
+	if (CI_SUCCESS == reResult)
+	{
+		/*CBTC通过进路需再检查数据中配置的逻辑区段的占用状态*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteCbtcKeepOpenLgcOccCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*非列车进路或已经检查失败，不处理*/
+	}
+
 	/* 进路内所有区段未被封锁 */
 	if (CI_SUCCESS == reResult)
 	{
@@ -4342,6 +4445,29 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	    ;
 	}
 
+	if (CI_SUCCESS == reResult)
+	{
+		/*CBTC通过进路需再检查数据中配置的逻辑区段的占用状态*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteCbtcLogSecOccCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*非列车进路或已经检查失败，不处理*/
+	}
+
+
 /*使用新增的函数RouteIntruSecVainSPKSErrCheck*/
 #if 0
 	/*侵限区段侵限条件不满足检查*/
@@ -4383,7 +4509,7 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	}
 #endif
 	/* 进路内所有区段未被封锁 */
-	if (checkResult == CI_SUCCESS)
+	if (CI_SUCCESS == reResult)
 	{
 		checkResult = RouteSecFLockErrCheck(routeId);
 		if ((CI_ERROR == checkResult) || (CI_ROUTE_RECOVER_ERR == checkResult))
@@ -4538,10 +4664,8 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 	UINT8 devJumpLockState = 0U;
 	UINT8 intruSwitchPosValid = CI_ERROR;
 	UINT8 reVal = CI_ERROR;
-	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;/*物理区段封锁类型变量*/
+	UINT8 fLockOpenCheck = CI_ERROR;/*物理区段封锁检查*/
 	UINT8 checkFlockFlag = GetCiFunctionSwitchConfig(FUNC_INTRUSEC_CHECKFLOCK_FLAG);
-	UINT8 cFuncSwitchSpks = 0U; /*SPKS自动信号重开是否检查进路级别开关*/
-	UINT8 cRouteLevel = 0U;
 	UINT8 chPhySecLogLockState = 0U;/*物理区段逻辑锁闭状态*/
 
 	/* 检查侵限状态 */
@@ -4554,21 +4678,16 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 	{
 		/*开始检查*/
 		reVal = CI_SUCCESS;/*先将返回值设置成功，若侵限成立则会修改函数返回值为CI_ERROR或CI_ROUTE_RECOVER_ERR*/
-		cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
-		cRouteLevel = GetRouteLevel(routeId);
 
 		for (i = 0u; i < checkSum; i++)
 		{
 			devId = dataIdBuf[i].SectionId;
 			devState = GetPhySecCurMergeState(devId);/*获取物理区段占用状态*/
 			devFLockState = GetPhySecFLockState(devId);/*获取物理区段封锁状态*/
-			fLockType = GetPhySecFLockType(devId);/*获取物理区段封锁类型*/
 			devLockState = GetPhySecLockState(devId);
 			devJumpLockState = GetPhySecJumpLockState(devId);
 			chPhySecLogLockState = PhySecLogLockStateCheck(devId);
 
-
-
 			/* 检查侵限区段是否占用或封锁*/
 			if ((SECTION_OCCUPY_YES == devState)
 				|| ((PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (FUNC_SWITCH_ON != checkFlockFlag))
@@ -4605,10 +4724,11 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 					if (CI_ERROR == intruSwitchPosValid)
 					{
 						/*有岔侵限条件成立*/
+						fLockOpenCheck = SectionFlockReOpenCheck(devId, routeId);
 						if ((PHYSICAL_SECTION_JUMP_LOCK_YES != devJumpLockState) && (PHYSICAL_SECTION_LOCK_NO == devLockState) && (SECTION_OCCUPY_YES != devState)
-							&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (PHY_SEC_FLOCK_TYPE_SPKS == fLockType) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
+							&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
-							&& ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel))))
+							&& (CI_SUCCESS==fLockOpenCheck))
-						{/*侵限区段未占用且封锁且是由于SPKS按下导致的封锁且(SPKS自动重开开关打开或关闭但进路为CBTC)，在SPKS恢复后可自动重开*/
+						{/*侵限区段未占用且封锁且是由于可重开的封锁（spks或全线封锁），在恢复后可自动重开*/
 							reVal = CI_ROUTE_RECOVER_ERR;
 						}
 						else
@@ -4619,10 +4739,11 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
 				}
 				else
 				{
+					fLockOpenCheck = SectionFlockReOpenCheck(devId, routeId);
 					if ((PHYSICAL_SECTION_JUMP_LOCK_YES != devJumpLockState) && (PHYSICAL_SECTION_LOCK_NO == devLockState) && (SECTION_OCCUPY_YES != devState)
-						&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (PHY_SEC_FLOCK_TYPE_SPKS == fLockType) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
+						&& (PHYSICAL_SECTION_FLOCK_YES == devFLockState) && (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)
-						&& ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel))))
+						&& (CI_SUCCESS == fLockOpenCheck))
-					{/*侵限区段未占用且封锁且是由于SPKS按下导致的封锁且(SPKS自动重开开关打开或关闭但进路为CBTC)，在SPKS恢复后可自动重开*/
+					{/*侵限区段未占用且封锁且是由于可重开的封锁（spks或全线封锁），在恢复后可自动重开恢复后可自动重开*/
 						reVal = CI_ROUTE_RECOVER_ERR;
 					}
 					else
@@ -4665,8 +4786,6 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 	UINT8 thisRelayState = 0U;
 	UINT8 routeState = 0U;
 	UINT8 retVal = CI_ERROR;                      /*函数返回值*/
-	UINT16 pDevId = 0U;
-	UINT8 pDevState = 0U;
 	UINT8 chErrTemp = 0U;
 
 	/* 对端照查检查 */
@@ -4790,15 +4909,13 @@ UINT8 RoutePhySecZhaoChaErrCheck(UINT16 const routeId ,UINT16 const phySecId)
 	UINT8 secLockedDirection = 0u;                    /*区段锁闭方向*/
 	UINT8 routeDirection = 0u;                        /*进路方向*/
 	UINT8 retVal = CI_ERROR;                         /*函数返回值*/
-	UINT8 fLockType = PHY_SEC_FLOCK_TYPE_NONE;       /*物理区段封锁类型变量*/
+	UINT8 fLockOpenCheck = CI_ERROR;       /*物理区段封锁重开检查*/
 	UINT8 phyBelongCi = 0u;                          /*物理区段所属联锁*/
 	UINT8 commState = 0u;                            /*通信状态*/
 	                                                 /*相邻联锁是否支持继电接口*/
 	UINT8 funcSwitchSupportRelayInterface = GetCiFunctionSwitchConfig(FUNC_SWITCH_USE_RELAY_INTERFACE_BETWEEN_NEIGHBOURCI);
 	UINT8 localCi = GetSystemParaLocalCiId();        /*本机联锁*/
 	UINT8 confirmRelayInterfaceFlag = GetCiCiRelayInterfConfirmFlag();/*继电接口确认状态*/
-	UINT8 cFuncSwitchSpks = 0U;  /*SPKS信号自动重开开关，0x55检查进路级别，0xaa不检查*/
-	UINT8 cRouteLevel = 0U;
 
 	if ((0U == routeId ) || (0U == phySecId))
 	{
@@ -4856,12 +4973,10 @@ UINT8 RoutePhySecZhaoChaErrCheck(UINT16 const routeId ,UINT16 const phySecId)
 			}
 			else if (PHYSICAL_SECTION_FLOCK_YES == secFlockState)
 			{
-				fLockType = GetPhySecFLockType(phySecId);/*获得物理区段封锁类型*/
+				fLockOpenCheck = SectionFlockReOpenCheck(phySecId, routeId);/*物理区段封锁重开检查*/
-				cFuncSwitchSpks = GetCiFunctionSwitchConfig(FUNC_REPEATE_OPEN_CHECK_SPKS);
+				if (CI_SUCCESS == fLockOpenCheck)
-				cRouteLevel = GetRouteLevel(routeId);
-				if ((PHY_SEC_FLOCK_TYPE_SPKS == fLockType) && ((FUNC_SWITCH_ON == cFuncSwitchSpks) || ((FUNC_SWITCH_OFF == cFuncSwitchSpks) && (ROUTE_LEVEL_CBTC == cRouteLevel))))
 				{
-					retVal = CI_ROUTE_RECOVER_ERR;  /* 状态如果SPKS导致的封锁且SPKS自动重开开关打开或关闭但进路为CBTC，则可以恢复重开*/
+					retVal = CI_ROUTE_RECOVER_ERR;  /* 区段封锁且是可重开封锁类型导致封锁，在封锁恢复后可自动重开*/
 				}
 				else
 				{

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

@@ -3787,7 +3787,7 @@ void SetSwitchPositionM(const UINT16 switchId, const UINT8 switchSetPos)
 	if (CI_SUCCESS == check_Result)
 	{/*데꾸貫零唐槻*/
 		/*데꾸돛뀄뇹잿*/
-		if (CI_SUCCESS == SetSwitchPositionLogicProcess(switchId, switchSetPos, 0u, &chTemp))
+		if (CI_SUCCESS == SetSwitchPositionLogicProcess(switchId, switchSetPos, 0u, &chTemp, ESEND_LEVEL_ATS))
 		{ /*쇱꿴繫법*/
 
 			(void)SetSwitchDanCaoPosition(switchId, switchSetPos); /*�零데꾸貫零깃羚*/

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

@@ -1006,11 +1006,12 @@ UINT8 ChekRoutSwitDrivOvtmStat(const UINT16 routeId);
 /*
 * 功能描述： 区段故障解锁
 * 参数说明： UINT16 const phySectionId
+*			 UINT8 const isConnectSec 是否联络线（联络线不报警）CI_SUCCESS是 CI_ERROR否
 * 返回值  ： CI_ERROR
 *            CI_SUCCESS
 * 故障编码： EFUNC_UNLOCK_FAULT_SECTION
 */
-UINT8 PhySecFaultUnlockLogicProcess(const UINT16 phySectionId);
+UINT8 PhySecFaultUnlockLogicProcess(const UINT16 phySectionId, UINT8 const isConnectSec);
 
 /*
 * 功能描述： 检查进路总人解的可行性。只要进路有一个区段可以直接解锁或变绿光带都认为总人解可行。
@@ -1734,6 +1735,16 @@ UINT8 LogicSecFLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
 */
 UINT8 LogicSecRelativeSwitchPosCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState);
 
+/*
+* 功能描述：获取逻辑区段所处道岔位置不一致原因
+* 参数说明：UINT16 const wLgcId 逻辑区段ID
+* 返 回 值：1 位置一致
+*           0x55 道岔在相反位置
+*           0xAA 道岔失表
+* Created By LQ 2025.12.19
+*/
+UINT8 GetLogSecRelSwPosErrReason(UINT16 const wLgcId);
+
 /*
 * 功能描述： 进路VBTC条件下第一逻辑区段检查
 * 参数说明：
@@ -2613,7 +2624,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 +2717,13 @@ UINT8 OtherCiOvlpRelProSwMovValCheck(const UINT16 wOverlapId);
 UINT8 OverlapProSwUsingCheck(const UINT16 wOverlapId, UINT16* pDevId, UINT8* pDevState, UINT8* pAlarmType);
 
 /*
-* 功能描述： 获取指定进路办理相邻控区道岔检查标志
+* 功能描述： 进路关联所有道岔位置正确检查
-* 参数说明： const UINT16 routeId 进路ID
+* 参数说明： UINT16 const routeId,    进路号）
-* 返 回 值： 进路办理相邻控区道岔检查标志
+* 返回值  ： CI_ERROR
-* 输出参数：UINT16* switchID道岔ID、UINT8* chSwitchState道岔状态
+*            CI_SUCCESS
-* by cgh 20241202
+* BY CGH 20250224
 */
-UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId, UINT16* switchID, UINT8* chSwitchState);
+UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId);
 
 /*
 *函数功能：保护区段照查继电器检查
@@ -2763,26 +2774,35 @@ UINT8 RouteCldAttrCheck(UINT16 wRouteId);
 UINT8 OverlapOccuUnlockCheck(UINT16 overlapId, UINT8 functionId);
 
 /*
-* 功能描述：列车占用完全在指定区段检查
+* 功能描述：区段封锁但可重开条件检查:存在spks封锁时检查开关打开或cbtc进路、无CMD封锁
-* 输入参数：const UINT16 wPhySecId 物理区段ID
+* 参数说明：UINT16 wPhySecId 区段ID wRouteId进路ID
-*           const UINT16 wTrainId  列车ID
+* 返 回 值：CI_ERROR 0 失败 非可重开封锁
-* 输出参数：无
+*           CI_SUCCESS 1 成功 可重开的封锁类型
-* 返回值  ：CI_ERROR 0 不完全在
+* Created By fan 2025.12.16
-*           CI_SUCCESS 1 完全在
-* by cgh 20251017
 */
-UINT8 TrainOccSameSecCheck(const UINT16 wPhySecId, const UINT16 wTrainId);
+UINT8 SectionFlockReOpenCheck(UINT16 wPhySecId, UINT16 wRouteId);
 
 /*
-* 功能描述：占用是否属于同一区段检查
+* 功能描述：CBTC进路逻辑区段占用检查
-* 输入参数：const UINT16 wBasePhySecId 基准物理区段ID
+* 参数说明：UINT16 const routeId 进路ID
-*           const UINT16 wCheckPhySecId 待检查物理区段ID
+*           UINT16 *pDevId 设备Id（出参）
-* 输出参数：无
+*           UINT8 *pDevState 设备状态（出参）
-* 返回值  ：CI_ERROR 0 不属于
+* 返 回 值：CI_ERROR 0 失败
-*           CI_SUCCESS 1 属于
+*           CI_SUCCESS 1 成功
-* by cgh 20251017
+* Created By LQ 2026.01.25
 */
-UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId);
+UINT8 RouteCbtcLogSecOccCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述：CBTC进路保持开放阶段逻辑区段占用检查
+* 参数说明：UINT16 const routeId 进路ID
+*           UINT16 *pDevId 设备Id（出参）
+*           UINT8 *pDevState 设备状态（出参）
+* 返 回 值：CI_ERROR 0 失败
+*           CI_SUCCESS 1 成功
+* Created By LQ 2026.03.12
+*/
+UINT8 RouteCbtcKeepOpenLgcOccCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
 
 #endif
 

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

@@ -368,7 +368,7 @@ UINT8 RoutePhySectionUseLogicProcess(const UINT16 routeId);
 * 故障编码： EFUNC_SET_SWITCH_POS
 * cgh-合并CID-3037-6：
 */
-UINT8 SetSwitchPositionLogicProcess(UINT16 const switchId, UINT8 const switchSetPos, const UINT8 chCmdType, UINT8* chSwitchTestFlag);
+UINT8 SetSwitchPositionLogicProcess(UINT16 const switchId, UINT8 const switchSetPos, const UINT8 chCmdType, UINT8* chSwitchTestFlag, UINT8 sendLevelFlag);
 
 /* C30_设置道岔单锁*/
 /*
@@ -815,6 +815,23 @@ UINT8 RouteLgcSecResUnlockNextSecCheck(const UINT16 wRouteId, const UINT16 wUnlo
 */
 UINT8 RouteLgcSecResReturnSecCheck(UINT16 wValidReturnSigId, const UINT16 wRouteId);
 
+/*
+* 功能描述： 迪士尼联络线其他联锁条件检查
+* 参数说明： UINT16 routeId 进路ID
+* 返回值  ： CI_ERROR						检查失败
+*            CI_SUCCESS						检查成功
+* 注意事项： 本函数只检查区段方向、进路协议相关内容
+*/
+UINT8 DsnConnectOtherCiValidCheck(UINT16 const routeId);
+
+/*
+* 功能描述：迪士尼联络线自动区故解处理
+* 参数说明：const UINT16 wRouteId 进路ID
+* 返 回 值：CI_SUCCESS：可以解锁 CI_ERROR：不能解锁
+* Created By wyd 20260318
+*/
+void DsnConnectRouteSecUnlockProc(UINT16 wRouteId);
+
 #if 0 
 /*
 * 功能描述： 逻辑区段保护锁闭可用性逻辑处理

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

@@ -274,15 +274,17 @@ UINT8 LockLogRouteCheckProcess(UINT16 const logRouteId)
 *          UINT8 pDevState,设备状态
 * @note：
 */
-UINT8 LogRoutePhySecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState)
+UINT8 LogRouteSecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState)
 {
 	UINT16* LogSecIdBuff = NULL;
 	UINT16 logSecSum = 0U;
 	UINT16 ii = 0U;
-	UINT16 devId = 0U; /*¹ØÁªÎïÀíÇø¶ÎID*/
+	UINT16 devId = 0U; /*关联区段ID*/
 	UINT8 devState = 0U;
 	UINT8 retval = CI_ERROR;
-
+	UINT8 chShareSwitchNum = 0U;/*共用道岔区段个数*/
+	UINT16* plogSecIdPBuf = NULL;/*共用道岔区段序列*/
+	UINT8 jj = 0U;
 	LogSecIdBuff = GetLogicalRouteInLogSecId(logRouteId);
 	logSecSum = GetLogicalRouteInLogSecSum(logRouteId);
 	if ((NULL != LogSecIdBuff) && (0U != logSecSum) && (NULL!= pDevId) && (NULL != pDevState))
@@ -290,21 +292,48 @@ UINT8 LogRoutePhySecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevS
 		retval = CI_SUCCESS;
 		for (ii = 0U; ii < logSecSum; ii++)
 		{
-			devId = GetLgcSecRelativePhySecId(LogSecIdBuff[ii]);
+			devId =LogSecIdBuff[ii];
-			devState = GetPhySecFLockState(devId);
+			devState = GetLogSecFLockType(devId);
-
 			/* 状态如果不是未封锁状态，则认为检查失败 */
-			if (PHYSICAL_SECTION_FLOCK_NO != devState )
+			if (SEC_FLOCK_TYPE_NONE != devState )
 			{
 				/*状态不一致返回故障状态*/
 				*pDevId = devId;
-				*pDevState = devState;
+				*pDevState = PHYSICAL_SECTION_FLOCK_YES;
 				retval = CI_ERROR;
-				break;
 			}
 			else
 			{
-				/*¼ÌÐø¼ì²é*/
+				chShareSwitchNum = GetLogSecSameSwitchSecSum(devId);
+				plogSecIdPBuf = GetLogSecSameSwitchSecId(devId);
+				if ((PHYSICAL_INCLUDE_AXIS_SUM_MAX > chShareSwitchNum) && (NULL != plogSecIdPBuf))
+				{	
+					/*检查与逻辑区段共用道岔的逻辑区段封锁状态*/
+					for (jj = 0U; jj < chShareSwitchNum; jj++)
+					{
+						devState = GetLogSecFLockType(plogSecIdPBuf[jj]);/*逻辑区段封锁*/
+						if (SEC_FLOCK_TYPE_NONE != devState)
+						{
+							/*区段处于封锁状态*/
+							/*状态不一致返回故障状态*/
+							*pDevId = plogSecIdPBuf[jj];
+							*pDevState = PHYSICAL_SECTION_FLOCK_YES;
+							retval = CI_ERROR;
+							break;
+						}
+					}
+				}
+				else
+				{
+					*pDevId = devId;
+					*pDevState = PHYSICAL_SECTION_FLOCK_YES;
+					retval = CI_ERROR;
+				}
+				
+			}
+			if (CI_ERROR == retval)
+			{
+				break;/*跳出*/
 			}
 		}
 	}
@@ -637,7 +666,7 @@ UINT8 LogRouteSectionCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLevel)
 	/*逻辑进路关联的物理区段未封锁*/
 	devId = 0u;
 	devState = 0u;
-	checkResult = LogRoutePhySecFengSuoCheck(logRouteId, &devId, &devState);
+	checkResult = LogRouteSecFengSuoCheck(logRouteId, &devId, &devState);
 	if (checkResult == CI_SUCCESS)
 	{
 		/* 通过检查 */
@@ -646,7 +675,7 @@ UINT8 LogRouteSectionCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLevel)
 	else
 	{
 		/* 记录故障码 */
-		SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
+		SetErrorData(functionId, CI_DEVICE_TYPE_LOGICSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
 		/* 失败返回 */
 		reResult = CI_ERROR;
 	}
@@ -2010,7 +2039,7 @@ UINT8 KeepLogRouteSectionCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendL
 	UINT8 devState = 0U;                 /*设备状态*/
 
 	/* 逻辑进路内所有区段未被封锁 */
-	checkResult = LogRoutePhySecFengSuoCheck(wLogRouteId, &devId, &devState);
+	checkResult = LogRouteSecFengSuoCheck(wLogRouteId, &devId, &devState);
 	if (CI_SUCCESS == checkResult)
 	{
 		/* 通过检查 */
@@ -2019,7 +2048,7 @@ UINT8 KeepLogRouteSectionCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendL
 	else
 	{
 		/* 记录故障码 */
-		SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
+		SetErrorData(functionId, CI_DEVICE_TYPE_LOGICSEC, devId, ETYPE_PS_FLOCK_STATE, devState, sendLevel);
 		/* 失败返回 */
 		reResult = CI_ERROR;
 	}

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

@@ -51,7 +51,7 @@ UINT8 LockLogRouteCheckProcess(UINT16 const logRouteId);
 *          UINT8 sendLevel,       故障码发送级别
 * @note：
 */
-UINT8 LogRoutePhySecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState);
+UINT8 LogRouteSecFengSuoCheck(UINT16 logRouteId, UINT16* pDevId, UINT8* pDevState);
 
 /**
 * @brief 逻辑进路逻辑区段锁闭检查

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

@@ -113,7 +113,7 @@ UINT8 MainProcess(void)
 
 	cost[2] = MSCP_GetTick();
 	/*退出运营处理*/
-	(void)APP_API_ExitOperation();
+	APP_API_ExitOperation();
 
 
 	/*联锁逻辑处理*/

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

@@ -98,6 +98,8 @@
 #define MASK_ZC_CI_SIG_ENGINEERV_NEAR              ((UINT8)0x97)    /*定义信号机工程车接近码位*/
 #define MASK_CI_ZC_SIG_ENGINCROSS_STE              ((UINT8)0x98)    /*定义信号机工程车关灯码位*/
 
+#define MASK_TYPE_SIGNAL_CROSS_RED                 ((UINT8)0x9F)    /*定义CI-ATS信号机列车闯红灯码位*/
+
 /*物理区段相关码位*/
 #define MASK_TYPE_PHYSECTION_OCCUPY                 ((UINT8)0x25)    /*定义物理区段占用码位*/
 #define MASK_TYPE_PHYSECTION_STARTLOCK              ((UINT8)0x26)    /*定义物理区段上电锁闭码位*/
@@ -140,8 +142,13 @@
 #define MASK_TYPE_LOGICSECTION_JUMPLOCK				((UINT8)0x9A)   /*定义逻辑区段跳跃锁闭码位*/
 #define MASK_TYPE_LOGICSECTION_ARB		            ((UINT8)0x9B)   /*定义逻辑区段ARB状态码位*/
 #define MASK_TYPE_LOGICSECTION_SPKS_FLOCK		    ((UINT8)0x9C)   /*定义逻辑区段SPKS封锁状态码位*/
-
+#define MASK_TYPE_LOGICSECTION_ALLSEC_FLOCK			((UINT8)0x9D)	/*定义逻辑区段全线封锁状态码位*/
-
+#define MASK_TYPE_LOGICSECTION_APG_FLOCK			((UINT8)0x9E)	/*定义逻辑区段站台门异常打开封锁码位*/
+#define MASK_TYPE_LOGICSECTION_PROHIBIT_FAO			((UINT8)0x9F)	/*定义逻辑区段禁止FAO运行码位*/
+#define MASK_TYPE_LOGICSECTION_CMD_FLOCK			((UINT8)0xA0)	/*定义逻辑区段人工封锁码位*/
+#define MASK_TYPE_LOGICSECTION_ESB_FLOCK			((UINT8)0xA1)	/*定义逻辑区段ESB封锁码位*/
+#define MASK_TYPE_LOGICSECTION_CESB_FLOCK			((UINT8)0xA2)	/*定义逻辑区段CESB封锁码位*/
+#define MASK_TYPE_LOGICSECTION_OVERRIDE				((UINT8)0xA8)	/*定义逻辑区段旁路码位*/
 
 /*保护区段相关码位*/
 #define MASK_TYPE_OVERLAP_LOCKSTATE                 ((UINT8)0x30)   /*定义保护区段锁闭状态码位*/
@@ -182,6 +189,7 @@
 #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_ESS_STATE                   ((UINT8)0xA7)    /*定义ESS去位/停位状态码位*/
 
 /*站台安全门相关码位*/
 #define MASK_TYPE_PSD_STATE                         ((UINT8)0x60)   /*定义站台安全门状态码位-ZC,LEU用*/
@@ -200,6 +208,7 @@
 #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_MUTUALLOCK_BTNERR                   ((UINT8)0xA6)   /*定义站台安全门互锁解除按钮异常码位*/
 
 /*车库门相关码位*/
 #define MASK_TYPE_GARAGEDOOR_OPEN_STATE             ((UINT8)0x62)    /*定义车库门开门状态码位（CI->ATS）*/
@@ -235,5 +244,10 @@
 
 /*防淹门相关码位*/
 
+/*临时限速相关码位*/
+#define  MASK_TYPE_SPEEDLIMITSEC_STATE              ((UINT8)0x9F)  /*CI-ATS限速区段临时限速设置码位*/
+#define  MASK_TYPE_SPEEDLIMITTF_STATE               ((UINT8)0xa9)  /*CI-ATS限速区段台风限速设置码位*/
+#define  MASK_TYPE_SPEEDLIMITTNR_STATE              ((UINT8)0xab)  /*CI-ATS限速区段NR限速设置码位*/
+#define  MASK_TYPE_SPEEDLIMITQX_STATE               ((UINT8)0xac)  /*CI-ATS限速区段全线临时限速设置码位*/
 
 #endif

TSCP/src/APP/ciapp/OHL/OHLConfigDataManage.c

@@ -0,0 +1,267 @@
+/********************************************************
+*
+* 文 件 名： OHLConfigDataManage.c
+* 版权说明： 北京交控科技有限公司
+* 创建时间： 
+* 作    者： 联锁组
+* 功能描述： 接触网相关配置
+* 函数包括：
+* 使用注意：
+* 修改记录：
+*
+********************************************************/
+
+#include "OHLConfigDataManage.h"
+
+OHLConfigDataStruct OhlConfigDataStru[OHL_MAX_NUM];	/*定义接触网数据配置结构体*/
+INT16 OhlCurSum = 0;   /*接触网当前总数*/
+UINT16 LocalCiOhlIdBuf[OHL_MAX_NUM] = { 0u };                   /*定义本地联锁接触网ID映射数组*/
+
+/*
+* 功能描述： 获取指定ID接触网索引号
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： SWITCH_SUM_MAX: 获取数据失败
+*			<SWITCH_SUM_MAX: 查找成功
+*/
+UINT16 GetOhlConfigBufIndex(const UINT16 ohlId)
+{
+	UINT16 retVal = OHL_MAX_NUM;
+	if ((ohlId >= 1u) && (ohlId < OHL_MAX_NUM))
+	{
+		retVal = ohlId;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 获取接触网分区当前总数
+* 参数说明： void
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网分区当前总数
+*/
+UINT16 GetOhlCurSum(void)
+{
+	UINT16 retVal = 0u;
+	if (OhlCurSum >= (INT16)OHL_MAX_NUM)
+	{
+		retVal = OHL_MAX_NUM;
+	}
+	else if (OhlCurSum < 0)
+	{
+		retVal = 0u;
+	}
+	else
+	{/*OhlCurSum在[0,OHL_MAX_NUM)区间强转，保证安全*/
+		retVal = (UINT16)OhlCurSum;
+	}
+	return retVal;
+}
+
+
+/*
+* 功能描述：	整理读入的接触网配置数据
+* 参数说明：	无
+* 返回值  ：	CI_SUCCESS,整理成功
+*				CI_ERROR,整理失败
+*/
+UINT8 OhlConfigDataManage(void)
+{
+	UINT16 ii = 0u;      /*游标*/
+	UINT16 jj = 0u;      /*游标*/
+	UINT16 ohlConfigDataSum = 0u;      /*道岔设备配置数据总数*/
+	UINT8 retVal = CI_SUCCESS;
+	UINT8 localCiId = 0u;
+
+	localCiId = GetSystemParaLocalCiId();
+	/*保存道岔ID索引数组*/
+	ohlConfigDataSum = GetOhlCurSum();
+	if (OHL_MAX_NUM <= ohlConfigDataSum)
+	{/*配置数据总数错误*/
+
+		retVal = CI_ERROR;
+	}
+	else
+	{
+		for (ii = 0u; ii < OHL_MAX_NUM; ii++)
+		{
+			if (jj == ohlConfigDataSum)
+			{/*遍历有效数据完毕*/
+
+				break;
+			}
+
+			if ((OhlConfigDataStru[ii].wOhlId >= 1u) && (OhlConfigDataStru[ii].wOhlId < OHL_MAX_NUM))
+			{/*id有效*/
+				if (localCiId == OhlConfigDataStru[ii].chBelongCiId)
+				{
+					LocalCiOhlIdBuf[jj] = OhlConfigDataStru[ii].wOhlId;
+					jj++;
+				}
+				else
+				{
+					/*只处理本控区*/
+				}
+			}
+			
+		}
+	}
+
+
+
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID接触网数据
+* 参数说明：
+* 返回值  ： OHLConfigDataStruct *
+*/
+OHLConfigDataStruct* GetOhlConfigData(void)
+{
+	return OhlConfigDataStru;
+}
+
+/*
+* 功能描述： 获取指定数组下标对应的接触网ID
+* 参数说明： const UINT16 bufIndex, 数组下标
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网ID
+*/
+UINT16 GetOhlId(const UINT16 bufIndex)
+{
+	UINT16 retVal = CI_ERROR;
+	UINT16 ohlCurNum = 0u;			/*接触网当前总数*/
+	ohlCurNum = GetOhlCurSum();
+	if (bufIndex < ohlCurNum)
+	{
+		retVal = LocalCiOhlIdBuf[bufIndex];
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID接触网组数
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网组数
+*/
+UINT8 GetOhlGroupSum(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlConfigDataStru[bufIndex].chRelayGroupNum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID接触网有电继电器ID数组
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 有电继电器ID数组
+*/
+UINT16* GetOhlEnergizedIdBuf(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	UINT16* retVal = NULL;
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取区段数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlConfigDataStru[bufIndex].wEnergizedId;
+	}
+	else
+	{
+
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID接触网断电继电器ID数组
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 断电继电器ID数组
+*/
+UINT16* GetOhlDeEnergizedIdBuf(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	UINT16* retVal = NULL;
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取区段数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlConfigDataStru[bufIndex].wDeEnergizedId;
+	}
+	else
+	{
+
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID接触网所属Oc ID
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属Oc ID
+*/
+UINT16 GetOhlBelongOcId(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	UINT16 retVal = CI_ERROR;
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取区段数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlConfigDataStru[bufIndex].wBelongOcId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID接触网所属联锁ID
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属联锁ID
+*/
+UINT8 GetOhlBelongCiId(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlConfigDataStru[bufIndex].chBelongCiId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}

TSCP/src/APP/ciapp/OHL/OHLConfigDataManage.h

@@ -0,0 +1,123 @@
+/********************************************************
+*
+* 文 件 名： OHLConfigDataConfig.h
+* 版权说明： 北京交控科技有限公司
+* 创建时间： 
+* 作    者： 联锁组
+* 功能描述： 接触网相关配置
+* 函数包括：
+* 使用注意：
+* 修改记录：
+*
+********************************************************/
+
+#ifndef _OHL_CONFIG_DATA_MANAGE_H_
+#define _OHL_CONFIG_DATA_MANAGE_H_
+
+#include "CommonTypes.h"
+#include "OHLDefine.h"
+#include "../System/CiSystemDefine.h"
+#include "../System/SystemParameterManage.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct S_OHLConfigDataStruct
+{
+	UINT16 wOhlId;				/*接触网ID*/
+	UINT16 wBelongOcId;         /*所属OC ID*/
+	UINT8 chBelongCiId;			/*所属CI ID*/
+	UINT8 chRelayGroupNum;		/*接触网继电器组数*/
+	UINT16 wEnergizedId[OHL_GROUP_MAX_NUM];		/*有电继电器ID*/
+	UINT16 wDeEnergizedId[OHL_GROUP_MAX_NUM];	/*断电继电器ID*/
+}OHLConfigDataStruct;
+
+extern OHLConfigDataStruct OhlConfigDataStru[OHL_MAX_NUM];	/*定义接触网数据配置结构体*/
+extern INT16 OhlCurSum;   /*接触网当前总数*/
+extern UINT16 LocalCiOhlIdBuf[OHL_MAX_NUM];                   /*定义本地联锁接触网ID映射数组*/
+
+/*
+* 功能描述： 获取指定ID接触网索引号
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： SWITCH_SUM_MAX: 获取数据失败
+*			<SWITCH_SUM_MAX: 查找成功
+*/
+UINT16 GetOhlConfigBufIndex(const UINT16 ohlId);
+
+/*
+* 功能描述： 获取接触网分区当前总数
+* 参数说明： void
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网分区当前总数
+*/
+UINT16 GetOhlCurSum(void);
+
+/*
+* 功能描述：	整理读入的接触网配置数据
+* 参数说明：	无
+* 返回值  ：	CI_SUCCESS,整理成功
+*				CI_ERROR,整理失败
+*/
+UINT8 OhlConfigDataManage(void);
+
+/*
+* 功能描述： 获取指定ID接触网数据
+* 参数说明：
+* 返回值  ： OHLConfigDataStruct *
+*/
+OHLConfigDataStruct* GetOhlConfigData(void);
+
+/*
+* 功能描述： 获取指定数组下标对应的接触网ID
+* 参数说明： const UINT16 bufIndex, 数组下标
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网ID
+*/
+UINT16 GetOhlId(const UINT16 bufIndex);
+
+/*
+* 功能描述： 获取指定ID接触网组数
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网组数
+*/
+UINT8 GetOhlGroupSum(const UINT16 ohlId);
+
+/*
+* 功能描述： 获取指定ID接触网有电继电器ID数组
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 有电继电器ID数组
+*/
+UINT16* GetOhlEnergizedIdBuf(const UINT16 ohlId);
+
+/*
+* 功能描述： 获取指定ID接触网断电继电器ID数组
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 断电继电器ID数组
+*/
+UINT16* GetOhlDeEnergizedIdBuf(const UINT16 ohlId);
+
+/*
+* 功能描述： 获取指定ID接触网所属Oc ID
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属Oc ID
+*/
+UINT16 GetOhlBelongOcId(const UINT16 ohlId);
+
+/*
+* 功能描述： 获取指定ID接触网所属联锁ID
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 所属联锁ID
+*/
+UINT8 GetOhlBelongCiId(const UINT16 ohlId);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

TSCP/src/APP/ciapp/OHL/OHLDataManage.c

@@ -0,0 +1,187 @@
+/********************************************************
+*
+* 文 件 名： OHLDataManage.c
+* 版权说明： 北京交控科技有限公司
+* 创建时间： 
+* 作    者： 联锁组
+* 功能描述： 接触网相关配置
+* 函数包括：
+* 使用注意：
+* 修改记录：
+*
+********************************************************/
+
+#include "OHLDataManage.h"
+
+OhlDataStruct OhlDataStru[OHL_MAX_NUM];   /*定义接触网数据结构体*/
+
+/*
+* 功能描述： 获取指定ID接触网数据
+* 参数说明：
+* 返回值  ：
+            SwitchDataStruct *
+*/
+OhlDataStruct* GetOhlData(void)
+{
+    return OhlDataStru;
+}
+
+/*
+* 功能描述： 设置指定ID接触网供电状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+*			 const UINT8 powerState, 接触网供电状态
+* 返回值  ： 无
+*
+*/
+void SetOhlPowerState(const UINT16 ohlId, const UINT8 powerState)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+
+		if ((OHL_POWER_ENERGIZED == powerState) || (OHL_POWER_DE_ENERGIZED == powerState)
+			||(OHL_POWER_UNKNOW == powerState))
+		{
+			OhlDataStru[bufIndex].chPowerState = powerState; /*道岔引导总锁状态*/
+		}
+		else
+		{
+			/*不做处理*/
+		}
+	}
+	else
+	{
+		/*不做处理*/
+	}
+}
+
+/*
+* 功能描述： 获取指定ID接触网供电状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网供电状态
+*/
+UINT8 GetOhlPowerState(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlDataStru[bufIndex].chPowerState;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置接触网断电状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+*            const UINT32 cycNum 周期号
+* 返回值  ： 无
+*/
+void SetOhlDeEnerCycNum(const UINT16 ohlId, const UINT32 cycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		OhlDataStru[bufIndex].dwOhlDeEnerCycNum = cycNum;
+	}
+}
+/*
+* 功能描述： 获取接触网断电状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： UINT32 断电状态起始周期
+*/
+UINT32 GetOhlDeEnerCycNum(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlDataStru[bufIndex].dwOhlDeEnerCycNum;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置接触网未知状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+*            const UINT32 cycNum 周期号
+* 返回值  ： 无
+*/
+void SetOhlUnknowCycNum(const UINT16 ohlId, const UINT32 cycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		OhlDataStru[bufIndex].dwOhlUnknowCycNum = cycNum;
+	}
+}
+/*
+* 功能描述： 获取接触网未知状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： UINT32 未知状态起始周期
+*/
+UINT32 GetOhlUnknowCycNum(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlDataStru[bufIndex].dwOhlUnknowCycNum;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置接触网旁路状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+*            const UINT8 bypassFlag 旁路标志
+* 返回值  ： 无
+*/
+void SetOhlBypassFlag(const UINT16 ohlId, const UINT8 bypassFlag)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		if ((OHL_BYPASS_YES == bypassFlag) || (OHL_BYPASS_NO == bypassFlag))
+		{
+			OhlDataStru[bufIndex].chOhlBypassFlag = bypassFlag;
+		}
+		else
+		{/*不处理*/
+		}
+	}
+}
+/*
+* 功能描述： 获取接触网旁路状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： UINT8 接触网旁路状态
+*/
+UINT8 GetOhlBypassFlag(const UINT16 ohlId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetOhlConfigBufIndex(ohlId);  /*获取道岔数组下标*/
+	if (bufIndex < OHL_MAX_NUM)
+	{
+		retVal = OhlDataStru[bufIndex].chOhlBypassFlag;
+	}
+	return retVal;
+}

TSCP/src/APP/ciapp/OHL/OHLDataManage.h

@@ -0,0 +1,113 @@
+/********************************************************
+*
+* 文 件 名： OHLDataManage.h
+* 版权说明： 北京交控科技有限公司
+* 创建时间：
+* 作    者： 联锁组
+* 功能描述： 接触网相关配置
+* 函数包括：
+* 使用注意：
+* 修改记录：
+*
+********************************************************/
+
+#ifndef _OHL_DATA_MANAGE_H_
+#define _OHL_DATA_MANAGE_H_
+
+#include "OHLDefine.h"
+#include "OHLConfigDataManage.h"
+#include "CommonTypes.h"
+#include "../System/CiSystemDefine.h"
+#include "../System/SystemParameterManage.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*道岔数据结构体*/
+typedef struct S_OhlDataStruct
+{
+    UINT16 wOhlId;				/*接触网ID (配置字段)*/
+	UINT8 chPowerState;			/*接触网供电状态*/	
+	UINT32 dwOhlDeEnerCycNum;	/*接触网断电起始周期*/
+	UINT32 dwOhlUnknowCycNum;	/*接触网未知起始周期*/
+	UINT8 chOhlBypassFlag;		/*接触网旁路状态*/
+}OhlDataStruct;
+
+extern OhlDataStruct OhlDataStru[OHL_MAX_NUM];	/*定义道岔数据结构体*/
+
+/*
+* 功能描述： 获取指定ID接触网数据
+* 参数说明：
+* 返回值  ：
+            SwitchDataStruct *
+*/
+OhlDataStruct* GetOhlData(void);
+
+/*
+* 功能描述： 设置指定ID接触网供电状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+*			 const UINT8 powerState, 接触网供电状态
+* 返回值  ： 无
+*
+*/
+void SetOhlPowerState(const UINT16 ohlId, const UINT8 powerState);
+
+/*
+* 功能描述： 获取指定ID接触网供电状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 接触网供电状态
+*/
+UINT8 GetOhlPowerState(const UINT16 ohlId);
+
+/*
+* 功能描述： 设置接触网断电状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+*            const UINT32 cycNum 周期号
+* 返回值  ： 无
+*/
+void SetOhlDeEnerCycNum(const UINT16 ohlId, const UINT32 cycNum);
+
+/*
+* 功能描述： 获取接触网断电状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： UINT32 断电状态起始周期
+*/
+UINT32 GetOhlDeEnerCycNum(const UINT16 ohlId);
+
+/*
+* 功能描述： 设置接触网未知状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+*            const UINT32 cycNum 周期号
+* 返回值  ： 无
+*/
+void SetOhlUnknowCycNum(const UINT16 ohlId, const UINT32 cycNum);
+
+/*
+* 功能描述： 获取接触网未知状态起始周期
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： UINT32 未知状态起始周期
+*/
+UINT32 GetOhlUnknowCycNum(const UINT16 ohlId);
+
+/*
+* 功能描述： 设置接触网旁路状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+*            const UINT8 bypassFlag 旁路标志
+* 返回值  ： 无
+*/
+void SetOhlBypassFlag(const UINT16 ohlId, const UINT8 bypassFlag);
+
+/*
+* 功能描述： 获取接触网旁路状态
+* 参数说明： const UINT16 ohlId, 接触网ID
+* 返回值  ： UINT8 接触网旁路状态
+*/
+UINT8 GetOhlBypassFlag(const UINT16 ohlId);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

TSCP/src/APP/ciapp/OHL/OHLDefine.h

@@ -0,0 +1,29 @@
+/********************************************************
+*
+* 文 件 名： OHLDataConfig.h
+* 版权说明： 北京交控科技有限公司
+* 创建时间： 2014-12-05
+* 作    者： 联锁组
+* 功能描述： 接触网相关常量定义
+* 函数包括：
+* 使用注意：
+* 修改记录：
+*
+********************************************************/
+
+#ifndef _OHL_DATA_CONFIG_H_
+#define _OHL_DATA_CONFIG_H_
+
+#define OHL_MAX_NUM	3		/*接触网分区数最大值(最大支持2个，以ID为索引)*/
+#define OHL_GROUP_MAX_NUM 2	/*一个接触网分区继电器最大组数*/
+
+/*接触网供电状态*/
+#define OHL_POWER_ENERGIZED		((UINT8)0x55)/*接触网有电*/
+#define OHL_POWER_DE_ENERGIZED	((UINT8)0xAA)/*接触网无电*/
+#define OHL_POWER_UNKNOW		((UINT8)0xFF)/*接触网未知*/
+
+/*接触网旁路状态*/
+#define OHL_BYPASS_YES			((UINT8)0xAA)/*接触网旁路*/
+#define OHL_BYPASS_NO			((UINT8)0x55)/*接触网未旁路*/
+
+#endif

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

@@ -2856,3 +2856,241 @@ void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum)
 		/*不处理*/
 	}
 }
+
+/*
+* 功能描述：获取指定ID屏蔽门旁路采集起始周期号
+* 参数说明：const UINT16 doorId  屏蔽门ID
+* 返 回 值：门互锁解除继电器吸起起始周期号
+* Created By fan 2025.12.15
+*/
+UINT32 GetPsdMutualLockCollStartCyc(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].dwPsdMutualLockCollStartCyc;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门旁路采集起始周期号
+* 参数说明：const UINT16 doorId  屏蔽门ID
+*           const UINT32 startCycNum  起始周期号
+* 返 回 值：无
+* Created By fan 2025.12.16
+*/
+void SetPsdMutualLockCollStartCyc(const UINT16 doorId, const UINT32 startCycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		PsdDataStru[bufIndex].dwPsdMutualLockCollStartCyc = startCycNum;
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取指定ID屏蔽门故障按下周期号(误触发)
+* 参数说明：const UINT16 doorId  屏蔽门ID
+* 返 回 值：门互锁解除继电器吸起起始周期号
+* Created By fan 2025.12.22
+*/
+UINT32 GetPsdMutualLockErrCollCyc(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].dwPsdMutualLockErrCollCyc;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门旁路故障按下周期号(误触发)
+* 参数说明：const UINT16 doorId  屏蔽门ID
+*           const UINT32 startCycNum  起始周期号
+* 返 回 值：无
+* Created By fan 2025.12.22
+*/
+void SetPsdMutualLockErrCollCyc(const UINT16 doorId, const UINT32 startCycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		PsdDataStru[bufIndex].dwPsdMutualLockErrCollCyc = startCycNum;
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取指定ID屏蔽门旁路起效周期
+* 参数说明：const UINT16 doorId  屏蔽门ID
+* 返 回 值：门旁路起效起始周期号
+* Created By fan 2025.12.15
+*/
+UINT32 GetPsdMutualLockStartCyc(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		retVal = PsdDataStru[bufIndex].dwPsdMutualLockStartCyc;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 设置指定ID门旁路按钮故障落下状态（OC通信中断导致）
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*			 const UINT8 chErrState,旁路故障状态
+* Created By fan 2025.12.15
+* 返回值  ： 无
+*/
+void SetPsdMutualLockErrDownState(const UINT16 doorId, const UINT8 chErrState)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		if ((PSD_BTN_ERROR_FLAG_YES == chErrState) || (PSD_BTN_ERROR_FLAG_NO == chErrState))
+		{
+			PsdDataStru[bufIndex].cPsdMutualLockBtnErrDownState = chErrState;
+		}
+		else
+		{/*不处理*/
+		}
+	}
+}
+
+/*
+* 功能描述： 获取指定ID旁路按钮故障落下状态（OC通信中断导致）
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： UINT8 旁路故障状态
+* Created By fan 2025.12.15
+*/
+UINT8 GetPsdMutualLockErrDownState(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = PSD_BTN_ERROR_FLAG_YES;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdDataStru[bufIndex].cPsdMutualLockBtnErrDownState;
+	}
+	else
+	{/*不处理*/
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID屏蔽门旁路旁路起效周期
+* 参数说明：const UINT16 doorId  屏蔽门ID
+*           const UINT32 startCycNum  起始周期号
+* 返 回 值：无
+* Created By fan 2025.12.15
+*/
+void SetPsdMutualLockStartCyc(const UINT16 doorId, const UINT32 startCycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+
+	if (bufIndex < PSD_SUM_MAX)
+	{
+		PsdDataStru[bufIndex].dwPsdMutualLockStartCyc = startCycNum;
+	}
+	else
+	{
+		/*不处理*/
+	}
+}
+
+/*
+* 功能描述： 设置指定ID门旁路按钮故障状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*			 const UINT8 chErrState,旁路故障状态
+* Created By fan 2025.12.15
+* 返回值  ： 无
+*/
+void SetPsdMutualLockErrState(const UINT16 doorId, const UINT8 chErrState)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		if ((PSD_BTN_ERROR_FLAG_YES == chErrState) || (PSD_BTN_ERROR_FLAG_NO == chErrState))
+		{
+			PsdDataStru[bufIndex].cPsdMutualLockBtnErrState = chErrState;
+		}
+		else
+		{/*不处理*/
+		}
+	}
+}
+
+/*
+* 功能描述： 获取指定ID旁路按钮故障状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： UINT8 旁路故障状态
+* Created By fan 2025.12.15
+*/
+UINT8 GetPsdMutualLockErrState(const UINT16 doorId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = PSD_BTN_ERROR_FLAG_YES;
+
+	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
+	if (PSD_SUM_MAX > bufIndex)
+	{
+		retVal = PsdDataStru[bufIndex].cPsdMutualLockBtnErrState;
+	}
+	else
+	{/*不处理*/
+	}
+
+	return retVal;
+}

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

@@ -49,8 +49,6 @@ typedef struct S_PsdDataStruct
 
 	UINT16 SrcVobcId;/*操作该屏蔽门的当前VOBC ID*/
 	UINT8 PsdCmd;/*操作屏蔽门的命令*/
-	/*UINT16 ClosedRouteId;*//*因VOBC打开PSD而关闭信号的进路*/
-	/*UINT8 LastDriState;*//*历史驱动状态*/
 	UINT32 CmdSetCycle;/*命令设置周期*/
 	UINT32 CmdSetCyclePsc;/*命令设置周期*/
 	UINT8 PsdRemoraState;  /*屏蔽门障碍物状态*/
@@ -91,6 +89,11 @@ typedef struct S_PsdDataStruct
 	UINT8 psdCloseErrState;		/*关门故障状态*/
 	UINT8 cPsdExceptOpenState;  /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
 	UINT32 dwPsdRelayDownCycNum; /*PSD门关继电器落下起始周期*/
+	UINT32 dwPsdMutualLockCollStartCyc;/*PSD旁路按钮正常按下起始周期*/
+	UINT32 dwPsdMutualLockErrCollCyc;/*PSD旁路按钮误触发按下起始周期*/
+	UINT32 dwPsdMutualLockStartCyc;/*PSD旁路起效周期*/
+	UINT8 cPsdMutualLockBtnErrState;  /*屏蔽门互锁解除按钮故障状态：0x55-未故障，0xAA-故障*/
+	UINT8 cPsdMutualLockBtnErrDownState;  /*屏蔽门旁路按钮故障落下状态：0x55-未故障，0xAA-故障*/
 } PsdDataStruct;
 
 extern PsdDataStruct PsdDataStru[PSD_SUM_MAX];   /*定义屏蔽门数据结构体*/
@@ -1001,6 +1004,89 @@ UINT32 GetPsdRelayDownCycNum(const UINT16 doorId);
 * Created By LQ 2025.06.26
 */
 void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum);
+/*
+* 功能描述：获取指定ID屏蔽门旁路采集起始周期号
+* 参数说明：const UINT16 doorId  屏蔽门ID
+* 返 回 值：门互锁解除继电器吸起起始周期号
+* Created By fan 2025.12.15
+*/
+UINT32 GetPsdMutualLockCollStartCyc(const UINT16 doorId);
+
+/*
+* 功能描述：设置指定ID屏蔽门旁路采集起始周期号
+* 参数说明：const UINT16 doorId  屏蔽门ID
+*           const UINT32 startCycNum  起始周期号
+* 返 回 值：无
+* Created By LQ 2025.06.26
+*/
+void SetPsdMutualLockCollStartCyc(const UINT16 doorId, const UINT32 startCycNum);
+
+/*
+* 功能描述：获取指定ID屏蔽门故障按下周期号(误触发)
+* 参数说明：const UINT16 doorId  屏蔽门ID
+* 返 回 值：门互锁解除继电器吸起起始周期号
+* Created By fan 2025.12.22
+*/
+UINT32 GetPsdMutualLockErrCollCyc(const UINT16 doorId);
+
+/*
+* 功能描述：设置指定ID屏蔽门旁路故障按下周期号(误触发)
+* 参数说明：const UINT16 doorId  屏蔽门ID
+*           const UINT32 startCycNum  起始周期号
+* 返 回 值：无
+* Created By fan 2025.12.22
+*/
+void SetPsdMutualLockErrCollCyc(const UINT16 doorId, const UINT32 startCycNum);
+/*
+* 功能描述：获取指定ID屏蔽门旁路起效周期
+* 参数说明：const UINT16 doorId  屏蔽门ID
+* 返 回 值：门旁路起效起始周期号
+* Created By fan 2025.12.15
+*/
+UINT32 GetPsdMutualLockStartCyc(const UINT16 doorId);
+
+/*
+* 功能描述：设置指定ID屏蔽门旁路旁路起效周期
+* 参数说明：const UINT16 doorId  屏蔽门ID
+*           const UINT32 startCycNum  起始周期号
+* 返 回 值：无
+* Created By fan 2025.12.15
+*/
+void SetPsdMutualLockStartCyc(const UINT16 doorId, const UINT32 startCycNum);
+
+/*
+* 功能描述： 设置指定ID门旁路按钮故障状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*			 const UINT8 chErrState,旁路故障状态
+* Created By fan 2025.12.15
+* 返回值  ： 无
+*/
+void SetPsdMutualLockErrState(const UINT16 doorId, const UINT8 chErrState);
+
+/*
+* 功能描述： 获取指定ID旁路按钮故障状态
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： UINT8 旁路故障状态
+* Created By fan 2025.12.15
+*/
+UINT8 GetPsdMutualLockErrState(const UINT16 doorId);
+
+/*
+* 功能描述： 设置指定ID门旁路按钮故障落下状态（OC通信中断导致）
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+*			 const UINT8 chErrState,旁路故障状态
+* Created By fan 2025.12.15
+* 返回值  ： 无
+*/
+void SetPsdMutualLockErrDownState(const UINT16 doorId, const UINT8 chErrState);
+
+/*
+* 功能描述： 获取指定ID旁路按钮故障落下状态（OC通信中断导致）
+* 参数说明： const UINT16 doorId, 屏蔽门ID
+* 返回值  ： UINT8 旁路故障状态
+* Created By fan 2025.12.15
+*/
+UINT8 GetPsdMutualLockErrDownState(const UINT16 doorId);
 
 #ifdef __cplusplus
 }

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

@@ -207,4 +207,8 @@
 #define HIGH_FOUR_CHAR			((UINT8)0U)		/*高四字节*/
 #define LOW_FOUR_CHAR			((UINT8)1U)		/*低四字节*/
 
+/*自复式屏蔽门按钮故障标志*/
+#define PSD_BTN_ERROR_FLAG_NO         ((UINT8)0x55)    /*自复式屏蔽门按钮故障标志无效*/
+#define PSD_BTN_ERROR_FLAG_YES        ((UINT8)0xaa)    /*自复式屏蔽门按钮故障标志有效*/
+
 #endif

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

@@ -151,6 +151,23 @@
 #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_PROHIBIT_FAO							 ((UINT8)0xac)		   /*禁止FAO列车进入逻辑区段命令*/
+#define ATS_CMD_CANCEL_PROHIBIT_FAO						 ((UINT8)0xad)		   /*取消禁止FAO列车进入逻辑区段命令*/
+#define ATS_CMD_OHL_BYPASS								 ((UINT8)0xae)         /*设置接触网旁路命令*/
+#define ATS_CMD_CANCEL_OHL_BYPASS						 ((UINT8)0xaf)         /*取消接触网旁路命令*/
+
+#define ATS_CMD_ECS_USE_START							 ((UINT8)0xB0U)         /*ECS自动触发启用命令*/
+#define ATS_CMD_ECS_USE_STOP							 ((UINT8)0xB1U)         /*ECS自动触发停用命令*/
+
+#define ATS_CMD_UNLOCK_STARTSTATE_ONE			((UINT8)0xB2)        /*全站解封解锁一次*/
+#define ATS_CMD_UNLOCK_STARTSTATE_TWO			((UINT8)0xB3)        /*全站解封解锁二次*/
+#define ATS_CMD_LOGSECTION_FLOCK_SET		((UINT8)0xB4)        /*逻辑区段封锁*/
+#define ATS_CMD_LOGSECTION_FLOCK_CANCLE			((UINT8)0xB5)        /*逻辑区段解封*/
+
+#define SCX_ATS_CMD_CESB_ACTIVE_YES			((UINT8)0xB6)        /*试车线虚拟CESB激活*/
+#define SCX_ATS_CMD_CESB_ACTIVE_NO			((UINT8)0xB7)        /*试车线虚拟CESB激活*/
+#define SCX_ATS_CMD_CESB_CUT_YES		((UINT8)0xB8)        /*试车线虚拟CESB旁路*/
+#define SCX_ATS_CMD_CESB_CUT_NO			((UINT8)0xB9)        /*试车线虚拟CESB旁路恢复*/
 
 #define ATS_CMD_GET_CTRL_POWER  						 ((UINT8)0x81)		/* 获取联锁控制权*/
 #define ATS_CMD_RELEASE_CTRL_POWER  					 ((UINT8)0x82)		/* 释放联锁控制权*/
@@ -307,6 +324,7 @@
 /* zt 删除单轨相关代码 2022-02-15 */
 #define  CI_BACK_SWT_USING					((UINT8)0x3f)		/*道岔征用中*/
 #define	 CI_BACK_SWT_MOVE_ERR				((UINT8)0x84)		    /*道岔搬动失败*/
+#define  CI_BACK_SWT_WAIT_MOVE				((UINT8)0xAE)		/*等待道岔动作完成后再操作*/
 
 /*继电器故障反馈*/
 #define  CI_BACK_REL_ZHAOCHA_UP            ((UINT8)0x41)        /*照查继电器吸起*/
@@ -429,6 +447,13 @@
 #define CI_BACK_DATA_APP_LEN_ERR 			  ((UINT8)0xf7) 		/* CI与其他子系统数据应用层数据长度无效 */
 #define CI_BACK_DATA_COM_PERIOD               ((UINT8)0xf8)      /* CI与其他子系统数据通信周期错误 */
 #define CI_BACK_DATA_VER_CHECK_FAIL			  ((UINT8)0xfe)      /* CI与其他子系统数据版本号校验失败 */
+
+/*联络线相关反馈*/
+#define CI_BACK_OVERRIDE_SWITCH_FAIL			((UINT8)0xAF)      /* 道岔不在定位，旁路无效 */
+#define CI_BACK_OVERRIDE_CT_OCCUPY				((UINT8)0xB0)      /* CT列车占用，旁路无效 */
+#define CI_BACK_CONNECT_ROUTE_OVERRIME			((UINT8)0xB1)      /* （联络线）进路办理超时 */
+#define CI_BACK_CONNECT_SWITCH_RET_FAIL			((UINT8)0xB2)      /* Point failed to move to normal within 20 seconds of the over switch block being cleared */
+
 /*应答类型*/
 #define RESPONSE_FIRST                         ((UINT8)0xAA)   /*一次确认应答命令*/
 #define RESPONSE_SECOND                        ((UINT8)0xBB)   /*二次确认应答命令*/

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

@@ -18,6 +18,7 @@
 #include "../IO/OutputDataProcess.h"
 #include "EnvelopeManageAPI.h"
 #include "../DataManage/PlatDataManage.h"
+#include "../ECS/ECSDataManage.h"
 
 /*解包使用*/
 CommandDataStruct CiRevCmdDataStru[ATSORXIANDI_TO_CI_CMD_DATA_STRU_SUM_MAX] = {0u}; /*CI操作命令结构体数组*/
@@ -1196,6 +1197,12 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 		/*组通信联锁信息*/
 		PackCiDataToAts(ciToXianDiDataBuffer, &ii);
 
+		/*组接触网信息*/
+		PackOhlDataToAts(ciToXianDiDataBuffer, &ii);
+
+		/*组ECS自动触发状态*/
+		PackECSStateToAts(ciToXianDiDataBuffer, &ii);
+
 		/*预留40字节*/
 		ii += 40u;
 	}
@@ -1902,6 +1909,9 @@ UINT8 FindFirstOrder(UINT8 SecondOrder)
 	 case ATS_CMD_QUXIAO_OC_P_PL_TWO:
 		 reVal = ATS_CMD_QUXIAO_OC_P_PL_ONE; /*取消OC-P旁路一次命令*/
 		 break;
+	 case ATS_CMD_UNLOCK_STARTSTATE_TWO:
+		 reVal = ATS_CMD_UNLOCK_STARTSTATE_ONE; /*迪士尼全站解封解锁*/
+		 break;
 	  default:
 		  reVal = 0u;
 		  break;
@@ -3093,3 +3103,102 @@ void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
 		/*入参检查失败，不处理*/
 	}
 }
+
+/*
+* 功能描述： 组接触网信息到ATS
+* 参数说明：入参
+*			UINT8* ciToXianDiDataBuffer 存放信息的buffer
+*			UINT16* ii 偏移量
+*			出参
+*			无
+* 返回值  ： 无
+*/
+void PackOhlDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
+{
+	UINT16 index = 0u;
+	UINT16 tempIndex = 0u;
+	UINT8 ohlNum = 0u;			/*接触网分区总数*/
+	UINT16 ohlId = 0u;			/*接触网分区ID*/
+	UINT8 ohlPowerState = 0u;	/*接触网状态*/
+	UINT8 ohlBypass = 0u;		/*接触网旁路状态*/
+	UINT8 jj = 0u;
+	UINT8 chLocalCiId = 0u;     /*本地联锁ID*/
+	UINT8 devBlongCiId = 0u;    /*设备所属联锁ID*/
+	UINT8 localOhlNum = 0u;		
+
+	if ((NULL != ciToXianDiDataBuffer) && (NULL != ii))
+	{
+		index = *ii;
+
+		chLocalCiId = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
+		ohlNum = (UINT8)GetOhlCurSum();
+		if ((0u < ohlNum) && (OHL_MAX_NUM > ohlNum))
+		{
+			tempIndex = index;	/*接触网数量*/
+			index = index + 1u;
+
+			for (jj = 0u; jj < ohlNum; jj++)
+			{
+				ohlId = GetOhlId(jj);	/*接触网ID*/
+				devBlongCiId = GetOhlBelongCiId(ohlId); /*获取设备所属联锁ID*/
+				if ((0u != ohlId) && (0u != chLocalCiId) && (chLocalCiId == devBlongCiId))
+				{
+					ShortToChar(ohlId, &ciToXianDiDataBuffer[index]);	/*接触网 id*/
+					index += 2u;
+
+					ohlPowerState = GetOhlPowerState(ohlId);	/*接触网状态*/
+					ciToXianDiDataBuffer[index++] = ohlPowerState;
+
+					ohlBypass = GetOhlBypassFlag(ohlId);		/*接触网旁路状态*/
+					ciToXianDiDataBuffer[index++] = ohlBypass;
+
+					localOhlNum++;
+				}
+				else
+				{
+					/*不处理*/
+				}
+			}
+
+			ciToXianDiDataBuffer[tempIndex] = localOhlNum;/*接触网数量*/
+		}
+		else
+		{
+			/*不处理*/
+		}
+
+		*ii = index;
+	}
+	else
+	{
+		/*入参检查失败，不处理*/
+	}
+}
+
+/*
+* 功能描述：组ECS自动触发状态到ATS
+* 参数说明：UINT8* ciToXianDiDataBuffer 存放信息的buffer（出参）
+*			UINT16* ii 偏移量（出参）
+* 返 回 值：无
+* Created By LQ 2026.01.23
+*/
+void PackECSStateToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
+{
+	UINT16 index = 0U;
+	UINT8 cEcsState = 0U;
+
+	if ((NULL != ciToXianDiDataBuffer) && (NULL != ii))
+	{
+		index = *ii;
+		cEcsState = GetEcsAutoTrigState(1U);   /*DSN当前仅一个控区、一个ECS，默认使用ID为1的ECS*/
+
+		ciToXianDiDataBuffer[index] = cEcsState;  /*组ECS自动触发状态*/
+		index++;
+
+		*ii = index;
+	}
+	else
+	{
+		/*入参检查失败，不处理*/
+	}
+}

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

@@ -408,6 +408,26 @@ UINT8 GetOcPscConfirmFlag(UINT8 index);
 */
 void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
 
+/*
+* 功能描述： 组接触网信息到ATS
+* 参数说明：入参
+*			UINT8* ciToXianDiDataBuffer 存放信息的buffer
+*			UINT16* ii 偏移量
+*			出参
+*			无
+* 返回值  ： 无
+*/
+void PackOhlDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
+
+/*
+* 功能描述：组ECS自动触发状态到ATS
+* 参数说明：UINT8* ciToXianDiDataBuffer 存放信息的buffer（出参）
+*			UINT16* ii 偏移量（出参）
+* 返 回 值：无
+* Created By LQ 2026.01.23
+*/
+void PackECSStateToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -16,6 +16,7 @@
 #include "dsuRsspFunc.h"
 #include "protclStruct.h"
 #include "../QueryFiles/dquCIInterFace.h"
+#include "AxisAssertDataPrepare.h"
 
 #define PHY_SEC_RESET_CMD (0x0DU) /*直接复位命令码*/
 #define PHY_SEC_PRE_RESET_CMD (0x0EU) /*预复位命令码*/
@@ -26,6 +27,7 @@
 
 AxisToCiDataStruct axisToCiDataStru[AXIS_TO_CI_SUM_MAX] = {0u};	/*Axis到CI数据帧结构体*/
 static DSU_RSSP_INFO_STRU_WL dsuRsspInfo = { 0 }; /*RSSPI查询数据信息*/
+AxisSecClassDataStruct gAxisSecClassData = { 0U }; /*计轴区段分类数据*/
 
 static UINT8 GalHeadCheck(const UINT32 localEtcsId, const UINT32 remoteEtcsId, const UINT16 devInterfaceType, const UINT8 prtrlVer, const UINT32 dataVer, HLHTGALInfoStruct* pMICommonPackage, UINT32* pErrorCode);
 static UINT8 GetRsspiAddr(const UINT16 locTypeId, const UINT16 oppTypeId, UINT16* locRsspiAddr, UINT16* oppRsspiAddr);
@@ -1305,3 +1307,230 @@ UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8*
 
 	return ret;
 }
+
+/*
+* 功能描述： 初始化计轴区段分类数据
+* 参数说明：
+* 返回值  ： CI_ERROR: 初始化失败
+*			 CI_SUCCESS: 初始化成功
+* by cgh 20260316
+*/
+UINT8 InitAxisSecClassData(void)
+{
+	UINT8 chReval = CI_ERROR;
+	UINT8 chDeviceSum =0U; /*获取通信Axis设备总数*/
+	UINT8* szDeviceIdBuf = NULL; /*获取通信Axis设备ID数组*/
+	AxisToCiDataStruct* CollAxisDataStru = NULL; /*计轴通信采集数据*/
+	UINT16 wPhySecId = 0U; /*物理区段ID*/
+	UINT8 chPhySecRelAcNum = 0U;  /*物理区段关联的计轴区段数目*/
+	UINT16* szPhySecRelAcId = NULL;  /*物理区段关联计轴区段ID数组*/
+	UINT16 ii = 0U; /*物理区段ID下标*/
+	UINT8 chAxisSecIndex = 0U; /*计轴区段索引*/
+	UINT8 chAxisSecCbtcProperty = 0U; /*计轴区段CBTC属性*/
+	UINT8 chAdjacentSecTypeCheck = 0U; /*相邻区段类型检查*/
+
+	chDeviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备总数*/
+	szDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备ID数组*/
+	CollAxisDataStru = GetCollAxisDataStruct();; /*计轴通信采集数据*/
+
+	/*目前只初始化RC和一个计轴系统通信的场景*/
+	if (1U == chDeviceSum)
+	{
+		/*数据防空*/
+		if ((NULL != szDeviceIdBuf) && (NULL != CollAxisDataStru))
+		{
+			chReval = CI_SUCCESS;
+			/*遍历计轴管辖的区段*/
+			for (ii = 0U; ii < (UINT16)(CollAxisDataStru[szDeviceIdBuf[0]].SectionSum); ii++)
+			{
+				wPhySecId = CollAxisDataStru[szDeviceIdBuf[0]].axisDataStr[ii].PhySecId;
+				chPhySecRelAcNum = GetPAxisSectionSum(wPhySecId);
+				szPhySecRelAcId = GetPAxisSectionIdBuf(wPhySecId);
+
+				/*数组防空*/
+				if (NULL != szPhySecRelAcId)
+				{
+					/*遍历当前物理区段关联的计轴区段*/
+					for (chAxisSecIndex = 0U; chAxisSecIndex < chPhySecRelAcNum; chAxisSecIndex++)
+					{
+						/* 第一步，添加集合A数据：计轴管辖的所有计轴区段数据*/
+						if (gAxisSecClassData.chElementANum < CI_INCLUDE_AXIS_MAX_SUM)
+						{
+							gAxisSecClassData.szElementASecId[gAxisSecClassData.chElementANum] = szPhySecRelAcId[chAxisSecIndex];
+							gAxisSecClassData.chElementANum++;
+
+							chAxisSecCbtcProperty = GetAxisSecCbtcProperty(szPhySecRelAcId[chAxisSecIndex]);
+
+							/*第二步，添加集合B数据：计轴管辖的所有具备CBTC属性的计轴区段数据*/
+							if (AXIS_SEC_CBTC_PROPERTY_YES == chAxisSecCbtcProperty)
+							{
+								gAxisSecClassData.szElementBSecId[gAxisSecClassData.chElementBNum] = szPhySecRelAcId[chAxisSecIndex];
+								gAxisSecClassData.chElementBNum++;
+
+								chAdjacentSecTypeCheck = AxisAdjacentSecTypeCheck(szPhySecRelAcId[chAxisSecIndex]);
+
+								/*第三步，添加集合C数据：计轴管辖的所有具备CBTC属性中不为联络线及非CBTC属性区段相邻区段的计轴区段数据*/
+								if (CI_SUCCESS == chAdjacentSecTypeCheck)
+								{
+									gAxisSecClassData.szElementCSecId[gAxisSecClassData.chElementCNum] = szPhySecRelAcId[chAxisSecIndex];
+									gAxisSecClassData.chElementCNum++;
+								}
+								else
+								{
+									/*不添加*/
+									;
+								}
+
+							}
+							else
+							{
+								/*不添加*/
+								;
+							}
+
+						}
+						else
+						{
+							/*初始化失败*/
+							chReval = CI_ERROR;
+							break;
+						}
+					}
+				}
+				else
+				{
+					chReval = CI_ERROR;
+				}
+
+				if (CI_ERROR == chReval)
+				{
+					break;
+				}
+				else
+				{
+					; /*继续检查*/
+				}
+			}
+		}
+		else
+		{
+			; /*数据获取失败*/
+		}
+
+		debug_infor_printf((const)"\ngAxisSecClassData.chElementANum : %d\n", gAxisSecClassData.chElementANum);
+		for (ii = 0U; ii < gAxisSecClassData.chElementANum; ii++)
+		{
+			debug_infor_printf((const)"%d/", gAxisSecClassData.szElementASecId[ii]);
+		}
+
+		debug_infor_printf((const)"\ngAxisSecClassData.chElementBNum : %d\n", gAxisSecClassData.chElementBNum);
+		for (ii = 0U; ii < gAxisSecClassData.chElementBNum; ii++)
+		{
+			debug_infor_printf((const)"%d/", gAxisSecClassData.szElementBSecId[ii]);
+		}
+
+		debug_infor_printf((const)"\ngAxisSecClassData.chElementCNum : %d\n", gAxisSecClassData.chElementCNum);
+		for (ii = 0U; ii < gAxisSecClassData.chElementCNum; ii++)
+		{
+			debug_infor_printf((const)"%d/", gAxisSecClassData.szElementCSecId[ii]);
+		}
+
+	}
+	else
+	{
+		chReval = CI_SUCCESS;
+	}
+
+	return chReval;
+}
+
+/**
+* 函数功能：计轴区段相邻计轴区段类型检查
+* 输入参数：UINT16 wAxisSecId 计轴区段ID
+* 返回值：CI_SUCCESS 1 成功
+*         CI_ERROR 0 失败
+* by cgh 20260309
+*/
+UINT8 AxisAdjacentSecTypeCheck(UINT16 wAxisSecId)
+{
+	UINT8 chReval = CI_ERROR;
+	UINT8 chAcSameCnt = 0U; /*计轴前方计轴区段数目*/
+	UINT16 szAcSameID[AC_MAXCNT_IN_SWITCH] = { 0U }; /*计轴前方计轴区段数组*/
+	UINT8 chAcConvertCnt = 0U; /*计轴后方计轴区段数目*/
+	UINT16 szAcConvertID[AC_MAXCNT_IN_SWITCH] = { 0U }; /*计轴后方计轴区段数组*/
+	UINT8 chAcIndex = 0U; /*计轴区段索引*/
+	UINT8 chLinkLine = 0U; /*计轴区段联络线属性*/
+	UINT8 chAxisSecCbtcProperty = 0U; /*计轴区段CBTC属性*/
+
+	if ((0U < wAxisSecId) && (AXIS_SECTION_SUM_MAX > wAxisSecId))
+	{
+		/* 查询前方计轴*/
+		chAcSameCnt = aam_PrepareAdjacentAC(wAxisSecId, EMAP_SAME_DIR, szAcSameID);
+
+		/** 查询后方计轴 */
+		chAcConvertCnt = aam_PrepareAdjacentAC(wAxisSecId, EMAP_CONVER_DIR, szAcConvertID);
+
+		if ((UINT8_MAX == chAcSameCnt) || (UINT8_MAX == chAcConvertCnt))
+		{
+			chReval = CI_ERROR; 
+		}
+		else
+		{
+			chReval = CI_SUCCESS;
+			/*遍历同向相邻计轴区段*/
+			for (chAcIndex = 0U; chAcIndex < chAcSameCnt; chAcIndex++)
+			{
+				chLinkLine = aam_PrepareACIsLinkingAxle(szAcSameID[chAcIndex]);
+				chAxisSecCbtcProperty = GetAxisSecCbtcProperty(szAcSameID[chAcIndex]);
+
+				/*相邻区段具备联络线属性或非CBTC属性*/
+				if ((CI_SUCCESS == chLinkLine) || (AXIS_SEC_CBTC_PROPERTY_NO == chAxisSecCbtcProperty))
+				{
+					chReval = CI_ERROR;
+					break;
+				}
+				else
+				{
+					; /*相邻计轴区段不是联络线或具备CBTC属性,继续检查*/
+				}
+			}
+
+			if(CI_SUCCESS == chReval)
+			{
+				for (chAcIndex = 0U; chAcIndex < chAcConvertCnt; chAcIndex++)
+				{
+					chLinkLine = aam_PrepareACIsLinkingAxle(szAcConvertID[chAcIndex]);
+					chAxisSecCbtcProperty = GetAxisSecCbtcProperty(szAcConvertID[chAcIndex]);
+
+					/*相邻区段具备联络线属性或非CBTC属性*/
+					if ((CI_SUCCESS == chLinkLine) || (AXIS_SEC_CBTC_PROPERTY_NO == chAxisSecCbtcProperty))
+					{
+						chReval = CI_ERROR;
+						break;
+					}
+					else
+					{
+						; /*相邻计轴区段不是联络线或具备CBTC属性,继续检查*/
+					}
+
+				}
+			}
+		}
+	}
+	else
+	{
+		;
+	}
+	return chReval;
+}
+
+/*
+* 功能描述： 获取计轴区段分类数据
+* 参数说明：无
+* 返回值  ：计轴区段分类数据
+* by cgh 20260316
+*/
+AxisSecClassDataStruct GetAxisSecClassData(void)
+{
+	return gAxisSecClassData;
+}

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

@@ -70,8 +70,20 @@ typedef struct S_AxisToCiDataStruct
 	AxisCollDataStruct  axisDataStr[CI_INCLUDE_AXIS_MAX_SUM];  	   /*计轴区段信息结构体数组*/
 }AxisToCiDataStruct;
 
+/*计轴区段分类数据结构体*/
+typedef struct S_AxisSecClassDataStruct
+{
+	UINT8	chElementANum;				/*元素A数量*/
+	UINT16	szElementASecId[CI_INCLUDE_AXIS_MAX_SUM];		/*元素A数据*/
+	UINT8	chElementBNum;				/*元素B数量*/
+	UINT16	szElementBSecId[CI_INCLUDE_AXIS_MAX_SUM];		/*元素B数据*/
+	UINT8	chElementCNum;				/*元素C数量*/
+	UINT16	szElementCSecId[CI_INCLUDE_AXIS_MAX_SUM];		/*元素C数据*/
+} AxisSecClassDataStruct;
+
 
 extern AxisToCiDataStruct axisToCiDataStru[AXIS_TO_CI_SUM_MAX];	/*Axis到CI数据帧结构体*/
+extern AxisSecClassDataStruct gAxisSecClassData;
 
 
 #ifdef __cplusplus
@@ -140,6 +152,31 @@ UINT8 InitAxleToCiDataStru(void);
 */
 UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8* pAxleDataStrIdx);
 
+/*
+* 功能描述： 初始化计轴区段分类数据
+* 参数说明：
+* 返回值  ： CI_ERROR: 初始化失败
+*			 CI_SUCCESS: 初始化成功
+* by cgh 20260316
+*/
+UINT8 InitAxisSecClassData(void);
+
+/**
+* 函数功能：计轴区段相邻计轴区段类型检查
+* 输入参数：UINT16 wAxisSecId 计轴区段ID
+* 返回值：CI_SUCCESS 1 成功
+*         CI_ERROR 0 失败
+* by cgh 20260309
+*/
+UINT8 AxisAdjacentSecTypeCheck(UINT16 wAxisSecId);
+
+/*
+* 功能描述： 获取计轴区段分类数据
+* 参数说明：无
+* 返回值  ：计轴区段分类数据
+* by cgh 20260316
+*/
+AxisSecClassDataStruct GetAxisSecClassData(void);
 
 #ifdef __cplusplus
 }

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

@@ -1079,9 +1079,9 @@ UINT8 CheckCi2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength,UINT
 		else
 		{
 			wNeedCheckSwStaRouteSum = ShortFromChar(&dataBuf[wNeedCheckSwStaRouteIndex]);/*离去区段数量*/
-			wNeedCheckSwStaRouteIndex += 2U;/*检查道岔进路数量*/
+			wNeedCheckSwStaRouteIndex += 2U;/*离去区段数量*/
 
-			wNeedCheckSwStaRouteIndex += wNeedCheckSwStaRouteSum * 8U;  /*检查道岔进路数量数据*/
+			wNeedCheckSwStaRouteIndex += wNeedCheckSwStaRouteSum * 3U;  /*离去区段数据ID*/
 		}
 	}
 
@@ -1146,7 +1146,7 @@ UINT8 CheckCi2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength,UINT
 			2u + (spksNum * CICI_ONE_SPKS_LEN) + 2u + (virtualRelayNum * CICI_ONE_VIRTUAL_RELAY_LEN) +
 			2u + (floodGateNum * CICI_ONE_FLOODGATE_LEN)+ 2u + (overlapNum * CICI_ONE_OVERLAP_LEN) + 2u + (autoRouteNum * CICI_ONE_AUTOROUTE_LEN)+ 
 			2u + (logsecLockStateNum * CICI_ONE_LOGSEC_LOCKSTATE_LEN) + logsecLockStateNum + (trainNum * 2U) + 2u + (wCfpInfoLen)+1U + cAreaSnowNum * 3U + 
-			1U + cAreaIteCutNum * 2U + 2U + cLeaveLogNum * 3U + 2U + wNeedCheckSwStaRouteSum * 8U + 2U + wNeedCheckProSwStaOlpNum * 3U + 2U + wProSwInfoLen;
+			1U + cAreaIteCutNum * 2U + 2U + cLeaveLogNum * 3U + 2U + wNeedCheckSwStaRouteSum * 3U + 2U + wNeedCheckProSwStaOlpNum * 3U + 2U + wProSwInfoLen;
 		if (stationLen == tmpStationLen)
 		{
 			reVal = CI_SUCCESS;
@@ -1291,7 +1291,7 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 	UINT8 kk = 0u;
 	UINT8 execRet = CI_ERROR;
 	UINT8 reVal = CI_ERROR;
-	UINT8 chErrorType = 0U;
+	
 	UINT16 routePhySecSum = 0u;
 	RoutePhysicalSectionStruct* routePSSecStru = NULL;
 	UINT16 preSecId = 0u;
@@ -2942,36 +2942,30 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 		ii += 2U;
 		for (jj = 0u; jj < deviceSum; jj++)
 		{
-			routeId = ShortFromChar(&dataBuf[ii]);
+			deviceId = ShortFromChar(&dataBuf[ii]);	
-			belongCiId = GetRouteBelongCiId(routeId);
+			belongCiId = GetRouteBelongCiId(deviceId);
 			if (belongCiId == localCiId)
 			{
 				ii += 2U;
-				chRouteState = GetRouteState(routeId);
+				chRouteState = GetRouteState(deviceId);
-				chRouteStateFlag = GetRouteStateFlag(routeId);
+				chRouteStateFlag = GetRouteStateFlag(deviceId);
 
 				if ((ROUTE_STATE_XUANPAI == chRouteState)
 					|| (((ROUTE_STATE_AUTO_UNLOCK == chRouteState) || (ROUTE_STATE_AUTO_UNLOCKERR == chRouteState)) && (ROUTE_STATE_FLAG_YES == chRouteStateFlag))
 					|| (ROUTE_STATE_LEAD_XUANPAI == chRouteState))
 				{
 					/*通信异步，只有进路所在联锁进路状态满足才根据相邻控区状态设置，防止本联锁已设置默认，相邻联锁异步传输了成功或者失败将默认误修改*/
-					SetRouteApplySwitchCheckFlag(routeId, dataBuf[ii++]);
+					SetRouteApplySwitchCheckFlag(deviceId, dataBuf[ii++]);
-					deviceId = ShortFromChar(&dataBuf[ii]);
-					ii += 2U;
-					deviceFlag = dataBuf[ii++];/*类型*/
-					deviceInfo = dataBuf[ii++];/*状态*/
-					chErrorType = dataBuf[ii++];/*错误码*/
-					SetRouteApplySwitchCheckErrorData(routeId, deviceId, deviceFlag, deviceInfo, chErrorType);
 				}
 				else
 				{
-					ii+=6U;
+					ii++;
 				}
 				
 			}
 			else
 			{
-				ii += 8U;/*跳过不属于本联锁的进路，继续解析*/
+				ii += 3U;/*跳过不属于本联锁的进路，继续解析*/
 			}
 		}
 	}
@@ -3889,9 +3883,6 @@ void PackCiToCiDataFrameUseCfg(UINT8 dstCiId,UINT8* dataFrame, UINT16* dataLengt
 	UINT16 wCiSendAreaIteCutIndex = 0U;
 	ToCiAreaIteCutStruct* pCiSendAreaIteCut = NULL;
 	UINT8 cCiSendAreaIteCutNum = 0U;  /*本联锁发送给相邻联锁的区间ITE切除数量*/
-	UINT8 devType = 0U; /*设备类型*/
-	UINT8 devState = 0U; /*设备状态*/
-	UINT8 chErrorType = 0U;/*失败类型*/
 
 	localCi = GetSystemParaLocalCiId();
 	startLockFlag = GetStartLockFlag();
@@ -4771,19 +4762,12 @@ void PackCiToCiDataFrameUseCfg(UINT8 dstCiId,UINT8* dataFrame, UINT16* dataLengt
 		for (jj = 0u; jj < pTmpCiTransInfo->wNeedCheckSwitchStateRouteSum; jj++)
 		{
 			chRouteApplySwitchCheckFlag = GetRouteApplySwitchCheckFlag(pTmpCiTransInfo->szNeedCheckSwStateRouteBuf[jj]);
-			deviceId = GetRouteApplySwitchCheckErrorData(pTmpCiTransInfo->szNeedCheckSwStateRouteBuf[jj], &devType, &devState, &chErrorType);
 			if ((ROUTE_APPLY_SWITCH_CHECK_NO == chRouteApplySwitchCheckFlag) || (ROUTE_APPLY_SWITCH_CHECK_YES == chRouteApplySwitchCheckFlag))
 			{
 				;/*进路办理道岔检查标志是成功或者失败需要反馈给进路所在联锁*/
 				ShortToChar(pTmpCiTransInfo->szNeedCheckSwStateRouteBuf[jj], &dataFrame[ii]);/*进路ID 2B*/
 				ii += 2U;
 				dataFrame[ii++] = chRouteApplySwitchCheckFlag;
-				/*增加检查失败设备ID(2) 设备类型(1) 设备状态(1) 错误类型(1)*/
-				ShortToChar(deviceId, &dataFrame[ii]);/*设备ID 2B*/
-				ii += 2U;
-				dataFrame[ii++] = devType;
-				dataFrame[ii++] = devState;
-				dataFrame[ii++] = chErrorType;
 				deviceSum++;
 			}
 			else
@@ -9094,7 +9078,7 @@ static UINT16 PackCiToCiDataFrameEa(UINT8 dstCiId, UINT8* dataFrame)
 
 			/* 类型 */
 			chPaType = GetPaTypeByIndex(chEaIndex);
-			if ((PA_TYPE_DA != chPaType) && (PA_TYPE_EA != chPaType))
+			if ((PA_TYPE_DA_TG != chPaType) && (PA_TYPE_DA_TSM != chPaType) && (PA_TYPE_DA_WZX != chPaType) && (PA_TYPE_EA != chPaType))
 			{
 				chPackFlag = CI_ERROR;
 			}
@@ -9195,7 +9179,7 @@ static UINT16 PackCiToCiDataFrameEa(UINT8 dstCiId, UINT8* dataFrame)
 
 			/* 类型 */
 			chPaType = GetPaTypeByIndex(chEaIndex);
-			if ((PA_TYPE_DA != chPaType) && (PA_TYPE_EA != chPaType))
+			if ((PA_TYPE_DA_TG != chPaType) && (PA_TYPE_DA_TSM != chPaType) && (PA_TYPE_DA_WZX != chPaType) && (PA_TYPE_EA != chPaType))
 			{
 				chPackFlag = CI_ERROR;
 			}
@@ -10517,16 +10501,6 @@ UINT8 CheckCiToCiPhySecData(const UINT8* dataBuf, UINT16* index)
 						{
 							/*物理区段封锁类型*/
 							chPhySecFLockType = dataBuf[ii++];
-							if ((PHY_SEC_FLOCK_TYPE_NONE == chPhySecFLockType) || (PHY_SEC_FLOCK_TYPE_SPKSCMD == chPhySecFLockType)
-								|| (PHY_SEC_FLOCK_TYPE_SPKS == chPhySecFLockType) || (PHY_SEC_FLOCK_TYPE_CMD == chPhySecFLockType))
-							{
-								retVal = CI_SUCCESS; /*继续解析*/
-							}
-							else
-							{
-								retVal = CI_ERROR;
-								debug_infor_printf((const)"CheckCiToCiPhySecData wPhySecId %d Is Error: chPhySecFLockType Is %d\n", wPhySecId, chPhySecFLockType);
-							}
 						}
 						if (CI_SUCCESS == retVal)
 						{
@@ -13418,7 +13392,7 @@ UINT8 CheckCiToCiEaData(const UINT8* dataBuf, UINT16* index)
 				{
 					strEaTmp.chPaType = dataBuf[ii];
 					ii++;
-					if ((PA_TYPE_EA == strEaTmp.chPaType) || (PA_TYPE_DA == strEaTmp.chPaType))
+					if ((PA_TYPE_EA == strEaTmp.chPaType) || (PA_TYPE_DA_TG == strEaTmp.chPaType) || (PA_TYPE_DA_TSM == strEaTmp.chPaType) || (PA_TYPE_DA_WZX == strEaTmp.chPaType))
 					{
 						/*继续校验*/
 					}
@@ -15670,10 +15644,6 @@ UINT8 CheckCiToCiNeedCheckSwRouteData(const UINT8* dataBuf, UINT16* index)
 	UINT16 wNeedCheckRouteSum = 0U;  /*需要检查进路数目*/
 	UINT32 wNeedCheckRouteId = 0U;  /*需要检查进路ID*/
 	UINT8 chRouteApplySwitchCheckFlag = 0U;/*进路办理道岔检查标志*/
-	UINT16 wErrorDevID = 0U;
-	UINT8 chErrorDevType = 0U;
-	UINT8 chErrorDevState = 0U;
-	UINT8 chErrorCodeType = 0U;
 
 	if ((NULL != dataBuf) && (NULL != index))
 	{
@@ -15696,99 +15666,12 @@ UINT8 CheckCiToCiNeedCheckSwRouteData(const UINT8* dataBuf, UINT16* index)
 					ii++;
 					if ((ROUTE_APPLY_SWITCH_CHECK_NO == chRouteApplySwitchCheckFlag) || (ROUTE_APPLY_SWITCH_CHECK_YES == chRouteApplySwitchCheckFlag))
 					{
-						/*设备ID 2  设备类型1 设备状态1 错误类型1*/
+						;
-						wErrorDevID = ShortFromChar(&dataBuf[ii]);
-						ii += 2U;
-						chErrorDevType = dataBuf[ii++];
-						chErrorDevState = dataBuf[ii++];
-						chErrorCodeType = dataBuf[ii++];
-						if (0U == wErrorDevID)
-						{
-							;/*跳过类型、状态和错误类型检查*/
-						}
-						else
-						{
-							switch (chErrorDevType)
-							{
-							case CI_DEVICE_TYPE_SWITCH:
-								if (SWITCH_SUM_MAX > wErrorDevID)
-								{
-									if ((ETYPE_SWT_POSTION_STATE == chErrorCodeType)
-										|| (ETYPE_SWT_YLOCK_STATE == chErrorCodeType)
-										|| (ETYPE_SWT_LOCK_STATUS == chErrorCodeType))
-									{
-										;/*通过*/
-									}
-									else
-									{
-										retVal = CI_ERROR;
-										debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: Switchid: chErrorCodeType Is %d\n", chErrorCodeType);
-									}
-								}
-								else
-								{
-									debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: Switchid: wErrorDevID Is %d\n", wErrorDevID);
-									retVal = CI_ERROR;
-								}
-								break;
-							case CI_DEVICE_TYPE_ROUTE:
-								if ((wNeedCheckRouteId != wErrorDevID) || (ETYPE_ROUTE_APPLY_SWITCH_MOVE != chErrorCodeType))
-								{
-									retVal = CI_ERROR;/*错误类型*/
-									debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: Route: wErrorDevID Is %d\n", wErrorDevID);
-								}
-								break;
-							case CI_DEVICE_TYPE_LOGICSEC:
-								if (LOGIC_SECTION_SUM_MAX > wErrorDevID)
-								{
-									if (ETYPE_LOGSEC_LOCK_STATE == chErrorCodeType)
-									{
-										;/*通过*/
-									}
-									else
-									{
-										debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: Logsec: chErrorDevState Is %d\n", chErrorCodeType);
-										retVal = CI_ERROR;
-									}
-								}
-								else
-								{
-									retVal = CI_ERROR;
-									debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: LogSec: wErrorDevID Is %d\n", wErrorDevID);
-								}
-								break;
-							case CI_DEVICE_TYPE_PHYSEC:
-								if (PHYSICAL_SECTION_SUM_MAX > wErrorDevID)
-								{
-									if ((ETYPE_PS_LOCK_STATE == chErrorCodeType) 
-										||(ETYPE_PS_JUMP_LOCK == chErrorCodeType) 
-										||(ETYPE_PS_MERGY_OCU_STATE == chErrorCodeType)
-										||(ETYPE_PS_FLOCK_STATE == chErrorCodeType))
-									{
-										;/*通过*/
-									}
-									else
-									{
-										debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: PhySec: chErrorCodeType Is %d\n", chErrorCodeType);
-										retVal = CI_ERROR;
-									}
-								}
-								else
-								{
-									retVal = CI_ERROR;
-									debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: PhySec: wErrorDevID Is %d\n", wErrorDevID);
-								}
-								break;
-							default:
-								debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: chErrorDevType Is %d\n", chErrorDevType);
-								retVal = CI_ERROR;/*错误类型*/
-							}
-						}
 					}
 					else
 					{
 						/*返回失败*/
-						debug_infor_printf((const)"CheckCiToCiNeedCheckSwRouteData Is Error: chRouteApplySwitchCheckFlag Is %d\n", chRouteApplySwitchCheckFlag);
+						debug_infor_printf((const)"CheckCiToCiLeaveLogSecData Is Error: chRouteApplySwitchCheckFlag Is %d\n", chRouteApplySwitchCheckFlag);
 						retVal = CI_ERROR;
 					}
 				}

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

@@ -100,7 +100,7 @@
 #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_VERSION					((UINT16)28) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.06.19*/
 #define CICI_BEGIN_TO_STATION_LEN		((UINT16)16) /*从开始到站场长度止  cgh增加4个字节CI-CI校验信息*/
 #define CICI_ONE_SWITCH_LEN				((UINT16)13) /*一个道岔数据长度*/
 #define CICI_ONE_PHYSEC_LEN				((UINT16)23U)/*一个物理区段数据长度*/

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

@@ -26,12 +26,12 @@
 #include "../DataManage/PlatDataManage.h"
 #include "dquCIInterFace.h"
 #include "NonAutoReturnDataManage.h"
+#include "../ConnectOverride/ConnectOverrideDataMg.h"
 
 #include "2oo2InterfaceDataManage.h"
 
 PlatHeartDataStruct RecvHeartDataStru = { 0U };  /*平台心跳帧数据结构*/
 PlatGPIODataStruct RecvPlatDataStruGPIO = { 0U };/*平台0x2D帧数据结构 GPIO采集状态*/
-PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍记录数据*/
 
 /*
 * 功能描述： 信号机相关码位处理
@@ -273,25 +273,22 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 		}
 		break;
 	case MASK_TYPE_SIGNAL_LIGHTSTATE:/*信号机亮灭状态码位*/
-		if ((SIGNAL_SHOWCOLOUR_REDCLOSE == GetSignalCurColor(DeviceId))
+		tmpRtState = GetSignalLightExtinctState(DeviceId);
-			|| (SIGNAL_SHOWCOLOUR_GREENCLOSE == GetSignalCurColor(DeviceId))
+		if (SIGNAL_LIGHT_EXTICT_STATE_NO == tmpRtState)
-			|| (SIGNAL_SHOWCOLOUR_YELLOWCLOSE == GetSignalCurColor(DeviceId))
-			|| (SIGNAL_SHOWCOLOUR_GREENYELLOWCLOSE == GetSignalCurColor(DeviceId))
-			)
 		{
-			SetMaskValue(MaskId, dataBuf);
+			SetMaskValue(MaskId, dataBuf);/*灭灯1*/
 		}
 		else
 		{
-
 		}
 		break;
 	case MASK_TYPE_SIGNAL_BREAK:/*信号机断丝码位*/
-		if ((CI_PATTERN_FULL_ELECTRONIC == CiPattern) && (FUNC_SWITCH_OFF == chDsnLinSwitch))/*全电子联锁*/
+		if (CI_PATTERN_FULL_ELECTRONIC == CiPattern)/*全电子联锁*/
+		{
+			if (FUNC_SWITCH_ON == chDsnLinSwitch) /* DSN */
 			{
-			getState = GetSignalCurColor(DeviceId); /*OC通信中断未设置断丝标志但信号机颜色为红断*/
 				chDsFlag = GetSignalDsBreakFlag(DeviceId);
-			if ((SIGNAL_DS_BREAK_YES == chDsFlag)||(SIGNAL_SHOWCOLOUR_REDBREAK == getState))
+				if (SIGNAL_DS_BREAK_YES == chDsFlag) /* 红灯断丝 */
 				{
 					; /*0为断丝*/
 				}
@@ -300,6 +297,21 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 					SetMaskValue(MaskId, dataBuf);
 				}
 			}
+			else
+			{
+				getState = GetSignalCurColor(DeviceId); /*OC通信中断未设置断丝标志但信号机颜色为红断*/
+				chDsFlag = GetSignalDsBreakFlag(DeviceId);
+				if ((SIGNAL_DS_BREAK_YES == chDsFlag) || (SIGNAL_SHOWCOLOUR_REDBREAK == getState))
+				{
+					; /*0为断丝*/
+				}
+				else
+				{
+					SetMaskValue(MaskId, dataBuf);
+				}
+			}
+		}
+
 		else
 		{
 			getState = GetSignalCurColor(DeviceId);
@@ -492,6 +504,18 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 			/*扣车旁路按钮未故障，码位值发0*/
 		}
 		break;
+
+	case MASK_TYPE_SIGNAL_CROSS_RED:
+		cDevState = GetTrainCrossRedSignalFlag(DeviceId);
+		if (SIGNAL_TRAIN_CROSS_RED_NO == cDevState)
+		{
+			SetMaskValue(MaskId, dataBuf);  /*无列车闯红灯，码位值发1*/
+		}
+		else
+		{
+			/*有列车闯红灯，码位值发0*/
+		}
+		break;
 	default:
 		returnValue = CI_ERROR;
 		break;
@@ -514,6 +538,7 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	UINT8 returnValue = CI_SUCCESS;/*返回值默认成功*/
 	UINT8 switchLockStatus = 0U;
 	UINT8 switchCurPosition = 0U;
+	UINT8 switchDsnConnectAttr = CI_ERROR;
 	UINT8 switchLockState = 0U;
 	UINT8 switchConnectDsState = 0U;
 	UINT8 switchByPassState = 0U;
@@ -523,7 +548,6 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	UINT16 indexFind = 0U;
 	UINT8 devBelongThisLine = 0U;
 	UINT8 switchBoardNum = 0U;
-	UINT8 switchStateCheck = CI_ERROR;
 
 	switchLockStatus = GetSwitchLockStatus(DeviceId);
 
@@ -728,8 +752,8 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	case MASK_TYPE_SWITCH_SUDDEN_JICHA:
 		/*道岔静态红闪码位*/
 		switchCurPosition = GetSwitchJichaState(DeviceId);
-
+		switchDsnConnectAttr = GetSwitchDsnConnectAttr(DeviceId);
-		if (SWITCH_POSITION_SUDDEN_JICHA == switchCurPosition)
+		if ((SWITCH_POSITION_SUDDEN_JICHA == switchCurPosition) && (CI_SUCCESS != switchDsnConnectAttr))
 		{
 			; /*有效值为0*/
 		}
@@ -741,7 +765,9 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	case MASK_TYPE_SWITCH_JICHA:
 		/*道岔静态红闪或动态红闪码位: 兼容28.0.0.14数据结构使用*/
 		switchCurPosition = GetSwitchJichaState(DeviceId);
-		if ((SWITCH_POSITION_SUDDEN_JICHA == switchCurPosition)|| (SWITCH_POSITION_DYNAMIC_JICHA == switchCurPosition))
+		switchDsnConnectAttr = GetSwitchDsnConnectAttr(DeviceId);
+		if (((SWITCH_POSITION_SUDDEN_JICHA == switchCurPosition)|| (SWITCH_POSITION_DYNAMIC_JICHA == switchCurPosition))
+			&& (CI_SUCCESS != switchDsnConnectAttr))
 		{
 			; /*有效值为0*/
 		}
@@ -1053,18 +1079,18 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 		}
 		break;
 	case MASK_TYPE_PHYSECTION_FLOCK:
-		/*封锁状态码位(ATS设置) 封锁发0 未封锁以及SPKS命令封锁发1*/
+		/*封锁状态码位未封锁 以及SPKS命令封锁发1*/
 		phySecState = GetPhySecFLockState(DeviceId);
 		if (PHYSICAL_SECTION_FLOCK_NO != phySecState)
 		{
 			phySecLockType = GetPhySecFLockType(DeviceId);
-			if (PHY_SEC_FLOCK_TYPE_SPKS != phySecLockType)
+			if (SEC_FLOCK_TYPE_CMD == (SEC_FLOCK_TYPE_CMD&phySecLockType))
 			{
-				/*除了SPKS封锁  都发0*/
+				/*存在区段封锁  都发0*/
 			}
 			else
 			{
-				/*SPKS命令的封锁 发1*/
+				/*其他发1*/
 				SetMaskValue(MaskId, dataBuf);
 			}
 		}
@@ -1075,18 +1101,18 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 		}
 		break;
 	case MASK_TYPE_PHYSEC_FLOCK_SPKS:
-		/*封锁状态码位(SPKS开关设置  封锁发0 未封锁以及ATS封锁发1*/
+		/*封锁状态码位(SPKS开关设置  封锁发0 未封锁以及其他封锁发1*/
 		phySecState = GetPhySecFLockState(DeviceId);
 		if (PHYSICAL_SECTION_FLOCK_NO != phySecState)
 		{
 			phySecLockType = GetPhySecFLockType(DeviceId);
-			if (PHY_SEC_FLOCK_TYPE_CMD != phySecLockType)
+			if (SEC_FLOCK_TYPE_SPKS == (SEC_FLOCK_TYPE_SPKS&phySecLockType))
 			{
-				/*除了ATS封锁  都发0*/
+				/*存在spks 发0*/
 			}
 			else
 			{
-				/*只有ATS命令的封锁 发1*/
+				/*其他封锁 发1*/
 				SetMaskValue(MaskId, dataBuf);
 			}
 		}
@@ -1196,10 +1222,12 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 	UINT8 chJumpLockState = 0U;/*逻辑区段锁闭状态*/
 	UINT8 cLogArbState = 0U;	/* 逻辑区段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 chLogSecProhibitFAO = LOGSEC_PROHIBIT_FAO_NO;
+	UINT8 cLogFlockState = 0U;	/* 逻辑区段封锁状态 */
+	UINT8 cLogOverrideState = 0U;	/* 逻辑区段旁路状态 */
 
 	switch (MaskType)
 	{
@@ -1366,11 +1394,11 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 		break;
 	case MASK_TYPE_LOGICSECTION_SPKS_FLOCK:
 		/* 逻辑区段SPKS封锁状态 */
-		cLogSpksFlockState = GetLogSecSpksFLockState(DeviceId);
+		cLogFlockState = GetLogSecFLockType(DeviceId);
-		/*区段SPKS封锁*/
+		/*存在全线区段封锁*/
-		if (LOGIC_SECTION_SPKS_FLOCK_YES == cLogSpksFlockState)
+		if (SEC_FLOCK_TYPE_SPKS == (SEC_FLOCK_TYPE_SPKS&cLogFlockState))
 		{
-			; /*封锁发0*/
+			;/*封锁发0*/
 		}
 		else
 		{
@@ -1378,6 +1406,100 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 			SetMaskValue(MaskId, dataBuf);
 		}
 		
+		break;
+	case MASK_TYPE_LOGICSECTION_ALLSEC_FLOCK:
+		/* 逻辑区段全线区段封锁状态 */
+		cLogFlockState = GetLogSecFLockType(DeviceId);
+		/*存在全线区段封锁*/
+		if(SEC_FLOCK_TYPE_ALLFLOCK == (SEC_FLOCK_TYPE_ALLFLOCK&cLogFlockState))
+		{
+			;/*封锁发0*/
+		}
+		else
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
+	case MASK_TYPE_LOGICSECTION_APG_FLOCK:
+		/* 逻辑区段站台门异常打开封锁状态 */
+		cLogFlockState = GetLogSecFLockType(DeviceId);
+		/*存在站台门异常打开封锁*/
+		if (SEC_FLOCK_TYPE_APG == (SEC_FLOCK_TYPE_APG&cLogFlockState))
+		{
+			;/*封锁发0*/
+		}
+		else
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
+	case MASK_TYPE_LOGICSECTION_PROHIBIT_FAO:
+		/* 逻辑区段禁止FAO运行状态 */
+		chLogSecProhibitFAO = GetLogSecProhibitFAOState(DeviceId);
+		/*禁止FAO运行*/
+		if (LOGSEC_PROHIBIT_FAO_YES == chLogSecProhibitFAO)
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
+	case MASK_TYPE_LOGICSECTION_CMD_FLOCK:
+		/* 逻辑区段人工区段封锁状态 */
+		cLogFlockState = GetLogSecFLockType(DeviceId);
+		/*存在对应封锁*/
+		if (SEC_FLOCK_TYPE_CMD == (SEC_FLOCK_TYPE_CMD&cLogFlockState))
+		{
+			;/*封锁发0*/
+		}
+		else
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
+	case MASK_TYPE_LOGICSECTION_ESB_FLOCK:
+		/* 逻辑区段ESB区段封锁状态 */
+		cLogFlockState = GetLogSecFLockType(DeviceId);
+		/*存在对应封锁*/
+		if (SEC_FLOCK_TYPE_ESB == (SEC_FLOCK_TYPE_ESB&cLogFlockState))
+		{
+			;/*封锁发0*/
+		}
+		else
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
+	case MASK_TYPE_LOGICSECTION_CESB_FLOCK:
+		/* 逻辑区段CESB区段封锁状态 */
+		cLogFlockState = GetLogSecFLockType(DeviceId);
+		/*存在对应封锁*/
+		if (SEC_FLOCK_TYPE_CESB == (SEC_FLOCK_TYPE_CESB&cLogFlockState))
+		{
+			;/*封锁发0*/
+		}
+		else
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
+	case MASK_TYPE_LOGICSECTION_OVERRIDE:
+		/* 逻辑区段联络线旁路状态 */
+		cLogOverrideState = GetOverrideStateByLogSecId(DeviceId);
+		/*存在对应联络线旁路*/
+		if (CONNECT_OVERRIDE_STATE_YES == cLogOverrideState)
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+			/*未设置发0*/
+		}
 		break;
 	default:
 		returnValue = CI_ERROR;
@@ -1881,6 +2003,8 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 	UINT8 cEsbCutErrFlag = ESB_ERROR_FLAG_NO;  /*紧急关闭旁路按钮故障标志*/
 	UINT16 wEsbCollRelayId = 0U;  /*ESB采集继电器ID*/
 	UINT8 cPsdExceptOpenState = 0U;  /*屏蔽门异常打开状态*/
+	UINT8 chBtnErrState = 0U;/*按钮故障状态*/
+	UINT8 localCiType = GetLocalCiType();/*获取联锁类型*/
 
 	chRtnIndicatorDevId = GetIndicatorRelNonReturnId(DeviceId);
 	virtualZDZFBelongCiId = GetVirtualZDZFBelongCiId();
@@ -1939,7 +2063,7 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 
 		break;
 
-	case MASK_TYPE_ESP_STATE:/*站台紧急关闭按钮码位*/
+	case MASK_TYPE_ESP_STATE:/*站台紧急关闭按钮状态码位*/
 		if ((ESB_STATE_VALID_NO == GetEsbState(DeviceId)) || (ESB_CUT_YES == GetEsbCutState(DeviceId)))
 		{
 			SetMaskValue(MaskId, dataBuf);
@@ -2004,6 +2128,20 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 		}
 		break;
 	case MASK_TYPE_ESP_PRESS_STATE:
+		if (CI_TYPE_SCX == localCiType)
+		{
+			RelayCollState = GetEsbAutualState(DeviceId);
+			if (ESB_STATE_VALID_NO == RelayCollState)
+			{
+				SetMaskValue(MaskId, dataBuf);  /*未按下1*/
+			}
+			else
+			{
+				;/*按下0*/
+			}
+		}
+		else
+		{
 			wEsbCollRelayId = GetEsbRelayId(DeviceId);  /*获取ESB采集继电器*/
 			RelayCollState = GetRelayCollState(wEsbCollRelayId);  /*获取ESB采集继电器状态*/
 			if (RELAY_STATE_UP == RelayCollState)
@@ -2014,6 +2152,34 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 			{
 				/*ESB按下，发0*/
 			}
+		}
+		break;
+	case MASK_TYPE_ESS_STATE:
+		if (CI_TYPE_SCX == localCiType)
+		{
+			RelayCollState = GetEssState(DeviceId);
+			if (ESB_STATE_GO_FLAG == RelayCollState)
+			{
+				SetMaskValue(MaskId, dataBuf);  /*去位1*/
+			}
+			else
+			{
+				;/*停位0*/
+			}
+		}
+		else
+		{
+			wEsbCollRelayId = GetESSRelayId(DeviceId);  /*获取ESS采集继电器*/
+			RelayCollState = GetRelayCollState(wEsbCollRelayId);  /*获取ESS采集继电器状态*/
+			if (RELAY_STATE_UP == RelayCollState)
+			{
+				SetMaskValue(MaskId, dataBuf);  /*去位*/
+			}
+			else
+			{
+				/*ESB按下，发0*/
+			}
+		}
 		break;
 	case MASK_TYPE_PSD_STATE_ATS:/*站台屏蔽门状态码位;给ATS*/
 		/*获取屏蔽门互锁解除状态、门状态*/
@@ -2243,6 +2409,17 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 			/*PSD异常打开，码位组0*/
 		}
 		break;
+	case MASK_TYPE_PSD_MUTUALLOCK_BTNERR:  /*站台屏蔽门旁路按钮粘连*/
+		chBtnErrState = GetPsdMutualLockErrState(DeviceId);
+		if (PSD_BTN_ERROR_FLAG_YES == chBtnErrState)
+		{
+			SetMaskValue(MaskId, dataBuf);  /*PSD旁路故障，码位组1*/
+		}
+		else
+		{
+			/*PSD异常打开，码位组0*/
+		}
+		break;
 	default:
 		returnValue = CI_ERROR;
 		break;
@@ -2439,6 +2616,7 @@ UINT8 GaragedoorMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 *			 UINT8* dataBuf, 数据缓冲区
 * 返回值  ： 0: 码位处理失败
 *			 1: 码位处理成功
+* BY  hh  2026.03.17
 */
 UINT8 FloodGateMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dataBuf)
 {
@@ -2535,6 +2713,87 @@ UINT8 FloodGateMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8*
 
 	return returnValue;
 }
+
+/*
+* 功能描述： 限速区段相关码位处理
+* 参数说明： UINT8 MaskType, 码位类型
+*			 UINT16 DeviceId, 设备ID
+*			 UINT16 MaskId, 码位ID
+*			 UINT8* dataBuf, 数据缓冲区
+* 返回值  ： 0: 码位处理失败
+*			 1: 码位处理成功
+* by hh  2026.03.17
+*/
+UINT8 SpeedLimitMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dataBuf)
+{
+	UINT8 returnValue = CI_ERROR;/*返回值默认失败*/
+	UINT8 sPeedLimitState = FLAG_UNSET; /*临时变量：限速状态*/
+	UINT16 Id = DeviceId;
+
+
+	switch (MaskType)
+	{
+	case MASK_TYPE_SPEEDLIMITSEC_STATE:/*CI-ATS限速区段临时限速设置码位*/
+	{
+		/*临时限速区段状态有效*/
+		sPeedLimitState = GetTSRSetFlag(Id);
+		if (FLAG_SL == sPeedLimitState)
+		{
+
+		}
+		else
+		{
+			SetMaskValue(MaskId, dataBuf);/*未限速*/
+		}
+		returnValue = CI_SUCCESS;
+	}
+	break;
+	case MASK_TYPE_SPEEDLIMITTF_STATE:/*CI-ATS限速区段台风限速设置码位*/
+	{
+		/*台风限速状态有效*/
+		sPeedLimitState = GetTFSRSetFlag(Id);
+		if (FLAG_SL == sPeedLimitState)
+		{
+			
+		}
+		else
+		{
+			SetMaskValue(MaskId, dataBuf);/*未限速*/
+		}
+		returnValue = CI_SUCCESS;
+	}
+	break;
+	case MASK_TYPE_SPEEDLIMITTNR_STATE /*CI-ATS限速区段NR限速设置码位*/
+	:/*CI-ATS限速区段NR限速设置码位*/
+	{
+		SetMaskValue(MaskId, dataBuf);  /*这版本没NR，都没有*/
+		returnValue = CI_SUCCESS;
+	}
+	break;
+	case MASK_TYPE_SPEEDLIMITQX_STATE:/*CI-ATS限速区段全线临时限速设置码位*/
+	{
+		/*全线限速状态有效 */
+		sPeedLimitState = GetAllSRSetFlag(Id);
+		if (FLAG_SL == sPeedLimitState)
+		{
+
+		}
+		else
+		{
+			SetMaskValue(MaskId, dataBuf);/*未限速*/
+		}
+		returnValue = CI_SUCCESS;
+	}
+	break;
+	default:
+		returnValue = CI_ERROR;
+		break;
+	}
+
+	return returnValue;
+}
+
+
 /*
 * 功能描述： 生成码位
 * 参数说明： const UINT8 localCiId, 本机联锁站ID
@@ -2647,7 +2906,12 @@ UINT8 MaskPack(const UINT8 destSystemType, UINT8* dataBuf)
 				returnValue = CI_ERROR;
 			}
 			break;
-
+		case CI_DEVICE_TYPE_SPEEDLIMIT:/*限速区段相关码位*/
+			if (CI_ERROR == SpeedLimitMaskManage(MaskType, DeviceId, MaskId, dataBuf))
+			{
+				returnValue = CI_ERROR;
+			}
+			break;
 		default:
 			returnValue = CI_ERROR;
 			break;
@@ -4501,6 +4765,7 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 	UINT16 curCoup = 0U;
 	UINT32 tempera = 0U;
 	UINT8 flagEEPROM = 0U;
+	UINT32 ccuSyn = 0u;/*通控请求序列号*/
 	UINT32 crcRecv = 0U;
 	
 	/*接收到平台心跳帧*/
@@ -4542,6 +4807,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 +4819,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 +4910,7 @@ UINT8 ParasePlantSEBHeartFrame(UINT8* dataBuf)
 
 	UINT8 boardSEBId = 0U;/*扩展板ID */
 	UINT16 dataLengthRcv = 0U; /*帧长度*/
+	UINT32 sebSyn = 0u;	/*串口请求序列号*/
 	UINT32 crcRecv = 0U;  /*CRC校验码*/
 	UINT32 rcvCyc = 0U;  /*周期号*/
 	/*接收到平台心跳帧*/
@@ -4665,17 +4934,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)
@@ -5136,9 +5408,62 @@ void PackCiToCimCollDiffData(void)
 	{/*不处理*/
 	}
 
-	debug_infor_printf((const)"IO Compare Diff OCnum = %d\n", gDiffDataOcNum);
-	debug_out_array(0xAA, ciToCimDataBuffer, ii);
-
 	/*发送维护机*/
 	(void)DarkInfoPack(CIM_INFO_IO_COLL_DIFF_ALARM, ciToCimDataBuffer, ii);
 }
+
+/*
+* 功能描述： 组包发送CIM接触网信息
+* 参数说明： void
+* 返回值  ： 无
+*/
+void PackCiToCimOHLData(void)
+{
+	/*变量初始化*/
+	UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0U };
+	UINT8 ohlNum = 0u;			/*接触网分区总数*/
+	UINT16 ii = 0u;
+	UINT8 jj = 0u;
+	UINT16 tempIndex = 0u;
+	UINT16 ohlId = 0u;			/*接触网分区ID*/
+	UINT8 ohlPowerState = 0u;	/*接触网状态*/
+	UINT8 chLocalCiId = 0u;     /*本地联锁ID*/
+	UINT8 devBlongCiId = 0u;    /*设备所属联锁ID*/
+	UINT8 localOhlNum = 0u;
+
+	ohlNum = (UINT8)GetOhlCurSum();
+	if ((0u < ohlNum) && (OHL_MAX_NUM > ohlNum))
+	{
+		chLocalCiId = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
+		tempIndex = ii;	/*接触网数量*/
+		ii = ii + 1u;
+
+		for (jj = 0u; jj < ohlNum; jj++)
+		{
+			ohlId = GetOhlId(jj);	/*接触网ID*/
+			devBlongCiId = GetOhlBelongCiId(ohlId); /*获取设备所属联锁ID*/
+			if ((0u != ohlId) && (0U != chLocalCiId) && (chLocalCiId == devBlongCiId))
+			{
+				ShortToChar(ohlId, &ciToCimDataBuffer[ii]);	/*接触网 id*/
+				ii += 2u;
+
+				ohlPowerState = GetOhlPowerState(ohlId);	/*接触网状态*/
+				ciToCimDataBuffer[ii++] = ohlPowerState;
+
+				localOhlNum++;
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+		ciToCimDataBuffer[tempIndex] = localOhlNum;/*接触网数量*/
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	/*发送维护机*/
+	(void)DarkInfoPack(CIM_INFO_OHL_POWER_ALARM, ciToCimDataBuffer, ii);
+}

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

@@ -44,6 +44,8 @@
 #include "../ParsePack/ParsePackOcData.h"
 #include "../DataManage/PlatDataManage.h"
 #include "../IO/DeviceRelayDataProcess.h"
+#include "SpeedLimitSecDataManage.h"
+
 
 #ifdef __cplusplus
 extern "C" {
@@ -60,7 +62,7 @@ extern "C" {
 
 	extern PlatHeartDataStruct RecvHeartDataStru;
 	extern PlatGPIODataStruct RecvPlatDataStruGPIO;
-	extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;
+
 /*
 * 功能描述： 信号机相关码位处理
 * 参数说明： UINT8 MaskType, 码位类型
@@ -223,6 +225,18 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId);
 */
 UINT8 FloodGateMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dataBuf);
 
+/*
+* 功能描述： 限速区段相关码位处理
+* 参数说明： UINT8 MaskType, 码位类型
+*			 UINT16 DeviceId, 设备ID
+*			 UINT16 MaskId, 码位ID
+*			 UINT8* dataBuf, 数据缓冲区
+* 返回值  ： 0: 码位处理失败
+*			 1: 码位处理成功
+* BY  hh  2026.03.17
+*/
+UINT8 SpeedLimitMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dataBuf);
+
 /*
 * 功能描述： 组包发送CIM通信状态信息
 * 参数说明： void    
@@ -386,6 +400,13 @@ void PackCiToCimFlyProtectData(void);
 */
 void PackCiToCimCollDiffData(void);
 
+/*
+* 功能描述： 组包发送CIM接触网信息
+* 参数说明： void
+* 返回值  ： 无
+*/
+void PackCiToCimOHLData(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -49,7 +49,7 @@
 #define ZC_TO_CI_EB_MAX                ((UINT16)254)      /*ZC发送CI的区间紧急制动区段数量最大值*/
 
 /*TIOC 和 TMC*/
-#define TIOC_TO_TMC_DATA_LEN_MAX					((UINT16)3000)	/*联锁到ZC组包数据最大值*/
+#define TIOC_TO_TMC_DATA_LEN_MAX					((UINT16)3000)	/*RC到TMC组包数据最大值*/
 
 /*CI 和 LEU*/
 #define LEU_TO_CI_SUM_MAX						((UINT16)9)	/*定义联锁可以通信的LEU最大值*/
@@ -104,6 +104,7 @@
 #define CIM_INFO_UNIT_ALARM				   ((UINT16)0x2011)	 /*发送CIM执行单元报警*/
 #define CIM_INFO_FLYPROTECT_ALARM				   ((UINT16)0x2012)	 /*发送CIM飞车宕机报警*/
 #define CIM_INFO_IO_COLL_DIFF_ALARM		   ((UINT16)0x2013)	 /*发送CIM IO双系采集不一致报警*/
+#define CIM_INFO_OHL_POWER_ALARM		   ((UINT16)0x2014)	 /*发送CIM 接触网供电状态报警*/
 
 #define CI_AND_OTHER_TRANSMIT_GOOD      ((UINT8)0x55) /*CI与其他系统双网通信正常*/
 #define CI_AND_OTHER_TRANSMIT_LINK      ((UINT8)0x5A) /*CI与其他系统单网通信正常*/

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

@@ -10,11 +10,11 @@
 #define MSG_TYPE_WLB_CONFIRM_FIRST	((UINT8)113u)	/*全线列车紧急制动首次确认*/
 #define MSG_TYPE_WLB_SET_SECOND		((UINT8)114u)	/*全线列车紧急制动设置二次*/
 #define MSG_TYPE_WLB_CONFIRM_SECOND	((UINT8)115u)	/*全线列车紧急制动二次确认*/
-#define MSG_TYPE_DA_REPORT			((UINT8)116u)	/*脱轨防护区汇报信息*/
+#define MSG_TYPE_DA_REPORT			((UINT8)116u)	/*列车状态异常防护区汇报信息*/
-#define MSG_TYPE_DA_CANCLE_FIRST	((UINT8)117u)	/*脱轨防护区取消首次消息*/
+#define MSG_TYPE_DA_CANCLE_FIRST	((UINT8)117u)	/*列车状态异常防护区取消首次消息*/
-#define MSG_TYPE_DA_CONFIRM_FIRST	((UINT8)118u)	/*脱轨防护区首次确认消息*/
+#define MSG_TYPE_DA_CONFIRM_FIRST	((UINT8)118u)	/*列车状态异常防护区首次确认消息*/
-#define MSG_TYPE_DA_CANCLE_SECOND	((UINT8)119u)	/*脱轨防护区取消再次消息*/
+#define MSG_TYPE_DA_CANCLE_SECOND	((UINT8)119u)	/*列车状态异常防护区取消再次消息*/
-#define MSG_TYPE_DA_CONFIRM_SECOND	((UINT8)120u)	/*脱轨防护区再次确认消息*/
+#define MSG_TYPE_DA_CONFIRM_SECOND	((UINT8)120u)	/*列车状态异常防护区再次确认消息*/
 #define MSG_TYPE_REPORT				((UINT8)121u)	/*汇报远程筛选列车信息*/
 #define MSG_TYPE_REQUEST_FIRST		((UINT8)122u)	/*首次消息*/
 #define MSG_TYPE_CONFIRM_FIRST		((UINT8)123u)	/*首次确认*/
@@ -27,6 +27,29 @@
 #define MSG_TYPE_EA_CONFIRM_SECOND	((UINT8)130u)	/*区间疏散再次确认消息*/
 #define MSG_TYPE_TRIAN_INFO_REPORT  ((UINT8)131u)	/*TIOC给ATS发送列车信息*/
 #define MSG_TYPE_TRAIN_FLY_INFO ((UINT8)132u)	/*TIOC给ATS发送飞车宕机报警信息*/
+#define MSG_TYPE_ALLSECFLOCK_CMD_FIRST		((UINT8)137u)	/*全线区段封锁设置一次*/
+#define MSG_TYPE_ALLSECFLOCK_CONFIRM_FIRST	((UINT8)138u)	/*全线区段封锁首次确认*/
+#define MSG_TYPE_ALLSECFLOCK_CMD_SECOND		((UINT8)139u)	/*全线区段封锁设置二次*/
+#define MSG_TYPE_ALLSECFLOCK_CONFIRM_SECOND	((UINT8)140u)	/*全线区段封锁二次确认*/
+#define MSG_TYPE_CESBFLOCK_CMD_FIRST		((UINT8)141u)	/*全线CESB封锁取消一次*/
+#define MSG_TYPE_CESBFLOCK_CONFIRM_FIRST	((UINT8)142u)	/*全线CESB封锁取消首次确认*/
+#define MSG_TYPE_CESBFLOCK_CMD_SECOND		((UINT8)143u)	/*全线CESB封锁取消二次*/
+#define MSG_TYPE_CESBFLOCK_CONFIRM_SECOND	((UINT8)144u)	/*全线CESB封锁取消二次确认*/
+
+#define MSG_JIEFENGJIESUO_CMD_FIRST		((UINT8)145u)	/*全线解封解锁一次*/
+#define MSG_JIEFENGJIESUO_BACK_FIRST	((UINT8)146u)	/*全线解封解锁首次确认*/
+#define MSG_JIEFENGJIESUO_CMD_SECOND	((UINT8)147u)	/*全线解封解锁二次*/
+#define MSG_JIEFENGJIESUO_BACK_SECOND	((UINT8)148u)	/*全线解封解锁二次确认*/
+
+#define MSG_FORCE_SWITCT_CMD_FIRST		((UINT8)149u)	/*道岔强转一次*/
+#define MSG_FORCE_SWITCT_BACK_FIRST	    ((UINT8)150u)	/*道岔强转首次确认*/
+#define MSG_FORCE_SWITCT_CMD_SECOND	    ((UINT8)151u)	/*道岔强转二次*/
+#define MSG_FORCE_SWITCT_BACK_SECOND	((UINT8)152u)	/*道岔强转二次确认*/
+
+#define MSG_PHY_PRE_RESET_CMD_FIRST		    ((UINT8)153u)	   /*计轴预复位一次*/
+#define MSG_PHY_PRE_RESET_BACK_FIRST	    ((UINT8)154u)      /*计轴预复位首次确认*/
+#define MSG_PHY_PRE_RESET_CMD_SECOND	    ((UINT8)155u)      /*计轴预复位二次*/
+#define MSG_PHY_PRE_RESET_BACK_SECOND	    ((UINT8)156u)	   /*计轴预复位二次确认*/
 
 #define CONFIRM_UNKNOWN			((UINT8)0u)		/*未知*/
 #define CONFIRM_FIRST_SUCCESS	((UINT8)1u)		/*首次确认成功*/
@@ -58,6 +81,9 @@
 #define WLB_TYPE_RC				((UINT8)2u)	/*全线列车紧急制动*/
 #define WLB_TYPE_PHYSEC			((UINT8)3u)	/*物理区段紧急制动*/
 
+#define SEC_ALLFLOCK_CMD_SET		((UINT8)0xaau)		/* 全线封锁设置命令 */
+#define SEC_ALLFLOCK_CMD_CANCLE		((UINT8)0x55u)		/* 全线封锁取消命令 */
+
 #define CONFIRM_WLB_FST_UNKNOWN	((UINT8)0u)	/*首次回复未知*/
 #define CONFIRM_WLB_FST_SUCCESS	((UINT8)1u)	/*首次回复成功*/
 #define CONFIRM_WLB_FST_REPEAT	((UINT8)2u)	/*首次回复重复设置*/
@@ -69,25 +95,41 @@
 #define CONFIRM_WLB_SND_FIRST	((UINT8)4u)	/*二次回复未执行首次确认*/
 #define CONFIRM_WLB_SND_INFO_DIFF	((UINT8)8u)	/*一二次命令信息不一致*/
 
-#define CONFIRM_DA_FST_UNKNOWN	((UINT8)0u) /*取消脱轨防护区首次回复未知*/
+#define CONFIRM_DA_FST_UNKNOWN	((UINT8)0u) /*取消列车状态异常防护区域首次回复未知*/
-#define CONFIRM_DA_FST_SUCCESS	((UINT8)1u)	/*取消脱轨防护区首次回复成功*/
+#define CONFIRM_DA_FST_SUCCESS	((UINT8)1u)	/*取消列车状态异常防护区域首次回复成功*/
-#define CONFIRM_DA_FST_UNSET	((UINT8)7u)	/*取消脱轨防护区首次回复未设置*/
+#define CONFIRM_DA_FST_UNSET	((UINT8)7u)	/*取消列车状态异常防护区域首次回复未设置*/
-#define CONFIRM_DA_FST_DERAIL	((UINT8)9u)	/*取消脱轨防护区首次回复当前列车处于脱轨状态*/
+#define CONFIRM_DA_FST_DERAIL	((UINT8)9u)	/*取消列车状态异常防护区域首次回复当前列车处于脱轨状态*/
 
-#define CONFIRM_DA_SND_UNKNOWN	((UINT8)0u)	/*取消脱轨防护区再次回复未知*/
+#define CONFIRM_DA_SND_UNKNOWN	((UINT8)0u)	/*取消列车状态异常防护区域再次回复未知*/
-#define CONFIRM_DA_SND_SUCCESS	((UINT8)1u)	/*取消脱轨防护区再次回复成功*/
+#define CONFIRM_DA_SND_SUCCESS	((UINT8)1u)	/*取消列车状态异常防护区域再次回复成功*/
-#define CONFIRM_DA_SND_CRC		((UINT8)3u)	/*取消脱轨防护区再次回复信息帧校验失败*/
+#define CONFIRM_DA_SND_CRC		((UINT8)3u)	/*取消列车状态异常防护区域再次回复信息帧校验失败*/
-#define CONFIRM_DA_SND_FIRST	((UINT8)4u)	/*取消脱轨防护区再次回复未执行首次*/
+#define CONFIRM_DA_SND_FIRST	((UINT8)4u)	/*取消列车状态异常防护区域再次回复未执行首次*/
-#define CONFIRM_DA_SND_DIFF		((UINT8)8u)	/*取消脱轨防护区再次回复列车ID与一次不一致*/
+#define CONFIRM_DA_SND_DIFF		((UINT8)8u)	/*取消列车状态异常防护区域再次回复列车ID与一次不一致*/
-#define CONFIRM_DA_SND_DERAIL	((UINT8)9u)	/*取消脱轨防护区再次回复列车当前处于脱轨状态*/
+#define CONFIRM_DA_SND_DERAIL	((UINT8)9u)	/*取消列车状态异常防护区域再次回复列车当前处于脱轨状态*/
-#define CONFIRM_DA_SND_LINE_DIFF	((UINT8)11U)	/*取消脱轨防护一二次命令线路属性不一致*/
+#define CONFIRM_DA_SND_LINE_DIFF	((UINT8)11U)	/*取消列车状态异常防护区域一二次命令线路属性不一致*/
+
+#define CONFIRM_ALLFLOCK_FST_SUCCESS	((UINT8)1u)	/*全线封锁首次回复成功*/
+#define CONFIRM_ALLFLOCK_FST_REPEAT	((UINT8)2u)	/*全线封锁首次回复重复设置*/
+#define CONFIRM_ALLFLOCK_FST_UNSET	((UINT8)5u)	/*全线封锁首次回复未设置*/
+
+#define CONFIRM_ALLFLOCK_SND_UNKNOWN	((UINT8)0u)	/*全线封锁二次回复未知*/
+#define CONFIRM_ALLFLOCK_SND_SUCCESS	((UINT8)1u)	/*全线封锁二次回复成功*/
+#define CONFIRM_ALLFLOCK_SND_CHECKFAIL		((UINT8)3u)	/*全线封锁信息帧校验失败*/
+#define CONFIRM_ALLFLOCK_SND_FIRST	((UINT8)4u)	/*全线封锁二次回复未执行首次确认*/
+
+#define CONFIRM_CANCLE_CESB_FST_SUCCESS	((UINT8)1u)	/*取消CESB首次回复成功*/
+#define CONFIRM_CANCLE_CESB_FST_UNSET	((UINT8)5u)	/*取消CESB首次回复未设置*/
+
+#define CONFIRM_CANCLE_CESB_SND_UNKNOWN	((UINT8)0u)	/*取消CESB二次回复未知*/
+#define CONFIRM_CANCLE_CESB_SND_SUCCESS	((UINT8)1u)	/*取消CESB二次回复成功*/
+#define CONFIRM_CANCLE_CESB_SND_CHECKFAIL		((UINT8)3u)	/*取消CESB信息帧校验失败*/
+#define CONFIRM_CANCLE_CESB_SND_FIRST	((UINT8)4u)	/*取消CESB二次回复未执行首次确认*/
+#define CONFIRM_CANCLE_CESB_RELAY_ACTIVE	((UINT8)9u)	/*取消CESB回复CESB激活*/
 
 #define DA_AREA_UP				((UINT8)0x55u)	/* 上行区域 */
 #define DA_AREA_DOWN			((UINT8)0xaau)	/* 下行区域 */
 #define DA_AREA_ALL				((UINT8)0xffu)	/* 上行和下行区域 */
 
-#define ATS_DA_CMD_TYPE_CANCEL	((UINT8)0x55u)	/* ATS取消脱轨防护区命令类型 */
-
 #define CONFIRM_TIMEOUT_CC		((UINT16)400u)	/*首次消息等待二次消息超时时间*/
 
 #define GATE_WAY_PRTCL_VER		((UINT32)101u)	/*协议版本号*/
@@ -100,6 +142,25 @@
 #define EA_AREA_UP					((UINT8)0x55u)	/* 上行区域 */
 #define EA_AREA_DOWN				((UINT8)0xaau)	/* 下行区域 */
 #define EA_AREA_ALL					((UINT8)0xffu)	/* 上行和下行区域 */
+
+
+#define CONFIRM_FST_SUCCESS	((UINT8)1u)	/*首次回复成功*/
+
+
+#define CONFIRM_SND_UNKNOWN	                ((UINT8)0u)	/*二次回复未知，一次二次不同*/
+#define CONFIRM_SND_SUCCESS	                ((UINT8)1u)	/*二次回复成功*/
+#define CONFIRM_SND_CHECKFAIL	        	((UINT8)3u)	/*CRC校验失败*/
+#define CONFIRM_SND_NOTFIRST    	        ((UINT8)4u)	/*二次回复未执行首次确认*/
+
+#define CONFIRM_ID_ILL	((UINT8)5u)	/*ID非法*/
+#define CONFIRM_PHY_PRERESET_ID_DIF  ((UINT8)5u)/*一次二次命令ID不一致*/
+#define CONFIRM_FORCE_SW_ID_DIF   	((UINT8)7u)	/*一次二次命令ID不一致*/
+#define CONFIRM_FORCE_SW_CMD_DIF	((UINT8)8u)	/*一次二次强转位置不一致*/
+#define CONFIRM_CMD_INVALID     ((UINT8)15u)  /*命令无效*/
+
+#define SWITCH_FORCE_DINGWEI			((UINT8)0x55u)	/* 强转定位 */
+#define SWITCH_FORCE_FANWEI				((UINT8)0xaau)	/* 强转反位 */
+
 /* 远程筛选列车信息结构体 */
 typedef struct
 {
@@ -121,7 +182,7 @@ typedef struct
 	AtsScreenTrainInfoStru strTrainInfo[TRAIN_SUM_MAX]; /*列车信息*/
 }AtsScreenMsgFstStru;
 
-/* ATS远程筛选确认结构体 */
+/* 确认信息结构体 */
 typedef struct
 {
 	UINT8 chFlag;			/*消息有效性*/
@@ -131,6 +192,7 @@ typedef struct
 	UINT32 dwTime;			/*时间*/
 	UINT8 chOpStatus;		/*操作结果*/
 	UINT32 dwCrc32;			/*CRC*/
+	UINT8 chDaType;         /*防护分区类型*/
 }AtsMsgCfmStru;
 
 /* ATS远程筛选二次消息结构体 */
@@ -181,7 +243,7 @@ typedef struct
 	UINT16 wBrakeIndex;		/*制动ID*/
 }AtsWlbMsgStru;
 
-/* ATS取消脱轨防护区信息结构体 */
+/* ATS取消列车状态异常防护区域信息结构体 */
 typedef struct
 {
 	UINT8 chFlag;			/*消息接收状态*/
@@ -192,11 +254,80 @@ typedef struct
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT32 dwDaTrainId;		/*列车互联互通编号*/
 	UINT32 dwTime;			/*时间*/
-	UINT8 chType;			/*建立/取消*/
+	UINT8 chType;			/*类型*/
 	UINT8 chLine;			/*线路*/
 	UINT32 dwCrc32;			/*CRC值*/
 }AtsDaMsgStru;
 
+/* ATS设置/取消全线区段封锁信息结构体 */
+typedef struct
+{
+	UINT8 chFlag;			/*消息接收状态*/
+	UINT32 dwCycle;			/*消息接收周期号*/
+	UINT8 chAtsId;			/*ATS编号*/
+	UINT8 chStation;		/*车站编号*/
+	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chTiocId;			/*TIOC编号*/
+	UINT32 dwTime;			/*时间*/
+	UINT8 chType;			/*设置/取消*/
+	UINT32 dwCrc32;			/*CRC值*/
+}AtsAllSecFlockMsgStru;
+
+/* ATS取消全线CESB封锁信息结构体 */
+typedef struct
+{
+	UINT8 chFlag;			/*消息接收状态*/
+	UINT32 dwCycle;			/*消息接收周期号*/
+	UINT8 chAtsId;			/*ATS编号*/
+	UINT8 chStation;		/*车站编号*/
+	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chTiocId;			/*TIOC编号*/
+	UINT32 dwTime;			/*时间*/
+	UINT32 dwCrc32;			/*CRC值*/
+}AtsCESBCancleMsgStru;
+
+/* ATS解封解锁信息结构体 */
+typedef struct
+{
+	UINT8 chFlag;			/*消息接收状态*/
+	UINT32 dwCycle;			/*消息接收周期号*/
+	UINT8 chAtsId;			/*ATS编号*/
+	UINT8 chStation;		/*车站编号*/
+	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chTiocId;			/*TIOC编号*/
+	UINT32 dwTime;			/*时间*/
+	UINT32 dwCrc32;			/*CRC值*/
+}AtsJieFengJieSuoMsgStru;
+
+/* ATS道岔强转信息结构体 */
+typedef struct
+{
+	UINT8 chFlag;			/*消息接收状态*/
+	UINT32 dwCycle;			/*消息接收周期号*/
+	UINT8 chAtsId;			/*ATS编号*/
+	UINT8 chStation;		/*车站编号*/
+	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chTiocId;			/*TIOC编号*/
+	UINT8 chCmdType;         /*命令类型*/
+	UINT32 dwSiwtchId;         /*设备互联互通ID*/
+	UINT32 dwTime;			/*时间*/
+	UINT32 dwCrc32;			/*CRC值*/
+}AtsSwitchForceMsgStru;
+
+/* ATS计轴预复位信息结构体 */
+typedef struct
+{
+	UINT8 chFlag;			/*消息接收状态*/
+	UINT32 dwCycle;			/*消息接收周期号*/
+	UINT8 chAtsId;			/*ATS编号*/
+	UINT8 chStation;		/*车站编号*/
+	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chTiocId;			/*TIOC编号*/
+	UINT32 dwPhySecHlhtId;   /*设备ID*/
+	UINT32 dwTime;			/*时间*/
+	UINT32 dwCrc32;			/*CRC值*/
+}AtsPhyPreResetMsgStru;
+
 /*******************************全局变量声明*******************************/
 extern AtsScreenMsgFstStru g_strAtsMsgFst;
 extern AtsMsgCfmStru g_strAtsCfmFst;
@@ -222,7 +353,37 @@ extern AtsMsgCfmStru g_strSndAtsCfmFst;			/*
 extern AtsMsgCfmStru g_strSndAtsEaCfmFst;			/*第二个ATS的取消区间疏散首次确认*/
 extern AtsMsgCfmStru g_strSndAtsWlbCfmFst;		/*第二个ATS的设置/取消全线列车紧急制动首次确认*/
 extern AtsMsgCfmStru g_strSndAtsDaCfmFst;			/*第二个ATS的取消脱轨防护区首次确认*/
+extern AtsMsgCfmStru g_strSndAtsAllFlockCfmFst;		/*第二个ATS的设置/取消全线区段封锁首次确认*/
 
+extern AtsAllSecFlockMsgStru g_strAtsAllFlockMsgFst; /*设置/取消全线区段封锁首次消息*/
+extern AtsMsgCfmStru g_strAtsAllFlockCfmFst;			/*设置/取消全线区段封锁首次确认*/
+extern AtsAllSecFlockMsgStru g_strAtsAllFlockMsgSnd;			/*取消全线区段封锁再次消息*/
+extern AtsMsgCfmStru g_strAtsAllFlockCfmSnd;			/*取消全线区段封锁再次确认*/
+
+extern AtsCESBCancleMsgStru g_strAtsCesbMsgFst; /*取消全线CESB封锁首次消息*/
+extern AtsMsgCfmStru g_strAtsCesbCfmFst ;			/*取消全线CESB封锁首次确认*/
+extern AtsCESBCancleMsgStru g_strAtsCesbMsgSnd ;			/*取消全线CESB封锁再次消息*/
+extern AtsMsgCfmStru g_strAtsCesbCfmSnd ;			/*取消全线CESB封锁再次确认*/
+extern AtsMsgCfmStru g_strSndAtsCesbCfmFst;		/*第二个ATS的取消CESB封锁首次确认*/
+
+
+extern AtsJieFengJieSuoMsgStru g_JieFengJieSuoMsgFst ;  /*全站解封解锁首次消息*/
+extern AtsMsgCfmStru g_strAtsJieFengJieSuoCfmFst ;			/*全站解封解锁首次确认*/
+extern AtsJieFengJieSuoMsgStru g_JieFengJieSuoMsgSnd; /*全站解封解锁再次消息*/
+extern AtsMsgCfmStru g_strAtsJieFengJieSuoCfmSnd;		    	/*全站解封解锁再次确认*/
+extern AtsMsgCfmStru g_SndAtsJieFengJieSuoCfmFst;		/*第二个ATS的解封解锁首次确认*/
+
+extern AtsSwitchForceMsgStru g_SwitchForceMsgFst; /*道岔强转首次消息*/
+extern AtsMsgCfmStru g_SwitchForceCfmFst;			/*道岔强转首次确认*/
+extern AtsSwitchForceMsgStru g_SwitchForceMsgSnd; /*道岔强转再次消息*/
+extern AtsMsgCfmStru g_SwitchForceCfmSnd;		    /*道岔强转再次确认*/
+extern AtsMsgCfmStru g_SndAtsSwitchForceCfmFst;	/*第二个ATS的道岔强转首次确认*/
+
+extern AtsPhyPreResetMsgStru g_PhyPreResetMsgFst; /*预复位首次消息*/
+extern AtsMsgCfmStru g_PhyPreResetCfmFst;			/*预复位首次确认*/
+extern AtsPhyPreResetMsgStru g_PhyPreResetMsgSnd; /*预复位再次消息*/
+extern AtsMsgCfmStru g_PhyPreResetCfmSnd;		    /*预复位再次确认*/
+extern AtsMsgCfmStru g_SndAtsPhyPreResetCfmFst;	/*第二个ATS的预复位首次确认*/
 
 /**
 * @brief 获取远程筛选ATS首次消息
@@ -367,42 +528,42 @@ void ClearAtsWlbMsgFirst(void);
 void ClearAtsWlbMsgSecond(void);
 
 /**
-* @brief 获取ATS取消脱轨防护区首次消息
+* @brief 获取ATS取消列车状态异常防护区域首次消息
 * @param 无
-* @return ATS取消脱轨防护区首次消息
+* @return ATS取消列车状态异常防护区域首次消息
 */
-AtsDaMsgStru * GetAtsDaMsgFst(void);
+AtsDaMsgStru* GetAtsDaMsgFst(void);
 
 /**
-* @brief 获取ATS取消脱轨防护区二次消息
+* @brief 获取ATS取消列车状态异常防护区域二次消息
 * @param 无
-* @return ATS取消脱轨防护区二次消息
+* @return ATS取消列车状态异常防护区域二次消息
 */
-AtsDaMsgStru * GetAtsDaMsgSnd(void);
+AtsDaMsgStru* GetAtsDaMsgSnd(void);
 
 /**
-* @brief 获取ATS取消脱轨防护区首次确认
+* @brief 获取ATS取消列车状态异常防护区域首次确认
 * @param 无
-* @return ATS取消脱轨防护区首次确认
+* @return ATS取消列车状态异常防护区域首次确认
 */
-AtsMsgCfmStru * GetAtsDaCfmFst(void);
+AtsMsgCfmStru* GetAtsDaCfmFst(void);
 
 /**
-* @brief 获取ATS取消脱轨防护区二次确认
+* @brief 获取ATS取消列车状态异常防护区域二次确认
 * @param 无
-* @return ATS取消脱轨防护区二次确认
+* @return ATS取消列车状态异常防护区域二次确认
 */
-AtsMsgCfmStru * GetAtsDaCfmSnd(void);
+AtsMsgCfmStru* GetAtsDaCfmSnd(void);
 
 /**
-* @brief 清除1次ATS取消脱轨防护区信息
+* @brief 清除1次ATS取消列车状态异常防护区域信息
 * @param void
 * @return void
 */
 void ClearAtsDaMsgFirst(void);
 
 /**
-* @brief 清除2次ATS取消脱轨防护区信息
+* @brief 清除2次ATS取消列车状态异常防护区域信息
 * @param void
 * @return void
 */
@@ -449,4 +610,265 @@ void ClearSndAtsWlbFstCfmMsg(void);
 */
 void ClearSndAtsDaFstCfmMsg(void);
 
+/**
+* @brief 清除1次ATS设置/取消全线区段封锁信息
+* @param void
+* @return void
+* @note Created By fan 2025.12.13
+*/
+void ClearAtsAllFlockMsgFirst(void);
+
+/**
+* @brief 清除2次ATS取消全线区段封锁信息
+* @param void
+* @return void
+* @note Created By fan 2025.12.13
+*/
+void ClearAtsAllFlockMsgSecond(void);
+
+/**
+* @brief 获取ATS设置/取消全线区段封锁首次消息
+* @param 无
+* @return ATS设置/取消区间疏散首次消息
+* Created By fan 2025.12.13
+*/
+AtsAllSecFlockMsgStru * GetAtsFlockMsgFst(void);
+/**
+* @brief 获取ATS取消全线区段封锁二次消息
+* @param 无
+* @return ATS取消全线列车紧急制动二次消息
+* Created By fan 2025.12.13
+*/
+AtsAllSecFlockMsgStru * GetAtsFlockMsgSnd(void);
+
+/**
+* @brief 获取ATS设置/取消全线区段封锁首次确认
+* @param 无
+* @return ATS设置/取消全线区段封锁首次确认
+* Created By fan 2025.12.13
+*/
+AtsMsgCfmStru * GetAtsFlockCfmFst(void);
+
+/**
+* @brief 获取ATS取消全线区段封锁二次确认
+* @param 无
+* @return ATS取消全线区段封锁二次确认
+* Created By fan 2025.12.13
+*/
+AtsMsgCfmStru * GetAtsFlockCfmSnd(void);
+
+/**
+* @brief 清除第二个ATS的全线区段封锁一次信息
+* @param 无
+* @return 无
+* @note Created By fan 2025.12.15
+*/
+void ClearSndAtsAllFlockFstCfmMsg(void);
+
+
+/**
+* @brief 清除1次ATS取消全线CESB封锁信息
+* @param void
+* @return void
+* Created By fan 2026.02.04
+*/
+void ClearAtsCesbMsgFirst(void);
+
+/**
+* @brief 清除2次ATS取消全线CESB封锁信息
+* @param void
+* @return void
+* Created By fan 2026.02.04
+*/
+void ClearAtsCesbMsgSecond(void);
+
+/**
+* @brief 获取ATS取消全线CESB封锁首次消息
+* @param 无
+* @return ATS设置/取消区间疏散首次消息
+* Created By fan 2026.02.04
+*/
+AtsCESBCancleMsgStru * GetAtsCesbMsgFst(void);
+/**
+* @brief 获取ATS取消全线CESB封锁二次消息
+* @param 无
+* @return ATS取消全线CESB封锁二次消息
+* Created By fan 2026.02.04
+*/
+AtsCESBCancleMsgStru * GetAtsCesbMsgSnd(void);
+
+/**
+* @brief 获取ATS取消全线CESB封锁首次确认
+* @param 无
+* @return ATS设置/取消全线CESB封锁首次确认
+* Created By fan 2026.02.04
+*/
+AtsMsgCfmStru * GetAtsCesbCfmFst(void);
+
+/**
+* @brief 获取ATS取消全线CESB封锁二次确认
+* @param 无
+* @return ATS取消全线CESB封锁二次确认
+* Created By fan 2026.02.04
+*/
+AtsMsgCfmStru * GetAtsCesbCfmSnd(void);
+
+/**
+* @brief 清除第二个ATS的全线CESB封锁一次信息
+* @param 无
+* @return 无
+* Created By fan 2026.02.04
+*/
+void ClearSndAtsCesbFstCfmMsg(void);
+
+/**
+* @brief 获取ATS全站解封解锁首次消息
+* @param 无
+* @return ATS全站解封解锁首次消息
+* Created By mpt 2026.2.8
+*/
+AtsJieFengJieSuoMsgStru* GetAtsJieFengJieSuoMsgFst(void);
+/**
+* @brief 获取ATS全站解封解锁二次消息
+* @param 无
+* @return ATS全站解封解锁二次消息
+* Created By mpt 2026.2.8
+*/
+AtsJieFengJieSuoMsgStru* GetAtsJieFengJieSuoMsgSnd(void);
+/**
+* @brief 获取ATS全站解封解锁首次确认
+* @param 无
+* @return ATS全站解封解锁首次确认
+* Created By mpt 2026.2.8
+*/
+AtsMsgCfmStru* GetAtsJieFengJieSuoCfmFst(void);
+/**
+* @brief 获取ATS全站解封解锁二次确认
+* @param 无
+* @return ATS全站解封解锁二次确认
+* Created By mpt 2026.2.8
+*/
+AtsMsgCfmStru* GetAtsJieFengJieSuoCfmSnd(void);
+/**
+* @brief 清除ATS全站解封解锁首次消息
+* @param void
+* @return void
+*  Created By mpt 2026.2.8
+*/
+void ClearAtsJieFengJieSuoMsgFirst(void);
+/**
+* @brief 清除ATS全站解封解锁二次消息
+* @param void
+* @return void
+* *Created By mpt 2026.2.8
+*/
+void ClearAtsJieFengJieSuoMsgSecond(void);
+/**
+* @brief 获取ATS道岔强转首次消息
+* @param 无
+* @return ATS道岔强转首次消息
+* Created By mpt 2026.2.8
+*/
+AtsSwitchForceMsgStru* GetAtsSwitchForceMsgFst(void);
+/**
+* @brief 获取ATS道岔强转二次消息
+* @param 无
+* @return ATS道岔强转二次消息
+* Created By mpt 2026.2.8
+*/
+AtsSwitchForceMsgStru* GetAtsSwitchForceMsgSnd(void);
+/**
+* @brief 获取ATS道岔强转首次确认
+* @param 无
+* @return ATS道岔强转首次确认
+* Created By mpt 2026.2.8
+*/
+AtsMsgCfmStru* GetAtsSwitchForceCfmFst(void);
+/**
+* @brief 获取ATS道岔强转二次确认
+* @param 无
+* @return ATS道岔强转二次确认
+* Created By mpt 2026.2.8
+*/
+AtsMsgCfmStru* GetAtsSwitchForceCfmSnd(void);
+/**
+* @brief 清除ATS道岔强转首次消息
+* @param void
+* @return void
+*  Created By mpt 2026.2.8
+*/
+void ClearAtsSwitchForceMsgFirst(void);
+/**
+* @brief 清除ATS道岔强转二次消息
+* @param void
+* @return void
+* *Created By mpt 2026.2.8
+*/
+void ClearAtsSwitchForceMsgSecond(void);
+/**
+* @brief 获取ATS计轴预复位首次消息
+* @param 无
+* @return ATS计轴预复位首次消息
+* Created By mpt 2026.2.8
+*/
+AtsPhyPreResetMsgStru* GetAtsPhyPreResetMsgFst(void);
+/**
+* @brief 获取ATS计轴预复位二次消息
+* @param 无
+* @return ATS计轴预复位二次消息
+* Created By mpt 2026.2.8
+*/
+AtsPhyPreResetMsgStru* GetAtsPhyPreResetMsgSnd(void);
+/**
+* @brief 获取ATS计轴预复位首次确认
+* @param 无
+* @return ATS道岔强转首次确认
+* Created By mpt 2026.2.8
+*/
+AtsMsgCfmStru* GetAtsPhyPreResetCfmFst(void);
+/**
+* @brief 获取ATS计轴预复位二次确认
+* @param 无
+* @return ATS道岔强转二次确认
+* Created By mpt 2026.2.8
+*/
+AtsMsgCfmStru* GetAtsPhyPreResetCfmSnd(void);
+
+/**
+* @brief 清除ATS计轴预复位首次消息
+* @param void
+* @return void
+*  Created By mpt 2026.2.8
+*/
+void ClearAtsPhyPreResetMsgFirst(void);
+/**
+* @brief 清除ATS计轴预复位二次消息
+* @param void
+* @return void
+* *Created By mpt 2026.2.8
+*/
+void ClearAtsPhyPreResetMsgSecond(void);
+/**
+* @brief 清除第二个ATS全站解封解锁一次信息
+* @param 无
+* @return 无
+* *Created By mpt 2026.2.8
+*/
+void ClearSndAtsJieFengJieSuoCfmMsg(void);
+/**
+* @brief 清除第二个ATS道岔强转一次信息
+* @param 无
+* @return 无
+* *Created By mpt 2026.2.8
+*/
+void ClearSndAtsSwitchForceCfmMsg(void);
+/**
+* @brief 清除第二个ATS计轴复位一次信息
+* @param 无
+* @return 无
+* *Created By mpt 2026.2.8
+*/
+void ClearSndAtsPhyPreResetCfmMsg(void);
+
+
 #endif

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

@@ -237,7 +237,11 @@ UINT8 ParseOtherSysToCiData(void)
 				if (ocId == chLocalCiId)/*如果oc id所属的ci id为本机联锁id*/
 				{
 					oc2ciParseResult = ParseOcToCiDataFrame(data, (UINT16)dataLen, devId);
-					if (CI_CHECK_LEN_ERROR == oc2ciParseResult)
+					if (CI_ERROR == oc2ciParseResult)
+					{
+						/*解析OC数据错误处理，这个错误已经处理，连续10个周期，会通信中断，导向安全*/
+					}
+					else if (CI_CHECK_LEN_ERROR == oc2ciParseResult)
 					{
 						/*长度校验错误处理，把此OC原始缓存所有设备状态导向安全*/
 						/* 长度校验失败处理：
@@ -257,11 +261,7 @@ UINT8 ParseOtherSysToCiData(void)
 					}
 					else
 					{
-						/*其它值，清除缓存数据*/
+						/*其它值，什么也不做*/
-						ResetOcOriginalState(devId);
-						ConvertOcOriginDataToPtData();/*把解析的OC板卡数据转换为OC点位数据*/
-						ConvertOcOriginDataToOcSigSwDev();/*把解析的OC设备数据转换为OC 信号机和 OC 道岔设备数据和OC轨道区段数据*/
-						debug_infor_printf((const)"OC Id %d parse ERROR.", devId);
 					}
 				}
 				else
@@ -1010,12 +1010,9 @@ UINT8 PackCiToOtherSysData(void)
 	}
 	else
 	{
-		/*不处理*/
+		PackCiToVobcFlyProtectData();  /*组飞车特控报文*/
 	}
 	
-	/*组飞车特控报文*/
-	PackCiToVobcFlyProtectData();
-	
 #ifdef APPCI_MAINTAIN_DEBUG
 #ifdef PLATFORM_2OO2
 	/*cgh-合并CID-2349-1：*/
@@ -1040,6 +1037,8 @@ UINT8 PackCiToOtherSysData(void)
 	PackCiToCimFlyProtectData();
 	/*发送维护机IO双系采集不一致报警*/
 	PackCiToCimCollDiffData();
+	/*发送维护机接触网供电状态报警*/
+	PackCiToCimOHLData();
 	/*发送给AIM退出运营信息*/
 	AIMOutput();
 	/*发送给维护机执行单元报警信息*/

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

@@ -1194,22 +1194,6 @@ void ResetOcOriginalState(const UINT8 ocId)
 		}
 
 		SetOcToCiDefaultDataStru(toFindIndex);/*置屏蔽门信息为安全侧*/
-
-		m_OcToCiOrginDataArr[toFindIndex].PowerAState = (UINT8)0xff;
-		m_OcToCiOrginDataArr[toFindIndex].PowerBState = (UINT8)0xff;
-		m_OcToCiOrginDataArr[toFindIndex].OCDevFaultState = (UINT8)0xff;
-		m_OcToCiOrginDataArr[toFindIndex].FanState = (UINT8)0xff;
-
-		for (ii = 0u; ii < m_OcToCiOrginDataArr[toFindIndex].OCBoardSwapSysNum; ii++)
-		{
-			m_OcToCiOrginDataArr[toFindIndex].SwapSysBoardId[ii] = 0U;
-		}
-		m_OcToCiOrginDataArr[toFindIndex].OCBoardSwapSysNum = 0U;
-
-		CommonMemSet(m_OcToCiOrginDataArr[toFindIndex].szPlusBox, (UINT32)(MAX_OC_PLUS_BOX_NUM)*(sizeof(OcPlusBox)), 0U, (UINT32)(MAX_OC_PLUS_BOX_NUM*(sizeof(OcPlusBox))));
-		m_OcToCiOrginDataArr[toFindIndex].chPbNum = 0U;
-
-		SetAllCleFarePCBButKeepSta(m_OcToCiOrginDataArr[toFindIndex].OcId, QK_PSD_BUTTON_STATE_UP);
 	}
 }
 
@@ -1357,6 +1341,10 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 				
 				pTmpOcToCiData->OcId = systemId; /*oc id赋值*/
 
+				pTmpOcToCiData->ComStartCycle = Get2oo2CurCycleNum();/*保存收到OC数据时的通信开始周期*/
+
+				debug_infor_printf((const)"\nId:%d OC_COM:%d\n",pTmpOcToCiData->OcId,pTmpOcToCiData->ComStartCycle);
+
 				if (OC_CI_STATE_INFO == appInfoType)/*OC给CI的状态信息 0x8802*/
 				{
 					/*by cgh 20230831 增加转辙机状态接口*/
@@ -1930,10 +1918,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 					SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_OC, systemId, hlhtGalHead.preOwnMsgSN);
 					SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_OC, systemId, curntCycleNo);
 					
-					/*解析通过 更新通信周期*/
-					pTmpOcToCiData->ComStartCycle = Get2oo2CurCycleNum();/*保存收到OC数据时的通信开始周期*/
-					debug_infor_printf((const)"\nId:%d OC_COM:%d\n", pTmpOcToCiData->OcId, pTmpOcToCiData->ComStartCycle);
-					
 					if(findFlag ==0u) /*如果需要更新的oc索引没找到，则认为这包数据是新的oc数据,需要增加oc总数量*/
 					{
 						m_OcToCiOrginDataNum++;
@@ -2700,46 +2684,9 @@ UINT16 GetKqChangeCommand(void)
 }
 
 
-/*
+
-* 功能描述： 获取点位采集容忍起始周期
+
-* 参数说明： const UINT16 ocId, OC ID
+
-*			 const UINT8 boardNum, 板卡ID
-*			 const UINT8 pointNum，点位ID
-* 返回值  ： UINT32 采集容忍起始周期
-*/
-UINT32 GetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum)
-{
-	UINT32 retVal = CI_ERROR;
-
-	if ((OC_SUM_MAX > ocId) && (Oc_Max_Board_Num > boardNum) && (OC_COLL_BOARD_POS_NUM > pointNum))
-	{
-		retVal = m_OcConvertedPtDataArr[ocId].BoardDatas[boardNum].TolerateCycNum[pointNum];
-	}
-	else
-	{/*不处理*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述： 设置道岔采集容忍起始周期
-* 参数说明： const UINT16 ocId, OC ID
-*			 const UINT8 boardNum, 板卡ID
-*			 const UINT8 pointNum，点位ID
-*            const UINT32 cycNum 周期号
-* 返回值  ： 无
-*/
-void SetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum, const UINT32 cycNum)
-{
-	if ((OC_SUM_MAX > ocId) && (Oc_Max_Board_Num > boardNum) && (OC_COLL_BOARD_POS_NUM > pointNum))
-	{
-		m_OcConvertedPtDataArr[ocId].BoardDatas[boardNum].TolerateCycNum[pointNum] = cycNum;
-	}
-	else
-	{/*不处理*/
-	}
-}
 
 
 

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

@@ -196,7 +196,6 @@ typedef struct S_OcBoardDataStruct1
 	UINT8 BoardAddress;  /*板子地址*/
 	UINT8 BoardState;	/*板卡状态，0x55：正常，0xaa：故障*/
 	UINT8 PosValueBuf[OC_COLL_BOARD_POS_NUM];  /*板子各位置数据*/
-	UINT32 TolerateCycNum[OC_COLL_BOARD_POS_NUM];/*板子各位置容忍周期*/
 }CollBoardData;
 
 typedef struct S_OcCollBoardDataStruct
@@ -461,23 +460,6 @@ void SetOcToCiDefaultDataStru(UINT8 index);
 */
 UINT16 GetKqChangeCommand(void);
 
-/*
-* 功能描述： 获取点位采集容忍起始周期
-* 参数说明： const UINT16 switchId, 道岔ID
-* 返回值  ： UINT32 采集容忍起始周期
-*/
-UINT32 GetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum);
-
-/*
-* 功能描述： 设置道岔采集容忍起始周期
-* 参数说明： const UINT16 ocId, OC ID
-*			 const UINT8 boardNum, 板卡ID
-*			 const UINT8 pointNum，点位ID
-*            const UINT32 cycNum 周期号
-* 返回值  ： 无
-*/
-void SetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum, const UINT32 cycNum);
-
 #ifdef __cplusplus
 }
 #endif

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

@@ -42,8 +42,6 @@ UINT8 InitialPscToCiData(void)
 	UINT16 psdId = 0u;
 	UINT8 pscId = 0u;
 	UINT8 deviceSum =0u;/*通信设备总数*/
-	UINT8* deviceIdBuf = NULL;/*通信设备ID数组*/
-	UINT8 psdSum = (UINT8)PSC_INCLUDE_PSD_MAX_SUM;
 	UINT8 retVal = CI_SUCCESS;
 	PscConfigDataStruct *pPSC = NULL;
 	deviceSum = (UINT8)GetPscCurSum();     /*获取通信PSC设备总数*/
@@ -245,7 +243,6 @@ UINT8 ParsePscToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const
 */
 UINT8 PackCiToPscData(UINT8 deviceId)
 {
-	UINT8 localCi = GetSystemParaLocalCiId();                    /*本地联锁ID*/
 	UINT8 CiToPscDataBuffer[PSC_TO_CI_DATA_LEN_MAX] = {0u};       /*CI到PSC组帧数组*/
 	UINT16 devCurSum = 0u;  /*设备总数*/
 	UINT16 devId = 0u; /*设备ID*/

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

@@ -24,6 +24,8 @@
 #include "SectionDefine.h"
 #include "LogicSectionDataManage.h"
 #include "WholeLineScreenAPI.h"
+#include "SpeedLimitSecDataManage.h"
+#include "SpeedLimitSecConfigDataManage.h"
 
 #define TIOC_TMC_PRTCL_VER			 ((UINT8)0x01u)			 /*TIOC-TMC协议版本号*/
 #define TIOC_TMC_INTERFACE_INFOTYPE  ((UINT16)0x0101u)		 /*TIOC-TMC接口信息类型*/
@@ -43,18 +45,27 @@
 #define TIOC_TO_TMC_LINECT_MSG  ((UINT16)0x0109U)		 /*TIOC发送TMC全线通信车信息类型*/
 #define TMC_TO_TIOC_LINECT_MSG  ((UINT16)0x010AU)		 /*TMC发送TIOC全线通信车信息类型*/
 
+#define TIOC_TO_TMC_ACCEL_MSG  ((UINT16)0x010BU)		 /*RC发送TMC牵引加速度信息类型*/
+#define TMC_TO_TIOC_ACCEL_MSG  ((UINT16)0x010CU)		 /*TMC发送RC牵引加速度信息类型*/
+
+#define TIOC_TO_TMC_BRAKE_MSG  ((UINT16)0x010DU)		 /*RC发送TMC制动率信息类型*/
+#define TMC_TO_TIOC_BRAKE_MSG  ((UINT16)0x010EU)		 /*TMC发送RC制动率信息类型*/
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+
 /*临时限速输入缓冲结构体*/
 typedef struct S_TsrInputInfoStruct
 {
-	UINT8 cTsrValidFlag;	/* 临时限速有效标志：0x55：信息有些；0xAA：信息无效 */
+	UINT8 cTsrValidFlag;	/* 临时限速有效标志：0x55：信息有效；0xAA：信息无效 */
 	UINT8 cAllLineTsrState;	/* 全线临时限速状态 */
 	UINT8 cAllLineTsrSpeed;	/* 全线临时限速速度 */
 	UINT8 cTsrSum;			/* 限速数量 */
-	TsrDataStruct szTsrInfo[TSR_MAX_SUM]; /* 限速信息 */
+	TsrDataStruct szTsrInfo[TSR_MAX_SUM]; /* ZC限速信息 */
+	TsrTMCDataStruct tmcTsrInfo[TSR_MAX_SUM]; /*TMC限速信息*/
+	TyphoonSpeedDataStruct tsdsInputInfoStru;/* 台风限速信息 */
 } TsrInputInfoStruct;
 
 /*TMC->TIOC缓冲数据*/
@@ -70,6 +81,14 @@ typedef struct S_TmcToTiocDataStruct
 	UINT16 szAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*区间ITE切除ID数组*/
 	UINT8 cLineCtNum;  /*全线通信车数量*/
 	UINT16 szLineCtId[TRAIN_SUM_MAX];  /*全线通信车ID数组*/
+	UINT8 cAllLineAccelerationState;  /*全线牵引加速度设置状态：0x55-未设置；0xAA-已设置*/
+	UINT8 cAllLineAccelerationValue;  /*全线牵引加速度设置值*/
+	UINT8 cAllLineBrakeRateState;  /*全线制动率设置状态：0x55-未设置；0xAA-已设置*/
+	UINT8 cAllLineBrakeRateValue;  /*全线制动率设置值*/
+	UINT8 cAreaAccelerationNum;  /*区间牵引加速度数量*/
+	AreaAccelerationInfoStruct szAreaAccelerationInfo[LOCAL_AREA_SNOW_SUM_MAX];  /*区间牵引加速度数组*/
+	UINT8 cAreaBrakeRateNum;  /*区间制动率数量*/
+	AreaBrakeRateInfoStruct szAreaBrakeRateInfo[LOCAL_AREA_SNOW_SUM_MAX];  /*区间制动率数组*/
 } TmcToTiocDataStruct;
 
 /*
@@ -101,6 +120,45 @@ extern TmcToTiocDataStruct* GetTmcToTiocData(void);
 * 功能描述：清除TMC输入数据
 */
 extern void ClearTmcToTiocData(void);
+
+/*
+* 功能描述：解析牵引加速度信息
+* 参数说明：const UINT8* dataBuf, 数据缓冲区
+*           const UINT16 dataLength, 数据长度
+* 返 回 值：CI_ERROR 0 数据解析失败
+*			CI_SUCCESS 1 数据解析成功
+* Created By LQ 2026.02.04
+*/
+UINT8 ParseAccelerationData(UINT8* dataBuf, UINT16 dataLen);
+
+/*
+* 功能描述：组TMC牵引加速度数据
+* 参数说明：UINT8* TiocToTmcDataBuffer 数据地址
+* 返 回 值：0 组数据失败
+*			其他 整包数据长度
+* Created By LQ 2026.02.04
+*/
+UINT16 PackToTMCAccelerationData(UINT8* TiocToTmcDataBuffer);
+
+/*
+* 功能描述：解析制动率信息
+* 参数说明：const UINT8* dataBuf 数据缓冲区
+*           const UINT16 dataLength 数据长度
+* 返 回 值：CI_ERROR 0 数据解析失败
+*			CI_SUCCESS 1 数据解析成功
+* Created By LQ 2026.02.04
+*/
+UINT8 ParseBrakeRateData(UINT8* dataBuf, UINT16 dataLen);
+
+/*
+* 功能描述：组TMC制动率数据
+* 参数说明：UINT8* TiocToTmcDataBuffer 数据地址
+* 返 回 值：0 组数据失败
+*			其他 整包数据长度
+* Created By LQ 2026.02.04
+*/
+UINT16 PackToTMCBrakeRateData(UINT8* TiocToTmcDataBuffer);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -202,6 +202,7 @@
 #define CI_IVOC_FLOODGATE_APPLY_SUM		((UINT16)50U)		  /*CI到IVOC 防淹门关闭请求最大数量*/
 #define CI_IVOC_PACKET_LENGTH_MAX		((UINT16)1400U)		  /*CI到IVOC 包长度数量最大值*/
 #define TRAIN_TOPLATFORM_LOG_SUM		((UINT16)1000U)		  /*列车到站台的逻辑区段最大数量*/
+#define  CI_IVOC_FLOCK_LOG_SUM		((UINT16)1000U)		  /*CI到IVOC封锁的逻辑区段最大数量*/
 
 #define CI_IVOC_LOGSEC_JUMPLOCK_YES		((UINT8)0x55U)		  /*CI到IVOC 逻辑区段跳跃锁闭已锁闭*/
 #define CI_IVOC_LOGSEC_JUMPLOCK_NO		((UINT8)0xaaU)		  /*CI到IVOC 逻辑区段跳跃锁闭未锁闭*/
@@ -343,6 +344,8 @@ typedef struct S_VobcToCiDataStruct
 	UINT8 chRrmReq;											/*远程RM申请*/
 	UINT16 wNextStation;									/*下一站*/
 	UINT8 chDerailment;										/*脱轨状态*/
+	UINT8 chIntegrityState;							        /*完整性状态*/
+	UINT8 chEscapeDoorState;								/*逃生门状态*/
 
 	UINT8 chVideoQkState;                                   /*视频清客状态*/
 	UINT8 chVideoQkResult;                                  /*视频清客结果*/
@@ -696,14 +699,6 @@ UINT8 ParseFAOHLHTBackUpControlData(UINT8* dataBuf, UINT16 dataLen, VobcToCiData
 */
 void PackCiToVobcFlyProtectData(void);
 
-/*
-* 功能描述：组RC到车载飞车宕机信息
-* 参数说明：const UINT16 wTrainId 列车ID
-* 返 回 值：无
-* Created By LQ 2025.09.15
-*/
-void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId);
-
 /*
 * 功能描述：组包Ci到Ivoc的向后跳跃申请回复
 * 参数说明： UINT8* dataBuf, 数据缓冲区
@@ -714,6 +709,28 @@ void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId);
 * Create： fan 20250725
 */
 UINT8 PackCiToIvocJumpBackReply(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
+
+/*
+* 功能描述：组包Ci到Ivoc的逻辑区段禁止FAO运行信息
+* 参数说明： UINT8* dataBuf, 数据缓冲区
+*            UINT16 *dataLength, 数据长度 输出参数
+*			 UINT16 wTrainId 列车ID
+* 返 回 值：CI_ERROR 0 失败
+*			CI_SUCCESS 1 成功
+* Create： fan 20250725
+*/
+UINT8 PackCiToIvocProhibitFAO(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
+
+/*
+* 功能描述： 组包Ci到Ivoc牵引加速度和制动率信息
+* 参数说明： UINT8* pDataBuf 数据缓冲区(输出参数)
+*            UINT16 *pDataLength 数据长度(输出参数)
+* 返回值  ： CI_ERROR 0 失败
+*			 CI_SUCCESS 1 成功
+* Created By LQ 2026.02.05
+*/
+UINT8 PackCiToIvocAccAndBrakeInfo(UINT8* pDataBuf, UINT16* pDataLength);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/QueryFiles/CiConfigData.h

@@ -45,6 +45,7 @@
 #include "../DiffLineDev/DiffLineDevConfigDataManage.h"
 #include "../VirtualDevice/VirtualDevDataManage.h"
 #include "../DataManage/DeviceConfigDataManage.h"
+#include "../OHL/OHLConfigDataManage.h"
 
 #endif
 

TSCP/src/APP/ciapp/QueryFiles/dquCIInit.c

@@ -69,6 +69,14 @@ void SetGardoorphySecData(GaragedoorConfigDataStruct* pGaragedoorCfgDtStr, UINT1
 UINT8 SetSignalVirtualAttr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct* pSgnlCfgDtStr);
 UINT8 SetSignalCrossCloseAttr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct* pSgnlCfgDtStr);
 
+/*********************************************
+*函数功能：根据电子地图中信号机属性设置信号机终端阻挡属性
+*参数说明：pSgnl是DSU信号机数据结构指针
+*          pSgnlCfgDtStr，信号机配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+static UINT8 SetSignalEndAttr(DSU_SIGNAL_STRU* pSgnl, SignalConfigDataStruct* pSgnlCfgDtStr);
+
 /*********************************************
 *函数功能：从点式临时限速配置数据（计轴区段）表到点式临时限速配置结构(逻辑区段)的转换
 *参数说明：pDquOutStationSigStrRef 点式临时限速配置数据结构体指针
@@ -347,6 +355,28 @@ UINT8 RelayInit(CHAR* FSName)
 		debug_infor_printf((const)"MenJinConfigDataStructInit fail.\r\n");
 	}
 
+	/*SSKS闪灯稳灯继电器初始化*/
+	funcRtn *= SSksLightRelayCfgDataStrInit(FSName);
+	if (0u == funcRtn)
+	{
+		debug_infor_printf((const)"SSksLightRelayCfgDataStrInit fail.\r\n");
+	}
+	else
+	{
+		/*继续*/
+	}
+
+	/*联络线旁路继电器初始化*/
+	funcRtn *= ConnectOverrideCfgDataStrInit(FSName);
+	if (0u == funcRtn)
+	{
+		debug_infor_printf((const)"ConnectOverrideCfgDataStrInit fail.\r\n");
+	}
+	else
+	{
+		/*继续*/
+	}
+
 	/*防淹门*/
 	funcRtn *= FloodGateConfigDataStructInit(FSName);
 	if (0u == funcRtn)
@@ -386,6 +416,31 @@ UINT8 RelayInit(CHAR* FSName)
 		}
 	}
 	
+	/*接触网*/
+	funcRtn *= OhlConfigDataStructInit(FSName);
+	if (0u == funcRtn)
+	{
+		debug_infor_printf((const)"OhlConfigDataStructInit fail.\r\n");
+	}
+
+	/*ECS初始化*/
+	funcRtn *= EcsConfigDataStructInit(FSName);
+	if (0U == funcRtn)
+	{
+		debug_infor_printf((const)"EcsConfigDataStructInit fail.\r\n");
+	}
+	else
+	{
+		/*继续初始化*/
+	}
+
+	/*初始全线化紧急停车按钮接口配置数据结构体----对外结构体*/
+	funcRtn *= CesbConfigDataStructInit(FSName);
+	if (0u == funcRtn)
+	{
+		debug_infor_printf((const)"CesbConfigDataStructInit fail.\r\n");
+	}
+
 	/********************************************************************************
 										联锁表数据内容计算
 	*********************************************************************************/
@@ -722,8 +777,6 @@ UINT8 SystemParameterStructInit(CHAR* FSName)
 					/*对向行驶双车间隔最小安全距离(cm)*/
 					dquCICfgDtStr.SystemParaStrNew.OppositeTrackDistance = pCbtcConfigDataStru.OppositeTrackDistance;
 
-					/*站台追踪时，列车间隔距离（cm）*/
-					dquCICfgDtStr.SystemParaStrNew.StationTrackDistance = pCbtcConfigDataStru.StationTrackDistance;
 
 					/*线路最差情况下紧急制动距离（单位m）*/
 					dquCICfgDtStr.SystemParaStrNew.MaxMALength = pCbtcConfigDataStru.MaxMALength;
@@ -1140,7 +1193,7 @@ UINT8 SglCfgDtStruFromDquSignalStr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct
 	UINT16 ocIdBuff = 0u;
 	UINT16 indexAc = 0U;
 	UINT8 railwayType = CI_TRADITION_RAILWAY;
-
+	UINT8 chDsnLinSwitch = 0u;
 	/*入口参数防护*/
 	if((NULL == pSgnl) || (NULL == pSgnlCfgDtStr))
 	{
@@ -1255,7 +1308,15 @@ UINT8 SglCfgDtStruFromDquSignalStr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct
 				pSgnlCfgDtStr->RepLxRelayId = (RelayData.pRelaySignalStr+i)->wRepRelayTrainSignalId;
 				pSgnlCfgDtStr->DetainDriveRelayId = (RelayData.pRelaySignalStr+i)->wRelayDriveDetainId;
 				pSgnlCfgDtStr->detainRelayId = (RelayData.pRelaySignalStr+i)->wRelayCollDetainId;
-				pSgnlCfgDtStr->SignalType = (UINT8)((RelayData.pRelaySignalStr+i)->wSignalDrvColType);
+				chDsnLinSwitch = GetCiFunctionSwitchConfig(FUNC_DSN_LINE_SWITCH);
+				if (FUNC_SWITCH_ON == chDsnLinSwitch)
+				{
+					pSgnlCfgDtStr->SignalType = SIGNAL_TYPE_2_ALL_NOYINDAO_DSN;
+				}
+				else
+				{
+					pSgnlCfgDtStr->SignalType = (UINT8)((RelayData.pRelaySignalStr + i)->wSignalDrvColType);
+				}
 				pSgnlCfgDtStr->detainRelayId = (RelayData.pRelaySignalStr + i)->DetainBtnCollRelayId;
 				pSgnlCfgDtStr->detainCutRelayId = (RelayData.pRelaySignalStr + i)->DetainCutBtnRelayId;
 				pSgnlCfgDtStr->detainDisplayRelayId = (RelayData.pRelaySignalStr + i)->DetainBtnIndicatorRelayId;
@@ -1288,9 +1349,14 @@ UINT8 SglCfgDtStruFromDquSignalStr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct
 		rtnvalue &= SetSignalVirtualAttr(pSgnl,pSgnlCfgDtStr);/*根据电子地图中信号机属性设置信号机虚拟属性*/
 		rtnvalue &= SetSignalCrossCloseAttr(pSgnl,pSgnlCfgDtStr);/*根据电子地图中信号机属性设置信号机调车跨压关灯属性*/
 		rtnvalue &= SetSignalFenDuanAttr(pSgnl, pSgnlCfgDtStr);/*根据电子地图中信号机属性设置信号机分段属性*/
+		rtnvalue &= SetSignalEndAttr(pSgnl, pSgnlCfgDtStr);/*根据电子地图中信号机属性设置信号机端点属性*/
 
 		if (1U == rtnvalue)
 		{
+			/*根据电子地图中信号机属性设置信号机联络线属性*/
+			pSgnlCfgDtStr->DsnConnectAttr = 
+				(0x55u == dsuStaticHeadStru.pLinkStru[dsuLinkIndex[pSgnl->wProtectLinkId]].cDisneyConnectAttr) 
+				? SIGNAL_CONNECT_TRUE : SIGNAL_CONNECT_FALSE;
 			pSgnlCfgDtStr->wProtectLinkId = pSgnl->wProtectLinkId;
 			pSgnlCfgDtStr->dwProtectOff = pSgnl->dwProtectLinkOfst;
 			pSgnlCfgDtStr->chShineSignal = (UINT8)pSgnl->wShineSignal;
@@ -1752,6 +1818,8 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru
 	pSwitchCfgDtStr->DsQRelayId = 0u;
 	pSwitchCfgDtStr->DsHRelayId = 0u;
 	pSwitchCfgDtStr->ByPassRelayId = 0u;
+	pSwitchCfgDtStr->RwmRelayId = 0u;
+	pSwitchCfgDtStr->EnableBypassRelayId = 0u;
 	for(j=0u;j<RelayDataLen.RelayPointStrLen;j++)
 	{
 		if(pPoint->wId==(RelayData.pRelayPointStr+j)->wPointId)
@@ -1766,6 +1834,8 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru
 			pSwitchCfgDtStr->DFHRelayId = (RelayData.pRelayPointStr+j)->wDFHId;
 			pSwitchCfgDtStr->wShadowDbRelayId = (RelayData.pRelayPointStr + j)->wRelayShadowDingBiaoId;
 			pSwitchCfgDtStr->wShadowFbRelayId = (RelayData.pRelayPointStr + j)->wRelayShadowFanBiaoId;
+			pSwitchCfgDtStr->wExtraPhySecId = (RelayData.pRelayPointStr + j)->wExtraPhySecId;
+			pSwitchCfgDtStr->chNormalPos = (RelayData.pRelayPointStr + j)->chNormalPos;
 			if (pSwitchCfgDtStr->SwitchId>0u)
 			{
 				if (0u == pSwitchCfgDtStr->DbRelayId)
@@ -2472,6 +2542,34 @@ UINT8 LogicSecCfgDtStruFromDquSgmtStr(DSU_LOGIC_SGMT_STRU* pLogicSgmt,LogicSecti
 			/*存在link不具有CBTC区域属性，则逻辑区段不具有CBTC区域属性*/
 		}
 
+		pLgScCfgDtStr->chDisneyConnectAttr = LOGSEC_CONNECT_PROPERTY_NO; /*逻辑区段联络线区域属性*/
+
+		/*遍历逻辑区段包含的link，确定逻辑区段的联络线属性*/
+		for (kk = 0U; kk < pLgScCfgDtStr->chLinkNum; kk++)
+		{
+			pLogSecIncLinkStru = dsuStaticHeadStru.pLinkStru + dsuLinkIndex[pLgScCfgDtStr->szLinkIdBuff[kk]];
+			if (0x55U != pLogSecIncLinkStru->cDisneyConnectAttr)
+			{
+				break;  /*link不具有联络线属性，停止遍历*/
+			}
+			else
+			{
+				/*link具有联络线区域属性，继续遍历*/
+			}
+		}
+
+		if ((kk == pLgScCfgDtStr->chLinkNum) && (0U != kk))
+		{
+			pLgScCfgDtStr->chDisneyConnectAttr = LOGSEC_CONNECT_PROPERTY_YES;  /*所有link均具有联络线区域属性，则逻辑区段具有联络线区域属性*/
+		}
+		else
+		{
+			/*存在link不具有联络线区域属性，则逻辑区段不具有联络线区域属性*/
+		}
+
+		/*关联联络线道岔ID暂初始化为0*/
+		pLgScCfgDtStr->wConnectSwticthId = 0u;
+
 		pLgScCfgDtStr->chLogLtrlDfncSwitchSum = 0u;
 		for (ii = 0u; ii < LSDataLen.LSLgcSecLtrlDfncStruLen; ii++)
 		{   /*遍历逻辑区段的侧防道岔表*/
@@ -3103,7 +3201,9 @@ UINT8 LogicSecCfgDtStruFromDquSgmtStr(DSU_LOGIC_SGMT_STRU* pLogicSgmt,LogicSecti
 			}
 		}
 
-		
+		/*关联联络线继电器ID暂初始化为0xFFFF*/
+		pLgScCfgDtStr->wRelSecDirLockRelayId = 0xFFFFu;
+		pLgScCfgDtStr->wRelRoutePrtlRelayId = 0xFFFFu;
 	}
 	else
 	{
@@ -3481,6 +3581,7 @@ UINT8 EsbCfgDtStruFromDquEmergStr(DSU_EMERG_STOP_STRU * pEmergStop,EsbConfigData
 	}
 
 	pEsbCfgDtStr->EsbId = pEmergStop->wId;
+	pEsbCfgDtStr->wRelateLink = pEmergStop->wRelatLkId;
 	rtnvalue = GetDsuLinkIndexNum(pEmergStop->wRelatLkId,&Linkindex);
 	if(CI_SUCCESS == rtnvalue)
 	{
@@ -3531,6 +3632,38 @@ UINT8 EsbCfgDtStruFromDquEmergStr(DSU_EMERG_STOP_STRU * pEmergStop,EsbConfigData
 	return rtnvalue;
 }
 
+/*********************************************
+*函数功能：全线紧急停车按钮接口数据结构体
+*参数说明：pRelayCesb继电器结构体指针
+pCesbCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 CesbCfgDtStruFromRelayData(Relay_CesbStruct*pRelayCesb,CesbConfigDataStruct* pCesbCfgDtStr)
+{
+	UINT8 rtnvalue = 0u;
+	/*入口参数防护*/
+	if ((NULL == pRelayCesb) || (NULL == pCesbCfgDtStr))
+	{
+		/*返回失败*/
+		rtnvalue = 0U;
+	}
+	else
+	{
+		pCesbCfgDtStr->wCesbId = pRelayCesb->wCesbBtnId;
+		pCesbCfgDtStr->wCesbCutRelayId = pRelayCesb->wCesbCutRelayId;
+		pCesbCfgDtStr->wCesbRelayId = pRelayCesb->wCesbRelayId;
+		pCesbCfgDtStr->BelongCiId = (UINT8)GetCiIdByOcId(pRelayCesb->wOcId);
+		if (0U == pCesbCfgDtStr->BelongCiId)
+		{
+			rtnvalue = 0U;
+		}
+		else
+		{
+			rtnvalue = 1U;
+		}
+	}	
+	return rtnvalue;
+}
 
 /*********************************************
 *函数功能：初始化紧急停车按钮接口配置数据结构体----对外结构体
@@ -3575,6 +3708,54 @@ UINT8 EsbConfigDataStructInit(CHAR * FSName)
 	return rtnvalue;
 }
 
+/*********************************************
+*函数功能：初始化全线紧急停车按钮接口配置数据结构体----对外结构体
+*参数说明：FSName文件指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 CesbConfigDataStructInit(CHAR * FSName)
+{
+	UINT8 rtnvalue = 0u;
+	UINT8 callFun = 0u;
+	UINT16 i = 0u;
+	callFun = InitRelay_CESBStru(FSName);
+	/*电子地图初始化失败，函数失败退出*/
+	if (0U == callFun)
+	{
+		rtnvalue = 0U;
+	}
+	else
+	{
+		rtnvalue = 1U;
+	}
+
+	if (1U == rtnvalue)
+	{
+		dquCICfgDtStr.CesbCfgDtStrLen = RelayDataLen.RelayCesbStrLen; 
+		if ((0U < dquCICfgDtStr.CesbCfgDtStrLen) && (NULL != RelayData.pCentreEsbStr))
+		{
+			for (i = 0u; i < dquCICfgDtStr.CesbCfgDtStrLen; i++)
+			{
+				if (i >= CI_SUM_MAX)
+				{
+					/*全线紧急制动按钮个数不大于集中区数量*/
+					rtnvalue = 0u;
+					debug_infor_printf((const)"CesbConfigDataStructInit fail. Sum Max:%d \n", CI_SUM_MAX);
+				}
+				else
+				{
+					rtnvalue &= CesbCfgDtStruFromRelayData(RelayData.pCentreEsbStr + i, &dquCICfgDtStr.CesbCfgDtStr[i]);
+				}
+				if (0u == rtnvalue)
+				{
+					break;
+				}
+			}
+		}
+	}
+	return rtnvalue;
+}
+
 
 
 /*********************************************
@@ -4734,6 +4915,7 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
 	DSU_LINK_STRU* pRouteIncLinkStru = NULL;  /*进路包含的link结构体*/
 	DSU_LINK_STRU * pRouteFirstLinkStru = NULL;
 	DSU_LINK_STRU * pRouteSecondLinkStru = NULL;
+	DSU_LINK_STRU * pRouteEndLinkStru = NULL;
 	UINT16 zCPhySecId= 0u;
 	UINT8 checkResult = 0u;
 	UINT16 signalIndex = 0u;
@@ -5435,6 +5617,59 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
 		else
 		{
 		}
+
+		if (CI_SUCCESS == rtnvalue)
+		{
+			/*进路迪士尼联络线属性处理*/
+			/*翻转防护*/
+			if (0u < pDsuRouteStr->wIncludeLinkNum)
+			{
+				/*初始化为全部属于本线*/
+				pRouteCfgDtStr->cDisneyConnectRouteAttr = ROUTE_DISNEY_CONNECT_ALLMINE;
+				/*获取进路第一个LINK结构体*/
+				pRouteFirstLinkStru = dsuStaticHeadStru.pLinkStru + dsuLinkIndex[pDsuRouteStr->wLinkId[0]];
+				/*获取进路最后一个LINK结构体*/
+				pRouteEndLinkStru = dsuStaticHeadStru.pLinkStru + dsuLinkIndex[pDsuRouteStr->wLinkId[pDsuRouteStr->wIncludeLinkNum - 1u]];
+				if ((0x55u == pRouteFirstLinkStru->cDisneyConnectAttr) && (0x55u == pRouteEndLinkStru->cDisneyConnectAttr))
+				{
+					/*进路完全属于邻线*/
+					pRouteCfgDtStr->cDisneyConnectRouteAttr = ROUTE_DISNEY_CONNECT_ALLOTHER;
+				}
+				else if ((0x55u == pRouteFirstLinkStru->cDisneyConnectAttr) && (0xFFu == pRouteEndLinkStru->cDisneyConnectAttr))
+				{
+					/*进路后半段属于本线*/
+					pRouteCfgDtStr->cDisneyConnectRouteAttr = ROUTE_DISNEY_CONNECT_ENDMINE;
+				}
+				else if ((0xFFu == pRouteFirstLinkStru->cDisneyConnectAttr) && (0x55u == pRouteEndLinkStru->cDisneyConnectAttr))
+				{
+					/*进路前半段属于本线*/
+					pRouteCfgDtStr->cDisneyConnectRouteAttr = ROUTE_DISNEY_CONNECT_STARTMINE;
+				}
+				else if ((0xFFu == pRouteFirstLinkStru->cDisneyConnectAttr) && (0xFFu == pRouteEndLinkStru->cDisneyConnectAttr))
+				{
+					/*进路前半段属于本线*/
+					pRouteCfgDtStr->cDisneyConnectRouteAttr = ROUTE_DISNEY_CONNECT_ALLMINE;
+				}
+				else
+				{
+					/*数据配置有误*/
+					rtnvalue = CI_ERROR;
+				}
+			}
+			else
+			{
+				/*数据初始化有误*/
+				rtnvalue = CI_ERROR;
+			}
+
+			/*迪士尼联络线关联关键道岔，暂赋值为0，初始化联络线继电器时再处理*/
+			pRouteCfgDtStr->wRelConnectSwitchId = 0u;
+		}
+		else
+		{
+			/*nothing*/
+		}
+
 		if(CI_SUCCESS == rtnvalue)
 		{	
 			pRouteCfgDtStr->RouteInitEnemyStatus = ROUTE_INIT_NOT_ENEMY;/*初始化成不敌对*/
@@ -6453,6 +6688,9 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
 			/*不为接近时，是否延时解锁赋值*/
 			pRouteCfgDtStr->RouteNeedDelayUnlock = pLSRouteStr->wNeedDelayUnlock;
 
+			/*CBTC进路跳过最后区段ESB/APG/SPKS封锁*/
+			pRouteCfgDtStr->cPassCbtcLastFlock = pLSRouteStr->cPassCbtcLastFlock;
+
 			/*调车同意继电器ID (配置字段)*/
 			pRouteCfgDtStr->DCRouteDCQJId = 0U;
 			pRouteCfgDtStr->DCRouteDCQJTwoId = 0U;
@@ -6965,6 +7203,7 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
 	callFun *= InitRelay_DCAgreeStru(FSName);/*初始化调车同意继电器表*/
 	callFun *= InitLS_SGBJStru(FSName);  /*初始化声光报警表*/
 	callFun *= InitLS_TransRouteRtnDataStruct(FSName);  /*初始化转换轨折返信号机表*/
+	callFun *= InitLS_CbtcRouteLogSecStru(FSName);  /*初始化CBTC进路逻辑区段检查表*/
 
 	/*电子地图初始化失败，函数失败退出*/
 	if(0u == callFun)
@@ -7011,6 +7250,24 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
 				}
 			}
 
+			if (1U == rtnvalue)
+			{
+				/*初始化CBTC进路需要检查的逻辑区段数据*/
+				execRet = CbtcRouteLgcCheckCfgDataInit(&(dquCICfgDtStr.RouteCfgDtStr[i]));
+				if (1U == execRet)
+				{
+					; /*继续执行*/
+				}
+				else
+				{/*调用函数失败，返回0*/
+					rtnvalue = 0U;
+				}
+			}
+			else
+			{
+				/*不处理*/
+			}
+
 			if (1U != rtnvalue)
 			{
 				break;
@@ -9376,6 +9633,38 @@ UINT8 SetSignalCrossCloseAttr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct* pSg
 	return ret;
 }
 
+/*********************************************
+*函数功能：根据电子地图中信号机属性设置信号机终端阻挡属性
+*参数说明：pSgnl是DSU信号机数据结构指针
+*          pSgnlCfgDtStr，信号机配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+static UINT8 SetSignalEndAttr(DSU_SIGNAL_STRU* pSgnl, SignalConfigDataStruct* pSgnlCfgDtStr)
+{
+	UINT8 ret = CI_SUCCESS;
+	UINT16 sigAttrEmap = 0u;/*电子地图中信号机属性*/
+
+	/*入口参数防护*/
+	if ((NULL == pSgnl) || (NULL == pSgnlCfgDtStr))
+	{
+		/*返回失败*/
+		ret = CI_ERROR;
+	}
+	if (CI_SUCCESS == ret)
+	{
+		sigAttrEmap = pSgnl->wAttribute;
+		if ((0x0004u & sigAttrEmap) == 0x0004u)
+		{
+			pSgnlCfgDtStr->signalEndAttr = SIGNAL_END_YES;
+		}
+		else
+		{
+			pSgnlCfgDtStr->signalEndAttr = SIGNAL_END_NO;
+		}
+
+	}
+	return ret;
+}
 
 /*********************************************
 *函数功能：初始化物理区段故障锁闭照查继电器表
@@ -10248,7 +10537,6 @@ UINT8 ReadVirCIWithOCRelationData(CHAR* FSName)
 	UINT8 RowDatalen =0u;/*行数*/
 	UINT8 virCIid = 0u;
 	UINT8 jj =0u;
-	UINT16 ocid =0u; 
 	UINT8 ocNum=0u;
 
 
@@ -10582,6 +10870,7 @@ UINT8 LinkCfgDtStruFromDquLinkStr(DSU_LINK_STRU* pLink, LinkDataConfigStru* pLin
 		pLinkScCfgDtStr->wManageTioc = pLink->wManagePhysicalCI;
 		pLinkScCfgDtStr->chLogicLineRelation = pLink->wLinkLogicDirUpAndDown;
 		pLinkScCfgDtStr->chLogicDirChanged = pLink->wLogicDirChanged;
+		pLinkScCfgDtStr->chDsnConnectAttr = pLink->cDisneyConnectAttr;
 		pLinkScCfgDtStr->chRelPhySecIsAGorBG = LINK_REL_PHYSEC_IS_DEFAULT;  /*先初始化为非AG非BG*/
 		pLinkScCfgDtStr->wLinkSpecialEa = 0U;  /*LINK特殊防护区域属性*/
 
@@ -12205,6 +12494,186 @@ UINT8 RouteRelatedSGBJCfgDataInit(RouteConfigDataStruct* pRouteCfgDtStr, LS_SGBJ
 	return rtnvalue;
 }
 
+/*********************************************
+* 函数功能：初始化SSKS闪灯稳灯继电器配置数据结构体----对外结构体
+* 参数说明：FSName文件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 SSksLightRelayCfgDataStrInit(CHAR* FSName)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT8 cFuncRet = CI_ERROR;
+
+	cFuncRet = dfsEmapInit(FSName);
+	cFuncRet *= InitRelaySsksLightStru(FSName);
+
+	if (CI_SUCCESS == cFuncRet)
+	{
+		dquCICfgDtStr.SsksLightRelayCfgDataStrLen = RelayDataLen.RelaySsksLightStrLen;
+
+		/*读取数据到静态数据结构体*/
+		cRetVal = ReadSsksLightRelayCfgFromDqu(dquCICfgDtStr.SsksLightRelayCfgDataStr);
+	}
+	else
+	{
+		cRetVal = CI_ERROR;  /*读表失败，返回失败*/
+	}
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：从读取SSKS闪灯稳灯继电器数据到静态数据结构体
+* 参数说明：SsksLightRelayCfgDataStruct *pSsksLightRelayCfgStr是信号机配置数据结构指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 ReadSsksLightRelayCfgFromDqu(SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStr)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 i = 0U;
+
+	if (NULL != pSsksLightRelayCfgStr)
+	{
+		cRetVal = CI_SUCCESS;
+
+		for (i = 0U; i < RelayDataLen.RelaySsksLightStrLen; i++)
+		{
+			if (SSKS_LIGHT_RELAY_SUM_MAX > i)
+			{
+				if ((0U != RelayData.pRelaySsksLightStr[i].SsksLightRelayId) && (UINT16_MAX != RelayData.pRelaySsksLightStr[i].SsksLightRelayId))
+				{
+					pSsksLightRelayCfgStr[i].SsksLightRelayId = RelayData.pRelaySsksLightStr[i].SsksLightRelayId;
+					pSsksLightRelayCfgStr[i].BelongOcId = RelayData.pRelaySsksLightStr[i].BelongOcId;
+					pSsksLightRelayCfgStr[i].BelongCiId = (UINT8)GetCiIdByOcId(RelayData.pRelaySsksLightStr[i].BelongOcId);
+
+					pSsksLightRelayCfgStr[i].cRelEnterRouteNum = RelayData.pRelaySsksLightStr[i].RelEnterRouteNum;
+					(void)CommonMemCpy((void*)(pSsksLightRelayCfgStr[i].szRelEnterRouteId), (UINT32)(sizeof(UINT16) * SSKS_LIGHT_RELAY_ROUTE_MAX),
+						(const void*)(RelayData.pRelaySsksLightStr[i].RelEnterRouteId), (UINT32)(sizeof(UINT16) * SSKS_LIGHT_RELAY_ROUTE_MAX));  /*拷贝驶入存车线的进路ID*/
+
+					pSsksLightRelayCfgStr[i].cRelExportRouteNum = RelayData.pRelaySsksLightStr[i].RelExportRouteNum;
+					(void)CommonMemCpy((void*)(pSsksLightRelayCfgStr[i].szRelExportRouteId), (UINT32)(sizeof(UINT16) * SSKS_LIGHT_RELAY_ROUTE_MAX),
+						(const void*)(RelayData.pRelaySsksLightStr[i].RelExportRouteId), (UINT32)(sizeof(UINT16) * SSKS_LIGHT_RELAY_ROUTE_MAX));  /*拷贝驶出存车线的进路ID*/
+				}
+				else
+				{
+					cRetVal = CI_ERROR;
+				}
+			}
+			else
+			{
+				cRetVal = CI_ERROR;
+			}
+
+			if (CI_SUCCESS != cRetVal)
+			{
+				break;
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;
+	}
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：初始化联络线旁路继电器配置数据结构体----对外结构体
+* 参数说明：FSName文件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 2026.3.11
+*********************************************/
+UINT8 ConnectOverrideCfgDataStrInit(CHAR* FSName)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT8 cFuncRet = CI_ERROR;
+
+	cFuncRet = dfsEmapInit(FSName);
+	cFuncRet *= InitConnectOverrideStru(FSName);
+
+	if (CI_SUCCESS == cFuncRet)
+	{
+		dquCICfgDtStr.ConnectOverrideCfgDataStrLen = RelayDataLen.RelayConnectOverrideStrLen;
+
+		/*读取数据到静态数据结构体*/
+		cRetVal = ReadConnectOverrideCfgFromDqu(dquCICfgDtStr.ConnectOverrideCfgDataStr);
+	}
+	else
+	{
+		cRetVal = CI_ERROR;  /*读表失败，返回失败*/
+	}
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：从读取联络线旁路继电器数据到静态数据结构体
+* 参数说明：ConnectOverrideCfgDataStru *pConnectOverrideCfgStr是联络线旁路配置数据结构指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 20260311
+*********************************************/
+UINT8 ReadConnectOverrideCfgFromDqu(ConnectOverrideCfgDataStru* pConnectOverrideCfgStr)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 i = 0U;
+
+	if (NULL != pConnectOverrideCfgStr)
+	{
+		cRetVal = CI_SUCCESS;
+
+		for (i = 0U; i < RelayDataLen.RelayConnectOverrideStrLen; i++)
+		{
+			if (CONNECT_OVERRIDE_RELAY_SUM_MAX > i)
+			{
+				if ((0U != RelayData.pRelayConnectOverrideStr[i].ConnectOverrideId) && (UINT16_MAX != RelayData.pRelayConnectOverrideStr[i].ConnectOverrideId))
+				{
+					pConnectOverrideCfgStr[i].ConnectOverrideId = RelayData.pRelayConnectOverrideStr[i].ConnectOverrideId;
+					pConnectOverrideCfgStr[i].BelongOcId = RelayData.pRelayConnectOverrideStr[i].BelongOcId;
+					pConnectOverrideCfgStr[i].BelongCiId = (UINT8)GetCiIdByOcId(RelayData.pRelayConnectOverrideStr[i].BelongOcId);
+					pConnectOverrideCfgStr[i].OverrideRelayId = RelayData.pRelayConnectOverrideStr[i].OverrideRelayId;
+					pConnectOverrideCfgStr[i].RelPhySecId = RelayData.pRelayConnectOverrideStr[i].RelPhySecId;
+					pConnectOverrideCfgStr[i].RelRouteRequestRelayId = RelayData.pRelayConnectOverrideStr[i].RelRouteRequestRelayId;
+					pConnectOverrideCfgStr[i].RelSwitchId = RelayData.pRelayConnectOverrideStr[i].RelSwitchId;
+				}
+				else
+				{
+					cRetVal = CI_ERROR;
+				}
+			}
+			else
+			{
+				cRetVal = CI_ERROR;
+			}
+
+			if (CI_SUCCESS != cRetVal)
+			{
+				break;
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;
+	}
+
+	return cRetVal;
+}
+
 /*********************************************
 *函数功能：计算联锁进路点式接近区段逻辑区段数据
 *参数说明：pLSRouteStr联锁进路结构体指针
@@ -12753,3 +13222,251 @@ static UINT8 LinkSpecialEaDataInit(CHAR* FSName)
 	return retVal;
 }
 
+/*********************************************
+*函数功能：初始化接触网配置数据结构体----对外结构体
+*参数说明：FSName文件指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 OhlConfigDataStructInit(CHAR* FSName)
+{
+	UINT8 rtnvalue = 0u;
+	UINT8 callFun = 0u;
+	UINT16 i = 0u;
+
+	callFun = InitRelay_OhlStru(FSName);
+	/*初始化失败，函数失败退出*/
+	if (0u == callFun)
+	{
+		rtnvalue = 0u;
+	}
+	else
+	{/*电子地图初始化成功，继续执行*/
+		rtnvalue = 1u;
+	}
+
+	if (1u == rtnvalue)
+	{
+		dquCICfgDtStr.wOhlCfgLen = RelayDataLen.RelayOhlStrLen;
+		for (i = 0u; i < RelayDataLen.RelayOhlStrLen; i++)
+		{
+			if (i >= OHL_MAX_NUM)
+			{
+				rtnvalue = 0u;
+				break;
+			}
+			else
+			{
+				;
+			}
+
+			rtnvalue &= OhlCfgDtStruFromDquStr(RelayData.pRelayOhlStr + i, &dquCICfgDtStr.OhlConfigDataStru[i]);
+		}
+	}
+	else
+	{
+		;
+	}
+
+	return rtnvalue;
+}
+
+/*********************************************
+*函数功能：接触网配置数据结构体计算
+*参数说明：pOhlCutRelay接触网结构体指针
+pOhlCfgDtStr接触网配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 OhlCfgDtStruFromDquStr(Relay_OhlStruct* pOhlCutRelay, OHLConfigDataStruct* pOhlCfgDtStr)
+{
+	UINT8 rtnvalue = 0u;
+	UINT16 jj = 0U;
+
+	/*入口参数防护*/
+	if ((NULL != pOhlCutRelay) && (NULL != pOhlCfgDtStr))
+	{
+		pOhlCfgDtStr->wOhlId = pOhlCutRelay->wOhlId;
+		pOhlCfgDtStr->wBelongOcId = pOhlCutRelay->wBelongOcId;
+		pOhlCfgDtStr->chBelongCiId = pOhlCutRelay->chBelongCiId;
+		pOhlCfgDtStr->chRelayGroupNum = pOhlCutRelay->chRelayGroupNum;
+		
+		for (jj = 0u; jj < pOhlCfgDtStr->chRelayGroupNum; jj++)
+		{
+			pOhlCfgDtStr->wEnergizedId[jj] = pOhlCutRelay->wEnergizedId[jj];
+			pOhlCfgDtStr->wDeEnergizedId[jj] = pOhlCutRelay->wDeEnergizedId[jj];
+		}
+		
+		rtnvalue = 1u;
+	}
+	else
+	{
+		/*返回失败*/
+		return 0u;
+	}
+	return rtnvalue;
+}
+
+/*********************************************
+* 函数功能：初始化ECS配置数据
+* 参数说明：FSName文件指针
+* 返回值：0，失败；1，成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 EcsConfigDataStructInit(CHAR* FSName)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT8 callFun = CI_ERROR;
+	UINT16 i = 0U;
+
+	callFun = dfsEmapInit(FSName);
+	callFun *= InitRelayEcsStru(FSName);
+	
+	if (CI_SUCCESS == callFun)
+	{
+		cRetVal = CI_SUCCESS;
+		
+		if (ECS_MAX_NUM > dsuDataLenStru.wEcsLen)
+		{
+			dquCICfgDtStr.EcsCfgDtStrLen = dsuDataLenStru.wEcsLen;
+			for (i = 0U; i < dsuDataLenStru.wEcsLen; i++)
+			{
+				cRetVal = EcsCfgDtStrFromDquEcsStr(dsuStaticHeadStru.pEcsStru + i, &dquCICfgDtStr.EcsCfgDtStr[i]);  /*从电子地图和OC表读取配置数据*/
+
+				if (CI_SUCCESS != cRetVal)
+				{
+					cRetVal = CI_ERROR;
+					break;
+				}
+				else
+				{
+					/*继续初始化*/
+				}
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\nEcsConfigDataStructInit fail: EcsLen Exceed Or Equal Max[%d]\n", dsuDataLenStru.wEcsLen);
+			cRetVal = CI_ERROR;
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;  /*电子地图/ECS继电器初始化失败，函数失败退出*/
+	}
+
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：计算ECS静态数据
+* 参数说明：DSU_ECS_STRU* pEcsStr ECS电子地图数据结构指针
+*           ECSConfigDataStruct* pEcsCfgDtStr ECS静态配置数据结构指针（出参）
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 EcsCfgDtStrFromDquEcsStr(DSU_ECS_STRU* pEcsStr, ECSConfigDataStruct* pEcsCfgDtStr)
+{
+	UINT16 i = 0U;
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 wLinkIndex = 0U;
+
+	if ((NULL != pEcsStr) && (NULL != pEcsCfgDtStr))
+	{
+		cRetVal = CI_SUCCESS;
+		pEcsCfgDtStr->wEcsId = pEcsStr->wEcsId;
+		pEcsCfgDtStr->wStartLinkId = pEcsStr->wTunnelStartLinkId;
+		pEcsCfgDtStr->dwStartLinkOff = pEcsStr->dwTunnelStartLinkOff;
+		pEcsCfgDtStr->wEndLinkId = pEcsStr->wTunnelEndLinkId;
+		pEcsCfgDtStr->dwEndLinkOff = pEcsStr->dwTunnelEndLinkOff;
+
+		cRetVal = GetDsuLinkIndexNum(pEcsCfgDtStr->wStartLinkId, &wLinkIndex);
+		if (CI_SUCCESS == cRetVal)
+		{
+			pEcsCfgDtStr->cBelongCiId = (UINT8)dsuStaticHeadStru.pLinkStru[wLinkIndex].wManagePhysicalCI;
+
+			pEcsCfgDtStr->wBelongOcId = 0U;
+			pEcsCfgDtStr->wFanUpRelayId = 0U;
+			pEcsCfgDtStr->wFanDownRelayId = 0U;
+
+			for (i = 0U; i < RelayDataLen.RelayEcsStrLen; i++)
+			{
+				if ((RelayData.pRelayEcsStr + i)->EcsId == pEcsStr->wEcsId)
+				{
+					pEcsCfgDtStr->wBelongOcId = (RelayData.pRelayEcsStr + i)->BelongOcId;
+					pEcsCfgDtStr->wFanUpRelayId = (RelayData.pRelayEcsStr + i)->FanUpRelayId;
+					pEcsCfgDtStr->wFanDownRelayId = (RelayData.pRelayEcsStr + i)->FanDownRelayId;
+					break;
+				}
+				else
+				{
+					/*继续循环*/
+				}
+			}
+
+			if (i != RelayDataLen.RelayEcsStrLen)
+			{
+				cRetVal = CI_SUCCESS;
+			}
+			else
+			{
+				debug_infor_printf((const)"\nEcsCfgDtStrFromDquEcsStr Err: Ecs[%d] Find Relay Fail.\n", pEcsCfgDtStr->wEcsId);
+				cRetVal = CI_ERROR;
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\nEcsCfgDtStrFromDquEcsStr Err: GetStartLinkIndex Fail.\n");
+			cRetVal = CI_ERROR;
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;  /*入参非法，返回失败*/
+	}
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：CBTC进路逻辑区段检查配置数据初始化
+* 参数说明：RouteConfigDataStruct* pRouteCfgDtStr 进路配置数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.25
+*********************************************/
+UINT8 CbtcRouteLgcCheckCfgDataInit(RouteConfigDataStruct* pRouteCfgDtStr)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 ii = 0U;
+
+	if (NULL != pRouteCfgDtStr)
+	{
+		cRetVal = CI_SUCCESS;
+
+		pRouteCfgDtStr->CbtcRouteCheckLgcSum = 0U;
+		(void)CommonMemSet(pRouteCfgDtStr->CbtcRouteCheckLgcId, (UINT32)(sizeof(UINT16) * MAX_ROUTE_IN_LT_NUM), (UINT8)0U, (UINT32)(sizeof(UINT16) * MAX_ROUTE_IN_LT_NUM));
+
+		for (ii = 0U; ii < LSDataLen.LSCbtcRouteLgcCheckStruLen; ii++)
+		{
+			if (pRouteCfgDtStr->RouteId == LSData.pLSCbtcRouteLgcCheckStru[ii].wRouteId)
+			{
+				/*找到目标进路，将需要检查的逻辑区段信息赋值到该进路的静态数据结构体中*/
+				pRouteCfgDtStr->CbtcRouteCheckLgcSum = LSData.pLSCbtcRouteLgcCheckStru[ii].cCheckLogSecNum;
+
+				(void)CommonMemCpy(pRouteCfgDtStr->CbtcRouteCheckLgcId, (UINT32)(sizeof(UINT16) * LSData.pLSCbtcRouteLgcCheckStru[ii].cCheckLogSecNum),
+					LSData.pLSCbtcRouteLgcCheckStru[ii].szCheckLogSecId, (UINT32)(sizeof(UINT16) * LSData.pLSCbtcRouteLgcCheckStru[ii].cCheckLogSecNum));
+			}
+			else
+			{
+				/*继续遍历查找*/
+			}
+		}
+	}
+	else
+	{
+		/*入参非法，返回0*/
+	}
+
+	return cRetVal;
+}

TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h

@@ -33,6 +33,9 @@
 #include "../SGBJ/SGBJConfigDataManage.h"
 #include "../Section/AxisSectionConfigDataManage.h"
 #include "../System/SystemParameterManage.h"
+#include "../SsksLightRelay/SsksLightRelayCfgDataManage.h"
+#include "../ConnectOverride/ConnectOverrideCfgDataMg.h"
+#include "../ECS/ECSConfigDataManage.h"
 
 #define ORIGIN_TO_TERMINAL	((UINT8)0x55)	/*起点到终点*/
 #define TERMINAL_TO_ORIGIN	((UINT8)0xAA)	/*终点到起点*/
@@ -137,6 +140,13 @@ typedef struct
 	UINT16  spksDataConfigStrLen;
     MJDataConfigStruct mjDataConfigStr[MJ_SUM_MAX];	                                  /* 门禁配置数据数组 */
     UINT16  mjDataConfigStrLen;
+
+    SsksLightRelayCfgDataStruct SsksLightRelayCfgDataStr[SSKS_LIGHT_RELAY_SUM_MAX];	     /*SSKS闪灯稳灯继电器数组*/
+    UINT16 SsksLightRelayCfgDataStrLen;
+
+	ConnectOverrideCfgDataStru ConnectOverrideCfgDataStr[CONNECT_OVERRIDE_RELAY_SUM_MAX];	     /*联络线旁路继电器数组*/
+	UINT16 ConnectOverrideCfgDataStrLen;
+
 	FloodGateConfigDataStruct FloodGateCfgDtStr[FLOOD_GATE_SUM_MAX];                  /*防淹门配置数据数组*/
 	UINT16 FloodGateCfgDtStrLen;
 	WashMachineConfigDataStruct WashMachineCfgStr[WASHMACHINE_SUM_MAX];               /*洗车机配置数据数组*/
@@ -185,6 +195,15 @@ typedef struct
 
     SGBJConfigDataStruct SGBJCfgDataStru[SGBJ_SUM_MAX];  /*声光报警器配置数据*/
     UINT16 wSGBJCfgLen;  /*声光报警器数量*/
+
+    OHLConfigDataStruct OhlConfigDataStru[OHL_MAX_NUM];    /*接触网配置数据*/
+    UINT16 wOhlCfgLen;  /*接触网分区数量*/
+
+    UINT16 EcsCfgDtStrLen;  /*ECS表长度*/
+    ECSConfigDataStruct EcsCfgDtStr[ECS_MAX_NUM];  /*ECS配置数据结构体*/
+
+	UINT16 CesbCfgDtStrLen;  /*Cesb表长度*/
+	CesbConfigDataStruct CesbCfgDtStr[CI_SUM_MAX];  /*CESB配置数据结构体*/
 } dquCIConfigDataStr;
 
 
@@ -328,6 +347,14 @@ UINT8  LogicSecConfigDataStructInit(CHAR * FSName);
 *返回值：0，失败；1，成功
 *********************************************/
 UINT8 EsbCfgDtStruFromDquEmergStr(DSU_EMERG_STOP_STRU * pEmergStop,EsbConfigDataStruct* pEsbCfgDtStr);
+
+/*********************************************
+*函数功能：全线紧急停车按钮接口数据结构体
+*参数说明：pRelayCesb继电器结构体指针
+pCesbCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 CesbCfgDtStruFromRelayData(Relay_CesbStruct*pRelayCesb, CesbConfigDataStruct* pCesbCfgDtStr);
 /*********************************************
 *函数功能：初始化紧急停车按钮接口配置数据结构体----对外结构体
 *参数说明：FSName文件指针
@@ -335,6 +362,13 @@ UINT8 EsbCfgDtStruFromDquEmergStr(DSU_EMERG_STOP_STRU * pEmergStop,EsbConfigData
 *********************************************/
 UINT8 EsbConfigDataStructInit(CHAR * FSName);
 
+/*********************************************
+*函数功能：初始化全线紧急停车按钮接口配置数据结构体----对外结构体
+*参数说明：FSName文件指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 CesbConfigDataStructInit(CHAR * FSName);
+
 /*********************************************
 *函数功能：屏蔽门配置数据结构体
 *参数说明：pScreen屏蔽门结构体指针
@@ -892,6 +926,42 @@ UINT8 SGBJConfigDataStructInit(CHAR* FSName);
 *********************************************/
 UINT8 RouteRelatedSGBJCfgDataInit(RouteConfigDataStruct* pRouteCfgDtStr, LS_SGBJStruct* pLSSGBJStr);
 
+/*********************************************
+* 函数功能：初始化SSKS闪灯稳灯继电器配置数据结构体----对外结构体
+* 参数说明：FSName文件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 SSksLightRelayCfgDataStrInit(CHAR* FSName);
+
+/*********************************************
+* 函数功能：初始化联络线旁路继电器配置数据结构体----对外结构体
+* 参数说明：FSName文件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 2026.3.11
+*********************************************/
+UINT8 ConnectOverrideCfgDataStrInit(CHAR* FSName);
+
+/*********************************************
+* 函数功能：从读取SSKS闪灯稳灯继电器数据到静态数据结构体
+* 参数说明：SsksLightRelayCfgDataStruct *pSsksLightRelayCfgStr是信号机配置数据结构指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 ReadSsksLightRelayCfgFromDqu(SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStr);
+
+/*********************************************
+* 函数功能：从读取联络线旁路继电器数据到静态数据结构体
+* 参数说明：ConnectOverrideCfgDataStru *pConnectOverrideCfgStr是联络线旁路配置数据结构指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 20260311
+*********************************************/
+UINT8 ReadConnectOverrideCfgFromDqu(ConnectOverrideCfgDataStru* pConnectOverrideCfgStr);
+
 /*********************************************
 *函数功能：计算联锁进路点式接近区段逻辑区段数据
 *参数说明：pLSRouteStr联锁进路结构体指针
@@ -937,5 +1007,47 @@ UINT8 AgLinkExistRelCGFlagCalc(LinkDataConfigStru* pLinkScCfgDtStr);
 *********************************************/
 UINT8 BGLinkRelAGLinkCal(LinkDataConfigStru* pLinkScCfgDtStr);
 
+/*********************************************
+*函数功能：初始化接触网配置数据结构体----对外结构体
+*参数说明：FSName文件指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 OhlConfigDataStructInit(CHAR* FSName);
+
+/*********************************************
+*函数功能：接触网配置数据结构体计算
+*参数说明：pOhlCutRelay接触网结构体指针
+pOhlCfgDtStr接触网配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 OhlCfgDtStruFromDquStr(Relay_OhlStruct* pOhlCutRelay, OHLConfigDataStruct* pOhlCfgDtStr);
+
+/*********************************************
+* 函数功能：初始化ECS配置数据
+* 参数说明：FSName文件指针
+* 返回值：0，失败；1，成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 EcsConfigDataStructInit(CHAR* FSName);
+
+/*********************************************
+* 函数功能：计算ECS静态数据
+* 参数说明：DSU_ECS_STRU* pEcsStr ECS电子地图数据结构指针
+*           ECSConfigDataStruct* pEcsCfgDtStr ECS静态配置数据结构指针（出参）
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 EcsCfgDtStrFromDquEcsStr(DSU_ECS_STRU* pEcsStr, ECSConfigDataStruct* pEcsCfgDtStr);
+
+/*********************************************
+* 函数功能：CBTC进路逻辑区段检查配置数据初始化
+* 参数说明：RouteConfigDataStruct* pRouteCfgDtStr 进路配置数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.25
+*********************************************/
+UINT8 CbtcRouteLgcCheckCfgDataInit(RouteConfigDataStruct* pRouteCfgDtStr);
+
 #endif
 

TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c

@@ -1801,6 +1801,56 @@ INT16 ReadEsbConfigData(const UINT8 ciId,EsbConfigDataStruct* pEsbConfigDataStru
 	
 	return DataNum;
 }
+/*********************************************
+*函数功能：读本集中区全线紧急停车按钮配置数据
+*参数说明：pCesbConfigDataStru全线紧急停车配置数据结构体指针
+*返回值：0失败 1成功
+*********************************************/
+UINT8 ReadLocalCesbConfigData(const UINT8 ciId, CesbConfigDataStruct* pCesbConfigDataStru)
+{
+	UINT16 i = 0u;
+	UINT8 DataNum = 0U;;
+	if ((0u == ciId) || (NULL == pCesbConfigDataStru))
+	{
+		DataNum = 0U;
+	}
+	else
+	{
+		DataNum = 1U;
+	}
+
+	if (0U != DataNum)
+	{
+		pCesbConfigDataStru->BelongCiId = ciId;
+		pCesbConfigDataStru->wCesbId = 0U;
+		pCesbConfigDataStru->wCesbCutRelayId = 0U;
+		pCesbConfigDataStru->wCesbRelayId = 0U;
+		for (i = 0u; i<dquCICfgDtStr.CesbCfgDtStrLen; i++)
+		{
+			/*访问数组不能越界，越界直接返回失败*/
+			if (dquCICfgDtStr.CesbCfgDtStr[i].wCesbId <= CI_SUM_MAX)
+			{
+				if (ciId == dquCICfgDtStr.CesbCfgDtStr[i].BelongCiId)
+				{
+					pCesbConfigDataStru->wCesbCutRelayId = dquCICfgDtStr.CesbCfgDtStr[i].wCesbCutRelayId;
+					pCesbConfigDataStru->wCesbRelayId = dquCICfgDtStr.CesbCfgDtStr[i].wCesbRelayId;
+					pCesbConfigDataStru->wCesbId = dquCICfgDtStr.CesbCfgDtStr[i].wCesbId;
+					break;
+				}
+			}
+			else
+			{
+				/*返回失败*/
+				DataNum = 0U;
+				debug_infor_printf((const)"\nReadCesbConfigData fail: BtnID Exceed MAX :%d\n", CI_SUM_MAX);
+				break;
+			}
+
+		}
+	}
+
+	return DataNum;
+}
 
 /*********************************************
 *函数功能：读屏蔽门配置数据
@@ -2421,8 +2471,6 @@ UINT8 ReadSystemParamConfDataNew(const UINT8 ciId,SystemParameterStructNew* Syst
 			/*对向行驶双车间隔最小安全距离(cm)*/
 			SystemParameterStru->OppositeTrackDistance = dquCICfgDtStr.SystemParaStrNew.OppositeTrackDistance;
 
-			/*站台追踪时，列车间隔距离（cm）*/
-			SystemParameterStru->StationTrackDistance = dquCICfgDtStr.SystemParaStrNew.StationTrackDistance;
 
 			/*线路最差情况下紧急制动距离（单位m）*/
 			SystemParameterStru->MaxMALength = dquCICfgDtStr.SystemParaStrNew.MaxMALength;
@@ -3819,7 +3867,6 @@ INT16 ReadLinkConfigData(LinkDataConfigStru* pLinkConfigAddr)
 			if (LINK_SUM_MAX > dquCICfgDtStr.LinkCfgDtStr[i].wId)
 			{
 				pLinkConfigAddr[dquCICfgDtStr.LinkCfgDtStr[i].wId] = dquCICfgDtStr.LinkCfgDtStr[i];
-
 				DataNum++;
 				for (indexAc = 0u; indexAc < dsuDataLenStru.wAxleSgmtLen; indexAc++)
 				{
@@ -3837,6 +3884,10 @@ INT16 ReadLinkConfigData(LinkDataConfigStru* pLinkConfigAddr)
 							}
 						}
 					}
+					else
+					{
+						;
+					}
 				}
 
 				pLinkConfigAddr[dquCICfgDtStr.LinkCfgDtStr[i].wId].wStopAreaId = 0u;
@@ -4343,6 +4394,98 @@ INT16 ReadSGBJConfigData(const UINT8 cLocalCiId, SGBJConfigDataStruct* pSGBJConf
 	return dataNum;
 }
 
+/*********************************************
+* 函数功能：读SSKS闪灯稳灯继电器配置数据
+* 参数说明：const UINT8 cLocalCiId 本地联锁ID
+*           SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStru SSKS闪灯稳灯继电器配置数据结构体指针
+* 返 回 值：-1 读取失败
+*		    其它 SSKS闪灯稳灯继电器数量
+* Created By LQ 2025.12.15
+*********************************************/
+INT16 ReadSsksLightRelayCfgData(const UINT8 cLocalCiId, SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStru)
+{
+	INT16 dataNum = -1;
+	UINT16 i = 0U;
+
+	if ((NULL != pSsksLightRelayCfgStru) && (0U != cLocalCiId))
+	{
+		dataNum = 0;
+
+		for (i = 0U; i < dquCICfgDtStr.SsksLightRelayCfgDataStrLen; i++)
+		{
+			if (cLocalCiId == dquCICfgDtStr.SsksLightRelayCfgDataStr[i].BelongCiId)
+			{
+				if (SSKS_LIGHT_RELAY_SUM_MAX > dataNum)
+				{
+					pSsksLightRelayCfgStru[dataNum] = dquCICfgDtStr.SsksLightRelayCfgDataStr[i];
+					dataNum++;
+				}
+				else
+				{
+					dataNum = -1;  /*返回失败*/
+					break;
+				}
+			}
+			else
+			{
+				/*继续遍历*/
+			}
+		}
+	}
+	else
+	{
+		dataNum = -1;
+	}
+
+	return dataNum;
+}
+
+/*********************************************
+* 函数功能：读联络线旁路继电器配置数据
+* 参数说明：const UINT8 cLocalCiId 本地联锁ID
+*           ConnectOverrideCfgDataStru* pConnectOverrideCfgStru 联络线旁路继电器配置数据结构体指针
+* 返 回 值：-1 读取失败
+*		    其它 联络线旁路继电器数量
+* Created By wyd 20260311
+*********************************************/
+INT16 ReadConnectOverrideCfgData(const UINT8 cLocalCiId, ConnectOverrideCfgDataStru* pConnectOverrideCfgStru)
+{
+	INT16 dataNum = -1;
+	UINT16 i = 0U;
+
+	if ((NULL != pConnectOverrideCfgStru) && (0U != cLocalCiId))
+	{
+		dataNum = 0;
+
+		for (i = 0U; i < dquCICfgDtStr.ConnectOverrideCfgDataStrLen; i++)
+		{
+			if (cLocalCiId == dquCICfgDtStr.ConnectOverrideCfgDataStr[i].BelongCiId)
+			{
+				if (CONNECT_OVERRIDE_RELAY_SUM_MAX > dataNum)
+				{
+					pConnectOverrideCfgStru[dataNum] = dquCICfgDtStr.ConnectOverrideCfgDataStr[i];
+					dataNum++;
+				}
+				else
+				{
+					dataNum = -1;  /*返回失败*/
+					break;
+				}
+			}
+			else
+			{
+				/*继续遍历*/
+			}
+		}
+	}
+	else
+	{
+		dataNum = -1;
+	}
+
+	return dataNum;
+}
+
 /*********************************************
 *函数功能：确定计轴区段的边界计轴区段属性
 *参数说明：const UINT16 wAxleId 计轴区段ID
@@ -4632,3 +4775,218 @@ UINT8 ReadPhySecIndexInAxle(const UINT8 chLocalCiId, PhysicalSectionConfigDataSt
 	return chReval;
 }
 
+/*********************************************
+*函数功能：读接触网配置数据
+*参数说明：ciId联锁ID，  pOhlConfigDataStru接触网配置数据结构体指针
+*返回值：信号机数
+*********************************************/
+INT16 ReadOhlConfigData(const UINT8 ciId, OHLConfigDataStruct* pOhlConfigDataStru)
+{
+	INT16 DataNum = -1;
+	UINT16 i = 0u;
+	if ((0u == ciId) || (NULL == pOhlConfigDataStru))
+	{
+		DataNum = -1;
+	}
+	else
+	{
+		DataNum = 0;
+	}
+
+	if (0 == DataNum)
+	{
+		for (i = 0u; i < dquCICfgDtStr.wOhlCfgLen; i++)
+		{
+			/*访问数组不能越界，越界直接返回失败*/
+			if (OHL_MAX_NUM >= dquCICfgDtStr.OhlConfigDataStru[i].wOhlId)
+			{
+				pOhlConfigDataStru[dquCICfgDtStr.OhlConfigDataStru[i].wOhlId] = dquCICfgDtStr.OhlConfigDataStru[i];
+	
+				if (ciId == dquCICfgDtStr.OhlConfigDataStru[i].chBelongCiId)
+				{
+					DataNum++;
+				}
+			}
+			else
+			{
+				/*返回失败*/
+				DataNum = -1;
+				break;
+			}
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	return DataNum;
+}
+
+/*********************************************
+* 函数功能：读ECS配置数据
+* 参数说明：ciId 联锁ID
+*           ECSConfigDataStruct* pEcsConfigDataStru ECS配置数据结构体指针
+* 返 回 值：ECS数量
+* Created By LQ 2026.01.24
+*********************************************/
+INT16 ReadEcsConfigData(const UINT8 ciId, ECSConfigDataStruct* pEcsConfigDataStru)
+{
+	UINT16 i = 0U;
+	INT16 DataNum = -1;
+	UINT16 wEcsId = 0U;
+
+	if ((0U == ciId) || (NULL == pEcsConfigDataStru))
+	{
+		DataNum = -1;
+	}
+	else
+	{
+		DataNum = 0;
+		for (i = 0U; i < dquCICfgDtStr.EcsCfgDtStrLen; i++)
+		{
+			if ((0U < dquCICfgDtStr.EcsCfgDtStr[i].wEcsId) && (ECS_MAX_NUM > dquCICfgDtStr.EcsCfgDtStr[i].wEcsId))
+			{
+				wEcsId = dquCICfgDtStr.EcsCfgDtStr[i].wEcsId;
+				pEcsConfigDataStru[wEcsId] = dquCICfgDtStr.EcsCfgDtStr[i];
+				if (ciId == dquCICfgDtStr.EcsCfgDtStr[i].cBelongCiId)
+				{
+					DataNum++;
+				}
+				else
+				{
+					/*继续遍历*/
+				}
+			}
+			else
+			{
+				debug_infor_printf((const)"ReadEcsConfigData Err: EcsId[%d] Is Invalid", dquCICfgDtStr.EcsCfgDtStr[i].wEcsId);  /*ECS ID非法，返回失败*/
+				DataNum = -1;
+				break;
+			}
+		}		
+	}
+
+	return DataNum;
+}
+
+/*********************************************
+* 函数功能：初始化ECS包含的物理区段信息
+* 参数说明：ECSConfigDataStruct* pEcsConfigDataStru ECS配置数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.227
+*********************************************/
+UINT8 EcsIncPhySecInfoInit(ECSConfigDataStruct* pEcsConfigDataStru)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT16 i = 0U;
+	UINT16 wEcsId = 0U;
+	UINT8 cFuncRetVal = CI_ERROR;
+	struct_PathPoint strStartPoint = { 0U };  /*隧道起点位置*/
+	struct_PathPoint strEndPoint = { 0U };  /*隧道终点位置*/
+	UINT16 wLogSecNum = 0U;  /*隧道关联的逻辑区段数量*/
+	UINT16 szLogSecID[ECS_REL_LOGSEC_MAX_NUM] = { 0U };  /*道关联的逻辑区段ID*/
+	UINT16 jj = 0U;
+	UINT16 wRelPhySecId = 0U;
+	UINT8 kk = 0U;
+	UINT8 cKeepWorkFlag = CI_SUCCESS;
+
+	if (NULL != pEcsConfigDataStru)
+	{
+		cRetVal = CI_SUCCESS;
+
+		for (i = 0U; i < dquCICfgDtStr.EcsCfgDtStrLen; i++)
+		{
+			wEcsId = dquCICfgDtStr.EcsCfgDtStr[i].wEcsId;
+
+			/*初始化ECS关联的物理区段信息*/
+			pEcsConfigDataStru[wEcsId].cRelPhySecNum = 0U;
+			(void)CommonMemSet(pEcsConfigDataStru[wEcsId].szRelPhySecId, (UINT32)(sizeof(UINT16) * ECS_REL_PHYSEC_MAX_NUM), (UINT8)0U, (UINT32)(sizeof(UINT16) * ECS_REL_PHYSEC_MAX_NUM));
+
+			strStartPoint.wLinkId = pEcsConfigDataStru[wEcsId].wStartLinkId;
+			strStartPoint.dwOffset = pEcsConfigDataStru[wEcsId].dwStartLinkOff;
+			strEndPoint.wLinkId = pEcsConfigDataStru[wEcsId].wEndLinkId;
+			strEndPoint.dwOffset = pEcsConfigDataStru[wEcsId].dwEndLinkOff;
+
+			cFuncRetVal = GetLogSecBtwTwoPoints(strStartPoint, strEndPoint, &wLogSecNum, szLogSecID);  /*获取隧道范围内的的逻辑区段*/
+			if ((CI_SUCCESS == cFuncRetVal) && (ECS_REL_LOGSEC_MAX_NUM >= wLogSecNum) && (0U < wLogSecNum))
+			{
+				/*将查询到的逻辑区段转换成物理区段并存储*/
+				for (jj = 0U; jj < wLogSecNum; jj++)
+				{
+					wRelPhySecId = GetLgcSecRelativePhySecId(szLogSecID[jj]);
+					if (0U != wRelPhySecId)
+					{
+						/*检查此物理区段是否已被添加*/
+						for (kk = 0U; kk < pEcsConfigDataStru[wEcsId].cRelPhySecNum; kk++)
+						{
+							if (wRelPhySecId == pEcsConfigDataStru[wEcsId].szRelPhySecId[kk])
+							{
+								break;  /*已添加，停止遍历*/
+							}
+							else
+							{
+								/*继续判断该物理区段是否已添加*/
+							}
+						}
+
+						if (kk == pEcsConfigDataStru[wEcsId].cRelPhySecNum)
+						{
+							/*物理区段未被添加，添加此物理区段*/
+							if (ECS_REL_PHYSEC_MAX_NUM > pEcsConfigDataStru[wEcsId].cRelPhySecNum)
+							{
+								pEcsConfigDataStru[wEcsId].szRelPhySecId[pEcsConfigDataStru[wEcsId].cRelPhySecNum] = wRelPhySecId;
+								pEcsConfigDataStru[wEcsId].cRelPhySecNum++;
+							}
+							else
+							{
+								debug_infor_printf((const)"\nReadEcsConfigData Err: PhySec Num Exceed Max[%d]", ECS_REL_PHYSEC_MAX_NUM);  /*物理区段数量超限，返回失败*/
+								cKeepWorkFlag = CI_ERROR;
+							}
+						}
+						else
+						{
+							/*已添加，不处理*/
+						}
+					}
+					else
+					{
+						debug_infor_printf((const)"ReadEcsConfigData Err: Query PhySec Fail");  /*获取逻辑区段关联的物理区段失败，返回失败*/
+						cKeepWorkFlag = CI_ERROR;
+					}
+
+					if (CI_SUCCESS != cKeepWorkFlag)
+					{
+						break;
+					}
+					else
+					{
+						/*继续遍历*/
+					}
+				}
+			}
+			else
+			{
+				debug_infor_printf((const)"ReadEcsConfigData Err: Query LogSec Fail");  /*查询逻辑区段失败或逻辑区段数量超限，返回失败*/
+				cKeepWorkFlag = CI_ERROR;
+			}
+
+			if (CI_SUCCESS != cKeepWorkFlag)
+			{
+				cRetVal = CI_ERROR;
+				break;
+			}
+			else
+			{
+				/*继续遍历*/
+			}
+		}
+	}
+	else
+	{
+		/*入参非法，返回失败*/
+	}
+
+	return cRetVal;
+}

TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h

@@ -97,7 +97,12 @@ INT16 ReadLogicSectionConfigData(const UINT8 ciId,LogicSectionConfigDataStruct*
 *********************************************/
 INT16 ReadEsbConfigData(const UINT8 ciId,EsbConfigDataStruct* pEsbConfigDataStru);/*读紧急停车按钮配置数据*/
 
-
+/*********************************************
+*函数功能：读本集中区全线紧急停车按钮配置数据
+*参数说明：pCesbConfigDataStru全线紧急停车配置数据结构体指针
+*返回值：0失败 1成功
+*********************************************/
+UINT8 ReadLocalCesbConfigData(const UINT8 ciId, CesbConfigDataStruct* pCesbConfigDataStru);
 /*********************************************
 *函数功能：读屏蔽门配置数据
 *参数说明：ciId联锁ID，  pPsdConfigDataStru屏蔽门配置数据结构体指针
@@ -480,6 +485,26 @@ UINT8 GetWLScreenTypeById(const UINT8 ciId);
 *********************************************/
 INT16 ReadSGBJConfigData(const UINT8 cLocalCiId, SGBJConfigDataStruct* pSGBJConfigDataStru);
 
+/*********************************************
+* 函数功能：读SSKS闪灯稳灯继电器配置数据
+* 参数说明：const UINT8 cLocalCiId 本地联锁ID
+*           SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStru SSKS闪灯稳灯继电器配置数据结构体指针
+* 返 回 值：-1 读取失败
+*		    其它 SSKS闪灯稳灯继电器数量
+* Created By LQ 2025.12.15
+*********************************************/
+INT16 ReadSsksLightRelayCfgData(const UINT8 cLocalCiId, SsksLightRelayCfgDataStruct* pSsksLightRelayCfgStru);
+
+/*********************************************
+* 函数功能：读联络线旁路继电器配置数据
+* 参数说明：const UINT8 cLocalCiId 本地联锁ID
+*           ConnectOverrideCfgDataStru* pConnectOverrideCfgStru 联络线旁路继电器配置数据结构体指针
+* 返 回 值：-1 读取失败
+*		    其它 联络线旁路继电器数量
+* Created By wyd 20260311
+*********************************************/
+INT16 ReadConnectOverrideCfgData(const UINT8 cLocalCiId, ConnectOverrideCfgDataStru* pConnectOverrideCfgStru);
+
 /*********************************************
 *函数功能：确定计轴区段的边界计轴区段属性
 *参数说明：const UINT16 wAxleId 计轴区段ID
@@ -507,6 +532,40 @@ UINT8 EnsureNearAxleStorageLineAtrr(const UINT16 wAxleId);
 */
 UINT8 ReadPhySecIndexInAxle(const UINT8 chLocalCiId, PhysicalSectionConfigDataStruct* pPhysicalSectionConfigDataStru);
 
+/*********************************************
+*函数功能：读接触网配置数据
+*参数说明：ciId联锁ID，  pOhlConfigDataStru接触网配置数据结构体指针
+*返回值：信号机数
+*********************************************/
+INT16 ReadOhlConfigData(const UINT8 ciId, OHLConfigDataStruct* pOhlConfigDataStru);
+
+/*********************************************
+* 函数功能：读ECS配置数据
+* 参数说明：ciId 联锁ID
+*           ECSConfigDataStruct* pEcsConfigDataStru ECS配置数据结构体指针
+* 返 回 值：ECS数量
+* Created By LQ 2026.01.24
+*********************************************/
+INT16 ReadEcsConfigData(const UINT8 ciId, ECSConfigDataStruct* pEcsConfigDataStru);
+
+/*********************************************
+* 函数功能：初始化ECS包含的物理区段信息
+* 参数说明：ECSConfigDataStruct* pEcsConfigDataStru ECS配置数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.227
+*********************************************/
+UINT8 EcsIncPhySecInfoInit(ECSConfigDataStruct* pEcsConfigDataStru);
+
+/*********************************************
+* 函数功能：获取编号对照表中Vobc数目
+* 参数说明：无
+* 返 回 值：Vobc数目
+* 
+*********************************************/
+UINT16 dquGetVobcNumLen(void);
+
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c

@@ -107,7 +107,7 @@ UINT8 RelayConfigDataStruFromChar(UINT8 * pDataAddr,RelayConfigDataStruct* pRela
 
 /*********************************************
 *函数功能：初始化紧急停车按钮继电器结构体
-*参数说明：pDataAddr数据地址，  pEmgcyStpStr紧急停车按钮继电器配置数据结构体指针    realRowLen 每行字节的长度
+*参数说明：pDataAddr数据地址，  pCesbStpStr紧急停车按钮继电器配置数据结构体指针    realRowLen 每行字节的长度
 *返回值：0，失败；1，成功
 *********************************************/
 UINT8 R_EmegencyStopStructFromChar(UINT8 * pDataAddr,Relay_EmgcyStpStruct* pEmgcyStpStr, UINT16 realRowLen)
@@ -180,6 +180,36 @@ UINT8 R_EmegencyStopStructFromChar(UINT8 * pDataAddr,Relay_EmgcyStpStruct* pEmgc
     rtnvalue = 1u;
 	return rtnvalue;
 }
+
+/*********************************************
+*函数功能：初始化全线紧急停车按钮继电器结构体
+*参数说明：pDataAddr数据地址，  pCesbStpStr紧急停车按钮继电器配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 R_CesbStructFromChar(UINT8 * pDataAddr, Relay_CesbStruct* pCesbStpStr)
+{
+	UINT8 * pData = pDataAddr;
+	UINT8 rtnvalue = 0u;
+
+	if ((NULL == pDataAddr) || (NULL == pCesbStpStr))
+	{
+		rtnvalue = 0u;
+	}
+	else
+	{
+		pCesbStpStr->wCesbBtnId = dquCiShortFromChar(pData);          /*全线紧急停车按钮ID */
+		pData += 2u;
+		pCesbStpStr->wOcId = dquCiShortFromChar(pData);				 /*OC ID*/
+		pData += 2u;
+		pCesbStpStr->wCesbRelayId = dquCiShortFromChar(pData);				 /*CESB继电器 id*/
+		pData += 2u;
+		pCesbStpStr->wCesbCutRelayId = dquCiShortFromChar(pData);				 /*旁路继电器ID*/
+		pData += 2u;
+
+		rtnvalue = 1u;
+	}
+	return rtnvalue;
+}
 /*********************************************
 *函数功能：从数据到屏蔽门继电器结构体
 *参数说明：pDataAddr数据地址，  pScrnStr屏蔽门继电器配置数据结构体指针,UINT16 rowLen 一行数据的长度
@@ -407,6 +437,12 @@ UINT8 R_PointStructFromChar(UINT8 * pDataAddr,Relay_PointStruct* pSwitchStr)
 		pData += 2u;
 		pSwitchStr->wRelayShadowFanBiaoId = dquCiShortFromChar(pData);          /*反表继电器ID */
 		pData += 2u;
+
+		pSwitchStr->wExtraPhySecId = dquCiShortFromChar(pData);        /*道岔动作额外检查物理区段ID */
+		pData += 2u;
+		pSwitchStr->chNormalPos = *pData;								/*道岔常态位置*/
+		pData += 1u;
+
 	}/* zt 删除单轨相关代码 2022-02-15 */
 	else
 	{
@@ -864,6 +900,170 @@ UINT8 R_SpksDataFromChar(UINT8 * pDataAddr,RelaySpksStruct* pSpksStr, UINT16 rea
 	return rtnvalue;
 }
 
+/*********************************************
+* 函数功能：从FS读取数据到SSKS闪灯稳灯继电器结构体
+* 参数说明：pDataAddr数据地址
+*           pSsksStr SSKS数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 R_SsksLightRelayDataFromChar(UINT8* pDataAddr, RelaySsksLightStruct* pSsksStr)
+{
+	UINT8* pData = pDataAddr;
+	UINT8 cRetVal = CI_ERROR;
+	UINT8 ii = 0U;
+
+	if ((NULL != pDataAddr) && (NULL != pSsksStr))
+	{
+		cRetVal = CI_SUCCESS;
+
+		pSsksStr->SsksLightRelayId = dquCiShortFromChar(pData);  /* 继电器ID */
+		pData += 2U;
+		if ((0U != pSsksStr->SsksLightRelayId) && (UINT16_MAX != pSsksStr->SsksLightRelayId))
+		{
+			pSsksStr->BelongOcId = dquCiShortFromChar(pData);  /*OC ID*/
+			pData += 2U;
+			if ((0U != pSsksStr->BelongOcId) && (UINT16_MAX != pSsksStr->BelongOcId))
+			{
+				pSsksStr->RelEnterRouteNum = *pData;  /*关联驶入存车线的进路数量*/
+				pData += 1U;
+				if (SSKS_LIGHT_RELAY_ROUTE_MAX >= pSsksStr->RelEnterRouteNum)
+				{
+					for (ii = 0U; ii < SSKS_LIGHT_RELAY_ROUTE_MAX; ii++)
+					{
+						pSsksStr->RelEnterRouteId[ii] = dquCiShortFromChar(pData);  /*关联驶入存车线的进路ID*/
+						pData += 2U;
+
+						if (((0U == pSsksStr->RelEnterRouteId[ii]) || (UINT16_MAX == pSsksStr->RelEnterRouteId[ii])) && (ii < pSsksStr->RelEnterRouteNum))
+						{
+							debug_infor_printf("\nR_SsksLightRelayDataFromChar Error: RelEnterRouteId[%d] Error.\n", pSsksStr->RelEnterRouteId[ii]);
+							cRetVal = CI_ERROR;  /*进路ID非法，返回失败*/
+							break;
+						}
+						else
+						{
+							/*继续遍历读取数据*/
+						}
+					}
+
+					if (CI_SUCCESS == cRetVal)
+					{
+						pSsksStr->RelExportRouteNum = *pData;  /*关联驶出存车线的进路数量*/
+						pData += 1U;
+						if (SSKS_LIGHT_RELAY_ROUTE_MAX >= pSsksStr->RelExportRouteNum)
+						{
+							for (ii = 0U; ii < SSKS_LIGHT_RELAY_ROUTE_MAX; ii++)
+							{
+								pSsksStr->RelExportRouteId[ii] = dquCiShortFromChar(pData);  /*关联驶出存车线的进路ID*/
+								pData += 2U;
+
+								if (((0U == pSsksStr->RelExportRouteId[ii]) || (UINT16_MAX == pSsksStr->RelExportRouteId[ii])) && (ii < pSsksStr->RelExportRouteNum))
+								{
+									debug_infor_printf("\nR_SsksLightRelayDataFromChar Error: RelExportRouteId[%d] Error.\n", pSsksStr->RelExportRouteId[ii]);
+									cRetVal = CI_ERROR;  /*进路ID非法，返回失败*/
+									break;
+								}
+								else
+								{
+									/*继续遍历读取数据*/
+								}
+							}
+						}
+						else
+						{
+							debug_infor_printf("\nR_SsksLightRelayDataFromChar Error: RelExportRouteNum[%d] Error.\n", pSsksStr->RelExportRouteNum);
+							cRetVal = CI_ERROR;  /*驶出存车线数量非法，返回失败*/
+						}
+					}
+					else
+					{
+						/*返回失败*/
+					}
+				}
+				else
+				{
+					debug_infor_printf("\nR_SsksLightRelayDataFromChar Error: RelEnterRouteNum[%d] Error.\n", pSsksStr->RelEnterRouteNum);
+					cRetVal = CI_ERROR;  /*驶入存车线数量非法，返回失败*/
+				}
+			}
+			else
+			{
+				debug_infor_printf("\nR_SsksLightRelayDataFromChar Error: BelongOcId[%d] Error.\n", pSsksStr->BelongOcId);
+				cRetVal = CI_ERROR;  /*OC ID非法，返回失败*/
+			}
+		}
+		else
+		{
+			debug_infor_printf("\nR_SsksLightRelayDataFromChar Error: SsksLightRelayId[%d] Error.\n", pSsksStr->SsksLightRelayId);
+			cRetVal = CI_ERROR;  /*继电器ID非法，返回失败*/
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;
+	}
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：从FS读取数据到联络线旁路继电器结构体
+* 参数说明：pDataAddr数据地址
+*           pOverrideStr 联络线旁路数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 20260311
+*********************************************/
+UINT8 R_ConnectOverrideDataFromChar(UINT8* pDataAddr, ConnectOverrideStruct* pOverrideStr)
+{
+	UINT8* pData = pDataAddr;
+	UINT8 cRetVal = CI_ERROR;
+
+	if ((NULL != pDataAddr) && (NULL != pOverrideStr))
+	{
+		cRetVal = CI_SUCCESS;
+
+		pOverrideStr->ConnectOverrideId = dquCiShortFromChar(pData);  /* 索引编号 */
+		pData += 2U;
+		if ((0U != pOverrideStr->ConnectOverrideId) && (UINT16_MAX != pOverrideStr->ConnectOverrideId))
+		{
+			pOverrideStr->BelongOcId = dquCiShortFromChar(pData);  /*OC ID*/
+			pData += 2U;
+			if ((0U != pOverrideStr->BelongOcId) && (UINT16_MAX != pOverrideStr->BelongOcId))
+			{
+				pOverrideStr->OverrideRelayId = dquCiShortFromChar(pData);  /*联络线旁路开关采集继电器ID*/
+				pData += 2U;
+
+				pOverrideStr->RelPhySecId = dquCiShortFromChar(pData);  /*关联物理区段ID*/
+				pData += 2U;
+
+				pOverrideStr->RelRouteRequestRelayId = dquCiShortFromChar(pData);  /*关联进路请求继电器ID*/
+				pData += 2U;
+
+				pOverrideStr->RelSwitchId = dquCiShortFromChar(pData);  /*关联道岔ID*/
+				pData += 2U;
+			}
+			else
+			{
+				debug_infor_printf((const)"\nR_ConnectOverrideDataFromChar Error: BelongOcId[%d] Error.\n", pOverrideStr->BelongOcId);
+				cRetVal = CI_ERROR;  /*OC ID非法，返回失败*/
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\nR_ConnectOverrideDataFromChar Error: SsksLightRelayId[%d] Error.\n", pOverrideStr->ConnectOverrideId);
+			cRetVal = CI_ERROR;  /*继电器ID非法，返回失败*/
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;
+	}
+
+	return cRetVal;
+}
+
 /*********************************************
 *函数功能：从数据到门禁继电器结构体
 *参数说明：pDataAddr数据地址，  pMjStr 门禁数据结构体指针   realRowLen 每一行数据长度
@@ -1141,3 +1341,137 @@ UINT8 R_OCIndicStruFromChar(UINT8* pDataAddr, OCStationIndicConfigDataStru* pInd
 }
 
 
+/*********************************************
+*函数功能：从数据到接触网继电器结构体
+*参数说明：pDataAddr数据地址，  pOhlStr 接触网继电器配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 R_OhlStructFromChar(UINT8* pDataAddr, Relay_OhlStruct* pOhlStr)
+{
+	UINT8* pData = pDataAddr;
+	UINT8 rtnvalue = CI_ERROR;
+	UINT8 i = 0U;
+
+	if ((NULL == pDataAddr) || (NULL == pOhlStr))
+	{
+		;
+
+	}
+	else
+	{
+		rtnvalue = CI_SUCCESS;
+
+		pOhlStr->wOhlId = dquCiShortFromChar(pData);		/*接触网分区ID*/
+		pData += 2u;
+		if ((0u < pOhlStr->wOhlId) && (OHL_MAX_NUM > pOhlStr->wOhlId))
+		{
+			pOhlStr->wBelongOcId = dquCiShortFromChar(pData);	/*所属OC ID*/
+			pData += 2u;
+
+			if ((0U != pOhlStr->wBelongOcId) && (UINT16_MAX != pOhlStr->wBelongOcId))
+			{
+				pOhlStr->chBelongCiId = (UINT8)(GetCiIdByOcId(pOhlStr->wBelongOcId));
+				pOhlStr->chRelayGroupNum = *pData;					/*继电器组数*/
+				pData += 1u;
+				
+				if ((0U < pOhlStr->chRelayGroupNum) && (OHL_GROUP_MAX_NUM >= pOhlStr->chRelayGroupNum))
+				{
+					for (i = 0u; i < pOhlStr->chRelayGroupNum; i++)
+					{
+						pOhlStr->wEnergizedId[i] = dquCiShortFromChar(pData); /*有电继电器*/
+						pData += 2u;
+
+						pOhlStr->wDeEnergizedId[i] = dquCiShortFromChar(pData); /*断电继电器*/
+						pData += 2u;
+					}
+				}
+				else
+				{
+					debug_infor_printf((const)"\R_OhlStructFromChar Error: chRelayGroupNum[%d] Error.\n", pOhlStr->chRelayGroupNum);
+					rtnvalue = CI_ERROR;  /*组数非法，返回失败*/
+				}
+			}
+			else
+			{
+				debug_infor_printf((const)"\R_OhlStructFromChar Error: wBelongOcId[%d] Error.\n", pOhlStr->wBelongOcId);
+				rtnvalue = CI_ERROR;  /*OC ID非法，返回失败*/
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\R_OhlStructFromChar Error: wOhlId[%d] Error.\n", pOhlStr->wOhlId);
+			rtnvalue = CI_ERROR;  /*分区ID非法，返回失败*/
+		}
+
+	}
+
+	return rtnvalue;
+
+}
+
+/*********************************************
+* 函数功能：从FS读取数据到ECS继电器结构体
+* 参数说明：UINT8* pDataAddr 数据地址
+*           pEcsStrRelayEcsStruct* pEcsStr ECS数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 R_EcsRelayDataFromChar(UINT8* pDataAddr, RelayEcsStruct* pEcsStr)
+{
+	UINT8* pData = pDataAddr;
+	UINT8 cRetVal = CI_ERROR;
+
+	if ((NULL != pDataAddr) && (NULL != pEcsStr))
+	{
+		cRetVal = CI_SUCCESS;
+
+		pEcsStr->EcsId = dquCiShortFromChar(pData);  /*ECS ID */
+		pData += 2U;
+		if ((0U < pEcsStr->EcsId) && (ECS_MAX_NUM >  pEcsStr->EcsId))
+		{
+			pEcsStr->BelongOcId = dquCiShortFromChar(pData);  /*OC ID*/
+			pData += 2U;
+			if ((0U != pEcsStr->BelongOcId) && (UINT16_MAX != pEcsStr->BelongOcId))
+			{
+				pEcsStr->FanUpRelayId = dquCiShortFromChar(pData);  /*风向为逻辑正方向继电器ID*/
+				pData += 2U;
+				if ((0U != pEcsStr->FanUpRelayId) && (UINT16_MAX != pEcsStr->FanUpRelayId))
+				{
+					pEcsStr->FanDownRelayId = dquCiShortFromChar(pData);  /*风向为逻辑反方向继电器ID*/
+					pData += 2U;
+					if ((0U != pEcsStr->FanDownRelayId) && (UINT16_MAX != pEcsStr->FanDownRelayId))
+					{
+						/*返回成功*/
+					}
+					else
+					{
+						debug_infor_printf((const)"\nR_EcsRelayDataFromChar Error: FanDownRelayId[%d] Error.\n", pEcsStr->FanDownRelayId);
+						cRetVal = CI_ERROR;  /*FanDown继电器ID非法，返回失败*/
+					}
+				}
+				else
+				{
+					debug_infor_printf((const)"\nR_EcsRelayDataFromChar Error: FanUpRelayId[%d] Error.\n", pEcsStr->FanUpRelayId);
+					cRetVal = CI_ERROR;  /*FanUp继电器ID非法，返回失败*/
+				}
+			}
+			else
+			{
+				debug_infor_printf((const)"\nR_EcsRelayDataFromChar Error: BelongOcId[%d] Error.\n", pEcsStr->BelongOcId);
+				cRetVal = CI_ERROR;  /*OC ID非法，返回失败*/
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\nR_EcsRelayDataFromChar Error: EcsId[%d] Error.\n", pEcsStr->EcsId);
+			cRetVal = CI_ERROR;  /*ECS ID非法，返回失败*/
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;
+	}
+
+	return cRetVal;
+}

TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.h

@@ -30,6 +30,13 @@ UINT8 RelayConfigDataStruFromChar(UINT8 * pDataAddr,RelayConfigDataStruct* pRela
 *********************************************/
 UINT8 R_EmegencyStopStructFromChar(UINT8 * pDataAddr,Relay_EmgcyStpStruct* pEmgcyStpStr,UINT16 realRowLen);
 
+/*********************************************
+*函数功能：初始化全线紧急停车按钮继电器结构体
+*参数说明：pDataAddr数据地址，  pCesbStpStr紧急停车按钮继电器配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 R_CesbStructFromChar(UINT8 * pDataAddr, Relay_CesbStruct* pCesbStpStr);
+
 /*********************************************
 *函数功能：从数据到屏蔽门继电器结构体
 *参数说明：pDataAddr数据地址，  pScrnStr屏蔽门继电器配置数据结构体指针,UINT16 rowLen 一行数据的长度
@@ -107,6 +114,26 @@ UINT8 R_GaragedoorStructFromChar(UINT8 * pDataAddr,Relay_GaragedoorStruct* pGara
 *********************************************/
 UINT8 R_SpksDataFromChar(UINT8 * pDataAddr,RelaySpksStruct* pSpksStr,UINT16 realRowLen);
 
+/*********************************************
+* 函数功能：从FS读取数据到SSKS闪灯稳灯继电器结构体
+* 参数说明：pDataAddr数据地址
+*           pSsksStr SSKS数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 R_SsksLightRelayDataFromChar(UINT8* pDataAddr, RelaySsksLightStruct* pSsksStr);
+
+/*********************************************
+* 函数功能：从FS读取数据到联络线旁路继电器结构体
+* 参数说明：pDataAddr数据地址
+*           pOverrideStr 联络线旁路数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 20260311
+*********************************************/
+UINT8 R_ConnectOverrideDataFromChar(UINT8* pDataAddr, ConnectOverrideStruct* pOverrideStr);
+
 /*********************************************
 *函数功能：从数据到门禁继电器结构体
 *参数说明：pDataAddr数据地址，  pMjStr 门禁数据结构体指针   realRowLen 每一行数据长度
@@ -149,4 +176,21 @@ UINT8 R_ReverseCutStrFromChar(UINT8 * pDataAddr, Relay_ReverseCutStruct * pRever
 * cgh-合并CID-3037-3：
 *********************************************/
 UINT8 R_OCIndicStruFromChar(UINT8* pDataAddr, OCStationIndicConfigDataStru* pIndicStru);
+/*********************************************
+*函数功能：从数据到接触网继电器结构体
+*参数说明：pDataAddr数据地址，  pOhlStr 接触网继电器配置数据结构体指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 R_OhlStructFromChar(UINT8* pDataAddr, Relay_OhlStruct* pOhlStr);
+
+/*********************************************
+* 函数功能：从FS读取数据到ECS继电器结构体
+* 参数说明：UINT8* pDataAddr 数据地址
+*           pEcsStrRelayEcsStruct* pEcsStr ECS数据结构体指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 R_EcsRelayDataFromChar(UINT8* pDataAddr, RelayEcsStruct* pEcsStr);
+
 #endif

TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c

@@ -335,6 +335,102 @@ UINT8 InitRelay_EmgcyStpStru(CHAR* CIDataName)
 	return rtnValue;
 }
 
+/*********************************************
+*函数功能：填充全线紧急停车按钮继电器结构体数组
+*参数说明：CIDataName件指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 InitRelay_CESBStru(CHAR* CIDataName)
+{
+	UINT8 funcRtn = 0U;
+	Relay_CesbStruct* pCentreEsbStr = NULL;   /*临时继电器变量*/
+	UINT8* pDataAddr = NULL;         /*数据地址*/
+	UINT32 DataSize = 0U;          /*数据大小（字节数）*/
+	UINT16 j = 0U;
+	UINT8 rtnValue = 0U;
+	UINT32 excelId = 0U; /*excel id*/
+	UINT32 sheetId = 0U; /*sheet id*/
+	UINT32 rowLen = 0U; /*读到的行数*/
+	UINT16 realRowLen = 0U;/*实际表一行的长度*/
+	UINT8 localCiPattern = 0U; /*本CI模式*/
+
+							   /*已经初始化了，不用老是调用执行过程*/
+	if (RelayData.pCentreEsbStr != NULL)
+	{
+		rtnValue = 1u;
+	}
+	else
+	{
+		localCiPattern = GetLocalCiPattern();
+		excelId = OC_DATA_TYPE;
+		sheetId = OC_RELAY_CENTER_ESB_ID;
+		/*读取 默认行车序列  数据*/
+		funcRtn = dquGetConfigDataNew(CIDataName, excelId, sheetId, &pDataAddr, &DataSize, &rowLen);
+		if (0u == funcRtn)
+		{
+			/*函数调用失败*/
+			rtnValue = 0U;
+		}
+		else
+		{
+			/*求得个数*/
+			if ((0U != DataSize) && (0U != rowLen))
+			{
+				if (0U != DataSize % rowLen)
+				{
+					/*求得个数不为整数，数据错误*/
+					debug_infor_printf((const)"\nCI_CI_DATA,CESB Btn len %d not equal to fs", rowLen);
+					rtnValue = 0u;
+				}
+				else
+				{
+					realRowLen = (UINT16)(DataSize / rowLen);
+					RelayDataLen.RelayCesbStrLen = (UINT16)rowLen;
+
+
+					if (DataSize < realRowLen)
+					{
+						rtnValue = 0U;
+					}
+					else
+					{
+						/*动态申请空间*/
+						RelayData.pCentreEsbStr = (Relay_CesbStruct*)MyNew((UINT32)((sizeof(Relay_CesbStruct)) * (RelayDataLen.RelayCesbStrLen)));
+						/*动态申请空间失败*/
+						if (NULL == RelayData.pCentreEsbStr)
+						{
+							RelayDataLen.RelayCesbStrLen = 0u;
+							rtnValue = 0u;
+						}
+						else
+						{							
+							/*内存先设为无效*/
+							(void)CommonMemSet(RelayData.pCentreEsbStr,  (UINT32)sizeof(Relay_CesbStruct) * RelayDataLen.RelayCesbStrLen, 0x00, (UINT32)sizeof(Relay_CesbStruct) * RelayDataLen.RelayCesbStrLen);
+							/*解析数据到 默认行车序列 结构体数组 */
+							rtnValue = 1u;
+							for (j = 0u; j < RelayDataLen.RelayCesbStrLen; j++)
+							{
+								pCentreEsbStr = RelayData.pCentreEsbStr + j;
+
+								/*填充数据结构体*/
+								rtnValue &= R_CesbStructFromChar(pDataAddr, pCentreEsbStr);
+								pDataAddr += realRowLen;
+
+							}
+						}
+					}
+				}
+			}
+			else
+			{
+				rtnValue = 1U;
+				RelayDataLen.RelayCesbStrLen = 0U;
+			}
+		}
+	}
+	return rtnValue;
+}
+
 /*********************************************
 *函数功能：填充屏蔽门继电器结构体数组
 *参数说明：CIDataName件指针          
@@ -1249,6 +1345,220 @@ UINT8 InitRelaySpksStru(CHAR* CIDataName)
 	return rtnValue;
 }
 
+/*********************************************
+* 函数功能：初始化SSKS闪灯稳灯继电器结构体
+* 参数说明：CIDataName件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2025.12.15
+*********************************************/
+UINT8 InitRelaySsksLightStru(CHAR* CIDataName)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT32 dwExcelId = 0U;  /*表ID*/
+	UINT32 dwSheetId = 0U;  /*表单编号*/
+	UINT8 cFuncRtn = CI_ERROR;
+	UINT8* pDataAddr = NULL;  /*数据地址*/
+	UINT32 dwDataSize = 0U;  /*数据大小（字节数）*/	
+	UINT16 wRowCount = 0U;  /*读到的行数*/
+	UINT16 wRealRowLen = 0U;  /*表一行的长度*/
+	UINT16 ii = 0U;
+	RelaySsksLightStruct* pRelaySpksStr = NULL;
+	
+	if (NULL != RelayData.pRelaySsksLightStr)
+	{
+		cRetVal = CI_SUCCESS;  /*已经初始化，返回成功*/
+	}
+	else
+	{
+		/*读取SSKS闪灯稳灯继电器表*/
+		dwExcelId = (UINT32)OC_DATA_TYPE;
+		dwSheetId = (UINT32)OC_RELAY_SSKS_LIGHT_ID;
+		cFuncRtn = dquGetConfigDataNew(CIDataName, dwExcelId, dwSheetId, &pDataAddr, &dwDataSize, &wRowCount);
+		if (CI_SUCCESS == cFuncRtn)
+		{		
+			if ((0U != dwDataSize) && (0U != wRowCount))
+			{
+				if (0U == (dwDataSize % wRowCount))
+				{
+					if (SSKS_LIGHT_RELAY_SUM_MAX >= wRowCount)
+					{
+						wRealRowLen = (UINT16)(dwDataSize / wRowCount);
+						RelayDataLen.RelaySsksLightStrLen = wRowCount;
+
+						/* 动态申请空间 */
+						RelayData.pRelaySsksLightStr = (RelaySsksLightStruct*)MyNew((UINT32)(sizeof(RelaySsksLightStruct) * RelayDataLen.RelaySsksLightStrLen));
+
+						if (NULL != RelayData.pRelaySsksLightStr)
+						{
+							cRetVal = CI_SUCCESS;
+							/*读表前现将数据清零*/
+							(void)CommonMemSet(RelayData.pRelaySsksLightStr, (UINT32)(sizeof(RelaySsksLightStruct) * RelayDataLen.RelaySsksLightStrLen), (UINT8)0U, (UINT32)(sizeof(RelaySsksLightStruct) * RelayDataLen.RelaySsksLightStrLen));
+
+							/*解析数据到结构体*/
+							for (ii = 0U; ii < RelayDataLen.RelaySsksLightStrLen; ii++)
+							{
+								pRelaySpksStr = RelayData.pRelaySsksLightStr + ii;
+
+								/*填充数据结构体*/
+								cFuncRtn = R_SsksLightRelayDataFromChar(pDataAddr, pRelaySpksStr);
+								pDataAddr += wRealRowLen;
+
+								if (CI_SUCCESS != cFuncRtn)
+								{
+									cRetVal = CI_ERROR;
+									break;
+								}
+								else
+								{
+									/*继续读取*/
+								}
+							}
+						}
+						else
+						{
+							debug_infor_printf((const)"\nInitRelaySsksLightStru Error: Apply Memory Error.\n");
+							RelayDataLen.RelaySsksLightStrLen = 0U;  /* 动态申请空间失败，长度重置零 */
+							cRetVal = CI_ERROR;  /*申请空间失败，返回失败*/
+						}
+					}
+					else
+					{
+						debug_infor_printf((const)"\nInitRelaySsksLightStru Error: RowCount[%d] Exceed Max[%d].\n", wRowCount, SSKS_LIGHT_RELAY_SUM_MAX);
+						cRetVal = CI_ERROR;  /*行数超限，返回失败*/
+					}
+				}
+				else
+				{
+					debug_infor_printf((const)"\nInitRelaySsksLightStru Error: RowCount %d not equal to fs\n", wRowCount);
+					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (dwExcelId << 8U) + dwSheetId, PRINT_ONCE);
+					cRetVal = CI_ERROR;  /*长度不一致，返回失败*/
+				}
+			}
+			else
+			{
+				RelayDataLen.RelaySsksLightStrLen = 0U;
+				cRetVal = CI_SUCCESS;  /*未配置数据，返回成功*/
+			}			
+		}
+		else
+		{
+			debug_infor_printf((const)"\nInitRelaySsksLightStru Error: Read OC_RELAY_SSKS_LIGHT Table Error.\n");
+			cRetVal = CI_ERROR;  /*读表失败，返回失败*/
+		}
+	}
+
+	return cRetVal;
+}
+
+/*********************************************
+* 函数功能：初始化联络线旁路继电器结构体
+* 参数说明：CIDataName件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By wyd 2026.3.11
+*********************************************/
+UINT8 InitConnectOverrideStru(CHAR* CIDataName)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT32 dwExcelId = 0U;  /*表ID*/
+	UINT32 dwSheetId = 0U;  /*表单编号*/
+	UINT8 cFuncRtn = CI_ERROR;
+	UINT8* pDataAddr = NULL;  /*数据地址*/
+	UINT32 dwDataSize = 0U;  /*数据大小（字节数）*/
+	UINT16 wRowCount = 0U;  /*读到的行数*/
+	UINT16 wRealRowLen = 0U;  /*表一行的长度*/
+	UINT16 ii = 0U;
+	ConnectOverrideStruct* pRelayStr = NULL;
+
+	if (NULL != RelayData.pRelayConnectOverrideStr)
+	{
+		cRetVal = CI_SUCCESS;  /*已经初始化，返回成功*/
+	}
+	else
+	{
+		/*读取联络线旁路继电器表*/
+		dwExcelId = (UINT32)OC_DATA_TYPE;
+		dwSheetId = (UINT32)OC_CONNECT_OVERRIDE_ID;
+		cFuncRtn = dquGetConfigDataNew(CIDataName, dwExcelId, dwSheetId, &pDataAddr, &dwDataSize, &wRowCount);
+		if (CI_SUCCESS == cFuncRtn)
+		{
+			if ((0U != dwDataSize) && (0U != wRowCount))
+			{
+				if (0U == (dwDataSize % wRowCount))
+				{
+					if (CONNECT_OVERRIDE_RELAY_SUM_MAX >= wRowCount)
+					{
+						wRealRowLen = (UINT16)(dwDataSize / wRowCount);
+						RelayDataLen.RelayConnectOverrideStrLen = wRowCount;
+
+						/* 动态申请空间 */
+						RelayData.pRelayConnectOverrideStr = (ConnectOverrideStruct*)MyNew((UINT32)(sizeof(ConnectOverrideStruct) * RelayDataLen.RelayConnectOverrideStrLen));
+
+						if (NULL != RelayData.pRelayConnectOverrideStr)
+						{
+							cRetVal = CI_SUCCESS;
+							/*读表前现将数据清零*/
+							(void)CommonMemSet(RelayData.pRelayConnectOverrideStr, 
+								(UINT32)(sizeof(ConnectOverrideStruct) * RelayDataLen.RelayConnectOverrideStrLen),
+								(UINT8)0U, (UINT32)(sizeof(ConnectOverrideStruct) * RelayDataLen.RelayConnectOverrideStrLen));
+
+							/*解析数据到结构体*/
+							for (ii = 0U; ii < RelayDataLen.RelayConnectOverrideStrLen; ii++)
+							{
+								pRelayStr = RelayData.pRelayConnectOverrideStr + ii;
+
+								/*填充数据结构体*/
+								cFuncRtn = R_ConnectOverrideDataFromChar(pDataAddr, pRelayStr);
+								pDataAddr += wRealRowLen;
+
+								if (CI_SUCCESS != cFuncRtn)
+								{
+									cRetVal = CI_ERROR;
+									break;
+								}
+								else
+								{
+									/*继续读取*/
+								}
+							}
+						}
+						else
+						{
+							debug_infor_printf((const)"\nInitConnectOverrideStru Error: Apply Memory Error.\n");
+							RelayDataLen.RelayConnectOverrideStrLen = 0U;  /* 动态申请空间失败，长度重置零 */
+							cRetVal = CI_ERROR;  /*申请空间失败，返回失败*/
+						}
+					}
+					else
+					{
+						debug_infor_printf((const)"\nInitConnectOverrideStru Error: RowCount[%d] Exceed Max[%d].\n", wRowCount, CONNECT_OVERRIDE_RELAY_SUM_MAX);
+						cRetVal = CI_ERROR;  /*行数超限，返回失败*/
+					}
+				}
+				else
+				{
+					debug_infor_printf((const)"\nInitConnectOverrideStru Error: RowCount %d not equal to fs\n", wRowCount);
+					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (dwExcelId << 8U) + dwSheetId, PRINT_ONCE);
+					cRetVal = CI_ERROR;  /*长度不一致，返回失败*/
+				}
+			}
+			else
+			{
+				RelayDataLen.RelayConnectOverrideStrLen = 0U;
+				cRetVal = CI_SUCCESS;  /*未配置数据，返回成功*/
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\nInitConnectOverrideStru Error: Read OC_CONNECT_OVERRIDE Table Error.\n");
+			cRetVal = CI_ERROR;  /*读表失败，返回失败*/
+		}
+	}
+
+	return cRetVal;
+}
+
 /*********************************************
 *函数功能：初始化门禁解锁继电器结构体数组
 *参数说明：CIDataName件指针
@@ -1647,3 +1957,204 @@ UINT8 InitRelay_ReverseCutStru(CHAR* CIDataName)
 	return rtnValue;
 }
 
+/*********************************************
+*函数功能：填充接触网继电器结构体数组
+*参数说明：CIDataName件指针
+*返回值：0，失败；1，成功
+*********************************************/
+UINT8 InitRelay_OhlStru(CHAR* CIDataName)
+{
+	UINT8 funcRtn = 0U;
+	Relay_OhlStruct* pOhlStr = NULL;   /*接触网继电器变量*/
+	UINT8* pDataAddr = NULL;           /*数据地址*/
+	UINT32 DataSize = 0U;              /*数据大小（字节数）*/
+	UINT16 j = 0U;
+	UINT8 rtnValue = 0U;
+	UINT8 localCiPattern = 0U;
+	UINT32 dwExcelId = 0u; /*excel id*/
+	UINT32 dwSheetId = 0u; /*sheet id*/
+	UINT32 dwRowLen = 0u; /*行长度*/
+	UINT16 wRealRowCount = 0U; /*行数*/
+	
+	/*已经初始化了，不用老是调用执行过程*/
+	if (NULL != RelayData.pRelayOhlStr)
+	{
+		rtnValue = 1u;
+	}
+	else
+	{
+		dwExcelId = OC_DATA_TYPE;
+		dwSheetId = OC_RELAY_OHL_ID;
+
+		/*读取进路调车同意继电器数据表*/
+		funcRtn = dquGetConfigDataNew(CIDataName, dwExcelId, dwSheetId, &pDataAddr, &DataSize, &wRealRowCount);
+		if (0U == funcRtn)
+		{
+			/*没有表*/
+			rtnValue = 0U;
+			debug_infor_printf((const)"\nOC_OHL_RELAY_ID NO IN FS\n");
+		}
+		else
+		{
+			rtnValue = 1U;
+
+			if ((0U != DataSize) && (0U != wRealRowCount))
+			{
+				if (0U != (DataSize % wRealRowCount))
+				{
+					/*求得个数不为整数，数据错误*/
+					debug_infor_printf((const)"\nCI_RELAY_DATA,RELAY_OHL len %d not equal to fs", (DataSize % wRealRowCount));
+					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, ((UINT32)(dwExcelId << 8U)) + dwSheetId, PRINT_ONCE);
+					rtnValue = 0U;
+				}
+				else
+				{
+					RelayDataLen.RelayOhlStrLen = wRealRowCount;/*计算结构体个数*/
+					dwRowLen = DataSize / wRealRowCount;
+
+					/*动态申请空间*/
+					RelayData.pRelayOhlStr = (Relay_OhlStruct*)MyNew((UINT32)(sizeof(Relay_OhlStruct) * RelayDataLen.RelayOhlStrLen));
+
+					if (NULL == RelayData.pRelayOhlStr)
+					{/*动态申请空间失败*/
+						RelayDataLen.RelayOhlStrLen = 0U;
+						rtnValue = 0U;
+					}
+					else
+					{
+						/*内存先设为无效*/
+						(void)memset(RelayData.pRelayOhlStr, 0x00, sizeof(Relay_OhlStruct) * RelayDataLen.RelayOhlStrLen);
+						/*解析数据到 默认行车序列 结构体数组 */
+
+						for (j = 0u; j < RelayDataLen.RelayOhlStrLen; j++)
+						{
+							if (1U == rtnValue)
+							{
+								pOhlStr = RelayData.pRelayOhlStr + j;
+
+								/*填充数据结构体*/
+								rtnValue &= R_OhlStructFromChar(pDataAddr, pOhlStr);
+								pDataAddr += dwRowLen;
+							}
+							else
+							{
+								break;
+							}
+						}
+					}
+				}
+			}
+			else
+			{
+				;
+			}
+		}
+	}
+	return rtnValue;
+}
+
+/*********************************************
+* 函数功能：初始化ECS继电器结构体
+* 参数说明：CIDataName件指针
+* 返 回 值：0 失败
+*           1 成功
+* Created By LQ 2026.01.24
+*********************************************/
+UINT8 InitRelayEcsStru(CHAR* CIDataName)
+{
+	UINT8 cRetVal = CI_ERROR;
+	UINT32 dwExcelId = 0U;  /*表ID*/
+	UINT32 dwSheetId = 0U;  /*表单编号*/
+	UINT8 cFuncRtn = CI_ERROR;
+	UINT8* pDataAddr = NULL;  /*数据地址*/
+	UINT32 dwDataSize = 0U;  /*数据大小（字节数）*/
+	UINT16 wRowCount = 0U;  /*读到的行数*/
+	UINT16 wRealRowLen = 0U;  /*表一行的长度*/
+	UINT16 ii = 0U;
+	RelayEcsStruct* pRelayEcsStr = NULL;
+
+	if (NULL != RelayData.pRelayEcsStr)
+	{
+		cRetVal = CI_SUCCESS;  /*已经初始化，返回成功*/
+	}
+	else
+	{
+		/*读取ECS继电器表*/
+		dwExcelId = (UINT32)OC_DATA_TYPE;
+		dwSheetId = (UINT32)OC_RELAY_ECS_ID;
+		cFuncRtn = dquGetConfigDataNew(CIDataName, dwExcelId, dwSheetId, &pDataAddr, &dwDataSize, &wRowCount);
+		if (CI_SUCCESS == cFuncRtn)
+		{
+			if ((0U != dwDataSize) && (0U != wRowCount))
+			{
+				if (0U == (dwDataSize % wRowCount))
+				{
+					if (ECS_MAX_NUM > wRowCount)
+					{
+						wRealRowLen = (UINT16)(dwDataSize / wRowCount);
+						RelayDataLen.RelayEcsStrLen = wRowCount;
+
+						/* 动态申请空间 */
+						RelayData.pRelayEcsStr = (RelayEcsStruct*)MyNew((UINT32)(sizeof(RelayEcsStruct) * RelayDataLen.RelayEcsStrLen));
+
+						if (NULL != RelayData.pRelayEcsStr)
+						{
+							cRetVal = CI_SUCCESS;
+							/*读表前现将数据清零*/
+							(void)CommonMemSet(RelayData.pRelayEcsStr, (UINT32)(sizeof(RelayEcsStruct) * RelayDataLen.RelayEcsStrLen), (UINT8)0U, (UINT32)(sizeof(RelayEcsStruct) * RelayDataLen.RelayEcsStrLen));
+
+							/*解析数据到结构体*/
+							for (ii = 0U; ii < RelayDataLen.RelayEcsStrLen; ii++)
+							{
+								pRelayEcsStr = RelayData.pRelayEcsStr + ii;
+
+								/*填充数据结构体*/
+								cFuncRtn = R_EcsRelayDataFromChar(pDataAddr, pRelayEcsStr);
+								pDataAddr += wRealRowLen;
+
+								if (CI_SUCCESS != cFuncRtn)
+								{
+									cRetVal = CI_ERROR;
+									break;
+								}
+								else
+								{
+									/*继续读取*/
+								}
+							}
+						}
+						else
+						{
+							debug_infor_printf((const)"\nInitRelayEcsStru Error: Apply Memory Error.\n");
+							RelayDataLen.RelayEcsStrLen = 0U;  /* 动态申请空间失败，长度重置零 */
+							cRetVal = CI_ERROR;  /*申请空间失败，返回失败*/
+						}
+					}
+					else
+					{
+						debug_infor_printf((const)"\nInitRelayEcsStru Error: RowCount[%d] Exceed Or Equal Max[%d].\n", wRowCount, ECS_MAX_NUM);
+						cRetVal = CI_ERROR;  /*行数超限，返回失败*/
+					}
+				}
+				else
+				{
+					debug_infor_printf((const)"\nInitRelayEcsStru Error: RowCount %d not equal to fs\n", wRowCount);
+					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (dwExcelId << 8U) + dwSheetId, PRINT_ONCE);
+					cRetVal = CI_ERROR;  /*长度不一致，返回失败*/
+				}
+			}
+			else
+			{
+				RelayDataLen.RelayEcsStrLen = 0U;
+				cRetVal = CI_SUCCESS;  /*未配置数据，返回成功*/
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"\nInitRelayEcsStru Error: Read OC_RELAY_ECS Table Error.\n");
+			cRetVal = CI_ERROR;  /*读表失败，返回失败*/
+		}
+	}
+
+	return cRetVal;
+}