Merge branch 'test/9.9外网接收时间测试' into dev/9.9

TSCP/Makefile

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

TSCP/src/APP/APP_API.c

@@ -244,7 +244,7 @@ void APP_API_Data_Init()
 	cDevType = (UINT8)((locTypeId >> 8U) & 0x00FFU);  /*RC/CI类型*/
 													 
 	
-	cRetVal = CiPatternInit((const)DataPath); /*初始化当前联锁类型配置数据*/
+	cRetVal = RciCommonConfigDataInit((const)DataPath); /*初始化当前联锁类型配置数据*/
 	if ((CI_SUCCESS == cRetVal) && (CI_SUCCESS == funcRetVal)) /*初始化当前联锁类型配置数据*/
 	{
 		cSystemWorkType = GetSystemWorkType();
@@ -717,46 +717,23 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
 {
 	ENUM_CM_RECCUSEB retVal = ENUM_CM_CC; /*返回值*/
 	CM_UINT8 devType = 0U; /*设备类型*/
-	CM_UINT8 devId = 0U; /*设备ID*/
 	CM_UINT16 wAtsGtWayDevTypeId = 0U;
-	UINT8 chLocalCiType = 0U; /*本联锁属性*/
-	UINT8 chDstCiType = 0U; /*本联锁属性*/
-	UINT8 chCldScxCommMode = 0U;
 	UINT8 chWorkType = 0U; /*双系工作模式*/
 	UINT8 cControlState = 0U;/*主备用模式*/
 	UINT8 cRcWorkMode = 0u;/*RC工作模式*/
 	UINT8 chResult = CI_ERROR; /*联锁属性检查结果*/
+	UINT8 serialGroup = 0U; /*串口通信组索引*/
 
 	wAtsGtWayDevTypeId = GetTiocTrnsmtGtwyDevTypeId();
 	/**使用通控板与ATS网关通信*/
 	if (dstDevTypeId != wAtsGtWayDevTypeId)
 	{
 		devType = (CM_UINT8)((dstDevTypeId >> 8) & 0xFF);
-		devId = (CM_UINT8)(dstDevTypeId & 0xFF);
-
-		chLocalCiType = GetLocalCiType();
-		chDstCiType = GetCiType(devId);
-		chCldScxCommMode = GetCiFunctionSwitchConfig(SCX_CLD_INTERFACE_TYPE);
 		chWorkType = GetSystemWorkType();
 		cControlState = GetLocalCiBackUpPattern();
 		cRcWorkMode = GetLocalRcWorkMode();
 
-		if ((SCX_CLD_SERIAL_PORT_COMM == chCldScxCommMode) && (CI_SYSTEM_TYPE_RCI == devType))
-		{
-			if (((CI_TYPE_CLD == chLocalCiType) && (CI_TYPE_SCX == chDstCiType)) || ((CI_TYPE_SCX == chLocalCiType) && (CI_TYPE_CLD == chDstCiType)))
-			{
-				/*串口通信要求双方一个为车辆段一个为试车线*/
-				chResult = CI_SUCCESS;
-			}
-			else
-			{
-				; /*CI类型错误，返回失败*/
-			}
-		}
-		else
-		{
-			; /*不为串口通信，此时不对本地CI类型及对方CI类型进行判断*/
-		}
+		chResult = IsSerialDevice(dstDevTypeId, &serialGroup);
 
 		if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType)
 			|| (CI_SUCCESS == chResult)

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

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

@@ -443,17 +443,17 @@ UINT32 CopyValidSetRcVobcDataStru(const UINT8* pCurCiAppDataPointer, void* pData
 
 		for (i = 0u; i < ValidIdNum; i++)
 		{
-			pDstAddr = (UINT8*)pDataStru + struLength * i;
-
-			/*�ṹ��Ԫ��ǰ�����ֽ�IDΪ0ʱ������Ч����,�˴����˵������Ч��*/
-			if (0u != ShortFromCharLE(pDstAddr))
+			if (i < struNum)
 			{
-				(void)memcpy(pDstAddr, pCurCiAppDataPointer + curIndex, struLength);
+				pDstAddr = (UINT8*)pDataStru + struLength * i;
+				(void)CommonMemCpy((void*)pDstAddr, (UINT32)struLength, (const void*)(pCurCiAppDataPointer + curIndex), (UINT32)struLength);
 				curIndex += (UINT32)struLength;
 			}
 			else
 			{
-				/*��ִ���κβ���*/
+				curIndex += (UINT32)struLength;
+
+				debug_infor_printf((const)"ERROR: SetValidIdNum = %d\n", i);
 			}
 		}
 	}
@@ -1618,19 +1618,22 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		pCiAppDataPointer[curIndex] = gDyTestNum;
 		curIndex += 1U;
 
-		/*�����г�Զ��ɸѡ�ṹ������*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(TrainAtsScreenStru)* TRAIN_SUM_MAX), (void*)(&gszAtsScreenInfo), (UINT32)(sizeof(TrainAtsScreenStru)* TRAIN_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(TrainAtsScreenStru) * TRAIN_SUM_MAX);
-
-
-		/*����Զ��ɸѡ�г�����*/
-		pCiAppDataPointer[curIndex] = gAtsScreenNum;
-		curIndex += 1U;
+		/*ZC����������CBTC�г���ѹ��Ϣ*/
+		pCiAppDataPointer[curIndex] = gCbtcCrossNumZc;
+		curIndex += 1u;
 
+		for (ii = 0u; ii < gCbtcCrossNumZc; ii++)
+		{
+			ShortToChar(gCbtcCrossStructZc[ii].wSignalId, &pCiAppDataPointer[curIndex]);
+			curIndex += 2u;
+			pCiAppDataPointer[curIndex] = gCbtcCrossStructZc[ii].wTrainId;
+			curIndex += 1u;
+		}
+		
 		/*����һ��CRC*/
 		crcLength = curIndex - crcIndex;
 		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 RecvCiCmdDataStruCurSum-szNeighborCiInfo CRC:%x, Length:%d\n", crcResult, crcLength);
+		debug_infor_printf((const)"2oo2 RecvCiCmdDataStruCurSum-gDyTestNum CRC:%x, Length:%d\n", crcResult, crcLength);
 	}
 	return curIndex;
 }
@@ -2463,9 +2466,17 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 				gDyTestNum = pCiAppDataPointer[curIndex];
 				curIndex += 1U;
 
-				/*�����г�Զ��ɸѡ�ṹ������*/
-				(void)CommonMemCpy((void*)(&gszAtsScreenInfo), (UINT32)(sizeof(TrainAtsScreenStru)* TRAIN_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(TrainAtsScreenStru)* TRAIN_SUM_MAX));
-				curIndex = curIndex + (UINT32)(sizeof(TrainAtsScreenStru) * TRAIN_SUM_MAX);
+				/*ZC����������CBTC�г���ѹ��Ϣ*/
+				gCbtcCrossNumZc = pCiAppDataPointer[curIndex];
+				curIndex += 1u;
+
+				for (ii = 0u; ii < gCbtcCrossNumZc; ii++)
+				{
+					gCbtcCrossStructZc[ii].wSignalId = ShortFromChar(&pCiAppDataPointer[curIndex]);
+					curIndex += 2u;
+					gCbtcCrossStructZc[ii].wTrainId = pCiAppDataPointer[curIndex];
+					curIndex += 1u;
+				}
 
 				rtn = 1U;
 			}
@@ -2921,12 +2932,12 @@ UINT32 GetCiGeneralData(UINT8* pCiAppDataPointer)
 		curIndex = curIndex + curResult;
 
 		/*ͬ����������������ѩ������Ϣ*/
-		curResult = CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void*)(szSendCiAreaSnow), CI_COM_CI_MAX_NUM, (UINT16)sizeof(ToCiAreaSnowStruct));
-		curIndex = curIndex + curResult;
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (void*)(szSendCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
+		curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
 		/*ͬ�������������������ѩ��Ϣ*/
-		curResult = CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void*)(szRecvCiAreaSnow), CI_COM_CI_MAX_NUM, (UINT16)sizeof(ToCiAreaSnowStruct));
-		curIndex = curIndex + curResult;
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (void*)(szRecvCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
+		curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
 		/* ����������ѩ���� */
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_LocalSnowModel), (UINT32)sizeof(UINT8));
@@ -2958,6 +2969,56 @@ UINT32 GetCiGeneralData(UINT8* pCiAppDataPointer)
 		/*�뱾CIͨ�ŵ�Rc������ͨ����ͷ����������*/
 		curResult = CopyValidGetHlhtHeadCtxs(pCiAppDataPointer + curIndex, CI_SUM_MAX, (UINT16)sizeof(HLHTHeadContextStru), gSzRcHLHTHeadCtxs);
 		curIndex = curIndex + curResult;
+
+		/*ZC����������CBTC�г���ѹ��Ϣ*/
+		pCiAppDataPointer[curIndex] = gCbtcCrossNumZc;
+		curIndex += 1u;
+
+		for (ii = 0u; ii < gCbtcCrossNumZc; ii++)
+		{
+			ShortToChar(gCbtcCrossStructZc[ii].wSignalId, &pCiAppDataPointer[curIndex]);
+			curIndex += 2u;
+			pCiAppDataPointer[curIndex] = gCbtcCrossStructZc[ii].wTrainId;
+			curIndex += 1u;
+		}
+		/*����������������*/
+		for (ii = 0U; ii < g_VirtualCIStructData.virtualCiNum; ii++)
+		{
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].virtualCiId), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].chAllSignalBrightFlag) , (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].chAllSwitchYLockFlag), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8) , (const void*)(&g_VirtualCIStructData.virtualCi[ii].autoTriggerflag) , (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].cimode), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].chLabourCancelLinShiXianState) , (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwFlag), (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwjHunXianFLag) , (UINT32)sizeof(UINT8));
+			curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT32), (const void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwStartCycNum) , (UINT32)sizeof(UINT32));
+			curIndex = curIndex + (UINT32)sizeof(UINT32);
+
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT32), (const void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwValidCycNum) , (UINT32)sizeof(UINT32));
+			curIndex = curIndex + (UINT32)sizeof(UINT32);
+
+			/*ָʾ��״̬����*/
+			(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(VIRTUAL_CI_INDICATOR_SUM_MAX) * sizeof(IndicatorDataStruct) ,(const void*)(&g_VirtualCIStructData.virtualCi[ii].IndicatorData) , (UINT32)(VIRTUAL_CI_INDICATOR_SUM_MAX) * sizeof(IndicatorDataStruct));
+			curIndex = curIndex + (UINT32)((VIRTUAL_CI_INDICATOR_SUM_MAX) * sizeof(IndicatorDataStruct));
+		}
 	}
 
 	return curIndex;
@@ -3216,12 +3277,12 @@ UINT8 SetCiGeneralData(const UINT8* pCiAppDataPointer, const UINT32 len)
 			curIndex = curIndex + curResult;
 
 			/*ͬ����������������ѩ������Ϣ*/
-			curResult = CopyValidSetDataStru(pCiAppDataPointer + curIndex, (void*)(szSendCiAreaSnow), CI_COM_CI_MAX_NUM, (UINT16)sizeof(ToCiAreaSnowStruct));
-			curIndex = curIndex + curResult;
+			(void)CommonMemCpy((void*)(szSendCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
+			curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
 			/*ͬ�������������������ѩ��Ϣ*/
-			curResult = CopyValidSetDataStru(pCiAppDataPointer + curIndex, (void*)(szRecvCiAreaSnow), CI_COM_CI_MAX_NUM, (UINT16)sizeof(ToCiAreaSnowStruct));
-			curIndex = curIndex + curResult;
+			(void)CommonMemCpy((void*)(szRecvCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
+			curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
 			/* ����������ѩ���� */
 			(void)CommonMemCpy((void*)(&g_LocalSnowModel), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
@@ -3254,6 +3315,56 @@ UINT8 SetCiGeneralData(const UINT8* pCiAppDataPointer, const UINT32 len)
 			curResult = CopyValidSetHlhtHeadCtxs(pCiAppDataPointer + curIndex, CI_SUM_MAX, (UINT16)sizeof(HLHTHeadContextStru), gSzRcHLHTHeadCtxsCiToRc);
 			curIndex = curIndex + curResult;
 
+			/*ZC����������CBTC�г���ѹ��Ϣ*/
+			gCbtcCrossNumZc = pCiAppDataPointer[curIndex];
+			curIndex += 1u;
+
+			for (ii = 0u; ii < gCbtcCrossNumZc; ii++)
+			{
+				gCbtcCrossStructZc[ii].wSignalId = ShortFromChar(&pCiAppDataPointer[curIndex]);
+				curIndex += 2u;
+				gCbtcCrossStructZc[ii].wTrainId = pCiAppDataPointer[curIndex];
+				curIndex += 1u;
+			}
+
+			/*����������������*/
+			for (ii = 0U; ii < g_VirtualCIStructData.virtualCiNum; ii++)
+			{
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].virtualCiId) , (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].chAllSignalBrightFlag), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].chAllSwitchYLockFlag), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].autoTriggerflag), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].cimode) , (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].chLabourCancelLinShiXianState) , (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwFlag), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwjHunXianFLag), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
+				curIndex = curIndex + (UINT32)sizeof(UINT8);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwStartCycNum) , (UINT32)sizeof(UINT32), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT32));
+				curIndex = curIndex + (UINT32)sizeof(UINT32);
+
+				(void)CommonMemCpy((void*)(&g_VirtualCIStructData.virtualCi[ii].ZfwValidCycNum), (UINT32)sizeof(UINT32), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT32));
+				curIndex = curIndex + (UINT32)sizeof(UINT32);
+
+				/*ָʾ��״̬����*/
+				(void)CommonMemCpy((void*)(g_VirtualCIStructData.virtualCi[ii].IndicatorData), (UINT32)(VIRTUAL_CI_INDICATOR_SUM_MAX) * sizeof(IndicatorDataStruct), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(VIRTUAL_CI_INDICATOR_SUM_MAX) * sizeof(IndicatorDataStruct));
+				curIndex = curIndex + (UINT32)((VIRTUAL_CI_INDICATOR_SUM_MAX) * sizeof(IndicatorDataStruct));
+			}
+
 			rtn = 1u;
 		}
 		else
@@ -3409,6 +3520,8 @@ UINT32 CopyValidGetSigDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, Signal
 				curIndex++;
 				*(pCurCiAppDataPointer + curIndex) = pstSignalDataStruCC[i].SignalCrossState;
 				curIndex++;
+				*(pCurCiAppDataPointer + curIndex) = pstSignalDataStruCC[i].wCrossTacsTrainId;
+				curIndex++;
 			}
 			else
 			{
@@ -3475,6 +3588,8 @@ UINT32 CopyValidSetSigDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, Signal
 				curIndex++;
 				pstSignalDataStruCC[devId].SignalCrossState = *(pCurCiAppDataPointer + curIndex);
 				curIndex++;
+				pstSignalDataStruCC[devId].wCrossTacsTrainId = *(pCurCiAppDataPointer + curIndex);
+				curIndex++;
 
 			}
 			else
@@ -3648,19 +3763,19 @@ UINT32 CopyValidGetLogicSecDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum,Lo
 		
 				for (j = 0U; j < pstLogSecDataStruCC[i].chTrainInfoSum; j++)
 				{
-					ShortToChar(pstLogSecDataStruCC[i].szTrainResData->wTrainId, (pCurCiAppDataPointer + curIndex));
+					ShortToChar(pstLogSecDataStruCC[i].szTrainResData[j].wTrainId, (pCurCiAppDataPointer + curIndex));
 					curIndex += 2U;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData->chTrainApplyState;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData[j].chTrainApplyState;
 					curIndex++;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData->chLogicResUsable;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData[j].chLogicResUsable;
 					curIndex++;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData->chLogicReturnState;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData[j].chLogicReturnState;
 					curIndex++;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData->chLogicUnlockState;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData[j].chLogicUnlockState;
 					curIndex++;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData->chTrainLevel;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szTrainResData[j].chTrainLevel;
 					curIndex++;
-					LongToChar(pstLogSecDataStruCC[i].szTrainResData->dwRcvUnlockCmdCyc, (pCurCiAppDataPointer + curIndex));
+					LongToChar(pstLogSecDataStruCC[i].szTrainResData[j].dwRcvUnlockCmdCyc, (pCurCiAppDataPointer + curIndex));
 					curIndex += 4U;
 				}
 				*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].cResReqOtherCIId;
@@ -3685,11 +3800,11 @@ UINT32 CopyValidGetLogicSecDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum,Lo
 				curIndex++;
 				for (j = 0U; j < pstLogSecDataStruCC[i].chLogSecLockBelLogRouteSum; j++)
 				{
-					ShortToChar(pstLogSecDataStruCC[i].szLogSecLockBelLogRouteData->wLogSecLockBelLogRouteId, (pCurCiAppDataPointer + curIndex));
+					ShortToChar(pstLogSecDataStruCC[i].szLogSecLockBelLogRouteData[j].wLogSecLockBelLogRouteId, (pCurCiAppDataPointer + curIndex));
 					curIndex += 2U;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szLogSecLockBelLogRouteData->chLogSecLockBelLogRouteState;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szLogSecLockBelLogRouteData[j].chLogSecLockBelLogRouteState;
 					curIndex++;
-					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szLogSecLockBelLogRouteData->wLogSecLockBelLogRouteDir;
+					*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].szLogSecLockBelLogRouteData[j].wLogSecLockBelLogRouteDir;
 					curIndex++;
 				}
 				*(pCurCiAppDataPointer + curIndex) = pstLogSecDataStruCC[i].LogSecLogLockState;
@@ -4586,6 +4701,7 @@ UINT32 CopyValidSetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 		{
 			m_OcToCiOrginDataNum = (UINT8)ValidIdNum;
 			/*����*/
+			debug_infor_printf((char*)"m_OcToCiOrginDataNum = %d\n", m_OcToCiOrginDataNum);
 			(void)CommonMemSet(OcRecvData, (UINT32)((OC_SUM_MAX)* sizeof(OcToCiOriginDataStruct)), 0U, (UINT32)((OC_SUM_MAX)* sizeof(OcToCiOriginDataStruct)));		/*����սṹ���ֹ������*/
 			for (i = 0U; i < ValidIdNum; i++)
 			{
@@ -4621,6 +4737,8 @@ UINT32 CopyValidSetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 						curIndex++;
 						pOcDevice->BoardState[j] = *(pCurCiAppDataPointer + curIndex);
 						curIndex++;
+						pOcDevice->MainStandbyState[j] = *(pCurCiAppDataPointer + curIndex);
+						curIndex++;
 					}
 				}
 
@@ -4766,7 +4884,6 @@ UINT32 CopyValidSetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcToCiOriginDataStruct OcRecvData[])
 {
 	UINT32 curIndex = 0U;
-	UINT16 ValidIdNum = 0U;
 	UINT16 i = 0U;
 	UINT16 k = 0U;
 	UINT8 j = 0U;
@@ -4786,9 +4903,9 @@ UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 		/*������Ч�豸����*/
 		ShortToChar(m_OcToCiOrginDataNum, pCurCiAppDataPointer);
 		curIndex += (UINT32)sizeof(UINT16);  /*�������ֽ��豸����*/
-		if (struNum > ValidIdNum)
-		{
-			for (i = 0U; i < m_OcToCiOrginDataNum; i++)
+		//printf("m_OcToCiOrginDataNum = %d\n", m_OcToCiOrginDataNum);
+
+		for (i = 0U; i < m_OcToCiOrginDataNum; i++)
 			{
 				ShortToChar(OcRecvData[i].OcId, (pCurCiAppDataPointer + curIndex));
 				curIndex += 2U;
@@ -4819,6 +4936,8 @@ UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 						curIndex++;
 						*(pCurCiAppDataPointer + curIndex) = pOcDevice->BoardState[j];
 						curIndex++;
+						*(pCurCiAppDataPointer + curIndex) = pOcDevice->MainStandbyState[j];
+						curIndex++;
 					}
 				}
 				ShortToChar(OcRecvData[i].OcGdNum, (pCurCiAppDataPointer + curIndex));
@@ -4935,7 +5054,7 @@ UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 				LongToChar(OcRecvData[i].ComStartCycle, (pCurCiAppDataPointer + curIndex));
 				curIndex += 4U;
 			}
-		}
+		
 	}
 	else
 	{

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

@@ -56,6 +56,7 @@
 #include "../Route/LogicalRouteDataManage.h"
 #include "../Route/LongRouteDataManage.h"
 #include "../ReverseCut/ReverseCutDataManage.h"
+#include "../AxisSort/AxisSort.h"
 
 #ifdef __cplusplus
 extern "C" {

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

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

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

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

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

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

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

@@ -105,37 +105,34 @@ SAME_LINE_ERR,
 */
 UINT8 IsSameLineCI(const UINT8 ciA, const UINT8 ciB)
 {
-	UINT32 etcsIdA, etcsIdB;
-	UINT16 u16CiA, u16CiB;
+	UINT32 etcsIdA = 0U;
+	UINT32 etcsIdB = 0U;
+	UINT16 u16CiA = 0U;
+	UINT16 u16CiB = 0U;
 	UINT8 retVal = SAME_LINE_ERR;
-	UINT8 cbtcSysType = DQU_CBTC_FAO;
 	UINT8 dquDevNameA = CI_ERROR;
 	UINT8 dquDevNameB = CI_ERROR;
+	UINT8 chCiAFactoryType = 0U;
+	UINT8 chCiBFactoryType = 0U;
 
-	u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256u) + ciA);
-	u16CiB = (UINT16)((CI_SYSTEM_TYPE_RCI * 256u) + ciB);
+	u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciA);
+	u16CiB = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciB);
 
-	cbtcSysType = GetCbtcSysType();
+	dquDevNameA = dquDevName2HlhtId(u16CiA,0U,&etcsIdA);
+	dquDevNameB = dquDevName2HlhtId(u16CiB,0U,&etcsIdB);
 
-	dquDevNameA = dquDevName2HlhtId(u16CiA,0u,&etcsIdA);
-
-	dquDevNameB = dquDevName2HlhtId(u16CiB,0u,&etcsIdB);
-
-	if(DQU_CBTC_CPK == cbtcSysType)
+	/*需要增加互联互通的判断*/
+	if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
 	{
-		retVal = SAME_LINE_YES;
-	}
-	else if(DQU_CBTC_FAO == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;	
-	}
-	else if(DQU_CBTC_HLT == cbtcSysType)
-	{
-		/*需要增加互联互通的判断*/
-		if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
+		/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
+		if ((etcsIdA & ((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
 		{
-			/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
-			if ((etcsIdA&((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
+			retVal = SAME_LINE_YES;
+
+			/*同一条线路，一期二期使用不同厂家联锁，也判为不同线路，接口走互联互通*/
+			chCiAFactoryType = GetCiFactoryType(ciA);
+			chCiBFactoryType = GetCiFactoryType(ciB);
+			if (chCiAFactoryType == chCiBFactoryType)
 			{
 				retVal = SAME_LINE_YES;
 			}
@@ -146,17 +143,14 @@ UINT8 IsSameLineCI(const UINT8 ciA, const UINT8 ciB)
 		}
 		else
 		{
-			retVal = SAME_LINE_ERR;
+			retVal = SAME_LINE_NO;
 		}
-	}/* zt 删除单轨相关代码 2022-02-15 */
-	else if (DQU_CBTC_CC == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;
 	}
 	else
-	{		
+	{
 		retVal = SAME_LINE_ERR;
 	}
+	
 	return retVal;
 }
 /*
@@ -204,7 +198,7 @@ UINT32 GetCiTranCiDataCheckVer(const UINT8 ciId, const UINT16 deviceName)
 	UINT8 ii = 0U;
 	UINT8 chBreakFlag = 0U;
 	UINT8 chDevType = 0U;
-	chDevType = (UINT8)((deviceName & 0xFF00) >> 8U);
+	chDevType = (UINT8)((deviceName & 0xFF00u) >> 8U);
 	if ((ciId > 0U) && (ciId < CI_SUM_MAX) && 
 		((RC_WORK_MODE_CI == chDevType)||(RC_WORK_MODE_TIOC == chDevType)))
 	{

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

@@ -1292,17 +1292,13 @@ edit cgh 20241203
 UINT8 RouteLockDriveSwitch(const UINT16 routeId, const UINT8 NeedForDrvRoutAssoSwit)
 {
     UINT8 ii = 0u;
-	UINT8 switchSum = 0u;
 	UINT16 switchId = 0u;
 	UINT8 switchExpPosition = SWITCH_POSITION_INVALID;			/*道岔期望位置*/
     UINT8 switchDancaoPosition = SWITCH_POSITION_INVALID; 		/*单操有效位置*/
-	RouteSwitchStruct* pRouteSwitchStru = NULL;					/*道岔数据结构指针*/
 	UINT8 innerSwitchRetVal = CI_ERROR;							/*检查进路内道岔是否可被驱动的结果*/
 	UINT8 assocSwitchRetVal = CI_ERROR; 						/*检查带动道岔是否可被驱动的结果*/
 	UINT8 assocSwitchSum = 0u; 									/*道岔数目*/
 	RouteAssocSwitchStruct routeAssocSwitchStru = {0,0}; 		        /*道岔数据*/
-	UINT8 routeProtectSwitchSum = 0u; 							/*防护道岔数目*/
-	RouteProtectSwitchStruct* pRouteProtectSwitchStru = NULL;    /*防护道岔数据*/
 	UINT8 chAutoCheck = 0U;
 	UINT8 chSendLevel = 0U;
 	chAutoCheck = AutoSignalOrRouteValid(routeId);
@@ -3236,7 +3232,6 @@ UINT8 GetSwitchRouteLockState(UINT16 switchId)
 {
 	UINT16 bufIndex = 0u;		/*数组下标*/
 	UINT16 belongSecId = 0u;		/*所属区段ID*/
-    UINT16 doubleSwitchId = 0u;  /*双动道岔ID*/
 	UINT8 belongPhySecState = 0u;	/*所属物理区段的进路状态*/
 	UINT8 reVal = CI_ERROR;
 
@@ -3258,21 +3253,7 @@ UINT8 GetSwitchRouteLockState(UINT16 switchId)
 		}
         else
         {
-            doubleSwitchId = GetDSwitchOtherId(switchId);/*获取双动道岔ID*/
-            if (doubleSwitchId != 0u)
-            {/*双动道岔非空*/
-
-                belongSecId = GetSwitchPhySectionId(doubleSwitchId);
-                belongPhySecState = GetPhySecLockState(belongSecId);
-                
-                if ((PHYSICAL_SECTION_LOCK_NORMAL == belongPhySecState) || 
-                    (PHYSICAL_SECTION_LOCK_PROTECT == belongPhySecState) ||
-					(PHYSICAL_SECTION_LOCK_DELAY == belongPhySecState) ||
-					(PHYSICAL_SECTION_LOCK_FAULTDELAY == belongPhySecState))
-                {
-                    reVal = CI_SUCCESS;
-                }
-            }            
+              /*双动道岔锁闭状态不处理*/ 
         }
     }
 	return reVal;
@@ -5016,15 +4997,15 @@ void SetPhySecSpksFLockBySpksId(UINT16 spksId,UINT8 spksStatus)
 */
 UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const chkDevStatus)
 {	
-	UINT8 devState = 0u;
-	UINT8 tmpDevState = 0u;
-	UINT8 tmpPsdVobcCmd = 0u;
-	UINT8 tmpColor = 0u;
-	UINT8 ttmpDevState = 0u;
-	UINT8 psdMutualLockState = 0u;
-	UINT16 tempdevId = 0u;                   /*临时设备ID*/
-	UINT8 tempdevState = 0u;                 /*临时设备状态*/
-
+	UINT8 devState = 0U;
+	UINT8 tmpDevState = 0U;
+	UINT8 tmpPsdVobcCmd = 0U;
+	UINT8 tmpColor = 0U;
+	UINT8 ttmpDevState = 0U;
+	UINT8 psdMutualLockState = 0U;
+	UINT16 tempdevId = 0U;                   /*临时设备ID*/
+	UINT8 tempdevState = 0U;                 /*临时设备状态*/
+	UINT8 chPsdExceptState = 0U;
 	switch(devType)
 	{
 	case CI_DEVICE_TYPE_SWITCH:           /*道岔*/
@@ -5039,12 +5020,12 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_SIGNAL:          /*信号机*/
 		tmpColor = GetSignalCurColor(devId);
-		if (tmpColor > 0u)
+		if (0U < tmpColor)
 		{
 			tmpDevState = GetSignalOpenCloseState(tmpColor);
 			if (SIGNAL_OPEN == tmpDevState)
@@ -5058,7 +5039,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_ROUTE:          /*进路*/
@@ -5092,44 +5073,55 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_PSD:              /*站台屏蔽门*/
 		tmpDevState = GetPsdState(devId);
 		tmpPsdVobcCmd = GetPsdVobcCmd(devId);
 		psdMutualLockState = GetPsdMutualLockRemoveState(devId);
-		if ((PSD_MUTUALLOCK_REMOVE_YES == psdMutualLockState) || (PSD_ATS_MUTUALLOCK_REMOVE_YES == psdMutualLockState)
-			|| (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == psdMutualLockState))
+		chPsdExceptState = GePsdExceptState(devId);
+
+		if (PSD_EXCEPT_NO != chPsdExceptState)
 		{
-			/* 采集到互锁解除，则直接认为屏蔽门关闭 */
-			devState = OTHER_CI_PSD_STATUS_CLOSE;
-		}
-		else if (PSD_STATE_OPEN == tmpDevState)
-		{
-			if (tmpPsdVobcCmd == VOBCTOCI_COMMAND_TYPE_PSDOPEN)
-			{
-				/* 收到VOBCToCI打开屏蔽门命令，则直接认为屏蔽门占用打开 */
-				devState = OTHER_CI_PSD_STATUS_OCCUPY_OPEN;
-			}
-			else
-			{
-				/* 未收到VOBCToCI打开屏蔽门命令，则直接认为屏蔽门打开 */
-				devState = OTHER_CI_PSD_STATUS_OPEN;
-			}
-		}
-		else if (PSD_STATE_CLOSE == tmpDevState)
-		{ 
-			/* 未采集到互锁解除，则直接认为屏蔽门关闭 */
-			devState = OTHER_CI_PSD_STATUS_CLOSE;
+			devState = OTHER_CI_PSD_STATUS_OPEN;  /* 屏蔽门异常状态,则认为打开 */
 		}
 		else
 		{
-			devState = 0u;
+			if ((PSD_MUTUALLOCK_REMOVE_YES == psdMutualLockState) || (PSD_ATS_MUTUALLOCK_REMOVE_YES == psdMutualLockState)
+				|| (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == psdMutualLockState))
+			{
+				/* 采集到互锁解除，则直接认为屏蔽门关闭 */
+				devState = OTHER_CI_PSD_STATUS_CLOSE;
+			}
+			else if (PSD_STATE_OPEN == tmpDevState)
+			{
+				if (VOBCTOCI_COMMAND_TYPE_PSDOPEN == tmpPsdVobcCmd)
+				{
+					/* 收到VOBCToCI打开屏蔽门命令，则直接认为屏蔽门占用打开 */
+					devState = OTHER_CI_PSD_STATUS_OCCUPY_OPEN;
+				}
+				else
+				{
+					/* 未收到VOBCToCI打开屏蔽门命令，则直接认为屏蔽门打开 */
+					devState = OTHER_CI_PSD_STATUS_OPEN;
+				}
+			}
+			else if (PSD_STATE_CLOSE == tmpDevState)
+			{
+				/* 未采集到互锁解除，则直接认为屏蔽门关闭 */
+				devState = OTHER_CI_PSD_STATUS_CLOSE;
+			}
+			else
+			{
+				devState = 0U;
+			}
 		}
+		
 		break;
-	case CI_DEVICE_TYPE_PSD_EXCEPT_OPEN:  /*站台屏蔽门（异常打开）*/
-		devState = GePsdExceptOpenState(devId);
+	case CI_DEVICE_TYPE_PSD_EXCEPT_OPEN:  /*站台屏蔽门（异常）*/
+		devState = GePsdExceptState(devId);
+		/*宁象需求：屏蔽门异常打开又关闭、尚未取消异常状态时不开放信号*/
 		break;
 	case CI_DEVICE_TYPE_GARAGEDOOR:       /*车库门*/
 		tmpDevState = GetGaragedoorState(devId);
@@ -5143,7 +5135,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			devState = 0u;
+			devState = 0U;
 		}
 		break;
 	case CI_DEVICE_TYPE_WASHMACHINE:	/* 洗车机 */
@@ -5166,7 +5158,7 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
 		}
 		else
 		{
-			if (ttmpDevState == SPKS_CUT_NO)
+			if (SPKS_CUT_NO == ttmpDevState)
 			{
 				devState = OTHER_CI_SPKS_YES;
 			}
@@ -5928,6 +5920,8 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
 	UINT8 routeTrainNear = 0u;
 	UINT8 physicalCheck = 0u;
 	UINT8 phyPLockRouteState = 0u;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
 
 	physicalSecId = GetAxisSecRelativePhySecId(axisSectionId);
 	routeRlockId = GetPhySecRLockBelongRouteId(physicalSecId);/*物理区段进路锁闭所属进路ID*/
@@ -6072,6 +6066,21 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
 			}
 		}
 	}
+
+	if (CI_SUCCESS == reVal)
+	{/*检查防护道岔位置*/
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecAllProtSwitchPosCheck(axisSectionId, &devId, &devState);
+	}
+
+	if (CI_SUCCESS == reVal)
+	{/*检查防护道岔封锁状态*/
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecProtSwitchFLockCheck(axisSectionId, &devId, &devState);
+	}
+
 	return reVal;
 }
 
@@ -6201,7 +6210,8 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 	UINT8 logSecLockState = 0U;
 	UINT8 logSecLockRouteNum = 0U;
 	UINT8 chFailStep = 0U;
-
+	UINT8 cYLockAlarmFlag = FLAG_UNSET;  /*引导总锁报警标志*/
+	
 	bufIndex = GetlogSectionBufIndex(logSectionId);  /*获取区段数组下标*/
 	/**区段下标合法*/
 	if (LOGIC_SECTION_SUM_MAX > bufIndex)
@@ -6466,6 +6476,28 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				reVal = CI_SUCCESS;
 			}
 		}
+
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔封锁状态检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwFLockCheck(logSectionId, &devId, &devState, &cYLockAlarmFlag);/*封锁检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 13U;
+			}
+		}
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔位置检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwPosCheck(logSectionId, &devId, &devState);/*位置检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 14U;
+			}
+		}
+
 	}
 	else 
 	{
@@ -6767,10 +6799,17 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 	AxisSwitchStruct* pRouteSwitchStru = NULL;					/*道岔数据结构指针*/
 	UINT8 innerSwitchRetVal = CI_ERROR;							/*检查计轴区段内道岔是否可被驱动的结果*/
 
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
+
 	switchSum = GetAxisSwitchSum(axisSecId);
 	pRouteSwitchStru = GetAxisSwitchIdStru(axisSecId);
 
-	if((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX))
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
+
+	if((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX)||(NULL == pRouteSwitchStru) || (NULL == pProtectSwitchStru))
 	{
 		innerSwitchRetVal = CI_ERROR;
 	}
@@ -6798,6 +6837,32 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 				break;
 			}
 		}
+
+		if (innerSwitchRetVal == CI_SUCCESS)
+		{
+			/* 单操相反位置取消驱动检查 */
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPosition = pProtectSwitchStru[ii].SwitchPosition;
+				switchDancaoPosition = GetSwitchDanCaoPostition(switchId);
+
+				if ((SWITCH_POSITION_INVALID == switchDancaoPosition)
+					||
+					(switchDancaoPosition == switchExpPosition))
+				{/*单操无效 或者 单操位置与动作位置一样*/
+					innerSwitchRetVal = CI_SUCCESS;
+				}
+				else
+				{
+					/*单操到相反位置取消道岔的驱动*/
+					innerSwitchRetVal = CI_ERROR;
+					break;
+				}
+			}
+		}
+
+
 		
 		if(innerSwitchRetVal == CI_SUCCESS)
 		{
@@ -6817,7 +6882,7 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 
 
 /*
-功能描述: 	驱动计轴区段内道岔处理
+功能描述: 	驱动计轴区段内道岔，计轴区段关联防护道岔处理
 输入参数:	const UINT16 axisSecId 计轴区段ID
 输出参数:	const UINT8 DrivFlag 道岔驱动标志
 返回值:		无
@@ -6829,22 +6894,36 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
 	UINT8 switchExpPos = 0u; 								/*道岔期望位置*/
 	AxisSwitchStruct* pAxisSecSwitchStru = NULL; 				/*道岔数据*/
 	UINT8 ii = 0u;											/*循环变量*/
-	UINT8 funRtn = CI_ERROR;
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
 
 	switchSum = GetAxisSwitchSum(axisSecId); /*获取计轴区段道岔数目*/
 	pAxisSecSwitchStru = GetAxisSwitchIdStru(axisSecId); /*获取计轴区段内道岔数据*/
 	
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
 
-	if(SWITCH_NEED_DRIV_TRUE == DrivFlag)
-	{/*需要驱动计轴区段内道岔*/
+	if ((NULL != pAxisSecSwitchStru) && (NULL != pProtectSwitchStru))
+	{
+		if (SWITCH_NEED_DRIV_TRUE == DrivFlag)
+		{/*需要驱动计轴区段内道岔*/
+
+			for (ii = 0u; ii < switchSum; ii++)
+			{
+				switchId = pAxisSecSwitchStru[ii].SwitchId;
+				switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
+			}
+
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPos = pProtectSwitchStru[ii].SwitchPosition;
+				(void) SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段防护道岔的驱动状态为驱动中*/
+			}
 
-		for(ii = 0u; ii < switchSum; ii++)
-		{
-			switchId = pAxisSecSwitchStru[ii].SwitchId;
-			switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
-			funRtn = SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
 		}
-				
 	}
 }
 
@@ -7298,7 +7377,7 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 	UINT8 retValue = CI_ERROR;
 	UINT8 chLogSecLogLockState = 0U;  /*逻辑区段逻辑锁闭状态*/
 	UINT8 cLockBelongLogicRouteNum = 0U;  /*逻辑区段逻辑锁闭所属逻辑进路数量*/
-
+	UINT8 chLogSecJumpLockState = 0U;
 	/*获取道岔关联逻辑区段信息*/
 	logSecSum = GetSwitchLogSecSum(switchId);
 	logSecBuf = GetSwitchLogSecBuf(switchId);
@@ -7322,8 +7401,9 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 				/*检查逻辑区段逻辑锁闭状态*/
 				chLogSecLogLockState = GetLogSecLogLockState(logSecBuf[i]);
 				cLockBelongLogicRouteNum = GetLogSecLockBelLogRouteSum(logSecBuf[i]);
+				chLogSecJumpLockState = GetLogSecJumpLockState(logSecBuf[i]);
 
-				if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum))
+				if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum)&&(LOGIC_SECTION_JUMP_LOCK_NO== chLogSecJumpLockState))
 				{
 					retValue = CI_SUCCESS;
 				}
@@ -11591,4 +11671,129 @@ UINT8 GetLocalVirCiType(UINT8 chVirCiId)
 	}
 
 	return ret;
+}
+/*
+* 功能描述：判断本联锁临时限速状态
+* 参数说明：无
+* 返 回 值：临时限速有效返回失败，清除或与限速确认返回成功
+* Created :LYJ
+*/
+
+UINT8 CheckLocalCiLSXSStata(void)
+{
+	UINT8 chRet = 0U;
+	UINT8 chVirCINum = 0U;
+	UINT8 i = 0U;
+	UINT8 chXiansuState = 0U;
+	UINT8 chVirtualCIid = 0U;
+	UINT8 chTsrSureFlag = 0U;
+	
+	chTsrSureFlag = GetTsrSureFlag(); /*获取临时限速确认标志*/
+	if (CI_TSR_SURE_YES == chTsrSureFlag)
+	{
+		chRet = CI_SUCCESS; 
+	}
+	else
+	{
+		/*临时限速未确认，判断是否做了限速清除*/
+		
+		chVirCINum = GetVirtualCINum();
+		for (i = 0U; i < chVirCINum; i++)
+		{
+			chVirtualCIid = GetVirtualCIid(i);
+			chXiansuState = GetVirCILabourCancelLSXianSta(chVirtualCIid);
+			if ((LINSHIXIANSU_COMM_GOOD_STATE == chXiansuState) || (LINSHIXIANSU_LABOURCANCLE_YES_STATE == chXiansuState))
+			{
+				chRet = CI_SUCCESS;
+			}
+			else
+			{
+				chRet = CI_ERROR;
+				break;
+			}
+		}
+	}
+
+	return chRet;
+}
+
+/*
+功能描述:
+	清除逻辑区段关联道岔单操位置
+输入参数:
+	const UINT16 逻辑区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId)
+{
+	UINT8 	switchSum = 0u; 									/*道岔数目*/
+	UINT16 	switchId = 0u; 									/*道岔ID*/
+	UINT8 	ii = 0u;											/*循环变量*/
+	UINT8  checkSum = 0u;
+	LogsecSwitchStruct* dataIdBuf = NULL;
+
+	UINT8 chLogicSecSwitchSum = 0U;/*逻辑区段道岔数目*/
+	LogsecSwitchStruct* pLogicSecSwitchIdData = NULL;/*逻辑区段道岔ID数据*/
+
+	chLogicSecSwitchSum = GetLogicSecSwitchSum(logicSecId);/*逻辑区段道岔数目*/
+	pLogicSecSwitchIdData = GetLogicSecSwitchIdStru(logicSecId);/*逻辑区段道岔ID数据*/
+
+	checkSum = GetLgcRelateProSwSum(logicSecId);/*获取指定ID逻辑区段关联防护道岔数目*/
+	dataIdBuf = GetLgcRelateProSwStru(logicSecId);
+
+	
+
+	if (NULL != pLogicSecSwitchIdData)
+	{
+		for (ii = 0u; ii < chLogicSecSwitchSum; ii++)
+		{
+			switchId = pLogicSecSwitchIdData[ii].SwitchId;
+			/*设置该道岔期望驱动位置为无效*/
+			(void)SetSwitchDanCaoPosition(switchId, SWITCH_POSITION_INVALID);
+		}
+	}
+
+	if (NULL != dataIdBuf)
+	{
+		for (ii = 0u; ii < checkSum; ii++)
+		{
+			switchId = dataIdBuf[ii].SwitchId;
+			/*设置该道岔期望驱动位置为无效*/
+			(void) SetSwitchDanCaoPosition(switchId, SWITCH_POSITION_INVALID);
+		}
+	}
+}
+
+/*
+功能描述:
+	清除计轴区段关联道岔单操位置
+输入参数:
+	const UINT16 计轴区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId)
+{
+	UINT16* pLogSectionIdBuf = NULL;
+	UINT8 chLogSectionSum = 0U;
+	UINT8 ii = 0U;
+
+	pLogSectionIdBuf = GetAxisSecLogSectionIdBuf(axisSecId);
+	chLogSectionSum = GetAxisSecLogSectionSum(axisSecId);
+
+	if (NULL != pLogSectionIdBuf)
+	{
+		for (ii = 0U; ii < chLogSectionSum; ii++)
+		{
+			/*清除逻辑区段道岔道岔标志*/
+			ClearLogSeceSwitchDanCaoPos(pLogSectionIdBuf[ii]);
+		}
+	}
 }

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

@@ -72,8 +72,13 @@ typedef struct S_AreaSnowInfoStruct
  * 其他联锁条件状态定义
  *--------------------------------------------------------------------------*/
 /* 其他联锁条件检查配置状态相关定义 */
-#define LOCAL_AREA_SNOW_SUM_MAX   ((UINT8)20)     /*本控区及相邻控区发送的区间雨雪站台数量*/
-#define ALL_AREA_SNOW_SUM_MAX     ((UINT8)254)    /*TMC发送的全线区间雨雪站台数量*/
+#define LOCAL_AREA_SNOW_SUM_MAX		((UINT8)20)			/*本控区及相邻控区发送的区间雨雪站台数量*/
+#define ALL_AREA_SNOW_SUM_MAX		((UINT8)254)		/*TMC发送的全线区间雨雪站台数量*/
+#define ALL_CBTC_CROSS_SUM_MAX		((UINT8)253)		/*CBTC跨压最大数量*/
+#define ALL_TACS_CROSS_SUM_MAX		((UINT8)253)		/*TACS跨压最大数量*/
+#define CROSS_SIGNAL_ID_MAX			((UINT16)1499)		/*跨压信号机ID最大值*/
+#define CBTC_CROSS_ID_MAX			((UINT8)253)		/*CBTC跨压最大列车ID*/
+#define TACS_CROSS_ID_MAX			((UINT8)253)		/*TACS跨压最大列车ID*/
 
 /* 1	信号机	
 开放0x55
@@ -221,8 +226,6 @@ extern UINT8 comm_Train_Test_YSKJ_SCX_State;				/*
 extern UINT8 comm_Train_Test_SQJ_CLD_State;				/*试车线与车辆段采用通信接口时车辆段SQJ状态*/
 extern UINT8 comm_Train_Test_TYSJ_CLD_State;				/*试车线与车辆段采用通信接口时车辆段TYSJ状态*/
 
-extern UINT8 ZCToCIAutoRtnIndict_Flash_Sta;			/*ZC给CI的无人折返灯闪灯状态*/
-extern UINT8 ZCToCIAutoRtnIndict_Steady_Sta;		/*ZC给CI的无人折返灯稳灯状态*/
 extern UINT8 AutoTriggerFlag;                                             /*自动触发标志初始化为未设置*/
 
 extern UINT8 CiCiRelayInterfaceConfirmFlag;/*继电接口确认标志*/
@@ -1975,4 +1978,36 @@ void SetLocalSnowModelCC(UINT8 setmodle);
 add by mpt 20260104
 */
 UINT8 GetLocalVirCiType(UINT8 chVirCiId);
+/*
+* 功能描述：判断本联锁临时限速状态
+* 参数说明：无
+* 返 回 值：临时限速有效返回失败，清除或与ZC通信正常返回成功
+* Created :LYJ
+*/
+
+UINT8 CheckLocalCiLSXSStata(void);
+/*
+功能描述:
+	清除逻辑区段关联道岔单操位置
+输入参数:
+	const UINT16 逻辑区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId);
+/*
+功能描述:
+	清除计轴区段关联道岔单操位置
+输入参数:
+	const UINT16 计轴区段ID
+输出参数:
+	无.
+返回值:
+	无
+add by mpt 20260403
+*/
+void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId);
 #endif

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

@@ -1529,7 +1529,7 @@ UINT8 elm_PrepareEnvelopeIsSelf(IN const EnvelopeStruct* ptemp)
 		/** 在一个OC*/
 		ret = ELM_BELONG_OWNER;
 	}
-	else if((localOCid != pointABelongOcid) && (localOCid != pointBBelongOcid))
+	else if ((localOCid != pointABelongOcid) && (localOCid != pointBBelongOcid))
 	{
 		/** 不在同一OC*/
 		ret = ELM_BELONG_OTHER;

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

@@ -186,10 +186,9 @@ UINT8 PsdDeviceToRelayStateProc(void);
 /*
 * 功能描述： 更新洗车机继电器状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
-*			 1: 更新成功      
+* 返回值  ： void     
 */
-UINT8 WashMachineDevToRelayStaProc(void);
+void WashMachineDevToRelayStaProc(void);
 
 /*
 * 功能描述： 更新紧急停车按钮逻辑状态
@@ -226,10 +225,9 @@ void GaragedoorDevToRelayStaProc(void);
 /*
 * 功能描述： 更新洗车机的逻辑状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
-*			 1: 更新成功
+* 返回值  ： void
 */
-UINT8 WashMachineToDeviceStateProc(void);
+void WashMachineToDeviceStateProc(void);
 /*
 * 功能描述： 更新Spks按钮逻辑状态
 * 参数说明： void
@@ -328,12 +326,17 @@ void OcSwitchDeviceOutput(void);
 UINT8 GetOcSignalColor(UINT16 signalId);
 
 /*
-* 功能描述： 获取OC道岔设备颜色
+* 功能描述： 获取OC道岔设备状态
 * 参数说明：
-		UINT16 signalId：信号机id
-* 返回值  ： void
+		UINT16 switchId：道岔id
+		UINT8 mainControlOCId 主控OCId
+* 返回值  ：
+*			((UINT8)0x01)    道岔定位
+*			((UINT8)0x02)    道岔反位
+*			((UINT8)0x04)    道岔四开
+*			((UINT8)0x08)    道岔移动
 */
-UINT8 GetOcSwitchState(UINT16 switchId);
+UINT8 GetOcSwitchState(UINT16 switchId, UINT8 mainControlOCId);
 
 /*
 * 功能描述： 间隙探测脉冲接口方式启动驱动处理
@@ -1136,6 +1139,61 @@ UINT8 PsdIbpRelToDevStaProc(const UINT16 wPsdId);
 */
 void OnePlatEsbAndCutBtnProc(void);
 
+/*
+* 功能描述：取消当前未异常打开的站台门的异常状态
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ：无
+*Create fan 2026.03.26
+*/
+void CancelPsdExceptState(UINT16 doorId);
+/*
+* 功能描述： 设置道岔的每一个OC的主控状态
+* 参数说明：
+		UINT16 switchId：道岔id
+* 返回值  ：void
+* add by mpt 20260326
+*/
+void SetOcSwitchControlState(UINT16 switchId);
+/*
+* 功能描述： 仲裁当前道岔的主控OC
+* 参数说明： UINT16 switchCurSum 道岔总数
+* 返回值  ： 无
+* add by mpt 20260326
+*/
+void SetAllSwitchCurMainControlOC(UINT16 switchCurSum);
+/*
+* 功能描述： OC道岔主控命令生成处理
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+*/
+void OutSwitchControlModeCmd(UINT16 switchId);
+/*
+* 功能描述： 道岔无主控时产生主备控命令处理
+* 参数说明： UINT16 switchId
+* 返回值  ： void
+*/
+void SwitchMainControlCmdOut(UINT16 switchId, UINT8 ocId);
+/*
+* 功能描述： OC道岔主控状态管理
+* 参数说明： void
+* 返回值  ： void
+*/
+void OcSwitchControlModeCmdOutput(void);
+/*
+* 功能描述： 双主防护模块
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+*/
+void SwitchDoubleMainProtect(UINT16 switchId);
+/*
+* 功能描述：道岔寻表模块
+* 参数说明： UINT16 switchId 道岔ID
+* 返回值  ： void
+* add by mpt 20260328
+*/
+void FindSwitchPostionCmdOut(UINT16 switchId);
+
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -537,6 +537,13 @@ void SignalTrainCrossPro(void);
 * 返回值  ： void
 */
 void ProcessIvocToRCData(void);
+/*
+* 功能描述： Vobc点连式信息清除
+* 参数说明： UINT16 wTrainId：VOBCid
+* 返回值  ： void
+* by lyj 20260316
+*/
+void VobcBlocLinkDataClear(const UINT16 wTrainId);
 
 #ifdef __cplusplus
 }

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

@@ -81,10 +81,12 @@ void OutputDataProcess(void)
 	UINT8 CiPattern = 0u;
 	UINT8 chDsnLinSwitch = 0U;
 	UINT8 chTiocSysMode = 0U;
+	UINT8 chLocalCiOCSswitch = 0U;
 
 	chTiocSysMode = GetTiocSystemMode();
 	chDsnLinSwitch = GetCiFunctionSwitchConfig(FUNC_DSN_LINE_SWITCH);
 	CiPattern = GetLocalCiPattern();
+	chLocalCiOCSswitch = GetLocalCiOCSswitch();
 
 	if (REVERSE_MODE_MAIN != chTiocSysMode)
 	{
@@ -118,6 +120,12 @@ void OutputDataProcess(void)
 			/*道岔输出处理*/
 			OcSwitchDeviceOutput();
 
+			if (OC_S_ON == chLocalCiOCSswitch)
+			{/*OCS开关打开*/
+				/*道岔主控命令和寻表命令输出管理*/
+				OcSwitchControlModeCmdOutput();
+			}
+
 			/*信号机输出处理*/
 			OcSignalDeviceOutput();
 		}
@@ -152,7 +160,7 @@ void OutputDataProcess(void)
 	(void)PsdDeviceToRelayStateProc();
 
 	/*更新洗车机继电器状态*/
-	(void)WashMachineDevToRelayStaProc();
+	WashMachineDevToRelayStaProc();
 
 	/*更新计轴复位继电器状态*/
 	/*虚拟联锁兼容*/
@@ -217,6 +225,9 @@ void OutputDataProcess(void)
 	/*后备列车发送数据处理*/
 	VobcBackUpOutputProcess();
 
+	/*点连式列车发送数据处理*/
+	VobcBlocLinkOutputProcess();
+
 	/*资源对顶点数据计算*/
 	(void)ReqAlignmentInfoCalc();
 
@@ -441,11 +452,11 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
 	case ETYPE_SIG_CLOSE_OVER_TIME:
 		returnValue = CI_BACK_SIG_CLOSE_OT;   /*信号机关闭超时*/
 		break;
-
+#if 0
 	case ETYPE_SIG_RETURN_OPENED_STATE:
 		returnValue = CI_BACK_AS_RETR_ENDSIG_RT_SET;/*以该信号机为终端信号机的折返进路已经办理*/
 		break;
-
+#endif
 	case ETYPE_SIG_LEAD_ALL_LOCK:
 		returnValue = CI_BACK_SIG_LEAD_OPEN_FAIL;		/*引导信号开放条件不满足，全站已下发引导总锁*/
 		break;
@@ -3538,6 +3549,7 @@ void NonRouteRelayStateProc(void)
 	UINT8 interfaceType = FUNC_SWITCH_UNDEF;/*试车线与车辆段接口类型*/
 	UINT8 i = 0u;
 	UINT16 agreeTryTrainRelayId = 0u;/*同意试车继电器ID*/
+	UINT16 wColWaysideTryTrainIndRelayId = 0U;/*轨旁试车指示器继电器ID*/
 	NonRouteDataStruct* pNonRoute = NULL;
 	UINT8 localCiId = 0U; /*本联锁ID*/
 	UINT8 nonRouteBelongCiId = 0U; /*非进路所属联锁ID*/
@@ -3564,6 +3576,7 @@ void NonRouteRelayStateProc(void)
 						{ /*试信号模式且试车线与车辆段采用继电器接口*/
 							agreeTryTrainRelayId = GetNonRouteAgreeTryRelayIdById(pNonRoute->NonRouteId);
 							(void)SetRelayDriveState(agreeTryTrainRelayId, RELAY_DRIVE_STATE_UP); /*设置同意试车继电器吸起*/
+							
 						}
 						else if ((NONROUTE_RUN_MODE_APPLY == pNonRoute->RunMode) && (SCX_CLD_INTERFACE_COMM == interfaceType))
 						{/*试信号模式且试车线与车辆段采用通信接口*/
@@ -3577,6 +3590,17 @@ void NonRouteRelayStateProc(void)
 						{
 							/*不处理*/
 						}
+						wColWaysideTryTrainIndRelayId = GetWaysideTryTrainIndRelayId(pNonRoute->NonRouteId);
+						if (0U != wColWaysideTryTrainIndRelayId)
+						{
+							/*设置轨旁试车指示器继电器吸起*/
+							(void)SetRelayDriveState(wColWaysideTryTrainIndRelayId, RELAY_DRIVE_STATE_UP); 
+						}
+						else
+						{
+							/*不处理*/
+						}
+
 					}
 					else
 					{/*车辆段非进路不是开放状态时，发送试车线不同意试车（继电接口：驱同意试车继电器落下；串口和网口：发送同意试车无效状态）*/
@@ -3586,6 +3610,7 @@ void NonRouteRelayStateProc(void)
 							/*驱动非进路同意试车继电器落下  非进路同意试车继电器常态落下，相当于恢复默认态*/
 							agreeTryTrainRelayId = GetNonRouteAgreeTryRelayIdById(pNonRoute->NonRouteId);
 							(void)SetRelayDriveState(agreeTryTrainRelayId, RELAY_DRIVE_STATE_DOWN);
+							
 						}
 						else if ((SCX_CLD_INTERFACE_COMM == interfaceType) || (SCX_CLD_SERIAL_PORT_COMM == interfaceType))
 						{
@@ -3595,6 +3620,16 @@ void NonRouteRelayStateProc(void)
 						{
 							; /*不处理*/
 						}
+						wColWaysideTryTrainIndRelayId = GetWaysideTryTrainIndRelayId(pNonRoute->NonRouteId);
+						if (0U != wColWaysideTryTrainIndRelayId)
+						{
+							/*设置轨旁试车指示器继电器落下*/
+							(void)SetRelayDriveState(wColWaysideTryTrainIndRelayId, RELAY_DRIVE_STATE_DOWN); 
+						}
+						else
+						{
+							/*不处理*/
+						}
 					}
 
 					break;
@@ -4930,7 +4965,7 @@ UINT16 GetOverlapUnlockBackTime(const UINT16 overlapId, UINT16 OverlapUnLockCoun
 
 	/*自动解锁倒计时*/
 	deltCount = (INT32)(curCycleNum - startCycNum);
-	if((deltCount >= 0) && (deltCount <= (INT32)OverlapUnLockCount))/*倒计时数值在合理范围内*/
+	if((deltCount >= 0U) && (deltCount <= (INT32)OverlapUnLockCount))/*倒计时数值在合理范围内*/
 	{
 		autotimeData = (UINT16)(((OverlapUnLockCount + startCycNum - curCycleNum)* appCycTime)/1000U) ;
 	}	
@@ -4944,7 +4979,7 @@ UINT16 GetOverlapUnlockBackTime(const UINT16 overlapId, UINT16 OverlapUnLockCoun
 	{
 		deltCount = (INT32)(curCycleNum - laborUnlockStartCycNum);
 		laborUnlockOverlapTimeCount =GetlabarUnlockOverlapTimeCount();
-		if((deltCount >= 0) && (deltCount <= (INT32)laborUnlockOverlapTimeCount))/*倒计时数值在合理范围内*/
+		if((deltCount >= 0U) && (deltCount <= (INT32)laborUnlockOverlapTimeCount))/*倒计时数值在合理范围内*/
 		{
 			labortimeData = (UINT16)(((laborUnlockOverlapTimeCount + laborUnlockStartCycNum- curCycleNum)* appCycTime)/1000U) ;
 
@@ -5722,6 +5757,8 @@ void VobcBackUpOutputProcess(void)
 	UINT8 chBackUpValid = 0U;/*备用通信有效标志*/
 	UINT8 cRcWorkMode = 0U;
 
+	cRcWorkMode = GetLocalRcWorkMode();
+
 	for (ii = 0U; ii < TRAIN_SUM_MAX; ii++)
 	{
 		wTrainId = GetTrainId(ii);
@@ -8217,7 +8254,6 @@ void SetSCApplyIndicator(const UINT16 wIndicatorId)
 	UINT8 chRtuCiType = 0U;		 /*虚拟联锁类型*/
 	UINT8 chIndicatorRtuId = 0U; /*虚拟联锁ID*/
 	UINT8 chinterfaceType = 0U;  /*试车线与车辆段接口方式*/
-	UINT16 wApplyId = 0U;        /*申请试车灯ID*/
 	UINT16 wApplyRelayId = 0U;   /*申请试车继电器ID*/
 	UINT16 wAllowRelayId = 0U;   /*允许试车灯ID*/
 	UINT8 chNonRouteState = 0U;  /*非进路状态*/
@@ -8629,4 +8665,285 @@ void SetSCOverIndicator(const UINT16 wIndicatorId)
 	{
 		SetIndicatorState(wIndicatorId, INDICATOR_SHOW_SC_NO); /*设置申结束试车指示灯无效*/
 	}
+}
+
+/*
+* 功能描述： 处理点连式列车发送数据信息
+* 参数说明： void
+* 返回值  ： 无
+* by lyj 20260314
+*/
+void VobcBlocLinkOutputProcess(void)
+{
+	UINT16 wTrainId = 0U;			 /*列车ID*/
+	UINT8 chXiansuState = 0U;		 /*临时限速状态*/
+	UINT8 chlineIdentity = 0U;		/*线路标识*/
+	UINT8 ii = 0U;					/*循环变量*/
+	UINT8 chResult = 0U;			/*临时承接变量*/
+
+	/*目前仅互联互通线路具备点连式接口*/
+	chlineIdentity = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);  /*获取线路标识*/
+	
+	if (LINE_HLHT == chlineIdentity)
+	{
+		/*限速确认之后或者限速清除之后*/
+		chXiansuState = CheckLocalCiLSXSStata();
+		if (CI_SUCCESS == chXiansuState)
+		{
+			for (ii = 0U; ii < TRAIN_SUM_MAX; ii++)
+			{
+				wTrainId = GetTrainId(ii);
+				wTrainId = wTrainId & 0x00ffU;
+				/*先清除要发送列车的点连式信息，然后重新计算*/
+				ClearBlocLinkTrainInfo(wTrainId);
+
+				/*互联互通线路使用消息剩余有效期来判断CI与VOBC通信是否中断*/
+				chResult = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_VOBC, (UINT8)wTrainId);
+				if (CI_SUCCESS == chResult)
+				{
+					/*计算列车进路信息*/
+					chResult = BlocLinkTrainRouteMange(wTrainId);
+
+					/*计算列车逻辑区段信息*/
+					chResult &= BlocLinkTrainLogSecMange(wTrainId);
+					if (CI_SUCCESS != chResult)
+					{
+						/*清除要发送列车的点连式信息*/
+						ClearBlocLinkTrainInfo(wTrainId);
+					}
+					else
+					{
+						/*不做处理*/
+					}
+				}
+				else
+				{
+					/*不做处理*/
+				}
+
+			}
+		}
+		else
+		{
+			/*清除要发送列车的点连式信息*/
+			for (ii = 0U; ii < TRAIN_SUM_MAX; ii++)
+			{
+				wTrainId = GetTrainId(ii);
+				wTrainId = wTrainId & 0x00ffU;
+				ClearBlocLinkTrainInfo(wTrainId);
+			}
+			debug_infor_printf((const)"\nCheckLocalCiLSXSStata ERROR\n");
+		}
+		
+		
+	}
+	else
+	{
+		/*不做处理*/
+	}
+
+}
+/*
+* 功能描述： 处理点连式列车进路信息
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 计算结果
+* by lyj 20260316
+*/
+
+UINT8 BlocLinkTrainRouteMange(const UINT16 wTrainId)
+{
+	UINT8 chRetVal = CI_ERROR;
+	struct_PathPoint end = { 0U };		/*列车逻辑终点*/
+	UINT16 wTempLogSecId = 0U;			/*车头逻辑区段*/
+	UINT16 wLogSecRLockRouteId = 0U;	/*逻辑区段锁闭所属进路*/
+	UINT8 chLocalCiId = 0U;				/*本机联锁ID*/
+	UINT16 wRouteEndSigId = 0U;			/*进路终端信号机ID*/
+	UINT8 chSigBelongCiId = 0U;			/*信号机所属联锁ID*/
+	UINT8 chRouteType = 0U;				/*进路类型*/
+	UINT16 wLastSectionId = 0U;			/*进路最后一个物理区段*/
+	UINT16 wValidReturnSigId = 0U;		/*有效折返信号机*/
+	UINT8 ii = 0U;
+	UINT16 wSigInFirstPhyId = 0U;		/*信号机内方物理区段*/
+	UINT16 wTempRouteId = 0U;
+	UINT8 chTempRouteState = 0U;
+	UINT8 chRouteDir = 0U;
+	UINT8 chTrainDir = 0U;
+
+	UINT8 chLogSecLockState = 0U;
+	if ((0U < wTrainId) && (TRAIN_SUM_MAX > wTrainId))
+	{
+		/*车头位置*/ 
+		end.wLinkId = GetAblTrainMaxHeadLink(wTrainId);
+		end.dwOffset = GetAblTrainMaxHeadOffset(wTrainId);
+
+		/*判断车头所属逻辑区段是否锁闭*/
+		wTempLogSecId = GetPointBelongLogSec(end);
+		wLogSecRLockRouteId = GetLogSecLockBelongRoute(wTempLogSecId);
+		chLogSecLockState = GetLogSecLockState(wTempLogSecId);
+		chRouteType = GetRouteType(wLogSecRLockRouteId);
+		if ((LOG_SECTION_LOCK_NORMAL == chLogSecLockState) && (0U < wLogSecRLockRouteId) && (ROUTE_SUM_MAX > wLogSecRLockRouteId) && (ROUTE_TYPE_DIAOCHE != chRouteType))
+		{
+			chRetVal = CI_SUCCESS;
+			/*记录脚下进路*/
+			SetBlocLinkRouteData(wTrainId, wLogSecRLockRouteId);
+			chLocalCiId = GetSystemParaLocalCiId();
+
+			for (ii = 0U; ii < (CI_VOBC_ROUTE_MAX -1U); ii++)
+			{
+				wRouteEndSigId = GetRouteEndSignalId(wLogSecRLockRouteId);
+				chSigBelongCiId = GetSignalBelongCiId(wRouteEndSigId);
+				if (chLocalCiId == chSigBelongCiId)
+				{
+					/*进路终端信号机所属联锁是本联锁，继续匹配*/
+					chRouteType = GetRouteType(wLogSecRLockRouteId);
+					if (ROUTE_TYPE_RETURN == chRouteType)
+					{
+						wLastSectionId = GetRouteLastPhySectionId(wLogSecRLockRouteId);				    /*获取进路最后一个物理区段*/
+						wValidReturnSigId = GetValidReturnSinalId(wLogSecRLockRouteId, wLastSectionId);	/*有效折返信号机*/
+						wRouteEndSigId = wValidReturnSigId;
+					}
+					else
+					{
+						/*直通进路-直接获取终端信号机*/
+						wRouteEndSigId = GetRouteEndSignalId(wLogSecRLockRouteId);
+					}
+					/*进路开放并且不是调车进路*/
+					wSigInFirstPhyId = GetSignalInFirstLockedPhySecId(wRouteEndSigId);
+					wTempRouteId = GetPhySecRLockBelongRouteId(wSigInFirstPhyId);
+					chTempRouteState = GetRouteState(wTempRouteId);
+
+					chRouteDir = GetRouteConfigDirection(wTempRouteId);
+					chTrainDir = GetAblTrainDir(wTrainId);
+					if (((ROUTE_STATE_YUXIAN_OPEN == chTempRouteState) || (ROUTE_STATE_NEAR_OPEN == chTempRouteState)) && (chRouteDir == chTrainDir) && (ROUTE_TYPE_DIAOCHE != chRouteType))
+					{
+						/*进路状态是接近开放或者预先开放(不匹配引导进路)；列车换端之后再匹配折出进路*/
+						SetBlocLinkRouteData(wTrainId, wTempRouteId);
+						wLogSecRLockRouteId = wTempRouteId;
+					}
+					else
+					{
+						break;
+					}
+					
+				}
+				else
+				{
+					break;
+				}
+			}
+	
+		}
+		else
+		{
+			/*不匹配进路*/
+		}
+		
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	return chRetVal;
+}
+
+/*
+* 功能描述： 处理点连式列车逻辑区段信息
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 计算结果
+* by lyj 20260316
+*/
+
+UINT8 BlocLinkTrainLogSecMange(const UINT16 wTrainId)
+{
+	/*计算列车逻辑区段--车脚下以及车头所处进路(往终端信号机)剩下的全部逻辑区段*/
+
+	struct_PathPoint start = { 0U };  /*列车逻辑起点*/
+	struct_PathPoint end = { 0U };    /*列车逻辑终点*/
+	UINT8 chRetVal = CI_ERROR;
+	UINT16 wTrainLogSecSum = 0U;							/*列车逻辑区段数量*/
+	UINT16 wTrainLogSecBuf[TRAIN_ABL_LOGSEC_SUM] = { 0U };   /*列车逻辑区段ID*/
+	UINT16 wTempLogSecId = 0U;			/*车头逻辑区段*/
+	UINT16 wLogSecRLockRouteId = 0U;	/*逻辑区段锁闭所属进路*/
+	UINT16 wRouteLogSectionSum = 0U;	/*进路逻辑区段数量*/
+	UINT16* pRouteLogSectionIdBuf = NULL;	/*进路逻辑区段数组*/
+	UINT16 ii = 0U;
+	UINT16 jj = 0U;
+	UINT8 chFlag = 0U;		/*开始记录进路的标志*/
+
+	/*车尾位置*/
+	start.wLinkId = GetAblTrainMinTailLink(wTrainId);;
+	start.dwOffset = GetAblTrainMinTailOffset(wTrainId);
+
+	/*车头位置*/
+	end.wLinkId = GetAblTrainMaxHeadLink(wTrainId);
+	end.dwOffset = GetAblTrainMaxHeadOffset(wTrainId);
+
+	/*获取车脚下逻辑区段*/
+	chRetVal = GetLogSecBtwTwoPoints(start, end, &wTrainLogSecSum, wTrainLogSecBuf);
+	if (CI_SUCCESS == chRetVal)
+	{
+		/*查车头所在进路的所有逻辑区段*/
+		wTempLogSecId = GetPointBelongLogSec(end);		/*车头逻辑区段*/
+		wLogSecRLockRouteId = GetLogSecLockBelongRoute(wTempLogSecId);			/*逻辑区段锁闭所属进路*/
+		wRouteLogSectionSum = GetRouteLogSectionSum(wLogSecRLockRouteId);		/*进路逻辑区段数量*/
+		pRouteLogSectionIdBuf = GetRouteLogSectionIdBuf(wLogSecRLockRouteId);	/*进路逻辑区段数组*/
+		if (TRAIN_ABL_LOGSEC_SUM > (wTrainLogSecSum + wRouteLogSectionSum))
+		{
+			if (NULL != pRouteLogSectionIdBuf)
+			{
+				for (ii = 0U; ii < wRouteLogSectionSum; ii++)
+				{
+					/*查进路的所有逻辑区段，查到了车头所在逻辑区段位置，往后开始记录逻辑区段*/
+					if ((wTempLogSecId == pRouteLogSectionIdBuf[ii]) && (0U == chFlag))
+					{
+						chFlag = 1U;
+						for (jj = 0U; jj < wTrainLogSecSum; jj++)
+						{
+							if (wTempLogSecId == wTrainLogSecBuf[jj])
+							{
+								break;		/*车头已存入，不再存*/
+							}
+						}
+						/*车头未存入，需要存一次*/
+						if ((jj == wTrainLogSecSum) && (TRAIN_ABL_LOGSEC_SUM > wTrainLogSecSum))
+						{
+							wTrainLogSecBuf[wTrainLogSecSum] = pRouteLogSectionIdBuf[ii];
+							wTrainLogSecSum++;
+						}
+					}
+					else
+					{
+						/*继续查找*/
+					}
+					/*找到了车头，开始存，车头所在逻辑区段已存入，不再存入*/
+					if ((1U == chFlag) && (TRAIN_ABL_LOGSEC_SUM > wTrainLogSecSum) && (wTempLogSecId != pRouteLogSectionIdBuf[ii]))
+					{
+						wTrainLogSecBuf[wTrainLogSecSum] = pRouteLogSectionIdBuf[ii];
+						wTrainLogSecSum++;
+					}
+					else
+					{
+						/*继续查找*/
+					}
+
+				}
+				SetBlocLinkOccLogSecData(wTrainId, wTrainLogSecSum, wTrainLogSecBuf);
+
+			}
+			else
+			{
+				chRetVal = CI_ERROR;
+			}
+		}
+		else
+		{
+			chRetVal = CI_ERROR;/*进路逻辑区段超标*/
+		}	
+	}
+	else
+	{
+		/*不处理*/
+	}
+	return chRetVal;
 }

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

@@ -524,6 +524,29 @@ void SetSCAllowIndicator(const UINT16 wIndicatorId);
 * by lyj 20260106
 */
 void SetSCOverIndicator(const UINT16 wIndicatorId);
+/*
+* 功能描述： 处理点连式列车发送数据信息
+* 参数说明： void
+* 返回值  ： 无
+* by lyj 20260314
+*/
+void VobcBlocLinkOutputProcess(void);
+/*
+* 功能描述： 处理点连式列车进路信息
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 计算结果
+* by lyj 20260316
+*/
+
+UINT8 BlocLinkTrainRouteMange(const UINT16 wTrainId);
+/*
+* 功能描述： 处理点连式列车逻辑区段信息
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 计算结果
+* by lyj 20260316
+*/
+
+UINT8 BlocLinkTrainLogSecMange(const UINT16 wTrainId);
 
 #ifdef __cplusplus
 }

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

@@ -1119,10 +1119,11 @@ UINT8 ReadConfigureData(void)
 		if (0u == rtnVal)
 		{
 			/*设置试车线与车辆段合设配置*/
-			g_ret = SetCldAndScxMergeConfig();
-			if (CI_ERROR == g_ret)
+			g_ret = (INT16)SetCldAndScxMergeConfig();
+			if (0 == g_ret)
 			{
 				debug_infor_printf((const)"SetCldAndScxMergeConfig fail.\r\n");
+				rtnVal = 44u;
 			}
 		}
 

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

@@ -683,6 +683,7 @@ UINT8 InitialSignalData(void)
 			SignalDataStruCC[signalId].cSleepTrainLightUpFlag = SIGNAL_SLEEP_TRAIN_LIGHTUP_NO;	/*初始化休眠车点亮信号机标志无效*/
 			SignalDataStruCC[signalId].LightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;  /*信号机亮灭状态CC(0x55：灭灯，0xaa：亮灯)*/
 			SignalDataStruCC[signalId].SignalCrossState = SIGNAL_CROSS_STATE_NO;           /*通信车跨压通过信号机状态CC(0x55：未跨压，0xaa：跨压)*/
+			SignalDataStruCC[signalId].wCrossTacsTrainId = 0u;           /*通信车跨压通过信号机TACS主控列车ID*/
 
 			/*初始化ZC发送的信号机动态数据*/
 			gZcToCiDymDataStru.szSignalDataStruZc[signalId].SignalId = signalId;
@@ -733,9 +734,11 @@ UINT8 InitialWashMachineData(void)
 		WashMachineDataStru[washMachinelId].TrainEmergencyStopState = WASHMACHINE_COL_FALUT_YES;
 		WashMachineDataStru[washMachinelId].HeadWashAllowState = WASHMACHINE_COL_HEADWASH_NO;
 		WashMachineDataStru[washMachinelId].TailWashAllowState = WASHMACHINE_COL_TAILWASH_NO;
+		WashMachineDataStru[washMachinelId].chCoupingWashAllowState = WASHMACHINE_COL_COUPINGWASH_NO;
 		WashMachineDataStru[washMachinelId].WashTrainRequestDrvState = WASHMACHINE_DRVSTATE_REQ_FALSE;
 		WashMachineDataStru[washMachinelId].TrainHeadStopSteadyDrvState = WASHMACHINE_HEAD_STEADY_NO;
 		WashMachineDataStru[washMachinelId].TrainTailStopSteadyDrvState = WASHMACHINE_TAIL_STEADY_NO;
+		WashMachineDataStru[washMachinelId].chCoupingStopSteadyDrvState = WASHMACHINE_COUPING_STEADY_NO;
 		WashMachineDataStru[washMachinelId].TrainOutWashTrainPortAllowState = WASHMACHINE_COL_OUT_NO;
 		WashMachineDataStru[washMachinelId].PauseTrainWashRequestDrvState = WASHMACHINE_PAUSE_DRVREQ_FALSE;
 		WashMachineDataStru[washMachinelId].PaseWashMachineRequesDrvtState = PASS_WASHMACHINE_DRVREQ_FALSE;
@@ -787,67 +790,88 @@ UINT8 InitialSwitchData(void)
 	UINT16 ii = 0u;								/*游标*/
 	UINT16 jj = 0u;		/*游标*/
 	UINT8 reVal = CI_ERROR;
+	UINT8 chSwitchIncludeOcNum = 0U;
+	UINT8 ocId = 0u;
+	UINT8 kk = 0u;
 
 	switchDataSum = GetTotalSwitchCurNum();		/*本联锁和相邻联锁发送给本联锁的道岔总数目*/
 																				/*数值大于SWITCH_SUM_MAX会返回0*/
 	for (ii = 0u; ii < switchDataSum; ii++)
-		{
-			switchId = GetSwitchId(ii);/*获取配置文件中该索引下的道岔ID*/
+	{
+		switchId = GetSwitchId(ii);/*获取配置文件中该索引下的道岔ID*/
 
-			SwitchDataStru[switchId].SwitchId = switchId;
-			SwitchDataStruCC[switchId].SwitchId = switchId;
-			SwitchDataStru[switchId].YLockState = SWITCH_LOCK_YINZONG_NO;
-			SwitchDataStru[switchId].LockStatus = SWITCH_LOCK_STATUS_NO;
-			SwitchDataStru[switchId].FLockState = SWITCH_LOCK_FENGSUO_NO;
-			SwitchDataStru[switchId].SwitchPrePosition = SWITCH_POSITION_SIKAI;
-			SwitchDataStru[switchId].SwitchCurPosition = SWITCH_POSITION_SIKAI;
-			SwitchDataStru[switchId].SingleSwitchCurPosition = SWITCH_POSITION_SIKAI;
-			SwitchDataStru[switchId].SwitchDrivePos = SWITCH_DRIVE_POS_INVALID;
-			SwitchDataStru[switchId].SwitchExpDrvPos = SWITCH_DRIVE_POS_INVALID;
-			SwitchDataStru[switchId].switchPreExpDrvPos = SWITCH_DRIVE_POS_INVALID;
-			SwitchDataStru[switchId].SwitMoveStartCycNum = 0u;
-			SwitchDataStru[switchId].SwitDriveStartCycNum = 0u;
-			SwitchDataStru[switchId].chSwitchDrivedFlag = SWITCH_DRIVED_FLAG_NO;
-			SwitchDataStru[switchId].SwitchDanCaoPostition = SWITCH_POSITION_INVALID;
-			SwitchDataStru[switchId].switchDrivingState = SWIT_DRIV_IDLE_TIME;
-			SwitchDataStru[switchId].switchDrivOvtmDrvPos = SWITCH_DRIVE_POS_INVALID;
-			SwitchDataStru[switchId].switchFaultState = SWITCH_FAULT_STATE_YES;
-			/* zt 删除单轨相关代码 2022-02-15 */
-			SwitchDataStru[switchId].switchKRState = SWITCH_KERAO_STATE_YES;
-			SwitchDataStru[switchId].switchLastValidDrvPosCycleNum = 0u;
-			SwitchDataStru[switchId].switchLastValidDrvPos = SWITCH_DRIVE_POS_INVALID;
-			SwitchDataStru[switchId].UsingBelongOverlapId = 0u;
-			SwitchDataStru[switchId].DFHRelayValidCycNum = 0u;
-			SwitchDataStru[switchId].SigleDFHRelayValidCycNum = 0u;
-			SwitchDataStru[switchId].PLockedRouteNum = 0u;
-			SwitchDataStruCC[switchId].PLockedLogRouteNum = 0u;
-			SwitchDataStru[switchId].PLockedOverlapNum = 0u;
-			SwitchDataStru[switchId].PLockedNonRouteNum = 0u;
-			SwitchDataStru[switchId].YCRelayValidCycNum = 0u;
-			SwitchDataStru[switchId].SigleYCRelayValidCycNum = 0u;
-			SwitchDataStru[switchId].ConnetSwitchDsState = CONNECT_SWITCH_DANSUO_NO;
-			SwitchDataStru[switchId].SwitchByPassState = SWITCH_BYPASS_NO;
-			SwitchDataStru[switchId].SwitchBypassStartCycNum = 0u;
-			SwitchDataStru[switchId].chSwitchJichaState = 0U;
-			SwitchDataStru[switchId].cSwitchUsingState = SWITCH_USING_NO;
-			SwitchDataStru[switchId].SwitchCollTolerateCycNum = 0U;
-			SwitchDataStru[switchId].SwitchColPosition = SWITCH_POSITION_SIKAI;
-			SwitchDataStru[switchId].switchFaultState = SWITCH_FAULT_STATE_YES; /*置为板卡故障*/
-			/*初始化被防护锁闭的进路、保护区段、非进路数量及数组*/
-			for (jj=0; jj<SWITCH_MAX_PROTECT_LOCKED_NUM;jj++)
-			{
-				SwitchDataStru[switchId].PLockedRouteIdArr[jj] = 0u;
-				SwitchDataStruCC[switchId].PLockedLogRouteIdArr[jj] = 0u;
-				SwitchDataStru[switchId].PLockedOverlapIdArr[jj] = 0u;
-				SwitchDataStru[switchId].PLockedNonRouteIdArr[jj] = 0u;
-			}
-			/*初始化道岔转辙机数量、状态*/
-			SwitchDataStru[switchId].chSwitchIncldeZzjNum = 0u;
-			for (jj = 0; jj < SWITCH_ZZJ_POWER_STATE_MAX_NUM; jj++)
-			{
-				SwitchDataStru[switchId].szSwitchIncldeZzjState[jj] = OC_SWITCH_POSITION_SIKAI;
-			}
+		SwitchDataStru[switchId].SwitchId = switchId;
+		SwitchDataStruCC[switchId].SwitchId = switchId;
+		SwitchDataStru[switchId].YLockState = SWITCH_LOCK_YINZONG_NO;
+		SwitchDataStru[switchId].LockStatus = SWITCH_LOCK_STATUS_NO;
+		SwitchDataStru[switchId].FLockState = SWITCH_LOCK_FENGSUO_NO;
+		SwitchDataStru[switchId].SwitchPrePosition = SWITCH_POSITION_SIKAI;
+		SwitchDataStru[switchId].SwitchCurPosition = SWITCH_POSITION_SIKAI;
+		SwitchDataStru[switchId].SingleSwitchCurPosition = SWITCH_POSITION_SIKAI;
+		SwitchDataStru[switchId].SwitchDrivePos = SWITCH_DRIVE_POS_INVALID;
+		SwitchDataStru[switchId].SwitchExpDrvPos = SWITCH_DRIVE_POS_INVALID;
+		SwitchDataStru[switchId].switchPreExpDrvPos = SWITCH_DRIVE_POS_INVALID;
+		SwitchDataStru[switchId].SwitMoveStartCycNum = 0u;
+		SwitchDataStru[switchId].SwitDriveStartCycNum = 0u;
+		SwitchDataStru[switchId].chSwitchDrivedFlag = SWITCH_DRIVED_FLAG_NO;
+		SwitchDataStru[switchId].SwitchDanCaoPostition = SWITCH_POSITION_INVALID;
+		SwitchDataStru[switchId].switchDrivingState = SWIT_DRIV_IDLE_TIME;
+		SwitchDataStru[switchId].switchDrivOvtmDrvPos = SWITCH_DRIVE_POS_INVALID;
+		SwitchDataStru[switchId].switchFaultState = SWITCH_FAULT_STATE_YES;
+		/* zt 删除单轨相关代码 2022-02-15 */
+		SwitchDataStru[switchId].switchKRState = SWITCH_KERAO_STATE_YES;
+		SwitchDataStru[switchId].switchLastValidDrvPosCycleNum = 0u;
+		SwitchDataStru[switchId].switchLastValidDrvPos = SWITCH_DRIVE_POS_INVALID;
+		SwitchDataStru[switchId].UsingBelongOverlapId = 0u;
+		SwitchDataStru[switchId].DFHRelayValidCycNum = 0u;
+		SwitchDataStru[switchId].SigleDFHRelayValidCycNum = 0u;
+		SwitchDataStru[switchId].PLockedRouteNum = 0u;
+		SwitchDataStruCC[switchId].PLockedLogRouteNum = 0u;
+		SwitchDataStru[switchId].PLockedOverlapNum = 0u;
+		SwitchDataStru[switchId].PLockedNonRouteNum = 0u;
+		SwitchDataStru[switchId].YCRelayValidCycNum = 0u;
+		SwitchDataStru[switchId].SigleYCRelayValidCycNum = 0u;
+		SwitchDataStru[switchId].ConnetSwitchDsState = CONNECT_SWITCH_DANSUO_NO;
+		SwitchDataStru[switchId].SwitchByPassState = SWITCH_BYPASS_NO;
+		SwitchDataStru[switchId].SwitchBypassStartCycNum = 0u;
+		SwitchDataStru[switchId].chSwitchJichaState = 0U;
+		SwitchDataStru[switchId].cSwitchUsingState = SWITCH_USING_NO;
+		SwitchDataStru[switchId].SwitchCollTolerateCycNum = 0U;
+		SwitchDataStru[switchId].SwitchColPosition = SWITCH_POSITION_SIKAI;
+		SwitchDataStru[switchId].switchFaultState = SWITCH_FAULT_STATE_YES; /*置为板卡故障*/
+		/*初始化被防护锁闭的进路、保护区段、非进路数量及数组*/
+		for (jj=0; jj<SWITCH_MAX_PROTECT_LOCKED_NUM;jj++)
+		{
+			SwitchDataStru[switchId].PLockedRouteIdArr[jj] = 0u;
+			SwitchDataStruCC[switchId].PLockedLogRouteIdArr[jj] = 0u;
+			SwitchDataStru[switchId].PLockedOverlapIdArr[jj] = 0u;
+			SwitchDataStru[switchId].PLockedNonRouteIdArr[jj] = 0u;
 		}
+		/*初始化道岔转辙机数量、状态*/
+		SwitchDataStru[switchId].chSwitchIncldeZzjNum = 0u;
+		for (jj = 0; jj < SWITCH_ZZJ_POWER_STATE_MAX_NUM; jj++)
+		{
+			SwitchDataStru[switchId].szSwitchIncldeZzjState[jj] = OC_SWITCH_POSITION_SIKAI;
+		}
+
+		chSwitchIncludeOcNum = GetSwitchIncludeOcNum(switchId);
+		SwitchDataStru[switchId].chSwitchBelongOcNum = chSwitchIncludeOcNum;
+		for (jj = 0u; jj < chSwitchIncludeOcNum; jj++)
+		{/*从静态数据读取OCID赋值给动态数据*/
+			ocId = GetSwitchIncludeOCId(switchId, jj);
+			SwitchDataStru[switchId].belongOCData[jj].OcId = ocId;
+			SwitchDataStru[switchId].belongOCData[jj].OutControlCmd = STANDBY_CONTROL;
+			SwitchDataStru[switchId].belongOCData[jj].PlusBoxSate = SWITCH_BOX_FAULT;
+			for (kk = 0u; kk < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; kk++)
+			{
+				SwitchDataStru[switchId].belongOCData[jj].BoardStateBuf[kk] = SWITCH_BOARD_FAULT;
+			}
+			SwitchDataStru[switchId].belongOCData[jj].controlMode = STANDBY_CONTROL;
+			SwitchDataStru[switchId].belongOCData[jj].FindCmdStartCycNum = 0u;
+			SwitchDataStru[switchId].belongOCData[jj].FindPostionCmd = NO_FIND_CMD;
+			SwitchDataStru[switchId].belongOCData[jj].OutMainControlCmdCycNum = 0u;
+		}
+	}
 	reVal = CI_SUCCESS;
 	return reVal;
 }
@@ -1044,6 +1068,7 @@ UINT8 InitialLogicSectionData(void)
 	UINT16 ii = 0u;									/*游标*/
 	UINT16 jj = 0u;									/*游标*/
 	UINT8 kk = 0u;									/*游标*/
+	UINT8 mm = 0u;									/*游标*/
 	UINT16 zcToCiMaskSum = 0u;                     /*ZC-CI码位总数*/
 	UINT8 reVal = CI_ERROR;
 	UINT8 chTmcSwitch = 0u;
@@ -1088,7 +1113,8 @@ UINT8 InitialLogicSectionData(void)
 			LogicSectionDataStru[logicSectionId].chLogicSpksFLockState = LOGIC_SECTION_SPKS_FLOCK_NO;/*仅用于ATS显示；逻辑区段不一定关联SPKS，如果初始化成封锁，无法获取SPKS状态，此逻辑区段会一直为封锁状态*/
 			LogicSectionDataStru[logicSectionId].chLinShiXianSuSetSpeed = 0U;		/*逻辑区段临时限速设置速度值*/
 			LogicSectionDataStru[logicSectionId].chLogSecEmergXianSu = LOGSEC_EMERG_XS_SET_NO; /*逻辑区段紧急临时限速*/
-
+			LogicSectionDataStru[logicSectionId].chLogSecCbtcArbState = LGC_SECTION_ARB_NO;
+			LogicSectionDataStru[logicSectionId].chLogSecPbTacsArbState = LGC_SECTION_ARB_NO;
 			/*初始化车车结构体成员*/
 			LogicSectionDataStruCC[logicSectionId].LogicSectionId = logicSectionId;
 			LogicSectionDataStruCC[logicSectionId].chResShareFlag = LOGIC_SECTION_RES_SHARE_NO;
@@ -1101,14 +1127,10 @@ UINT8 InitialLogicSectionData(void)
 			LogicSectionDataStruCC[logicSectionId].LogErrlockStartCycNum = 0U;
 			LogicSectionDataStruCC[logicSectionId].chAblRelLogSecUsableFlag = LOGIC_ABLNEAR_USE_FLAG_NO;		/*初始化ABL接近逻辑区段可用标志*/
 			LogicSectionDataStruCC[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO;   /*离去区段ABL列车检查不通过*/
-			for (jj = 0U; jj < LOGIC_SECTION_RES_SUM_MAX; jj++)
+			for (mm = 0U; mm < LOGIC_SECTION_RES_SUM_MAX; mm++)
 			{
-				LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].wTrainId = 0U;
-				LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chLogicResUsable = LOGIC_SECTION_RES_UNUSABLE;
-				LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chLogicReturnState = LOGIC_SECTION_TRAIN_RETURN_NO;
-				LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chTrainApplyState = LOGIC_SECTION_TRAIN_APPLY_NO;
-				LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chLogicUnlockState = LOGIC_SECTION_TRAIN_UNLOCK_NO;
-				LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].dwRcvUnlockCmdCyc = 0U;
+				/*重置资源信息结构体*/
+				ResetResInfoStruct(logicSectionId, mm);
 			}
 			LogicSectionDataStruCC[logicSectionId].chLogSecLockBelLogRouteSum = 0U;
 			for (jj = 0U; jj < LOGSEC_RELATE_ROUTE_SUM_MAX; jj++)
@@ -1472,7 +1494,7 @@ UINT8 InitialPsdData(void)
 		PsdDataStru[psdId].psdOpenErrState = PSD_OPEN_CLOSE_ERROR;
 		PsdDataStru[psdId].psdCloseErrState = PSD_OPEN_CLOSE_ERROR;
 		
-		PsdDataStru[psdId].cPsdExceptOpenState = PSD_EXCEPT_OPEN_YES;  /*初始化为PSD异常打开*/
+		PsdDataStru[psdId].cPsdExceptOpenState = PSD_EXCEPT_NO;  /*初始化为PSD未异常*/
 		PsdDataStru[psdId].dwPsdRelayDownCycNum = 0U;  /*PSD门关继电器落下起始周期*/
 		PsdDataStru[psdId].JXTCMutualLockFaultState = JXTC_MUTUALLOCKFAULT_NO;
 		PsdDataStru[psdId].JXTCMutualLockStartCycNum = 0u;
@@ -2322,7 +2344,9 @@ void ResetDynamicState(const UINT8 ciId)
 			LogicSectionDataStruCC[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO;   /*离去区段ABL列车检查不通过*/
 			LogicSectionDataStru[logicSectionId].chLogicProResUsable = LOGIC_SECTION_PRO_RES_UNUSABLE;
 			LogicSectionDataStru[logicSectionId].chLogSecEmergXianSu = LOGSEC_EMERG_XS_SET_YES;  /*逻辑区段紧急临时限速设置状态*/
-   	    }
+			LogicSectionDataStru[logicSectionId].chLogSecCbtcArbState = LGC_SECTION_ARB_NO;
+			LogicSectionDataStru[logicSectionId].chLogSecPbTacsArbState = LGC_SECTION_ARB_NO;
+		}
 		else
 		{
 			/*不做处理*/
@@ -2374,7 +2398,7 @@ void ResetDynamicState(const UINT8 ciId)
 				PsdDataStru[devId].PsdState = PSD_STATE_CLOSE;
 			}
 			PsdDataStru[devId].MutualLockRemoveState = PSD_MUTUALLOCK_REMOVE_NO;
-			PsdDataStru[devId].cPsdExceptOpenState = PSD_EXCEPT_OPEN_YES;  /*重置为PSD异常打开*/
+			PsdDataStru[devId].cPsdExceptOpenState = PSD_EXCEPT_YES;  /*重置为PSD异常*/
    	    }
 	}
 
@@ -2565,7 +2589,7 @@ void ResetDynamicState(const UINT8 ciId)
 		devId = (ii);
 		devLen = (UINT16)sizeof(OverlapDataStruct);
 		chOverlapCiId = GetOverlapBelongCiId(devId);
-		if((chOverlapCiId == ciId) && (devId > 0u) && (devId < OVERLAP_SUM_MAX))
+		if((chOverlapCiId == ciId))
 		{
 			OverlapDataStru[devId].BelongRouteId = 0u;
 			OverlapDataStru[devId].UnlockStartCycNum = 0u;
@@ -2586,7 +2610,7 @@ void ResetDynamicState(const UINT8 ciId)
 			OverlapDataStru[devId].chPreLaborUnlockState = PRO_PRE_LABOR_UNLOCK_STATE_NO;
 			OverlapDataStru[devId].dwAtsLastTimeLockCyc = 0U;
 		}
-		else if ((chOverlapCiId == localCi) && (devId > 0U) && (devId < OVERLAP_SUM_MAX))
+		else if ((chOverlapCiId == localCi))
 		{
 			cOverlapRelProSwNum = GetOverlapRelatedProtSwitSum(devId);  /*获取保护区段关联的防护道岔信息*/
 			pOverlapRelProSwStru = GetOverlapRelatedProtSwitStru(devId);
@@ -3411,7 +3435,7 @@ void ResetLocalRcDynamicState(void)
 		if (cBelongCiId == cLocalCiId)
 		{
 			SetSignalLightExtinctStateCC(wSignalId, SIGNAL_LIGHT_EXTICT_STATE_YES);  /*设置RC信号机亮灭状态为亮灯*/
-			SetSignalCrossStateCC(wSignalId, SIGNAL_CROSS_STATE_NO);  /*设置RC信号机跨压状态为未跨压*/
+			SetSignalCrossStateCC(wSignalId, SIGNAL_CROSS_STATE_NO, 0u);  /*设置RC信号机跨压状态为未跨压*/
 		}
 		else
 		{

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

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

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

@@ -13,6 +13,7 @@
 
 #include "LogRecord.h"
 #include "../ParsePack/ParsePackVobcData.h"
+#include "../ParsePack/ParsePackZcData.h"
 #include <stdarg.h>
 
 
@@ -497,6 +498,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	OCStationIndicDataStru* pNewOCStationIndicData = GetOCStationIndicDataStru();
 	EsbDataStruct* pNewEsbData = GetEsbData();
 	LogicalRouteDataStruct* pNewLogicalRouteDataStru = GetLogicalRouteStr();
+	CbtcCrossStructZC* pCbtcCrossStructZCStru = GetCbtcCrossStructZc();
 	UINT16 wCfpId = 0u;
 	UINT8 chEnIndex = 0u;
 	UINT8 chTrainIndex = 0u;
@@ -505,6 +507,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	UINT16 wNonAutoReturnCurSum = 0U;/*无人折返按钮当前总数*/
 	NonAutoReturnDataStruct* pNonAutoReturnData = NULL;    /*无人折返数据结构体指针*/
 	NonAutoReturnDataStructCC* pNonReturnDataStruCC = NULL;  /*无人折返数据结构体指针-CC*/
+	UINT8 chThisOCBoardState = 0U;
 
     /*************************************打印物理区段数据********************************************/
     /*打印区段数据*/
@@ -701,6 +704,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newSignalData[deviceId].DoubleGreenDsBreakFlag;/*双绿灯丝断丝标志状态*/
 				outString[outStringLength++] = newSignalData[deviceId].DoubleYellowDsBreakFlag;/*双黄灯丝断丝标志状态*/
 				outString[outStringLength++] = newSignalData[deviceId].MaintainLightState;/*信号机维修点灯状态*/
+				outString[outStringLength++] = pSignalDataCC[deviceId].wCrossTacsTrainId;/*TACS跨压列车ID*/
 
 				if (MAX_SIGNAL_LIGHTUPLINK_NUM < pSignalDataCC[deviceId].wSignalLightUpLinkIdSum)
 				{
@@ -955,6 +959,36 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newSwitchData[deviceId].chSwitchJichaState;   /*道岔挤岔状态*/
 				LongToChar(newSwitchData[deviceId].SwitchCollTolerateCycNum, &outString[outStringLength]);/*容忍周期号*/
 				outStringLength += 4u;
+
+				LongToChar(newSwitchData[deviceId].SwitchOutputDrvCmdCycNum, &outString[outStringLength]);/*驱动起始周期*/
+				outStringLength += 4u;
+
+				outString[outStringLength++] = newSwitchData[deviceId].mainControlOcId;/*主控OC*/
+
+				outString[outStringLength++] = newSwitchData[deviceId].chSwitchBelongOcNum;/*道岔所属OC数*/
+				for (jj = 0U; jj < newSwitchData[deviceId].chSwitchBelongOcNum; jj++)
+				{
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].OcId;/*道岔所属OC*/
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].controlMode;/*OC当前主控状态*/
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].OutControlCmd;/*发送OC当前主控命令*/
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].PlusBoxSate;/*插箱状态*/
+					chThisOCBoardState = GetSwitchThisOCBoardState(deviceId, newSwitchData[deviceId].belongOCData[jj].OcId);
+					outString[outStringLength++] = chThisOCBoardState;/*双系板卡故障状态*/
+
+					LongToChar(newSwitchData[deviceId].belongOCData[jj].OutMainControlCmdCycNum, &outString[outStringLength]);/*升主控命令周期*/
+					outStringLength += 4u;
+					outString[outStringLength++] = newSwitchData[deviceId].belongOCData[jj].FindPostionCmd;/*寻表命令*/
+					LongToChar(newSwitchData[deviceId].belongOCData[jj].FindCmdStartCycNum, &outString[outStringLength]);/*寻表命令起始周期*/
+					outStringLength += 4u;
+				}
+
+				outString[outStringLength++] = newSwitchData[deviceId].PLockedAxisSecNum;/*被防护锁闭的计轴区段ID*/
+				for (jj = 0; jj < SWITCH_MAX_PROTECT_LOCKED_NUM; jj++)
+				{
+					ShortToChar(newSwitchData[deviceId].PLockedAxisSecIdArr[jj], &outString[outStringLength]);
+					outStringLength += 2u;
+				}
+				
             }
         }
         else
@@ -1344,6 +1378,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength++;
 				outString[outStringLength] = pLogicSecDataCC[deviceId].TXOccupyState;/*逻辑区段通信车占用状态CC(0x55-无车或非通信车占用，0xAA-通信车占用)*/
 				outStringLength++;
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecCbtcArbState;/*逻辑区段CBTC_ARB状态*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chLogSecPbTacsArbState;/*逻辑区段PB_TACS_ARB状态*/
+				outString[outStringLength++] = newLogicSecData[deviceId].chArbState;/*逻辑区段ARB状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].LogLockState;/*逻辑区段锁闭状态*/
 				outString[outStringLength++] = newLogicSecData[deviceId].LogLockDir;/*逻辑区段锁闭方向*/
 				outString[outStringLength++] = pLogicSecDataCC[deviceId].chResShareFlag;/*逻辑区段共享标志 0x55共享 0xAA非共享*/
@@ -1485,9 +1522,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainEmergencyStopState;/*列车紧急停车状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].HeadWashAllowState;/*允许车头清洗状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].TailWashAllowState;/*允许车尾清洗状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chCoupingWashAllowState;/*允许联挂端清洗状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].WashTrainRequestDrvState;/*洗车请求驱动状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainHeadStopSteadyDrvState;/*车头停稳驱动状态*/
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainTailStopSteadyDrvState;/*车尾停稳驱动状态*/
+				outString[outStringLength++] = newWashMachineData[deviceId].chCoupingStopSteadyDrvState;    /*联挂端停稳驱动状态*/
+
 				outString[outStringLength++] = newWashMachineData[deviceId].TrainOutWashTrainPortAllowState;/*允许出洗车库状态*/
 				ShortToChar(newWashMachineData[deviceId].CurVobcId, &outString[outStringLength]);/*当前洗车的VOBC ID*/
 				outStringLength += 2u;
@@ -2411,6 +2451,11 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 
 				outString[outStringLength++] = pNewTrainInfoData[deviceId].chtrainControlMode;/*当前控车模式*/
 				outString[outStringLength++] = pNewTrainInfoData[deviceId].chTrainPostionMode; /*列车位置模式，0无位置，1使用IVOC位置，2使用VOBC位置*/
+				ShortToChar(pNewTrainInfoData[deviceId].wMinSafeHeadLink, &outString[outStringLength]);/*延时小前所处link*/
+				outStringLength += 2u;
+				LongToChar(pNewTrainInfoData[deviceId].dwMinSafeHeadOffset, &outString[outStringLength]);/*延时小前所处link偏移量*/
+				outStringLength += 4u;
+				outString[outStringLength++] = pNewTrainInfoData[deviceId].chMinSafeHeadDir;/* 延时小前方向 */
 			}
 
 
@@ -2879,10 +2924,46 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	else
 	{
 #ifdef PLATFORM_2OO2
-		debug_infor_printf((const)"\nNonAutoReturnData:%d", (UINT16)sizeof(NonAutoReturnDataStruct), outStringLength);
+		debug_infor_printf((const)"\nNonAutoReturnData:%d, length:%d", (UINT16)sizeof(NonAutoReturnDataStruct), outStringLength);
 
 		debug_out_array(0xAA, outString, outStringLength);
 
+#endif
+
+		/*清空打印数据*/
+		CleanString(outString);
+		outStringLength = 0u;
+	}
+
+	/*************************************打印CBTC跨压数据********************************************/
+	/*打印CBTC跨压数据*/
+	deviceNum = GetCbtcCrossNumZc();/* 获取边界点数量 */
+
+	for (ii = 0U; ii < deviceNum; ii++)
+	{
+		if ((CI_SUCCESS != returnValue) || (NULL == pCbtcCrossStructZCStru))
+		{
+			returnValue = CI_ERROR;
+			break;
+		}
+
+		ShortToChar(pCbtcCrossStructZCStru[ii].wSignalId, &outString[outStringLength]);/*CBTC跨压信号机ID*/
+		outStringLength += 2u;
+		outString[outStringLength] = pCbtcCrossStructZCStru[ii].wTrainId; /*CBTC跨压列车ID*/
+		outStringLength++;
+	}
+
+	if (0u == outStringLength)
+	{
+		/*nothing*/
+		debug_infor_printf((const)"\nCbtcCrossData:0u");
+	}
+	else
+	{
+#ifdef PLATFORM_2OO2
+		debug_infor_printf((const)"\nCbtcCrossData:%d:", outStringLength);
+
+		debug_out_array(0xAA, outString, outStringLength);
 #endif
 
 		/*清空打印数据*/

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

@@ -595,7 +595,7 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
 			cSwitchCurPos = GetSwitchCurPosition(protectSwitchId);
 			cFuncRet = checkSwtLastValDrvPosStayorNot(protectSwitchId, routeProtectSwitchStru[ii].ProtectPosition);
 			if ((SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
-				|| ((SWITCH_LOCK_PROTECT_SET == lockCommand) && (cSwitchCurPos == routeProtectSwitchStru[ii].ProtectPosition) && (CI_SUCCESS == cFuncRet)))
+				|| ((cSwitchCurPos == routeProtectSwitchStru[ii].ProtectPosition) && (CI_SUCCESS == cFuncRet)))
 			{
 				SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, routeId, protectSwitchId, lockCommand);  /*设置道岔防护锁闭状态*/
 			    /*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/

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

@@ -16,7 +16,6 @@
 #include "TrainDataManage.h"
 #include "HLHTHeadContexManage.h"
 #include "TrainOnAcManage.h"
-#include "TrainDataManage.h"
 #include "SectionStateProcess_define.h"
 #include "DynamicRouteDataManage.h"
 #include "LogicalRouteDataManage.h"
@@ -2014,8 +2013,10 @@ void RouteNearLockManage(const UINT16 routeId)
 	UINT16 returnSecId = 0U;  /*折返区段*/
 	UINT8 localCiType = 0U;/*联锁类型*/
 	UINT8 cFuncRetVal = CI_ERROR;
+	UINT8 chRouteBelongVirCiId = 0U;
 
-	localCiType = GetLocalCiType();
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	localCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 	/*获取进路始端信号机ID*/
 	startSignalId = GetRouteStartSignalId(routeId);
 	autoSigRouteState = GetRouteAutoSigSetState(routeId);        /*获取自动信号进路状态*/
@@ -2141,6 +2142,7 @@ void RouteNearLockManage(const UINT16 routeId)
 
 				validReturnSigId = GetValidReturnSinalId(routeId, logBelongPhyId);
 				returnSecId = GetSignalOutFirstPhySecId(validReturnSigId);
+
 				/*逻辑区段当前CT占用，或者之前CT占用，当前空闲 且逻辑区段不是道岔区段，且非折返进路或为折返进路但非折返轨*/
 				if (((LOGICSECTION_OCCUPY_CT == logCurOccupyState) ||
 					((LOGICSECTION_OCCUPY_NO == logCurOccupyState) && (LOGICSECTION_OCCUPY_CT == logPreOccupyState)))
@@ -2254,7 +2256,6 @@ void RouteNearLockManage(const UINT16 routeId)
 */
 void RouteDelayUnlockManage(const UINT16 routeId)
 {
-	UINT8 routeLevel = 0u;         /*进路监督级别*/
 	UINT16 startSignalId = 0u;     /*进路始端信号机ID*/
 	UINT32 delayStartCycNum = 0u;  /*延时解锁起始周期号*/
 	UINT32 delayTotalCycSum = 0u;  /*延时解锁总周期数*/
@@ -2267,13 +2268,10 @@ void RouteDelayUnlockManage(const UINT16 routeId)
 	UINT16 wTrainId = 0u;
 	UINT16 wLastTrainId = 0u;
 	UINT32 curCycle = 0u;
-	UINT8 chRouteState = 0u;
 
 	/*获取进路动态字段*/
-	routeLevel = GetRouteLevel(routeId);                       /*获取进路监督级别*/
 	startSignalId = GetRouteStartSignalId(routeId);            /*获取进路始端信号机ID*/
 	curCycle = Get2oo2CurCycleNum();
-	chRouteState = GetRouteType(routeId);
 
 	(void)DriveSignalClose(startSignalId);  /*驱动信号关闭*/
 
@@ -3388,7 +3386,18 @@ UINT8 LockRouteOverlapProc(const UINT16 routeId)
 	UINT8 cTimeCheckFlag = CI_TIME_OUT;
 	UINT8 cKeepWorkFlag = CI_ERROR;
 	UINT8 cSwitchPosCheckRet = CI_ERROR;
+	UINT8 cOverlapCiId = 0U;  /*保护区段所属联锁ID*/
+	UINT16 wRouteLeavePhySecId = 0U;/*进路离去物理区段ID*/
+	UINT8 cPhySecLockState = 0U;	/*物理区段锁闭状态*/
+	UINT8 cLocalCiId = 0U;	/*本机联锁ID*/
+	UINT8 cRouteBlongCiId = 0U;	/*进路所属联锁ID*/
+	UINT8 cProSecDelayLockFlag = 0U;	/*保护区段延时锁闭标志*/
+	UINT32 dwPhySecDelayLockStartCyc = 0U;	/*物理区段延时锁闭起始周期*/
+	UINT32 dwBadEnsureCount = 0U;	/*联锁通信中断确认周期数*/
 
+	cLocalCiId = GetSystemParaLocalCiId();
+	dwBadEnsureCount = GetCiAndCiTransBadEnsureCnt();
+	cRouteBlongCiId = GetRouteBelongCiId(routeId);
 	overlapSum = GetRouteOverlapSum(routeId);  /*获取Overlap总数*/
 	overlapIdBuf = GetRouteOverlapIdBuf(routeId);  /*获取Overlap ID BUF*/
 	dwCurCycNum = Get2oo2CurCycleNum();
@@ -3403,7 +3412,8 @@ UINT8 LockRouteOverlapProc(const UINT16 routeId)
 		cKeepWorkFlag = CI_SUCCESS;
 		for (ii = 0u; ii < overlapSum; ii++)
 		{
-			if (GetOverlapBelongCiId(overlapIdBuf[ii]) == localCiId)
+			cOverlapCiId = GetOverlapBelongCiId(overlapIdBuf[ii]);
+			if (cOverlapCiId == localCiId)
 			{
 				/*属于本联锁保护区段*/
 
@@ -3430,31 +3440,35 @@ UINT8 LockRouteOverlapProc(const UINT16 routeId)
 				devId = GetRouteLastPhySectionId(routeId);
 				devState = GetPhySecCurOccupyState(devId);
 				devPreState = GetPhySecPreOccupyState(devId);
-				overlapState = GetPhySecCurOccupyState(GetRouteLeavePhySecId(routeId));
+				cPhySecLockState = GetPhySecLockState(devId);
+				wRouteLeavePhySecId = GetRouteLeavePhySecId(routeId);
+				overlapState = GetPhySecCurOccupyState(wRouteLeavePhySecId);
 				routeState = GetRouteState(routeId);
 				if ((SECTION_OCCUPY_NO == devState) &&
 					(SECTION_OCCUPY_YES == devPreState) &&
 					(SECTION_OCCUPY_NO == overlapState) &&
-					(PHYSICAL_SECTION_LOCK_NORMAL == GetPhySecLockState(devId)) &&
+					(PHYSICAL_SECTION_LOCK_NORMAL == cPhySecLockState) &&
 					(ROUTE_STATE_AUTO_UNLOCK == routeState) &&
-					(GetSystemParaLocalCiId() != GetRouteBelongCiId(routeId))
+					(cLocalCiId != cRouteBlongCiId)
 					)
 				{
 					SetProtectSecLockDelayTimeFlag(devId, PROTECTSECLOCKDELAY_YES);
-					SetPhySecLockDelayStartCycNum(devId, Get2oo2CurCycleNum());  /*设置物理区段延时锁闭周期号*/
+					SetPhySecLockDelayStartCycNum(devId, dwCurCycNum);  /*设置物理区段延时锁闭周期号*/
 				}
 				else
 				{
 					;
 				}
 
-				if (PROTECTSECLOCKDELAY_NO == GetProtectSecLockDelayTimeFlag(devId))
+				cProSecDelayLockFlag = GetProtectSecLockDelayTimeFlag(devId);
+				dwPhySecDelayLockStartCyc = GetPhySecLockDelayStartCycNum(devId);
+				if (PROTECTSECLOCKDELAY_NO == cProSecDelayLockFlag)
 				{
 					/*锁闭进路Overlap管理*/
 					returnValue = LockRouteOverlapLogicProcess(routeId, overlapIdBuf[ii], CI_LOCK_OVERLAP);
 				}
-				else if (((Get2oo2CurCycleNum() - GetPhySecLockDelayStartCycNum(devId)) > GetCiAndCiTransBadEnsureCnt())
-					&& (PROTECTSECLOCKDELAY_YES == GetProtectSecLockDelayTimeFlag(devId)))
+				else if (((dwCurCycNum - dwPhySecDelayLockStartCyc) > dwBadEnsureCount)
+					&& (PROTECTSECLOCKDELAY_YES == cProSecDelayLockFlag))
 				{  /*标志设置超时则清除标志*/
 					SetProtectSecLockDelayTimeFlag(devId, PROTECTSECLOCKDELAY_NO);
 					SetPhySecLockDelayStartCycNum(devId, 0);  /*清物理区段延时锁闭周期号*/
@@ -4140,105 +4154,109 @@ UINT8 KeepOpenRouteSignalProc(const UINT16 routeId)
 */
 void RouteZongQuXiaoProc(const UINT16 routeId)
 {
-	UINT8 routeState = 0u;         /*进路状态*/
-	UINT16 startSignalId = 0u;
+	UINT8 routeState = 0U;         /*进路状态*/
+	UINT16 startSignalId = 0U;
 	UINT8 sigCurColor = SIGNAL_SHOWCOLOUR_INVALID;
-	UINT8 routeDelayUnlockflag = 0u; /* 进路延时解锁属性*/
-	UINT8 checkRouteCancel = 0u;
+	UINT8 routeDelayUnlockflag = 0U; /* 进路延时解锁属性*/
+	UINT8 checkRouteCancel = 0U;
 	UINT8 cSignalInHumidRailFlag = PHYSEC_IN_HUMID_RAIL_NO;  /*信号机湿轨标志*/
-
+	UINT8 chCiType = 0U;
+	UINT8 chRouteVirCiId = 0U;
+	UINT8 chOpenClose = 0U;
 	/*获取进路动态字段*/
 	routeState = GetRouteState(routeId);  /*获取进路状态*/
 	startSignalId = GetRouteStartSignalId(routeId);
 	sigCurColor = GetSignalCurColor(startSignalId);
-
-	if (GetSignalOpenCloseState(sigCurColor) == SIGNAL_OPEN)
+	
+	chOpenClose = GetSignalOpenCloseState(sigCurColor);
+	if (SIGNAL_OPEN == chOpenClose)
 	{
 		/*信号未关闭*/
-
 		(void)DriveSignalClose(startSignalId);  /*驱动信号关闭*/
-
-		return;
 	}
 	else
 	{
 		/*信号已关闭*/
-
 		SetRouteZongQuXiaoFlag(routeId, ROUTE_ZONGQUXIAO_SET_NO);  /*取消进路总取消标志*/
-	}
 
-	cSignalInHumidRailFlag = GetSignalInHumidRailFlag(startSignalId);
-	if (PHYSEC_IN_HUMID_RAIL_NO == cSignalInHumidRailFlag)
-	{
-		/*总取消进路处理*/
-		if ((ROUTE_STATE_XUANPAI == routeState) || (ROUTE_STATE_FIRST_XUANPAI == routeState))
+		cSignalInHumidRailFlag = GetSignalInHumidRailFlag(startSignalId);
+		chRouteVirCiId = GetRouteBelongVirCiId(routeId);  /*获取进路虚拟联锁ID*/
+		chCiType = GetLocalVirCiType(chRouteVirCiId);     /*获取联锁类型*/
+		/*信号机湿轨标志无效或者进路属于车辆段，则执行总取消*/
+		if ((PHYSEC_IN_HUMID_RAIL_NO == cSignalInHumidRailFlag) || (CI_TYPE_CLD == chCiType))
 		{
-			/*进路选排或初选*/
-
-			/*取消进路选排*/
-			SetRouteStateManage(routeId, ROUTE_STATE_IDLE);  /*-->设置进路空闲*/
-
-		}
-		/*进路初锁||进路初锁异常||进路预先锁闭*/
-		else if ((ROUTE_STATE_FIRST_LOCK == routeState) ||
-			(ROUTE_STATE_FIRST_LOCKERR == routeState) ||
-			(ROUTE_STATE_YUXIAN_LOCK == routeState))
-		{
-			/* 检查取消检查条件*/
-			checkRouteCancel = RouteCancelLogicProcess(routeId);
-			/* 获取进路延时解锁属性*/
-			routeDelayUnlockflag = GetRouteNeedDelayUnlock(routeId);
-			if (CI_SUCCESS == checkRouteCancel)
+			/*总取消进路处理*/
+			if ((ROUTE_STATE_XUANPAI == routeState) || (ROUTE_STATE_FIRST_XUANPAI == routeState))
 			{
-				/*需要延时解锁*/
-				if (ROUTE_NEED_DELAY_UNLOCK == routeDelayUnlockflag)
+				/*进路选排或初选*/
+
+				/*取消进路选排*/
+				SetRouteStateManage(routeId, ROUTE_STATE_IDLE);  /*-->设置进路空闲*/
+
+			}
+			/*进路初锁||进路初锁异常||进路预先锁闭*/
+			else if ((ROUTE_STATE_FIRST_LOCK == routeState) ||
+				(ROUTE_STATE_FIRST_LOCKERR == routeState) ||
+				(ROUTE_STATE_YUXIAN_LOCK == routeState))
+			{
+				/* 检查取消检查条件*/
+				checkRouteCancel = RouteCancelLogicProcess(routeId);
+				/* 获取进路延时解锁属性*/
+				routeDelayUnlockflag = GetRouteNeedDelayUnlock(routeId);
+				if (CI_SUCCESS == checkRouteCancel)
 				{
-					/*设置进路延时解锁状态*/
-					SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK);
-					/*设置延时解锁*/
-					SetRouteZongQuXiaoDelayFlag(routeId, ROUTE_ZQX_DELAY_YES);
+					/*需要延时解锁*/
+					if (ROUTE_NEED_DELAY_UNLOCK == routeDelayUnlockflag)
+					{
+						/*设置进路延时解锁状态*/
+						SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK);
+						/*设置延时解锁*/
+						SetRouteZongQuXiaoDelayFlag(routeId, ROUTE_ZQX_DELAY_YES);
+					}
+					else
+					{
+						/*-->设置进路空闲*/
+						SetRouteStateManage(routeId, ROUTE_STATE_IDLE);
+					}
 				}
 				else
 				{
-					/*-->设置进路空闲*/
-					SetRouteStateManage(routeId, ROUTE_STATE_IDLE);
+					/*进路不能取消*/
 				}
 			}
+			else if ((ROUTE_STATE_NEAR_LOCK == routeState) ||
+				(ROUTE_STATE_NEAR_LOCKERR == routeState))
+			{
+				/*反馈接近锁闭*/
+				SetCiSendCmdBackInfoData(CI_BACK_ROUTE_NEAR_LOCK_YES, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);
+			}
+			else if ((ROUTE_STATE_LEAD_LOCK == routeState) ||
+				(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
+				(ROUTE_STATE_LEAD_FIRST_XUANPAI == routeState) ||
+				(ROUTE_STATE_LEAD_OPEN == routeState) ||
+				(ROUTE_STATE_LEAD_XUANPAI == routeState))
+			{
+				/*引导进路总取消新增报警信息*/
+				SetCiSendCmdBackInfoData(CI_BACK_LEAD_ROUTE_CANCEL, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);
+			}
+			else if (ROUTE_STATE_IDLE == routeState)
+			{
+				CancelLongRouteXuanPai(routeId);  /*修复缺陷YF0083-2370：总取消时若进路空闲，则取消长调进路选排*/
+			}
 			else
 			{
-				/*进路不能取消*/
+				/*反馈未完整锁闭*/
+				SetCiSendCmdBackInfoData(CI_BACK_ROUTE_LOCK_NOTALL, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);
 			}
 		}
-		else if ((ROUTE_STATE_NEAR_LOCK == routeState) ||
-			(ROUTE_STATE_NEAR_LOCKERR == routeState))
-		{
-			/*反馈接近锁闭*/
-			SetCiSendCmdBackInfoData(CI_BACK_ROUTE_NEAR_LOCK_YES, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);
-		}
-		else if ((ROUTE_STATE_LEAD_LOCK == routeState) ||
-			(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
-			(ROUTE_STATE_LEAD_FIRST_XUANPAI == routeState) ||
-			(ROUTE_STATE_LEAD_OPEN == routeState) ||
-			(ROUTE_STATE_LEAD_XUANPAI == routeState))
-		{
-			/*引导进路总取消新增报警信息*/
-			SetCiSendCmdBackInfoData(CI_BACK_LEAD_ROUTE_CANCEL, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);
-		}
-		else if (ROUTE_STATE_IDLE == routeState)
-		{
-			CancelLongRouteXuanPai(routeId);  /*修复缺陷YF0083-2370：总取消时若进路空闲，则取消长调进路选排*/
-		}
 		else
 		{
-			/*反馈未完整锁闭*/
-			SetCiSendCmdBackInfoData(CI_BACK_ROUTE_LOCK_NOTALL, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);
+			/*进路始端信号机处于湿轨范围，不解锁进路*/
+			debug_infor_printf((const)"\n SignalInHumidRailFlag Valid,Not RouteZongQuXiaoProc \n");
 		}
 	}
-	else
-	{
-		/*进路始端信号机处于湿轨范围，不解锁进路*/
-		debug_infor_printf((const)"\n SignalInHumidRailFlag Valid,Not RouteZongQuXiaoProc \n");
-	}
+
+	
 }
 
 /*
@@ -4515,7 +4533,10 @@ void RouteZongRenJieProc(const UINT16 routeId)
 		if (CI_SUCCESS == checkResultSecAndQXZC)
 		{   /*所有区段空闲或最后一个区段占用*/
 
-			SetRouteStateManage(routeId, ROUTE_STATE_IDLE);  /*-->设置进路空闲*/
+			/*总人解办理*/
+			SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK);  /*-->设置进路延时解锁*/
+			/*延时后全部解锁*/
+			SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/
 		}
 		else if ((ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta) && (CI_ERROR_QXZC != checkResultSecAndQXZC))
 		{/*当总人解引导进路时，有取消照查继电器且未吸起则不能解锁引导进路*/
@@ -4692,38 +4713,45 @@ UINT8 UnlockRouteOverlapProc(const UINT16 routeId)
 		}
 		else if (CI_ERROR == ret)
 		{
-			/*错误，什么也不做*/
+			/*不满足解锁条件，清除保护区段解锁申请*/
+
+			if (RC_WORK_MODE_TIOC == cRcWorkMode)
+			{
+				SetOverlapUnlockApplyTrainId(unlockOverlapId, 0U);
+				SetReqIvocUnlockStartCycNum(unlockOverlapId, 0U);
+			}
+			else if (RC_WORK_MODE_CI == cRcWorkMode)
+			{
+				/*停止发解锁申请*/
+				SetOverlapUnlockApplyFlag(unlockOverlapId, UNLOCK_OVERLAP_APPLY_NO);
+			}
+			else
+			{
+				; /* 无处理 */
+			}
 		}
 		else
 		{
-			/*什么也不做*/
+			; /*什么也不做*/
 		}
 
-		wTrainId = GetOverlapUnlockApplyTrainId(unlockOverlapId);
-
 		if (SECTION_OCCUPY_NO == devCurMergeState)/*当前空闲*/
 		{
 			if (RC_WORK_MODE_TIOC == cRcWorkMode)
 			{
-				if (0u != wTrainId)
-				{
 					/*停止发解锁申请*/
 					SetOverlapUnlockApplyTrainId(unlockOverlapId, 0U);
 					SetReqIvocUnlockStartCycNum(unlockOverlapId, 0U);
 					/*停止倒计时*/
 					SetSecUtOrCtOccuStartCycNum(devId, 0u);
-				}
 			}
 			else if (RC_WORK_MODE_CI == cRcWorkMode)
 			{
-				/* TODO */
-				if (UNLOCK_OVERLAP_APPLY_YES == GetOverlapUnlockApplyFlag(unlockOverlapId))/*当前正给ZC发送解锁申请*/
-				{
-					/*停止发解锁申请*/
-					SetOverlapUnlockApplyFlag(unlockOverlapId, UNLOCK_OVERLAP_APPLY_NO);
-					/*停止倒计时*/
-					SetSecUtOrCtOccuStartCycNum(devId, 0u);
-				}
+
+				/*停止发解锁申请*/
+				SetOverlapUnlockApplyFlag(unlockOverlapId, UNLOCK_OVERLAP_APPLY_NO);
+				/*停止倒计时*/
+				SetSecUtOrCtOccuStartCycNum(devId, 0u);
 			}
 			else
 			{
@@ -4735,21 +4763,14 @@ UINT8 UnlockRouteOverlapProc(const UINT16 routeId)
 		{
 			if (RC_WORK_MODE_TIOC == cRcWorkMode)
 			{
-				if (0u != wTrainId)
-				{
-					/*停止发解锁申请*/
-					SetOverlapUnlockApplyTrainId(unlockOverlapId, 0u);
-					SetReqIvocUnlockStartCycNum(unlockOverlapId, 0U);
-				}
+				/*停止发解锁申请*/
+				SetOverlapUnlockApplyTrainId(unlockOverlapId, 0u);
+				SetReqIvocUnlockStartCycNum(unlockOverlapId, 0U);
 			}
 			else if (RC_WORK_MODE_CI == cRcWorkMode)
 			{
-				/* TODO */
-				if (UNLOCK_OVERLAP_APPLY_YES == GetOverlapUnlockApplyFlag(unlockOverlapId))/*当前正给ZC发送解锁申请*/
-				{
-					/*停止发解锁申请*/
-					SetOverlapUnlockApplyFlag(unlockOverlapId, UNLOCK_OVERLAP_APPLY_NO);
-				}
+				/*停止发解锁申请*/
+				SetOverlapUnlockApplyFlag(unlockOverlapId, UNLOCK_OVERLAP_APPLY_NO);
 			}
 			else
 			{
@@ -4758,7 +4779,7 @@ UINT8 UnlockRouteOverlapProc(const UINT16 routeId)
 		}
 		else
 		{
-			/*什么也不做*/
+			; /*什么也不做*/
 		}
 	}
 	return CI_ERROR;
@@ -4904,6 +4925,7 @@ UINT8 RouteLTrainEnter(const UINT16 routeId)
 	UINT8 chRCMode = 0u;
 	UINT8 cRoutePreLevel = 0U;  /*进路之前级别*/
 	UINT8 chLocalCiType = 0U;/*联锁类型*/
+	UINT8 chRouteBelongVirCiId = 0U;
 
 	/* 联锁逻辑检查 */
 
@@ -5048,7 +5070,8 @@ UINT8 RouteLTrainEnter(const UINT16 routeId)
 				chDevState = GetPhySecCurMergeState(inPhySecId);
 				if (SECTION_OCCUPY_YES == chDevState)
 				{ /*内方区段占用，进路为CBTC非车辆段时，考虑为列车高速跨压,只需要考虑内方第一区段的占压，不用管外方*/
-					chLocalCiType = GetLocalCiType();
+					chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+					chLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 					if ((ROUTE_LEVEL_CBTC == routeLevel) && (CI_TYPE_CLD != chLocalCiType))
 					{
 						chRetVal = CI_SUCCESS;
@@ -8368,7 +8391,14 @@ void SetSectionResetLogicManage(const UINT16 phySecId, const UINT8 resetType)
 			}
 			else
 			{
-				retValid = GetZFWValidByPhySecId(phySecId); /*获取物理区段计轴总复位继电器状态有效性*/
+				if (PHYSICAL_SECTION_PRE_RESET_YES != resetType)
+				{
+					retValid = GetZFWValidByPhySecId(phySecId); /*计轴复位：检查物理区段计轴总复位继电器状态有效性*/
+				}
+				else
+				{
+					retValid = CI_SUCCESS;/*计轴预复位不检查总复位继电器*/
+				}
 				if (CI_SUCCESS == retValid) /*有效，执行计轴复位功能*/
 				{
 					dwResetStartCycNum = GetPhySecResetStartCycNum(phySecId);
@@ -9467,27 +9497,10 @@ void CiTrainTestLogicManage(void)
 	UINT16 wCollAgreeTryTrainRelayId = 0U;/*试车线采集同意试车继电器ID*/
 	UINT8 chRelayCollState = 0U;/*采集继电器状态*/
 	UINT8 ii = 0U;
-	UINT8 flag = 0U;
-	UINT8 chCldAndScxMergeFlag = GetCldAndScxMergeFlag();
-	UINT8 localCiType = GetLocalCiType();
-
-	if (CI_TYPE_SCX == localCiType)
-	{
-		flag = 1U;
-	}
-	else if (CI_TYPE_CLD == localCiType)
-	{
-		if (CLD_SCX_MERGE_ON == chCldAndScxMergeFlag)
-		{/*是车辆段，且车辆段与试车线合设*/
-			flag = 1U;
-		}
-	}
-	else
-	{
-		/*无处理*/
-	}
-
-	if (1U == flag)
+	UINT8 flag = CI_ERROR;;
+	
+	flag = GetLocalCiIsScx();
+	if (CI_SUCCESS == flag)
 	{
 		for (; ii < NONROUTE_ID_NUM_MAX; ii++)
 		{
@@ -11117,6 +11130,7 @@ void UnlockSwitchLogicManage(void)
 	UINT8 unlockFlag = 0U;/*解锁标志*/
 	UINT8 funcSwitch = 0U;
 	UINT8 chPhySecLogLockState = 0U;/*物理区段逻辑锁闭状态*/
+	UINT8 chPhySecJumpLockState = 0U;
 
 	localCiId = GetSystemParaLocalCiId();				/*获取本机联锁ID*/
 	funcSwitch = GetCiFunctionSwitchConfig(FUNC_ROUTE_DRV_SWITCH_EARLY);
@@ -11147,10 +11161,11 @@ void UnlockSwitchLogicManage(void)
 					phyLockStatus = GetPhySecLockState(hostPhyId);/*获取物理区段锁闭状态*/
 					chFuncRet1 = GetSwitchLogSecLockState(hostSwitchId, &wDevId, &chDevState);
 					chPhySecLogLockState = PhySecLogLockStateCheck(hostPhyId);
+					chPhySecJumpLockState = GetPhySecJumpLockState(hostPhyId);
 
 					if ((PHYSICAL_SECTION_LOCK_NO == phyLockStatus) && (CI_SUCCESS == chFuncRet1)
-						&& (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState))
-					{/*区段锁闭状态为未锁闭(物理区段未被进路锁，逻辑区段未被进路锁，物理区段未被逻辑进路锁)*/
+						&& (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState)&&(PHYSICAL_SECTION_JUMP_LOCK_NO == chPhySecJumpLockState))
+					{/*区段锁闭状态为未锁闭(物理区段未被进路锁，逻辑区段未被进路锁，物理区段未被逻辑进路锁,未被跳跃锁闭)*/
 						unlockFlag = 1u;
 					}
 					else
@@ -11413,6 +11428,9 @@ void CheckLogSecJumpLockManage(void)
 	UINT8 logJumpLockState = LOGIC_SECTION_JUMP_LOCK_NO;
 	UINT8 localCi = 0u;/*本联锁*/
 	UINT16 logJumpLockTrainId = 0u;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
+	UINT8 retVal = CI_ERROR;
 
 
 	localCi = GetSystemParaLocalCiId();
@@ -11432,8 +11450,19 @@ void CheckLogSecJumpLockManage(void)
 					checkResult = CheckLogJumpLockApply(logicSecId);
 					if (CI_SUCCESS == checkResult)
 					{
-						/** 检查条件满足，设置跳跃锁闭允许标志为允许 */
-						SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+						devId = 0u;
+						devState = 0u;
+						retVal = LogicSecRltvPrtctSwLockCheck(logicSecId, &devId, &devState);
+						if (CI_SUCCESS == retVal)
+						{
+							/** 检查条件满足，设置跳跃锁闭允许标志为允许 */
+							SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+						}
+						else
+						{
+							/** 检查条件不满足，设置跳跃锁闭允许标志为禁止 */
+							SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
+						}
 					}
 					else
 					{
@@ -11488,7 +11517,6 @@ void AxisSecJumpLockLogicManage(void)
 	UINT8 applyFlag = 0u;/*申请标志*/
 	UINT8 cancelApplyFlag = 0u;/*取消申请标志*/
 	UINT16 phyId = 0u;/*物理区段ID*/
-	UINT8 phyUseState = 0u;/*物理区段征用状态*/
 	UINT8 jumpLockState = 0u;/*跳跃锁闭状态*/
 	UINT8 secBelongCi = 0u;/*区段所属联锁*/
 	UINT8 localCi = 0u;/*本联锁*/
@@ -11501,6 +11529,7 @@ void AxisSecJumpLockLogicManage(void)
 	UINT32 applyCycle = 0u;/*跳跃锁闭申请周期*/
 	UINT32 curCycle = 0u;/*当前周期号*/
 	UINT8 chPhySecJmpState = 0U;
+	UINT8 chJumpPhySectionUseCheck = 0U;
 
 	localCi = GetSystemParaLocalCiId();
 	axisSectionDataSum = GetTotalAxisCurNum();
@@ -11516,7 +11545,6 @@ void AxisSecJumpLockLogicManage(void)
 		jumpLockState = GetAxisJumpLockState(axisSectionId);/*获取跳跃锁闭状态*/
 
 		phyId = GetAxisSecRelativePhySecId(axisSectionId);/*获取相关物理区段ID*/
-		phyUseState = GetPhySecUseState(phyId);/*获取物理区段征用状态*/
 
 		secBelongCi = GetPhySecBelongCiId(phyId);
 
@@ -11554,10 +11582,12 @@ void AxisSecJumpLockLogicManage(void)
 					(AXSEC_CANCEL_JUMPLOCK_APPLY_NO == cancelApplyFlag))
 				{/*有跳跃锁闭申请*/
 
-					if (PHYSICAL_SECTION_USING_NO == phyUseState)
+					chJumpPhySectionUseCheck = JumpPhySectionUseCheck(axisSectionId);
+					if (CI_SUCCESS == chJumpPhySectionUseCheck)
 					{/*未征用*/
 						/*设置征用*/
 						SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_YES, 0);
+						SetJumpPhySectionPortectSecUse(axisSectionId, PHYSICAL_SECTION_USING_YES);/*设置物理区段关联防护道岔的区段征用*/
 						/*转为选排*/
 						SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_XUANPAI);
 					}
@@ -11574,36 +11604,7 @@ void AxisSecJumpLockLogicManage(void)
 
 			case AXIS_SECTION_JUMPLOCK_STATE_LOCK:
 			{/*计轴区段跳跃锁闭处理*/
-				/*持续进行锁闭检查，检查通过，设置物理区段跳跃锁闭；检查不通过，设置未跳跃锁闭*/
-				rtVal = LockAxisSecProc(axisSectionId);/*跳跃锁闭联锁条件检查*/
-				if (CI_SUCCESS == rtVal)
-				{
-					if ((AXIS_SECTION_JUMPLOCK_APPLY_YES == applyFlag) &&
-						(AXSEC_CANCEL_JUMPLOCK_APPLY_NO == cancelApplyFlag) &&
-						(curCycle == applyCycle))
-					{/*本周期有跳跃锁闭申请，才设置物理区段跳跃锁闭*/
-						SetPhySecJumpLockState(phyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
-						SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
-						SetAxisInCludeLogJumpLockState(axisSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
-					}
-					else
-					{
-						chPhySecJmpState = GetPhySecJumpLockState(phyId);
-						if ((PHYSICAL_SECTION_JUMP_LOCK_YES == chPhySecJmpState) && (0U < applyCycle))
-						{
-							SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
-						}
-					}
-				}
-				else
-				{/*之前处于锁闭，当持续检查锁闭条件不满足时，内部维持跳跃锁闭，给ZC发不锁闭*/
-					SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
-				}
-				if ((AXIS_SECTION_JUMPLOCK_APPLY_NO == applyFlag) &&
-					(AXSEC_CANCEL_JUMPLOCK_APPLY_YES == cancelApplyFlag))
-				{/*有取消跳跃申请*/
-					SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
-				}
+				AxisJumpLockStateManage(axisSectionId);
 			}
 			break;
 			default:
@@ -11641,16 +11642,22 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	{
 		rtVal = CI_SUCCESS;
 	}
+
+	if (CI_SUCCESS == rtVal)
+	{
+		rtVal = JumpPhySecAllUseCheck(axisSecId);/*所有区段已设置上征用（不考虑相邻联锁，若防护道岔在相邻联锁则不跳跃锁闭）*/
+	}
+
 	if (CI_SUCCESS == rtVal)
 	{
 		rtVal = LockAxisSecProc(axisSecId);/*跳跃锁闭联锁条件检查*/
 	}
-	axisSecSwitDrvOvtmFlag = ChekJumpLockSwitDrivOvtmStat(axisSecId);/*检查计轴区段内道岔是否驱动超时*/
+	axisSecSwitDrvOvtmFlag = ChekJumpLockSwitDrivOvtmStat(axisSecId);/*检查计轴区段关联道岔是否驱动超时*/
 	if (CI_SUCCESS == rtVal)
 	{/*检查成功*/
-		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_LOCK);
-		/*设置未征用*/
-		SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+
+		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_LOCK);/*状态机流程转*/
+
 	}
 	else if ((RETURN_LOCK_ERR_SWITPOS == rtVal) && (CI_SUCCESS == axisSecSwitDrvOvtmFlag))
 	{/*位置错误可驱动且驱动道岔没有超时*/
@@ -11661,6 +11668,8 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 		{
 			/*设置未征用*/
 			SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+			SetJumpPhySectionPortectSecUse(axisSecId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+
 			/*设置计轴区段跳跃状态空闲*/
 			SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
 		}
@@ -11669,6 +11678,8 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	{/*其它*/
 		/*设置未征用*/
 		SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+		SetJumpPhySectionPortectSecUse(axisSecId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+
 		/*设置计轴区段跳跃状态空闲*/
 		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
 	}
@@ -12393,8 +12404,11 @@ void RoutePhyOrLogSecAutoUnlocManage(const UINT16 routeId)
 	UINT8 chPhyIncSwitchSum = 0U;
 	UINT16* pPhySecSwitchId = NULL;
 	UINT8 localCiType = 0U;/*联锁类型*/
+	UINT8 chRouteBelongVirCiId = 0U;
 
-	localCiType = GetLocalCiType();
+
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	localCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 	
 
 	/*获取进路锁闭的第一逻辑区段占用状态*/
@@ -12562,7 +12576,6 @@ void LogicSecResManage(void)
 	startLockState = GetStartLockFlag();        /*获取上电解锁标志*/
 	startFlockFlag = GetStartFLockFlag();       /*获取上电解封标志*/
 
-
 	if (0u == localCiId)
 	{
 		rtVal = CI_ERROR;
@@ -13730,6 +13743,8 @@ static void TrainTransitmitStatJumpLockProcess(const UINT16 logSectionId, const
 						/** 清除区段跳跃锁闭延时解锁起始周期号和延时解锁设置标志*/
 						SetLogSecJumpDelayUnlocStartCyc(logSectionId, 0u);
 						SetLogSecJumpDelayUnlockFlag(logSectionId, LOGIC_JUMPUNLOCK_DELAY_SET_NO);
+						/*取消防护锁闭*/
+						SetLogSecRelProSwitchLockSta(logSectionId, SWITCH_LOCK_PROTECT_CANCEL);
 					}
 					else
 					{
@@ -14434,6 +14449,8 @@ void PhySecJumpLockLogicManage(void)
 	UINT32 dwApplyCycle = 0U;/*跳跃锁闭申请周期号*/
 	UINT8 chPhySecFLockType = 0U;/*物理区段封锁类型*/
 	UINT8 chPhySecJempState = 0U;/*物理区段跳跃锁闭状态*/
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
 
 	wAxisSectionDataSum = GetTotalAxisCurNum();
 
@@ -14456,9 +14473,23 @@ void PhySecJumpLockLogicManage(void)
 					chPhySecFLockType = GetPhySecFLockType(wPhyId); /*获取物理区段封锁类型*/
 					if ((PHY_SEC_FLOCK_TYPE_NONE == chPhySecFLockType))
 					{
+						ClearAxisSeceSwitchDanCaoPos(wAxisSectionId);/*清除单操*/
 						SetPhySecJumpLockState(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
-						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
-						SetAxisInCludeLogJumpLockState(wAxisSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+						SetAxisRelProSwitchLockSta(wAxisSectionId, SWITCH_LOCK_PROTECT_SET);
+
+						chTempcheck = AxisRelatedProSwitchLockCheck(wAxisSectionId, &devId, &devState);
+						if (CI_SUCCESS == chTempcheck)
+						{/*检查计轴区段锁闭状态*/
+							SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+							SetAxisInCludeLogJumpLockState(wAxisSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+						}
+						else
+						{
+							/*无执行*/
+						}
+
+					
+
 					}
 					else
 					{
@@ -14480,8 +14511,17 @@ void PhySecJumpLockLogicManage(void)
 				}
 				else
 				{  /*联锁内部锁闭，当持续检查锁闭条件满足时，再次给ZC发锁闭*/
-
-					SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+					devId = 0u;
+					devState = 0u;
+					chTempcheck = AxisRelatedProSwitchLockCheck(wAxisSectionId, &devId, &devState);
+					if (CI_SUCCESS == chTempcheck)
+					{
+						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+					}
+					else
+					{
+						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+					}
 				}
 			}
 		}
@@ -14490,6 +14530,7 @@ void PhySecJumpLockLogicManage(void)
 		{/*有取消跳跃申请*/
 			SetPhySecJumpLockState(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
 			SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+			SetAxisRelProSwitchLockSta(wAxisSectionId, SWITCH_LOCK_PROTECT_CANCEL);/*取消防护锁闭*/
 		}
 	}
 }
@@ -15607,7 +15648,7 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 	if ((LOG_SECTION_LOCK_NORMAL == chLogicLockState)
 		|| (LOG_SECTION_LOCK_DELAY == chLogicLockState))
 	{
-		chRouteTrainEnterFlag = dsuTrainMinHeadCrossSignal(wTrainId, wLogicRLockRouteId);
+		chRouteTrainEnterFlag = dsuTrainMinHeadCrossSignal(wTrainId, wLogicRLockRouteId, CI_SUCCESS);
 
 		chTrainMaxHeadCross = dsuTrainCrossSignal(wTrainId, wLogicRLockRouteId);/*判断列车大前是否驶入进路*/
 
@@ -16802,4 +16843,140 @@ void lockSwitchLogicManage(void)
 			}	
 		}
 	}
+}
+/*
+* 功能描述： 计轴区段跳跃锁闭状态机管理
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+* 返回值  ： void
+* add by mpt 20260407
+*/
+void AxisJumpLockStateManage(const UINT16 axisSectionId)
+{
+	UINT8 rtVal = 0U;
+	UINT8 applyFlag = 0U;
+	UINT32 applyCycle = 0U;
+	UINT8 cancelApplyFlag = 0U;
+	UINT16 phyId = 0U;
+	UINT32 curCycle = 0U;
+	UINT8 chPhySecJmpState = 0U;
+
+
+	applyFlag = GetAxisSecJumpLockApplyFlag(axisSectionId);
+	applyCycle = GetAxisSecJumpLockApplyCylce(axisSectionId);
+	cancelApplyFlag = GetAxisSecJLockCancelApplyFlag(axisSectionId);
+
+	phyId = GetAxisSecRelativePhySecId(axisSectionId);/*获取相关物理区段ID*/
+	curCycle = Get2oo2CurCycleNum();
+
+
+	/*持续进行锁闭检查，检查通过，设置物理区段跳跃锁闭；检查不通过，设置未跳跃锁闭*/
+	rtVal = LockAxisSecProc(axisSectionId);/*跳跃锁闭联锁条件检查*/
+	if (CI_SUCCESS == rtVal)
+	{
+		if ((AXIS_SECTION_JUMPLOCK_APPLY_YES == applyFlag) &&
+			(AXSEC_CANCEL_JUMPLOCK_APPLY_NO == cancelApplyFlag) &&
+			(curCycle == applyCycle))
+		{/*本周期有跳跃锁闭申请，才设置物理区段跳跃锁闭*/
+			chPhySecJmpState = GetPhySecJumpLockState(phyId);
+			if (PHYSICAL_SECTION_JUMP_LOCK_NO == chPhySecJmpState)
+			{/*无跳跃锁闭且当前无征用*/
+				ClearAxisSeceSwitchDanCaoPos(axisSectionId);/*清除单操*/
+
+				SetPhySecJumpLockState(phyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+				SetAxisRelProSwitchLockSta(axisSectionId, SWITCH_LOCK_PROTECT_SET);
+				SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+				SetAxisInCludeLogJumpLockState(axisSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+
+				/*设置未征用*/
+				SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+				SetJumpPhySectionPortectSecUse(axisSectionId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+			}
+			else
+			{
+				/*不执行*/
+			}
+		}
+		else
+		{
+			chPhySecJmpState = GetPhySecJumpLockState(phyId);
+			if ((PHYSICAL_SECTION_JUMP_LOCK_YES == chPhySecJmpState) && (0U < applyCycle))
+			{
+				SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+			}
+			else if (PHYSICAL_SECTION_JUMP_LOCK_NO == chPhySecJmpState)
+			{/*当前未跳跃锁闭*/
+				SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_NO);/*给ZC不锁闭*/
+
+				if (AXIS_SECTION_JUMPLOCK_APPLY_NO == applyFlag)
+				{/*当前未申请*/
+					/*设置未征用*/
+					SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+					SetJumpPhySectionPortectSecUse(axisSectionId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+
+					SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);/*设置计轴区段跳跃锁闭状态为空闲*/
+				}
+				else
+				{
+					/*有申请则继续锁闭*/
+				}
+			}
+			else
+			{/*维持之前*/
+			}
+		}
+	}
+	else
+	{/*之前处于锁闭，当持续检查锁闭条件不满足时，内部维持跳跃锁闭，给ZC发不锁闭*/
+		SetPhySecJumpLockStateToZC(phyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+
+		chPhySecJmpState = GetPhySecJumpLockState(phyId);
+		if (PHYSICAL_SECTION_JUMP_LOCK_NO == chPhySecJmpState)
+		{/*未锁闭就一定有征用*/
+			/*设置未征用*/
+			SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+			SetJumpPhySectionPortectSecUse(axisSectionId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+			SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);/*设置计轴区段跳跃锁闭状态为空闲*/
+		}
+
+	}
+	if ((AXIS_SECTION_JUMPLOCK_APPLY_NO == applyFlag) &&
+		(AXSEC_CANCEL_JUMPLOCK_APPLY_YES == cancelApplyFlag))
+	{/*有取消跳跃申请*/
+		SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
+		SetAxisRelProSwitchLockSta(axisSectionId, SWITCH_LOCK_PROTECT_CANCEL);
+	}
+	
+}
+
+/*
+* 功能描述： 试车状态管理逻辑处理中获取本联锁是否具备试车功能（拆分复杂度使用）
+*参数说明：无
+* 返回值  ：CI_SUCCESS 是试车线（含合设） CI_ERROR
+*/
+UINT8 GetLocalCiIsScx(void)
+{
+	UINT8 chRtn = CI_ERROR;
+	UINT8 chCldAndScxMergeFlag = GetCldAndScxMergeFlag();
+	UINT8 localCiType = GetLocalCiType();
+
+	if (CI_TYPE_SCX == localCiType)
+	{
+		chRtn = CI_SUCCESS;
+	}
+	else if (CI_TYPE_CLD == localCiType)
+	{
+		if (CLD_SCX_MERGE_ON == chCldAndScxMergeFlag)
+		{/*是车辆段，且车辆段与试车线合设*/
+			chRtn = CI_SUCCESS;
+		}
+		else
+		{
+			;/*返回CI_ERROR;*/
+		}
+	}
+	else
+	{
+		;/*返回CI_ERROR;*/
+	}
+	return chRtn;
 }

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

@@ -1161,6 +1161,20 @@ void SetCouplinkRouteLogicManage(const UINT16 wRouteId);
 * 返回值  ：
 */
 void lockSwitchLogicManage(void);
+/*
+* 功能描述： 计轴区段跳跃锁闭状态机管理
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+* 返回值  ： void
+* add by mpt 20260407
+*/
+void AxisJumpLockStateManage(const UINT16 axisSectionId);
+
+/*
+* 功能描述： 试车状态管理逻辑处理中获取本联锁是否具备试车功能（拆分复杂度使用）
+*参数说明：无
+* 返回值  ：CI_SUCCESS 是试车线（含合设） CI_ERROR
+*/
+UINT8 GetLocalCiIsScx(void);
 
 #ifdef __cplusplus
 }

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

@@ -3161,14 +3161,14 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
 					{
 						if (psdIdBuf[j] == tmpOtherCiDevInfo->DevId)
 						{
-							cPsdExceptOpenState = GePsdExceptOpenState(tmpOtherCiDevInfo->DevId);
-							if (PSD_EXCEPT_OPEN_NO == cPsdExceptOpenState)
+							cPsdExceptOpenState = GePsdExceptState(tmpOtherCiDevInfo->DevId);
+							if (PSD_EXCEPT_NO == cPsdExceptOpenState)
 							{
-								toOpenCheckFlag = 1U;  /*PSD未异常打开，设置可自动重开*/
+								toOpenCheckFlag = 1U;  /*PSD未异常，设置可自动重开*/
 							}
 							else
 							{
-								toOpenCheckFlag = 0U;  /*存在PSD异常打开，停止遍历，设置不可自动重开*/
+								toOpenCheckFlag = 0U;  /*存在PSD异常，停止遍历，设置不可自动重开*/
 								break;
 							}
 						}
@@ -3702,6 +3702,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		else
 		{
 			/* zt 删除单轨相关代码 2022-02-15 */
+			reResult = CI_ERROR;
 		}
 
 		/*保护区段 内所有道岔【未封锁】*/
@@ -4171,12 +4172,15 @@ static UINT8 KeepCbtcRouteSectionErrCheck(const UINT16 routeId)
 	UINT8 preLogDevState = 0u;			/*之前逻辑区段占用状态*/
 	UINT8 LogSecCurCtOrUtOcc = 0U;		/*逻辑区段当前占用状态*/
 	UINT8 cLocalCiType = 0U;  /*本控区类型*/
+	UINT8 chRouteBelongVirCiId = 0U;
 
 	rcWorkMode = GetLocalRcWorkMode();
 
 	/* 联锁逻辑检查 */
 	reResult = CI_SUCCESS;
 	cLocalCiType = GetLocalCiType();
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	cLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 	if (CI_TYPE_CLD != cLocalCiType)
 	{
 		/*非车辆段，按CBTC既有逻辑处理*/
@@ -4324,10 +4328,12 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	UINT8 cLocalCiType = 0U;  /*本控区类型*/
 	UINT8 chRouteCouplinkFlag = 0U;
 	UINT8 chSigCrossState = 0U;
+	UINT8 chRouteBelongVirCiId = 0U;
 	rcWorkMode = GetLocalRcWorkMode();
 
 	/* 联锁逻辑检查 */
-	cLocalCiType = GetLocalCiType();
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	cLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 	if (CI_TYPE_CLD != cLocalCiType)
 	{
 		/*非车辆段，按CBTC既有逻辑处理*/

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

@@ -229,6 +229,7 @@ void NonRouteLogicProcess(void)
 		{ 
 			NonRouteCancelDeal(pNonRoute->NonRouteId); /*非进路取消处理*/
 		}
+
 	}
 }
 
@@ -240,22 +241,42 @@ void NonRouteLogicProcess(void)
 */
 void NonRouteXuanPaiDeal(UINT8 nonRouteId)
 {
+	UINT8 reResult = CI_ERROR;
 	NonRouteDataStruct *pNonRoute = GetNonRouteDataById(nonRouteId);
-	if (CI_SUCCESS == LockNonRouteP(nonRouteId))
+	reResult = LockNonRouteP(nonRouteId);
+	if (CI_SUCCESS == reResult)
 	{ /*锁闭成功*/
-        
-        if (CI_SUCCESS == CheckNonRouteSwitchPosRight(nonRouteId,0u,0u))
-		{ /*进路道岔位置正确*/
-			SetNonRouteStateDeal(nonRouteId,NONROUTE_STATE_LOCK); /*设置非进路为锁闭*/
+		reResult = CheckNonRouteSwitchPosRight(nonRouteId, 0U, 0U);
+        if (CI_SUCCESS == reResult)
+		{ 
+			/*进路道岔位置正确*/
+			/*侵限区段侵限条件不满足检查*/
+			reResult = NonRouteIntruSecVainCheck(nonRouteId, EFUNC_CLD_LOCK_NONROUTE, ESEND_LEVEL_ATS);
+			if (CI_SUCCESS == reResult)
+			{
+				SetNonRouteStateDeal(nonRouteId, NONROUTE_STATE_LOCK); /*设置非进路为锁闭*/
+			}
+			else
+			{
+				SetNonRouteStateDeal(nonRouteId, NONROUTE_STATE_IDLE); /*设置非进路为空闲*/
+				/* NonRouteIntruSecVainCheck函数已经有故障码，不再记录*/
+			}
+	
+			
 		}
 		else
 		{ /*道岔未动作到位*/
 		
             /*非进路锁闭驱动道岔*/
-		    if (CI_ERROR == NonRouteLockDrvSwitchDeal(nonRouteId))
+			reResult = NonRouteLockDrvSwitchDeal(nonRouteId);
+		    if (CI_SUCCESS == reResult)
 		    {
-                SetNonRouteStateDeal(nonRouteId,NONROUTE_STATE_IDLE); /*设置非进路为空闲*/
+				/*继续驱动道岔*/
 		    }
+			else
+			{
+				SetNonRouteStateDeal(nonRouteId, NONROUTE_STATE_IDLE); /*设置非进路为空闲*/
+			}
 
 		}
     }
@@ -6026,6 +6047,8 @@ void DTrainReturnUnlockP(void)
 	UINT16 routeId = 0u;	         /*进路ID*/
 	UINT8 belongCiId = 0u;        /*进路所属联锁ID*/
 	UINT16 ii = 0u;               /*循环索引*/
+	UINT8 belongVirCIid = 0U;
+	UINT8 chLocalVirCiType = 0U;
 	
 	
 	routeCurSum = GetRouteCurSum();		        /*获取进路总数*/
@@ -6047,9 +6070,13 @@ void DTrainReturnUnlockP(void)
 		{
 			continue;
 		}
-
-		/*调车中途折返进路完整锁闭处理*/
-        DTrainReturnUnlockRouteAllLockP(routeId);
+		belongVirCIid = GetRouteBelongVirCiId(routeId);
+		chLocalVirCiType = GetLocalVirCiType(belongVirCIid);
+		if (CI_TYPE_CLD == chLocalVirCiType)
+		{
+			/*调车中途折返进路完整锁闭处理*/
+			DTrainReturnUnlockRouteAllLockP(routeId);
+		}
 	}
 
 	/*处理调车中途折返*/
@@ -6068,9 +6095,13 @@ void DTrainReturnUnlockP(void)
 		{
 			continue;
 		}
-
-		/*调车中途折返进路部分锁闭处理*/
-        DTrainRtnUnlockRoutePartLockP(routeId);
+		belongVirCIid = GetRouteBelongVirCiId(routeId);
+		chLocalVirCiType = GetLocalVirCiType(belongVirCIid);
+		if (CI_TYPE_CLD == chLocalVirCiType)
+		{
+			/*调车中途折返进路部分锁闭处理*/
+			DTrainRtnUnlockRoutePartLockP(routeId);
+		}
 	}
 }
 
@@ -6089,6 +6120,11 @@ UINT16 GetReturnId(const UINT16	routeId)
 	UINT8 preRouteState = 0u;	/* 之前进路状态 */
 	UINT16 ii = 0u;
 	UINT8 toGo = CI_SUCCESS;
+	UINT8 chRouteState = 0U;
+	UINT8 chRoutePhysicalType = 0U;
+	UINT8 chAllLockSecNoOccupyCheck = 0U;
+	UINT8 chTrainEnterRouteFlag = 0U;
+
 	routeState = GetRouteState(routeId); /*获取进路状态*/
 	preRouteState = GetRoutePreState(routeId);/*获取进路前一状态*/
 
@@ -6098,7 +6134,8 @@ UINT16 GetReturnId(const UINT16	routeId)
 		toGo = CI_ERROR;
 	}
 
-	if ((CI_ERROR == RouteAllLockSecNoOccupyCheck(routeId)) && (CI_SUCCESS == toGo))
+	chAllLockSecNoOccupyCheck = RouteAllLockSecNoOccupyCheck(routeId);
+	if ((CI_ERROR == chAllLockSecNoOccupyCheck) && (CI_SUCCESS == toGo))
 	{ /*进路区段不是都空闲*/
 
 		toGo = CI_ERROR;
@@ -6119,8 +6156,10 @@ UINT16 GetReturnId(const UINT16	routeId)
 					/*获取所有满足道岔条件的进路ID*/
 					for (ii = 0u; ii < starSigRouteSum; ii++)
 					{
+						chRouteState = GetRouteState(starSigRouteBuf[ii]);
+						chRoutePhysicalType = CheckRoutePhysicalType(starSigRouteBuf[ii]);
 						/*B库改为两条进路，当8编组车占压两条进路时，此时BG2进路解锁需要检查以差值信号机为始端的进路的状态*/
-						if ((ROUTE_STATE_IDLE == GetRouteState(starSigRouteBuf[ii])) &&(CI_SUCCESS == CheckRoutePhysicalType(starSigRouteBuf[ii])))
+						if ((ROUTE_STATE_IDLE == chRouteState) &&(CI_SUCCESS == chRoutePhysicalType))
 						{    
 							/*以并置信号机为始端的进路均为空闲且进路包含的区段均为列检库区段，且并置信号机为虚拟信号机,
 							该种算法目前只限制在库线中中途折返场景(SIGNAL_VIRTUAL_YES == GetSignalVirtualAttr(returnSigId))*/
@@ -6148,7 +6187,8 @@ UINT16 GetReturnId(const UINT16	routeId)
 			/* 如果是差至，如果列车驶入过进路，同时之前状态必须为接近锁闭开放
 			* 否则不认为是同一列车跨入中途折返处理
 			*/
-			if((ROUTE_STATE_NEAR_OPEN == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == GetTrainEnterRouteFlag(routeId)))
+			chTrainEnterRouteFlag = GetTrainEnterRouteFlag(routeId);
+			if((ROUTE_STATE_NEAR_OPEN == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == chTrainEnterRouteFlag))
 			{
 				returnSigId = GetRouteChaZhiSignalId(routeId); /*获取差置信号机ID*/
 			}
@@ -6498,103 +6538,134 @@ UINT16 GetRouteBingZhiSignalId(const UINT16 routeId)
 */
 UINT16 GetRouteChaZhiSignalId(const UINT16 routeId)
 {
-	UINT16 startSigId = 0u; /*始端信号机ID*/
-	UINT16 signalSum = 0u; /*信号机总数*/
-	UINT16 signalId = 0u; /*信号机ID*/
-	UINT16 routeSecSum = 0u; /*进路区段总数*/
-	RoutePhysicalSectionStruct *pRoutePhySecStru = NULL; /*进路区段数据*/
-	UINT16 returnOutSecId = 0u; /*折返信号机外方区段ID*/
-	UINT16 returnInSecId = 0u; /*折返信号机内方区段ID*/
-    UINT16 lockBelongRouteId = 0u; /*锁闭所属进路ID*/
-    UINT16 outSecId = 0u; /*外方区段ID*/
-	UINT16 ii = 0u;
-	UINT16 tmpSigId = 0u;
-
+	UINT16 startSigId = 0U; /*始端信号机ID*/
+	UINT16 signalSum = 0U; /*信号机总数*/
+	UINT16 signalId = 0U; /*信号机ID*/
+	UINT16 routeSecSum = 0U; /*进路区段总数*/
+	RoutePhysicalSectionStruct* pRoutePhySecStru = NULL; /*进路区段数据*/
+	UINT16 returnOutSecId = 0U; /*折返信号机外方区段ID*/
+	UINT16 returnInSecId = 0U; /*折返信号机内方区段ID*/
+    UINT16 lockBelongRouteId = 0U; /*锁闭所属进路ID*/
+    UINT16 outSecId = 0U; /*外方区段ID*/
+	UINT16 ii = 0U;
+	UINT16 tmpSigId = 0U;
+	UINT8 chPhySecType = 0U;
+	UINT16 wTempPhySecId = 0U;
+	UINT16 wReturnSignal = 0U;
+	UINT16 wTempSigId = 0U;
+	UINT8 chPhyLockState = 0U;
+	UINT16 wLockRouteId = 0U;
+	UINT16 wTempSigOutPhyId = 0U;
+	UINT16 wTempSigInPhyId = 0U;
 
     startSigId = GetRouteStartSignalId(routeId); /*获取进路始端信号机ID*/
 	signalSum = GetSignalCurSum(); /*获取信号机总数*/
 
-	if (PHYSICAL_SEC_TYPE_NOSWITCH == GetPhySecType(GetSignalOutFirstPhySecId(startSigId)))
+	outSecId = GetSignalOutFirstPhySecId(startSigId);
+	chPhySecType = GetPhySecType(outSecId);
+	if (PHYSICAL_SEC_TYPE_NOSWITCH == chPhySecType)
 	{ /*无岔区段*/
 
 		for (ii = 0u; ii < signalSum; ii++)
 		{
 			signalId = GetSignalId(ii); /*获取信号机ID*/
+			wTempPhySecId = GetSignalOutFirstPhySecId(signalId);
 
-			if ((GetSignalOutFirstPhySecId(startSigId) == GetSignalOutFirstPhySecId(signalId)) &&
-				(startSigId != signalId))
+			if ((outSecId == wTempPhySecId) && (startSigId != signalId))
 			{
-				return signalId;
+				wReturnSignal =  signalId;
+				break;
+			}
+			else
+			{
+				/*不处理*/
 			}
 		}
 	}
 	else
 	{ /*有岔*/
 
-		outSecId = GetSignalOutFirstPhySecId(startSigId); /*进路始端信号机外方区段ID*/
 		lockBelongRouteId = GetPhySecRLockBelongRouteId(outSecId); /*区段锁闭所属进路ID*/
 		
 		routeSecSum = GetRoutePhysicalSectionSum(lockBelongRouteId); /*获取进路区段总数*/
 		pRoutePhySecStru = GetRouteSectionData(lockBelongRouteId); /*获取进路区段数据*/
 		
-		if ((0u == routeSecSum) || (NULL == pRoutePhySecStru))
+		if ((0U == routeSecSum) || (NULL == pRoutePhySecStru))
 		{
-			return 0u;
-		}
-		if (routeSecSum == 1u)
-		{
-			/*if ((PHYSICAL_SECTION_LOCK_NORMAL == GetPhySecLockState(pRoutePhySecStru[0].PhysicalSectionId)) &&
-				(lockBelongRouteId == GetPhySecRLockBelongRouteId(pRoutePhySecStru[0].PhysicalSectionId)))*/
-			{
-				returnOutSecId = pRoutePhySecStru[0].PhysicalSectionId;/*折返信号机外方区段ID*/
-
-				tmpSigId = GetRouteStartSignalId(lockBelongRouteId);/*折返信号机内方区段ID*/
-				
-				returnInSecId = GetSignalOutFirstPhySecId(tmpSigId);
-			}
-		}
-		else if (routeSecSum > 1u)
-		{
-			for (ii = 0u; ii < routeSecSum; ii++)
-			{
-
-				if ((PHYSICAL_SECTION_LOCK_NORMAL == GetPhySecLockState(pRoutePhySecStru[ii].PhysicalSectionId)) &&
-					(lockBelongRouteId == GetPhySecRLockBelongRouteId(pRoutePhySecStru[ii].PhysicalSectionId)))
-				{ /*本进路第一个锁闭的区段*/
-				
-					returnOutSecId = pRoutePhySecStru[ii].PhysicalSectionId; /*折返信号机外方区段ID*/
-
-					if (ii > 0u)
-					{
-						returnInSecId = pRoutePhySecStru[ii-1U].PhysicalSectionId; /*折返信号机内方区段ID*/
-					}
-
-					break;
-				}
-			}
+			/*不处理*/
 		}
 		else
 		{
-			/*无操作*/
-		}
-		if ((0u == returnOutSecId) || (0u == returnInSecId))
-		{
-			return 0u;
-		}
-
-		for (ii = 0u; ii < signalSum; ii++)
-		{
-			signalId = GetSignalId(ii); /*获取信号机ID*/
-
-			if ((returnOutSecId == GetSignalOutFirstPhySecId(signalId)) &&
-				(returnInSecId == GetSignalInFirstPhySecId(signalId, routeId)))
+			if (1U == routeSecSum)
 			{
-				return signalId;
+				returnOutSecId = pRoutePhySecStru[0U].PhysicalSectionId;/*折返信号机外方区段ID*/
+
+				tmpSigId = GetRouteStartSignalId(lockBelongRouteId);/*折返信号机内方区段ID*/
+
+				returnInSecId = GetSignalOutFirstPhySecId(tmpSigId);
+			}
+			else if (1U < routeSecSum)
+			{
+				for (ii = 0U; ii < routeSecSum; ii++)
+				{
+
+					chPhyLockState = GetPhySecLockState(pRoutePhySecStru[ii].PhysicalSectionId);
+					wLockRouteId = GetPhySecRLockBelongRouteId(pRoutePhySecStru[ii].PhysicalSectionId);
+					if ((PHYSICAL_SECTION_LOCK_NORMAL == chPhyLockState) &&
+						(lockBelongRouteId == wLockRouteId))
+					{ /*本进路第一个锁闭的区段*/
+
+						returnOutSecId = pRoutePhySecStru[ii].PhysicalSectionId; /*折返信号机外方区段ID*/
+
+						if (0U < ii)
+						{
+							returnInSecId = pRoutePhySecStru[ii - 1U].PhysicalSectionId; /*折返信号机内方区段ID*/
+						}
+						else
+						{
+							wTempSigId = GetRouteStartSignalId(lockBelongRouteId);/*获取锁闭进路的外方第一区段*/
+							returnInSecId = GetSignalOutFirstPhySecId(wTempSigId);
+
+						}
+
+						break;
+					}
+				}
+			}
+			else
+			{
+				/*无操作*/
 			}
 		}
+		
+		if ((0U == returnOutSecId) || (0U == returnInSecId))
+		{
+			/*无操作*/
+		}
+		else
+		{
+			for (ii = 0u; ii < signalSum; ii++)
+			{
+				signalId = GetSignalId(ii); /*获取信号机ID*/
+				wTempSigOutPhyId = GetSignalOutFirstPhySecId(signalId);
+				wTempSigInPhyId = GetSignalInFirstPhySecId(signalId, routeId);
+				if ((returnOutSecId == wTempSigOutPhyId) &&
+					(returnInSecId == wTempSigInPhyId))
+				{
+					wReturnSignal = signalId;
+					break;
+				}
+				else
+				{
+					/*无操作*/
+				}
+			}
+		}
+
+		
 	}
 
-	return 0u;
+	return wReturnSignal;
 }
 
 

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

@@ -2919,6 +2919,127 @@ UINT8 AutoReturnRouteCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunc
 * by lyj 20250929
 */
 UINT8 AllAutoReturnRCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
+/*
+* 功能描述： 区段征用、区段防护道岔区段征用、区段内道岔道岔征用检查、区段内防护道岔道岔征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：区段防护道岔区段、防护道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*  add by mpt 20260331
+*/
+UINT8 JumpPhySectionPortectUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：逻辑区段防护道岔区段征用、道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 JumpLogicSecPortectUseCheck(const UINT16 wLgcId);
+/*
+* 功能描述：计轴区段所在道岔道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*  add by mpt 20260331
+*/
+UINT8 JumpPhySectionSwitchUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：设置跳跃锁闭防护道岔区段征用状态
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+*           const UINT8 state 状态
+* 返回值  ： void
+*  add by mpt 20260331
+*/
+void SetJumpPhySectionPortectSecUse(const UINT16 axisSecId, const UINT8 state);
+/*
+* 功能描述：设置逻辑区段的防护道岔区段征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+*           const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetJumpLogicSecPortectUse(const UINT16 wLgcId, const UINT8 state);
+/*
+* 功能描述： 检查计轴区段跳跃锁闭是否有防护道岔驱动超时
+* 参数说明： const UINT16 routeId, 进路ID
+* 返回值  ： UINT8
+			 CI_SUCCESS:计轴区段防护道岔无道岔驱动超时
+			 CI_ERROR:计轴区段防护道岔驱动超时
+add by mpt 20260331
+*/
+UINT8 ChekJumpLockProtectSwitDrivOvtmStat(const UINT16 axisSecId);
+/*
+* 功能描述： 计轴区段道岔封锁状态检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* Add by mpt 20260331
+*/
+UINT8 AxisSecProtSwitchFLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 计轴区段的防护道岔位置和动作有效性检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 AxisSecPorteSwitchPosMoveCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState, UINT8 funcId, UINT8 sendLevel);
+/*
+* 功能描述： 计轴区段所有防护道岔位置正确检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add mpt 20260331
+*/
+UINT8 AxisSecAllProtSwitchPosCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 设置计轴区段关联防护道岔防护锁闭状态
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+*            const UINT8 lockCommand, 锁闭状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetAxisRelProSwitchLockSta(const UINT16 axisSecId, const UINT8 lockCommand);
+/*
+* 功能描述： 计轴区段关联防护道岔防护锁闭检查
+* 参数说明： UINT16 const routeId,    计轴区段号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add mpt 20260331
+*/
+UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 设置逻辑区段关联防护道岔防护锁闭状态
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+*            const UINT8 lockCommand, 锁闭状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand);	
+/*
+* 功能描述：计轴区段所有道岔是否全部征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR  未全部征用
+*            CI_SUCCESS 全部征用
+*  add by mpt 20260403
+*/
+UINT8 JumpPhySecAllUseCheck(const UINT16 axisSecId);
 
 
 #endif

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

@@ -454,26 +454,21 @@ UINT8 SetRevrLTrainRouteLogicProcess(UINT16 const routeId)
 /* 联锁逻辑检查 */
 
     /* 进路类型是【列车进路】*/
-	if(CI_SUCCESS == reResult)
+	devState = GetRouteType(routeId);
+	if (devState == ROUTE_TYPE_LIECHE)
 	{
-		devState = GetRouteType(routeId);
-		if (devState == ROUTE_TYPE_LIECHE)
-		{
-			/* 通过检查 */
-			reResult = CI_SUCCESS;
-		}
-		else
-		{
-			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,routeId,ETYPE_ROUTE_TYPE,devState,sendLevel);
-			/* 失败返回 */
-			reResult = CI_ERROR;
+		/* 通过检查 */
+		reResult = CI_SUCCESS;
+	}
+	else
+	{
+		/* 记录故障码 */
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_TYPE, devState, sendLevel);
+		/* 失败返回 */
+		reResult = CI_ERROR;
 
-		}
-    }
-	
-	
-   
+	}
+	  
 	if(CI_SUCCESS == reResult)
 	{
 		devState = GetRouteState(routeId);
@@ -1053,21 +1048,18 @@ UINT8 SetReverseRtnRouteLogicProcess(UINT16 const routeId)
 /* 联锁逻辑检查 */
 
     /* 进路类型是【折返进路】*/
-    if(CI_SUCCESS == reResult)
+	devState = GetRouteType(routeId);
+	if (devState == ROUTE_TYPE_RETURN)
 	{
-		devState = GetRouteType(routeId);
-		if (devState == ROUTE_TYPE_RETURN)
-		{
-			/* 通过检查 */
-			reResult = CI_SUCCESS;
-		}
-		else
-		{
-			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,routeId,ETYPE_ROUTE_TYPE,devState,sendLevel);
-			/* 失败返回 */
-			reResult = CI_ERROR;
-		}
+		/* 通过检查 */
+		reResult = CI_SUCCESS;
+	}
+	else
+	{
+		/* 记录故障码 */
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_TYPE, devState, sendLevel);
+		/* 失败返回 */
+		reResult = CI_ERROR;
 	}
     
 	if(CI_SUCCESS == reResult)
@@ -2895,36 +2887,23 @@ UINT8 LockRouteOverlapLogicProcess(UINT16 const routeId, UINT16 const overlapId,
 		if (CI_TRADITION_RAILWAY == lineIdentity)
 		{/*传统线路*/
 			checkResult = OverlapSwitchMoveValidCheck(overlapId,&devId,&devState);
+			if (checkResult == CI_SUCCESS)
+			{
+				/* 通过检查，保持当前状态 */
+			}
+			else
+			{
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+				/* 失败返回 */
+				reResult = CI_ERROR;
+			}
 		}/* zt 删除单轨相关代码 2022-02-15 */
 		else
 		{/*线路类型错误*/
-			checkResult = CI_ERROR;
-		}
-
-		if (checkResult == CI_SUCCESS)
-		{
-			/* 通过检查，保持当前状态 */
-		}
-		else
-		{
-			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_SWITCH,devId,ETYPE_SWT_POSTION_STATE,devState,sendLevel);
-			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
 	} 
-	/*线路类型检查*/
-	if ((CI_SUCCESS == reResult) || (RETURN_WAIT_SWITCH_USING == reResult))
-	{/* zt 删除单轨相关代码 2022-02-15 */
-		if (CI_TRADITION_RAILWAY == lineIdentity)
-		{/*传统线路*/
-			/* 通过检查，保持当前状态 */
-		}
-		else
-		{/*线路类型错误*/
-			reResult = CI_ERROR;
-		}
-	}
 
 	/*保护区段道岔位置检查
      * RETURN_LOCK_ERR_SWITPOS： 保护区段道岔位置不正确
@@ -2934,15 +2913,7 @@ UINT8 LockRouteOverlapLogicProcess(UINT16 const routeId, UINT16 const overlapId,
 	{
 		devId = 0u;
 		devState = 0u;
-		if(CI_TRADITION_RAILWAY == lineIdentity)
-		{/*传统线路*/
-			checkResult = OverlapSwitchPosCheck(overlapId,&devId,&devState);
-		}/* zt 删除单轨相关代码 2022-02-15 */
-		else
-		{/*线路类型错误*/
-			checkResult = CI_ERROR;
-		}
-
+		checkResult = OverlapSwitchPosCheck(overlapId, &devId, &devState);
 		if (checkResult == CI_ERROR)
 		{
 			/* 道岔位置不正确 */
@@ -3631,21 +3602,18 @@ UINT8 OpenCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 /* 联锁逻辑检查 */
 
     /* 进路监督模式为【CBTC】*/
-	if (CI_SUCCESS == reResult)
+	devState = GetRouteLevel(routeId);
+	if ((devState == ROUTE_LEVEL_CBTC))
 	{
-		devState = GetRouteLevel(routeId);
-		if ((devState == ROUTE_LEVEL_CBTC))
-		{
-			/* 通过检查 */
-			reResult = CI_SUCCESS;
-		}
-		else
-		{
-			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,routeId,ETYPE_ROUTE_LEVEL,devState,sendLevel);
-			/* 失败返回 */
-			reResult = CI_ERROR;
-		}
+		/* 通过检查 */
+		reResult = CI_SUCCESS;
+	}
+	else
+	{
+		/* 记录故障码 */
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_LEVEL, devState, sendLevel);
+		/* 失败返回 */
+		reResult = CI_ERROR;
 	}
 
     /* 进路类型是列车进路*/
@@ -3886,18 +3854,15 @@ UINT8 OpenCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 		else
 		{
 			/*既不是反向进路，也不是风井进路*/
-			if (CI_SUCCESS == reResult)
+			/*防淹门联锁条件检查*/
+			checkResult = CBTCRouteFloodGateCheck(routeId, functionId, sendLevel);
+			if (CI_SUCCESS == checkResult)
 			{
-				/*防淹门联锁条件检查*/
-				checkResult = CBTCRouteFloodGateCheck(routeId,functionId,sendLevel);
-				if (CI_SUCCESS == checkResult)
-				{
-					reResult = CI_SUCCESS;
-				}
-				else
-				{
-					reResult = CI_ERROR;
-				}
+				reResult = CI_SUCCESS;
+			}
+			else
+			{
+				reResult = CI_ERROR;
 			}
 		}
 	}
@@ -4851,21 +4816,18 @@ UINT8 OpenCbtcReturnRouteLogicProcess(UINT16 const routeId)
 /* 联锁逻辑检查 */
 
     /* 进路监督模式为【CBTC】*/
-	if (CI_SUCCESS == reResult)
+	devState = GetRouteLevel(routeId);
+	if ((devState == ROUTE_LEVEL_CBTC))
 	{
-		devState = GetRouteLevel(routeId);
-		if ((devState == ROUTE_LEVEL_CBTC))
-		{
-			/* 通过检查 */
-			reResult = CI_SUCCESS;
-		}
-		else
-		{
-			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,routeId,ETYPE_ROUTE_LEVEL,devState,sendLevel);
-			/* 失败返回 */
-			reResult = CI_ERROR;
-		}
+		/* 通过检查 */
+		reResult = CI_SUCCESS;
+	}
+	else
+	{
+		/* 记录故障码 */
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_LEVEL, devState, sendLevel);
+		/* 失败返回 */
+		reResult = CI_ERROR;
 	}
 
     /* 进路类型是【折返进路】*/
@@ -7863,42 +7825,33 @@ UINT8 SetSwitchFLockLogicProcess(UINT16 const switchId)
 			{
 				if(FUNC_SWITCH_ON == CiFunctionLock)
 				{
-					if (CI_TRADITION_RAILWAY == lineIdentity)
-					{/*传统线路*/
-						/*道岔2区段状态为【未锁闭】*/
-						checkResult = switch2ndSecLockState;
-						if (checkResult == PHYSICAL_SECTION_LOCK_NO)
+					/*传统线路*/
+					/*道岔2区段状态为【未锁闭】*/
+					checkResult = switch2ndSecLockState;
+					if (checkResult == PHYSICAL_SECTION_LOCK_NO)
+					{
+						/*【未锁闭】*/
+						reResult = CI_SUCCESS;
+						if (LOG_SECTION_LOGLOCK_NO == chSw2PhySecLogLockState)
 						{
-							/*【未锁闭】*/
+							/*【未被逻辑进路锁闭】*/
 							reResult = CI_SUCCESS;
-							if (LOG_SECTION_LOGLOCK_NO == chSw2PhySecLogLockState)
-							{
-								/*【未被逻辑进路锁闭】*/
-								reResult = CI_SUCCESS;
-							}
-							else
-							{
-								/* 记录故障码 */
-								SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, switch2ndSecId, ETYPE_PS_LOCK_STATE, chSw2PhySecLogLockState, sendLevel);
-								/* 失败返回 */
-								reResult = CI_ERROR;
-							}
 						}
 						else
 						{
-							/*【锁闭】*/
 							/* 记录故障码 */
-							SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,switch2ndSecId,ETYPE_PS_LOCK_STATE,checkResult,sendLevel); 
+							SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, switch2ndSecId, ETYPE_PS_LOCK_STATE, chSw2PhySecLogLockState, sendLevel);
 							/* 失败返回 */
 							reResult = CI_ERROR;
-
 						}
-					}/* zt 删除单轨相关代码 2022-02-15 */
+					}
 					else
-					{/*线路类型错误*/
-						reResult = CI_ERROR;
+					{
+						/*【锁闭】*/
 						/* 记录故障码 */
-						SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,phySecId,ETYPE_PS_LOCK_STATE,devState,sendLevel);
+						SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, switch2ndSecId, ETYPE_PS_LOCK_STATE, checkResult, sendLevel);
+						/* 失败返回 */
+						reResult = CI_ERROR;
 					}
 				}
 				else if(FUNC_SWITCH_OFF == CiFunctionLock)
@@ -9604,11 +9557,13 @@ UINT8 OpenBlocRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 	UINT8 chDsnFuncSwitch = 0U;		/* 无直轨计轴占用功能开关 */
 	UINT8 chXianSuFuncSwitch = 0U; /*后备模式信号开放是否检查区段临时限速开关*/
 	UINT8 cCrossState = 0U;  /*信号机跨压状态*/
+	UINT8 chRouteBelongVirCiId = 0U;
 
 	chDsnFuncSwitch = GetCiFunctionSwitchConfig(FUNC_TOA_SWITCH);
 	chXianSuFuncSwitch = GetCiFunctionSwitchConfig(FUNC_XIANSU_SWITCH);
 
-	ciType = GetCiType(LocalCiId);
+	chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+	ciType = GetLocalVirCiType(chRouteBelongVirCiId);
 	 
 	/* 联锁逻辑检查 */  
 	/* 进路内所有区段未被封锁 */
@@ -9635,6 +9590,8 @@ UINT8 OpenBlocRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 		devState = 0u;
 		startSignalId = GetRouteStartSignalId(routeId);/*获取进路始端信号机ID*/
 		checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &cPhySecCurMergeState);
+
+	
 		routeState = GetRouteState(routeId);
 		if ((CI_TYPE_CLD == ciType) && ((ROUTE_STATE_YUXIAN_OPEN == routeState) ||(ROUTE_STATE_NEAR_OPEN == routeState)))
 		{/*车辆段进路预先开放或接近开放*/
@@ -9873,8 +9830,6 @@ UINT8 CLDKeepOpenSecCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel)
 		{
 			/*进路内区段，有UT占用，信号保持失败*/
 			/*进路内区段，有CT，且第一逻辑区段和外方第一物理区段最后一个逻辑区段CT占用，信号保持成功，其它失败*/
-			hasUtFlag = 0u;
-			hasCtFlag = 0u;
 			for (ii = 0u; ii < routePhyNum; ii++)
 			{
 				phyId = pRoutePhySecData[ii].PhysicalSectionId;
@@ -9908,7 +9863,7 @@ UINT8 CLDKeepOpenSecCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel)
 					ETYPE_PS_MERGY_OCU_STATE, devState,
 					sendLevel);
 			}
-			else if ((0u == hasUtFlag) && (1u == hasCtFlag))
+			else if (1u == hasCtFlag)
 			{
 				if (RC_WORK_MODE_TIOC == rcWorkMode)
 				{
@@ -9916,7 +9871,7 @@ UINT8 CLDKeepOpenSecCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel)
 					chFunRet = GetRouteInOutFstLgcTrainInfo(routeId, &chReadyEnterRouteTrainSum, wszReadyEtRouteTrainId);
 					if (CI_SUCCESS == chFunRet)
 					{
-						chTrainEnterState = dsuTrainMinHeadCrossSignal(wszReadyEtRouteTrainId[0], routeId);
+						chTrainEnterState = dsuTrainMinHeadCrossSignal(wszReadyEtRouteTrainId[0], routeId, CI_ERROR);
 						if (TRAIN_ENTER_ROUTE_FULL == chTrainEnterState)
 						{
 							/*列车完全驶入进路，关灯 by cgh 20231128*/
@@ -10038,6 +9993,7 @@ UINT8 OpenCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
     UINT16 startSignalId = 0u;
 	UINT8 signalCrossState = 0u;
 	UINT8 chRouteCouplinkFlag = 0U;
+	UINT8 chRouteBelongVirCiId = 0U;
     
 /* 联锁逻辑检查 */  
 	/* 进路内所有区段未被封锁 */
@@ -10060,7 +10016,8 @@ UINT8 OpenCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 	/*CBTC进路内方第一逻辑区段条件检查，车辆段进路需内方区段空闲*/
 	if (CI_SUCCESS == reResult)
 	{
-		cLocalCiType = GetLocalCiType();
+		chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+		cLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 		if (CI_TYPE_CLD != cLocalCiType)
 		{
 			/*非车辆段，按CBTC既有逻辑处理*/
@@ -10138,6 +10095,8 @@ UINT8 OpenCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 				}
 				else
 				{
+					devId = GetRouteInFirstLogSecId(routeId);
+					devState = GetLogSecCurOccupyState(devId);
 					reResult = CheckEngineerVehicleNear(routeId);/*检查是否是工程车接近的跨压*/
 					if (CI_SUCCESS == reResult)
 					{
@@ -10384,6 +10343,7 @@ UINT8 KeepCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 	UINT8 outPhySecState = 0U;
 	UINT8 cLocalCiType = 0U;  /*本控区类型*/
 	UINT8 chRouteCouplinkFlag = 0U;
+	UINT8 chRouteBelongVirCiId = 0U;
 /* 联锁逻辑检查 */  
 
 	/* 进路内所有区段未被封锁 */
@@ -10406,7 +10366,8 @@ UINT8 KeepCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
     /*CBTC进路内方第一逻辑区段条件检查*/
 	if(CI_SUCCESS == reResult)
 	{
-		cLocalCiType = GetLocalCiType();
+		chRouteBelongVirCiId = GetRouteBelongVirCiId(routeId);
+		cLocalCiType = GetLocalVirCiType(chRouteBelongVirCiId);
 		if (CI_TYPE_CLD != cLocalCiType)
 		{
 			/*非车辆段，按CBTC既有逻辑处理*/
@@ -10443,7 +10404,12 @@ UINT8 KeepCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 					if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
 					{
 						reResult = KeepCouplinkRouteSecOccCheck(routeId,&devId,&devState);
-						if (CI_ERROR == reResult)
+						if (CI_SUCCESS == reResult)
+						{
+							/* 通过检查 */
+							reResult = CI_SUCCESS;
+						}
+						else
 						{
 							/* 记录故障码 */
 							SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, SECTION_OCCUPY_YES, devState, sendLevel);
@@ -10492,6 +10458,8 @@ UINT8 KeepCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 				}
 				else
 				{
+					devId = GetRouteInFirstLogSecId(routeId);
+					devState = GetLogSecCurOccupyState(devId);
 					reResult = CheckEngineerVehicleNear(routeId);/*检查是否是工程车接近的跨压以及列车的真实跨压*/
 					if (CI_SUCCESS == reResult)
 					{
@@ -11577,6 +11545,7 @@ void RouteLgcSecResReleaseProcess(const UINT16 wRouteId)
 			wUnlockLgcSecId = routeLogIdBuf[ii];
 			wBelongRouteId = GetLogSecLockBelongRoute(wUnlockLgcSecId);
 			wLgcBufIndex = GetlogSectionBufIndex(wUnlockLgcSecId);
+			chLgcResTrainSum = GetLogSecTrainInfoSum(wUnlockLgcSecId);
 
 			chLogSecLogLockState = GetLogSecLogLockState(wUnlockLgcSecId);
 
@@ -11594,7 +11563,6 @@ void RouteLgcSecResReleaseProcess(const UINT16 wRouteId)
 				/*锁闭所属进路等于本进路或逻辑区段已解锁*/
 				if (wBelongRouteId == wRouteId)
 				{
-					chLgcResTrainSum = GetLogSecTrainInfoSum(wUnlockLgcSecId);
 					if (LOGIC_SECTION_RES_SUM_MAX > chLgcResTrainSum)
 					{
 						; /*继续执行*/
@@ -11640,7 +11608,10 @@ void RouteLgcSecResReleaseProcess(const UINT16 wRouteId)
 						&& (NULL == pstTrainResInfo))
 					{/*上一区段已经解锁，本区段由列车申请资源释放或本区段已经解锁*/
 						/*删除该列车对应逻辑区段资源*/
-						(void)ComMemSet((void *)&pstLgcSecInfo[wLgcBufIndex].szTrainResData[jj], (UINT16)sizeof(LogicTrainResStruct), 0U);
+
+						/*重置资源信息结构体*/
+						ResetResInfoStruct(wLgcBufIndex, jj);
+
 						debug_infor_printf((const)"LogSecRes Release LgcId: %d TrainId:%d  Cyc\n"
 							, wUnlockLgcSecId
 							, wTrainId

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

@@ -1598,12 +1598,14 @@ UINT8 SetNonRouteP(UINT8 nonRouteId)
 		reResult = NonRouteRelProSwiPosMovValCheck(nonRouteId,functionId,sendLevel);
 	}
 
+#if 0
+	/*修复缺陷YF0083-2105---LYJ--20260128*/
 	if (CI_SUCCESS == reResult)
 	{/*侵限区段侵限条件不满足检查*/
 		reResult = NonRouteIntruSecVainCheck(nonRouteId,functionId,sendLevel);
 	}
 
-	
+#endif	
 
 	return reResult;
 }
@@ -1721,14 +1723,6 @@ UINT8 LockNonRouteP(UINT8 nonRouteId)
 
 		reResult = NonRouteRelProSwiPosMovValCheck(nonRouteId,functionId,sendLevel);
 	}
-
-	if (CI_SUCCESS == reResult)
-	{/*侵限区段侵限条件不满足检查*/
-		reResult = NonRouteIntruSecVainCheck(nonRouteId,functionId,sendLevel);
-	}
-
-	
-
 	return reResult;
 }
 

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

@@ -118,6 +118,8 @@
 #define MASK_TYPE_PHYSECTION_HEAD_XTD				((UINT8)0x31)	/*定义物理区段运行方向下行状态码位*/
 #define MASK_TYPE_PHYSECTION_HEAD_STD				((UINT8)0x32)	/*定义物理区段运行方向上行状态码位*/
 #define MASK_TYPE_LIECHE_STOPSTATE					((UINT8)0x3a)	/*定义列车停稳信息状态码位*/
+#define MASK_TYPE_PHYSECTION_INTRUSION				((UINT8)0x5a)	/*定义物理区段侵限状态码位(CI->ZC)*/
+#define MASK_TYPE_PHYSECTION_ATS_FLOCK				((UINT8)0x5b)	/*定义物理区段由ATS封锁状态码位(CI->ZC)*/
 #define MASK_TYPE_PHYSEC_CENTERDETAIN_UP					((UINT8)0x3d)	/*定义物理区段CI-ATS中心上行扣车状态状态码位 (兼容28.0.0.14使用)*/
 #define MASK_TYPE_PHYSEC_CENTERDETAIN_DOWN				((UINT8)0x3e)	/*定义物理区段CI-ATS中心下行扣车状态状态码位 (兼容28.0.0.14使用)*/
 #define MASK_TYPE_PHYSEC_STATIONDETAIN_UP					((UINT8)0x3f)	/*定义物理区段CI-ATS车站上行扣车状态状态码位 (兼容28.0.0.14使用)*/
@@ -139,9 +141,10 @@
 #define MASK_TYPE_DOWNWARD_DIRECTION    			((UINT8)0x94)	/*定义逻辑区段下行锁闭码位*/
 #define MASK_TYPE_LOGICSECTION_PROTECTLOCK			((UINT8)0x99)	/*定义逻辑区段防护锁闭码位*/
 #define MASK_TYPE_LOGICSECTION_JUMPLOCK				((UINT8)0x9A)   /*定义逻辑区段跳跃锁闭码位*/
-#define MASK_TYPE_LOGICSECTION_ARB		            ((UINT8)0x9B)   /*定义逻辑区段ARB状态码位*/
+#define MASK_TYPE_LOGSEC_CBTC_ARB		            ((UINT8)0x9B)   /*定义逻辑区段CBTC_ARB状态码位*/
 #define MASK_TYPE_LOGICSECTION_SPKS_FLOCK		    ((UINT8)0x9C)   /*定义逻辑区段SPKS封锁状态码位*/
 #define MASK_TYPE_LOGICSECTION_EMERG_XIANSU         ((UINT8)0x9D)   /*定义逻辑区段紧急临时限速码位*/
+#define MASK_TYPE_LOGSEC_PB_TACS_ARB		        ((UINT8)0xB3)   /*定义逻辑区段PB_TACS_ARB状态码位*/
 
 
 /*保护区段相关码位*/
@@ -204,7 +207,7 @@
 #define MASK_TYPE_PSD_PDB_FLASH_STATE		        ((UINT8)0xA0)	/*定义清客确认箱PDB按钮指示灯闪灯状态码位*/
 #define MASK_TYPE_PSD_VIDEO_QK_LU		            ((UINT8)0xA1)	/*定义清客按钮箱视频清客表示灯（绿)状态码位*/
 #define MASK_TYPE_PSD_VIDEO_QK_HONG		            ((UINT8)0xA2)	/*定义清客按钮箱视频清客表示灯（红)状态码位*/
-#define MASK_TYPE_PSD_EXCEPT_OPEN                   ((UINT8)0xA5)   /*定义站台安全门异常打开码位*/
+#define MASK_TYPE_PSD_EXCEPT                   ((UINT8)0xA5)   /*定义站台安全门异常码位 CI-ATS、CI-ZC*/
 #define MASK_TYPE_PSD_JXTCPANGLU_FAULT              ((UINT8)0xAA)   /*定义间隙探测旁路按钮故障码位*/
 #define MASK_TYPE_PSD_IBP_STATE                     ((UINT8)0xAD)   /*定义IBP盘按钮状态码位*/
 #define MASK_TYPE_PSD_IBP_FAULT                     ((UINT8)0xAE)   /*定义IBP盘按钮故障码位*/

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

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

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

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

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

@@ -28,7 +28,7 @@
 
 
 /*·Ç½ø·µ÷³µ×´Ì¬*/
-#define NONROUTE_STATE_INVALID					((UINT8)0x0)		/*·Ç½ø·״̬ÎÞЧ*/
+#define NONROUTE_STATE_INVALID					((UINT8)0x0)	/*·Ç½ø·״̬ÎÞЧ*/
 #define NONROUTE_STATE_IDLE						((UINT8)0x01)	/*·Ç½ø·¿ÕÏÐ*/
 #define NONROUTE_STATE_XUANPAI					((UINT8)0x02)	/*·Ç½ø·ѡÅÅ*/
 #define NONROUTE_STATE_LOCK						((UINT8)0x04)	/*·Ç½ø·Ëø±Õ*/

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

@@ -97,7 +97,7 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
 	overlapProtectSwitchSum = GetOverlapRelatedProtSwitSum(overlapId);      /*获取防护道岔数目*/
 	overlapProtectSwitchStru = GetOverlapRelatedProtSwitStru(overlapId);    /*获取防护道岔数据*/
 
-	if (0u == overlapProtectSwitchSum) 
+	if ((0U == overlapProtectSwitchSum) || (NULL == overlapProtectSwitchStru))
 	{
 		retVal = CI_ERROR;
 	}
@@ -890,7 +890,10 @@ void CleanOverlapSpecificFlag(const UINT16 routeId, const UINT16 overlapId)
 	}
 	else
 	{
-		if ((dwAtsLastTimeLockCyc < dwUnlockStartCycNum) && (0U < dwAtsLastTimeLockCyc))
+		atsExpLockOverlapId = GetRouteAtsExpLkOverlapId(routeId);
+
+		if ((dwAtsLastTimeLockCyc <= dwUnlockStartCycNum) && (0U < dwAtsLastTimeLockCyc)
+			&& (overlapId == atsExpLockOverlapId))
 		{
 			/*ATS最后一次下发锁闭保护区段命令时保护区段未自动解锁*/
 			SetRouteAtsExpLkOverlapId(routeId, 0U);

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

@@ -43,7 +43,7 @@ typedef struct S_PsdConfigDataStruct
 	UINT16 OpenFourEditGroupDriveRelayId;                                   /*打开四编组屏蔽门的驱动继电器(配置字段)*/
 	UINT16 OpenSixEditGroupDriveRelayId;                                    /*打开六编组屏蔽门的驱动继电器(配置字段)*/
 	UINT16 OpenEightEditGroupDriveRelayId;                                  /*打开八编组屏蔽门的驱动继电器(配置字段)*/
-	UINT16 DoorStateRelayId;     											/*门开采集继电器ID (配置字段)*/
+	UINT16 DoorStateRelayId;     											/*门开采集继电器ID (配置字段)*/   
 	UINT16 wDoorStateRelayId2;												/*门开采集继电器ID2(配置字段) 迪斯尼*/
 	UINT16 wRelayDoorButtonId;                                              /*屏蔽门再关门按钮继电器*/
 	UINT16 doorReopenRelayId;												/*站台门再次开门继电器*/

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

@@ -1565,7 +1565,6 @@ UINT8 GetPsdPlFlag(const UINT16 doorId)
 void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFlag)
 {
 	/*变量初始化*/
-	UINT8 i = 0u;
 	UINT8 transmitState = 0u;
 	UINT8 localCiId = 0u;
 	UINT8 psdCiId = 0u;
@@ -2575,21 +2574,21 @@ UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId)
 }
 
 /*
-* 功能描述：设置指定ID屏蔽门异常打开状态
+* 功能描述：设置指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-*			const UINT8 cExceptOpenState 屏蔽门异常打开状态
+*			const UINT8 cExceptOpenState 屏蔽门异常状态
 * 返 回 值：无
 * Created By LQ 2025.05.22
 */
-void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
+void SetPsdExceptState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
 {
 	UINT16 bufIndex = 0U;
 
-	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/
+	bufIndex = GetPsdConfigBufIndex(wPsdId); /*获取屏蔽门数组下标*/
 
-	if ((PSD_SUM_MAX > bufIndex) && ((PSD_EXCEPT_OPEN_YES == cExceptOpenState) || (PSD_EXCEPT_OPEN_NO == cExceptOpenState)))
+	if ((PSD_SUM_MAX > bufIndex) && ((PSD_EXCEPT_YES == cExceptOpenState) || (PSD_EXCEPT_NO == cExceptOpenState)))
 	{
-		PsdDataStru[bufIndex].cPsdExceptOpenState = cExceptOpenState;  /*设置屏蔽门异常打开状态*/
+		PsdDataStru[bufIndex].cPsdExceptOpenState = cExceptOpenState;  /*设置屏蔽门异常状态*/
 	}
 	else
 	{
@@ -2598,16 +2597,16 @@ void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
 }
 
 /*
-* 功能描述：获取指定ID屏蔽门异常打开状态
+* 功能描述：获取指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-* 返 回 值：0x55 异常打开
-*           0xAA 未异常打开
+* 返 回 值：0x55 异常（曾异常打开未解除）
+*           0xAA 未异常
 * Created By LQ 2025.05.22
 */
-UINT8 GePsdExceptOpenState(const UINT16 wPsdId)
+UINT8 GePsdExceptState(const UINT16 wPsdId)
 {
 	UINT16 bufIndex = 0U;
-	UINT8 cRetVal = PSD_EXCEPT_OPEN_YES;
+	UINT8 cRetVal = PSD_EXCEPT_YES;
 
 	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/
 
@@ -3375,4 +3374,46 @@ UINT32 GetIBPPressCycNum(const UINT16 doorId)
 		retVal = CI_ERROR;
 	}
 	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID屏蔽门状态给 VOBC
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ：屏蔽门状态
+*/
+UINT8 GetPsdStateToVobc(const UINT16 doorId)
+{
+	UINT8 chPsdState = 0U;
+	UINT8 chPsdPlState = 0U;
+	UINT8 chExceptOpenState = 0U;
+	UINT8 chRet = 0U;
+	chPsdPlState = GetPsdMutualLockRemoveState(doorId); /*屏蔽门互锁解除*/
+	if ((PSD_MUTUALLOCK_REMOVE_YES == chPsdPlState) || (PSD_ATS_MUTUALLOCK_REMOVE_YES == chPsdPlState) || (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == chPsdPlState))
+	{
+		/*屏蔽门互锁解除*/
+		chRet = CI_IVOC_PSD_STATE_PANGLU;
+	}
+	else
+	{
+		chPsdState = GetPsdState(doorId);
+		if (PSD_STATE_CLOSE == chPsdState)
+		{/*屏蔽门关*/
+			chRet = CI_IVOC_PSD_STATE_CLOSE;
+		}
+		else
+		{
+			/*屏蔽门开, 判断是否异常*/
+			chExceptOpenState = GePsdExceptState(doorId);
+			if (PSD_EXCEPT_NO == chExceptOpenState)
+			{
+				chRet = CI_IVOC_PSD_STATE_OPEN;
+			}
+			else
+			{
+				/*屏蔽门异常打开*/
+				chRet = CI_IVOC_PSD_STATE_OPEN_EXCEPT;
+			}
+		}
+	}
+	return chRet;
 }

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

@@ -925,22 +925,22 @@ void SetPsdVideoQkRelateVobcId(const UINT16 wPsdId, const UINT16 wVobcId);
 UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId);
 
 /*
-* 功能描述：设置指定ID屏蔽门异常打开状态
+* 功能描述：设置指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-*			const UINT8 cExceptOpenState 屏蔽门异常打开状态
+*			const UINT8 cExceptOpenState 屏蔽门异常状态
 * 返 回 值：无
 * Created By LQ 2025.05.22
 */
-void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState);
+void SetPsdExceptState(const UINT16 wPsdId, const UINT8 cExceptOpenState);
 
 /*
-* 功能描述：获取指定ID屏蔽门异常打开状态
+* 功能描述：获取指定ID屏蔽门异常状态
 * 参数说明：const UINT16 wPsdId 屏蔽门ID
-* 返 回 值：0x55 异常打开
-*           0xAA 未异常打开
+* 返 回 值：0x55 异常（曾异常打开未解除）
+*           0xAA 未异常
 * Created By LQ 2025.05.22
 */
-UINT8 GePsdExceptOpenState(const UINT16 wPsdId);
+UINT8 GePsdExceptState(const UINT16 wPsdId);
 
 /*
 * 功能描述： 设置指定ID屏蔽门故障隔离信息
@@ -1179,6 +1179,12 @@ UINT8 GetPsdButtonIbpState(const UINT16 doorId);
 *           >0: 设置数据成功
 */
 UINT8 SetIBPPressCycNum(const UINT16 doorId, const UINT32 startCycNum);
+/*
+* 功能描述： 获取指定ID屏蔽门状态给 VOBC
+* 参数说明： const UINT16 doorId，屏蔽门ID
+* 返回值  ：屏蔽门状态
+*/
+UINT8 GetPsdStateToVobc(const UINT16 doorId);
 #ifdef __cplusplus
 }
 #endif

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

@@ -17,7 +17,7 @@
 
 
 /*屏蔽门总数最大值*/
-#define PSD_SUM_MAX                        ((UINT16)90U)     /*定义屏蔽门数量最大值*/
+#define PSD_SUM_MAX                        ((UINT16)150U)     /*定义屏蔽门数量最大值*/
 
 /*和屏蔽门关联的出站进路数目最大值*/
 #define RALATED_OUT_STATION_ROUTE_SUM_MAX  ((UINT16)10U)     /*屏蔽门关联的出站进路数目最大值*/
@@ -198,9 +198,13 @@
 #define VIDEO_QK_DRIVE_STATE_TESTING  ((UINT8)0xccU)  /*视频清客驱动状态—检测中*/
 #define VIDEO_QK_DRIVE_STATE_INVALID  ((UINT8)0xffU)  /*视频清客驱动状态—无效*/
 
-/*屏蔽门异常打开状态*/
-#define PSD_EXCEPT_OPEN_NO            ((UINT8)0xAAU)   /*未异常打开*/
-#define PSD_EXCEPT_OPEN_YES           ((UINT8)0x55U)   /*异常打开*/
+/*屏蔽门异常状态*/
+#define PSD_EXCEPT_NO            ((UINT8)0xAAU)   /*未异常*/
+#define PSD_EXCEPT_YES           ((UINT8)0x55U)   /*异常(曾异常打开未取消)*/
+
+/*屏蔽门异常取消方式*/
+#define PSD_EXCEPT_CANCLE_ATS            ((UINT8)0xAAU)   /*ATS命令取消*/
+#define PSD_EXCEPT_CANCLE_RCI            ((UINT8)0x55U)   /*未异常打开时联锁自动取消异常*/
 
 /*OC-P旁路状态确认*/
 #define OC_PSC_PL_CONFIRM_YES  ((UINT8)0xaaU)  /*OC-P旁路状态已确认*/
@@ -218,4 +222,10 @@
 
 
 #define PSD_INCLUDE_ESB_NUM			((UINT8)10U)		/*ESB个数*/
+
+/*CI-VOBC屏蔽门状态*/
+#define CI_IVOC_PSD_STATE_CLOSE			((UINT8)0xAAU)		  /*CI到IVOC屏蔽门关闭*/
+#define CI_IVOC_PSD_STATE_OPEN			((UINT8)0x55U)		  /*CI到IVOC屏蔽门打开*/
+#define CI_IVOC_PSD_STATE_PANGLU		((UINT8)0xCCU)		  /*CI到IVOC屏蔽门互锁解除*/
+#define CI_IVOC_PSD_STATE_OPEN_EXCEPT	((UINT8)0x33U)		  /*CI到IVOC屏蔽门异常打开*/
 #endif

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

@@ -163,6 +163,7 @@
 #define ATS_CMD_APPLY_XICHE                             ((UINT8)0xB1)         /*降级模式洗车请求*/
 #define ATS_CMD_APPLY_PASSXICHE                         ((UINT8)0xB2)         /*现地请求反向洗车命令-降级模式*/
 #define ATS_CMD_CANCEL_PASSXICHE                        ((UINT8)0xB3)         /*现地取消反向洗车命令-降级模式*/
+#define ATS_CMD_CANCEL_PSD_EXCEPT                        ((UINT8)0xBA)         /*现地取消站台门异常状态*/
 
 /****联锁到其他联锁的命令宏定义****/
 #define CI_CMD_PHYSEC_USING_APPLY				((UINT16)0x0001)        /*物理区段征用申请*/

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

@@ -2065,7 +2065,7 @@ UINT16 TransCiToAtsSwitchZzjInfo(OcToATSSwitchZzjData* ciSendAtsSwitchZzjData, U
 									}
 									else
 									{
-										/*道岔没被驱动四开，此转辙机状态设置为正常*/
+										/*道岔没被驱动四开，此转辙机状态设置为故障*/
 										ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_ALARM;
 									}
 								}

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

@@ -108,13 +108,13 @@
 #define PHYSEC_LOCKDIRECTION_OPPST_YES					((UINT8)0xAA)	/*取反*/
 #define PHYSEC_LOCKDIRECTION_OPPST_DEFAULT				((UINT8)0xFF)	/*默认值*/
 
-#define CICI_VERSION					((UINT8)31) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2026.01.04*/
+#define CICI_VERSION					((UINT8)32) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2026.03.10*/
 #define CICI_BEGIN_TO_STATION_LEN		((UINT16)31) /*20251104更新为HLHT头长度+应用层保温内容前6字节*/
 #define CICI_CICIVERINDEX (CICI_BEGIN_TO_STATION_LEN-3U) /*20251104更新后CI接口版本信息索引*/
 #define CICI_ONE_SWITCH_LEN				((UINT16)13) /*一个道岔数据长度*/
 #define CICI_ONE_PHYSEC_LEN				((UINT16)12U)/*一个物理区段数据长度*/
 #define CICI_ONE_PHYSEC_UT_LEN				((UINT16)1U)/*一个物理区段坏车占用数据长度*/
-#define CICI_ONE_LOGSEC_LEN				((UINT16)9)/*一个逻辑区段数据长度*/
+#define CICI_ONE_LOGSEC_LEN				((UINT16)6)/*一个逻辑区段数据长度*/
 #define CICI_ONE_SIGNAL_LEN				((UINT16)11)/*一个信号机数据长度*/
 #define CICI_ONE_PSD_LEN				((UINT16)5)/*一个屏蔽门数据长度*/
 #define CICI_ONE_ESB_LEN				((UINT16)4)/*一个ESB数据长度*/
@@ -231,6 +231,12 @@ extern "C" {
 		UINT16 szNeedCheckProSwtStateOlpIdBuf[OVERLAP_SUM_MAX];  /*需要检查防护道岔状态的保护区段ID数组*/
 		UINT16 wSwitchSumOfOtherCi;  /*涉及到保护区段征用的其它控区道岔数量*/
 		UINT16 szSwitchIdBufOfOtherCi[SWITCH_SUM_MAX];  /*涉及到保护区段征用的其它控区道岔数量*/
+
+		/*互联互通增加分界数据类型*/
+		UINT16 wSwitchPhySecNum;							/*道岔所在物理区段数量*/
+		UINT16 wSwitchPhySecBuf[PHYSICAL_SECTION_SUM_MAX];	/*道岔所在物理区段数组*/
+		UINT16 wXianSuLogSecNum;						/*限速逻辑区段数量*/
+		UINT16 wXianSuLogSecBuf[LOGIC_SECTION_SUM_MAX]; /*限速逻辑区段数组*/
 	} CiTransmitStruct;
 
 	/* 相邻TIOC发来的通信车 */
@@ -1443,11 +1449,12 @@ UINT8 PackManufacDefPacket(UINT8* pInputBuf, UINT16* pItemLen, const UINT8 dstCi
 * 参数说明：const UINT8 *pInputData 输入数据指针
 *           UINT16 *pItemLen 该项数据在输入数据中的长度
 *           const UINT8 srcCiId 源联锁ID
+*			const UINT16 packetLen 报文长度
 * 返 回 值：CI_SUCCESS 1 解析成功
 *           CI_ERROR 0 解析失败
 * Created By LQ 2025.05.26
 */
-UINT8 ParseManufacDefPacket(const UINT8* pInputData, UINT16* pItemLen, const UINT8 srcCiId);
+UINT8 ParseManufacDefPacket(const UINT8* pInputData, UINT16* pItemLen, const UINT8 srcCiId, const UINT16 packetLen);
 
 /*
 * 功能描述：组CI到本控区RC单帧数据

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

@@ -524,7 +524,11 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	UINT16 indexFind = 0U;
 	UINT8 devBelongThisLine = 0U;
 	UINT8 switchBoardNum = 0U;
-	UINT8 switchStateCheck = CI_ERROR;
+	UINT8 chLocalCiOCSswitch = 0U;
+	UINT8 chMainCotrolOCId = 0U;
+
+	chLocalCiOCSswitch = GetLocalCiOCSswitch();
+
 
 	switchLockStatus = GetSwitchLockStatus(DeviceId);
 
@@ -699,13 +703,17 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 		}
 		break;
 	case MASK_TYPE_SWITCH_OPEN_CAP:
+		chMainCotrolOCId = GetSwitchMainCotrolOCId(DeviceId);/*获取主控OC*/
 		for (i = 0u; i < m_SwitchNum; i++)
 		{
 			if (m_Switches[i].DeviceId == DeviceId)
 			{
-				flagFind = 1u;
-				indexFind = i;
-				break;
+				if ((chMainCotrolOCId == m_Switches[i].OcId) || (OC_S_OFF == chLocalCiOCSswitch))
+				{/*当前有主控OC或OC-S功能关闭*/
+					flagFind = 1u;
+					indexFind = i;
+					break;
+				}
 			}
 		}
 		if (1u == flagFind)
@@ -1178,6 +1186,42 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
 			;
 		}
 		break;
+		case MASK_TYPE_PHYSECTION_INTRUSION:
+		/* 物理区段侵限状态码位 */
+		phyIntruSecVainCheck = PhysicalIntruSecVainCheck(DeviceId);
+		if (CI_SUCCESS == phyIntruSecVainCheck)
+		{			
+			/*未侵限，发1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+			/*侵限，发0*/
+		}
+		break;
+	case MASK_TYPE_PHYSECTION_ATS_FLOCK:
+		/* 物理区段由ATS封锁状态码位 */
+		/*封锁状态码位(ATS设置) 封锁发0 未封锁以及SPKS命令封锁发1*/
+		phySecState = GetPhySecFLockState(DeviceId);
+		if (PHYSICAL_SECTION_FLOCK_NO != phySecState)
+		{
+			phySecLockType = GetPhySecFLockType(DeviceId);
+			if (PHY_SEC_FLOCK_TYPE_SPKS != phySecLockType)
+			{
+				/*除了SPKS封锁  都发0*/
+			}
+			else
+			{
+				/*SPKS命令的封锁 发1*/
+				SetMaskValue(MaskId, dataBuf);
+			}
+		}
+		else
+		{
+			/*未封锁 发1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		break;
 
 	default:
 		returnValue = CI_ERROR;
@@ -1204,13 +1248,16 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 	UINT16 logLockBelongRoute = 0U;/*逻辑区段锁闭所属进路*/
 	UINT16 logProtectLockRoute = 0U;/*逻辑区段防护锁闭所属进路*/
 	UINT8 chJumpLockState = 0U;/*逻辑区段锁闭状态*/
-	UINT8 cLogArbState = 0U;	/* 逻辑区段ARB状态 */
+	UINT8 cLogCbtcArbState = 0U;	/* 逻辑区段CBTC_ARB状态 */
+	UINT8 cLogPbTacsArbState = 0U;	/* 逻辑区段PB_TACS_ARB状态 */
 	UINT8 chLogSecLockDirOpposedFlag = CI_ERROR;/*逻辑区段锁闭方向是否取反标志*/
 	UINT8 cLogSpksFlockState = 0U;	/* 逻辑区段SPKS封锁状态 */
 	UINT8 cLogSecLogicLockState = LOG_SECTION_LOCK_NO;  /*逻辑区段逻辑锁闭状态*/
 	UINT8 cLogSecLockDir = CI_SYSTEM_DIRECTION_NONE;  /*逻辑区段锁闭方向*/
 	UINT8 chLogSecBelLogRouteSum = 0U;/*逻辑区段所属逻辑进路数目*/
 	UINT8 chLogSecEmergXianSu = 0U;/*逻辑区段紧急临时限速状态*/
+	UINT8 chRcWorkMode = 0U; /*RC工作模式*/
+
 	switch (MaskType)
 	{
 	case MASK_TYPE_LOGICSECTION_UTOCCUPY:
@@ -1364,15 +1411,33 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 			SetMaskValue(MaskId, dataBuf);
 		}
 		break;
-	case MASK_TYPE_LOGICSECTION_ARB:
-		/* 逻辑区段ARB状态 */
-		cLogArbState = GetLgcArbState(DeviceId);
-		/*区段ARB*/
-		if (LGC_SECTION_ARB_YES == cLogArbState)
+	case MASK_TYPE_LOGSEC_CBTC_ARB:
+		/* 逻辑区段CBTC_ARB状态 */
+		cLogCbtcArbState = GetLogSecCbtcArbState(DeviceId);
+		/*当前系统为CI，获取逻辑区段ARB状态*/
+		if (LGC_SECTION_ARB_YES == cLogCbtcArbState)
 		{
 			/*设置码位为1*/
 			SetMaskValue(MaskId, dataBuf);
 		}
+		else
+		{
+			;
+		}
+		break;
+	case MASK_TYPE_LOGSEC_PB_TACS_ARB:
+		/* 逻辑区段PC_TACS_ARB状态 */
+		cLogPbTacsArbState = GetLogSecPbTacsArbState(DeviceId);
+		/*当前系统为RC，获取逻辑区段ARB状态*/
+		if (LGC_SECTION_ARB_YES == cLogPbTacsArbState)
+		{
+			/*设置码位为1*/
+			SetMaskValue(MaskId, dataBuf);
+		}
+		else
+		{
+			;
+		}
 		break;
 	case MASK_TYPE_LOGICSECTION_SPKS_FLOCK:
 		/* 逻辑区段SPKS封锁状态 */
@@ -1387,7 +1452,7 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
 			/*设置码位为1*/
 			SetMaskValue(MaskId, dataBuf);
 		}
-		
+
 		break;
 	case MASK_TYPE_LOGICSECTION_EMERG_XIANSU:
 		/* 逻辑区段紧急临时限速状态 */
@@ -1576,6 +1641,10 @@ UINT8 OverlapMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* d
 UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dataBuf)
 {
 	UINT8 returnValue = CI_SUCCESS;              /*返回值默认成功*/
+	UINT8 chVirCiId = 0u;
+	UINT8 chVirCiType = 0u;
+	UINT8 ciTrainTestState = 0u;	/*试车线联锁状态*/
+	UINT32 xuanpaiStartCycNum = 0u;/*进路选排开始周期数*/
 	UINT8 routeState = GetRouteState(DeviceId);  /*获取进路状态*/
 	UINT8 routeLevel = GetRouteLevel(DeviceId);
 	UINT16 lastPhyLockId = GetRouteLastPhySectionId(DeviceId);   /*获取指定ID进路最后一个物理区段ID*/
@@ -1584,12 +1653,11 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 	UINT8 dcQState = GetRouteDCQState(DeviceId);/*进路调车请求状态*/
 	UINT8 dcTState = GetRouteDCTYState(DeviceId);/*进路调车同意状态*/
 	UINT8 chDCAgreeBtnErrState = GetRouteDcAgreeButtonErrState(DeviceId);/*进路调车同意按钮故障状态*/
-	UINT8 ciTrainTestState = 0u;	/*试车线联锁状态*/
+
 	UINT8 routeAutoTriggerFlag = GetRouteAutoTriggerFlag(DeviceId);     /*获取进路自动触发标志*/
 
-	UINT8 chVirCiId = 0u;
-	UINT8 chVirCiType = 0u;
 
+	xuanpaiStartCycNum = GetRouteXuanPaiStartCycNum(DeviceId);/*进路选排开始周期数*/
 	switch (MaskType)
 	{
 	case MASK_TYPE_ROUTE_IDLE:/*进路空闲码位*/
@@ -1603,7 +1671,8 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 		}
 		break;
 	case MASK_TYPE_ROUTE_XUANPAI:/*进路选排码位*/
-		if (ROUTE_STATE_XUANPAI == routeState)
+		/* 处于选排周期号有效即可发送码位*/
+		if (xuanpaiStartCycNum > 0u)
 		{
 			SetMaskValue(MaskId, dataBuf);
 		}
@@ -1906,11 +1975,10 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 	UINT16 wRtnIndicatorDevId = 0U;/*无人折返报警灯设备ID*/
 	UINT8 chNonRrnAdhesionState = 0U;/*无人折返按钮粘连状态*/
 	UINT8 cEsbCutErrFlag = ESB_ERROR_FLAG_NO;  /*紧急关闭旁路按钮故障标志*/
-	UINT8 cPsdExceptOpenState = 0U;  /*屏蔽门异常打开状态*/
+	UINT8 cPsdExceptState = 0U;  /*屏蔽门异常状态*/
 	UINT8 chJXTCMutualLockFaultState = 0U; /*间隙探测按钮故障状态*/
 	UINT8 chIBPBtnState = 0U; /*IBP按钮状态*/
 	UINT8 chIBPBtnFaultState = 0U; /*IBP按钮故障状态*/
-	UINT8 chJXTCState = 0U; /*间隙探测状态*/
 	UINT8 cEsbCutBtnState = 0U;  /*紧急关闭旁路按钮激活状态*/
 	UINT8 cOnePlatEsbState = 0U;  /*同站紧急按钮激活状态*/
 	UINT8 cOnePlatEsbCutState = 0U;  /*同站紧急旁路按钮激活状态*/
@@ -2308,15 +2376,15 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
 			/*视频清客驱动状态为无人或者无效，红灯码位无效*/
 		}
 		break;
-	case MASK_TYPE_PSD_EXCEPT_OPEN:  /*站台屏蔽门异常打开状态码位-给ZC/ATS用*/
-		cPsdExceptOpenState = GePsdExceptOpenState(DeviceId);
-		if (PSD_EXCEPT_OPEN_NO == cPsdExceptOpenState)
+	case MASK_TYPE_PSD_EXCEPT:  /*站台屏蔽门异常状态码位-给ATS/ZC用*/
+		cPsdExceptState = GePsdExceptState(DeviceId);
+		if (PSD_EXCEPT_NO == cPsdExceptState)
 		{
-			SetMaskValue(MaskId, dataBuf);  /*PSD未异常打开，码位组1*/
+			SetMaskValue(MaskId, dataBuf);  /*PSD未异常，码位组1*/
 		}
 		else
 		{
-			/*PSD异常打开，码位组0*/
+			/*PSD异常，码位组0*/
 		}
 		break;
 	case MASK_TYPE_PSD_JXTCPANGLU_FAULT:
@@ -4833,6 +4901,7 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 	UINT16 curCoup = 0U;
 	UINT32 tempera = 0U;
 	UINT8 flagEEPROM = 0U;
+	UINT32 ccuSyn = 0u;/*通控请求序列号*/
 	UINT32 crcRecv = 0U;
 	
 	/*接收到平台心跳帧*/
@@ -4874,6 +4943,9 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 		/*EEPROM存储检验*/
 		flagEEPROM = dataBuf[ii];
 		ii += 1u;
+		/*通控请求序列号*/
+		ccuSyn = LongFromChar(&dataBuf[ii]);
+		ii += 4u;
 		/*CRC校验码*/
 		crcRecv = LongFromChar(&dataBuf[ii]);		/*获取CRC*/
 		ii += 4u;
@@ -4883,7 +4955,7 @@ UINT8 ParasePlantCCUHeartFrame(UINT8* dataBuf)
 		{
 
 			/*计算CRC校验码,除长度2和CRC4*/
-			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 22U);
+			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 26U);
 
 			
 			if (crcCheck == crcRecv)
@@ -4974,6 +5046,7 @@ UINT8 ParasePlantSEBHeartFrame(UINT8* dataBuf)
 
 	UINT8 boardSEBId = 0U;/*扩展板ID */
 	UINT16 dataLengthRcv = 0U; /*帧长度*/
+	UINT32 sebSyn = 0u;	/*串口请求序列号*/
 	UINT32 crcRecv = 0U;  /*CRC校验码*/
 	UINT32 rcvCyc = 0U;  /*周期号*/
 	/*接收到平台心跳帧*/
@@ -4997,17 +5070,20 @@ UINT8 ParasePlantSEBHeartFrame(UINT8* dataBuf)
 		/*数据内容 3字节*/
 		ii += 5U;
 
+		/*串口请求序列号*/
+		sebSyn = LongFromChar(&dataBuf[ii]);
+		ii += 4U;
 
 		/*CRC校验码*/
 		crcRecv = LongFromChar(&dataBuf[ii]);		/*获取CRC*/
 		ii += 4u;
 
-		/*长度校验*/  /*总长度16字节*/
+		/*长度校验*/  /*总长度20字节*/
 		if (dataLengthRcv == ii - 2U)
 		{
 
 			/*计算CRC校验码,除长度2和CRC4*/
-			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 10U);
+			crcCheck = Tioc_PlatCommonCrc32(&dataBuf[2], 14U);
 
 
 			if (crcCheck == crcRecv)

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

@@ -40,6 +40,9 @@ AtsMsgCfmStru g_strSndAtsDaCfmFst = { 0U };			/*
 UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 {
 	UINT8 chRtn = CI_ERROR;
+	UINT8 chRtn1 = CI_SUCCESS;
+	UINT8 chRtn2 = CI_SUCCESS;
+	UINT8 chRtn3 = CI_SUCCESS;
 	UINT8 chMsgNum = 0u;
 	UINT32 dwDataVer = 0u;
 	UINT32 dwPrtclMsg = 0u;
@@ -67,6 +70,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 	UINT16 wDevId = 0U;
 	UINT8 szCrcTmp[1024] = { 0U };
 	
+
 	if ((NULL != dataBuf) && (0u < dataLength))
 	{
 		chLocalId = GetSystemParaLocalCiId();
@@ -89,6 +93,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 			else
 			{
 				chRtn = CI_ERROR;
+				chRtn3 = CI_ERROR;
 			}
 		}
 		else
@@ -105,6 +110,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 			else
 			{
 				chRtn = CI_ERROR;
+				chRtn3 = CI_ERROR;
 			}
 		}
 		else
@@ -236,6 +242,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							; /*DO NOTHING*/
 						}
+						chRtn1 = chRtn;
 					}
 					else
 					{
@@ -355,6 +362,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							; /*DO NOTHING*/
 						}
+						chRtn2 = chRtn;
 					}
 					break;
 				}
@@ -469,6 +477,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						; /*DO NOTHING*/
 					}
+					chRtn3 = chRtn;
 					break;
 				}
 				case MSG_TYPE_EA_CANCLE_FIRST:/* 区间疏散取消首次消息 */
@@ -580,6 +589,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							;
 						}
+						chRtn1 = chRtn;
 					}
 					else
 					{
@@ -682,6 +692,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							;
 						}
+						chRtn2 = chRtn;
 					}
 					break;
 				}
@@ -801,7 +812,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						;
 					}
-
+					chRtn3 = chRtn;
 					break;
 				}
 				case MSG_TYPE_WLB_SET_FIRST:	/* 全线列车紧急制动一次命令 */
@@ -923,6 +934,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							;
 						}
+						chRtn1 = chRtn;
 					}
 					else
 					{
@@ -1039,6 +1051,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							;
 						}
+						chRtn2 = chRtn;
 					}
 					break;
 				}
@@ -1169,7 +1182,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						;
 					}
-
+					chRtn3 = chRtn;
 					break;
 				}
 				case MSG_TYPE_DA_CANCLE_FIRST:/* 脱轨防护区取消首次消息 */
@@ -1281,6 +1294,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							;
 						}
+						chRtn1 = chRtn;
 					}
 					else
 					{
@@ -1383,6 +1397,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 						{
 							;
 						}
+						chRtn2 = chRtn;
 					}
 					break;
 				}
@@ -1502,12 +1517,13 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						;
 					}
-
+					chRtn3 = chRtn;
 					break;
 				}
 				default:
 				{
 					chRtn = CI_ERROR;
+					chRtn3 = CI_ERROR;
 					break;
 				}
 				}
@@ -1545,20 +1561,40 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 	}
 	else
 	{
-		ClearAtsMsgFirst();
-		ClearAtsMsgSecond();
-		ClearAtsEaMsgFirst();
-		ClearAtsEaMsgSecond();
-		ClearAtsWlbMsgFirst();
-		ClearAtsWlbMsgSecond();
-		ClearAtsDaMsgFirst();
-		ClearAtsDaMsgSecond();
-		ClearSndAtsScreenFstCfmMsg();
-		ClearSndAtsEaFstCfmMsg();
-		ClearSndAtsWlbFstCfmMsg();
-		ClearSndAtsDaFstCfmMsg();
-	}
+    	/*命令校验非法后，清除对应相关的命令存储*/
+		if (CI_ERROR == chRtn1)
+		{
+			ClearAtsMsgFirst();
+			ClearAtsEaMsgFirst();
+			ClearAtsWlbMsgFirst();
+			ClearAtsDaMsgFirst();
+		}
+		if (CI_ERROR == chRtn2)
+		{
+			ClearSndAtsScreenFstCfmMsg();
+			ClearSndAtsEaFstCfmMsg();
+			ClearSndAtsWlbFstCfmMsg();
+			ClearSndAtsDaFstCfmMsg();
+		}
 
+		if (CI_ERROR == chRtn3)
+		{
+			ClearAtsMsgFirst();
+			ClearAtsEaMsgFirst();
+			ClearAtsWlbMsgFirst();
+			ClearAtsDaMsgFirst();
+			ClearSndAtsScreenFstCfmMsg();
+			ClearSndAtsEaFstCfmMsg();
+			ClearSndAtsWlbFstCfmMsg();
+			ClearSndAtsDaFstCfmMsg();
+			ClearAtsMsgSecond();
+			ClearAtsEaMsgSecond();
+			ClearAtsWlbMsgSecond();
+			ClearAtsDaMsgSecond();
+		}
+		
+	}
+	
 	return chRtn;
 }
 

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

@@ -989,7 +989,7 @@ UINT8 PackCiToOtherSysData(void)
 						reVal = PackCiToCiData(cLocalDevType, deviceIdBuf[ii]);
 						if (CI_ERROR == reVal)
 						{
-							debug_infor_printf((const)"\nPackCiToCiData Error: DstDev[0x%x]", (UINT16)(cLocalDevType) +(UINT16)(deviceIdBuf[ii]));  /*组包错误*/
+							debug_infor_printf((const)"\nPackCiToCiData Error: DstDev[0x%x]", (UINT16)(cLocalDevType * 256U) + (UINT16)(deviceIdBuf[ii]));  /*组包错误*/
 						}
 						else
 						{
@@ -1002,7 +1002,7 @@ UINT8 PackCiToOtherSysData(void)
 						reVal = PackHLHTCiToCiData(deviceIdBuf[ii]);
 						if (CI_ERROR == reVal)
 						{
-							debug_infor_printf((const)"\nPackHLHTCiToCiData Error: DstDev[0x%x]", (UINT16)(cLocalDevType)+(UINT16)(deviceIdBuf[ii]));/*组包错误*/
+							debug_infor_printf((const)"\nPackHLHTCiToCiData Error: DstDev[0x%x]", (UINT16)(cLocalDevType * 256U) +(UINT16)(deviceIdBuf[ii]));/*组包错误*/
 						}
 						else
 						{
@@ -1017,11 +1017,11 @@ UINT8 PackCiToOtherSysData(void)
 			}
 
 			
-			cSysType = GetSystemWorkType();			
+			cSysType = GetSystemWorkType();
 			cLocalCiType = GetLocalCiType();
-			if ((SYSTEM_WORK_MODE_ALL == cSysType) && ((CI_TYPE_ZX == cLocalCiType) || (CI_TYPE_SCX == cLocalCiType)))
+			if (SYSTEM_WORK_MODE_ALL == cSysType)
 			{
-				/*****双系统正线或试车线，组相邻控区另一个设备数据*****/
+				/*****双系统，组相邻控区另一个设备数据*****/
 				if (CI_SYSTEM_TYPE_CI == cLocalDevType)
 				{
 					cNearOtherDevType = CI_SYSTEM_TYPE_RC;
@@ -1048,7 +1048,7 @@ UINT8 PackCiToOtherSysData(void)
 							reVal = PackCiToCiData(cNearOtherDevType, deviceIdBuf[ii]);
 							if (CI_ERROR == reVal)
 							{
-								debug_infor_printf((const)"\nPackCiToCiData Error: DstDev[0x%x]", (UINT16)(cNearOtherDevType) +(UINT16)(deviceIdBuf[ii]));  /*组包错误*/
+								debug_infor_printf((const)"\nPackCiToCiData Error: DstDev[0x%x]", (UINT16)(cNearOtherDevType * 256U) +(UINT16)(deviceIdBuf[ii]));  /*组包错误*/
 							}
 							else
 							{
@@ -1068,7 +1068,7 @@ UINT8 PackCiToOtherSysData(void)
 
 				/*组本控区CI-RC数据*/
 				cStartLockFlag = GetStartLockFlag();
-				if (CI_START_LOCK_NO == cStartLockFlag)
+				if ((CI_START_LOCK_NO == cStartLockFlag) && ((CI_TYPE_ZX == cLocalCiType) || (CI_TYPE_SCX == cLocalCiType)))
 				{
 					/*双系统下的正线和试车线才进行本控区CI-RC的组包*/
 					if (CI_SYSTEM_TYPE_CI == cLocalDevType)

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

@@ -94,7 +94,10 @@ UINT16 ConvertSigDrvColorToSigDrvCmd(const UINT16 signalId, const UINT8 drvColor
 	UINT8 ocHasBlue = 0u;
 	UINT8 funSwitchGreenYellow = GetCiFunctionSwitchConfig(CI_FUNCTION_SWITCH_SHOW_SIGNAL_GreenYellow);/*显示绿黄功能开关是否打开*/
 	UINT8 funSwitchALLCloseUseBlue = GetCiFunctionSwitchConfig(FUNC_SWITCH_ZX_ALLCLOSE_USEBLUE);/*杭德正线灭灯均转蓝灯功能开关*/
-	UINT8 ciType = GetLocalCiType();
+	UINT8 ciType = 0U;
+	UINT8 chSigBelongRtuId = 0U;
+	chSigBelongRtuId = GetSignalBelongVirCiId(signalId);
+	ciType = GetLocalVirCiType(chSigBelongRtuId);
 	switch (drvColor)
 	{
 	case SIGNAL_DRIVECOLOUR_RED:/*红*/
@@ -247,6 +250,15 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 	UINT16 deviceSum = 0u;
 	UINT16 kqChangeCommand = 0u;/*控权切换命令*/
 	UINT8 chCurSystemAreaState = 0u; /*主备用模式*/
+	UINT8 chMainCotrolOCId = 0U;
+	UINT8 chControlCmd = 0U;
+	UINT8 chControlCmdNum = 0u;
+	UINT32 cmdIndex = 0u;
+	UINT8 chOcOutControlCmd = 0u;
+	UINT8 chOcFindPostionCmd = 0u;
+	UINT8 chLocalCiOCSswitch = 0u;
+
+	chLocalCiOCSswitch = GetLocalCiOCSswitch();
 #if 0
 	QueueClear(CiToOcDataQueue);	/*清队列*/
 #endif
@@ -325,7 +337,25 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 					ShortToChar(pOcData->OcDevices[kk].DeviceId, &Ci2OcDataBuffer[ii]);
 					ii += 2u;
 					drvPos = GetSwitchDrivePostion(pOcData->OcDevices[kk].DeviceId);
-					drvCmd = ConvertSwitchDrvPosToSwDrvCmd(drvPos);
+					chMainCotrolOCId = GetSwitchMainCotrolOCId(pOcData->OcDevices[kk].DeviceId);
+
+				
+					if ((chMainCotrolOCId == pOcData->OcId)||(OC_S_OFF == chLocalCiOCSswitch))
+					{/*当前有主控OC或OC-S功能关闭*/
+						drvCmd = ConvertSwitchDrvPosToSwDrvCmd(drvPos);
+					}
+					else
+					{/*有OC-S且当前无主控，需寻表*/
+						drvCmd = OC_SWITCH_DRIVE_POS_KEEP;/*保持*/
+
+						chOcOutControlCmd = GetSwitchThisOcOutControlCmd(pOcData->OcDevices[kk].DeviceId, (UINT8)pOcData->OcId);
+						
+						if (MAIN_CONTROL == chOcOutControlCmd)
+						{
+							chOcFindPostionCmd = GetSwitchThisOcFindPostionCmd(pOcData->OcDevices[kk].DeviceId, (UINT8)pOcData->OcId);
+							drvCmd = ConvertSwitchFindPosToSwFindCmd(chOcFindPostionCmd);	
+						}
+					}
 					ShortToChar(drvCmd, &Ci2OcDataBuffer[ii]);
 					ii += 2u;
 					break;
@@ -636,6 +666,51 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 			ii += ciSorToOcIdx;
 		}
 
+		if (CI_SUCCESS == retVal)
+		{
+			cmdIndex = ii;
+			ii += 1u;
+			for (kk = 0u; kk < pOcData->OcDeviceNum; kk++)/*遍历设备*/
+			{
+				switch (pOcData->OcDevices[kk].DeviceType)
+				{
+					case CI_DEVICE_TYPE_SWITCH:/*道岔设备*/
+					{
+						ShortToChar(pOcData->OcDevices[kk].DeviceId, &Ci2OcDataBuffer[ii]);
+						ii += 2u;
+						if (OC_S_ON == chLocalCiOCSswitch)
+						{/*OS-S开关打开*/
+							chControlCmd = GetSwitchThisOcOutControlCmd(pOcData->OcDevices[kk].DeviceId, (UINT8)pOcData->OcId);
+							if ((MAIN_CONTROL == chControlCmd) || (STANDBY_CONTROL == chControlCmd))
+							{
+								Ci2OcDataBuffer[ii] = chControlCmd;
+							}
+							else
+							{
+								Ci2OcDataBuffer[ii] = STANDBY_CONTROL;
+							}
+						}
+						else
+						{/*OC-S开关关闭*/
+							Ci2OcDataBuffer[ii] = NO_CONTROL_FUN;
+						}
+						ii += 1u;
+
+						chControlCmdNum++;
+						break;
+					}
+					default:
+					{/*无执行*/
+						break;
+					}
+				}
+			}
+		    
+			Ci2OcDataBuffer[cmdIndex]= chControlCmdNum;/*设备数量*/
+		}
+
+
+
 #if 0 /*屏蔽型式实验，以后有需要再打开*/
 		if (curCycleNum == xingshiTestStartCycle && 1 == xingshiTestStart)
 		{
@@ -1124,6 +1199,10 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 	UINT32 dwUpToMainCyc = 0U;/*本机升主机周期号*/
 	UINT32 CiRecvOcSN = 0U;/*同步的CI数据中OC周期号*/
 	HLHTHeadContextStru* pstrHlhtHeadCtx = NULL;  /*CI同步的互联互通报文头上下文数据*/
+	UINT8 dwMainStandbyState = 0U;
+	UINT8 chSwitchBelongOThisOCRet = 0U;
+
+
 	(void)CommonMemSet(pTmpOcToCiData, (UINT32)sizeof(OcToCiOriginDataStruct),0U, (UINT32)sizeof(OcToCiOriginDataStruct));/*清内存，防止脏数据*/
 	chMainWorckMode = GetLocalCiBackUpPattern();
 	dwUpToMainCyc = GetSystemUpdateMainUseCycNum();
@@ -1184,7 +1263,7 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 		localCiId = GetSystemParaLocalCiId();	/*获取联锁ID*/
 		wCiName = (CI_SYSTEM_TYPE_RCI)* 256U + localCiId;
 		
-		headRet = HLHTRecvCommonPacketHeadCheck(ocName, wCiName, CI_OC_INTERFACE_INFOTYPE, CI_OC_PRTCL_VER, &hlhtGalHead, &errCode, 0u, CI_SYSTEM_TYPE_OC);
+		headRet = HLHTRecvCommonPacketHeadCheck(ocName, wCiName, CI_OC_INTERFACE_INFOTYPE, (UINT8)CI_OC_PRTCL_VER, &hlhtGalHead, &errCode, 0u, CI_SYSTEM_TYPE_OC);
 		transmitBadEnsureTime = GetCiAndOcTransmitBadEnsureTime();
 		debug_infor_printf((const)"\nOC %d GAL Check Result:%d errCode:%d\n", systemId, headRet, errCode);	/*0x55正确，0xaa错误，0x33初始通信帧*/
 
@@ -1224,7 +1303,7 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 			{
 				chUsableCycCheck = CI_SUCCESS;
 			}
-			if (0U < ocInfoRemainValidity)
+			if (0 < ocInfoRemainValidity)
 			{
 				/*解析应用数据*/
 				wApplyDataLenth = ShortFromChar(&dataBuf[ii]);/*应用层数据长度*/
@@ -1253,9 +1332,9 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 						{
 							tmpDeviceId = ShortFromChar(&dataBuf[ii]); /*设备Id 2B*/
 							ii += 2u;
-							chDevBelongOC = (UINT8)GetSwitchBelongOcId(tmpDeviceId);
+							chSwitchBelongOThisOCRet = (UINT8)GetSwitchWhetherBelongThisOc(tmpDeviceId, systemId);
 							chDevBelongCI = GetSwitchBelongCiId(tmpDeviceId);
-							if ((chDevBelongOC != systemId)||(chDevBelongCI != localCiId))
+							if ((CI_SUCCESS != chSwitchBelongOThisOCRet)||(chDevBelongCI != localCiId))
 							{
 								retVal = CI_ERROR;
 								debug_infor_printf((const)"Swicth devId:%d  Belong OC/CI Error\n", tmpDeviceId);
@@ -1319,20 +1398,39 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 										{
 											switchBoardCheck = CI_SUCCESS; /*存在正常板卡*/
 										}
-									}
-									pTmpOcToCiData->OcDevices[j].DeviceType = tmpDeviceType; /*设备类型 1B*/
-									pTmpOcToCiData->OcDevices[j].DeviceId = tmpDeviceId; /*设备Id 2B*/
-									pTmpOcToCiData->OcDevices[j].DeviceState = tmpDeviceState; /*设备状态 1B*/
+										dwMainStandbyState = dataBuf[ii++];/*板卡主控状态*/
+										if ((MAIN_CONTROL == dwMainStandbyState) || (STANDBY_CONTROL == dwMainStandbyState) || (NO_CONTROL_FUN == dwMainStandbyState))
+										{
+											pTmpOcToCiData->OcDevices[j].MainStandbyState[k] = dwMainStandbyState;
+											
+										}
+										else
+										{
+											retVal = CI_ERROR;
+											debug_infor_printf((const)"Swicth devId %d Board ControlMode ill, mode: %d\n", tmpDeviceId, dwMainStandbyState);
+											break;
+										}
 
-									if (CI_SUCCESS == switchBoardCheck) /*0为正常 存在正常板卡*/
+									}
+									if (CI_SUCCESS == retVal)
 									{
+										pTmpOcToCiData->OcDevices[j].DeviceType = tmpDeviceType; /*设备类型 1B*/
+										pTmpOcToCiData->OcDevices[j].DeviceId = tmpDeviceId; /*设备Id 2B*/
 										pTmpOcToCiData->OcDevices[j].DeviceState = tmpDeviceState; /*设备状态 1B*/
-									}
-									else
-									{
-										/*发送ats报警*/
 
+										if (CI_SUCCESS == switchBoardCheck) /*0为正常 存在正常板卡*/
+										{
+											pTmpOcToCiData->OcDevices[j].DeviceState = tmpDeviceState; /*设备状态 1B*/
+										}
+										else
+										{
+											/*发送ats报警*/
+
+										}
 									}
+
+									
+
 								}
 								else
 								{
@@ -2072,10 +2170,10 @@ INT16 GetIndexBySignalId(UINT16 sigId)
 
 /*
 * 功能描述： 通过道岔id获取索引
-* 参数说明： void
-* 返回值  ： void      
+* 参数说明： UINT16 swId 道岔ID,UINT8 ocId OCID
+* 返回值  ： 索引      
 */
-INT16 GetIndexBySwitchId(UINT16 swId)
+INT16 GetIndexBySwitchId(UINT16 swId,UINT8 ocId)
 {
 	INT16 retIndex = -1;
 
@@ -2083,7 +2181,7 @@ INT16 GetIndexBySwitchId(UINT16 swId)
 
 	for (i=0u;i<m_SwitchNum;i++)
 	{
-		if (m_Switches[i].DeviceId == swId)
+		if ((m_Switches[i].DeviceId == swId)&&(ocId == (UINT8)m_Switches[i].OcId))
 		{
 			retIndex = (INT16)i;
 			break;
@@ -2162,35 +2260,49 @@ void InitOcSignals(void)
 */
 void InitOcSwitchs(void)
 {
-	
 	UINT16 i = 0u;
+	UINT8 j = 0u;
 	UINT8 k = 0U;
 	SwitchConfigDataStruct *pSwitch = NULL;
 	UINT8 localCi = 0u;
 	localCi =GetSystemParaLocalCiId();
 	m_SwitchNum = 0u;
 	pSwitch = GetSwitchConfigData();
-	for (i=0u;i<SWITCH_SUM_MAX;i++)
+
+	if (NULL != pSwitch)
 	{
-		if ((CI_SWITCH_MAX == m_SwitchNum) || (NULL == pSwitch))
+		for (i = 0u; i < SWITCH_SUM_MAX; i++)
 		{
-			/*超出索引，给出调试警告信息*/
-			debug_infor_printf((const)"InitOcSwitchs():error");
-			break;
-		}
-		if ((0u < pSwitch[i].SwitchId) && (0u < pSwitch[i].BelongOcId)&&(localCi == pSwitch[i].BelongCiId))
-		{
-			m_Switches[m_SwitchNum].DeviceId = pSwitch[i].SwitchId;
-			m_Switches[m_SwitchNum].DeviceType = OC_DEVICE_TYPE_SWITCH;
-			m_Switches[m_SwitchNum].DeviceState = OC_SWITCH_POSITION_SIKAI;
-			m_Switches[m_SwitchNum].BoardNum = 0U;
-			for (k = 0U; k < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; k++)
-			{
-				m_Switches[m_SwitchNum].BoardState[k] = 0xffU;
-				m_Switches[m_SwitchNum].BoardAddr[k] = 0U;
+			for (j = 0u; j < pSwitch[i].chSwitchBelongOcNum; j++)
+			{/*线性存储2个OC的临时数据*/
+				if (CI_SWITCH_MAX == m_SwitchNum)
+				{
+					/*超出索引，给出调试警告信息*/
+					debug_infor_printf((const)"InitOcSwitchs():error");
+					break;
+				}
+				if ((0u < pSwitch[i].SwitchId) && (0u < pSwitch[i].BelongOcId) && (localCi == pSwitch[i].BelongCiId))
+				{
+					m_Switches[m_SwitchNum].DeviceId = pSwitch[i].SwitchId;
+					m_Switches[m_SwitchNum].DeviceType = OC_DEVICE_TYPE_SWITCH;
+					m_Switches[m_SwitchNum].DeviceState = OC_SWITCH_POSITION_SIKAI;
+					m_Switches[m_SwitchNum].BoardNum = 0U;
+					for (k = 0U; k < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; k++)
+					{
+						m_Switches[m_SwitchNum].BoardState[k] = 0xffU;
+						m_Switches[m_SwitchNum].BoardAddr[k] = 0U;
+						m_Switches[m_SwitchNum].MainStandbyState[k] = 0U;
+					}
+					m_Switches[m_SwitchNum].OcId = pSwitch[i].belongOCConfigData[j].OcId;
+					m_SwitchNum++;
+				}
+			}
+
+			if (CI_SWITCH_MAX == m_SwitchNum)
+			{
+				debug_infor_printf((const)"InitOcSwitchs():error1");
+				break;
 			}
-			m_Switches[m_SwitchNum].OcId = pSwitch[i].BelongOcId;
-			m_SwitchNum++;
 		}
 	}
 }
@@ -2249,6 +2361,8 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 	UINT8 chOcId = 0U;
 	UINT8 chOcBelongCI = 0U;/*OC所属联锁*/
 	UINT8  chLocalCiId = GetSystemParaLocalCiId();
+	UINT8 chSwitchszPlusBoxId = 0U;
+
 	for (i=0U;i<m_OcToCiOrginDataNum;i++)/*遍历OC*/
 	{
 		chOcId = (UINT8)m_OcToCiOrginDataArr[i].OcId & 0xFFU;
@@ -2264,7 +2378,7 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 					if (pOcDevice->DeviceType == OC_DEVICE_TYPE_SIGNAL)
 					{/*信号机*/
 						ind = GetIndexBySignalId(pOcDevice->DeviceId);
-						if ((ind >=0) && (OC_DEVICE_TYPE_SIGNAL == pOcDevice->DeviceType))
+						if (ind >=0) 
 						{
 							if ((m_Signals[ind].OcId == pOcDevice->OcId) &&
 								(m_Signals[ind].DeviceId == pOcDevice->DeviceId))
@@ -2289,7 +2403,7 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 					}
 					else
 					{/*道岔*/
-						ind = GetIndexBySwitchId(pOcDevice->DeviceId);
+						ind = GetIndexBySwitchId(pOcDevice->DeviceId, pOcDevice->OcId);
 						if ((ind >=0) && (OC_DEVICE_TYPE_SWITCH == pOcDevice->DeviceType))
 						{
 							if ((m_Switches[ind].OcId == pOcDevice->OcId) &&
@@ -2302,6 +2416,8 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 								{
 									m_Switches[ind].BoardAddr[k] = pOcDevice->BoardAddr[k];
 									m_Switches[ind].BoardState[k] = pOcDevice->BoardState[k];
+
+
 								}
 								/* 保存数据 */
 								m_Switches[ind].chSwitchIncldeZzjNum = pOcDevice->chSwitchIncldeZzjNum;
@@ -2309,6 +2425,36 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 								{
 									m_Switches[ind].szSwitchIncldeZzjState[k] = pOcDevice->szSwitchIncldeZzjState[k];
 								}
+
+								for (k = 0U; k < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; k++)
+								{/*给所有OC设置主控状态*/
+									m_Switches[ind].MainStandbyState[k] = pOcDevice->MainStandbyState[k];
+								}
+
+								chSwitchszPlusBoxId = GetSwitchszPlusBoxId(m_Switches[ind].DeviceId,(UINT8)m_Switches[ind].OcId);
+								for (k = 0U; k < m_OcToCiOrginDataArr[i].chPbNum; k++)
+								{
+									if (chSwitchszPlusBoxId == m_OcToCiOrginDataArr[i].szPlusBox[k].chPbId)
+									{
+										if (SWITCH_BOX_NORMAL == m_OcToCiOrginDataArr[i].szPlusBox[k].chAsState)
+										{/*正常*/
+											SetSwitchOcPlusBoxSateState(m_Switches[ind].DeviceId, (UINT8)m_Switches[ind].OcId, SWITCH_BOX_NORMAL);
+										}
+										else
+										{
+											SetSwitchOcPlusBoxSateState(m_Switches[ind].DeviceId, (UINT8)m_Switches[ind].OcId, SWITCH_BOX_FAULT);
+										}
+										break;
+									}
+								}
+
+								/*将板卡故障状态导入*/
+								for (k = 0U; k < m_Switches[ind].BoardNum; k++)
+								{
+									SetSwitchThisOCBoardState(m_Switches[ind].DeviceId, (UINT8)m_Switches[ind].OcId, m_Switches[ind].BoardAddr[k], m_Switches[ind].BoardState[k]);
+									
+								}
+
 							}
 							else
 							{
@@ -2352,6 +2498,10 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 
 			}
 
+
+			
+
+
 		}
 		else
 		{
@@ -2864,9 +3014,42 @@ UINT8 OcInputSignalStateCheck(const UINT8 chInput)
 			break;
 		default:
 			retVal = CI_ERROR;
+			break;
 	}
 	return retVal;
 }
+/*
+* 功能描述： 把道岔寻表状态转化为道岔寻表命令
+* 参数说明：
+*		输入参数：
+*			UINT8 drvColor：道岔寻表位置
+* 返回值  ： 0:道岔驱动命令转化失败
+*			 1:道岔寻表命令
+* add by mpt 20260330
+*/
+UINT16 ConvertSwitchFindPosToSwFindCmd(UINT8 chFindPos)
+{
+	UINT16 retDrvCmd = 0u;
+	switch (chFindPos)
+	{
+	case FIND_DINGWEI_CMD:
+		retDrvCmd = OC_SWITCH_FIND_DINGWEI;
+		break;
+	case FIND_FANWEI_CMD:
+		retDrvCmd = OC_SWITCH_FIND_FANWEI;
+		break;
+	case INIT_FIND_CMD:
+		retDrvCmd = OC_SWITCH_ININ_FIAND;
+		break;
+	case NO_FIND_CMD:
+		retDrvCmd = OC_SWITCH_DRIVE_POS_KEEP;
+		break;		
+	default:
+		retDrvCmd = OC_SWITCH_DRIVE_POS_KEEP;
+		break;
+	}
+	return retDrvCmd;
+}
 
 
 

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

@@ -55,7 +55,7 @@
 #define MAX_OC_PLUS_BOX_NUM	((UINT16)3)		/*一个OC支持最大执行电插箱（可达最大值）*/
 #define MAX_OC_DEVICE_SWAP_MAX	((UINT16)83)	/*一个OC最大切系板卡数量(MAX_OC_DEVICE_NUM/2)（不可达最大值） */
 #define MAX_OC_SWITCH_INCLUDE_ZZJ_NUM	((UINT16)10)		/*一个道岔支持最大转辙机个数（可达最大值）*/
-#define MAX_OC_SWITCH_INCLUDE_BOARD_NUM	((UINT8)10)		/*一个道岔支持最大板卡数量（不可达最大值）*/
+
 
 #define Max_OC_GD_NUM		((UINT16)252) /*一个oc支持最大多少个轨道区段（不可达最大值）*/
 #define MAX_OC_DEVICE_PSD_MAX	((UINT8)2)	/*一个OC最大屏蔽门数量（可达最大值）*/
@@ -95,6 +95,7 @@ typedef struct s_OcDevState
 	UINT8 BoardNum; /*板卡数量*/
 	UINT8 BoardAddr[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*板卡地址*/
 	UINT8 BoardState[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*板卡状态 正常0x0000 错误发错误码*/
+	UINT8 MainStandbyState[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*主备状态*/
 }OcDeviceStruct;
 
 typedef struct s_OcDoBoardData
@@ -436,12 +437,10 @@ INT16 GetIndexBySignalId(UINT16 sigId);
 
 /*
 * 功能描述： 通过道岔id获取索引
-* 参数说明： 
-*	Id：道岔索引
-* 返回值  ： 
-*	Int16:道岔Id
+* 参数说明： UINT16 swId 道岔ID,UINT8 ocId OCID
+* 返回值  ： 索引
 */
-INT16 GetIndexBySwitchId(UINT16 swId);
+INT16 GetIndexBySwitchId(UINT16 swId, UINT8 ocId);
 
 /*
 * 功能描述： 通过轨道id获取索引
@@ -513,7 +512,16 @@ UINT8 OcInputStateCheck(const UINT8 chInput, const UINT8 chOtherValid);
 * 返回值  ： CI_ERROR CI_SUCCESS
 */
 UINT8 OcInputSignalStateCheck(const UINT8 chInput);
-
+/*
+* 功能描述： 把道岔寻表状态转化为道岔寻表命令
+* 参数说明：
+*		输入参数：
+*			UINT8 drvColor：道岔寻表位置
+* 返回值  ： 0:道岔驱动命令转化失败
+*			 1:道岔寻表命令
+* add by mpt 20260330
+*/
+UINT16 ConvertSwitchFindPosToSwFindCmd(UINT8 chFindPos);
 #ifdef __cplusplus
 }
 #endif

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

@@ -364,7 +364,7 @@ UINT8 ParseTmcToTiocDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 		retVal = CI_ERROR;
 	}
 
-	if ((CI_ERROR == retVal) || (0u == galHeadSaved))
+	if ((CI_ERROR == retVal) && (0u == galHeadSaved))
 	{
 		/*清除通用报文头*/
 		ClearHlhtHeadCtx(CI_SYSTEM_TYPE_TMC, systemId);

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

@@ -36,6 +36,8 @@
 #include "../IO/DeviceRelayDataProcess.h"
 #include "dquIdmapQuery.h"
 #include "../Section/LogicSectionConfigDataManage.h"
+#include "AxisAssertDefine.h"
+#include "AxisAssertManageAPI.h"
 
 
 #define CI_PSD_COMM_STATE_GOOD  ((UINT8)0x55)
@@ -53,7 +55,7 @@
 
 #define CI_VOBC_NO_LOCK				((UINT8)0x00)		  /*CI给后备通道发站外直轨锁闭方向，默认值*/
 
-#define CI_VOBC_INTERFACE_INFOTYPE    ((UINT16)0x0206) /*互联互通CI_VOBC接口信息类型*/
+#define CI_VOBC_INTERFACE_INFOTYPE           ((UINT16)0x0206) /*互联互通CI_VOBC接口信息类型*/
 #define CI_VOBC_BACKUP_INTERFACE_INFOTYPE    ((UINT16)0x0402) /*后备模式的CI_VOBC接口信息类型*/
 #define VOBC_CI_INFO_TYPE_PSD_CONTROL ((UINT16)0x0201) /*VOBC_CI屏蔽门控制报文类型*/
 #define VOBC_CI_INFO_TYPE_BACKUP ((UINT16)0x0308) /*VOBC_CI备用通道报文类型*/
@@ -73,6 +75,10 @@
 #define CI_VOBC_BACKUP_STATE_INFO    ((UINT16)0x0211) /*CI=>VOBC后备运行状态信息*/
 #define VOBC_CI_INFO_TYPE_BACKUU_CONTROL    ((UINT16)0x0212) /*VOBC=>CI后备运行控制信息*/
 
+/*VOBC_CI点连式信息帧-目前仅互联互通接口具备，帧类型与全自动运行洗车重复，若需要适配其他接口，需要重新排帧类型*/
+#define VOBC_CI_INFO_TYPE_BLOCLINK    ((UINT16)0x020b) /*VOBC_CI点连式信息帧类型*/
+#define CI_VOBC_INFO_TYPE_BLOCLINK    ((UINT16)0x020c) /*CI_VOBC点连式信息帧类型*/
+
 #define VOBC_CI_GAP_DETECT_CMD_START   ((UINT8)0x55)         /*VOBC2CI启动间隙探测命令*/
 #define VOBC_CI_GAP_DETECT_CMD_STOP    ((UINT8)0xAA)         /*VOBC2CI停止间隙探测命令*/
 #define VOBC_CI_GAP_DETECT_CMD_DEFAULT    ((UINT8)0xFF)         /*VOBC2CI默认间隙探测命令*/
@@ -106,7 +112,8 @@
 
 #define VOBC_RC_INTERFACE_INFOTYPE	 ((UINT16)0x0217U)		/*VOBC-RC接口，RC-VOBC接口*/
 #define VOBC_RC_INFO_STATE	 ((UINT16)0x0201U)		/*VOBC->RC控制信息，周期发送*/
-#define RC_VOBC_HEART_FRAME	 ((UINT16)0x0202U)		/*RC->VOBC心跳信息，周期发送*/
+#define RC_VOBC_HEART_FRAME	 ((UINT16)0x0202U)		/*RC->VOBC心跳信息，非周期发送*/
+#define RC_VOBC_STATE_FRAME	 ((UINT16)0x0205U)		/*RC->VOBC设备状态信息，周期发送*/
 
 
 #define CI_IVOC_PRTCL_VER		((UINT8)0x01U)					/*CI_VOBC协议版本号*/
@@ -145,9 +152,9 @@
 #define IVOC_CI_LOGOUT_NORMAL			((UINT8)0x00U)		  /*IVOC到IC 正常注销*/
 #define IVOC_CI_LOGOUT_SLEEP			((UINT8)0x01U)		  /*IVOC到IC 休眠注销*/
 
-#define VOBC_CI_DIR_UP				((UINT8)0x55U)		  /*IVOC到IC 上行*/
-#define VOBC_CI_DIR_DOWN			((UINT8)0xAAU)		  /*IVOC到IC 下行*/
-#define VOBC_CI_DIR_DEF				((UINT8)0xFFU)		  /*IVOC到IC 默认*/
+#define VOBC_CI_DIR_UP				((UINT8)0x55U)		  /*VOBC-CI 上行*/
+#define VOBC_CI_DIR_DOWN			((UINT8)0xAAU)		  /*VOBC-CI 下行*/
+#define VOBC_CI_DIR_DEF				((UINT8)0xFFU)		  /*VOBC-CI 默认*/
 
 #define CI_IVOC_SWITCH_POSTION_DING		((UINT8)0x55U)		  /*CI到IVOC道岔定位状态*/
 #define CI_IVOC_SWITCH_POSTION_FAN		((UINT8)0xAAU)		  /*CI到IVOC道岔反位状态*/
@@ -225,6 +232,7 @@
 #define IVOC_CI_FLOODGATE_CLOSE_ALLOW_SUM		((UINT8)50U)	/*IVOC到CI防淹门关闭允许的数量最大值*/
 #define IVOC_CI_GARAGEDOOR_CLOSE_ALLOW_SUM		((UINT8)50U)	/*IVOC到CI车库门关闭允许的数量最大值*/
 #define CI_IVOC_YUXIANOPEN_ROUTE_MAX		((UINT8)200U)		  /*CI到IVOC预先开放进路最大值*/
+#define CI_IVOC_COM_ERR_RC_NUM_MAX		  ((UINT8)5U)		  /*CI到IVOC通信故障RC最大值*/
 
 #define CI_IVOC_URGENT_YES		        ((UINT8)0x55U)		  /*CI到IVOC 紧急制动状态有效*/
 #define CI_IVOC_URGENT_NO		        ((UINT8)0xaaU)		  /*CI到IVOC 紧急制动状态无效*/
@@ -243,6 +251,23 @@
 #define  TRAIN_LEN_MIN        1000U  /*最小车长*/
 #define  TRAIN_LEN_MAX        50000U  /*最大车长*/
 
+#define VOBC_CI_BLOCLINK_BLOCK_CTRL       ((UINT8)0x01)	  /*点式列车控制级别*/
+#define VOBC_CI_BLOCLINK_CI_CTRL          ((UINT8)0x02)	  /*联锁控制级别*/
+#define VOBC_CI_BLOCLINK_CI_DEFAULT       ((UINT8)0xFF)	  /*默认值*/
+
+#define CI_VOBC_SWITCH_MAX				  ((UINT8)20U)    /*CI-VOBC点连式道岔数量最大值*/
+#define CI_VOBC_OTHER_EQUIPMENT_MAX		  ((UINT8)10U)    /*CI-VOBC点连式其他设备数量最大值*/
+
+#define CI_VOBC_XIANSU_NOT				  ((UINT8)0xaaU)  /*CI-VOBC点连式未设置临时限速*/
+#define CI_VOBC_XIANSU_YES				  ((UINT8)0x55U)  /*CI-VOBC点连式已设置临时限速*/
+
+#define CI_VOBC_DESTINATION_TYPE_RETURN   ((UINT8)0xaaU)  /*CI-VOBC点连式目的地属性-折返*/
+#define CI_VOBC_DESTINATION_TYPE_LIECHE   ((UINT8)0x55U)  /*CI-VOBC点连式目的地属性-直通*/
+
+#define CI_VOBC_FLOOD_STATE_OPEN		  ((UINT8)0xaaU)  /*CI-VOBC点连式防淹门开启锁定状态且无关门请求*/
+#define CI_VOBC_FLOOD_STATE_CLOSE         ((UINT8)0x55U)  /*CI-VOBC点连式防淹非开启锁定状态或有关门请求*/
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -286,6 +311,18 @@ typedef struct S_IvocToCiCmdStruct
 	UINT16 wCmdDevId[IVOC_CI_CMD_DEVICE_MAX];				/* 命令设备ID数组*/
 }IvocCmdStru;
 
+/*点连式信息*/
+typedef struct S_VobcToCiBlocLinkStruct
+{
+	UINT8 chBlocLinkTrainLevel;             /*点连式运行级别*/
+	UINT32 chBlocLinkCycle;					/*点连式通信周期*/
+	UINT8 chTrainDirection;                 /*运行方向*/
+	UINT16  wTrainMaxSafeHeadLink;			/*列车最大安全前端所处Link*/
+	UINT32  dwTrainMaxSafeHeadOffset;		/*列车最大安全前端偏移量*/
+	UINT16	wTrainMinSafeTailLink;			/*列车最小安全后端所处link*/
+	UINT32	dwTrainMinSafeTailOffset;		/*列车最小安全后端偏移量*/
+}VobcToCiBlocLinkStruct;
+
 /*与联锁通信的Vobc信息*/
 typedef struct S_VobcToCiDataStruct
 {
@@ -295,6 +332,7 @@ typedef struct S_VobcToCiDataStruct
 	UINT8  washTrainRequest;                                 /*洗车请求信息*/
 	UINT8 headWashStopSteadyInfo;                            /*头端洗位停稳信息，洗车停稳1*/
 	UINT8 tailWashStopSteadyInfo;                            /*尾端洗位停稳信息，洗车停稳2*/
+	UINT8 couplingWashStopSteadyInfo;                        /*联挂端洗位停稳信息，洗车停稳3*/
 	UINT8 passWashMachineRequest;                            /*通过洗车机请求信息*/
 	UINT8 washPauseRequest;									 /*暂停洗车请求*/
 	UINT8 chWashMachineWorkMode;							 /*洗车机工作模式设置*/
@@ -309,7 +347,9 @@ typedef struct S_VobcToCiDataStruct
 	UINT16 vobcLogId;										 /*互联互通4IP VOBC1端或2端标识*/
 	VobcToCiPsdDataStruct PsdData[VOBC_TO_CI_TRAIN_PSD_MAX]; /*关联屏蔽门数据*/
 	UINT32 signalID;										 /*VOBC->CI信号机ID*/
-	
+
+	VobcToCiBlocLinkStruct strBlocLinkData;                     /*VOBC->CI点连式信息*/
+
 	/*add by qw.liu 2022-02-24 增加车车新接口字段*/
 	UINT8 chTrainLevel;										/*列车运行级别:01:VBTC;02:ITC;03:UR;04:ABL*/
 	UINT8 chTrainMode;						/*列车模式*/
@@ -809,6 +849,32 @@ UINT8 GetRecvVobcControlMode(const UINT16 wVobcId);
 * Create： fan 20250725
 */
 UINT8 PackCiToIvocOpenRouteNotNearInfo(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
+/*
+* 功能描述： 组VOBC点连式数据
+* 参数说明： UINT8* CiToVobcDataBuffer 存放信息的buffer
+*			 UINT16* ii 偏移量
+*            VobcToCiDataStruct *vobcToCiDataStru VOBC-CI数据
+* 返回值  ： 无
+* Create： lyj 20260314
+*/
+void PackVobcBlocLinkData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcToCiDataStruct* vobcToCiDataStru);
+/*
+* 功能描述： 解析VOBC点连式数据
+* 参数说明： const UINT8* dataBuf, 数据缓冲区
+*            const UINT16 dataLength, 数据长度
+*			 VobcToCiDataStruct* vobcToCiDataStru VOBC到CI结构体数据
+* 返回值  ： 解析结果
+* Create： lyj 20260314
+*/
+UINT8 ParseVobcBlocLinkData(const UINT8* dataBuf, const UINT16 dataLength, VobcToCiDataStruct* vobcToCiDataStru);
+/*
+* 功能描述：检查设备是否已经添加
+* 参数说明：const UINT16 wCheckDeviceId 检查设备ID
+*           const UINT16* pDeviceBuf    数组
+*           const UINT8 wDeviceNum      数量
+* 返回值  ：检查结果
+*/
+UINT8 CheckRepeatData(const UINT16 wCheckDeviceId, const UINT16* pDeviceBuf, const UINT8 wDeviceNum);
 #ifdef __cplusplus
 }
 #endif

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

@@ -28,6 +28,11 @@ UINT8 lineIdentity = 0u;	 /*
 
 ZcToCiDynamicDataStruct gZcToCiDymDataStru = { 0U };  /*ZC动态数据结构体*/
 
+UINT8 gCbtcCrossNumZc = 0u;													/*主控CBTC列车跨压数量*/
+CbtcCrossStructZC gCbtcCrossStructZc[ALL_CBTC_CROSS_SUM_MAX] = { 0u };		/*主控CBTC列车跨压信息*/
+
+static UINT8 ParseZcCbtcCrossData(UINT8* pDataBuf, UINT16 dataLen);
+static UINT16 PackRcTacsCrossData(UINT8 *pDataBuf);
 
 /*
 * 功能描述： 解析ZC单帧数据
@@ -41,8 +46,6 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 {
 	UINT8* sourceId = NULL;		/*源ID*/
 	UINT16 ii = 0u;
-	UINT16 jj = 0u;
-	UINT8 kk = 0u;
 	UINT8 retVal = CI_SUCCESS;
 	UINT32 dwStep = 0U;
 	UINT8 galHeadSaved = 0u;	/*通用头是否已保存标志，1保存；0未保存*/
@@ -71,8 +74,8 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 	zcName = (CI_SYSTEM_TYPE_ZC)*256U + systemId;
 	ciName = (CI_SYSTEM_TYPE_RCI)*256U + localCiId;
 	curntCycleNo = Get2oo2CurCycleNum();
-	chDataType = GetLocalPublicDataType(); /*区分28.0.0.14与其他线路zc接口*/
-	if ((NULL != dataBuf) && (dataLength > 0u))
+	chDataType = GetLocalPublicDataType(); /*区分分支，与主线zc接口*/
+	if ((NULL != dataBuf) && (0U < dataLength))
 	{
 		sourceId = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_ZC);/*获取与本联锁通信的ZC的ID，目前一个联锁最多只与一个ZC通信*/
 
@@ -116,7 +119,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 			/*计算消息的时效性*/
 			zcInfoRemainValidity = HLHTCommonMsgRemainingValidity(GetCiAndZcTransmitBadEnsureTime(), curntCycleNo, GetSystemParaAppCycleTime(), hlhtGalHead.recvOppMsgSN, hlhtGalHead.crntOwnMsgSN, hlhtGalHead.preOwnMsgSN, hlhtGalHead.comPeriod);
 
-			if (zcInfoRemainValidity > 0)
+			if (0 < zcInfoRemainValidity)
 			{
 				if (0u == hlhtGalHead.totalDataLen)
 				{
@@ -132,157 +135,247 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 				{
 					/*报文有效，继续解析*/
 					retVal = CI_SUCCESS;
+					if (DATA_TYPE_MAIN_BRANCH == chDataType)
 					{
-						if (DATA_TYPE_NEW == chDataType)
+						while (wTmpDataLen < hlhtGalHead.totalDataLen)
 						{
-							while (wTmpDataLen < hlhtGalHead.totalDataLen)
+							/* 一条应用数据长度 */
+							wMsgLen = ShortFromChar(&dataBuf[ii]);
+
+							ii += 2u;
+							wTmpDataLen += 2U;
+							wTmpDataLen += wMsgLen;
+
+							if (0u == wMsgLen)
 							{
-								/* 一条应用数据长度 */
-								wMsgLen = ShortFromChar(&dataBuf[ii]);
-
+								; /* 无处理，继续解析下一包 */
+							}
+							else if (5u > wMsgLen)
+							{
+								/* 单包长度不对 */
+								retVal = CI_ERROR;
+								debug_infor_printf((const)"ParseZcToCiDataFrame_Error wMsgLen\n");
+							}
+							else
+							{
+								/* 获取报文类型 */
+								wMsgType = ShortFromChar(&dataBuf[ii]);
 								ii += 2u;
-								wTmpDataLen += 2U;
-								wTmpDataLen += wMsgLen;
 
-								if (0u == wMsgLen)
+								/* 跳过预留 */
+								ii += 2u;
+
+								wMsgCheckLen = wMsgLen - 4u;/*单个应用报文解析长度，删除预留2和类型2字节*/
+								switch (wMsgType)
 								{
-									; /* 无处理，继续解析下一包 */
-								}
-								else if (5u > wMsgLen)
-								{
-									/* 单包长度不对 */
+								case ZC_TO_TIOC_MASK_MSG:
+									/* 解析ZC-CI码位信息 */
+									retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
+									dwStep |= 0x10000U;
+									break;
+								case ZC_TO_TIOC_TSR_MSG:
+									/* 解析临时限速信息 */
+									retVal = ParseZcTsrData(&dataBuf[ii], wMsgCheckLen);
+									dwStep |= 0x01000U;
+									break;
+								case ZC_TO_TIOC_WLB_MSG:
+									/* 解析紧急制动信息 */
+									retVal = ParseZcEbData(&dataBuf[ii], wMsgCheckLen);
+									dwStep |= 0x00100U;
+									break;
+								case ZC_TO_TIOC_SNOW_MSG:
+									/*解析ZC-CI雨雪模式信息*/
+									retVal = ParseZcSnowData(&dataBuf[ii], wMsgCheckLen);
+									dwStep |= 0x00010U;
+									break;
+								case ZC_TO_TIOC_ITELINECUT_MSG:
+									/*解析ZC-CI的ITE切除信息*/
+									retVal = ParseZcIteCutData(&dataBuf[ii], wMsgCheckLen);
+									dwStep |= 0x00001U;
+									break;
+								case ZC_TO_RC_CBTC_CROSS_MSG:
+									/*解析ZC-CI的CBTC主控列车跨压信息*/
+									retVal = ParseZcCbtcCrossData(&dataBuf[ii], wMsgCheckLen);
+									dwStep |= 0x00002U;
+									break;
+								default:
 									retVal = CI_ERROR;
-									debug_infor_printf((const)"ParseZcToCiDataFrame_Error wMsgLen\n");
-								}
-								else
-								{
-									/* 获取报文类型 */
-									wMsgType = ShortFromChar(&dataBuf[ii]);
-									ii += 2u;
-
-									/* 跳过预留 */
-									ii += 2u;
-
-									wMsgCheckLen = wMsgLen - 4u;/*单个应用报文解析长度，删除预留2和类型2字节*/
-									switch (wMsgType)
-									{
-									case ZC_TO_TIOC_MASK_MSG:
-										/* 解析ZC-CI码位信息 */
-										retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
-										dwStep |= 0x10000U;
-										break;
-									case ZC_TO_TIOC_TSR_MSG:
-										/* 解析临时限速信息 */
-										retVal = ParseZcTsrData(&dataBuf[ii], wMsgCheckLen);
-										dwStep |= 0x01000U;
-										break;
-									case ZC_TO_TIOC_WLB_MSG:
-										/* 解析紧急制动信息 */
-										retVal = ParseZcEbData(&dataBuf[ii], wMsgCheckLen);
-										dwStep |= 0x00100U;
-										break;
-									case ZC_TO_TIOC_SNOW_MSG:
-										/*解析ZC-CI雨雪模式信息*/
-										retVal = ParseZcSnowData(&dataBuf[ii], wMsgCheckLen);
-										dwStep |= 0x00010U;
-										break;
-									case ZC_TO_TIOC_ITELINECUT_MSG:
-										/*解析ZC-CI的ITE切除信息*/
-										retVal = ParseZcIteCutData(&dataBuf[ii], wMsgCheckLen);
-										dwStep |= 0x00001U;
-										break;
-									default:
-										retVal = CI_ERROR;
-										break;
-									}
-
-									if (CI_SUCCESS == retVal)
-									{
-										/* 解析成功，跳过该数据包 */
-										ii += wMsgCheckLen;
-									}
-									else
-									{
-										debug_infor_printf((const)"ParseZcToCiDataFrame_Error Step: 0x%5x\n", dwStep);
-										ClearZcData(); /*任意步骤没解析通过则清空*/
-									}
-								}
-
-								if (CI_ERROR == retVal) /*解析失败*/
-								{
 									break;
 								}
+
+								if (CI_SUCCESS == retVal)
+								{
+									/* 解析成功，跳过该数据包 */
+									ii += wMsgCheckLen;
+								}
 								else
 								{
-									;  /*do nothing*/
+									debug_infor_printf((const)"ParseZcToCiDataFrame_Error Step: 0x%5x\n", dwStep);
+									ClearZcData(); /*任意步骤没解析通过则清空*/
 								}
 							}
-							if (CI_SUCCESS == retVal)
+
+							if (CI_ERROR == retVal) /*解析失败*/
 							{
-								/*校验数据长度*/
-								if (ii > dataLength)
+								break;
+							}
+							else
+							{
+								;  /*do nothing*/
+							}
+						}
+						if (CI_SUCCESS == retVal)
+						{
+							/*校验数据长度*/
+							if (ii > dataLength)
+							{
+								retVal = CI_ERROR;
+							}
+						}
+					}
+					else if (DATA_TYPE_28_BRANCH == chDataType)
+					{
+						/*28分支具备码位0201，0205*/
+						while (wTmpDataLen < hlhtGalHead.totalDataLen)
+						{
+							/* 一条应用数据长度 */
+							wMsgLen = ShortFromChar(&dataBuf[ii]);
+							ii += 2U;
+							wTmpDataLen += 2U;
+							wTmpDataLen += wMsgLen;
+
+							if (5U > wMsgLen)
+							{
+								/* 单包长度不对 */
+								retVal = CI_ERROR;
+								debug_infor_printf((const)"ParseZcToCiDataFrame_Error wMsgLen\n");
+							}
+							else
+							{
+								/* 获取报文类型 */
+								wMsgType = ShortFromChar(&dataBuf[ii]);
+								ii += 2U;
+								/* 跳过预留 */
+								ii += 2U;
+								wMsgCheckLen = wMsgLen - 4U;
+
+								switch (wMsgType)
 								{
+								case ZC_TO_TIOC_MASK_MSG:
+								{
+									/* 解析ZC-CI码位信息 */
+									retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
+								}
+								break;
+								case ZC_TO_TIOC_SNOW_MSG:
+								{
+									/*解析ZC-CI雨雪模式信息*/
+									retVal = ParseZcSnowData(&dataBuf[ii], wMsgCheckLen);
+								}
+								break;
+								default:
 									retVal = CI_ERROR;
+									break;
+								}
+
+								if (CI_SUCCESS == retVal)
+								{
+									/* 解析成功，跳过该数据包 */
+									ii += wMsgCheckLen;
+								}
+								else
+								{
+									debug_infor_printf((const)"ParseZcToCiDataFrame_Error MsgType: %d\n", wMsgType);
+									ClearZcData(); /*任意步骤没解析通过则清空*/
 								}
 							}
+
+							if (CI_ERROR == retVal) /*解析失败*/
+							{
+								break;
+							}
+							else
+							{
+								;  /*do nothing*/
+							}
+
+						}
+						if (CI_SUCCESS == retVal)
+						{
+							/*校验数据长度*/
+							if (ii > dataLength)
+							{
+								retVal = CI_ERROR;
+							}
+						}
+					}
+					else
+					{
+						/*23分支无报文类型、类型长度和预留，仅具备码位*/
+						wMsgCheckLen = hlhtGalHead.totalDataLen;
+						retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
+						if (CI_ERROR == retVal)
+						{
+							debug_infor_printf((const)"\nParseZcToCiDataFrame_Error MaskOnly\n");
+							ClearZcData(); /*没解析通过则清空*/
 						}
 						else
 						{
-							/*杭德线无报文类型、类型长度和预留，仅具备码位0201*/
-							wMsgCheckLen = hlhtGalHead.totalDataLen;
-							retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
-							if (CI_ERROR == retVal)
-							{
-								debug_infor_printf((const)"\nParseZcToCiDataFrame_Error MaskOnly\n");
-								ClearZcData(); /*没解析通过则清空*/
-							}
-							else
-							{
-								; /*继续*/
-							}
+							ii += wMsgCheckLen; /*继续*/
 						}
-
-						if (CI_SUCCESS == retVal)
+					}
+					if (CI_SUCCESS == retVal)
+					{
+						if (hlhtGalHead.totalDataLen != (ii - 31U))
 						{
-							/*更新通信周期*/
-							dwCurCyc = Get2oo2CurCycleNum();
-							funRet = SetCiTransmitRecvDataCycNum(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0], dwCurCyc);
-							if (CI_ERROR == funRet)
-							{/*更新周期失败*/
+							retVal = CI_ERROR;
+							debug_infor_printf((const)"\nParseZcToCiDataFrame_Error totalDataLen\n");
+						}
+						else
+						{
+							/*继续*/
+						}
+					}
+					if (CI_SUCCESS == retVal)
+					{
+						/*更新通信周期*/
+						dwCurCyc = Get2oo2CurCycleNum();
+						funRet = SetCiTransmitRecvDataCycNum(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0U], dwCurCyc);
+						if (CI_ERROR == funRet)
+						{/*更新周期失败*/
 
+						}
+						else
+						{/*更新周期成功*/
+
+						 /*更新与ZC通信状态：判断与ZC是否通信中断*/
+							funRet = UpdateCiTransmitState(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0U]);
+							if (CI_ERROR == funRet)
+							{
+								/*更新通信状态失败*/
 							}
 							else
-							{/*更新周期成功*/
-
-							 /*更新与ZC通信状态：判断与ZC是否通信中断*/
-								funRet = UpdateCiTransmitState(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0]);
-								if (CI_ERROR == funRet)
-								{
-									/*更新通信状态失败*/
-								}
-								else
-								{
-									/*更新通信状态成功*/
-								}
+							{
+								/*更新通信状态成功*/
 							}
-
-							/*数据经过校验，需要存储通用报文上下文*/
-							SetHLHTHeadCtxComPeriod(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.comPeriod);
-							SetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.crntOwnMsgSN);
-							SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.recvOppMsgSN);
-							SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.preOwnMsgSN);
-							SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ZC, systemId, curntCycleNo);
-							SetHLHTHeadCtxCiRcvLogId(CI_SYSTEM_TYPE_ZC, systemId, 0u);
-
-							galHeadSaved = 1;
 						}
+
+						/*数据经过校验，需要存储通用报文上下文*/
+						SetHLHTHeadCtxComPeriod(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.comPeriod);
+						SetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.crntOwnMsgSN);
+						SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.recvOppMsgSN);
+						SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.preOwnMsgSN);
+						SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ZC, systemId, curntCycleNo);
+						SetHLHTHeadCtxCiRcvLogId(CI_SYSTEM_TYPE_ZC, systemId, 0u);
+
+						galHeadSaved = 1U;
 					}
 				}
 			}
 		}
 		else if (HLHT_HEAD_INIT ==headRet)
 		{
-			if (curntCycleNo > 0u)/*判断序号大于0，因为把0当做无效序号*/
+			if (0U < curntCycleNo)/*判断序号大于0，因为把0当做无效序号*/
 			{
 				SetHLHTHeadCtxComPeriod(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.comPeriod);
 				SetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ZC, systemId, hlhtGalHead.crntOwnMsgSN);
@@ -291,7 +384,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 				SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ZC, systemId, curntCycleNo);
 				SetHLHTHeadCtxCiRcvLogId(CI_SYSTEM_TYPE_ZC, systemId, 0u);
 
-				galHeadSaved = 1;
+				galHeadSaved = 1U;
 			}
 
 			retVal = CI_ERROR;
@@ -1053,25 +1146,26 @@ UINT8 ParseZcSnowData(UINT8* dataBuf, UINT16 dataLen)
 */
 UINT8 PackCiToZcData( UINT8 deviceId)
 {
-	UINT8 localCi = 0u; /*本地联锁ID*/
-    UINT8 CiToZcDataBuffer[CI_TO_ZC_DATA_LEN_MAX] = {0u};/*CI到ZC组帧数组*/
-    UINT16 SendMaskSum = 0u;
-	UINT16 ii = 0u;
-	UINT32 ciEtcsId = 0u;	/*CI互联互通编号*/
-	UINT32 zcEtcsId = 0u;	/*ZC互联互通编号*/
-	UINT32 emapCheckVer = 0u;	/*共用数据校验信息*/
+	UINT8 localCi = 0U; /*本地联锁ID*/
+    UINT8 CiToZcDataBuffer[CI_TO_ZC_DATA_LEN_MAX] = {0U};/*CI到ZC组帧数组*/
+    UINT16 SendMaskSum = 0U;
+	UINT16 ii = 0U;
+	UINT32 ciEtcsId = 0U;	/*CI互联互通编号*/
+	UINT32 zcEtcsId = 0U;	/*ZC互联互通编号*/
+	UINT32 emapCheckVer = 0U;	/*共用数据校验信息*/
 	UINT8 retVal = CI_ERROR;
 	UINT32 curCycleNum = Get2oo2CurCycleNum();	/*联锁应用周期号*/
 	UINT32 appCycleTime = GetSystemParaAppCycleTime();	/*联锁应用周期*/
-	UINT8 ci_zcPrtclVersion = 0u;
-	UINT16 dstDevId = 0;
-	UINT8 outnetSafeSendRtn = 0u;
+	UINT8 ci_zcPrtclVersion = 0U;
+	UINT16 dstDevId = 0U;
+	UINT8 outnetSafeSendRtn = 0U;
 	UINT8 CIName2HlhtId = 0U;
 	UINT8 ZCName2HlhtId = 0U;
 	UINT8 CiEmapCheckVer = 0U;
-	UINT32 dwHlhtHSrcSN = 0u;
-	UINT32 dwHlhtHRcvSN = 0u;
+	UINT32 dwHlhtHSrcSN = 0U;
+	UINT32 dwHlhtHRcvSN = 0U;
 	UINT16 totallenIndex = 0U;
+	UINT16 wCrossFrameLen = 0U;
 	UINT8 chDataType = 0U;
 
 	localCi = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
@@ -1095,16 +1189,16 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 	if ((CI_SUCCESS == retVal))
 	{	
 		/*获取将要发送的码位字节数*/
-		if ((GetSendMaskSum(CI_SYSTEM_TYPE_ZC) % 8u) == 0u)
+		if (0U == (GetSendMaskSum(CI_SYSTEM_TYPE_ZC) % 8U))
 		{
-			SendMaskSum = (UINT16) (GetSendMaskSum(CI_SYSTEM_TYPE_ZC) / 8u);
+			SendMaskSum = (UINT16) (GetSendMaskSum(CI_SYSTEM_TYPE_ZC) / 8U);
 		}
 		else
 		{
-			SendMaskSum = (UINT16) (GetSendMaskSum(CI_SYSTEM_TYPE_ZC) / 8u + 1u);
+			SendMaskSum = (UINT16) (GetSendMaskSum(CI_SYSTEM_TYPE_ZC) / 8U + 1U);
 		}
 
-        if (0u == SendMaskSum)
+        if (0U == SendMaskSum)
         {
 			retVal = CI_ERROR;
         }
@@ -1122,21 +1216,21 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 			/*开始组应用数据帧*/
 			/*组GAL包头*/
 			ShortToChar(CI_ZC_INTERFACE_INFOTYPE, &CiToZcDataBuffer[ii]);/*接口信息类型*/
-			ii += 2u;
+			ii += 2U;
 			LongToChar(ciEtcsId, &CiToZcDataBuffer[ii]);/*发送方标识信息*/
-			ii += 4u;
+			ii += 4U;
 			LongToChar(zcEtcsId, &CiToZcDataBuffer[ii]);/*接收方标识信息*/
-			ii += 4u;
+			ii += 4U;
 			LongToChar(emapCheckVer, &CiToZcDataBuffer[ii]);/*电子地图版本校验信息*/
-			ii += 4u;
+			ii += 4U;
 			LongToChar(curCycleNum, &CiToZcDataBuffer[ii]);/*本方消息序列号*/
-			ii += 4u;
+			ii += 4U;
 			ShortToChar((UINT16)appCycleTime, &CiToZcDataBuffer[ii]);/*设备通讯周期*/
-			ii += 2u;
+			ii += 2U;
 			LongToChar(dwHlhtHSrcSN, &CiToZcDataBuffer[ii]);/*对方消息序列号：recvOppMsgSN记录收到对方上一条消息中的对方消息序列号*/
-			ii += 4u;
+			ii += 4U;
 			LongToChar(dwHlhtHRcvSN, &CiToZcDataBuffer[ii]);/*收到上一条消息时本方序列号*/
-			ii += 4u;
+			ii += 4U;
 
 			lineIdentity = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);/*获取线路标识*/
 
@@ -1150,39 +1244,58 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 			}
 
 			totallenIndex = ii;
-			ii += 2u;/*通用报文头中的应用层报文总长度*/
-			if (DATA_TYPE_NEW == chDataType)
+			ii += 2U;/*通用报文头中的应用层报文总长度*/
+
+			if ((DATA_TYPE_MAIN_BRANCH == chDataType) || (DATA_TYPE_28_BRANCH == chDataType))
 			{
-				ii += 2u;/*通用报文头中的应用层报文长度(0x202报文长度)*/
+				ii += 2U;/*通用报文头中的应用层报文长度(0x202报文长度)*/
 
 				ShortToChar(TIOC_TO_ZC_MASK_MSG, &CiToZcDataBuffer[ii]);/*接口信息类型*/
-				ii += 2u;
+				ii += 2U;
 
-				ii += 2u; /*预留*/
+				ii += 2U; /*预留*/
 			}
 			else
 			{
-				;/*杭德线路无0x202报文长度、类型及预留*/
+				/*23分支无0x202报文长度、类型及预留*/
 			}
+			
 
 			/*组码位信息*/
 			(void)MaskPack(CI_SYSTEM_TYPE_ZC,&CiToZcDataBuffer[ii]);	
-			ii = (UINT16) (ii + SendMaskSum);
+			ii = (UINT16)(ii + SendMaskSum);
 
-			/*通用报文头中应用层报文总长度*/
-			ShortToChar(ii - totallenIndex - 2U, &CiToZcDataBuffer[totallenIndex]);
-			if (DATA_TYPE_NEW == chDataType)
+			if (DATA_TYPE_MAIN_BRANCH == chDataType)
 			{
 				/*通用应用层报文长度(0x202报文长度)*/
-				totallenIndex += 2U;
-				ShortToChar(ii - totallenIndex - 2U, &CiToZcDataBuffer[totallenIndex]);
+				/*刨去2字节应用报文总长度+2字节0202帧长度*/
+				ShortToChar((ii - (totallenIndex + 4U)), &CiToZcDataBuffer[totallenIndex + 2U]);
+
+				/*组TACS列车跨压信息*/
+				wCrossFrameLen = PackRcTacsCrossData(&CiToZcDataBuffer[ii]);
+				ii += wCrossFrameLen;
 			}
+			else if(DATA_TYPE_28_BRANCH == chDataType)
+			{
+				/*通用应用层报文长度(0x202报文长度)*/
+				/*刨去2字节应用报文总长度+2字节0202帧长度*/
+				ShortToChar((ii - (totallenIndex + 4U)), &CiToZcDataBuffer[totallenIndex + 2U]);
+			}
+			else
+			{
+				/*23分支 nothing*/
+			}
+
+			/*通用报文头中应用层报文总长度*/
+			/*刨去2字节应用报文总长度*/
+			ShortToChar(ii - (totallenIndex + 2U), &CiToZcDataBuffer[totallenIndex]);
+
 			/*清ZC数据*/
 			ClearZcData();
 
-			dstDevId = (UINT16)(CI_SYSTEM_TYPE_ZC << 8) | ((UINT16)deviceId);
-			outnetSafeSendRtn = OutnetSafeSend(dstDevId, 0u, &CiToZcDataBuffer[0], ii);
-			if (1u == outnetSafeSendRtn)
+			dstDevId = (UINT16)(CI_SYSTEM_TYPE_ZC << 8U) | ((UINT16)deviceId);
+			outnetSafeSendRtn = OutnetSafeSend(dstDevId, 0U, &CiToZcDataBuffer[0U], ii);
+			if (1U == outnetSafeSendRtn)
 			{ /*写队列成功*/
 #ifdef LOGPRINT/*日志打印宏*/			
 #ifdef PLATFORM_2OO2/*2oo2平台打印*/
@@ -1244,6 +1357,93 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 	return retVal;
 }
 
+/*
+* 功能描述： 组发送给ZC的TACS主控列车跨压信息
+* 参数说明： UINT8 *pDataBuf 数据包
+* 返回值  ： 数据长度
+*/
+static UINT16 PackRcTacsCrossData(UINT8 *pDataBuf)
+{
+	UINT16 Index = 0u;				/*索引编号*/
+	UINT16 i = 0u;					/*循环变量*/
+	UINT8 j = 0u;					/*循环变量*/
+	UINT16 wSignalCurSum = 0u;		/*信号机数量*/
+	UINT16 wSignalId = 0u;			/*信号机ID*/
+	UINT8 wSignalBelongCiId = 0u;	/*信号机所属联锁ID*/
+	UINT8 wLocalCiId = 0u;			/*本机联锁ID*/
+	UINT8 wCrossTacsTrainId = 0u;	/*TACS跨压列车ID*/
+
+	UINT8 wTacsCrossTrainSum = 0u;	/*TACS跨压列车数量*/
+	UINT16 wTacsCrossSignalBuf[ALL_TACS_CROSS_SUM_MAX] = { 0u };	/*TACS跨压信号机ID数组*/
+	UINT8 wTacsCrossTrainBuf[ALL_TACS_CROSS_SUM_MAX] = { 0u };		/*TACS跨压列车ID数组*/
+
+	/*Step1：TACS跨压信息准备*/
+	wSignalCurSum = GetSignalCurSum();
+	/*遍历所有本联锁信号机*/
+	for (i = 0u; i < wSignalCurSum; i++)
+	{
+		wSignalId = GetSignalId(i);
+		wSignalBelongCiId = GetSignalBelongCiId(wSignalId);
+		wLocalCiId = GetSystemParaLocalCiId();
+		if (wSignalBelongCiId == wLocalCiId)
+		{
+			/*判断跨压TACS主控列车ID是否为零*/
+			wCrossTacsTrainId = GetSignalCrossTacsTrainIdCC(wSignalId);
+
+			/*非法值防护*/
+			if ((0u < wSignalId) && (CROSS_SIGNAL_ID_MAX >= wSignalId)
+				&& (0u < wCrossTacsTrainId) && (TACS_CROSS_ID_MAX >= wCrossTacsTrainId)
+				&& (ALL_TACS_CROSS_SUM_MAX > wTacsCrossTrainSum))
+			{
+				/*TACS主控列车ID有效，赋值至待发送数组*/
+				wTacsCrossSignalBuf[wTacsCrossTrainSum] = wSignalId;
+				wTacsCrossTrainBuf[wTacsCrossTrainSum] = wCrossTacsTrainId;
+				wTacsCrossTrainSum += 1u;
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+
+	/*Step2：TACS跨压信息组包*/	
+	/*帧长度，最后赋值*/
+	Index += 2u;
+
+	/*帧类型*/
+	ShortToChar(RC_TO_ZC_TACS_CROSS_MSG, &pDataBuf[Index]);
+	Index += 2u;
+
+	/*预留2字节发0*/
+	ShortToChar(0u, &pDataBuf[Index]);
+	Index += 2u;
+
+	/*跨压TACS主控列车数量*/
+	pDataBuf[Index] = wTacsCrossTrainSum;
+	Index += 1u;
+
+	for (j = 0u; j < wTacsCrossTrainSum; j++)
+	{
+		/*跨压信号机ID*/
+		ShortToChar(wTacsCrossSignalBuf[j], &pDataBuf[Index]);
+		Index += 2u;
+
+		/*跨压列车ID*/
+		pDataBuf[Index] = wTacsCrossTrainBuf[j];
+		Index += 1u;
+	}
+
+	/*最后赋值长度*/
+	ShortToChar((Index - 2u), &pDataBuf[0u]);
+
+	return Index;
+}
+
 
 /*
 * 功能描述： 获取ZC码位值Buf
@@ -1448,6 +1648,94 @@ UINT8 ParseZcIteCutData(UINT8* dataBuf, UINT16 dataLen)
 	return cRetVal;
 }
 
+/*
+* 功能描述：解析ZC到CI的CBTC主控列车跨压数据
+* 参数说明：UINT8* pDataBuf 数据缓冲区
+*           UINT16 dataLen 数据长度
+* 返 回 值：CI_ERROR 0 数据解析失败
+*			CI_SUCCESS 1 数据解析成功
+* Edit By wyd 2026.3.26
+*/
+static UINT8 ParseZcCbtcCrossData(UINT8* pDataBuf, UINT16 dataLen)
+{
+	UINT8 cRetVal = CI_ERROR;	/*函数返回值*/
+	UINT8 wCrossNum = 0u;		/*承接跨压状态*/
+	UINT16 ii = 0U;				/*数组下标变量*/
+	UINT8 jj = 0U;				/*循环变量*/
+	UINT16 wSignalId = 0U;		/*承接跨压信号机ID*/
+	UINT8 wTrainId = 0U;		/*承接跨压列车ID*/
+
+	if (NULL != pDataBuf)
+	{
+		cRetVal = CI_SUCCESS;
+		ZcToCiDataStru.cRecvCbtcCrossFrameTag = CI_SUCCESS;
+
+		wCrossNum = pDataBuf[ii];
+		ii++;
+
+		if (ALL_CBTC_CROSS_SUM_MAX >= wCrossNum)
+		{
+			ZcToCiDataStru.wCbtcCrossNum = wCrossNum;
+			for (jj = 0U; jj < wCrossNum; jj++)
+			{
+				wSignalId = ShortFromChar(&pDataBuf[ii]);  /*解析信号机ID*/
+				ii += 2u;
+
+				if ((0U < wSignalId) && (CROSS_SIGNAL_ID_MAX >= wSignalId))
+				{
+					ZcToCiDataStru.wCbtcCrossSignalId[jj] = wSignalId;
+				}
+				else
+				{
+					debug_infor_printf((const)"ParseZcCbtcCrossData: wSignalId Error\n");
+					cRetVal = CI_ERROR;  /*Z信号机ID超限，返回失败*/
+				}
+
+				wTrainId = pDataBuf[ii];  /*解析列车ID*/
+				ii += 1u;
+
+				if ((0U < wTrainId) && (CBTC_CROSS_ID_MAX >= wTrainId))
+				{
+					ZcToCiDataStru.wCbtcCrossTrainId[jj] = wTrainId;
+				}
+				else
+				{
+					debug_infor_printf((const)"ParseZcCbtcCrossData: wTrainId Error\n");
+					cRetVal = CI_ERROR;  /*列车ID超限，返回失败*/
+				}
+			}
+
+			if (CI_SUCCESS == cRetVal)
+			{
+				if (dataLen != ii)
+				{
+					debug_infor_printf((const)"ParseZcCbtcCrossData: Msg Len Error\n");
+					cRetVal = CI_ERROR;
+				}
+				else
+				{
+					/*不处理*/
+				}
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+		else
+		{
+			debug_infor_printf((const)"ParseZcCbtcCrossData Error: wCrossNum Error\n");
+			cRetVal = CI_ERROR;  /*状态非法，返回失败*/
+		}
+	}
+	else
+	{
+		cRetVal = CI_ERROR;  /*入参非法，返回失败*/
+	}
+
+	return cRetVal;
+}
+
 /**
 * @brief 获取ZC发送的进路停车保证标志
 * @param[in] UINT16 wDeviceId 设备ID
@@ -2017,4 +2305,61 @@ void SetLocalSnowModelZc(UINT8 setmodle)
 	{
 		; /*不处理*/
 	}
+}
+
+/*
+* 功能描述：获取ZC发送的CBTC主控列车跨压数量
+* 参数说明：无
+* 返 回 值：跨压数量
+* Created By wyd 2026.3.27
+*/
+UINT8 GetCbtcCrossNumZc(void)
+{
+	return gCbtcCrossNumZc;
+}
+
+/*
+* 功能描述：获取ZC发送的CBTC主控列车跨压信息
+* 参数说明：无
+* 返 回 值：跨压信息
+* Created By wyd 2026.3.27
+*/
+CbtcCrossStructZC *GetCbtcCrossStructZc(void)
+{
+	return gCbtcCrossStructZc;
+}
+
+/*
+* 功能描述：设置ZC发送CBTC主控列车跨压信息
+* 参数说明：UINT8 wCrossNum 跨压数量
+*			UINT16 wSignalId[ALL_CBTC_CROSS_SUM_MAX] 跨压信号机ID
+*			UINT8 wTrainId[ALL_CBTC_CROSS_SUM_MAX] 跨压列车ID
+* 返 回 值：无
+* 注意事项：RC接收CI->RC同步过来的该信息时，是直接赋值，没调用该接口函数
+* Created By wyd 2026.3.26
+*/
+void SetCbtcCrossInfo(UINT8 wCrossNum, UINT16 wSignalId[ALL_CBTC_CROSS_SUM_MAX],
+	UINT8 wTrainId[ALL_CBTC_CROSS_SUM_MAX])
+{
+	UINT8 i = 0u;
+
+	/*先清空，防止残留脏数据*/
+	(void)CommonMemSet(gCbtcCrossStructZc, ALL_CBTC_CROSS_SUM_MAX * sizeof(CbtcCrossStructZC), 
+		0x00u, ALL_CBTC_CROSS_SUM_MAX * sizeof(CbtcCrossStructZC));
+
+	/*赋值跨压数量和ID*/
+	gCbtcCrossNumZc = wCrossNum;
+
+	if ((NULL == wSignalId) || (NULL == wTrainId))
+	{
+		/*不处理*/
+	}
+	else
+	{
+		for (i = 0u; i < wCrossNum; i++)
+		{
+			gCbtcCrossStructZc[i].wSignalId = wSignalId[i];
+			gCbtcCrossStructZc[i].wTrainId = wTrainId[i];
+		}
+	}
 }

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

@@ -26,15 +26,17 @@
 #include "../ParsePack/ParsePackTmcData.h"
 
 
-#define CI_ZC_INTERFACE_INFOTYPE    ((UINT16)0x0106) /*互联互通CI_ZC接口信息类型*/
-#define CI_ZC_PRTCL_VER	((UINT16)0x65)		/*CI_ZC协议版本号，根据《IFAO-3048-ZC-CI接口说明书》修改*/
-#define ZC_TO_TIOC_MASK_MSG  ((UINT16)0x0201u)		 /*ZC发送TIOC码位信息类型*/
-#define TIOC_TO_ZC_MASK_MSG  ((UINT16)0x0202u)		 /*TIOC发送ZC码位信息类型*/
-#define ZC_TO_TIOC_TSR_MSG  ((UINT16)0x0203u)		 /*ZC发送TIOC临时限速信息类型*/
-#define ZC_TO_TIOC_WLB_MSG  ((UINT16)0x0204u)		 /*ZC发送TIOC紧急制动信息类型*/
-#define ZC_TO_TIOC_SNOW_MSG  ((UINT16)0x0205u)		 /*ZC发送TIOC雨雪模式信息类型*/
-#define ZC_TO_TIOC_ITELINECUT_MSG  ((UINT16)0x0206U) /*ZC发送TIOC的全线ITE切除状态信息类型*/
-#define ZC_TSR_VALID  ((UINT8)0x55U)		 /*ZC发送临时限速有效*/
+#define CI_ZC_INTERFACE_INFOTYPE	((UINT16)0x0106)	/*互联互通CI_ZC接口信息类型*/
+#define CI_ZC_PRTCL_VER				((UINT16)0x65)		/*CI_ZC协议版本号，根据《IFAO-3048-ZC-CI接口说明书》修改*/
+#define ZC_TO_TIOC_MASK_MSG			((UINT16)0x0201u)	/*ZC发送TIOC码位信息类型*/
+#define TIOC_TO_ZC_MASK_MSG			((UINT16)0x0202u)	/*TIOC发送ZC码位信息类型*/
+#define ZC_TO_TIOC_TSR_MSG			((UINT16)0x0203u)	/*ZC发送TIOC临时限速信息类型*/
+#define ZC_TO_TIOC_WLB_MSG			((UINT16)0x0204u)	/*ZC发送TIOC紧急制动信息类型*/
+#define ZC_TO_TIOC_SNOW_MSG			((UINT16)0x0205u)	/*ZC发送TIOC雨雪模式信息类型*/
+#define ZC_TO_TIOC_ITELINECUT_MSG	((UINT16)0x0206U)	/*ZC发送TIOC的全线ITE切除状态信息类型*/
+#define ZC_TO_RC_CBTC_CROSS_MSG		((UINT16)0x0207U)	/*ZC发送给RC的主控CBTC列车跨压信息*/
+#define RC_TO_ZC_TACS_CROSS_MSG		((UINT16)0x0208u)	/*RC发送给ZC的主控TACS列车跨压信息*/
+#define ZC_TSR_VALID				((UINT8)0x55U)		/*ZC发送临时限速有效*/
 
 #ifdef __cplusplus
 extern "C" {
@@ -64,6 +66,10 @@ typedef struct S_ZcToCiDataStruct
 	UINT8 cIteLineCutState;				/* ITE全线切除状态 */
 	UINT8 cAreaIteCutNum;  /*区间ITE切除数量*/
 	UINT16 szAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*区间ITE切除ID数组*/
+	UINT8 cRecvCbtcCrossFrameTag;	/*接收到主控CBTC列车跨压信息帧标志*/
+	UINT8 wCbtcCrossNum;			/*CBTC主控列车跨压数量*/
+	UINT16 wCbtcCrossSignalId[ALL_CBTC_CROSS_SUM_MAX];	/*CBTC主控列车跨压信号机ID*/
+	UINT8 wCbtcCrossTrainId[ALL_CBTC_CROSS_SUM_MAX];	/*CBTC主控列车跨压列车ID*/
 } ZcToCiDataStruct;
 
 /*ZC发送的信号机动态数据结构体*/
@@ -87,7 +93,7 @@ typedef struct S_LogicSectionDataStructZC
 typedef struct S_AxisSectionDataStructZC
 {
 	UINT16 AxisSectionId;      		/*计轴区段ID (初始化字段)*/
-	UINT8 AxisArbState;             /*计轴ARB状态CC(0x55-未ARB，0xaa-ARB)*/
+	UINT8 AxisArbState;             /*计轴ARB状态(0x55-未ARB，0xaa-ARB)*/
 }AxisSectionDataStructZC;
 
 /*ZC发送的物理区段动态数据结构体*/
@@ -104,6 +110,13 @@ typedef struct S_RouteDataStructZC
 	UINT8 StopensureFlag;												    /*停车保证标志ZC(0x55：已设置，0xAA：未设置) */
 }RouteDataStructZC;
 
+/*ZC发送的CBTC主控列车跨压结构体*/
+typedef struct S_CbtcCrossStructZC
+{
+	UINT16 wSignalId;				/*跨压信号机ID*/
+	UINT8 wTrainId;					/*跨压列车ID*/
+}CbtcCrossStructZC;
+
 /*存储ZC发送的动态数据结构体*/
 typedef struct S_ZcToCiDynamicDataStruct
 {
@@ -133,7 +146,8 @@ extern ComTrainPosDataStruct ComTrainPosDataStru[ZC_TO_CI_TRAIN_MAX];
 extern UINT16 ComTrainSum;
 extern UINT8 lineIdentity;
 extern ZcToCiDynamicDataStruct gZcToCiDymDataStru;  /*ZC动态数据结构体*/
-
+extern UINT8 gCbtcCrossNumZc;
+extern CbtcCrossStructZC gCbtcCrossStructZc[ALL_CBTC_CROSS_SUM_MAX];
 
 #endif
 
@@ -468,6 +482,34 @@ UINT8 GetLocalSnowModelZc(void);
 */
 void SetLocalSnowModelZc(UINT8 setmodle);
 
+/*
+* 功能描述：获取ZC发送的CBTC主控列车跨压数量
+* 参数说明：无
+* 返 回 值：跨压数量
+* Created By wyd 2026.3.27
+*/
+UINT8 GetCbtcCrossNumZc(void);
+
+/*
+* 功能描述：获取ZC发送的CBTC主控列车跨压信息
+* 参数说明：无
+* 返 回 值：跨压信息
+* Created By wyd 2026.3.27
+*/
+CbtcCrossStructZC *GetCbtcCrossStructZc(void);
+
+/*
+* 功能描述：设置ZC发送CBTC主控列车跨压信息
+* 参数说明：UINT8 wCrossNum 跨压数量
+*			UINT16 wSignalId[ALL_CBTC_CROSS_SUM_MAX] 跨压信号机ID
+*			UINT8 wTrainId[ALL_CBTC_CROSS_SUM_MAX] 跨压列车ID
+* 返 回 值：无
+* 注意事项：RC接收CI->RC同步过来的该信息时，是直接赋值，没调用该接口函数
+* Created By wyd 2026.3.26
+*/
+void SetCbtcCrossInfo(UINT8 wCrossNum, UINT16 wSignalId[ALL_CBTC_CROSS_SUM_MAX],
+	UINT8 wTrainId[ALL_CBTC_CROSS_SUM_MAX]);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -49,9 +49,6 @@
 /*4个字节*/
 #define LONG_LEN ((UINT8)4)
 
-/*dquCICfgDtStr.OCSwitchCfgStr中成员个数*/
-#define OC_SWITCH_CFG_STR_MEMBER_NUM ((UINT8)2)
-
 /*dquCICfgDtStr.OCSwitchCfgStr中成员个数_旧版*/
 #define OC_SWITCH_CFG_STR_MEMBER_NUM_OLD ((UINT8)6)
 
@@ -430,20 +427,6 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
 UINT8 RouteConfigDataStructInit(CHAR * FSName);
 
 
-/*********************************************
-*函数功能：按行解析通信关系（从设备IP表里去到的数据，每行17个数据）
-*参数说明：Data通信数组
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8 TransmitRelationDataStruFrmSZ(UINT16 Data[]);
-
-/*********************************************
-*函数功能：初始化通信关系数据结构体
-*参数说明：FSName文件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8 TransmitRelationDataStructInit(CHAR* FSName);
-
 /*********************************************
 *函数功能：初始化通信关系数据结构体（NEW）
 *参数说明：FSName文件指针
@@ -839,14 +822,6 @@ UINT8 EaConfigDataStruFromDquEaStr(DSU_EMAP_EA_STRU* pEa, EaConfigStru* pEaCfgDt
 *返回值：0，失败；1，成功
 *********************************************/
 UINT8 EaConfigDataStructInit(CHAR * FSName);
-
-/*********************************************
-*函数功能：解析OC 道岔配置表数据
-*参数说明：pDataAddr 数据地址；
-*返回值：0，失败；1，成功
-*备注：cgh-合并CID-2539-5：：修改初始化《OC_配置数据表》中“物理区段模块配置表”、“信号机模块配置表”、“道岔模块配置表”的初始化方式，和其他表格的初始化方式一致
-*********************************************/
-void R_OCSwitchConfigDataFromChar(UINT8* pDataAddr);
 /*********************************************
 *函数功能：解析OC 道岔转辙机状态指示灯表
 *参数说明：pDataAddr 数据地址；
@@ -1011,5 +986,107 @@ INT16 SetNoRepeatDataToBuf(UINT16* pBuf, UINT16 maxlen, UINT16 dwData, UINT16 cu
 * add by mpt 20260104
 *********************************************/
 UINT8 SetCldAndScxMergeConfig(void);
+/*********************************************
+*函数功能：解析道岔模块配置表
+*参数说明：pDataAddr 数据地址；
+*返回值：0，失败；1，成功
+* add by mpt 20260325
+*********************************************/
+void R_OCSwitchModeCfgDataFromChar(UINT8* pDataAddr);
+/*********************************************
+*函数功能：存储单个OC的板卡配置情况到道岔配置数据结构体
+*参数说明：SwitchBelongOCConfigDataStr* pSwitchOCcfgDtStr  道岔配置结构体
+*          OCSwitchConfigDataStruct* pOcCfgDtStr           OC配置表结构体
+*返回值：0，失败；1，成功
+* add by mpt 20260325
+*********************************************/
+UINT8 SwitchOcCfgStrFromOCconfigStr(SwitchBelongOCConfigDataStr* pSwitchOCcfgDtStr, OCSwitchConfigDataStruct* pOcCfgDtStr);
+/*********************************************
+*函数功能：从道岔结构体计算道岔继电器结构体
+*参数说明：SwitchConfigDataStruct* pSwitchCfgDtStr 道岔配置数据结构体
+*返回值：0，失败；1，成功
+* add by mpt 20260325
+*********************************************/
+UINT8 SwitchCfgDtStruFromOCconfigStr(SwitchConfigDataStruct* pSwitchCfgDtStr);
+/*********************************************
+*函数功能：计算道岔关联每一个OC的插箱数
+*参数说明：SwitchConfigDataStruct* pSwitchCfgDtStr 道岔配置数据结构体
+*返回值：0，失败；1，成功
+* add by mpt 20260325
+*********************************************/
+UINT8 CalcuSwitchInsertionBoxData(SwitchConfigDataStruct* pSwitchCfgDtStr);
+/*********************************************
+*函数功能：填充不重复的数据进入数组
+*参数说明：目标数组的指针
+*          待填入的数据
+*返回值：非-1为已填入的长度,-1为空间已满
+* add by mpt 20260330
+*********************************************/
+INT16 SetNoUINT8RepeatDataToBuf(UINT8* pBuf, UINT16 maxlen, UINT8 dwData, UINT16 currentLen);
+/*********************************************
+*函数功能：逻辑区段关联保护区段相关数据初始化
+*参数说明：pOverlapCfgDtStr保护区段配置数据结构体指针   pLogCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+* add by mpt 20260331
+*********************************************/
+UINT8 LogRelateOverlapDataInit(OverlapConfigDataStruct* pOverlapCfgDtStr, LogicSectionConfigDataStruct* pLogCfgDtStr);
+/*********************************************
+*函数功能：逻辑区段关联防护道岔（遍历保护区段）
+*参数说明：pLogCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+* add mpt 20260331
+*********************************************/
+UINT8 LogRelateProSwDataByOverlapInit(LogicSectionConfigDataStruct* pLgScCfgDtStr);
+/*********************************************
+*函数功能：逻辑区段配置数据结构体计算
+*参数说明：LogsecSwitchStruct* pSrcSwitchStructBuf 源数据
+           UINT8 chSrclen 源数据长度
+           AxisSwitchStruct* pDstSwitchStructBuf 目标数据
+           UINT8 dstLen 目标数据长度
+*返回值：-1，失败；其他为长度
+*add by  mpt 20260331
+*********************************************/
+INT16 AxisSecCfgDtStruFromLogicSecStr(LogsecSwitchStruct* pSrcSwitchStructBuf, UINT8 chSrclen, AxisSwitchStruct* pDstSwitchStructBuf, UINT8 dstLen);
+/*********************************************
+*函数功能：计轴区段防护道岔初始化
+*参数说明：void
+*返回值：0，失败；1，成功
+* add mpt 20260331
+*********************************************/
+UINT8 AxisSecProtectSwitchInit(void);
+/*********************************************
+*函数功能：为某道岔计算属于同板卡的另一道岔ID
+*参数说明：OCSwitchConfigDataStruct * pOCSwitchCfgStr 道岔配置数据结构体
+* add by mpt 20260404
+*返回值：0 失败，1成功
+*********************************************/
+UINT8 SwitchOtherSwitchFromOCconfig(OCSwitchConfigDataStruct* pOCSwitchCfgStr);
+/*********************************************
+*函数功能：为所有道岔计算属于同板卡的另一道岔ID
+*参数说明：void
+*返回值：0 失败，1成功
+*  add by mpt 20260404
+*********************************************/
+UINT8 AllSwitchOtherSwitchByOCconfig(void);
+
+/*********************************************
+*函数功能：初始化屏蔽门关联ESB数据----降低复杂度使用
+*参数说明：FSName文件指针
+*输入参数 wPsdIndex屏蔽门索引
+*返回值：0，失败；1，成功
+* fan 20260421
+*********************************************/
+UINT8 PsdRelateEsbConfigDataInit(UINT16 wPsdIndex);
+
+/*
+*功能描述: RCI功能配置数据初始化
+*输入参数:	CHAR * FSName 数据文件名指针
+*输出参数:	无
+*返回值: 0 失败
+*        1 成功
+* by cgh 20260516
+*/
+UINT8 RciCommonConfigDataInit(CHAR* FSName);
+
 #endif
 

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

@@ -133,7 +133,7 @@ UINT8 InitAll(CHAR* FSName)
 	{
 		CIInitEmap(dsuEmapStru);/*为CI使用的公共数据赋值*/
 
-		RtnVal = CiPatternInit(FSName); /*初始化当前联锁类型配置数据*/
+		RtnVal = RciCommonConfigDataInit(FSName); /*初始化当前联锁类型配置数据*/
 		if (0u != RtnVal) /*初始化当前联锁类型配置数据*/
 		{
 			/*初始化系统配置数据结构体*/
@@ -171,8 +171,8 @@ UINT8 InitAll(CHAR* FSName)
 		else
 		{
 #ifdef PLATFORM_2OO2
-			(void)printf("CiPattern Init Error\n");
-			debug_infor_printf((const)"CiPattern Init Error\n");
+			(void)printf("RciCommonConfigDataInit Error\n");
+			debug_infor_printf((const)"RciCommonConfigDataInit Error\n");
 #endif
 		}
 	}
@@ -2369,57 +2369,22 @@ UINT8 ReadSystemParamConfDataNew(const UINT8 ciId,SystemParameterStructNew* Syst
 		}
 		if (1u == rtnVal)
 		{	/*给从公共查询函数中*/
-			/*紧急制动最高触发速度（单位已在dfsInitSubSystemCommonConfigData_CC函数中转换）*/
-			SystemParameterStru->MaxLineLimitSpeed = dquCICfgDtStr.SystemParaStrNew.MaxLineLimitSpeed;
 
 			/*临时限速最高限速(km/h)（未进行单位转换）*/
 			SystemParameterStru->MaxTsrSpeed = dquCICfgDtStr.SystemParaStrNew.MaxTsrSpeed;
 
-			/*NTP校时时区差（小时）*/
-			SystemParameterStru->TimeZoneDifference = dquCICfgDtStr.SystemParaStrNew.TimeZoneDifference;
-
-			/*区间同向行驶双车间隔最小安全距离(cm))*/
-			SystemParameterStru->MABackDistance = dquCICfgDtStr.SystemParaStrNew.MABackDistance;
-
 			/*一次设置的临时限速最大个数*/
 			SystemParameterStru->MaxTsrNum = dquCICfgDtStr.SystemParaStrNew.MaxTsrNum;
 
 			/*一个临时限速报文中包含的最大限速区段数量*/
 			SystemParameterStru->MaxSectionOfTsr = dquCICfgDtStr.SystemParaStrNew.MaxSectionOfTsr;
 
-			/*IVOC-IVOC信故障判断时间（ms）*/
-			SystemParameterStru->IvocIvocCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.IvocIvocCommunicationErrorTime;
-
-			/*IVOC-OC通信故障判断时间(ms)*/
-			SystemParameterStru->IvocOcCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.IvocOcCommunicationErrorTime;
-
-			/*VOBC-ITS通信故障判断时间(ms)*/
-			SystemParameterStru->VobcAtsCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.VobcAtsCommunicationErrorTime;
-
-			/*TMC-ITS通信故障判断时间（ms）*/
-			SystemParameterStru->TmcItsCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.TmcItsCommunicationErrorTime;
-
-			/*ITS-OC通信故障判断时间（ms）*/
-			SystemParameterStru->ItsOcCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.ItsOcCommunicationErrorTime;
-
-			/*OC-PSD通信故障判断时间（ms）*/
-			SystemParameterStru->OcPsdCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.OcPsdCommunicationErrorTime;
-
-			/*IVOC-TSL通信故障判断时间（ms）*/
-			SystemParameterStru->IvocTslCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.IvocTslCommunicationErrorTime;
-
 			/*OC-TSL通信故障判断时间（ms）*/
 			SystemParameterStru->OcTslCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.OcTslCommunicationErrorTime;
 
-			/*满足精确停车条件的MA延伸长度（cm）*/
-			SystemParameterStru->MALengthForATOParking = dquCICfgDtStr.SystemParaStrNew.MALengthForATOParking;
-
 			/*本线系统定义逻辑方向与上下行方向的关系*/
 			SystemParameterStru->LinkLogicDirUpAndDown = dquCICfgDtStr.SystemParaStrNew.LinkLogicDirUpAndDown;
 
-			/*对向行驶双车间隔最小安全距离(cm)*/
-			SystemParameterStru->OppositeTrackDistance = dquCICfgDtStr.SystemParaStrNew.OppositeTrackDistance;
-
 			/*线路最差情况下紧急制动距离（单位m）*/
 			SystemParameterStru->MaxMALength = dquCICfgDtStr.SystemParaStrNew.MaxMALength;
 
@@ -3456,8 +3421,8 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
 	UINT8 ciId;
 	UINT8 jj = 0U;
 	UINT8 chLocalCiId = 0U;
-
-
+	UINT16 k = 0U;
+	 
 	chLocalCiId = GetSystemParaLocalCiId();
 	if (NULL != emapVerArr)
 	{
@@ -3465,7 +3430,7 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
 
 		for (i = 0u; i < wCIStruSum; i++)
 		{
-			ciId = (UINT8)(dsuStaticHeadStru.pCIStruStru[i].wID & 0x00FF);
+			ciId = (UINT8)(dsuStaticHeadStru.pCIStruStru[i].wID & 0x00FFu);
 			emapVerArr[ciId].devId = ciId;
 			emapVerArr[ciId].ciType = (UINT8)(dsuStaticHeadStru.pCIStruStru[i].wType);
 			if (CI_TYPE_TCC == dsuStaticHeadStru.pCIStruStru[i].wType)
@@ -3516,14 +3481,30 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
 				{/*试车线与车辆段合设开关*/
 					SystemParameterStruNew.chCldAndScxMergeFlag = dsuStaticHeadStru.pCIStruStru[i].chCldAndScxMergeFlag;
 				}
-
-
+				else 
+				{
+					/*不处理*/
+				}
 			}
 			else
 			{
 				; /*RC模式校验数据信息根据RC表初始化*/
 			}
 		}
+		/*联锁厂商定义 ** CI类型配置*/
+		for (k = 0U; k < wCIStruSum; k++)
+		{
+			ciId = (UINT8)(dsuStaticHeadStru.pCIStruStru[k].wID & 0x00FFU);
+			if (CI_SUM_MAX > ciId)
+			{
+				SystemParameterStruNew.chCiFactoryType[ciId] = dsuStaticHeadStru.pCIStruStru[k].chCiFactoryType;
+			}
+			else
+			{
+				/*不处理*/
+			}
+		}
+	
 		
 		if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
 		{
@@ -3531,7 +3512,7 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
 			for (i = 0u; i < wRCStruSum; i++)
 			{
 				/*并非所有联锁均包含在RC表，因此未配置在RC表中时根据CI表初始化*/
-				ciId = (UINT8)(dsuStaticHeadStru.pRCStruStru[i].wID & 0x00FF);		
+				ciId = (UINT8)(dsuStaticHeadStru.pRCStruStru[i].wID & 0x00FFu);		
 				emapVerArr[ciId].devId = ciId;
 				emapVerArr[ciId].ciType = (UINT8)(dsuStaticHeadStru.pRCStruStru[i].wType);
 				if (CI_TYPE_TCC == dsuStaticHeadStru.pRCStruStru[i].wType)

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

@@ -521,13 +521,16 @@ UINT8 R_WashMachineStructFromChar(UINT8* pDataAddr, Relay_WashMachineStruct* pWa
 		pData += 2U;
 		pWashMachineStr->TailWashAllowRelayId = dquCiShortFromChar(pData);             /*出发2继电器ID*/
 		pData += 2U;
+		pWashMachineStr->wCouplingWashAllowRelayId = dquCiShortFromChar(pData);        /*联挂端出发继电器ID*/
+		pData += 2U;
 		pWashMachineStr->WashTrainRequestRelayId = dquCiShortFromChar(pData);           /*洗车请求继电器ID*/
 		pData += 2U;
-
 		pWashMachineStr->TrainHeadStopSteadyRelayId = dquCiShortFromChar(pData);       /*列车停稳1继电器ID*/
 		pData += 2U;
 		pWashMachineStr->TrainTailStopSteadyRelayId = dquCiShortFromChar(pData);       /*列车停稳2继电器ID*/
 		pData += 2U;
+		pWashMachineStr->wCoupingStopSteadyRelayId = dquCiShortFromChar(pData);        /*联挂端停稳继电器ID*/
+		pData += 2U;
 		pWashMachineStr->TrainOutWashPortAllowRelayId = dquCiShortFromChar(pData);/*允许出库继电器ID*/
 		pData += 2U;
 		pWashMachineStr->PauseTrainWashRequestRelayId = dquCiShortFromChar(pData);	   /*暂停洗车继电器ID*/
@@ -611,6 +614,10 @@ UINT8 R_NoRouteDcStruFromChar(UINT8 * pDataAddr,Relay_NoRouteDcStruct* pNoRotStr
 	pNoRotStr->wRelayColTongYiScId = dquCiShortFromChar(pData);	/* 试车线采集同意试车继电器ID */
 	pData += 2u;
 
+	pNoRotStr->wWaysideTryTrainIndRelayId = dquCiShortFromChar(pData);	/* 轨旁试车指示器继电器ID */
+	pData += 2u;
+	
+
 	 rtnvalue = 1u;
 	return rtnvalue;
 

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

@@ -397,35 +397,27 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
 				{
 					RelayDataLen.RelayScreenStrLen = wRealRowCount;
 					rowLen = DataSize / wRealRowCount;
-					if (DataSize < rowLen)
+					/*动态申请空间*/
+					RelayData.pRelayScreenStr = (Relay_ScreenStruct*)MyNew((UINT32)(sizeof(Relay_ScreenStruct) * RelayDataLen.RelayScreenStrLen));
+					/*动态申请空间失败*/
+					if (NULL == RelayData.pRelayScreenStr)
 					{
+						RelayDataLen.RelayScreenStrLen = 0U;
 						rtnValue = 0U;
-
 					}
 					else
 					{
-						/*动态申请空间*/
-						RelayData.pRelayScreenStr = (Relay_ScreenStruct*)MyNew((UINT32)(sizeof(Relay_ScreenStruct) * RelayDataLen.RelayScreenStrLen));
-						/*动态申请空间失败*/
-						if (NULL == RelayData.pRelayScreenStr)
+						/*内存先设为无效*/
+						(void)memset(RelayData.pRelayScreenStr, 0x00, sizeof(Relay_ScreenStruct) * RelayDataLen.RelayScreenStrLen);
+						/*解析数据到 默认行车序列 结构体数组 */
+						for (j = 0u; j < RelayDataLen.RelayScreenStrLen; j++)
 						{
-							RelayDataLen.RelayScreenStrLen = 0U;
-							rtnValue = 0U;
-						}
-						else
-						{
-							/*内存先设为无效*/
-							(void)memset(RelayData.pRelayScreenStr, 0x00, sizeof(Relay_ScreenStruct) * RelayDataLen.RelayScreenStrLen);
-							/*解析数据到 默认行车序列 结构体数组 */
-							for (j = 0u; j < RelayDataLen.RelayScreenStrLen; j++)
-							{
-								pScreenStr = RelayData.pRelayScreenStr + j;
+							pScreenStr = RelayData.pRelayScreenStr + j;
 
-								/*填充数据结构体*/
-								rtnValue &= R_ScreenStructFromChar(pDataAddr, pScreenStr, (UINT16)rowLen);								
-								pDataAddr += rowLen;
+							/*填充数据结构体*/
+							rtnValue &= R_ScreenStructFromChar(pDataAddr, pScreenStr, (UINT16)rowLen);
+							pDataAddr += rowLen;
 
-							}
 						}
 					}
 				}

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

@@ -1583,40 +1583,33 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
 				   realRowLen = (UINT16)(DataSize / rowLen);
 				   LSDataLen.LSOverlapLockCondStruLen = (UINT16)rowLen;
 
-				   if (DataSize < realRowLen)
+				   /*动态申请空间*/
+				   LSData.pLSOverlapLockCondStru = (LS_OveralpLockCondStru*)MyNew((UINT32)(sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen));
+				   /*动态申请空间失败*/
+				   if (NULL == LSData.pLSOverlapLockCondStru)
 				   {
-					   rtnValue = 0U;
+					   /*将数组长度清0，防护数组访问越界*/
+					   LSDataLen.LSOverlapLockCondStruLen = 0u;
+
+					   rtnValue = 0u;
 				   }
 				   else
 				   {
-					   /*动态申请空间*/
-					   LSData.pLSOverlapLockCondStru = (LS_OveralpLockCondStru*)MyNew((UINT32)(sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen));
-					   /*动态申请空间失败*/
-					   if (NULL == LSData.pLSOverlapLockCondStru)
+					   /*内存先设为无效*/
+					   (void)memset(LSData.pLSOverlapLockCondStru, 0x00, sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen);
+
+					   /*解析数据到 默认行车序列 结构体数组 */
+					   rtnValue = 1u;
+					   for (j = 0u; j < LSDataLen.LSOverlapLockCondStruLen; j++)
 					   {
-						   /*将数组长度清0，防护数组访问越界*/
-						   LSDataLen.LSOverlapLockCondStruLen = 0u;
+						   pTempLSProtSecLockCondStru = LSData.pLSOverlapLockCondStru + j;
 
-						   rtnValue = 0u;
+						   /*填充数据结构体*/
+						   rtnValue &= LS_OverlapLockCondStruFromChar(pDataAddr, pTempLSProtSecLockCondStru);
+
+						   pDataAddr += realRowLen;
 					   }
-					   else
-					   {
-						   /*内存先设为无效*/
-						   (void)memset(LSData.pLSOverlapLockCondStru, 0x00, sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen);
 
-						   /*解析数据到 默认行车序列 结构体数组 */
-						   rtnValue = 1u;
-						   for (j = 0u; j < LSDataLen.LSOverlapLockCondStruLen; j++)
-						   {
-							   pTempLSProtSecLockCondStru = LSData.pLSOverlapLockCondStru + j;
-
-							   /*填充数据结构体*/
-							   rtnValue &= LS_OverlapLockCondStruFromChar(pDataAddr, pTempLSProtSecLockCondStru);
-
-							   pDataAddr += realRowLen;
-						   }
-
-					   }
 				   }
 			   }
 		   }
@@ -2403,28 +2396,21 @@ UINT8 InitLSSideProtec(CHAR* LSDataName)
 			for (j = 0u; j < wRouteSideProtecNum; j++)/*遍历每个侧防条件*/
 			{
 				wSideProtecID = LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j].SideProtecID;
-				if (0u < wSideProtecID)/*侧防条件组表中的侧防条件ID大于0*/
+				for (k = 0u; k < LSDataLen.LSRouteSideProtecStruLen; k++)
 				{
-					for (k = 0u; k < LSDataLen.LSRouteSideProtecStruLen; k++)
+					if (wSideProtecID == LSData.pLSRouteSideProtecStru[k].SideProtecID)
 					{
-						if (wSideProtecID == LSData.pLSRouteSideProtecStru[k].SideProtecID)
-						{
-							CommonMemCpy(&LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j], sizeof(SideProtecStru), &LSData.pLSRouteSideProtecStru[k], sizeof(SideProtecStru));
-							break;/*找到则跳出*/
-						}
-						else
-						{
-							/*继续遍历*/
-						}
+						(void)CommonMemCpy(&LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j], (UINT32)sizeof(SideProtecStru), &LSData.pLSRouteSideProtecStru[k], (UINT32)sizeof(SideProtecStru));
+						break;/*找到则跳出*/
 					}
-					if (k == LSDataLen.LSRouteSideProtecStruLen)
+					else
 					{
-						rtnValue = 0u;
+						/*继续遍历*/
 					}
 				}
-				else
+				if (k == LSDataLen.LSRouteSideProtecStruLen)
 				{
-					break;
+					rtnValue = 0u;
 				}
 			}			
 		}

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

@@ -40,7 +40,7 @@
 #define CI_SYSTEM_OUTSIG_RALATE_AXIS_LEN ((UINT8)82)
 
 #define CI_SYSTEM_CI_PATTERN_ID  ((UINT8)0x08)	/*增加联锁类型配置表*/
-#define CI_SYSTEM_CI_PATTERN_LEN ((UINT8)13)	/*修改为13，增加是否分布式联锁，UT/CT保护区段解锁停稳时间，UT/CT接近区段延时解锁超限时间*/
+#define CI_SYSTEM_CI_PATTERN_LEN ((UINT8)14)	/*修改为14，增加是否分布式联锁，UT/CT保护区段解锁停稳时间，UT/CT接近区段延时解锁超限时间*/
 
 #define CI_SYSTEM_VIRCI_INCLUDEOC_ID  ((UINT8)0x09)	/*增加虚拟联锁与OC对应关系表*/
 #define CI_SYSTEM_VIRCI_INCLUDEOC_LEN ((UINT8)22)	
@@ -61,5 +61,7 @@
 
 #define CI_SYSTEM_VERGE_KILL_ID			((UINT8)0x0F)  /*计轴器对应临线的公里标转换表*/
 
+#define CI_SYSTEM_SERIAL_COMM_ID			((UINT8)0x10)  /*相邻联锁串口通信配置表*/
+
 #endif
 

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

@@ -21,6 +21,8 @@
 #define DEVICE_IP_TYPE  ((UINT32)0x40)
 
 #define ZC_DSU_TRANSMIT_DATA_ID  ((UINT32)4)
-#define ZC_DSU_TRANSMIT_DATA_LEN ((UINT16)(34+30))
+#define ZC_DSU_TRANSMIT_DATA_NEW_LEN ((UINT16)(34+30+40))/*ZCDSU通信关系表数据结构长度*/
+
+#define ZC_DSU_TRANSMIT_DATA_NEW_NUM_MAX ((UINT16)(50)) /*ZCDSU通信关系表数据结构最大条数*/
 
 #endif

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

@@ -304,7 +304,7 @@ UINT8  MaskCfgDtStruFrmCIATSPsdMask(UINT8* FSDataName)
 						MASK_TYPE_PSD_PCB,MASK_TYPE_PSD_POB,MASK_TYPE_PSD_PSB,MASK_TYPE_PSD_PCB_INVALID,
 						MASK_TYPE_PSD_POB_INVALID,MASK_TYPE_PSD_PSB_INVALID,MASK_TYPE_PSD_JXTC_PANGLU,
 						MASK_TYPE_PSD_PCBPSBDPB_PANGLU_STATE,MASK_TYPE_PSD_PDB_FLASH_STATE,
-						MASK_TYPE_PSD_VIDEO_QK_LU,MASK_TYPE_PSD_VIDEO_QK_HONG,MASK_TYPE_PSD_EXCEPT_OPEN,MASK_TYPE_PSD_JXTCPANGLU_FAULT,MASK_TYPE_PSD_IBP_STATE,MASK_TYPE_PSD_IBP_FAULT,MASK_TYPE_PSD_JXTC_STATE,0U };
+						MASK_TYPE_PSD_VIDEO_QK_LU,MASK_TYPE_PSD_VIDEO_QK_HONG,MASK_TYPE_PSD_EXCEPT,MASK_TYPE_PSD_JXTCPANGLU_FAULT,MASK_TYPE_PSD_IBP_STATE,MASK_TYPE_PSD_IBP_FAULT,MASK_TYPE_PSD_JXTC_STATE,0U };
 #else
 	UINT8 MaskType[] = { 0u,MASK_TYPE_PSD_STATE_ATS,MASK_TYPE_MUTUALLOCK_STATE,MASK_TYPE_REMORA_STATE, MASK_TYPE_PSD_PCB,MASK_TYPE_PSD_POB,MASK_TYPE_PSD_PSB,MASK_TYPE_PSD_PCB_INVALID,MASK_TYPE_PSD_POB_INVALID,MASK_TYPE_PSD_PSB_INVALID,0 };
 #endif
@@ -546,7 +546,7 @@ UINT8  MaskCfgDtStruFrmCIATSLogSgmtT(UINT8* FSDataName)
 		MASK_TYPE_LOGICSECTION_JUMPLOCK,
 		MASK_TYPE_UPWARD_DIRECTION,
 		MASK_TYPE_DOWNWARD_DIRECTION,
-		MASK_TYPE_LOGICSECTION_ARB,
+		MASK_TYPE_LOGSEC_CBTC_ARB,
 		MASK_TYPE_LOGICSECTION_EMERG_XIANSU,1u };
 	UINT16 BuChang = 0u;
 	funcRtn = dquGetConfigDataNew(FSDataName, CI_ATS_MASK_TYPE, CI_ATS_LOGIC_SGMT_MASK_ID, &pDataAddr, &DataSize, &rowCount);
@@ -594,7 +594,7 @@ UINT8  MaskCfgDtStruFrmCIATSLogSgmtT(UINT8* FSDataName)
 						if ((0xFFFFu != tempMaskId) && (0u != tempMaskId))
 						{
 							/*0和0xFFFF是无效的码位*/
-							if ((CI_SUM_MAX > MaskRow) && (CI_TO_ATS_MASK_SUM_MAX > tempMaskId) && (0u < tempMaskId))/*¼ì²éÊÇ·ñΪÓÐЧÂëλֵ*/
+							if ((CI_SUM_MAX > MaskRow) && (CI_TO_ATS_MASK_SUM_MAX > tempMaskId))/*¼ì²éÊÇ·ñΪÓÐЧÂëλֵ*/
 							{
 								ConfigCiToAtsMaskConfigDataStru[MaskRow][tempMaskId].DeviceId = DeviceID;
 								ConfigCiToAtsMaskConfigDataStru[MaskRow][tempMaskId].DeviceType = CI_DEVICE_TYPE_LOGICSEC;
@@ -669,8 +669,9 @@ UINT8  MaskCfgDtStruFrmCIATSLogSgmt(UINT8 * FSDataName)
 		MASK_TYPE_LOGICSECTION_JUMPLOCK,
 		MASK_TYPE_UPWARD_DIRECTION,
 		MASK_TYPE_DOWNWARD_DIRECTION,
-		MASK_TYPE_LOGICSECTION_ARB,
+		MASK_TYPE_LOGSEC_CBTC_ARB,
 		MASK_TYPE_LOGICSECTION_SPKS_FLOCK,
+		MASK_TYPE_LOGSEC_PB_TACS_ARB,
 		1u};
 	UINT16 BuChang = 0u;
 	funcRtn = dquGetConfigDataNew(FSDataName,CI_ATS_MASK_TYPE,CI_ATS_LOGIC_SGMT_MASK_ID,&pDataAddr,&DataSize,&rowCount);
@@ -1426,7 +1427,7 @@ UINT8  MaskCfgDtStruFrmCIATSWashM(UINT8* FSDataName)
 	UINT16 residue = 0u;
 	UINT16 tempMaskId = 0u; /*码位ID临时变量*/
 
-	UINT8 MaskType[] = { 0u,MASK_TYPE_WASHMACHINE_READYSTATE,MASK_TYPE_WASHMACHINE_WORKMODE,0u };
+	UINT8 MaskType[] = { 0u,MASK_TYPE_WASHMACHINE_READYSTATE,0u };
 	UINT16 BuChang = 0u;
 	funcRtn = dquGetConfigData(FSDataName, CI_ATS_MASK_TYPE, CI_ATS_WASHMACHINE_MASK_ID, &pDataAddr, &DataSize);
 	if (0u == funcRtn)
@@ -2459,7 +2460,7 @@ UINT8  MaskCfgDtStruFrmCIZCPsdMask(UINT8 * FSDataName)
 	UINT16 DeviceID=0u;
     UINT16 tempMaskId = 0u; /*码位ID临时变量*/
     
-	UINT8 MaskType[] = { 1u,MASK_TYPE_PSD_STATE,MASK_TYPE_PSD_EXCEPT_OPEN,1u };
+	UINT8 MaskType[] = { 1u,MASK_TYPE_PSD_STATE,MASK_TYPE_PSD_EXCEPT,1u };
 	UINT16 BuChang = 0u;
 	UINT16 wTempCount = 0U;
 	funcRtn = dquGetConfigData(FSDataName,CI_ZC_MASK_TYPE,CI_ZC_PSD_MASK_ID,&pDataAddr,&DataSize);
@@ -3333,7 +3334,7 @@ UINT8  MaskCfgStruFrmCIZCAxleSgmtMask(UINT8 * FSDataName)
 	UINT8 MaskType[]={1u,MASK_TYPE_PHYSECTION_HEAD_STD,MASK_TYPE_PHYSECTION_HEAD_XTD,MASK_TYPE_PHYSECTION_OCCUPY,
 		               MASK_TYPE_PHYSECTION_ROUTELOCK,MASK_TYPE_PHYSECTION_JUMPLOCK_ZC,MASK_TYPE_AXISSECTION_ARB,MASK_TYPE_LIECHE_STOPSTATE,
 					   MASK_TYPE_PHYSECTION_HEAD_STD,MASK_TYPE_PHYSECTION_HEAD_XTD,MASK_TYPE_PHYSECTION_JUMPLOCK_APPLY,
-					   MASK_TYPE_PHYSECTION_JUMPLOCK_CANCEL,1u};
+					   MASK_TYPE_PHYSECTION_JUMPLOCK_CANCEL,MASK_TYPE_PHYSECTION_INTRUSION,MASK_TYPE_PHYSECTION_ATS_FLOCK,1u};
 	UINT16 BuChang = 0u;
 	funcRtn = dquGetConfigData(FSDataName,CI_ZC_MASK_TYPE,CI_ZC_AXLE_SGMT_MASK_ID,&pDataAddr,&DataSize);
 	if(funcRtn==0u)
@@ -3397,7 +3398,7 @@ UINT8  MaskCfgStruFrmCIZCAxleSgmtMask(UINT8 * FSDataName)
 				}
 		   }
 		}
-		else if((0u < residue )&&( residue < 6u))
+		else if(((0u < residue )&&( residue < 6u))||((11U < residue)&&(residue < 14U)))
 		{
             /*获取码位ID*/
             tempMaskId = ShortFromChar(pDataAddr);
@@ -3438,7 +3439,7 @@ UINT8  MaskCfgStruFrmCIZCAxleSgmtMask(UINT8 * FSDataName)
 			BuChang++;
 		}
 	}	
-   funcRtn = 1u;
+    funcRtn = 1u;
 	return funcRtn;
 }
 
@@ -3581,7 +3582,7 @@ UINT8  MaskCfgStruFrmZCCIAxleSgmtMask(UINT8 * FSDataName)
 	UINT8 MaskType[]={1u,MASK_TYPE_PHYSECTION_HEAD_STD,MASK_TYPE_PHYSECTION_HEAD_XTD,MASK_TYPE_PHYSECTION_OCCUPY,
 		MASK_TYPE_PHYSECTION_ROUTELOCK,MASK_TYPE_PHYSECTION_JUMPLOCK_ZC,MASK_TYPE_AXISSECTION_ARB,MASK_TYPE_LIECHE_STOPSTATE,
 		MASK_TYPE_PHYSECTION_HEAD_STD,MASK_TYPE_PHYSECTION_HEAD_XTD,MASK_TYPE_PHYSECTION_JUMPLOCK_APPLY,
-		MASK_TYPE_PHYSECTION_JUMPLOCK_CANCEL,1u};
+		MASK_TYPE_PHYSECTION_JUMPLOCK_CANCEL,MASK_TYPE_PHYSECTION_INTRUSION,MASK_TYPE_PHYSECTION_ATS_FLOCK,1u};
 	UINT16 BuChang = 0u;
 	funcRtn = dquGetConfigData(FSDataName,CI_ZC_MASK_TYPE,CI_ZC_AXLE_SGMT_MASK_ID,&pDataAddr,&DataSize);
 	if(0U == funcRtn)
@@ -3658,7 +3659,7 @@ UINT8  MaskCfgStruFrmZCCIAxleSgmtMask(UINT8 * FSDataName)
 				return funcRtn;
 			}
 		}
-		else if((6u <= residue)&&(residue <((CI_ZC_AXLE_SGMT_MASK_LEN/2u)-1u)))
+		else if((6u <= residue)&&(residue < 12U))
 		{
 			/*获取码位ID*/
 			tempMaskId = ShortFromChar(pDataAddr);
@@ -4697,7 +4698,7 @@ UINT8 MaskInit(UINT8 * FSDataName)
 	******CI到ATS码位表解析
 	********/
 	/*CI-ATS道岔码位*/
-	if (DATA_TYPE_NEW == chPulicData)
+	if (DATA_TYPE_MAIN_BRANCH == chPulicData)
 	{
 		/*CI-ATS道岔码位*/
 		funcRtn = MaskCfgDtStruFrmCIATSSwitchMask(FSDataName);
@@ -4718,7 +4719,7 @@ UINT8 MaskInit(UINT8 * FSDataName)
 	/*CI-ATS紧急停车按钮码位*/
 	funcRtn *= MaskCfgDtStruFrmCIATSEsbMask( FSDataName);
 	/*CI-ATS逻辑区段码位*/
-	if (DATA_TYPE_NEW == chPulicData)
+	if (DATA_TYPE_MAIN_BRANCH == chPulicData)
 	{
 		/*主线*/
 		funcRtn *= MaskCfgDtStruFrmCIATSLogSgmt(FSDataName);
@@ -4742,7 +4743,7 @@ UINT8 MaskInit(UINT8 * FSDataName)
 	funcRtn *= MaskCfgDtStruFrmCIATSSPKSMask(FSDataName);
 	
 	/*CI-ATS 洗车机码位*/
-	if (DATA_TYPE_NEW == chPulicData)
+	if (DATA_TYPE_MAIN_BRANCH == chPulicData)
 	{
 		/*主线*/
 		funcRtn *= MaskCfgDtStruFrmCIATSWash(FSDataName);
@@ -4773,7 +4774,7 @@ UINT8 MaskInit(UINT8 * FSDataName)
 	if(RC_WORK_MODE_CI == ciPattern)
 	{
 
-		if (DATA_TYPE_NEW == chPulicData)
+		if (DATA_TYPE_MAIN_BRANCH == chPulicData)
 		{
 			/*CI-ZC道岔码位*/
 			funcRtn *= MaskCfgDtStruFrmCIZCSwitchMask(FSDataName);
@@ -4806,7 +4807,7 @@ UINT8 MaskInit(UINT8 * FSDataName)
 		/*ZC-CI逻辑区段码位*/
 		funcRtn *= MaskCfgStruFrmZCCILogSgmtMask( FSDataName);
 		/*CI-ZC逻辑区段码位*/
-		if (DATA_TYPE_NEW == chPulicData)
+		if (DATA_TYPE_MAIN_BRANCH == chPulicData)
 		{
 			funcRtn *= MaskCfgDtStruFrmCI2ZCLogSgmt(FSDataName);
 		}
@@ -4818,7 +4819,7 @@ UINT8 MaskInit(UINT8 * FSDataName)
 		/*CI-ZC进路码位*/
 		funcRtn *= MaskCfgStruFrmCIZCRouteMask( FSDataName);
 		/*ZC-CI进路码位*/
-		if (DATA_TYPE_NEW == chPulicData)
+		if (DATA_TYPE_MAIN_BRANCH == chPulicData)
 		{
 			funcRtn *= MaskCfgDtStruFrmZC2CiRouteMask(FSDataName);
 		}

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

@@ -53,7 +53,7 @@
 #define CI_ZC_ROUTE_MASK_LEN ((UINT32)14)      /*CI-ZC进路码位字节长度--1行长度*/
 
 #define CI_ZC_AXLE_SGMT_MASK_ID  ((UINT32)5)       /*CI-ZC计轴区段码位*/
-#define CI_ZC_AXLE_SGMT_MASK_LEN ((UINT32)26)      /*CI-ZC计轴区段码位字节长度--1行长度，Modified 20151015*/
+#define CI_ZC_AXLE_SGMT_MASK_LEN ((UINT32)30)      /*CI-ZC计轴区段码位字节长度--1行长度，Modified 20151015*/
 
 #define CI_ZC_OVER_LAP_MASK_ID  ((UINT32)8)       /*CI-ZC保护区段码位*/
 #define CI_ZC_OVER_LAP_MASK_LEN ((UINT32)8)      /*CI-ZC保护区段码位字节长度--1行长度*/
@@ -114,7 +114,7 @@
 #define CI_ATS_SPKS_MASK_LEN ((UINT32)8)      /*CI-ATS SPKS开关状态码位字节长度--1行长度；2018.03.19 由6改为8，CI_ATS SPKS开关码位表增加一列开关旁路状态码位*/
 
 #define CI_ATS_WASHMACHINE_MASK_ID  ((UINT32)11)       /*CI-ATS 洗车机就绪状态码位*/
-#define CI_ATS_WASHMACHINE_MASK_LEN ((UINT32)8)      /*CI-ATS 洗车机就绪状态码位字节长度--1行长度*/
+#define CI_ATS_WASHMACHINE_MASK_LEN ((UINT32)6)      /*CI-ATS 洗车机就绪状态码位字节长度--1行长度*/
 
 #define CI_ATS_AAR_ROUTE_MASK_ID  ((UINT32)12)       /*CI-ATS全自动折返进路码位*/
 #define CI_ATS_AAR_ROUTE_MASK_LEN  ((UINT32)6)      /*CI-ATS全自动折返进路码位字节长度--1行长度*/

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

@@ -108,7 +108,7 @@
 
 /*道岔配置表*/
 #define OC_SWITCH_ID	((UINT8)2)
-#define LEN_OC_SWITCH	((UINT8)8)
+#define SWITCH_BOARD_MODE_MAX  5U  /*一个OC中道岔最多的模块数*/
 /*道岔继电器配置表*/
 #define OC_SWITCH_RELAY_ID	((UINT8)4)
 #define LEN_OC_SWITCH_RELAY	((UINT8)24)
@@ -171,7 +171,7 @@
 
 /*非进路调车继电器表*/
 #define OC_RELAY_NO_ROUTE_ID  ((UINT8)20)
-#define OC_LEN_RELAY_NO_ROUTE  ((UINT8)10)
+#define OC_LEN_RELAY_NO_ROUTE  ((UINT8)12)
 
 /*车库门继电器表*/
 #define OC_RELAY_GARAGE_DOOR_ID  ((UINT8)21)
@@ -340,6 +340,7 @@ typedef struct S_Relay_NoRouteDcStruct
     UINT16 wRelayTongYiScId;           /*同意试车继电器ID*/
 	UINT16 wRelayDrvShiCheShengQingId; /* 试车线驱动的申请试车继电器ID */
 	UINT16 wRelayColTongYiScId;			/* 试车线同意试车继电器ID */	
+	UINT16 wWaysideTryTrainIndRelayId;	/* 轨旁试车指示器继电器ID */
 } Relay_NoRouteDcStruct;
 
 /*照查继电器结构体*/
@@ -437,9 +438,11 @@ typedef struct S_Relay_WashMachineStruct
 	UINT16 TrainEmergencyStopRelayId;                                       /*全自动列车紧急停车继电器(配置字段:采集继电器)*/
 	UINT16 HeadWashAllowRelayId;                                            /*全自动允许车头清洗继电器(配置字段:采集继电器)*/
 	UINT16 TailWashAllowRelayId;     										/*全自动允许车尾清洗继电器(配置字段:采集继电器)*/
+	UINT16 wCouplingWashAllowRelayId;     									/*全自动允许联挂段清洗继电器(配置字段:采集继电器)*/
 	UINT16 WashTrainRequestRelayId;                                         /*全自动洗车请求继电器(配置字段:驱动继电器)*/
 	UINT16 TrainHeadStopSteadyRelayId;                                      /*全自动车头停稳继电器(配置字段:驱动继电器)*/
 	UINT16 TrainTailStopSteadyRelayId;                                      /*全自动车尾停稳继电器(配置字段:驱动继电器)*/
+	UINT16 wCoupingStopSteadyRelayId;                                      /*全自动车尾停稳继电器(配置字段:驱动继电器)*/
 	UINT16 TrainPassRequestRelayId;                                         /*全自动通过请求继电器(配置字段:驱动继电器)*/
 	UINT16 TrainOutWashPortAllowRelayId;                                    /*全自动允许列车出库继电器(配置字段:采集继电器)*/
 	UINT16 PauseTrainWashRequestRelayId;                                    /*全自动暂停洗车继电器(配置字段:驱动继电器)*/

TSCP/src/APP/ciapp/RemoteRM/RRMDataPrepare.c

@@ -900,6 +900,7 @@ UINT8 rrm_PrepareSwitchStatOfAC(UINT16 acID)
 	 UINT8 cycleESB = 0u;
 	 UINT8 chLinkNum  = 0u;
 	 UINT8 ESBStatus = ESB_STATE_VALID_YES;
+	 UINT8 chEsbCutState = 0U; /*ESB旁路状态*/
 	 const UINT16 *pLinkIdBuf = NULL;
 	 const DSU_DEVICE_IN_LINK_STRU* pTempDeviceStru = NULL;
 
@@ -932,14 +933,22 @@ UINT8 rrm_PrepareSwitchStatOfAC(UINT16 acID)
 					 for (cycleESB = 0u;cycleESB < pTempDeviceStru->struESBDev.wDevCount;cycleESB++)
 					 {
 						 ESBStatus = GetEsbState(pTempDeviceStru->struESBDev.wDevSetId[cycleESB]);
+						 chEsbCutState = GetEsbCutState(pTempDeviceStru->struESBDev.wDevSetId[cycleESB]);
 
-						 if (ESB_STATE_VALID_NO == ESBStatus)
+						 if (ESB_CUT_YES == chEsbCutState)
 						 {
-							 /** ESB未按下，继续遍历*/
+							 /* ESB旁路，认为按钮未按下*/
 						 }
 						 else
 						 {
-							 break;
+							 if (ESB_STATE_VALID_NO == ESBStatus)
+							 {
+								 /** ESB未按下，继续遍历*/
+							 }
+							 else
+							 {
+								 break;
+							 }
 						 }
 					 }
 
@@ -986,6 +995,7 @@ UINT8 rrm_PrepareSwitchStatOfAC(UINT16 acID)
 	 UINT8 PSDStatus = PSD_STATE_OPEN;
 	 const UINT16 *pLinkIdBuf = NULL;
 	 const DSU_DEVICE_IN_LINK_STRU* pTempDeviceStru = NULL;
+	 UINT8 chPsdMutualLockStat = 0U; /*PSD互锁解除状态*/
 
 	 chLinkNum = GetAxisLinkSum(acID);
 	 pLinkIdBuf = GetAxisLinkIdBuf(acID);
@@ -1016,15 +1026,23 @@ UINT8 rrm_PrepareSwitchStatOfAC(UINT16 acID)
 					 for (cyclePSD = 0u;cyclePSD < pTempDeviceStru->struScreenDev.wDevCount;cyclePSD++)
 					 {
 						 PSDStatus = GetPsdState(pTempDeviceStru->struScreenDev.wDevSetId[cyclePSD]);
+						 chPsdMutualLockStat = GetPsdMutualLockRemoveState(pTempDeviceStru->struScreenDev.wDevSetId[cyclePSD]);
 
-						 if (PSD_STATE_CLOSE == PSDStatus)
+						 if (PSD_MUTUALLOCK_REMOVE_YES == chPsdMutualLockStat)
 						 {
-							 /** 屏蔽门关闭，继续遍历*/
+							 /*互锁解除认为PSD状态正常，继续检查*/
 						 }
 						 else
 						 {
-							 break;
-						 }
+							 if (PSD_STATE_CLOSE == PSDStatus)
+							 {
+								 /** 屏蔽门关闭，继续遍历*/
+							 }
+							 else
+							 {
+								 break;
+							 }
+						 }		 
 					 }
 
 					 if (cyclePSD != pTempDeviceStru->struScreenDev.wDevCount)
@@ -1182,20 +1200,13 @@ UINT8 rrm_PrepareSwitchStatOfAC(UINT16 acID)
  */
 void rrm_SetRRMResult(UINT16 trainID,UINT8 rrmReply,UINT8 rrmReason,UINT8 nextOCId)
 {
-	UINT16 wRcIdWithType = 0U;
-	if (RC_WORK_MODE_CI == CI_SYSTEM_TYPE_RCI)
-	{
-		wRcIdWithType = 0x3C00U;
-	}
-	else
-	{
-		wRcIdWithType = 0x3D00U;
-	}
+	UINT16 wRcIdWithType = 0x3D00U;
+	
 	wRcIdWithType |= (UINT16)nextOCId;
 
 	SetTrainRrmState(trainID,rrmReply);
 	SetTrainRrmReson(trainID,rrmReason);
-	SetTrainNextTioc(trainID, wRcIdWithType);  /*设置下一控区ID需带0x3c，否则给IVOC组包时无法获取互联互通ID*/
+	SetTrainNextTioc(trainID, wRcIdWithType); 
 }
 
 /**

TSCP/src/APP/ciapp/RemoteRM/RRMManageAPI.c

@@ -1901,12 +1901,14 @@ static UINT8 rrm_CheckTrainHeadInFreeSta(UINT16 trainID, IN const EnvelopeStruct
 	UINT8 chHeadAcStatus = 0U; /*车头计轴区段占用状态*/
 
 	/** 入口参数校验 */
-	ASSERT_RET_VALUE((NULL == pTemp) || (0U == pTemp->ACCnt), errorCode, 0x80000000U);
-
-	headRelStaID = rrm_PrepareAtsLgcStaOfAC(pTemp->ACID[pTemp->ACCnt - 1U]);
-
-	ASSER_ERROR((0xffffU == headRelStaID), errorCode, 0x40000000U);
+	ASSER_ERROR((NULL == pTemp) || (0U == pTemp->ACCnt), errorCode, 0x80000000U);
+	if(0U == errorCode)
+	{ 
+		headRelStaID = rrm_PrepareAtsLgcStaOfAC(pTemp->ACID[pTemp->ACCnt - 1U]);
 
+		ASSER_ERROR((0xffffU == headRelStaID), errorCode, 0x40000000U);
+	}
+	
 	if (0U == errorCode)
 	{
 		trainNextSta = rrm_PrepareNextStaOfTrain(trainID);

TSCP/src/APP/ciapp/Route/DynamicRouteDataManage.c

@@ -2163,32 +2163,24 @@ static UINT8 LockDrSubRouteSwitchCheck(UINT16 wSubRouteId, UINT8 functionId, UIN
 
 	if (CI_SUCCESS == reResult)
 	{
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+		/*
+		进路内所有道岔位置正确
+		不正确：RETURN_LOCK_ERR_SWITPOS
+		正确：CI_SUCCESS
+		*/
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAllSwitchPosCheck(wSubRouteId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
 		{
-			/*
-			进路内所有道岔位置正确
-			不正确：RETURN_LOCK_ERR_SWITPOS
-			正确：CI_SUCCESS
-			*/
-			devId = 0u;
-			devState = 0u;
-			checkResult = RouteAllSwitchPosCheck(wSubRouteId, &devId, &devState);
-			if (checkResult == CI_SUCCESS)
-			{
-				/* 通过检查 */
-				reResult = CI_SUCCESS;
-			}
-			else
-			{
-				/* 失败返回 */
-				reResult = RETURN_LOCK_ERR_SWITPOS;
-
-			}
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
 		}
 		else
 		{
 			/* 失败返回 */
-			reResult = CI_ERROR;
+			reResult = RETURN_LOCK_ERR_SWITPOS;
+
 		}
 	}
 
@@ -3922,32 +3914,30 @@ static UINT8 SetDrSubRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 se
 	}
 
 	if (CI_SUCCESS == reResult)
-	{
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+	{/*进路办理防护道岔检查*/
+	 /*进路关联防护道岔【未引导总锁】*/
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteRelatedProSwitchYLockCheck(routeId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_YLOCK_STATE, devState, sendLevel);
+			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
-	}
-	else
-	{
-		/* 失败返回 */
-		reResult = CI_ERROR;
-	}
 
-	if (CI_SUCCESS == reResult)
-	{/*进路办理防护道岔检查*/
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+		if (CI_SUCCESS == reResult)
 		{
-			/*进路关联防护道岔【未引导总锁】*/
+			/*进路关联防护道岔位置正确或位置不正确但可动作*/
 			devId = 0u;
 			devState = 0u;
-			checkResult = RouteRelatedProSwitchYLockCheck(routeId, &devId, &devState);
+			checkResult = DrSubRouteProtSwiPosMovValCheck(routeId, &devId, &devState, sendLevel);
 			if (checkResult == CI_SUCCESS)
 			{
 				/* 通过检查 */
@@ -3955,37 +3945,12 @@ static UINT8 SetDrSubRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 se
 			}
 			else
 			{
-				/* 记录故障码 */
-				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_YLOCK_STATE, devState, sendLevel);
 				/* 失败返回 */
 				reResult = CI_ERROR;
 			}
-
-			if (CI_SUCCESS == reResult)
-			{
-				/*进路关联防护道岔位置正确或位置不正确但可动作*/
-				devId = 0u;
-				devState = 0u;
-				checkResult = DrSubRouteProtSwiPosMovValCheck(routeId, &devId, &devState, sendLevel);
-				if (checkResult == CI_SUCCESS)
-				{
-					/* 通过检查 */
-					reResult = CI_SUCCESS;
-				}
-				else
-				{
-					/* 失败返回 */
-					reResult = CI_ERROR;
-				}
-			}
-			else
-			{
-				reResult = CI_ERROR;
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
 			reResult = CI_ERROR;
 		}
 	}

TSCP/src/APP/ciapp/Route/LogicalRouteDataManage.c

@@ -2437,7 +2437,9 @@ void LgcSecLogicalUnlockProc(const UINT16 logRouteId, const UINT16 logSectionId,
 			/*清0 防脏数据*/
 			for (jj = chTrainSum; jj < chLgcResTrainSum; jj++)
 			{
-				(void)ComMemSet(&(pstLgcSecInfo[wLgcBufIndex].szTrainResData[jj]), (UINT16)sizeof(LogicTrainResStruct), 0U);
+				
+				/*重置资源信息结构体*/
+				ResetResInfoStruct(wLgcBufIndex, jj);
 			}
 			pstLgcSecInfo[wLgcBufIndex].chTrainInfoSum = chTrainSum;
 

TSCP/src/APP/ciapp/Route/RouteConfigDataManage.c

@@ -12,7 +12,7 @@
 
 #include "../Switch/SwitchDataManage.h"
 #include "RouteConfigDataManage.h"
-
+#include "dquCILSStruInit.h"
 RouteConfigDataStruct RouteConfigDataStru[ROUTE_SUM_MAX];   /*定义进路配置数据结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
 UINT16 LocalCiRouteIdBuf[ROUTE_SUM_MAX] = {0u};                   /*定义本地联锁进路ID映射数组*/
 INT16 RouteCurSum = 0;   /*进路当前总数(本联锁和相邻联锁发送给本联锁的进路总数),进路的特殊处理*/
@@ -3699,5 +3699,31 @@ UINT8 GetPhySecInRoutePosIndex(const UINT16 routeId, const UINT16 phySectionId)
 		retVal = ROUTE_PHYSICALSECTION_SUM_MAX;  /*返回失败*/
 	}
 
+	return retVal;
+}
+
+
+/*
+* 功能描述： 获取指定ID进路配置方向
+* 参数说明： const UINT16 routeId, 进路ID
+* 返回值  ：0x55 与Link方向一致  
+*			0xAA 与Link方向相反
+** by LYJ 20260330
+*/
+UINT8 GetRouteConfigDirection(const UINT16 routeId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
+
+	if (ROUTE_SUM_MAX > bufIndex)
+	{
+		retVal = RouteConfigDataStru[bufIndex].chRouteConfigDirection;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
 	return retVal;
 }

TSCP/src/APP/ciapp/Route/RouteConfigDataManage.h

@@ -188,7 +188,8 @@ typedef struct S_RouteConfigDataStruct
     UINT16 RouteId;              /*进路ID (配置字段)*/
 	UINT8 BelongCiId;            /*所属联锁ID (配置字段)*/
 	UINT8 BelongVirCIid;         /*所属虚拟联锁ID*/
-	UINT8 RouteDirection;        /*进路方向(向左/向右) (配置字段)*/
+	UINT8 RouteDirection;        /*进路方向(向左/向右) (配置字段叠系统定义逻辑方向与上下行方向的关系计算的上下行)*/
+	UINT8 chRouteConfigDirection; /*进路方向(向左/向右) (纯配置字段0x55 与Link方向一致  0xAA 与Link方向相反)*/
 	UINT8 RouteType;             /*进路类型(列车进路/折返进路/调车进路) (配置字段)*/
 	UINT8 ConfigRouteType;       /*配置进路类型(列车进路/折返进路/调车进路) (配置字段)*/
     UINT8 LeadProperty;          /*进路引导属性(不可引导/可引导) (配置字段)*/
@@ -1418,6 +1419,14 @@ UINT8 GetRouteThisPortecSwitchPos(const UINT16 wRouteId, const UINT16 wSwitchId)
 *			其它 位置所有
 */
 UINT8 GetPhySecInRoutePosIndex(const UINT16 routeId, const UINT16 phySectionId);
+/*
+* 功能描述： 获取指定ID进路配置方向
+* 参数说明： const UINT16 routeId, 进路ID
+* 返回值  ：0x55 与Link方向一致
+*			0xAA 与Link方向相反
+** by LYJ 20260330
+*/
+UINT8 GetRouteConfigDirection(const UINT16 routeId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/Route/RouteDataManage.h

@@ -72,7 +72,7 @@ typedef struct S_RouteDataStruct
     UINT8 RouteAssoSwitSingOperStat;									    /*进路带动道岔单操状态*/
 	UINT8 RouteInnerSwitDrivState;										    /*进路内道岔驱动状态*/
 	UINT8 RouteAssocSwitDrivState;											/*进路带动道岔驱动状态*/
-	UINT8 RouteStateFlag;													/*进路状态标志（1：表示有效；0：表示无效）*/
+	UINT8 RouteStateFlag;													/*进路状态标志（0x55：表示有效；0xAA：表示无效）*/
 	UINT8 TrainEnterFlag;													/*列车驶入标志*/
 	UINT8 ZongRenJieDelayType;												/*总人解延时类型，分为：倒计时结束后立刻全部区段解锁，第一个占压的物理区段前变异常锁闭，所有的物理区段变异常锁闭*/
 	UINT8 RecoverOpenState;													/*进路需要重开状态，用于处理PSD、SPKS、扣车恢复重开信号*/

TSCP/src/APP/ciapp/Section/AxisSectionConfigDataManage.c

@@ -17,7 +17,7 @@
 
 AxisSectionConfigDataStruct AxisSectionConfigDataStru[AXIS_SECTION_SUM_MAX];   /*定义计轴区段配置数据结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
 UINT16 LocalCiAxisSectionIdBuf[AXIS_SECTION_SUM_MAX] = {0u};                   /*定义本地联锁计轴区段ID映射数组*/
-INT16 AxisSectionCurSum = 0;   /*逻辑区段当前总数*/
+INT16 AxisSectionCurSum = 0;   /*计轴区段当前总数*/
 UINT16 totalAxisNum = 0u;       /*本联锁+相邻联锁的计轴区段ID数量*/
 
 /*
@@ -1150,4 +1150,56 @@ UINT8 GetAxisSecCbtcProperty(const UINT16 axisSectionId)
 	}
 
 	return retVal;
-}
+}
+
+/*
+* 功能描述： 获取指定ID计轴区段关联防护道岔数目
+* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 道岔数目
+*  创建	  :  mpt 20260331
+*/
+UINT8 GetAxisSecRelateProSwSum(const UINT16 wAxisSecId)
+{
+	UINT16 wBufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取计轴区段数组下标*/
+
+	if (AXIS_SECTION_SUM_MAX > wBufIndex)
+	{
+		retVal = AxisSectionConfigDataStru[wBufIndex].chRelateProSwSum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+
+/*
+* 功能描述： 获取指定ID计轴区段关联防护道岔结构体
+* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 道岔ID数组指针
+* 创建	  : mpt 20260331
+*/
+AxisSwitchStruct* GetAxisSecRelateProSwStru(const UINT16 wAxisSecId)
+{
+	UINT16 wBufIndex = 0u;  /*数组下标*/
+	AxisSwitchStruct* retVal = NULL;
+
+	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取数组下标*/
+
+	if (AXIS_SECTION_SUM_MAX > wBufIndex)
+	{
+		retVal = AxisSectionConfigDataStru[wBufIndex].wRelateProSwId;
+	}
+	else
+	{
+		retVal = NULL;
+	}
+	return retVal;
+}
+

TSCP/src/APP/ciapp/Section/AxisSectionConfigDataManage.h

@@ -53,6 +53,8 @@ typedef struct S_AxisSectionConfigDataStruct
 	UINT8 chAxisLinXian;			/*计轴临线属性-是否为本线路-电子地图Link表获得*/
 	UINT32 dwAxisTotalLen;   /*计轴关联link总长*/
 	UINT8 cAcCbtcAttr;  /*计轴区段CBTC区域属性：0x55-具有CBTC区域属性，0xaa-不具有CBTC区域属性*/
+	UINT8 chRelateProSwSum; /* add by mpt 20260331  计轴区段关联防护道岔数量*/
+	AxisSwitchStruct wRelateProSwId[AXIS_RELATE_PRO_SW_SUM_MAX];/* add by mpt 20260331  计轴区段关联防护道岔ID数组*/
 } AxisSectionConfigDataStruct;
 
 extern AxisSectionConfigDataStruct AxisSectionConfigDataStru[AXIS_SECTION_SUM_MAX];   /*定义计轴区段配置数据结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
@@ -320,6 +322,22 @@ UINT8 GetAxisSecBorderProperty(const UINT16 axisSectionId);
 * Created By LQ 2025.08.05
 */
 UINT8 GetAxisSecCbtcProperty(const UINT16 axisSectionId);
+/*
+* 功能描述： 获取指定ID计轴区段关联防护道岔数目
+* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 道岔数目
+*  创建	  :  mpt 20260331
+*/
+UINT8 GetAxisSecRelateProSwSum(const UINT16 wAxisSecId);
+/*
+* 功能描述： 获取指定ID计轴区段关联防护道岔结构体
+* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 道岔ID数组指针
+* 创建	  : mpt 20260331
+*/
+AxisSwitchStruct* GetAxisSecRelateProSwStru(const UINT16 wAxisSecId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/Section/AxisSectionDataManage.c

@@ -503,20 +503,43 @@ void SetAxisIncludeLogSecArbState(const UINT16 wAxisSectionId, const UINT8 chSta
 	UINT16* pLogSectionIdBuf = NULL;/*计轴区段包含逻辑区段ID*/
 	UINT8 chLogSectionSum = 0U;/*计轴区段包含逻辑区段数目*/
 	UINT8 ii = 0U;
+	UINT8 cLocalCiId = 0U;
+	UINT8 chLogSecBelongCi = 0U;
+	UINT8 chCheckFlag = 0U;
 
 	pLogSectionIdBuf = GetAxisSecLogSectionIdBuf(wAxisSectionId);
 	chLogSectionSum = GetAxisSecLogSectionSum(wAxisSectionId);
-
+	cLocalCiId = GetSystemParaLocalCiId();
+	
 	if (NULL != pLogSectionIdBuf)
 	{
 		for (ii = 0U; ii < chLogSectionSum; ii++)
 		{
 			if ((LGC_SECTION_ARB_NO == chState) || (LGC_SECTION_ARB_YES == chState))
 			{
-				SetLgcArbState(pLogSectionIdBuf[ii], chState);
+				chLogSecBelongCi = GetLogSecBelongCiId(pLogSectionIdBuf[ii]);
+				chCheckFlag = IsSameLineCI(cLocalCiId, chLogSecBelongCi);
+				if (SAME_LINE_NO == chCheckFlag)
+				{
+					SetLgcArbState(pLogSectionIdBuf[ii], chState); 
+					SetLogSecCbtcArbState(pLogSectionIdBuf[ii], chState);  /*互联互通，不同线路设置CBTCARB；用于显示*/
+				}
+				else
+				{
+					SetLgcArbState(pLogSectionIdBuf[ii], chState);
+				}
+				
+			}
+			else
+			{
+				/*不处理*/
 			}
 		}
 	}
+	else
+	{
+		/*不处理*/
+	}
 }
 
 /*
@@ -854,4 +877,49 @@ void SetAxisSecArbStateCC(const UINT16 axisSectionId, const UINT8 arbState)
 	{
 		; /*不设置*/
 	}
+}
+
+/*
+* 功能描述：计轴区段状态处理
+* 参数说明：void
+* 返 回 值：无
+* by cgh 20260327
+*/
+void AxisSecStateDeal(void)
+{
+	UINT8 cLocalCiId = 0U; /*本地联锁ID*/
+	UINT16 ii = 0U;
+	UINT16 wAxisSecSum = 0U;  /*本控区计轴区段数量*/
+	UINT16 wAxisSecId = 0U;  /*计轴区段ID*/
+	UINT8 cAxisSecBlongCiId = 0U;  /*计轴区段所属控区*/
+	UINT8 chAcArbState = 0U; /*计轴区段ARB状态*/
+
+	cLocalCiId = GetSystemParaLocalCiId();
+	wAxisSecSum = GetAxisSecCurSum();
+	/*遍历本控区计轴区段*/
+	for (ii = 0U; ii < wAxisSecSum; ii++)
+	{
+		wAxisSecId = GetAxisSecId(ii);
+		cAxisSecBlongCiId = GetAxisSectionBelongCiId(wAxisSecId);
+
+		if ((cLocalCiId == cAxisSecBlongCiId) && (0U != cAxisSecBlongCiId))
+		{
+			chAcArbState = aam_GetAxisStatusAPI(wAxisSecId);
+			/* 计轴区段ARB，则逻辑区段ARB */
+			if (AAM_STATUS_ARB == chAcArbState)
+			{
+				/*设置RC计轴区段ARB状态为ARB*/
+				SetAxisSecArbStateCC(wAxisSecId, AXIS_SECTION_ARB_YES);
+			}
+			else
+			{
+				/*设置RC计轴区段ARB状态为未ARB*/
+				SetAxisSecArbStateCC(wAxisSecId, AXIS_SECTION_ARB_NO);
+			}
+		}
+		else
+		{
+			; /*不属于本控区，只是异常防护*/
+		}
+	}
 }

TSCP/src/APP/ciapp/Section/AxisSectionDataManage.h

@@ -288,6 +288,14 @@ UINT8 GetAxisSecArbStateCC(const UINT16 axisSectionId);
 */
 void SetAxisSecArbStateCC(const UINT16 axisSectionId, const UINT8 arbState);
 
+/*
+* 功能描述：计轴区段状态处理
+* 参数说明：void
+* 返 回 值：无
+* by cgh 20260327
+*/
+void AxisSecStateDeal(void);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Section/LogicSectionConfigDataManage.h

@@ -89,6 +89,9 @@ typedef struct S_LogicSectionConfigDataStruct
 	UINT16 logSecRltPsdBuf[LOGSEC_RELATE_PSD_MAX]; /*逻辑区段关联屏蔽门ID数组*/
 	UINT8 logSecRltEsbSum;   /*关联紧急按钮数量*/
 	UINT16 logSecRltEsbBuf[LOGSEC_RELATE_ESB_MAX]; /*逻辑区段关联紧急按钮ID数组*/
+
+	UINT8 chRelateOverLapSum; /* add by mpt 20260330  逻辑区段关联保护区段数量*/
+	UINT16 wRelateOverLapIdBuf[LOGSEC_RELATE_OVERLAP_SUM_MAX];/* add by mpt 20260330  逻辑区段关联保护区段ID数组*/
 } LogicSectionConfigDataStruct;
 
 /*******************************全局变量声明*******************************/

TSCP/src/APP/ciapp/Section/LogicSectionDataManage.c

@@ -1099,7 +1099,6 @@ void RemoveLogSecTrainInfoById(const UINT16 wLogSectionId, const UINT16 wTrnId)
 	UINT8  chTrainSum = 0U;
 	UINT8 ii = 0U;
 	UINT8 chNeedKeepSum = 0U;
-	LogicTrainResStruct * pLogicTrainInfo = NULL;
 
 	wBufIndex = GetlogSectionBufIndex(wLogSectionId);  /*获取区段数组下标*/
 
@@ -1406,7 +1405,7 @@ void AddLogSecTrainResFromCI(const UINT16 wLogSectionId, const UINT16 wTrnId)
 
 		if (TRANSMIT_STATE_GOOD == trainTransSta)
 		{
-			trainInRoutePos = dsuTrainMinHeadCrossSignal(wTrnId, wRLockBelongRouteId);
+			trainInRoutePos = dsuTrainMinHeadCrossSignal(wTrnId, wRLockBelongRouteId, CI_ERROR);
 			if ((ROUTE_AUTOROUTE_NORMAL == autoRouteType)
 				|| (ROUTE_AUTOROUTE_NORMAL == autoProtRouteType)
 				|| (ROUTE_AUTOSIGROUTE_YES == (ROUTE_AUTOSIGROUTE_YES & autoSigRouteType))
@@ -1589,7 +1588,6 @@ void ClearLgcSecResTrain(UINT16 wLogSecId)
 	UINT8 chTrainResSum = 0U;
 	UINT16 wBufIndex = 0U;
 	UINT8 ii = 0U;
-	UINT8 logRouteSum = 0;
 	UINT16 wTrainId = 0U;			/*列车ID*/
 	UINT16 chFlag = 0U;
 	UINT8 chNeedKeepSum = 0U;
@@ -1620,7 +1618,8 @@ void ClearLgcSecResTrain(UINT16 wLogSecId)
 		/*清0防脏*/
 		for (ii = chNeedKeepSum; ii < LOGIC_SECTION_RES_SUM_MAX; ii++)
 		{
-			(void)ComMemSet(&(LogicSectionDataStruCC[wBufIndex].szTrainResData[ii]), (UINT16)sizeof(LogicTrainResStruct), 0U);
+			/*重置资源信息结构体*/
+			ResetResInfoStruct(wBufIndex, ii);
 		}
 		LogicSectionDataStruCC[wBufIndex].chTrainInfoSum = chNeedKeepSum;
 	}
@@ -1647,7 +1646,7 @@ void CpyLgcSecResTrain(UINT16 wLogSecId,UINT8 chTrainSum, LogicTrainResStruct *p
 	}
 	else
 	{
-		(void)ComMemCopy(pstLgcResInfo, (LogicSectionDataStruCC[wBufIndex].szTrainResData), (UINT16)(sizeof(LogicTrainResStruct)*LOGIC_SECTION_RES_SUM_MAX));
+		(void)ComMemCopy((UINT8*)pstLgcResInfo, (UINT8*)(LogicSectionDataStruCC[wBufIndex].szTrainResData), (UINT16)(sizeof(LogicTrainResStruct)*LOGIC_SECTION_RES_SUM_MAX));
 		LogicSectionDataStruCC[wBufIndex].chTrainInfoSum = chTrainSum;
 	}
 }
@@ -1774,7 +1773,7 @@ void SetLogSecTrainLockApply(const UINT16 wLogSectionId, const UINT16 wTrnId)
 						}
 						else
 						{
-							trainInRoutePos = dsuTrainMinHeadCrossSignal(wTrnId, wRLockBelongRouteId);
+							trainInRoutePos = dsuTrainMinHeadCrossSignal(wTrnId, wRLockBelongRouteId, CI_ERROR);
 							if ((TRAIN_ENTER_ROUTE_FULL == trainInRoutePos) || (TRAIN_ENTER_ROUTE_TAIL == trainInRoutePos))
 							{
 								; /*不处理 V12.0.2变更2*/
@@ -1900,17 +1899,10 @@ UINT8 GetLgcSecResCanAdd(const UINT16 wLogSectionId,const UINT16 wTrnId)
 	UINT16 wBufIndex = 0u;  /*数组下标*/
 	UINT16 wRLockBelongRouteId = 0U;
 	UINT16 wRLockStartSignalId = 0U;
-	UINT16 wPLockStartSignalId = 0U;
-	UINT16 wPLockEndSignalId = 0U;
 	UINT16 wRLockLightUpTrainId = 0U;
-	UINT16 wPLockLightUpTrainId = 0U;
-	UINT16 wRouteLockOverLapId = 0U;
-	UINT8  chOverLapBelongCiId = 0U;
-	UINT8 chTrainCrossPLockStt = 0U;
 	UINT8 chTrainCrossRLockStt = 0U;
 	UINT8 cRouteCId = 0u;
 	UINT8 cLocalCiId = 0u;
-	UINT8 chLgcResShareFlag = 0U;
 	UINT8 autoRouteType = 0U;
 	UINT8 autoSigRouteType = 0U;
 	UINT8 autoProtRouteType = 0U;
@@ -2820,7 +2812,7 @@ UINT8 GetLogSecResShareFlag(const UINT16 wLgcSecId)
 		/*返回错误*/
 		funRetVal = CI_ERROR;
 	}
-	return funRetVal;
+	return LOGIC_SECTION_RES_SHARE_YES;
 }
 
 /*
@@ -2895,7 +2887,7 @@ void RemoveLgcSecResTrain(UINT16 wLogSecId, UINT16 wTrainId)
 			if (wLgcResTrainId == wTrainId) 
 			{
 				/*删除该列车对应逻辑区段资源*/
-				(void)ComMemSet((void *)&pstLgcSecInfo[wLgcBufIndex].szTrainResData[jj], (UINT16)sizeof(LogicTrainResStruct), 0U);
+				ResetResInfoStruct(wLgcBufIndex, jj);
 				debug_infor_printf((const)"LogSecRes Remove LgcId: %d TrainId:%d  Cyc\n"
 					, wLogSecId
 					, wTrainId
@@ -2983,7 +2975,7 @@ UINT8 GetBackUpVobcMinTsr(UINT16* minSpeed, UINT16 logSum, UINT16 szLogId[])
 			{
 				if (pTsrData[jj].cSpeed < *minSpeed)
 				{
-					for (mm == 0U; mm < pTsrData[jj].cLogSecSum; mm++)
+					for (mm = 0U; mm < pTsrData[jj].cLogSecSum; mm++)
 					{
 						for (kk = 0U; kk < logSum; kk++)
 						{
@@ -3037,7 +3029,7 @@ void SetTsrSum(UINT8 cTsrSum)
 */
 TsrDataStruct* GetTsrData(void)
 {
-	return &g_TsrDataStru;
+	return g_TsrDataStru;
 }
 
 /*
@@ -3790,6 +3782,9 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 {
 	UINT16 bufIndex = 0u;  /*数组下标*/
 	UINT8 checkResult = CI_ERROR;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
+	UINT8 retVal = 0u;
 
 	/** 获取逻辑区段数组下标*/
 	bufIndex = GetlogSectionBufIndex(logSectionId);
@@ -3811,9 +3806,26 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 			else
 			{
 				/** 设置跳跃锁闭允许标志为允许 */
-				SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+
+			
+				ClearLogSeceSwitchDanCaoPos(logSectionId);/*清除单操位置*/
 				/** 设置逻辑区段跳跃锁闭 */
 				SetLogSecJumpLockState(logSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+
+				SetLogSecRelProSwitchLockSta(logSectionId, SWITCH_LOCK_PROTECT_SET);
+
+				devId = 0u;
+				devState = 0u;
+				retVal = LogicSecRltvPrtctSwLockCheck(logSectionId, &devId, &devState);
+				if (CI_SUCCESS == retVal)
+				{/*防护道岔锁检查*/
+					SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+				}
+				else
+				{
+					SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
+				}
+			
 			}
 		}
 		/** 逻辑区段跳跃锁闭未锁闭*/
@@ -3823,6 +3835,8 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 			SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
 			/** 设置跳跃锁闭未锁闭 */
 			SetLogSecJumpLockState(logSectionId, LOGIC_SECTION_JUMP_LOCK_NO);
+
+			SetLogSecRelProSwitchLockSta(logSectionId, SWITCH_LOCK_PROTECT_CANCEL);
 		}
 		else
 		{
@@ -4283,7 +4297,7 @@ UINT8 GetLgcArbState(const UINT16 wLgcId)
 }
 
 /*
-* 功能描述： 设置制定逻辑区段ARB状态
+* 功能描述： 设置指定逻辑区段ARB状态
 * 参数说明： const UINT16 wLgcId, 逻辑区段ID
 *			const UINT8 chArb ARB状态
 * 返回值  ： 无
@@ -4384,6 +4398,7 @@ void SetLgcArbStateProc(void)
 		}
 	}
 }
+
 /*
 * 功能描述： 获取指定逻辑区段延时故障锁闭起始周期号
 * 参数说明： const UINT16 logSectionId, 逻辑区段ID
@@ -4460,7 +4475,6 @@ UINT8 GetLogicSupicTrainStat(UINT16 wLgcId)
 	UINT8 chIndex = 0u;
 	UINT8 chRtn = CI_ERROR;
 	TRAIN_SEQUANCE_s strTmp[SIZE_MAX_TRAINOFAC] = { 0u };
-	TRAIN_SEQUANCE_s strTmpB = { 0u };
 	UINT8 chTrainNum = 0u;
 	chLinkNum = GetSecIntrudeLinkSum(wLgcId);
 	pLinkId = GetSecIntrudeLinkIdBuf(wLgcId);
@@ -4853,7 +4867,7 @@ UINT8 DelLogSecBelongLogRouteId(const UINT16 logSectionId, const UINT16 wLogRout
 				}
 			}
 			/* 清0防止脏数据*/
-			(void)ComMemSet(&logRoutBuf[chNeedKeepSum], (UINT16)sizeof(LogSecLockBelLogRouteStruct), 0U);
+			(void)ComMemSet((UINT8*)&logRoutBuf[chNeedKeepSum], (UINT16)sizeof(LogSecLockBelLogRouteStruct), 0U);
 			LogicSectionDataStruCC[bufIndex].chLogSecLockBelLogRouteSum = chNeedKeepSum;/*修改所属逻辑进路数量*/
 			retVal = CI_SUCCESS;
 		}
@@ -4883,8 +4897,6 @@ UINT8 AddLogSecBelongLogRouteId(const UINT16 logSectionId, const UINT16 wLogRout
 	LogSecLockBelLogRouteStruct* logRoutBuf = NULL;  /*逻辑区段所属逻辑进路数组*/
 	UINT16 logRoutSum = 0U;  /*逻辑区段所属逻辑进路数组数量*/
 	UINT8 retVal = CI_ERROR;
-	UINT8 ii = 0U;
-	UINT8 chNeedKeepSum = 0U;
 
 	bufIndex = GetlogSectionBufIndex(logSectionId);  /*获取区段数组下标*/
 
@@ -4980,7 +4992,7 @@ void SetLogSecLogLockState(const UINT16 wLogSectionId, const UINT8 chLogLockStat
 {
 	UINT16 wBufIndex = 0U;  /*数组下标*/
 	UINT16 LogSecLockBelongRouteId = 0U;
-
+	UINT8 index = 0U;
 	wBufIndex = GetlogSectionBufIndex(wLogSectionId);  /*获取区段数组下标*/
 
 	if (LOGIC_SECTION_SUM_MAX > wBufIndex)
@@ -4998,9 +5010,10 @@ void SetLogSecLogLockState(const UINT16 wLogSectionId, const UINT8 chLogLockStat
 			else
 			{
 				LogicSectionDataStruCC[wBufIndex].chTrainInfoSum = 0U;
-				(void)CommonMemSet(LogicSectionDataStruCC[wBufIndex].szTrainResData, \
-					(UINT32)sizeof(LogicSectionDataStruCC[wBufIndex].szTrainResData), \
-					0U, (UINT32)sizeof(LogicSectionDataStruCC[wBufIndex].szTrainResData));
+				for(index = 0U; index < LOGIC_SECTION_RES_SUM_MAX; index++)
+				{
+					ResetResInfoStruct(wBufIndex, index);
+				}
 			}
 
 		}
@@ -5184,7 +5197,7 @@ void SetLogSecLogLockStateOtherCi(const UINT16 wLogSectionId, const UINT8 chLogL
 {
 	UINT16 wBufIndex = 0U;  /*数组下标*/
 	UINT8 cLogSecLockState = 0U;  /*逻辑区段锁闭状态*/
-
+	UINT8 jj = 0U;	
 	wBufIndex = GetlogSectionBufIndex(wLogSectionId);  /*获取区段数组下标*/
 
 	if (LOGIC_SECTION_SUM_MAX > wBufIndex)
@@ -5199,7 +5212,10 @@ void SetLogSecLogLockStateOtherCi(const UINT16 wLogSectionId, const UINT8 chLogL
 			{
 				/*进路锁闭和逻辑锁闭均未锁闭，清除逻辑区段资源列车信息*/
 				LogicSectionDataStruCC[wBufIndex].chTrainInfoSum = 0U;
-				(void)CommonMemSet(LogicSectionDataStruCC[wBufIndex].szTrainResData, (UINT32)sizeof(LogicSectionDataStruCC[wBufIndex].szTrainResData), 0U, (UINT32)sizeof(LogicSectionDataStruCC[wBufIndex].szTrainResData));
+				for (jj = 0U; jj < LOGIC_SECTION_RES_SUM_MAX; jj++)
+				{
+					ResetResInfoStruct(wBufIndex, jj);
+				}
 			}
 			else
 			{
@@ -5647,7 +5663,6 @@ UINT8 GetLogSecLockBelLogRouteBuf(const UINT16 wLgcId,OUT LogSecLockBelLogRouteS
 void SetLogSecLockStateHlht(UINT16 wLogSectionId, const UINT8 lockState)
 {
 	UINT16 bufIndex = 0u;  /*数组下标*/
-	UINT8 preLockState = 0u;
 
 	bufIndex = GetlogSectionBufIndex(wLogSectionId);  /*获取区段数组下标*/
 
@@ -5715,13 +5730,13 @@ void SetLogSecLockDirHlht(UINT16 wLogSectionId, const UINT8 lockDir)
 
 	if (bufIndex < LOGIC_SECTION_SUM_MAX)
 	{
-		if (CI_SYSTEM_DIRECTION_NONE == lockDir)
+		if ((CI_SYSTEM_DIRECTION_UP == lockDir) || (CI_SYSTEM_DIRECTION_DOWN == lockDir))
 		{
-			LogicSectionDataStru[bufIndex].LogLockDir = CI_SYSTEM_DIRECTION_NONE;
+			LogicSectionDataStru[bufIndex].LogLockDir = lockDir;
 		}
 		else
 		{
-			LogicSectionDataStru[bufIndex].LogLockDir = lockDir;
+			LogicSectionDataStru[bufIndex].LogLockDir = CI_SYSTEM_DIRECTION_NONE;
 		}
 	}
 	else
@@ -5756,11 +5771,10 @@ void SetLogSecPLockRouteIdHlht(UINT16 wLogSectionId, const UINT16 routeId)
 /*
 * 功能描述：设置互联互通其它联锁逻辑区段锁闭所属的进路ID
 * 参数说明：UINT16 wLogSectionId, 逻辑区段ID
-			const UINT16 routeId,锁闭所属的进路ID
 * 返回值  ：无
 * by 20250117
 */
-void SetLogSecRLockRouteIdHlht(UINT16 wLogSectionId, const UINT16 routeId)
+void SetLogSecRLockRouteIdHlht(UINT16 wLogSectionId)
 {
 	UINT16 bufIndex = 0u;  /*数组下标*/
 
@@ -6382,10 +6396,6 @@ UINT8 ReqAlignmentInfoCalc(void)
 			{
 				break;
 			}
-			else
-			{
-				/*继续执行*/
-			}
 		}
 	}
 	else
@@ -6396,4 +6406,249 @@ UINT8 ReqAlignmentInfoCalc(void)
 	}
 
 	return chRetVal;
-}
+}
+
+/*
+* 功能描述： 获取给ATS的逻辑区段ARB状态
+* 参数说明： const UINT16 wLgcId 逻辑区段状态
+*            const UINT8 chDevType 设备类型
+* 返回值  ： LGC_SECTION_ARB_NO 逻辑区段未ARB
+*            LGC_SECTION_ARB_YES 逻辑区段ARB
+* by cgh 20260327
+*/
+UINT8 GetToAtsLgcArbState(const UINT16 wLgcId,const UINT8 chDevType)
+{
+	UINT8 chReval = LGC_SECTION_ARB_NO;
+	UINT8 chAcNum = 0U; /*逻辑区段对应计轴区段数目*/
+	UINT16* pAcId = NULL; /*逻辑区段关联计轴区段ID*/
+	UINT8 chAcIndex = 0U; /*计轴区段循环索引*/
+	UINT8 chAcArbState = 0U; /*计轴区段ARB状态*/
+
+	chAcNum = GetLgcSecRelativeAxleSecSum(wLgcId);
+	pAcId = GetLgcSecRltvAxleSecIdBuf(wLgcId);
+
+	/*逻辑区段关联计轴区段数据合法*/
+	if ((0U != chAcNum) && (NULL != pAcId) && ((RC_WORK_MODE_TIOC == chDevType) || (RC_WORK_MODE_CI == chDevType)))
+	{
+		/*遍历逻辑区段关联的所有计轴区段*/
+		for (chAcIndex = 0U; chAcIndex < chAcNum; chAcIndex++)
+		{
+			/*当前系统工作模式为RC*/
+			if (RC_WORK_MODE_TIOC == chDevType)
+			{
+				chAcArbState = GetAxisSecArbStateCC(pAcId[chAcIndex]);
+			}
+			/*当前系统工作模式为CI*/
+			else
+			{
+				chAcArbState = GetAxisSecArbStateZc(pAcId[chAcIndex]);
+			}
+			
+			/* 计轴区段ARB，则逻辑区段ARB */
+			if (AXIS_SECTION_ARB_YES == chAcArbState)
+			{
+				chReval = LGC_SECTION_ARB_YES;
+				/*找到逻辑区段关联的任意一个计轴区段ARB，则不再继续查找，认为逻辑区段ARB*/
+				break;
+			}
+			else
+			{
+				/* 计轴区段非ARB，继续查找 */
+				;
+			}
+		}
+	}
+	else
+	{
+		/* 数据获取失败 */
+	}
+	return chReval;
+}
+
+/*
+* 功能描述： 获取指定逻辑区段CBTC_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+* 返回值  ： 0: 获取失败
+*			 >0: 逻辑区段CBTC_ARB状态
+* BY CGH 20260330
+*/
+UINT8 GetLogSecCbtcArbState(const UINT16 wLgcId)
+{
+	UINT16 bufIndex = LGC_SECTION_ARB_NO;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetlogSectionBufIndex(wLgcId);  /*获取区段数组下标*/
+
+	if (LOGIC_SECTION_SUM_MAX > bufIndex)
+	{
+		retVal = LogicSectionDataStru[bufIndex].chLogSecCbtcArbState;
+	}
+	else
+	{
+		;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置指定逻辑区段CBTC_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+*			const UINT8 chArb ARB状态
+* 返回值  ： 无
+* BY CGH 20260330
+*/
+void SetLogSecCbtcArbState(const UINT16 wLgcId, const UINT8 chArb)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetlogSectionBufIndex(wLgcId);  /*获取区段数组下标*/
+
+	if ((LOGIC_SECTION_SUM_MAX > bufIndex)
+		&& ((LGC_SECTION_ARB_NO == chArb) || (LGC_SECTION_ARB_YES == chArb)))
+	{
+		LogicSectionDataStru[bufIndex].chLogSecCbtcArbState = chArb;
+	}
+	else
+	{
+		;
+	}
+}
+
+/*
+* 功能描述： 获取指定逻辑区段PB_TACS_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+* 返回值  ： 0: 获取失败
+*			 >0: 逻辑区段PB_TACS_ARB状态
+* BY CGH 20260330
+*/
+UINT8 GetLogSecPbTacsArbState(const UINT16 wLgcId)
+{
+	UINT16 bufIndex = LGC_SECTION_ARB_NO;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetlogSectionBufIndex(wLgcId);  /*获取区段数组下标*/
+
+	if (LOGIC_SECTION_SUM_MAX > bufIndex)
+	{
+		retVal = LogicSectionDataStru[bufIndex].chLogSecPbTacsArbState;
+	}
+	else
+	{
+		;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置指定逻辑区段PB_TACS_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+*			const UINT8 chArb ARB状态
+* 返回值  ： 无
+* BY CGH 20260330
+*/
+void SetLogSecPbTacsArbState(const UINT16 wLgcId, const UINT8 chArb)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetlogSectionBufIndex(wLgcId);  /*获取区段数组下标*/
+
+	if ((LOGIC_SECTION_SUM_MAX > bufIndex)
+		&& ((LGC_SECTION_ARB_NO == chArb) || (LGC_SECTION_ARB_YES == chArb)))
+	{
+		LogicSectionDataStru[bufIndex].chLogSecPbTacsArbState = chArb;
+	}
+	else
+	{
+		;
+	}
+}
+
+/*
+* 功能描述： 设置发送给ATS的逻辑区段ARB状态
+* 参数说明： 无
+* 返回值  ： 无
+* by cgh 20260330
+*/
+void SetSendAtsLgcArbState(void)
+{
+	UINT8 chLocalId = 0U; /*本地联锁ID*/
+	UINT8 chBelongCiId = 0U; /*所属联锁ID*/
+	UINT16 wLgcNum = 0U; /*逻辑区段数目*/
+	UINT16 wLgcIndex = 0U; /*逻辑区段索引ID*/
+	UINT16 wLgcId = 0U; /*逻辑区段ID*/
+	UINT8 chArbState = 0U; /*ARB状态*/
+
+	chLocalId = GetSystemParaLocalCiId();
+
+	/* 获取逻辑区段数量 */
+	wLgcNum = GetLogicSecCurSum();
+
+	for (wLgcIndex = 0u; wLgcIndex < wLgcNum; wLgcIndex++)
+	{
+		wLgcId = GetLogicSecId(wLgcIndex);
+		chBelongCiId = GetLogSecBelongCiId(wLgcId);
+
+		if ((chLocalId == chBelongCiId) && (0U != chBelongCiId))
+		{
+			/*处理CBTC_ARB状态*/
+			chArbState = GetToAtsLgcArbState(wLgcId, RC_WORK_MODE_CI);
+
+			if (LGC_SECTION_ARB_YES == chArbState)
+			{
+				SetLogSecCbtcArbState(wLgcId, LGC_SECTION_ARB_YES);
+			}
+			else
+			{
+				SetLogSecCbtcArbState(wLgcId, LGC_SECTION_ARB_NO);
+			}
+
+			/*处理PB_TACS_ARB状态*/
+			chArbState = GetToAtsLgcArbState(wLgcId, RC_WORK_MODE_TIOC);
+
+			if (LGC_SECTION_ARB_YES == chArbState)
+			{
+				SetLogSecPbTacsArbState(wLgcId, LGC_SECTION_ARB_YES);
+			}
+			else
+			{
+				SetLogSecPbTacsArbState(wLgcId, LGC_SECTION_ARB_NO);
+			}
+			
+		}
+		else
+		{
+			; /* 数据获取失败 */
+		}
+	}
+}
+
+/*
+* 功能描述： 重置资源信息结构体
+* 参数说明： UINT16 logicSectionId 逻辑区段ID
+*			 UINT8 index 资源信息结构体数组索引
+* 返回值  ： 无
+*/
+void ResetResInfoStruct(UINT16 logicSectionId, UINT8 index)
+{
+	if (LOGIC_SECTION_SUM_MAX > logicSectionId)
+	{
+
+		if (LOGIC_SECTION_RES_SUM_MAX > index)
+		{
+			LogicSectionDataStruCC[logicSectionId].szTrainResData[index].wTrainId = 0U;
+			LogicSectionDataStruCC[logicSectionId].szTrainResData[index].chLogicResUsable = LOGIC_SECTION_RES_UNUSABLE;
+			LogicSectionDataStruCC[logicSectionId].szTrainResData[index].chLogicReturnState = LOGIC_SECTION_TRAIN_RETURN_NO;
+			LogicSectionDataStruCC[logicSectionId].szTrainResData[index].chTrainApplyState = LOGIC_SECTION_TRAIN_APPLY_NO;
+			LogicSectionDataStruCC[logicSectionId].szTrainResData[index].chLogicUnlockState = LOGIC_SECTION_TRAIN_UNLOCK_NO;
+			LogicSectionDataStruCC[logicSectionId].szTrainResData[index].dwRcvUnlockCmdCyc = 0U;
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		; /*不处理*/
+	}
+}

TSCP/src/APP/ciapp/Section/LogicSectionDataManage.h

@@ -75,6 +75,8 @@ typedef struct S_LogicSectionDataStruct
 	UINT8  chLogicSpksFLockState;	                  /*逻辑区段被SPKS封锁状态	0x55 未封锁 0xaa 封锁*/
 
 	UINT8 chLogSecEmergXianSu;        /*逻辑区段紧急临时限速*/
+	UINT8 chLogSecCbtcArbState;     /*逻辑区段CBTC_ARB状态*/
+	UINT8 chLogSecPbTacsArbState;     /*逻辑区段PB_TACS_ARB状态*/
 } LogicSectionDataStruct;
 
 /*逻辑区段结构体-车车*/
@@ -1310,11 +1312,10 @@ void SetLogSecPLockRouteIdHlht(UINT16 wLogSectionId, const UINT16 routeId);
 /*
 * 功能描述：设置互联互通其它联锁逻辑区段锁闭所属的进路ID
 * 参数说明：UINT16 wLogSectionId, 逻辑区段ID
-			const UINT16 routeId,锁闭所属的进路ID
 * 返回值  ：无
 * by 20250117
 */
-void SetLogSecRLockRouteIdHlht(UINT16 wLogSectionId, const UINT16 routeId);
+void SetLogSecRLockRouteIdHlht(UINT16 wLogSectionId);
 
 /*
 * 功能描述： 设置逻辑区段关联的所有逻辑进路状态
@@ -1415,6 +1416,66 @@ void SetLogSecTXOccupyStateCC(const UINT16 logSectionId, const UINT8 curOccupySt
 */
 UINT8 ReqAlignmentInfoCalc(void);
 
+/*
+* 功能描述： 获取给ATS的逻辑区段ARB状态
+* 参数说明： const UINT16 wLgcId 逻辑区段状态
+*            const UINT8 chDevType 设备类型
+* 返回值  ： LGC_SECTION_ARB_NO 逻辑区段未ARB
+*            LGC_SECTION_ARB_YES 逻辑区段ARB
+* by cgh 20260327
+*/
+UINT8 GetToAtsLgcArbState(const UINT16 wLgcId, const UINT8 chDevType);
+
+/*
+* 功能描述： 获取指定逻辑区段CBTC_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+* 返回值  ： 0: 获取失败
+*			 >0: 逻辑区段CBTC_ARB状态
+* BY CGH 20260330
+*/
+UINT8 GetLogSecCbtcArbState(const UINT16 wLgcId);
+
+/*
+* 功能描述： 设置指定逻辑区段CBTC_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+*			const UINT8 chArb ARB状态
+* 返回值  ： 无
+* BY CGH 20260330
+*/
+void SetLogSecCbtcArbState(const UINT16 wLgcId, const UINT8 chArb);
+
+/*
+* 功能描述： 获取指定逻辑区段PB_TACS_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+* 返回值  ： 0: 获取失败
+*			 >0: 逻辑区段PB_TACS_ARB状态
+* BY CGH 20260330
+*/
+UINT8 GetLogSecPbTacsArbState(const UINT16 wLgcId);
+
+/*
+* 功能描述： 设置指定逻辑区段PB_TACS_ARB状态
+* 参数说明： const UINT16 wLgcId, 逻辑区段ID
+*			const UINT8 chArb ARB状态
+* 返回值  ： 无
+* BY CGH 20260330
+*/
+void SetLogSecPbTacsArbState(const UINT16 wLgcId, const UINT8 chArb);
+
+/*
+* 功能描述： 设置发送给ATS的逻辑区段ARB状态
+* 参数说明： 无
+* 返回值  ： 无
+* by cgh 20260330
+*/
+void SetSendAtsLgcArbState(void);
+/*
+* 功能描述： 重置资源信息结构体
+* 参数说明： UINT16 logicSectionId 逻辑区段ID
+* 返回值  ： 无
+* by cgh 20260330
+*/
+void ResetResInfoStruct(UINT16 logicSectionId, UINT8 index);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Section/SectionDefine.h

@@ -16,9 +16,9 @@
 
 /*区段最大数量*/
 #define PHYSICAL_SECTION_SUM_MAX            ((UINT16)1000)      /*定义物理区段数量最大值*/
-#define AXIS_SECTION_SUM_MAX                ((UINT16)1200)      /*定义计轴区段数量最大值*/
+#define AXIS_SECTION_SUM_MAX                ((UINT16)2000)      /*定义计轴区段数量最大值*/
 #define AXIS_INCLUDE_LOG_SUM_MAX            ((UINT16)50)      /*定义计轴包含逻辑区段数量最大值*/
-#define LOGIC_SECTION_SUM_MAX               ((UINT16)1500)      /*定义逻辑区段数量最大值*/
+#define LOGIC_SECTION_SUM_MAX               ((UINT16)2000)      /*定义逻辑区段数量最大值*/
 #define PHYSICAL_INCLUDE_AXIS_SUM_MAX       ((UINT16)10)       /*定义物理区段包含计轴区段数量最大值*/
 #define AXIS_INCLUDE_SWITCH_SUM_MAX         ((UINT16)4)         /*定义计轴区段包含的道岔数量最大值*/
 #define AXIS_INCLUDE_LINK_SUM_MAX			((UINT16)5)         /*定义计轴区段包含的LINK最大值*/
@@ -26,7 +26,7 @@
 #define PHYSICAL_INCLUDE_SWITCH_SUM_MAX     ((UINT16)10)         /*定义物理区段包含的道岔数量最大值*/
 #define SEC_INVASECT_N_CONDSWIT_SUM_MAX     ((UINT16)20)         /*定义物理区段包含的侵限区段数量最大值*/
 #define LOGSEC_INV_N_CONDSWIT_SUM_MAX        ((UINT16)8)         /*定义逻辑区段包含的侵限区段数量最大值*/
-#define LINK_SUM_MAX						((UINT16)1300)		/*定义LINK数量最大值*//* add 2022.02.28 */
+#define LINK_SUM_MAX						((UINT16)1600)		/*定义LINK数量最大值*//* add 2022.02.28 20260211增加置1600厦门3*/
 #define LOGSEC_INCLUDE_AXIS_SUM_MAX			((UINT16)8)         /*定义逻辑区段包含的计轴区段数量最大值*//* add 20220919 TIOC5.0*/
 #define LOGSEC_INCLUDE_SWITCH_SUM_MAX       ((UINT16)4)         /*定义逻辑区段包含的道岔数量最大值*//* add 20220921 TIOC5.0*/
 #define LOGSEC_LTRL_DFNC_SUM_MAX			((UINT16)8)         /*定义逻辑区段侧防条件数量最大值*//* add 20220921 TIOC5.0*/
@@ -34,12 +34,14 @@
 #define LOGSEC_NEXT_LOGSEC_SUM_MAX        ((UINT16)16)       /*定义逻辑区段相邻逻辑区段数量最大值*//* add 20230408  cgh*/
 #define LOGSEC_RELATE_SIG_SUM_MAX        ((UINT16)2)       /*定义逻辑区段关联信号机数量最大值*//* add 20230504   cgh*/
 #define LOGSEC_RELATE_ROUTE_SUM_MAX        ((UINT16)200)       /*定义逻辑区段关联进路数量最大值*//* add 20230504   cgh*/
-#define LOGSEC_RELATE_PRO_SW_SUM_MAX  ((UINT16)8)       /*定义逻辑区段关联防护道岔数量最大值*//* add 20230504   cgh*/
+#define LOGSEC_RELATE_PRO_SW_SUM_MAX  ((UINT16)50)       /*定义逻辑区段关联防护道岔数量最大值*//* add 20230504   cgh*/
 #define LOGSEC_RELATE_CON_SW_SUM_MAX  ((UINT16)4)       /*定义逻辑区段关联联络线道岔数量最大值*//* add 20230504   cgh*/
 #define PHYSEC_RELATE_ROUTE_SUM_MAX   ((UINT16)24)      /*定义物理区段关联进路数量最大值*//* add 20231113 lq*/
 #define LOGSEC_RELATE_PSD_MAX  ((UINT8)0X04U)       /*定义逻辑区段关联屏蔽门数量最大值*//* add 20240410   fan*/
 #define LOGSEC_RELATE_ESB_MAX  ((UINT8)10U)       /*定义逻辑区段关联紧急按钮数量最大值*//* add 20240410   fan*/
 #define TRCAK_SECTION_SUM_MAX            ((UINT16)5000)      /*定义轨道区段数量最大值*/
+#define LOGSEC_RELATE_OVERLAP_SUM_MAX        ((UINT16)200)       /*定义逻辑区段关联保护区段数量最大值 add 20260330 mpt*/
+#define AXIS_RELATE_PRO_SW_SUM_MAX  ((UINT16)100)       /*定义计轴区段关联防护道岔数量最大值*/
 
 #define QINXIAN_SWITCH_MAX_NUM  ((UINT8)0X16U)       /*定义侵限区段关联条件道岔的最大数量 add 20240607   LC */
 

TSCP/src/APP/ciapp/Signal/SignalDataManage.c

@@ -5646,9 +5646,9 @@ UINT32 GetDetainSndBtnPressCycNum(const UINT16 signalId)
 * 功能描述：获取指定ID信号机亮灭状态CC
 * 参数说明：const UINT16 signalId, 信号机ID
 * 返 回 值：0 获取数据失败
-*			0x55 未跨压
-*           0xaa 跨压
-* Created By LQ 2025.11.05
+*			0x55 灭灯
+*           0xaa 亮灯
+* EDIT By CGH 2026.02.01
 */
 UINT8 GetSignalLightExtinctStateCC(const UINT16 signalId)
 {
@@ -5736,23 +5736,51 @@ UINT8 GetSignalCrossStateCC(const UINT16 signalId)
 	return reVal;
 }
 
+/*
+* 功能描述：获取通信车跨压通过信号机 TACS主控列车ID
+* 参数说明：const UINT16 signalId, 信号机ID
+* 返 回 值：TACS主控列车ID
+* Created By wyd 2026.3.27
+*/
+UINT8 GetSignalCrossTacsTrainIdCC(const UINT16 signalId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 reVal = CI_ERROR;
+
+	bufIndex = GetSignalConfigBufIndex(signalId);  /*获取区段数组下标*/
+
+	if (SIGNAL_SUM_MAX > bufIndex)
+	{
+		reVal = SignalDataStruCC[bufIndex].wCrossTacsTrainId;
+	}
+	else
+	{
+		/*不处理*/
+	}
+	return reVal;
+}
+
 /*
 * 功能描述：设置通信车跨压通过信号机状态CC
 * 参数说明：const UINT16 signalId, 信号机ID
+*			const UINT8 signalCrossState 信号机跨压状态
+*			const UINT8 wTrainId 列车ID
 * 返 回 值：无
 * Created By LQ 2025.11.05
 */
-void SetSignalCrossStateCC(const UINT16 signalId, const UINT8 signalCrossState)
+void SetSignalCrossStateCC(const UINT16 signalId, const UINT8 signalCrossState, const UINT8 wTrainId)
 {
 	UINT16 bufIndex = 0U;  /*数组下标*/
 
-	bufIndex = GetSignalConfigBufIndex(signalId);  /*获取道岔数组下标*/
+	bufIndex = GetSignalConfigBufIndex(signalId);  /*获取信号机数组下标*/
 
 	if (bufIndex < SIGNAL_SUM_MAX)
 	{
-		if ((SIGNAL_CROSS_STATE_NO == signalCrossState) || (SIGNAL_CROSS_STATE_YES == signalCrossState))
+		if (((SIGNAL_CROSS_STATE_NO == signalCrossState) || (SIGNAL_CROSS_STATE_YES == signalCrossState))
+			&& (TACS_CROSS_ID_MAX >= wTrainId))
 		{
 			SignalDataStruCC[bufIndex].SignalCrossState = signalCrossState;  /*设置通信车跨压通过信号机状态*/
+			SignalDataStruCC[bufIndex].wCrossTacsTrainId = wTrainId;  /*设置通信车跨压通过信号机列车ID*/
 		}
 		else
 		{

TSCP/src/APP/ciapp/Signal/SignalDataManage.h

@@ -111,6 +111,7 @@ typedef struct S_SignalDataStructCC
 	UINT8 cSleepTrainLightUpFlag;								    /*休眠车点亮信号机标志：0x55 无效，0xAA 有效*/
 	UINT8 LightExtinctState;   /*信号机亮灭状态CC(0x55：灭灯，0xaa：亮灯)*/
 	UINT8 SignalCrossState;		/*通信车跨压通过信号机状态CC(0x55：未跨压，0xaa：跨压)*/
+	UINT8 wCrossTacsTrainId;		/*PB-TACS主控，通信车跨压通过信号机列车ID*/
 }SignalDataStructCC;
 
 extern SignalDataStruct SignalDataStru[SIGNAL_SUM_MAX];		  /*定义信号机数据结构体*/
@@ -1205,9 +1206,9 @@ UINT32 GetDetainSndBtnPressCycNum(const UINT16 signalId);
 * 功能描述：获取指定ID信号机亮灭状态CC
 * 参数说明：const UINT16 signalId, 信号机ID
 * 返 回 值：0 获取数据失败
-*			0x55 δ¿çѹ
-*           0xaa ¿çѹ
-* Created By LQ 2025.11.05
+*			0x55 灭灯
+*           0xaa 亮灯
+* EDIT By CGH 2026.02.01
 */
 UINT8 GetSignalLightExtinctStateCC(const UINT16 signalId);
 
@@ -1230,13 +1231,23 @@ void SetSignalLightExtinctStateCC(const UINT16 signalId, const UINT8 lightExtinc
 */
 UINT8 GetSignalCrossStateCC(const UINT16 signalId);
 
+/*
+* 功能描述：获取通信车跨压通过信号机 TACS主控列车ID
+* 参数说明：const UINT16 signalId, 信号机ID
+* 返 回 值：TACS主控列车ID
+* Created By wyd 2026.3.27
+*/
+UINT8 GetSignalCrossTacsTrainIdCC(const UINT16 signalId);
+
 /*
 * 功能描述：设置通信车跨压通过信号机状态CC
 * 参数说明：const UINT16 signalId, 信号机ID
+*			const UINT8 signalCrossState 信号机跨压状态
+*			const UINT8 wTrainId 列车ID
 * 返 回 值：无
 * Created By LQ 2025.11.05
 */
-void SetSignalCrossStateCC(const UINT16 signalId, const UINT8 signalCrossState);
+void SetSignalCrossStateCC(const UINT16 signalId, const UINT8 signalCrossState, const UINT8 wTrainId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.c

@@ -1467,4 +1467,298 @@ UINT16 GetSwitchIbpDrvRelayId(const UINT16 switchId)
 		retVal = CI_ERROR;
 	}
 	return retVal;
-}
+}
+
+/*
+* 功能描述： 获取指定道岔所属OC数
+* 参数说明： const UINT16 switchId, 道岔ID
+* 返回值  ：0 返回错误
+*           >0 返回道岔所属OC数
+* add by mpt 20260326
+*/
+UINT8 GetSwitchIncludeOcNum(const UINT16 switchId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		retVal = SwitchConfigDataStru[bufIndex].chSwitchBelongOcNum;
+		if (SWITCH_BELONG_OC_MAX < retVal)
+		{
+			retVal = CI_ERROR;
+		}
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定道岔包含的OCID
+* 参数说明： const UINT8 index 
+* 返回值  ： 返回指定索引的OCID
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchIncludeOCId(const UINT16 switchId,const UINT8 index)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX >bufIndex )&&(SWITCH_BELONG_OC_MAX > index))
+	{
+		retVal = SwitchConfigDataStru[bufIndex].belongOCConfigData[index].OcId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定道岔的OC索引
+* 参数说明： const UINT8 index
+* 返回值  ：指定道岔的OC索引
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOCIndex(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = SWITCH_BELONG_OC_MAX;
+	UINT8 i = 0u;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId))
+	{
+		for (i = 0u; i < SWITCH_BELONG_OC_MAX;i++)
+		{
+			if (SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId== ocId)
+			{
+				retVal = i;
+				break;
+			}
+		}
+	}
+	else
+	{
+		retVal = SWITCH_BELONG_OC_MAX;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定道岔OC的插箱ID
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ： 返回道岔指定OC的插箱号
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchszPlusBoxId(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+	UINT8 i = 0u;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId))
+	{
+		for (i = 0u; i < SwitchConfigDataStru[bufIndex].chSwitchBelongOcNum; i++)
+		{
+			if (ocId == SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId)
+			{
+				retVal = SwitchConfigDataStru[bufIndex].belongOCConfigData[i].szPlusBoxId;
+				break;
+			}
+		}
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定道岔在该OC的转辙机板卡数
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ： 指定道岔在该OC的转辙机板卡数
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOCBoardNum(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+	UINT8 i = 0u;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId))
+	{
+		for (i = 0u; i < SwitchConfigDataStru[bufIndex].chSwitchBelongOcNum; i++)
+		{
+			if (ocId == SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId)
+			{
+				retVal = SwitchConfigDataStru[bufIndex].belongOCConfigData[i].chSwitchBoardNum;
+				break;
+			}
+		}
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定道岔在该OC的转辙机板卡ID的索引号
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ：指定道岔在该OC的转辙机板卡ID的索引号
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOCBoardIDindex(const UINT16 switchId, const UINT8 ocId,const UINT8 boardId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 num = 0u;
+	UINT8 i = 0u;
+	UINT8 j = 0u;
+	UINT8 retVal = MAX_OC_SWITCH_INCLUDE_BOARD_NUM;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId))
+	{
+		for (i = 0u; i < SwitchConfigDataStru[bufIndex].chSwitchBelongOcNum; i++)
+		{
+			if (ocId == SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId)
+			{
+				num = SwitchConfigDataStru[bufIndex].belongOCConfigData[i].chSwitchBoardNum;
+				for (j = 0u; j < num; j++)
+				{
+					if (boardId == SwitchConfigDataStru[bufIndex].belongOCConfigData[i].ModuleAddr[j])
+					{
+						retVal = j;
+						break;
+					}	
+				}
+				break;
+			}
+		}
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定道岔指定OC的另一OCId
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ：指定道岔指定OC的另一OCId
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOcOtherOCId(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 i = 0u;
+	UINT8 retVal = 0u;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId)&&(0u < ocId))
+	{
+		for (i = 0u; i < SwitchConfigDataStru[bufIndex].chSwitchBelongOcNum; i++)
+		{
+			if ((ocId != SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId)&&(0u < SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId))
+			{
+				retVal = SwitchConfigDataStru[bufIndex].belongOCConfigData[i].OcId;
+				break;
+			}
+		}
+	}
+
+	return retVal;
+}
+/*
+* 功能描述： 获取道岔是否属于本OC
+* 参数说明：
+*		输入参数：
+*			UINT16 switchId 道岔ID
+*           UINT8 ocId  OCID
+* 返回值  ： 0:不是
+*			 1:是
+* Add by mpt 20260330
+*/
+UINT8 GetSwitchWhetherBelongThisOc(UINT16 switchId, UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 i = 0u;
+	UINT8 retVal = CI_ERROR;
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId) && (0u < ocId))
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			if (ocId == SwitchConfigDataStru[bufIndex].belongOCConfigData[chOCIndex].OcId)
+			{
+				retVal = CI_SUCCESS;
+			}
+		}
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 获取道岔属于本OC同块板卡的道岔ID
+* 参数说明：
+*		输入参数：
+*			UINT16 switchId 道岔ID
+*           UINT8 ocId  OCID
+* 返回值  ：
+            <500 道岔ID
+			=500 非法值
+* Add by mpt 20260404
+*/
+UINT16 GetSwitchThisOcOtherSwitchId(UINT16 switchId, UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 i = 0u;
+	UINT16 retVal = SWITCH_SUM_MAX;
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if ((SWITCH_SUM_MAX > bufIndex) && (OC_SUM_MAX > ocId) && (0u < ocId))
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			retVal = SwitchConfigDataStru[bufIndex].belongOCConfigData[chOCIndex].wThisOcOtherSwitchId;
+		}
+		else
+		{
+			/*无执行*/
+		}
+	}
+
+	return retVal;
+}
+

TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.h

@@ -33,6 +33,15 @@ typedef struct S_ZzjPowerConfigDataStruct
 	UINT16 ZzjFanweiPower2;				/*转辙机J1反表灯_供电2*/
 }ZzjPowerConfigDataStruct;
 
+typedef struct S_SwitchBelongOCConfigDataStr/*道岔所属OC配置数据*/
+{
+	UINT8 OcId;          /*当前OC*/
+	UINT8 chSwitchBoardNum; /*道岔板卡数*/
+	UINT8 ModuleAddr[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*地址ID*/
+	UINT8 szPlusBoxId;	/*转辙机板所在插箱ID*/
+	UINT16 wThisOcOtherSwitchId; /*同OC属于同板卡的另一道岔ID*/
+}SwitchBelongOCConfigDataStr;
+
 typedef struct S_SwitchConfigDataStruct
 {
     UINT16 SwitchId;           /*道岔ID (配置字段)*/
@@ -99,6 +108,9 @@ typedef struct S_SwitchConfigDataStruct
 	UINT16 DsDrvHRelayId;         /*道岔单锁后节点驱动继电器ID (配置字段-联络线使用)*/
 	UINT16 IbpDrvRelayId;		  	/*IBP盘道岔旁路驱动继电器ID (配置字段-联络线使用)*/
 	ZzjPowerConfigDataStruct ZzjPowerData[SWITCH_ZZJ_POWER_STATE_MAX_NUM];	/*转辙机供电配置数据*/
+
+	UINT8 chSwitchBelongOcNum;/*道岔所属OC数*/
+	SwitchBelongOCConfigDataStr belongOCConfigData[SWITCH_BELONG_OC_MAX];/*道岔所属各OC的配置情况*/
 	
 } SwitchConfigDataStruct;
 
@@ -107,6 +119,9 @@ typedef struct S_OC_SwitchConfigDataStruct
 {
 	UINT16 SwitchId;				/*道岔ID(配置字段)*/
 	UINT16 BelongOcId;				/*所属OCID(配置字段)*/
+	UINT8 ModuleAddrA[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*A系地址*/
+	UINT8 ModuleAddrB[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*B系地址*/
+	UINT16 otherSwitchId;				/*同OC属于同板卡的另一道岔ID(运算字段)*/
 }OCSwitchConfigDataStruct;
 
 /*旧版OC道岔配置数据表*/
@@ -592,8 +607,83 @@ ZzjPowerConfigDataStruct* GetSwitchZzjPowerConfigData(const UINT16 switchId);
 *			>0: IBP盘道岔旁路表示灯驱动继电器ID
 */
 UINT16 GetSwitchIbpDrvRelayId(const UINT16 switchId);
-
-
+/*
+* 功能描述： 获取指定道岔所属OC数
+* 参数说明： const UINT16 switchId, 道岔ID
+* 返回值  ：0 返回错误
+*           >0 返回道岔所属OC数
+* add by mpt 20260326
+*/
+UINT8 GetSwitchIncludeOcNum(const UINT16 switchId);
+/*
+* 功能描述： 获取指定道岔包含的OCID
+* 参数说明： const UINT8 index
+* 返回值  ： 返回指定索引的OCID
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchIncludeOCId(const UINT16 switchId, const UINT8 index);
+/*
+* 功能描述： 获取指定道岔的OC索引
+* 参数说明： const UINT8 index
+* 返回值  ：指定道岔的OC索引
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOCIndex(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 获取指定道岔OC的插箱ID
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ： 返回道岔指定OC的插箱号
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchszPlusBoxId(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 获取指定道岔在该OC的转辙机板卡数
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ： 指定道岔在该OC的转辙机板卡数
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOCBoardNum(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 获取指定道岔在该OC的转辙机板卡ID的索引号
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ：指定道岔在该OC的转辙机板卡ID的索引号
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOCBoardIDindex(const UINT16 switchId, const UINT8 ocId, const UINT8 boardId);
+/*
+* 功能描述： 获取指定道岔指定OC的另一OCId
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ：指定道岔指定OC的另一OCId
+*  add by mpt 20260326
+*/
+UINT8 GetSwitchThisOcOtherOCId(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 获取道岔是否属于本OC
+* 参数说明：
+*		输入参数：
+*			UINT16 switchId 道岔ID
+*           UINT8 ocId  OCID
+* 返回值  ： 0:不是
+*			 1:是
+* Add by mpt 20260330
+*/
+UINT8 GetSwitchWhetherBelongThisOc(UINT16 switchId, UINT8 ocId);
+/*
+* 功能描述： 获取道岔属于本OC同块板卡的道岔ID
+* 参数说明：
+*		输入参数：
+*			UINT16 switchId 道岔ID
+*           UINT8 ocId  OCID
+* 返回值  ：
+			<500 道岔ID
+			=500 非法值
+* Add by mpt 20260404
+*/
+UINT16 GetSwitchThisOcOtherSwitchId(UINT16 switchId, UINT8 ocId);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Switch/SwitchDataManage.c

@@ -416,6 +416,73 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 				retVal = CI_SUCCESS;
 			}
 			break;
+		case SWITCH_PLOCKTYPE_AXISSEC:/*锁闭类型为被计轴区段防护锁闭*/
+		{
+			if (SWITCH_LOCK_PROTECT_SET == lockCommand)
+			{/*设置防护锁闭*/
+				findFlag = 0u;/*置未找到*/
+				emptyIndex = -1;/*空位索引*/
+				/*查找被防护计轴区段id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的计轴区段数量*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
+					{
+						if (0u == SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii])
+						{
+							emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
+						}
+					}
+
+					if (pLockId == SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii])
+					{/*找到被锁闭的id*/
+						findFlag = 1u;
+					}
+				}
+
+				if (0u == findFlag)
+				{/*没找到被锁闭id*/
+					if (emptyIndex >= 0)
+					{/*且空位存在*/
+						SwitchDataStru[bufIndex].PLockedAxisSecIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
+						SwitchDataStru[bufIndex].PLockedAxisSecNum++; /*被锁闭id数量增加1个*/
+					}
+					else
+					{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
+						debug_infor_printf((const)"Set switch id %d PLOCK by axis %d fail,no empty space\n", bufIndex, pLockId);
+					}
+				}
+			}
+			else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+			{/*取消防护锁闭*/
+				targetIndex = -1;/*目标索引*/
+				/*如果没找到，返回*/
+				/*找到，设为0，且把数量-1*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii] == pLockId)
+					{
+						targetIndex = (INT16)ii;
+						SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii] = 0;/*设为0*/
+						break;
+					}
+				}
+
+				if (targetIndex >= 0)/*找到了*/
+				{
+					if (SwitchDataStru[bufIndex].PLockedAxisSecNum > 0U)
+					{
+						SwitchDataStru[bufIndex].PLockedAxisSecNum--;/*减1处理*/
+					}
+				}
+
+			}
+			else
+			{
+				/*非法命令，不处理*/
+			}
+			retVal = CI_SUCCESS;
+			break;
+		}
 		default:
 			{
 				/*类型非法，置返回标志错误*/
@@ -432,7 +499,7 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 				(SWITCH_LOCK_STATUS_DAP == SwitchDataStru[bufIndex].LockStatus))/*道岔状态包含单锁*/
 			{
 				if (SwitchDataStru[bufIndex].PLockedNonRouteNum + SwitchDataStru[bufIndex].PLockedOverlapNum +
-					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStruCC[bufIndex].PLockedLogRouteNum > 0u)
+					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStruCC[bufIndex].PLockedLogRouteNum + SwitchDataStru[bufIndex].PLockedAxisSecNum > 0u)
 				{/*被防护锁闭的设备数目大于0*/
 					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_DAP;
 				}
@@ -451,7 +518,7 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 			else
 			{/*不包含单锁*/
 				if (SwitchDataStru[bufIndex].PLockedNonRouteNum + SwitchDataStru[bufIndex].PLockedOverlapNum +
-					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStruCC[bufIndex].PLockedLogRouteNum > 0u)
+					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStruCC[bufIndex].PLockedLogRouteNum + SwitchDataStru[bufIndex].PLockedAxisSecNum > 0u)
 				{/*被防护锁闭的设备数目大于0*/
 					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_PROTECT;
 				}
@@ -3068,4 +3135,518 @@ UINT8 GetSwitchThisOverlapPLocked(const UINT16 switchId, const UINT16 overlapId)
 	}
 
 	return retVal;
-}
+}
+
+/*
+* 功能描述： 设置道岔指定OC的控制模式
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 controlMode 控制模式
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchThisOcCotrolMode(const UINT16 switchId, const UINT8 ocId,const UINT8 controlMode)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 i = 0u;
+	UINT8 chSwitchIncludeOcNum = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chSwitchIncludeOcNum = GetSwitchIncludeOcNum(switchId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (0u < ocId))
+	{
+		for (i = 0u; i < chSwitchIncludeOcNum; i++)
+		{
+			if (ocId == SwitchDataStru[bufIndex].belongOCData[i].OcId)
+			{
+				if ((MAIN_CONTROL == controlMode) || (STANDBY_CONTROL == controlMode) || (NO_CONTROL_FUN == controlMode) || (ERR_MODE_CONTROL == controlMode))
+				{
+					SwitchDataStru[bufIndex].belongOCData[i].controlMode = controlMode;
+				}
+				break;
+			}
+		}
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+}
+
+/*
+* 功能描述： 获取道岔指定OC的控制模式
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： 控制模式
+* add by mpt 20260326
+*/
+UINT8 GetSwitchThisOcCotrolMode(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+	UINT8 i = 0u;
+	UINT8 chSwitchIncludeOcNum = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chSwitchIncludeOcNum = GetSwitchIncludeOcNum(switchId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (0u < ocId))
+	{
+		for (i = 0u; i < chSwitchIncludeOcNum; i++)
+		{
+			if (ocId == SwitchDataStru[bufIndex].belongOCData[i].OcId)
+			{
+				retVal= SwitchDataStru[bufIndex].belongOCData[i].controlMode;	
+				break;
+			}
+		}
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 设置道岔的主控OCID
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchMainCotrolOCId(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		SwitchDataStru[bufIndex].mainControlOcId = ocId;
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+}
+
+/*
+* 功能描述： 获取道岔的主控OC
+* 参数说明： const UINT16 switchId 道岔ID
+* 返回值  ： 主控OCId
+* add by mpt 20260326
+*/
+UINT8 GetSwitchMainCotrolOCId(const UINT16 switchId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+	
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		retVal = SwitchDataStru[bufIndex].mainControlOcId;
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 设置道岔指定OC执行电插箱的状态
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchOcPlusBoxSateState(const UINT16 switchId, const UINT8 ocId, const UINT8 state)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 i = 0u;
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX >chOCIndex))
+	{	
+		SwitchDataStru[bufIndex].belongOCData[chOCIndex].PlusBoxSate = state;	
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+}
+
+/*
+* 功能描述： 获取道岔在指定OC中的执行电插箱状态
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： 0x55 转辙机执行电表示电均表示正常
+*            0xAA	   转辙机存在执行电熔丝或表示电熔丝报警
+*            0 非法状态
+* add by mpt 20260326
+*/
+UINT8 GetSwitchOcPlusBoxSateState(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 ret = 0u;
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX > chOCIndex))
+	{
+		ret = SwitchDataStru[bufIndex].belongOCData[chOCIndex].PlusBoxSate;
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+	return ret;
+}
+
+
+/*
+* 功能描述： 设置指定道岔在该OC的转辙机板卡ID的状态
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+*            const UINT8 boardId  板卡ID
+*            UINT8 state  板卡故障状态
+* 返回值  ：void
+*  add by mpt 20260326
+*/
+void SetSwitchThisOCBoardState(const UINT16 switchId, const UINT8 ocId, const UINT8 boardId, const UINT8 state)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chBoardIndex = 0u;
+	UINT8 chOCIndex = 0u;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		chBoardIndex = GetSwitchThisOCBoardIDindex(switchId, ocId, boardId);
+		if ((MAX_OC_SWITCH_INCLUDE_BOARD_NUM > chBoardIndex)&&(SWITCH_BELONG_OC_MAX >chOCIndex))
+		{
+			SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[chBoardIndex] = state;
+		}
+		else
+		{
+			/*nothing*/
+		}
+	}
+	else
+	{
+		/*nothing*/
+	}
+}
+
+/*
+* 功能描述： 获取指定道岔在该OC中是否存在某组转辙机板故障
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+*            const UINT8 boardId  板卡ID
+*            UINT8 state  板卡故障状态
+* 返回值  ：SWITCH_BOARD_FAULT 故障
+*           SWITCH_BOARD_NORMAL 正常
+*  add by mpt 20260326
+*/
+UINT8  GetSwitchThisOCBoardState(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 num = 0u;
+	UINT8 i = 0u;
+	UINT8 chSwitchThisOCBoardNum = 0u;
+	UINT8 chOCIndex = 0u;
+	UINT8 addrAState = 0u;
+	UINT8 addrBState = 0u;
+	UINT8 retVal = SWITCH_BOARD_FAULT;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		chSwitchThisOCBoardNum = GetSwitchThisOCBoardNum(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			if (0u < chSwitchThisOCBoardNum)
+			{
+				retVal = SWITCH_BOARD_NORMAL;/*先置为正常*/
+				for (i = 0u; i < (chSwitchThisOCBoardNum - 1u); i += 2u)
+				{
+					addrAState = SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[i];
+					addrBState = SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[i + 1u];
+					if ((SWITCH_BOARD_FAULT == addrAState) && (SWITCH_BOARD_FAULT == addrBState))
+					{
+						retVal = SWITCH_BOARD_FAULT;
+						break;
+					}
+				}
+			}
+			else
+			{/*异常分支，置为故障*/
+				retVal = SWITCH_BOARD_FAULT;
+			}
+
+		}
+		
+	}
+	else
+	{
+		/*nothing*/
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置道岔指定OC的主控命令
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchThisOcOutControlCmd(const UINT16 switchId, const UINT8 ocId, const UINT8 state)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX >chOCIndex))
+	{
+		if ((MAIN_CONTROL == state) || (STANDBY_CONTROL == state)||(NO_CONTROL_FUN == state))
+		{
+			SwitchDataStru[bufIndex].belongOCData[chOCIndex].OutControlCmd = state;
+		}
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+}
+
+/*
+* 功能描述： 获取道岔指定OC的主控命令
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： 0x55 主控
+*            0xaa 备控
+* add by mpt 20260326
+*/
+UINT8 GetSwitchThisOcOutControlCmd(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+	UINT8 retVal = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX > chOCIndex))
+	{
+		retVal = SwitchDataStru[bufIndex].belongOCData[chOCIndex].OutControlCmd;
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 设置道岔指定OC的主控命令的设置周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT32 cycnum 周期
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchOutMainContrCmdCycNum(const UINT16 switchId, const UINT8 ocId,const UINT32 cycnum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX > chOCIndex))
+	{
+		SwitchDataStru[bufIndex].belongOCData[chOCIndex].OutMainControlCmdCycNum = cycnum;
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+}
+
+/*
+* 功能描述：获取道岔指定OC的主控命令的设置周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： void
+* add by mpt 20260326
+*/
+UINT32 GetSwitchOutMainContrCmdCycNum(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+	UINT32 retVal = 0u;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX > chOCIndex))
+	{
+		retVal = SwitchDataStru[bufIndex].belongOCData[chOCIndex].OutMainControlCmdCycNum;
+	}
+	else
+	{
+		/*什么也不做*/
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述： 设置道岔驱动命令下发起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT32 cycNum 周期号
+* 返回值  ： 无
+* add mpt by 20260327 
+*/
+void SetSwitchOutputDrvCmdCycNum(const UINT16 switchId, const UINT32 cycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX >bufIndex)
+	{
+		SwitchDataStru[bufIndex].SwitchOutputDrvCmdCycNum = cycNum;
+	}
+}
+/*
+* 功能描述： 获取道岔驱动命令下发起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+* 返回值  ：  道岔操作命令起始周期
+* add mpt by 20260327 
+*/
+UINT32 GetSwitchOutputDrvCmdCycNum(const UINT16 switchId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT32 retVal = CI_ERROR;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		retVal = SwitchDataStru[bufIndex].SwitchOutputDrvCmdCycNum;
+	}
+	return retVal;
+}
+/*
+* 功能描述： 设置道岔寻找表示位置
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+*            const UINT8  chFindCmd  寻表命令
+* 返回值  ： 无
+* add mpt by 20260327
+*/
+void SetSwitchThisOcFindPostionCmd(const UINT16 switchId, const UINT8 ocId, const UINT8 chFindCmd)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			if ((FIND_DINGWEI_CMD == chFindCmd)||(FIND_FANWEI_CMD == chFindCmd) || (INIT_FIND_CMD == chFindCmd)||(NO_FIND_CMD == chFindCmd))
+			{
+				SwitchDataStru[bufIndex].belongOCData[chOCIndex].FindPostionCmd = chFindCmd;
+			}
+			else
+			{
+				/*无处理*/
+			}
+		}
+	}
+}
+/*
+* 功能描述： 获取道岔寻找表示命令
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ： 道岔寻找表示位置
+* add mpt by 20260327
+*/
+UINT8 GetSwitchThisOcFindPostionCmd(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+	UINT8 retVal = 0u;
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			retVal = SwitchDataStru[bufIndex].belongOCData[chOCIndex].FindPostionCmd;
+		}
+	}
+
+	return retVal;
+}
+
+
+/*
+* 功能描述： 获取道岔寻找表示命令起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ：道岔寻找表示命令起始周期
+* add mpt by 20260327
+*/
+UINT32 GetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+	UINT32 retVal = 0u;
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			retVal = SwitchDataStru[bufIndex].belongOCData[chOCIndex].FindCmdStartCycNum;
+		}
+	}
+
+	return retVal;
+}
+/*
+* 功能描述： 设置道岔寻找表示命令起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+*            UINT32 cycNum 周期号
+* 返回值  ：void
+* add mpt by 20260402
+*/
+void SetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId, const UINT32 cycNum)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 chOCIndex = 0U;
+	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
+	if (SWITCH_SUM_MAX > bufIndex)
+	{
+		chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
+		if (SWITCH_BELONG_OC_MAX > chOCIndex)
+		{
+			SwitchDataStru[bufIndex].belongOCData[chOCIndex].FindCmdStartCycNum = cycNum;
+		}
+	}
+}
+

TSCP/src/APP/ciapp/Switch/SwitchDataManage.h

@@ -28,6 +28,18 @@
 extern "C" {
 #endif
 
+/*道岔数据结构体*/
+typedef struct S_SwitchOcDataStruct
+{
+	UINT8 OcId; /*OC ID*/
+	UINT8 controlMode; /*当前主备控制模式*/
+	UINT8 OutControlCmd;/*控制主备命令*/
+	UINT8 PlusBoxSate;	/*插箱状态*/
+	UINT8 BoardStateBuf[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];/*板卡状态*/
+	UINT32 OutMainControlCmdCycNum;/*升主命令周期，向外输出升主命令时设置（一直输出则一直设置），或当前通信中断主控->备控时设置，收到OC数据由主控->备控时清除*/
+	UINT8 FindPostionCmd;/*1 寻定，2 寻反，3初始寻，0 无寻位置指令*/
+	UINT32 FindCmdStartCycNum;/*寻表示命令起始周期*/
+}SwitchOCDataStr;
 
 /*道岔数据结构体*/
 typedef struct S_SwitchDataStruct
@@ -83,6 +95,16 @@ typedef struct S_SwitchDataStruct
 
 	UINT8 chSwitchIncldeZzjNum; /*道岔对应转辙机数目，设备类型为信号机时,此个数为0*/
 	UINT8 szSwitchIncldeZzjState[SWITCH_ZZJ_POWER_STATE_MAX_NUM];/*转辙机状态*/
+
+	UINT32 SwitchOutputDrvCmdCycNum; /*道岔输出驱动命令起始周期*/
+	UINT8 mainControlOcId;/*主控OCId*/
+	UINT8 chSwitchBelongOcNum;/*道岔所属OC数*/
+	SwitchOCDataStr belongOCData[SWITCH_BELONG_OC_MAX];/*道岔所属各OC的状态*/
+
+	UINT8 PLockedAxisSecNum;/*被防护锁闭的计轴区段id数量，只能在本文件使用*/
+	UINT16 PLockedAxisSecIdArr[SWITCH_MAX_PROTECT_LOCKED_NUM];/*被防护锁闭的计轴区段id数组，只能在本文件使用*/
+
+	
 } SwitchDataStruct;
 
 /*道岔数据结构体*/
@@ -748,7 +770,163 @@ UINT8 GetSwitchThisRoutePLocked(const UINT16 switchId, const UINT16 routeId);
 * 返回值  ： CI_SUCCESS 已经被锁闭或入参不合法，CI_ERROR 未被该保护区段防护锁闭
 */
 UINT8 GetSwitchThisOverlapPLocked(const UINT16 switchId, const UINT16 overlapId);
+/*
+* 功能描述： 设置道岔指定OC的控制模式
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 controlMode 控制模式
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchThisOcCotrolMode(const UINT16 switchId, const UINT8 ocId, const UINT8 controlMode);
+/*
+* 功能描述： 获取道岔指定OC的控制模式
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： 控制模式
+* add by mpt 20260326
+*/
+UINT8 GetSwitchThisOcCotrolMode(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 设置道岔的主控OCID
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchMainCotrolOCId(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 获取道岔的主控OC
+* 参数说明： const UINT16 switchId 道岔ID
+* 返回值  ： 主控OCId
+* add by mpt 20260326
+*/
+UINT8 GetSwitchMainCotrolOCId(const UINT16 switchId);
+/*
+* 功能描述： 设置道岔指定OC执行电插箱的状态
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchOcPlusBoxSateState(const UINT16 switchId, const UINT8 ocId, const UINT8 state);
+/*
+* 功能描述： 获取道岔在指定OC中的执行电插箱状态
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： > 0道岔指定OC执行电插箱的状态
+*            =0 非法状态
+* add by mpt 20260326
+*/
+UINT8 GetSwitchOcPlusBoxSateState(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 设置指定道岔在该OC的转辙机板卡ID的状态
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+*            const UINT8 boardId  板卡ID
+*            UINT8 state  板卡故障状态
+* 返回值  ：void
+*  add by mpt 20260326
+*/
+void SetSwitchThisOCBoardState(const UINT16 switchId, const UINT8 ocId, const UINT8 boardId, const UINT8 state);
+/*
+* 功能描述： 获取指定道岔在该OC中是否存在某组转辙机板故障
+* 参数说明： const UINT16 switchId 道岔ID
+*            const UINT8 ocId OCID
+*            const UINT8 boardId  板卡ID
+*            UINT8 state  板卡故障状态
+* 返回值  ：SWITCH_BOARD_FAULT 故障
+*           SWITCH_BOARD_NORMAL 正常
+*  add by mpt 20260326
+*/
+UINT8  GetSwitchThisOCBoardState(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 设置道岔指定OC的主控命令
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchThisOcOutControlCmd(const UINT16 switchId, const UINT8 ocId, const UINT8 state);
+/*
+* 功能描述： 获取道岔指定OC的主控命令
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+*            const UINT8 state 状态
+* 返回值  ： 0x55 主控
+*            0xaa 备控
+* add by mpt 20260326
+*/
+UINT8 GetSwitchThisOcOutControlCmd(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 设置道岔指定OC的主控命令的设置周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： void
+* add by mpt 20260326
+*/
+void SetSwitchOutMainContrCmdCycNum(const UINT16 switchId, const UINT8 ocId, const UINT32 cycnum);
+/*
+* 功能描述：获取道岔指定OC的主控命令的设置周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId 指定OC
+* 返回值  ： void
+* add by mpt 20260326
+*/
+UINT32 GetSwitchOutMainContrCmdCycNum(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 设置道岔驱动命令下发起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT32 cycNum 周期号
+* 返回值  ： 无
+* add mpt by 20260327
+*/
+void SetSwitchOutputDrvCmdCycNum(const UINT16 switchId, const UINT32 cycNum);
 
+/*
+* 功能描述： 获取道岔驱动命令下发起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+* 返回值  ：  道岔操作命令起始周期
+* add mpt by 20260327
+*/
+UINT32 GetSwitchOutputDrvCmdCycNum(const UINT16 switchId);
+/*
+* 功能描述： 设置道岔寻找表示位置
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+*            const UINT8  chFindCmd  寻表命令
+* 返回值  ： 无
+* add mpt by 20260327
+*/
+void SetSwitchThisOcFindPostionCmd(const UINT16 switchId, const UINT8 ocId, const UINT8 chFindCmd);
+/*
+* 功能描述： 获取道岔寻找表示命令
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ： 道岔寻找表示位置
+* add mpt by 20260327
+*/
+UINT8 GetSwitchThisOcFindPostionCmd(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 获取道岔寻找表示命令起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+* 返回值  ：道岔寻找表示命令起始周期
+* add mpt by 20260327
+*/
+UINT32 GetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId);
+/*
+* 功能描述： 设置道岔寻找表示命令起始周期
+* 参数说明： const UINT16 switchId, 道岔ID
+*            const UINT8 ocId OCID
+*            UINT32 cycNum 周期号
+* 返回值  ：void
+* add mpt by 20260402
+*/
+void SetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId, const UINT32 cycNum);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Switch/SwitchDefine.h

@@ -74,6 +74,9 @@
 #define		OC_SWITCH_DRIVE_POS_DINGWEI	((UINT16)0x5555)	/*道岔驱动定位*/
 #define		OC_SWITCH_DRIVE_POS_FANWEI	((UINT16)0xaaaa)	/*道岔驱动反位*/
 #define		OC_SWITCH_DRIVE_POS_KEEP	((UINT16)0x55aa)	/*道岔驱动位置保持*/
+#define		OC_SWITCH_FIND_DINGWEI   	((UINT16)0x555f)	/*道岔寻定*/
+#define		OC_SWITCH_FIND_FANWEI   	((UINT16)0xaaaf)	/*道岔寻反*/
+#define		OC_SWITCH_ININ_FIAND     	((UINT16)0x5faf)	/*道岔初始寻*/
 
 #define	OC_SWITCH_OTHER_BJ_STATE               ((UINT8)0xf6) /*OC转辙机其他报警（除了封连、开盖）状态（板卡状态）*/
 #define	OC_SWITCH_OPEN_CAP_STATE               ((UINT8)0x01) /*OC转辙机开盖状态（板卡状态）*/
@@ -96,8 +99,6 @@
 #define SWITCH_KERAO_STATE_NO       ((UINT8)0xAA)		/*道岔可绕*/
 /* zt 删除单轨相关代码 2022-02-15 */
 
-#define SWITCH_LAST_DRV_STAY_MAX_NUM ((UINT8)10)			/*道岔最近一次有效驱动位置延续最大周期数*/
-
 #define SWITCH_MOVE_FAIL                (UINT8)0x55     /*道岔移动失败*/
 #define SWITCH_USING_NORMAL                  (UINT8)0xaa     /*道岔移动正常*/
 
@@ -109,6 +110,7 @@
 #define SWITCH_PLOCKTYPE_NONROUTE		((UINT8)0x4)	/*被非进路防护锁闭*/
 #define SWITCH_PLOCKTYPE_NOROUTE_NOOVERLAP_NONONROUTE	((UINT8)0x5) /*解除道岔防护锁闭*/
 #define SWITCH_PLOCKTYPE_LOGROUTE	    ((UINT8)0x6)    /*被逻辑进路防护锁闭*/
+#define SWITCH_PLOCKTYPE_AXISSEC	    ((UINT8)0x7)    /*被计轴区段防护锁闭*/
 
 #define SWITCH_OPER_NO_DANCAO			((UINT8)0x55)	/*非单操操作：进路锁闭、保护区段锁闭、非进路锁闭、自动进路办理*/
 #define SWITCH_OPER_DANCAO				((UINT8)0xaa)	/*单操操作*/
@@ -147,5 +149,28 @@
 
 #define SWITCH_ZZJ_POWER_STATE_MAX_NUM 5U	/*道岔转辙机标识灯状态最大数*/
 
+#define MAX_OC_SWITCH_INCLUDE_BOARD_NUM	((UINT8)10)		/*一个道岔支持最大板卡数量（不可达最大值）*/
+
+#define SWITCH_BOX_NUM 10U	/*单个OC插箱最大数*/
+
+
+#define SWITCH_BELONG_OC_MAX  2U  /*道岔所属OC最多数*/
+
+#define MAIN_CONTROL           0x55U   /*主控*/
+#define STANDBY_CONTROL        0xAAU   /*备控*/
+#define NO_CONTROL_FUN         0x00U   /*无此功能*/
+#define ERR_MODE_CONTROL       0xCCU   /*异常控制模式，部分主控部分备控，或OC没有全所有板卡*/
+
+
+#define SWITCH_BOX_NORMAL	((UINT8)0x55)		/*转辙机执行电表示电均表示正常*/
+#define SWITCH_BOX_FAULT	((UINT8)0xAA)	   /*转辙机存在执行电熔丝或表示电熔丝报警*/
+
+#define SWITCH_BOARD_FAULT	((UINT8)0xff)	   /*转辙机板故障*/
+#define SWITCH_BOARD_NORMAL	((UINT8)0x55)	   /*转辙机板正常*/
+
+#define FIND_DINGWEI_CMD   ((UINT8)0x1)    /*寻定*/
+#define FIND_FANWEI_CMD    ((UINT8)0x2)    /*寻反*/
+#define INIT_FIND_CMD      ((UINT8)0x3)    /*初始寻*/
+#define NO_FIND_CMD      ((UINT8)0x0)    /*无寻位置指令*/
 #endif
 

TSCP/src/APP/ciapp/System/CiSystemDefine.h

@@ -125,6 +125,9 @@ extern UINT8 CI_SYSTEM_TYPE_RCI;
 #define CI_DEVICE_TYPE_BACKUP_VOBC	  ((UINT8)0xBE)	/*后备VOBC列车*/
 #define CI_DEVICE_TYPE_ZHAOCHA		  ((UINT8)0xC0)		/*照查*/
 
+#define CI_DEVICE_TYPE_SWITCH_PHYSEC  ((UINT8)0xC1)		/*道岔所在物理区段，互联互通接口使用*/
+#define CI_DEVICE_TYPE_XIANSU_LOGSEC  ((UINT8)0xC2)		/*限速逻辑区段，互联互通接口使用*/
+
 
 #define CI_DEVICE_TYPE_CMD				((UINT8)0x0B)	/*命令*/
 

TSCP/src/APP/ciapp/System/SystemConfigDefine.h

@@ -59,7 +59,7 @@
 
 /*联锁V13.0版本升级数据结构 2018.8.3*/
 /*版本号*/
-#define VER_MAIN_SUBCI_CI_CID            ((UINT8)25)   /*子系统主版本号*/
+#define VER_MAIN_SUBCI_CI_CID            ((UINT8)27)   /*子系统主版本号*/
 #define VER_SUB_SUBCI_CI_CID			 ((UINT8)0)	/*子系统子版本号*/
 #define VER_BRUNCH_CI_CID			     ((UINT8)0)	/*分支版本号..........主线填0....分支填1 调试填2 */
 #define VER_RETURN_SUBCI_CI_CID			 ((UINT8)0)	/*子系统回归版本号*/
@@ -75,30 +75,30 @@
 /*手写软件版本号*/
 #define VER_SOFT_PRODUCT            ((UINT8)40) /*产品编号*/
 #define VER_SOFT_MODUAL_APP             ((UINT8)1)  /*模块编号*/
-#define VER_SOFT_MIANVERSION        ((UINT8)25)  /*主版本号*/
+#define VER_SOFT_MIANVERSION        ((UINT8)27)  /*主版本号*/
 #define VER_SOFT_SUBVERSION         ((UINT8)1) /*子版本号*/
 
 #endif
 
 /*可兼容的公共数据结构版本号*/
 #define VER_1_PUBLIC_FS_1            ((UINT8)31)
-#define VER_1_PUBLIC_FS_2            ((UINT8)4)
+#define VER_1_PUBLIC_FS_2            ((UINT8)7)
 #define VER_1_PUBLIC_FS_3            ((UINT8)0)
 #define VER_1_PUBLIC_FS_4            ((UINT8)0)
 
-#define VER_2_PUBLIC_FS_1            ((UINT8)0)
-#define VER_2_PUBLIC_FS_2            ((UINT8)0)
-#define VER_2_PUBLIC_FS_3            ((UINT8)0)
-#define VER_2_PUBLIC_FS_4            ((UINT8)0)
+#define VER_2_PUBLIC_FS_1            ((UINT8)23)
+#define VER_2_PUBLIC_FS_2            ((UINT8)2)
+#define VER_2_PUBLIC_FS_3            ((UINT8)1)
+#define VER_2_PUBLIC_FS_4            ((UINT8)7)
 
 #define VER_3_PUBLIC_FS_1            ((UINT8)28)
 #define VER_3_PUBLIC_FS_2            ((UINT8)0)
 #define VER_3_PUBLIC_FS_3            ((UINT8)0)
-#define VER_3_PUBLIC_FS_4            ((UINT8)22)
+#define VER_3_PUBLIC_FS_4            ((UINT8)25)
 
 
 /*可兼容的私有数据结构版本号*/
-#define VER_1_PRIVATE_FS_1            ((UINT8)49)
+#define VER_1_PRIVATE_FS_1            ((UINT8)52)
 #define VER_1_PRIVATE_FS_2            ((UINT8)0)
 
 #define VER_2_PRIVATE_FS_1            ((UINT8)0xFF)
@@ -108,7 +108,7 @@
 #define VER_3_PRIVATE_FS_2            ((UINT8)0xFF)
 
 /*可兼容OC数据结构版本号*/
-#define VER_1_OCDATA_FS_1            ((UINT8)36) /*oc 3.0  较新数据版本*/
+#define VER_1_OCDATA_FS_1            ((UINT8)37) /*oc 3.0  较新数据版本*/
 #define VER_1_OCDATA_FS_2            ((UINT8)0)
 
 #define VER_2_OCDATA_FS_1            ((UINT8)0xFF)

TSCP/src/APP/ciapp/System/SystemParameterManage.c

@@ -23,6 +23,10 @@ static UINT16 LocalCTProtectSecUnlockTime = 0u;/*
 static UINT16 LocalUTNearUnLockTime = 0u;/*本联锁UT接近延时解锁超限时间（s）*/
 static UINT16 LocalCTNearUnLockTime = 0u;/*本联锁CT接近延时解锁超限时间（s）*/
 static UINT8 LocalWaysidePattern = 0u; /*本联锁轨旁继电器接口类型*/
+UINT8 gSerialCommFlag = SERIAL_COMM_NO; /*本联锁串口通信标志*/
+SerialCommData gSzSerialCommData[SERIAL_GROUP_SUM_MAX] = { 0U }; /*串口通信数据*/
+
+static UINT8 OCSswitch = 0u; /*OC-S开关*/
 /* RC合并新增，用于区分TIOC功能或者联锁联锁 */
 UINT8 CI_SYSTEM_TYPE_RCI = 0u;                        /*工作模式：0x3C-CI,0x3D-RC*/
 static UINT8 gLocalRcLinkLineAttr = 0u; /* RC联络线属性 */
@@ -120,6 +124,10 @@ UINT32 wJXTCStopDetectTime = 0U; /*
 static UINT16 g_TiocFsVersion[TIOCFS_VERSION_LENGTH] = { 0u };/* TIOC数据版本号 */
 
 UINT32 gSystemUpdateMainUseCycNum = 0U; /*系统升级主用起始周期号*/
+
+static UINT32 wSwitchMachineCutInterval = 0U;        /*RC/CI系统控制转辙机板主控切换间隔时间(单位：S)*/
+static UINT32 wSwitchMachineDrvingCutInterval = 0U;  /*RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)*/
+static UINT32 wSwitchLastDrvValidTime = 0U;          /*RC/CI系统上一次驱动道岔有效时间*/
 /*
 * 功能描述： 系统参数时间转周期数
 * 参数说明： void    
@@ -342,6 +350,17 @@ void SystemParaTimeToCycleCount(void)
 
 	paraVal = GetSystemParaValue(JXTC_STOP_DETECTION_TIME);
 	wJXTCStopDetectTime = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);  /*JXTC停止检测时间（s）*/
+
+
+	paraVal = GetSystemParaValue(SWITCH_MACHINE_CUT_INTERVAL);
+	wSwitchMachineCutInterval = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);  /*RC/CI系统控制转辙机板主控切换间隔时间(单位：S)*/
+
+
+	paraVal = GetSystemParaValue(SWITCH_MACHINE_CUT_DRV_INTERVAL);
+	wSwitchMachineDrvingCutInterval = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);  /*RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)*/
+
+	paraVal = GetSystemParaValue(SWITCH_LAST_DRV_TIME);
+	wSwitchLastDrvValidTime = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);  /*RC/CI系统上一次驱动道岔有效时间*/
 }
 
 /*
@@ -1340,20 +1359,22 @@ UINT8 CheckTiocPublicFsVersion(UINT8* pSrcFsVersion)
 
 	if (NULL != pSrcFsVersion)
 	{
-		SetLocalPublicDataType(DATA_TYPE_NEW);
-		/*查询公共数据结构版本号是否属于可兼容的版本 
-		28.0.0.14及其升级版本只支持配置到第三个兼容数据结构 VER_3_PUBLIC*/
+		SetLocalPublicDataType(DATA_TYPE_MAIN_BRANCH);
+		/*查询公共数据结构版本号是否属于可兼容的版本 */
+		/*28.0.0.14及其升级版本只支持配置到第三个兼容数据结构 VER_3_PUBLIC*/
+		/*23.2.1.4 及其升级版本只支持配置到第二个兼容数据结构 VER_2_PUBLIC */
 		if ((VER_1_PUBLIC_FS_1 == pSrcFsVersion[0]) && (VER_1_PUBLIC_FS_2 == pSrcFsVersion[1]) && (VER_1_PUBLIC_FS_3 == pSrcFsVersion[2]) && (VER_1_PUBLIC_FS_4 == pSrcFsVersion[3]))
 		{
 			retVal = CI_SUCCESS;
 		}
 		else if ((VER_2_PUBLIC_FS_1 == pSrcFsVersion[0]) && (VER_2_PUBLIC_FS_2 == pSrcFsVersion[1]) && (VER_2_PUBLIC_FS_3 == pSrcFsVersion[2]) && (VER_2_PUBLIC_FS_4 == pSrcFsVersion[3]))
 		{
+			SetLocalPublicDataType(DATA_TYPE_23_BRANCH);
 			retVal = CI_SUCCESS;
 		}
 		else if ((VER_3_PUBLIC_FS_1 == pSrcFsVersion[0]) && (VER_3_PUBLIC_FS_2 == pSrcFsVersion[1]) && (VER_3_PUBLIC_FS_3 == pSrcFsVersion[2]) && (VER_3_PUBLIC_FS_4 == pSrcFsVersion[3]))
 		{
-			SetLocalPublicDataType(DATA_TYPE_OLD);
+			SetLocalPublicDataType(DATA_TYPE_28_BRANCH);
 			retVal = CI_SUCCESS;
 		}
 		else
@@ -1421,11 +1442,11 @@ UINT8 CheckTiocOcFsVersion(UINT8* pSrcFsVersion)
 		/*查询OC数据结构版本号是否属于可兼容的版本*/
 		if ((VER_1_OCDATA_FS_1 == pSrcFsVersion[0]) && (VER_1_OCDATA_FS_2 == pSrcFsVersion[1]))
 		{
-			retVal = SetLocalOcPattern(DATA_TYPE_NEW);
+			retVal = CI_SUCCESS;
 		}
 		else if ((VER_2_OCDATA_FS_1 == pSrcFsVersion[0]) && (VER_2_OCDATA_FS_2 == pSrcFsVersion[1]))
 		{
-			retVal = SetLocalOcPattern(DATA_TYPE_OLD);
+			retVal = CI_SUCCESS;
 		}
 		else
 		{
@@ -1522,6 +1543,45 @@ UINT16 GetTiocSystemParameterData(UINT32* pConfigDataAdderBuf, UINT16* pConfigDa
 			;/*无处理 */
 		}
 
+		/*本联锁轨旁继电器接口类型*/
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalWaysidePattern;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/*无处理 */
+		}
+
+		/*本联锁串口通信标志*/
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &gSerialCommFlag;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/*无处理 */
+		}
+
+		/*串口通信数据*/
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &gSzSerialCommData;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)(sizeof(SerialCommData) * (SERIAL_GROUP_SUM_MAX));
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/*无处理 */
+		}
+
 		/*本联锁OC数据结构类型*/
 		wTmpLen = 1u + wTmpConfigDataSum;
 		if (wBufMaxLen >= wTmpLen)
@@ -2426,6 +2486,55 @@ UINT16 GetTiocSystemParameterData(UINT32* pConfigDataAdderBuf, UINT16* pConfigDa
 		{
 			;/* 无处理 */
 		}
+		/* OC-S开关  */
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &OCSswitch;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/* 无处理 */
+		}
+
+		/* RC/CI系统控制转辙机板主控切换间隔时间(单位：ms)  */
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &wSwitchMachineCutInterval;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/* 无处理 */
+		}
+		/* RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms) */
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &wSwitchMachineDrvingCutInterval;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/* 无处理 */
+		}
+		/* RC/CI系统上一次驱动道岔有效时间*/
+		wTmpLen = 1u + wTmpConfigDataSum;
+		if (wBufMaxLen >= wTmpLen)
+		{
+			pConfigDataAdderBuf[wTmpConfigDataSum] = &wSwitchLastDrvValidTime;
+			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
+			wTmpConfigDataSum++;
+		}
+		else
+		{
+			;/* 无处理 */
+		}
 
 	}
 	else
@@ -2839,7 +2948,7 @@ OtherCiParaStruct GetOtherCiPara(const UINT8 chOtherCiId)
 /*
 * 功能描述：获取无C轨站型B轨有UT车时可追踪功能开关
 * 参数说明：无
-* 返回值：aa关闭 55打开
+* 返回值：aa打开 55关闭
 * by cgh 20240815
 */
 UINT8 GetNoCGFollowUtSwitch(void)
@@ -2880,24 +2989,7 @@ UINT32 GetdwNonReturnBtnErrEnsureCount(void)
 	return dwNonReturnBtnErrEnsureTime;
 }
 
-/*
-* 设置本联锁OC版本
-* 参数说明：OC版本
-* 返回值：成功 CI_SUCCESS  失败CI_ERROR
-* Create: fan 20250210
-*/
-UINT8 SetLocalOcPattern(UINT8 localOcPattern)
-{
-	UINT8 rtn = CI_ERROR; /*返回值*/
 
-	if ((DATA_TYPE_NEW == localOcPattern) || (DATA_TYPE_OLD == localOcPattern))
-	{
-		gLocalOcType = localOcPattern;
-		rtn = CI_SUCCESS;
-	}
-
-	return rtn;
-}
 #if 0
 /*
 * 获取本联锁OC版本 -----暂无适配兼容需求 屏蔽代码
@@ -2952,7 +3044,7 @@ UINT8 GetLocalRcLinkLineAttr(void)
 */
 void SetLocalPublicDataType(UINT8 localPublicData)
 {
-	if ((DATA_TYPE_NEW == localPublicData) || (DATA_TYPE_OLD == localPublicData))
+	if ((DATA_TYPE_MAIN_BRANCH == localPublicData) || (DATA_TYPE_28_BRANCH == localPublicData) || (DATA_TYPE_23_BRANCH == localPublicData))
 	{
 		gLocalPublicDataType = localPublicData;
 	}
@@ -2961,7 +3053,9 @@ void SetLocalPublicDataType(UINT8 localPublicData)
 /*
 * 获取当前公共数据版本类型
 * 参数说明：无
-* 返回值：0x55 较新版本  0xaa 较旧版本
+* 返回值：0x01 主线版本  
+          0x02 28.0.0.x版本  
+		  0x03 23.2.1.x版本
 * Create: fan 20250521
 */
 UINT8 GetLocalPublicDataType(void)
@@ -3216,3 +3310,208 @@ void SetCiFunctionSwitchConfig(UINT8 chFunctionConfigIndex,UINT8 chSwitchVal)
 		
 	}
 }
+/*
+* 功能描述：获取RC/CI系统控制转辙机板主控切换间隔时间(单位：S)
+* 参数说明：无
+* 返回值：RC/CI系统控制转辙机板主控切换间隔时间(单位：S)
+* by mpt 20260324
+*/
+UINT32 GetSwitchMachineCutInterval(void)
+{
+	return wSwitchMachineCutInterval;
+}
+/*
+* 功能描述：获取RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
+* 参数说明：无
+* 返回值：RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
+* by mpt 20260324
+*/
+UINT32 GetSwitchMachineDrvCutInterval(void)
+{
+	return wSwitchMachineDrvingCutInterval;
+}
+/*
+* 功能描述：获取RC/CI系统上一次驱动道岔有效时间
+* 参数说明：无
+* 返回值：RC/CI系统上一次驱动道岔有效时间
+* by mpt 20260324
+*/
+UINT32 GetSwitchLastDrvValidTime(void)
+{
+	return wSwitchLastDrvValidTime;
+}
+/*
+* 设置本联锁OCS开关
+* 参数说明：支持OC-S开关
+* 返回值：是否设置成功
+*/
+UINT8 SetLocalCiOCSswitch(UINT8 funSwitch)
+{
+	UINT8 rtn = 0u; /*返回值*/
+
+	if ((OC_S_ON == funSwitch) || (OC_S_OFF == funSwitch))
+	{
+		OCSswitch = funSwitch;
+		rtn = 1u;
+	}
+
+	return rtn;
+}
+/*
+* 设置本联锁OCS开关
+* 参数说明：void
+* 返回值：本联锁OCS开关
+*/
+UINT8 GetLocalCiOCSswitch(void)
+{
+	return OCSswitch;
+}
+
+/*
+* 获取联锁厂商信息
+* 参数说明：const UINT8 chCiId
+* 返回值：厂商信息
+* BY:lyj
+*/
+UINT8 GetCiFactoryType(const UINT8 chCiId)
+{
+	UINT8 chRet = 0U;
+	if (CI_SUM_MAX > chCiId)
+	{
+		chRet =  SystemParameterStruNew.chCiFactoryType[chCiId];
+	}
+	else
+	{
+		/*不处理*/
+	}
+	return chRet;
+}
+/**
+* @brief 设置本联锁串口通信标志
+* @param[in] UINT8 chSerialCommFlag 串口通信标志
+* @return CI_SUCCESS 设置成功   CI_ERROR 设置失败
+* @note by cgh 20260507
+*/
+UINT8 SetLocalSerialCommFlag(UINT8 chSerialCommFlag)
+{
+	UINT8 chReval = CI_ERROR;
+
+	if ((SERIAL_COMM_YES == chSerialCommFlag) || (SERIAL_COMM_NO == chSerialCommFlag))
+	{
+		gSerialCommFlag = chSerialCommFlag;
+		chReval = CI_SUCCESS;
+	}
+	else
+	{
+		;
+	}
+
+	return chReval;
+}
+
+/**
+* @brief 获取本联锁串口通信标志
+* @param[in] void
+* @return SERIAL_COMM_YES 支持串口通信   chSerialCommFlag 不支持串口通信
+* @note by cgh 20260507
+*/
+UINT8 GetLocalSerialCommFlag(void)
+{
+	return gSerialCommFlag;
+}
+
+/**
+* @brief 设置本联锁串口通信数据
+* @param[in] UINT8 chGroupIndex 串口组索引
+* @param[in] UINT8 chPortIndex 端口索引
+* @param[in] UINT16 wSerialCommCiId 串口通信其它联锁ID
+* @param[in] UINT8 chSerialCommPort 串口通信端口号
+* @return CI_SUCCESS 设置成功   CI_ERROR 设置失败
+* @note by cgh 20260507
+*/
+UINT8 SetLocalSerialCommData(UINT8 chGroupIndex,UINT8 chPortIndex,UINT16 wSerialCommCiId,UINT8 chSerialCommPort)
+{
+	UINT8 chReval = CI_ERROR;
+
+	if ((SERIAL_GROUP_SUM_MAX > chGroupIndex) && (CI_SUM_MAX > wSerialCommCiId) && (SERIAL_PORT_SUM_MAX > chPortIndex))
+	{
+		gSzSerialCommData[chGroupIndex].wSerialCommOtherCiId = wSerialCommCiId;
+		gSzSerialCommData[chGroupIndex].chSerialCommPort[chPortIndex] = chSerialCommPort;
+
+		chReval = CI_SUCCESS;
+	}
+	else
+	{
+		;
+	}
+
+	return chReval;
+}
+
+/**
+* @brief 获取本联锁串口通信数据
+* @param[in] void
+* @return 串口通信数据
+* @note by cgh 20260507
+*/
+SerialCommData* GetLocalSerialCommData(void)
+{
+	return gSzSerialCommData;
+}
+
+/**
+* @brief 根据设备名获取对应的串口组
+* @param[in] UINT16 DeviceName 设备名称
+* @param[in] UINT8* pSerialGroup 端口组索引
+* @return 串口通信数据
+* @note by cgh 20260507
+*/
+UINT8 IsSerialDevice(UINT16 DeviceName, UINT8* pSerialGroup)
+{
+	UINT8 chReval = CI_ERROR;
+	UINT8 chLocalRcWorkMode = 0u; /*本地RC工作模式*/
+	UINT8 cDstType = 0U; /*目标设备类型*/
+	UINT8 cDstId = 0U; /*目标设备ID*/
+	UINT8 chSerialCommFlag = 0U; /* 串口通信标志 */
+	SerialCommData* szSerialCommData = NULL; /*串口通信数据*/
+	UINT8 cSerialGroupIndex = 0U;
+
+	chLocalRcWorkMode = GetLocalRcWorkMode();
+	cDstType = (UINT8)((DeviceName & 0xFF00U) >> 8U);
+	cDstId = (UINT8)(DeviceName & 0x00FFU);
+
+	if ((chLocalRcWorkMode == cDstType) && (NULL != pSerialGroup))
+	{
+		/* 先判断当前联锁是否具备串口通信的功能 */
+		chSerialCommFlag = GetLocalSerialCommFlag();
+		szSerialCommData = GetLocalSerialCommData();
+
+		if ((SERIAL_COMM_YES == chSerialCommFlag) && (NULL != szSerialCommData))
+		{
+			for (cSerialGroupIndex = 0U; cSerialGroupIndex < SERIAL_GROUP_SUM_MAX; cSerialGroupIndex++)
+			{
+				if (DeviceName == szSerialCommData[cSerialGroupIndex].wSerialCommOtherCiId)
+				{
+					*pSerialGroup = cSerialGroupIndex;
+					chReval = CI_SUCCESS;
+					break;
+				}
+				else
+				{
+					/*继续查找第二组*/
+					;
+				}
+			}
+		}
+		else
+		{
+			;
+		}
+	}
+	else
+	{
+
+	}
+
+	return chReval;
+}

TSCP/src/APP/ciapp/System/SystemParameterManage.h

@@ -84,7 +84,7 @@ extern "C" {
 #define FUNC_DA_SWITCH									((UINT8)48)       /*脱轨防护功能开关（0x55:不支持；0xaa：支持）*/ 
 #define FUNC_OC_100_OR_200								((UINT8)49)       /*执行单元使用类型（0x55:OC-100；0xaa：OC-200）*/ 
 #define FUNC_OC_200_INOUTNET							((UINT8)50)       /*OC通信使用内外网配置（0x55:外网；0xaa：内网）*/ 
-#define FUNC_ZIFUSHI_BUTTON							    ((UINT8)51)       /*按钮是否为自复式（0x55:非自复式；0xaa：自复式）*/ 
+#define FUNC_ZIFUSHI_BUTTON							    ((UINT8)51)       /*按钮是否为自复式（0x55:非自复式；0xaa：自复式；0x5A：宁象市域铁路）*/ 
 #define FUNC_JIZHONGQU_LINSHIXIASNSU_FLAG				((UINT8)52)       /*与ZC通信中断后，是否设置集中区临时限速（0x55:设置；0xaa：不设置）*/ 
 #define FUNC_REPEATE_OPEN_CHECK_SPKS				    ((UINT8)53)       /*点式进路重开信号是否检查SPKS状态，（0x55:检查，点式不重开；0xaa：不检查，可重开）*/ 
 #define FUNC_SWITCH_SHIBIAO_PROMPTLY_ALARM				((UINT8)54)       /*道岔失表是否立即向ATS报警（0XAA：立即报警  0X55：等待时间超限报警）*/ 
@@ -107,6 +107,8 @@ extern "C" {
 #define FUNC_WDOWNWASH_ZIFUSHI_BUTTON                   ((UINT8)72)	      /*降级模式洗车同意按钮是否为自复式（0X55非自复式、0XAA自复式）*/
 #define FUNC_REOPRN_SET_NEAR                            ((UINT8)73)		  /*重开信号是否记忆进路接近锁闭状态开关：0xAA-重开后默认设置接近 0x55-重开后根据接近区段占用状态设置接近/未接近*/
 #define FUNC_OVERLAP_UT_UNLOCK_MODE                     ((UINT8)74)       /*UT列车占压停车区域时，保护区段解锁方式*/
+#define FUNC_PSD_EXCEPT_CANCLE_TYPE                     ((UINT8)75)       /*屏蔽门异常打开后解除异常方式：0xAA 需ATS发 0xBA命令；0x55未异常打开自动解除*/
+#define FUNC_PSD_KEEP_CLOSE_TYPE                        ((UINT8)76)       /*联锁系统输出打开/关闭站台门命令原则*/
 
 
 #define CiSum_ID						((UINT16)1)/*实际联锁集中站数量 编号*/
@@ -186,7 +188,9 @@ extern "C" {
 #define JXTCJXTC_MUTUALLOCK_FAULT_TIME   		(75U)	/*间隙探测旁路按钮故障判断时间（s）*/
 #define JXTC_STOP_DETECTION_TIME   				(76U)	/*JXTC停止检测时间（s）*/
 
-
+#define SWITCH_MACHINE_CUT_INTERVAL   			(77U)	/*RC/CI系统控制转辙机板主控切换间隔时间(单位：S)*/
+#define SWITCH_MACHINE_CUT_DRV_INTERVAL   		(78U)	/*RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)*/
+#define SWITCH_LAST_DRV_TIME   			    	(79U)	/*RC/CI系统上一次驱动道岔有效时间*/
 
 #define FUNC_SWITCH_ON 									((UINT8)0xAA)				/*功能配置开关打开*/
 #define FUNC_SWITCH_OFF 								((UINT8)0x55)				/*功能配置开关关闭*/
@@ -218,7 +222,7 @@ extern "C" {
 #define Oc_Max_Board_Num	(57U)		/*属于一个OC的最大板卡数目（上层8块+其他3层*16块=56块）*/
 
 #define CI_SIGNAL_MAX	 ((UINT16)300)	/*属于一个CI的最大信号机的数目*/
-#define CI_SWITCH_MAX	 ((UINT16)100)	/*属于一个CI的最大道岔的数目*/
+#define CI_SWITCH_MAX	 ((UINT16)200)	/*属于一个CI的最大道岔的数目*/
 #define CI_GD_MAX		 ((UINT16)700)	/*轨道区段最大数量*/
 
 #define RC_WORK_MODE_CI		((UINT8)0x3Cu)	/*联锁工作模式*/
@@ -242,8 +246,10 @@ extern "C" {
 #define FUNC_OVERLAP_LOCK_BY_ATS       ((UINT8)0x01)				/*ATS锁闭保护区段*/
 #define FUNC_OVERLAP_LOCK_BY_CI       ((UINT8)0x02)				    /*联锁自行锁闭保护区段*/
 
-#define DATA_TYPE_NEW	((UINT8)0x55u)	/*最新数据结构__OC3.2 数据结构及新公共数据结构30.X*/
-#define DATA_TYPE_OLD		((UINT8)0xAAu)	/*兼容的老OC数据结构_或杭德数据结构28.0.0.X*/
+#define DATA_TYPE_MAIN_BRANCH    ((UINT8)0x01U)	/*公共数据结构--主线--30.X*/
+#define DATA_TYPE_28_BRANCH 	 ((UINT8)0x02U)	/*公共数据结构--杭德数据结构-28.0.0.X*/
+#define DATA_TYPE_23_BRANCH 	 ((UINT8)0x03U)	/*公共数据结构--厦门3数据结构23.2.1.X*/
+
 
 #define OC200_VER2_1_9			((UINT8)0x01u)/*功能开关7配置为1，OC200 2.1.9接口*/
 #define OC200_VER3_2			((UINT8)0x02u)/*功能开关7配置为2，OC200 3.2接口*/
@@ -254,6 +260,15 @@ extern "C" {
 #define RC_LINK_LINE_YES		((UINT8)0x55U)	/*具备联络线属性*/
 #define RC_LINK_LINE_NO	        ((UINT8)0xAAU)	/*不具备联络线属性*/
 
+#define OC_S_ON					((UINT8)0xAA)	/*支持OC-S*/
+#define OC_S_OFF				((UINT8)0x55)	/*不支持OC-S*/
+
+#define SERIAL_GROUP_SUM_MAX 2  /*串口通信设备数最大值 */
+#define SERIAL_PORT_SUM_MAX  2  /*串口通信端口索引最大值 */
+
+#define SERIAL_COMM_YES  ((UINT8)0xAAU)   /*支持串口通信*/
+#define SERIAL_COMM_NO   ((UINT8)0x55U)   /*不支持串口通信*/
+
 /*系统参数结构体*/
 typedef struct S_SystemParameterStruct
 {
@@ -364,25 +379,13 @@ typedef struct S_SystemParaStruct
 	UINT32 CiAndPscTransmitBadEnsureTime ;
 
 	/**********适配最新系统配置数据****************/
-	UINT16  MaxLineLimitSpeed;/*线路最高限速,此处数据库中存放的是UINT8的km/h数据，需要在这里转换成cmps单位的数据*/
 	UINT8	MaxTsrSpeed;/*临时限速最高限速*/
-	UINT8	TimeZoneDifference;/*NTP校时时区差.格林威治时间与本地时间的时区差，单位：时区，应用使用时应乘以3600转换为秒。*/
-	UINT16	MABackDistance;/*安全防护距离.考虑到最不利情况情况下（最大潜在退行距离和线路最大坡度等）移动授权考虑的安全防护距离*/
 	UINT16	MaxTsrNum;/*一次设置临时限速的最大个数*/
 	UINT16	MaxSectionOfTsr;/*一个临时限速报文中包含的最大逻辑区段数量*/
-	UINT32	IvocIvocCommunicationErrorTime;/*IVOC-IVOC信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT32	IvocOcCommunicationErrorTime;/*IVOC-OC通信故障判断时间(ms),add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT32	TmcItsCommunicationErrorTime;/*TMC-ITS通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT32	TmcOcCommunicationErrorTime;/*TMC-OC通信故障判断时间(ms),add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT32	ItsOcCommunicationErrorTime;/*ITS-OC通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT32	OcPsdCommunicationErrorTime;/*OC-PSD通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT32	IvocTslCommunicationErrorTime;/*IVOC-TSL通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT32	OcTslCommunicationErrorTime;/*OC-TSL通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT16	MALengthForATOParking;        /*满足ATO精准停车条件的MA长度,add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT8 LinkLogicDirUpAndDown;   /*系统定义逻辑方向与上下行方向的关系,add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT16  OppositeTrackDistance;    /*对向行驶双车间隔最小安全距离（cm）,add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT32  MaxMALength;              /*线路最差情况下紧急制动距离（单位m）,add by yt，2022年3月1日，适配车车系统配置数据*/
-	UINT32	VobcAtsCommunicationErrorTime;/*VOBCATS通信故障判断时间*/
 	UINT32 dwLineMinTrainLength;		/*系统配置数据，线路最小车长*/
 	UINT8  chZXDynamicTestSwitch;		/*正线是否支持动态测试，55 关闭，AA打开 配置中 aa关闭 55打开*/
 	UINT8  chDynamicTestSwitch;			/*是否支持动态测试开关，55 关闭，AA打开 配置中 aa关闭 55打开*/
@@ -398,6 +401,7 @@ typedef struct S_SystemParaStruct
 	UINT8 chNoCGFollowUtSwitch; /*无C轨站型B轨有UT车是可追踪功能开关 aa打开 55关闭*/
 	OtherCiParaStruct otherCICiParaStru[CI_SUM_MAX]; /*其他联锁参数配置*/
 	UINT8 chCldAndScxMergeFlag; /*车辆段与试车线合设开关，0x55 合设，0xaa 不合设*/
+	UINT8 chCiFactoryType[CI_SUM_MAX]; /*联锁厂商定义*/
 	/************************************************/
 }SystemParameterStructNew;
 
@@ -421,6 +425,12 @@ typedef struct S_CI_OC_Relation
 	UINT16 OcIdNum;
 }CiOcRelateion;
 
+typedef struct S_SERIAL_COMM_DATA
+{
+	UINT16 wSerialCommOtherCiId; /*串口通信其它联锁ID*/
+	UINT8 chSerialCommPort[SERIAL_PORT_SUM_MAX];     /*串口通信端口*/
+}SerialCommData;
+
 
 /*******************************全局变量声明*******************************/
 extern UINT8 LocalCiId;                       /*本机联锁ID*/
@@ -508,6 +518,9 @@ extern UINT32 gSystemUpdateMainUseCycNum; /*ϵͳ
 extern UINT8 localBackUpFlag; /*本机备用/主用模式 原共享内存主备系区分标志*/
 extern UINT32 dwDownWashWaitAcceptTime;  /*降级模式洗车等待值班员同意最大时间（S）*/
 extern UINT32 LineMinTrainLength;		/*系统配置数据，线路最小车长*/
+extern UINT32 wJXTCStopDetectTime; /*间隙探测停止检测时间（s）*/
+extern UINT8 gSerialCommFlag; /*本联锁串口通信标志*/
+extern SerialCommData gSzSerialCommData[SERIAL_GROUP_SUM_MAX]; /*串口通信数据*/
 /*
 * 功能描述： 系统参数时间转周期数
 * 参数说明： void    
@@ -1355,7 +1368,7 @@ OtherCiParaStruct GetOtherCiPara(const UINT8 chOtherCiId);
 /*
 * 功能描述：获取无C轨站型B轨有UT车是可追踪功能开关
 * 参数说明：无
-* 返回值：aa关闭 55打开
+* 返回值：aa打开 55关闭
 * by cgh 20240815
 */
 UINT8 GetNoCGFollowUtSwitch(void);
@@ -1384,13 +1397,6 @@ UINT32 GetArbProtectCheckTime(void);
 */
 UINT32 GetdwNonReturnBtnErrEnsureCount(void);
 
-/*
-* 设置本联锁OC版本
-* 参数说明：OC版本
-* 返回值：成功 CI_SUCCESS  失败CI_ERROR
-* Create: fan 20250210
-*/
-UINT8 SetLocalOcPattern(UINT8 localOcPattern);
 #if 0
 /*
 * 获取本联锁OC版本-----暂无适配OC兼容需求 屏蔽代码
@@ -1427,7 +1433,9 @@ void SetLocalPublicDataType(UINT8 localPublicData);
 /*
 * 获取当前公共数据版本类型
 * 参数说明：无
-* 返回值：0x55 较新版本  0xaa 较旧版本
+* 返回值：0x01 主线版本
+		  0x02 28.0.0.x版本
+		  0x03 23.2.1.x版本
 * Create: fan 20250521
 */
 UINT8 GetLocalPublicDataType(void);
@@ -1543,6 +1551,91 @@ UINT8 GetCldAndScxMergeFlag(void);
 */
 void SetCiFunctionSwitchConfig(UINT8 chFunctionConfigIndex, UINT8 chSwitchVal);
 
+/*
+* 功能描述：获取RC/CI系统控制转辙机板主控切换间隔时间(单位：S)
+* 参数说明：无
+* 返回值：RC/CI系统控制转辙机板主控切换间隔时间(单位：S)
+* by mpt 20260324
+*/
+UINT32 GetSwitchMachineCutInterval(void);
+/*
+* 功能描述：获取RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
+* 参数说明：无
+* 返回值：RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
+* by mpt 20260324
+*/
+UINT32 GetSwitchMachineDrvCutInterval(void);
+/*
+* 功能描述：获取RC/CI系统上一次驱动道岔有效时间
+* 参数说明：无
+* 返回值：RC/CI系统上一次驱动道岔有效时间
+* by mpt 20260324
+*/
+UINT32 GetSwitchLastDrvValidTime(void);
+/*
+* 设置本联锁OCS开关
+* 参数说明：支持OC-S开关
+* 返回值：是否设置成功
+*/
+UINT8 SetLocalCiOCSswitch(UINT8 funSwitch);
+/*
+* 设置本联锁OCS开关
+* 参数说明：void
+* 返回值：本联锁OCS开关
+*/
+UINT8 GetLocalCiOCSswitch(void);
+/*
+* 获取联锁厂商信息
+* 参数说明：const UINT8 chCiId
+* 返回值：厂商信息
+* BY:lyj
+*/
+UINT8 GetCiFactoryType(const UINT8 chCiId);
+
+/**
+* @brief 设置本联锁串口通信标志
+* @param[in] UINT8 chSerialCommFlag 串口通信标志
+* @return CI_SUCCESS 设置成功   CI_ERROR 设置失败
+* @note by cgh 20260507
+*/
+UINT8 SetLocalSerialCommFlag(UINT8 chSerialCommFlag);
+
+/**
+* @brief 获取本联锁串口通信标志
+* @param[in] void
+* @return SERIAL_COMM_YES 支持串口通信   chSerialCommFlag 不支持串口通信
+* @note by cgh 20260507
+*/
+UINT8 GetLocalSerialCommFlag(void);
+
+/**
+* @brief 设置本联锁串口通信数据
+* @param[in] UINT8 chGroupIndex 串口组索引
+* @param[in] UINT8 chPortIndex 端口索引
+* @param[in] UINT16 wSerialCommCiId 串口通信其它联锁ID
+* @param[in] UINT8 chSerialCommPort 串口通信端口号
+* @return CI_SUCCESS 设置成功   CI_ERROR 设置失败
+* @note by cgh 20260507
+*/
+UINT8 SetLocalSerialCommData(UINT8 chGroupIndex, UINT8 chPortIndex, UINT16 wSerialCommCiId, UINT8 chSerialCommPort);
+
+/**
+* @brief 获取本联锁串口通信数据
+* @param[in] void
+* @return 串口通信数据
+* @note by cgh 20260507
+*/
+SerialCommData* GetLocalSerialCommData(void);
+
+/**
+* @brief 根据设备名获取对应的串口组
+* @param[in] UINT16 DeviceName 设备名称
+* @param[in] UINT8* pSerialGroup 端口组索引
+* @return 串口通信数据
+* @note by cgh 20260507
+*/
+UINT8 IsSerialDevice(UINT16 DeviceName, UINT8* pSerialGroup);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Train/TrainDataManage.h

@@ -142,6 +142,17 @@ typedef struct S_ABLTrainInfoStru
 
 }ABLTrainInfoStru;
 
+/*点连式信息结构体*/
+typedef struct S_BlocLinkInfoStru
+{
+	UINT8 chBlocLinkLogSecNum;							/*点连式列车逻辑区段数量-车脚下以及车大前所在进路的逻辑区段*/
+	UINT16 wBlocLinkLogSecBuf[TRAIN_ABL_LOGSEC_SUM];	/*点连式列车逻辑区段数组*/
+	UINT8 chBlocLinkRouteNum;							/*点连式匹配进路数量*/
+	UINT16 wBlocLinkRouteBuf[CI_VOBC_ROUTE_MAX];		/*点连式匹配进路数组*/
+
+}BlocLinkInfoStru;
+
+
 /*前车ATP位置信息结构体*/
 typedef struct S_HeadTrainAtpLocStru
 {
@@ -213,12 +224,16 @@ typedef struct S_TrainInfoStru
 	UINT16	wTrainMinTailLink;			/*列车最小安全后端所处link*/
 	UINT32	dwTrainMinTailOffset;		/*列车最小安全后端偏移量*/
 	UINT8	chSpeedDir;                 /*速度方向*/
-	UINT16  wTrainSpeed;                /*速度方向*/
+	UINT16  wTrainSpeed;                /*速度*/
 	UINT8	chTrainZeroState;			/*列车零速状态*/
 	UINT8	chTransmitStat;				/*与列车传输状态*/
+	UINT8   chIvocTransmitStat;			/*与IVOC列车传输状态*/
 	UINT8	chHeadScreenStat;			/*列车前筛标志*/
 	UINT8	chTailScreenStat;			/*列车后筛标志*/
 	TrainSafeLocStru strSafeLoc;		/*列车安全位置*/
+	UINT16 wMinSafeHeadLink;			/*最小安全车头所处link*/
+	UINT32 dwMinSafeHeadOffset;			/*最小安全车头所处link偏移量*/
+	UINT8 chMinSafeHeadDir;				/*最小安全车头方向*/
 	UINT32 dwDelayTime;					/*消息延迟时间*/
 	UINT16 wGroupOtherTrainId;			/* 编组另一列车ID*/
 	UINT8 chGroupRunState;				/* 编组列车状态: 1非编组 2编组建立 3编组运行 4编组折返 5编组解耦*/
@@ -238,6 +253,7 @@ typedef struct S_TrainInfoStru
 	UINT8 chStopSteadyState;			/*列车停准停稳状态*/
 	UINT8 chSleepCancleFlag;			/*清除休眠车标志*/
 	UINT32 dwTransBadCyc;				/*通信中断周期*/
+	UINT32 dwIvocTransBadCyc;				/*通信中断周期*/
 	UINT8 chEaNum;						/*通信列车回复的区间疏散数量*/
 	TrainEaStru strTrainEaInfo[EA_MAX_NUM];			/*列车恢复区间疏散信息*/
 	UINT8 chEaCmd;						/*区间疏散命令*/
@@ -280,6 +296,7 @@ typedef struct S_TrainInfoStru
 	UINT8 chtrainControlMode;				/*本车当前控车模式，0不处于任何控制模式，1:处于IVOC主控，2处于VOBC主控*/
 	UINT8 chTrainPostionMode;              /*列车位置模式，0x10 使用IVOC位置，0x14使用VOBC位置*/
 
+	BlocLinkInfoStru strBlocLinkData;		/*点连式信息*/
 }TrainInfoStru;
 
 
@@ -421,6 +438,16 @@ UINT16 GetTrainBufIndex(const UINT16 wTrainId);
 */
 UINT8 GetTrainTransitmitStat(const UINT16 wTrainId);
 
+/*
+* 功能描述： 获取指定列车(IVOC)通信状态
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ： 0: 获取数据失败
+*			 0x55: 通信状态良好
+*			 0xAA: 丢失通信
+*			 0xFF: 通信状态未知
+* 创建: qw.liu 2022-02-24
+*/
+UINT8 GetTrainIvocTransitmitStat(const UINT16 wTrainId);
 /*
 * 功能描述： 获取指定列车最小安全前端偏移量
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -580,6 +607,19 @@ CI_SUCCESS:
 */
 UINT8 SetTrainTransmitStat(const UINT16 wTrainId, const UINT8 chTrainmitStat);
 
+
+/*
+* 功能描述： 设置指定列车(IVOC)通信状态
+* 参数说明： const UINT16 wTrainId, 列车ID
+*			 const UINT8 chTrainmitStat 通信状态
+* 返回值  ：CI_ERROR: 设置数据失败
+CI_SUCCESS:设置数据成功
+* 0x55 : 通信状态良好
+* 0xAA : 丢失通信
+* 0xFF : 通信状态未知
+* 创建 : qw.liu 2025 - 05 - 08
+*/
+UINT8 SetTrainIvocTransmitStat(const UINT16 wTrainId, const UINT8 chTrainmitStat);
 /*
 * 功能描述： 设置指定列车运行等级
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -710,6 +750,41 @@ CI_SUCCESS:
 */
 UINT8 SetTrainSafeHeadDir(const UINT16 wTrainId, const UINT8 chDir);
 
+/*
+* 功能描述： 获取指定列车最小安全车头所处link
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ：安全车头所处link
+* 创建 : 2026.3.27
+*/
+UINT16 GetTrainMinSafeHeadLink(const UINT16 wTrainId);
+
+/*
+* 功能描述： 获取指定列车最小安全车头所处link偏移量
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ：安全车头所处link偏移量
+* 创建 : 2026.3.27
+*/
+UINT32 GetTrainMinSafeHeadOffset(const UINT16 wTrainId);
+
+/*
+* 功能描述： 获取指定列车最小安全车头方向
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ：安全车头方向
+* 创建 : 2026.3.27
+*/
+UINT8 GetTrainMinSafeHeadDir(const UINT16 wTrainId);
+
+/*
+* 功能描述：设置指定列车最小安全车头位置
+* 参数说明：const UINT16 wTrainId, 列车ID
+*			const UINT16 wLinkId
+*			const UINT16 dwLinkOffset
+*			const UINT16 chDir
+* 返回值  ：无
+* 创建 : 2026.3.27
+*/
+void SetTrainMinSafeHead(const UINT16 wTrainId, const UINT16 wLinkId, const UINT32 dwLinkOffset, const UINT8 chDir);
+
 /*
 * 功能描述： 设置指定列车安全车头所处link
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -1062,6 +1137,8 @@ UINT8 isGroupHeadTrain(const UINT16 wTrainId);
 * @brief 查询列车处于进路位置 使用列车最小前，最小后
 * @param UINT16 wTrainId 列车ID
 * @param UINT16 wRouteId 进路ID
+* @param UINT8 cSetResTag 是否为设置逻辑区段资源时调用
+*				（CBTC主控跨压时使用延时后的小前） CI_SUCCESS 是 CI_ERROR 否
 * @return 0：查询失败
 *			1：列车未驶入进路
 *			2：列车车头驶入进路但未跨压
@@ -1069,7 +1146,7 @@ UINT8 isGroupHeadTrain(const UINT16 wTrainId);
 *			4：列车完全驶入进路
 *			5：列车车头出清进路
 */
-UINT8 dsuTrainMinHeadCrossSignal(const UINT16 wTrainId, const UINT16 wRouteId);
+UINT8 dsuTrainMinHeadCrossSignal(const UINT16 wTrainId, const UINT16 wRouteId, const UINT8 cSetResTag);
 
 /**
 * @brief 获取计轴区段上的通信列车
@@ -2854,12 +2931,6 @@ UINT32 CalTrainMsgDelayTime(UINT16 wTrainId, UINT8 trainType);
 */
 void SetTrainPostionMode(const UINT16 wTrainId, const UINT8 chPos);
 /*
-* 功能描述： 获取指定列车位置模式
-* 参数说明： const UINT16 wTrainId, 列车ID
-* 返回值  ： 无
-*/
-UINT8 GetTrainPostionMode(const UINT16 wTrainId);
-/*
 * 功能描述： 设置指定IVOC列车主控模式
 * 参数说明： const UINT16 wTrainId, 列车ID
 *			 const UINT8 chMode 模式
@@ -3004,6 +3075,59 @@ UINT8 SetIvocTrainMsgDelayTime(const UINT16 wTrainId, const UINT32 dwDelayTime);
 * 返回值  :列车等级
 */
 UINT8 GetIvocTrainLevel(const UINT16 wTrainId);
+/*
+* 功能描述： 清除点连式列车发送信息
+* 参数说明： void
+* 返回值  ： void
+*/
+void ClearBlocLinkTrainInfo(UINT16 wTrainId);
+/*
+* 功能描述： 设置点连式列车脚下逻辑区段
+* 参数说明： const UINT16 wTrainId 列车ID
+*			 const UINT8 chAOcculogNum 列车脚下逻辑区段数量
+*			 const UINT16* chOcculogIdbuff 列车脚下逻辑区段数组
+* 返回值  ： void
+* by:lyj 20260316
+*/
+void SetBlocLinkOccLogSecData(const UINT16 wTrainId, const UINT8 chAOcculogNum, const UINT16* chOcculogIdbuff);
+
+/*
+* 功能描述： 设置点连式列车匹配的进路
+* 参数说明： const UINT16 wTrainId 列车ID
+*			 const UINT16 wRouteId 列车匹配的进路id
+* 返回值  ： void
+* by:lyj 20260316
+*/
+void SetBlocLinkRouteData(const UINT16 wTrainId, const UINT16 wRouteId);
+/*
+* 功能描述： 获取点连式列车匹配的进路数量
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 列车匹配的进路数量
+* by:lyj 20260316
+*/
+UINT8 GetBlocLinkRouteNum(const UINT16 wTrainId);
+/*
+* 功能描述： 获取点连式列车匹配的进路数组
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 列车匹配的进路数组
+* by:lyj 20260316
+*/
+UINT16* GetBlocLinkRouteBuf(const UINT16 wTrainId);
+/*
+* 功能描述： 获取点连式列车逻辑区段数量
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 列车逻辑区段数量
+* by:lyj 20260316
+*/
+UINT8 GetBlocLinkLogSecNum(const UINT16 wTrainId);
+/*
+* 功能描述： 获取点连式列车匹配的逻辑区段数组
+* 参数说明： const UINT16 wTrainId 列车ID
+* 返回值  ： 列车逻辑区段数组
+* by:lyj 20260316
+*/
+UINT16* GetBlocLinkLogSecBuf(const UINT16 wTrainId);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Train/TrainDefine.h

@@ -279,6 +279,9 @@
 /*³µÔؿسµ×´Ì¬*/
 #define VEHICLE_CONTROL_STATUS_YES		 ((UINT8)0x55)       /*³µÔؿسµ×´Ì¬-¿Ø³µ*/
 #define VEHICLE_CONTROL_STATUS_NO	     ((UINT8)0xaa)       /*³µÔؿسµ×´Ì¬-·Ç¿Ø³µ*/
+
+/*点连式宏值定义*/
+#define CI_VOBC_ROUTE_MAX              ((UINT8)3U)   /*CI-VOBC点连式匹配进路数量最大值*/
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Transmit/TransmitStateDataManage.c

@@ -1253,7 +1253,7 @@ UINT8 GetCiWithOtherCiTransmitState(const UINT8 DeviceType, const UINT8 DeviceId
 		{
 			pstrHlhtHeadCtx = GetCiToRcWithCiHeadCtx(DeviceId);
 		}
-		else if (CI_SYSTEM_TYPE_CI == DeviceType)
+		else if (CI_SYSTEM_TYPE_RC == DeviceType)
 		{
 			pstrHlhtHeadCtx = GetCiToRcWithRcHeadCtx(DeviceId);
 		}

TSCP/src/APP/ciapp/WashMachine/WashMachineConfigDataManage.c

@@ -334,6 +334,30 @@ UINT16 GetTrainTailStopSteadyRelayId(const UINT16 washMachineId)
 	return retVal;
 }
 
+/*
+* 功能描述： 获取指定ID洗车机联挂端停稳继电器
+* 参数说明： const UINT16 washMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 联挂端停稳继电器
+*/
+UINT16 GetCoupingStopSteadyRelayId(const UINT16 washMachineId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16 retVal = 0u;
+
+	bufIndex = GetWashMachineIdConfigBufIndex(washMachineId);  /*获取洗车机数组下标*/
+
+	if (bufIndex < WASHMACHINE_SUM_MAX)
+	{
+		retVal = WashMachineConfigDataStru[bufIndex].wCoupingStopSteadyRelayId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
 /*
 * 功能描述：	整理读入的洗车机配置数据
 * 参数说明：	无
@@ -953,3 +977,29 @@ UINT16 GetDccWashPassApplyLightRelayId(const UINT16 washMachineId)
 	}
 	return retVal;
 }
+
+/*
+* 功能描述： 获取指定ID洗车机允许联挂端清洗继电器
+* 参数说明： const UINT16 washMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 允许联挂端清洗继电器
+*/
+UINT16 GetCoupingWashAllowRelayId(const UINT16 washMachineId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16 retVal = 0u;
+
+	bufIndex = GetWashMachineIdConfigBufIndex(washMachineId);  /*获取洗车机数组下标*/
+
+	if (bufIndex < WASHMACHINE_SUM_MAX)
+	{
+		retVal = WashMachineConfigDataStru[bufIndex].wCouplingWashAllowRelayId;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+

TSCP/src/APP/ciapp/WashMachine/WashMachineConfigDataManage.h

@@ -37,14 +37,17 @@ typedef struct S_WashMachineConfigDataStruct
 	UINT16 TrainEmergencyStopRelayId;                                       /*列车紧急停车继电器(配置字段:采集继电器)*/
 	UINT16 HeadWashAllowRelayId;                                            /*允许车头清洗继电器(配置字段:采集继电器)*/
 	UINT16 TailWashAllowRelayId;     										/*允许车尾清洗继电器(配置字段:采集继电器)*/
+	UINT16 wCouplingWashAllowRelayId;     								    /*允许联挂端清洗继电器(配置字段:采集继电器)*/
 	UINT16 WashTrainRequestRelayId;                /*洗车请求继电器(配置字段:驱动继电器)，合肥用作洗车同意继电器*/
 	UINT16 TrainHeadStopSteadyRelayId;                                      /*车头停稳继电器(配置字段:驱动继电器)*/
 	UINT16 TrainTailStopSteadyRelayId;                                      /*车尾停稳继电器(配置字段:驱动继电器)*/
+	UINT16 wCoupingStopSteadyRelayId;                                       /*联挂端停稳继电器(配置字段:驱动继电器)*/
 	UINT16 TrainPassRequestRelayId;                                         /*通过请求继电器(配置字段:驱动继电器)*/
 	UINT16 TrainOutWashPortAllowRelayId;                               /*允许列车出库继电器(配置字段:采集继电器)*/
 	UINT16 PauseTrainWashRequestRelayId;                                    /*暂停洗车继电器(配置字段:驱动继电器)*/	
 	UINT16 WashModeBackRelayId;                                             /*全自动洗车模式反馈继电器(配置字段:采集继电器)*/
 	UINT16 WashModeRelayId;													/*全自动自动洗车模式继电器（配置字段:驱动继电器)*/
+
 	UINT16 wDownWashAllowRelayId;											/*降级模式洗车同意按钮继电器ID(配置字段:采集继电器)*/
 	UINT16 wDownWashAllowLightRelayId;										/*降级模式洗车同意指示灯继电器ID（配置字段:驱动继电器)*/
 	UINT16 wDownDccWashAllowRelayId;										/*降级模式DCC洗车同意按钮继电器ID (配置字段:采集继电器)*/
@@ -397,6 +400,21 @@ UINT16 GetWashPassApplyLightRelayId(const UINT16 washMachineId);
 */
 UINT16 GetDccWashPassApplyLightRelayId(const UINT16 washMachineId);
 
+/*
+* 功能描述： 获取指定ID洗车机允许联挂端清洗继电器
+* 参数说明： const UINT16 washMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 允许联挂端清洗继电器
+*/
+UINT16 GetCoupingWashAllowRelayId(const UINT16 washMachineId);
+
+/*
+* 功能描述： 获取指定ID洗车机联挂端停稳继电器
+* 参数说明： const UINT16 washMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 联挂端停稳继电器
+*/
+UINT16 GetCoupingStopSteadyRelayId(const UINT16 washMachineId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/WashMachine/WashMachineDataManage.c

@@ -14,7 +14,7 @@
 
 
 WashMachineDataStruct WashMachineDataStru[WASHMACHINE_SUM_MAX];       /*定义洗车机数据结构体*/
-
+UINT8 RouteDriveIntoResult = CI_ERROR;    /*判断进路是否有车驶入过*/
 
 /*
 * 功能描述： 获取指定ID洗车机数据
@@ -2296,3 +2296,119 @@ void SetDownWashDccAllowPassCycle(const UINT16 washMachineId, const UINT32 washA
 	}
 }
 
+/*
+* 功能描述： 获取指定ID洗车机允许联挂端清洗状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 允许联挂端清洗状态
+*/
+UINT8 GetCoupingWashAllowState(const UINT16 WashMachineId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = 0u;
+
+	bufIndex = GetWashMachineIdConfigBufIndex(WashMachineId);  /*获取洗车机数组下标*/
+
+	if (bufIndex < WASHMACHINE_SUM_MAX)
+	{
+		retVal = WashMachineDataStru[bufIndex].chCoupingWashAllowState;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+
+}
+
+/*
+* 功能描述： 设置指定ID洗车机允许联挂端清洗状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+			 const UINT8 state,设置状态
+* 返回值  ： 0: 设置失败
+*			 1: 设置成功
+*/
+UINT8 SetCoupingWashAllowState(const UINT16 WashMachineId, const UINT8 state)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = 0u;
+
+	bufIndex = GetWashMachineIdConfigBufIndex(WashMachineId);  /*获取洗车机数组下标*/
+
+	if (bufIndex < WASHMACHINE_SUM_MAX)
+	{
+		if ((WASHMACHINE_COL_COUPINGWASH_YES == state) || (WASHMACHINE_COL_COUPINGWASH_NO == state))
+		{
+			WashMachineDataStru[bufIndex].chCoupingWashAllowState = state;
+
+			retVal = CI_SUCCESS;
+		}
+		else
+		{
+			retVal = CI_ERROR;
+		}
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+
+/*
+* 功能描述： 设置指定ID洗车机联挂端停稳驱动状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+*			 const UINT8 drvState, 驱动状态
+* 返回值  ： 无
+*
+*/
+void SetCoupingStopSteadyDrvState(const UINT16 WashMachineId, const UINT8 drvState)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+
+	bufIndex = GetWashMachineIdConfigBufIndex(WashMachineId);  /*获取洗车机数组下标*/
+
+	if (bufIndex < WASHMACHINE_SUM_MAX)
+	{
+		if ((WASHMACHINE_COUPING_STEADY_YES == drvState) || (WASHMACHINE_COUPING_STEADY_NO == drvState))
+		{
+			WashMachineDataStru[bufIndex].chCoupingStopSteadyDrvState = drvState;
+		}
+		else
+		{
+			/*不做处理*/
+		}
+	}
+	else
+	{
+		/*不做处理*/
+	}
+}
+
+/*
+* 功能描述： 获取指定ID洗车机允许联挂端停稳驱动状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 停稳驱动状态
+*/
+UINT8 GetCoupingStopSteadyDrvState(const UINT16 WashMachineId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = 0u;
+
+	bufIndex = GetWashMachineIdConfigBufIndex(WashMachineId);  /*获取洗车机数组下标*/
+
+	if (bufIndex < WASHMACHINE_SUM_MAX)
+	{
+		retVal = WashMachineDataStru[bufIndex].chCoupingStopSteadyDrvState;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+
+}
+
+

TSCP/src/APP/ciapp/WashMachine/WashMachineDataManage.h

@@ -35,9 +35,11 @@ typedef struct S_WashMachineDataStruct
 	UINT8 TrainEmergencyStopState;                                          /*列车紧急停车状态(动态字段:采集)*/
 	UINT8 HeadWashAllowState;                                               /*允许车头清洗状态(动态字段:采集)*/
 	UINT8 TailWashAllowState;     										    /*允许车尾清洗状态(动态字段:采集)*/
+	UINT8 chCoupingWashAllowState;     										/*允许联挂端清洗状态(动态字段:采集)*/
 	UINT8 WashTrainRequestDrvState;                                         /*洗车请求驱动状态(动态字段:驱动)*/
 	UINT8 TrainHeadStopSteadyDrvState;                                      /*车头停稳驱动状态(动态字段:驱动)*/
 	UINT8 TrainTailStopSteadyDrvState;                                      /*车尾停稳驱动状态(动态字段:驱动)*/
+	UINT8 chCoupingStopSteadyDrvState;                                      /*联挂端停稳驱动状态(动态字段:驱动)*/
 	UINT8 TrainOutWashTrainPortAllowState;                                  /*允许出洗车库状态(动态字段:采集)*/
 	UINT8 PauseTrainWashRequestDrvState;                                    /*暂停洗车请求驱动状态(动态字段:驱动)*/
 	UINT8 PaseWashMachineRequesDrvtState;                                   /*通过洗车机请求驱动状态(动态字段:驱动)*/
@@ -45,6 +47,7 @@ typedef struct S_WashMachineDataStruct
 	UINT32 WashWorkModeRelayDrvCycle;									    /*洗车模式继电器驱动起始周期号*/
 	UINT8 WashModeState;                                                    /*洗车模式(动态字段:采集)*/
 	UINT8 chSetWashWorkModeBack;											/*设置洗车机工作模式反馈(动态字段:采集)*/
+
 	UINT8 chDownWashAllowState;												/*降级模式洗车同意状态(动态字段:融合)*/
 	UINT8 chDownWashAllowPassState;											/*降级模式洗车同意通过状态(动态字段:融合)*/
 	UINT8 chDownWashReqState;												/*降级模式洗车请求状态*/
@@ -72,6 +75,7 @@ typedef struct S_WashMachineDataStruct
 
 
 extern WashMachineDataStruct WashMachineDataStru[WASHMACHINE_SUM_MAX];       /*定义洗车机数据结构体*/
+extern UINT8 RouteDriveIntoResult;    /*判断进路是否有车驶入过*/
 /*
 * 功能描述： 获取指定ID洗车机数据
 * 参数说明： 
@@ -776,7 +780,39 @@ UINT8 GetDownDccWashAllowPassErrState(const UINT16 washMachineId);
 */
 void SetDownDccWashAllowPassErrState(const UINT16 washMachineId, const UINT8 dccPassWashAdhesionState);
 
+/*
+* 功能描述： 获取指定ID洗车机允许联挂端清洗状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 允许联挂端清洗状态
+*/
+UINT8 GetCoupingWashAllowState(const UINT16 WashMachineId);
 
+/*
+* 功能描述： 设置指定ID洗车机允许联挂端清洗状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+			 const UINT8 state,设置状态
+* 返回值  ： 0: 设置失败
+*			 1: 设置成功
+*/
+UINT8 SetCoupingWashAllowState(const UINT16 WashMachineId, const UINT8 state);
+
+/*
+* 功能描述： 设置指定ID洗车机联挂端停稳驱动状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+*			 const UINT8 drvState, 驱动状态
+* 返回值  ： 无
+*
+*/
+void SetCoupingStopSteadyDrvState(const UINT16 WashMachineId, const UINT8 drvState);
+
+/*
+* 功能描述： 获取指定ID洗车机允许联挂端停稳驱动状态
+* 参数说明： const UINT16 WashMachineId, 洗车机ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 停稳驱动状态
+*/
+UINT8 GetCoupingStopSteadyDrvState(const UINT16 WashMachineId);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/WashMachine/WashMachineDefine.h

@@ -30,6 +30,9 @@
 #define WASHMACHINE_TAIL_STEADY_YES ((UINT8)0x55)   /*车尾停稳驱动状态*/
 #define WASHMACHINE_TAIL_STEADY_NO  ((UINT8)0xaa)   /*车尾未停稳驱动状态*/
 
+#define WASHMACHINE_COUPING_STEADY_YES ((UINT8)0x55)   /*联挂端停稳驱动状态*/
+#define WASHMACHINE_COUPING_STEADY_NO  ((UINT8)0xaa)   /*联挂端未停稳驱动状态*/
+
 #define WASHMACHINE_PAUSE_DRVREQ_TRUE              ((UINT8)0x55)   /*暂停洗车请求有效驱动状态*/
 #define WASHMACHINE_PAUSE_DRVREQ_FALSE            ((UINT8)0xaa)   /*暂停洗车请求无效驱动状态*/
 
@@ -52,6 +55,9 @@
 #define WASHMACHINE_COL_TAILWASH_YES           ((UINT8)0x55)   /*尾部洗车允许*/
 #define WASHMACHINE_COL_TAILWASH_NO            ((UINT8)0xaa)   /*尾部洗车不允许*/
 
+#define WASHMACHINE_COL_COUPINGWASH_YES           ((UINT8)0x55)   /*联挂端洗车允许*/
+#define WASHMACHINE_COL_COUPINGWASH_NO            ((UINT8)0xaa)   /*联挂端洗车不允许*/
+
 #define WASHMACHINE_COL_FALUT_YES        ((UINT8)0x55)   /*洗车机故障*/
 #define WASHMACHINE_COL_FALUT_NO         ((UINT8)0xaa)   /*洗车机未故障*/