应用代码及数据更新

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))
+		chResult = IsSerialDevice(dstDevTypeId, &serialGroup);
-		{
-			if (((CI_TYPE_CLD == chLocalCiType) && (CI_TYPE_SCX == chDstCiType)) || ((CI_TYPE_SCX == chLocalCiType) && (CI_TYPE_CLD == chDstCiType)))
-			{
-				/*串口通信要求双方一个为车辆段一个为试车线*/
-				chResult = CI_SUCCESS;
-			}
-			else
-			{
-				; /*CI类型错误，返回失败*/
-			}
-		}
-		else
-		{
-			; /*不为串口通信，此时不对本地CI类型及对方CI类型进行判断*/
-		}
 
 		if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType)
 			|| (CI_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               116   /*集成次数编号*/
+#define VER_INTE_TIME               127   /*集成次数编号*/
 
 #endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/

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

@@ -1629,7 +1629,7 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 			pCiAppDataPointer[curIndex] = gCbtcCrossStructZc[ii].wTrainId;
 			curIndex += 1u;
 		}
-
+		
 		/*����һ��CRC*/
 		crcLength = curIndex - crcIndex;
 		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
@@ -3800,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;
@@ -4701,7 +4701,7 @@ UINT32 CopyValidSetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 		{
 			m_OcToCiOrginDataNum = (UINT8)ValidIdNum;
 			/*����*/
-			//printf("m_OcToCiOrginDataNum = %d\n", m_OcToCiOrginDataNum);
+			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++)
 			{
@@ -4884,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;
@@ -4905,9 +4904,8 @@ UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcTo
 		ShortToChar(m_OcToCiOrginDataNum, pCurCiAppDataPointer);
 		curIndex += (UINT32)sizeof(UINT16);  /*�������ֽ��豸����*/
 		//printf("m_OcToCiOrginDataNum = %d\n", m_OcToCiOrginDataNum);
-		if (struNum > ValidIdNum)
+
-		{
+		for (i = 0U; i < m_OcToCiOrginDataNum; i++)
-			for (i = 0U; i < m_OcToCiOrginDataNum; i++)
 			{
 				ShortToChar(OcRecvData[i].OcId, (pCurCiAppDataPointer + curIndex));
 				curIndex += 2U;
@@ -5056,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));
+		(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)), s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)));
-		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u);
+		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U));
+		/*拷贝link列车排序*/
+		dwLinkNumIndex = copyIndex;
+		copyIndex += 2U;
+		for (u16Index = 1U; u16Index <= g_pSortLinkNum; u16Index++)
+		{
+			wTmpLinkId = g_pSortLinkInfo[u16Index].u16ID;
+			chLinkCIId = (UINT8)GetLinkManageTiocById(wTmpLinkId);
+			if ((0U != chLocalId) && (chLinkCIId == chLocalId))
+			{
+				/*仅拷贝本联锁*/
+				(void)CommonMemCpy(&pDataBuff[copyIndex],(UINT32)(sizeof(AS_SORT_INFO_s)), &g_pSortLinkInfo[u16Index], (UINT32)(sizeof(AS_SORT_INFO_s)));
+				copyIndex += (UINT32)(sizeof(AS_SORT_INFO_s));
+				wLinkNum++;
+			}
+		}
+		ShortToChar(wLinkNum, &pDataBuff[dwLinkNumIndex]); /* 写入有车占用的计轴区段数量 */
 		ret = copyIndex;
 	}
 	else
@@ -2215,12 +2237,29 @@ UINT32 as_SetTransferData(IN UINT8 * pDataBuff, IN UINT32 curIndex)
 {
 	UINT32 ret = curIndex;
 	UINT32 copyIndex = curIndex;
+	UINT16 wLinkNum = 0U;
+	UINT16 jj = 0U;
+	UINT16 wTmpLinkId =0U;
+	UINT16 wLinkIndex = 0U;
 	if (NULL != pDataBuff)
 	{
 		(void)CommonMemCpy(s_pCTSortIndex, (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM), &pDataBuff[copyIndex], (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM));
 		copyIndex += (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM);
-		(void)CommonMemCpy(s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u), &pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u));
+		(void)CommonMemCpy(s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)), &pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)));
-		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u);
+		copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U));
+		/*拷贝列车排序*/
+		wLinkNum = ShortFromChar(&pDataBuff[copyIndex]);
+		copyIndex += 2u;
+		for (jj = 0U; jj < wLinkNum; jj++)
+		{
+			wTmpLinkId = ShortFromCharLE(&pDataBuff[copyIndex]);
+			wLinkIndex = g_pSortLinkIndex[wTmpLinkId];
+			if ((DEFAULT_ZERO < wLinkIndex) && (wLinkIndex < AS_LINK_MAX+1U))
+			{			
+				(void)CommonMemCpy(&g_pSortLinkInfo[wLinkIndex], (UINT32)(sizeof(AS_SORT_INFO_s)), &pDataBuff[copyIndex], (UINT32)(sizeof(AS_SORT_INFO_s)));
+				copyIndex += (UINT32)(sizeof(AS_SORT_INFO_s));
+			}
+		}
 		ret = copyIndex;
 	}
 	else

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

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

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

@@ -105,37 +105,34 @@ SAME_LINE_ERR,
 */
 UINT8 IsSameLineCI(const UINT8 ciA, const UINT8 ciB)
 {
-	UINT32 etcsIdA, etcsIdB;
+	UINT32 etcsIdA = 0U;
-	UINT16 u16CiA, u16CiB;
+	UINT32 etcsIdB = 0U;
+	UINT16 u16CiA = 0U;
+	UINT16 u16CiB = 0U;
 	UINT8 retVal = SAME_LINE_ERR;
-	UINT8 cbtcSysType = DQU_CBTC_FAO;
 	UINT8 dquDevNameA = CI_ERROR;
 	UINT8 dquDevNameB = CI_ERROR;
+	UINT8 chCiAFactoryType = 0U;
+	UINT8 chCiBFactoryType = 0U;
 
-	u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256u) + ciA);
+	u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciA);
-	u16CiB = (UINT16)((CI_SYSTEM_TYPE_RCI * 256u) + ciB);
+	u16CiB = (UINT16)((CI_SYSTEM_TYPE_RCI * 256U) + ciB);
 
-	cbtcSysType = GetCbtcSysType();
+	dquDevNameA = dquDevName2HlhtId(u16CiA,0U,&etcsIdA);
+	dquDevNameB = dquDevName2HlhtId(u16CiB,0U,&etcsIdB);
 
-	dquDevNameA = dquDevName2HlhtId(u16CiA,0u,&etcsIdA);
+	/*需要增加互联互通的判断*/
-
+	if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
-	dquDevNameB = dquDevName2HlhtId(u16CiB,0u,&etcsIdB);
-
-	if(DQU_CBTC_CPK == cbtcSysType)
 	{
-		retVal = SAME_LINE_YES;
+		/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
-	}
+		if ((etcsIdA & ((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
-	else if(DQU_CBTC_FAO == cbtcSysType)
-	{
-		retVal = SAME_LINE_YES;	
-	}
-	else if(DQU_CBTC_HLT == cbtcSysType)
-	{
-		/*需要增加互联互通的判断*/
-		if ((CI_SUCCESS == dquDevNameA) && (CI_SUCCESS == dquDevNameB))
 		{
-			/*根据互联互通ETCS编号的定义，从低到高第三个字节为线路编号*/
+			retVal = SAME_LINE_YES;
-			if ((etcsIdA&((UINT32)0x00ff0000)) == (etcsIdB & ((UINT32)0x00ff0000)))
+
+			/*同一条线路，一期二期使用不同厂家联锁，也判为不同线路，接口走互联互通*/
+			chCiAFactoryType = GetCiFactoryType(ciA);
+			chCiBFactoryType = GetCiFactoryType(ciB);
+			if (chCiAFactoryType == chCiBFactoryType)
 			{
 				retVal = SAME_LINE_YES;
 			}
@@ -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;
 }
 /*

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

@@ -4997,15 +4997,15 @@ void SetPhySecSpksFLockBySpksId(UINT16 spksId,UINT8 spksStatus)
 */
 UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const chkDevStatus)
 {	
-	UINT8 devState = 0u;
+	UINT8 devState = 0U;
-	UINT8 tmpDevState = 0u;
+	UINT8 tmpDevState = 0U;
-	UINT8 tmpPsdVobcCmd = 0u;
+	UINT8 tmpPsdVobcCmd = 0U;
-	UINT8 tmpColor = 0u;
+	UINT8 tmpColor = 0U;
-	UINT8 ttmpDevState = 0u;
+	UINT8 ttmpDevState = 0U;
-	UINT8 psdMutualLockState = 0u;
+	UINT8 psdMutualLockState = 0U;
-	UINT16 tempdevId = 0u;                   /*临时设备ID*/
+	UINT16 tempdevId = 0U;                   /*临时设备ID*/
-	UINT8 tempdevState = 0u;                 /*临时设备状态*/
+	UINT8 tempdevState = 0U;                 /*临时设备状态*/
-
+	UINT8 chPsdExceptState = 0U;
 	switch(devType)
 	{
 	case CI_DEVICE_TYPE_SWITCH:           /*道岔*/
@@ -5020,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)
@@ -5039,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:          /*进路*/
@@ -5073,41 +5073,51 @@ 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)
+		chPsdExceptState = GePsdExceptState(devId);
-			|| (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == psdMutualLockState))
+
+		if (PSD_EXCEPT_NO != chPsdExceptState)
 		{
-			/* 采集到互锁解除，则直接认为屏蔽门关闭 */
+			devState = OTHER_CI_PSD_STATUS_OPEN;  /* 屏蔽门异常状态,则认为打开 */
-			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;
 		}
 		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 = GePsdExceptState(devId);
@@ -5125,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:	/* 洗车机 */
@@ -5148,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;
 			}
@@ -6200,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)
@@ -6470,13 +6481,21 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 		{/*防护道岔封锁状态检查*/
 			devId = 0u;                   /*设备ID*/
 			devState = 0u;                 /*设备状态*/
-			reVal = LogicSecRltvPrtctSwFlockCheck(logSectionId, &devId, &devState);/*封锁检查*/
+			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;
+			}
 		}
 
 	}
@@ -6863,7 +6882,7 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 
 
 /*
-功能描述: 	驱动计轴区段内道岔处理
+功能描述: 	驱动计轴区段内道岔，计轴区段关联防护道岔处理
 输入参数:	const UINT16 axisSecId 计轴区段ID
 输出参数:	const UINT8 DrivFlag 道岔驱动标志
 返回值:		无
@@ -6875,7 +6894,6 @@ 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;
@@ -6895,7 +6913,7 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
 			{
 				switchId = pAxisSecSwitchStru[ii].SwitchId;
 				switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
-				funRtn = SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
 			}
 
 			for (ii = 0u; ii < protectSwitchSum; ii++)
@@ -11657,21 +11675,19 @@ UINT8 GetLocalVirCiType(UINT8 chVirCiId)
 /*
 * 功能描述：判断本联锁临时限速状态
 * 参数说明：无
-* 返 回 值：临时限速有效返回失败，清除或与ZC通信正常返回成功
+* 返 回 值：临时限速有效返回失败，清除或与限速确认返回成功
 * Created :LYJ
 */
 
 UINT8 CheckLocalCiLSXSStata(void)
 {
-	UINT8 cLocalCiId = 0U;
 	UINT8 chRet = 0U;
 	UINT8 chVirCINum = 0U;
 	UINT8 i = 0U;
 	UINT8 chXiansuState = 0U;
 	UINT8 chVirtualCIid = 0U;
 	UINT8 chTsrSureFlag = 0U;
-	cLocalCiId = GetSystemParaLocalCiId();
+	
-	chVirCINum = GetVirtualCINum();
 	chTsrSureFlag = GetTsrSureFlag(); /*获取临时限速确认标志*/
 	if (CI_TSR_SURE_YES == chTsrSureFlag)
 	{
@@ -11679,7 +11695,9 @@ UINT8 CheckLocalCiLSXSStata(void)
 	}
 	else
 	{
-		/*临时限速未确认，判断是否做了限速确认*/
+		/*临时限速未确认，判断是否做了限速清除*/
+		
+		chVirCINum = GetVirtualCINum();
 		for (i = 0U; i < chVirCINum; i++)
 		{
 			chVirtualCIid = GetVirtualCIid(i);
@@ -11697,4 +11715,85 @@ UINT8 CheckLocalCiLSXSStata(void)
 	}
 
 	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

@@ -76,7 +76,7 @@ typedef struct S_AreaSnowInfoStruct
 #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			((UINT8)1499)		/*跨压信号机ID最大值*/
+#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*/
 
@@ -226,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;/*继电接口确认标志*/
@@ -1988,4 +1986,28 @@ UINT8 GetLocalVirCiType(UINT8 chVirCiId);
 */
 
 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/IO/DeviceRelayDataProcess.h

@@ -186,10 +186,9 @@ UINT8 PsdDeviceToRelayStateProc(void);
 /*
 * 功能描述： 更新洗车机继电器状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
+* 返回值  ： void     
-*			 1: 更新成功      
 */
-UINT8 WashMachineDevToRelayStaProc(void);
+void WashMachineDevToRelayStaProc(void);
 
 /*
 * 功能描述： 更新紧急停车按钮逻辑状态
@@ -226,10 +225,9 @@ void GaragedoorDevToRelayStaProc(void);
 /*
 * 功能描述： 更新洗车机的逻辑状态
 * 参数说明： void
-* 返回值  ： 0: 更新失败
+* 返回值  ： void
-*			 1: 更新成功
 */
-UINT8 WashMachineToDeviceStateProc(void);
+void WashMachineToDeviceStateProc(void);
 /*
 * 功能描述： 更新Spks按钮逻辑状态
 * 参数说明： void
@@ -1194,13 +1192,6 @@ void SwitchDoubleMainProtect(UINT16 switchId);
 * add by mpt 20260328
 */
 void FindSwitchPostionCmdOut(UINT16 switchId);
-/*
-* 功能描述：道岔寻表超时检测模块
-* 参数说明： UINT16 switchId 道岔ID
-* 返回值  ： void
-* add by mpt 20260330
-*/
-void FindSwitchPostionCmdTimeOutCheck(UINT16 switchId);
 
 
 #ifdef __cplusplus

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

@@ -946,7 +946,7 @@ void ProcessOcToCiData(void)
 {
 	UINT8 localCiId = 0u;					/*本地联锁ID*/
 
-	UINT16 ii = 0u;
+	UINT8 ii = 0u;
 	UINT16 jj = 0u;
 	UINT16 j = 0u;
 	UINT16 ind = 0u;
@@ -968,6 +968,7 @@ void ProcessOcToCiData(void)
 	UINT8 chOcId = 0U;
 	UINT8 transmitState = 0U;
 	UINT8 chThisOcCotrolMode = 0u;
+	UINT8 mm = 0u;
 
 	localCiId = GetSystemParaLocalCiId();
 
@@ -1015,9 +1016,9 @@ void ProcessOcToCiData(void)
 							pTempOc->OcDevices[jj].szSwitchIncldeZzjState[chSwitchZzjIndex] = OC_SWITCH_POSITION_SIKAI;
 						}
 
-						for (kk = 0u; kk < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; kk++)
+						for (mm = 0u; mm < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; mm++)
 						{
-							pTempOc->OcDevices[jj].MainStandbyState[kk] = STANDBY_CONTROL;/*备控制权*/
+							pTempOc->OcDevices[jj].MainStandbyState[mm] = STANDBY_CONTROL;/*备控制权*/
 						}
 
 					}
@@ -1071,20 +1072,20 @@ void ProcessOcToCiData(void)
 							m_Switches[jj].MainStandbyState[j] = STANDBY_CONTROL;/*备控*/
 						}
 
-						SetSwitchOcPlusBoxSateState(m_Switches[jj].DeviceId, pTempOc->OcId, SWITCH_BOX_FAULT);/*道岔插箱故障*/
+						SetSwitchOcPlusBoxSateState(m_Switches[jj].DeviceId, (UINT8)pTempOc->OcId, SWITCH_BOX_FAULT);/*道岔插箱故障*/
 
 						/*重置板卡为故障状态*/
 						for (j = 0U; j < MAX_OC_SWITCH_INCLUDE_BOARD_NUM; j++)
 						{
-							SetSwitchThisOCBoardState(m_Switches[jj].DeviceId, m_Switches[jj].OcId, m_Switches[jj].BoardAddr[j], 0xffU);
+							SetSwitchThisOCBoardState(m_Switches[jj].DeviceId, (UINT8)m_Switches[jj].OcId, m_Switches[jj].BoardAddr[j], 0xffU);
 						}
 
 						/*通信中断降状态为备控并设置周期号*/
-						chThisOcCotrolMode = GetSwitchThisOcCotrolMode(m_Switches[jj].DeviceId, pTempOc->OcId);
+						chThisOcCotrolMode = GetSwitchThisOcCotrolMode(m_Switches[jj].DeviceId, (UINT8)pTempOc->OcId);
 						if ((MAIN_CONTROL == chThisOcCotrolMode) || (ERR_MODE_CONTROL == chThisOcCotrolMode))
 						{/*主控或异常控*/
-							SetSwitchThisOcCotrolMode(m_Switches[jj].DeviceId, pTempOc->OcId, STANDBY_CONTROL);
+							SetSwitchThisOcCotrolMode(m_Switches[jj].DeviceId, (UINT8)pTempOc->OcId, STANDBY_CONTROL);
-							SetSwitchOutMainContrCmdCycNum(m_Switches[jj].DeviceId, pTempOc->OcId, curCycle);/*在通信中断当周期设置OC备控，并刷新周期号，其他OC做升主控操作时需延时一定时间*/
+							SetSwitchOutMainContrCmdCycNum(m_Switches[jj].DeviceId, (UINT8)pTempOc->OcId, curCycle);/*在通信中断当周期设置OC备控，并刷新周期号，其他OC做升主控操作时需延时一定时间*/
 						}
 
 					}
@@ -1382,7 +1383,7 @@ void ProcessZcToCiData(void)
 
 	sourceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_ZC);/*获取与本联锁通信的ZC的ID，目前一个联锁最多只与一个ZC通信*/
 
-	if (sourceIdBuf != NULL)
+	if (NULL != sourceIdBuf)
 	{
 		/*更新与ZC通信状态*/
 		(void)UpdateCiTransmitState(localCiId, CI_SYSTEM_TYPE_ZC, sourceIdBuf[0]);
@@ -1391,11 +1392,11 @@ void ProcessZcToCiData(void)
 		hLHTHeadCtxValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_ZC, sourceIdBuf[0]); 
 		if (CI_ERROR == hLHTHeadCtxValid)	/*不使用GetZcMaskZcId()来获取ZC ID，因为组包完给ZC数据就清空了*/
 		{
-			dataValidFlag = 0u;
+			dataValidFlag = 0U;
 		}
 		else
 		{/*消息有效*/
-			dataValidFlag = 1u;
+			dataValidFlag = 1U;
 		}
 		debug_infor_printf((const)"\n CurCycle:%d  ZcCiValidFlag:%d \n",curCycle,dataValidFlag);
 		
@@ -1405,7 +1406,7 @@ void ProcessZcToCiData(void)
 
 		secJumpLockDelayUnlockCount = GetSysParaSecJLokDelayUnlockCyc();/*获取区段跳跃延时解锁周期数*/
 
-		if ((0u == zcMaskValueLen) || (NULL == pZcMaskValueBuf))
+		if ((0U == zcMaskValueLen) || (NULL == pZcMaskValueBuf))
 		{/*未收到zc发送过来的码位数据*/
 
 			/*if (GetCiTransmitState(CI_SYSTEM_TYPE_ZC, 0u) != TRANSMIT_STATE_GOOD)*/
@@ -1573,7 +1574,7 @@ void ProcessZcToCiData(void)
 			}
 		}
 
-		if (reVal == CI_SUCCESS)
+		if (CI_SUCCESS == reVal)
 		{
 			/*与ZC通信恢复后，倒计时立即结束，维持动态测试防护锁闭状态*/
 			phySecCurSum = GetPhySecCurSum();
@@ -1603,7 +1604,7 @@ void ProcessZcToCiData(void)
 		}
 
 		/*处理ZC发送的临时限速信息*/
-		if (reVal == CI_SUCCESS)
+		if (CI_SUCCESS == reVal)
 		{
 			cTsrSureFlag = GetTsrSureFlag();
 			pZcToCiDataStru = GetZcToCiDataStru();
@@ -1627,7 +1628,7 @@ void ProcessZcToCiData(void)
 		}
 
 		/*处理ZC发送的紧急制动信息*/
-		if (reVal == CI_SUCCESS)
+		if (CI_SUCCESS == reVal)
 		{
 			if (NULL != pZcToCiDataStru)
 			{
@@ -1647,12 +1648,10 @@ void ProcessZcToCiData(void)
 			}
 		}
 
-		/*此处不再处理ZC发送的雨雪信息，转至融合处处理*/
-
 		/*处理ZC发送的雨雪模式信息*/
-		if (reVal == CI_SUCCESS)
+		if (CI_SUCCESS == reVal)
 		{
-			if ((1u == dataValidFlag)&&(ZC_TSR_VALID == pZcToCiDataStru->tsrInputInfoStru.cTsrValidFlag))
+			if (1U == dataValidFlag)
 			{
 				if ((CI_ALL_SNOW_VALID == pZcToCiDataStru->cSnowValidFlag) || (CI_ALL_SNOW_UNVALID == pZcToCiDataStru->cSnowValidFlag))
 				{
@@ -1674,7 +1673,7 @@ void ProcessZcToCiData(void)
 
 
 		/*处理ZC发送的ITE全线切除信息*/
-		if (reVal == CI_SUCCESS)
+		if (CI_SUCCESS == reVal)
 		{
 			if ((1u == dataValidFlag) && (ZC_TSR_VALID == pZcToCiDataStru->tsrInputInfoStru.cTsrValidFlag) && ((CI_ITE_LINE_CUT_VALID == pZcToCiDataStru->cIteLineCutState)
 				|| (CI_ITE_LINE_CUT_INVALID == pZcToCiDataStru->cIteLineCutState) || (CI_ITE_LINE_CUT_DEFAULT == pZcToCiDataStru->cIteLineCutState)))
@@ -1699,9 +1698,16 @@ void ProcessZcToCiData(void)
 		{
 			if ((1u == dataValidFlag) && (ALL_CBTC_CROSS_SUM_MAX >= pZcToCiDataStru->wCbtcCrossNum))
 			{
-				/*设置*/
+				/*当周期收到CBTC跨压帧时，设置CBTC跨压全局变量*/
-				SetCbtcCrossInfo(pZcToCiDataStru->wCbtcCrossNum,
+				if (CI_SUCCESS == pZcToCiDataStru->cRecvCbtcCrossFrameTag)
-					pZcToCiDataStru->wCbtcCrossSignalId, pZcToCiDataStru->wCbtcCrossTrainId);
+				{
+					SetCbtcCrossInfo(pZcToCiDataStru->wCbtcCrossNum,
+						pZcToCiDataStru->wCbtcCrossSignalId, pZcToCiDataStru->wCbtcCrossTrainId);
+				}
+				else
+				{
+					/*nothing*/
+				}
 			}
 			else
 			{
@@ -1731,7 +1737,11 @@ void ProcessTmcToTiocData(void)
 	UINT8* deviceIdBuf = NULL;
 	UINT8 ii = 0u;
 	UINT8 cTransState = 0U;  /*与TMC通信状态*/
+	UINT8 chWorkType = 0U; /*双系工作模式*/
+	UINT8 cRcWorkMode = 0u;/*RC工作模式*/
 
+	chWorkType = GetSystemWorkType();
+	cRcWorkMode = GetLocalRcWorkMode();
 	/*手动更新TMC通信状态*/
 	cLocalTiocId = GetSystemParaLocalCiId();
 	deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_TMC); /*获取通信TMC设备总数*/
@@ -1754,6 +1764,10 @@ void ProcessTmcToTiocData(void)
 		else
 		{
 			ClearLineCommTrainData();  /*与TMC通信中断，清除本地存储的全线通信车信息*/
+			if ((SYSTEM_WORK_MODE_ALL == chWorkType) && (RC_WORK_MODE_TIOC == cRcWorkMode))
+			{
+				SetTsrSureFlag(CI_TSR_SURE_NO);
+			}
 		}
 	}
 	else
@@ -1858,7 +1872,6 @@ void ProcessVobcToCiData(void)
 {
 	UINT8 ii = 0u;
 	UINT8 jj = 0u;
-	UINT8 kk = 0u;
 	UINT8 vobcToCiDataSum = GetVobcToCiSum();
 	VobcToCiDataStruct* vobcToCiDataStru = GetVobcToCiDataStru();
 	UINT8 chLineIdentity = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);/*获取线路标识*/
@@ -1917,7 +1930,7 @@ void ProcessVobcToCiData(void)
 				for (jj = 0u; ((jj < vobcToCiDataStru[ii].PsdSum) && (jj < VOBC_TO_CI_TRAIN_PSD_MAX)); jj++)
 				{
 					/*由于新机场线VOBC和CI一直通信，导致故障隔离信息无法清除，故在此检查收到最后一次VOBC的控制命令是否超时*/
-					if ((dwCurCycNum - vobcToCiDataStru[ii].PsdData[kk].CmdStartCycNum) > dwTransmitBadEnsureCount)
+					if ((dwCurCycNum - vobcToCiDataStru[ii].PsdData[jj].CmdStartCycNum) > dwTransmitBadEnsureCount)
 					{
 						ClearPsdVobcContext(vobcToCiDataStru[ii].VobcId);
 						break;
@@ -4890,7 +4903,7 @@ void ProcessDeviceLogicState(void)
 	(void)GaragedoorRelayToDevStaProc();
 
 	/*洗车机处理*/
-	(void)WashMachineToDeviceStateProc();
+	WashMachineToDeviceStateProc();
 
 	/*防淹门处理*/
 	FloodGateRelayToDeviceStateProc();
@@ -5224,6 +5237,7 @@ UINT8 MaskDataProcess(const UINT8 systemType,const UINT8* maskBuf, const UINT16
 					/*不设置无效，进路状态处理设置*/
 				}
 				break;
+
 			}
 		
 			break;
@@ -5318,7 +5332,7 @@ UINT8 MaskDataProcess(const UINT8 systemType,const UINT8* maskBuf, const UINT16
 */
 void ProcessCiToCiData(void)
 {
-	UINT8 localCiId = GetSystemParaLocalCiId();			/*本地联锁ID*/									
+	UINT8 chLocalCiId = 0U;			/*本地联锁ID*/
 	UINT8 jj = 0U;
 	UINT8 tranCiNum = 0U;
 	UINT8* tranCiIdBuf = NULL;
@@ -5327,7 +5341,7 @@ void ProcessCiToCiData(void)
 	UINT8 chMainMode = CI_SYSTEM_TYPE_RCI;/*主用模式*/
 	UINT8 chSystemType = GetSystemWorkType();
 	UINT8 chRcTransState = 0U;/*只判断Rc通信*/
-	
+	chLocalCiId = GetSystemParaLocalCiId();
 	/*如果相邻联锁通信中断则重置数据 通信关闭*/
 	if (SYSTEM_WORK_MODE_ALL == chSystemType)
 	{
@@ -5341,17 +5355,17 @@ void ProcessCiToCiData(void)
 		tranCiIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RCI);
 	}
 	
-
+	
-	for (jj = 0u;jj<tranCiNum;jj++)
+	for (jj = 0U;jj < tranCiNum;jj++)
 	{
-		if (tranCiIdBuf[jj] != localCiId)
+		if (tranCiIdBuf[jj] != chLocalCiId)
 		{
-			sameLineFlag = IsSameLineCI(localCiId, tranCiIdBuf[jj]);
+			sameLineFlag = IsSameLineCI(chLocalCiId, tranCiIdBuf[jj]);
 			if (SAME_LINE_YES == sameLineFlag)
 			{
 				/*更新通信状态*/
-				(void)UpdateCiTransmitState(GetSystemParaLocalCiId(), CI_SYSTEM_TYPE_RC, tranCiIdBuf[jj]);
+				(void)UpdateCiTransmitState(chLocalCiId, CI_SYSTEM_TYPE_RC, tranCiIdBuf[jj]);
-				(void)UpdateCiTransmitState(GetSystemParaLocalCiId(), CI_SYSTEM_TYPE_CI, tranCiIdBuf[jj]);
+				(void)UpdateCiTransmitState(chLocalCiId, CI_SYSTEM_TYPE_CI, tranCiIdBuf[jj]);
 				if (SYSTEM_WORK_MODE_ALL == chSystemType)
 				{
 					chMainMode = GetNearRCISendMainUseMode(tranCiIdBuf[jj]);
@@ -5395,10 +5409,18 @@ void ProcessCiToCiData(void)
 			}
 			else if (SAME_LINE_NO == sameLineFlag)
 			{
-				if (CI_SUCCESS != GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_RCI, tranCiIdBuf[jj]))
+				/*更新通信状态*/
+				(void)UpdateCiTransmitState(chLocalCiId, CI_SYSTEM_TYPE_CI, tranCiIdBuf[jj]);
+				tranCiState = GetCiTransmitState(CI_SYSTEM_TYPE_RCI, tranCiIdBuf[jj]);
+				if (TRANSMIT_STATE_GOOD != tranCiState)
 				{
 					ResetCiDevStateHlht(tranCiIdBuf[jj]);
 				}
+				else
+				{
+					/*不做处理*/
+				}
+				
 			}
 			else
 			{
@@ -6398,6 +6420,7 @@ static void ProcessPsdData(void)
 	UINT32 dwCurCycNum = 0U;
 	UINT32 dwCmdSetCycNum = 0U;  /*PSD命令周期*/
 	UINT32 dwTransmitBadEnsureCount = 0U;  /*CI与VOBC通信中断判断时间*/
+	
 
 	dwCurCycNum = Get2oo2CurCycleNum();
 	dwTransmitBadEnsureCount = GetCiAndVobcTransBadEnsureCnt();
@@ -6652,6 +6675,10 @@ static void HLHTVOBCDataProc(VobcToCiDataStruct* vobcToCiDataStru)
 		/*处理VOBC点连式信息数据*/
 		VobcBlocLinkDataProc(vobcToCiDataStru);
 	}
+	else
+	{
+		/*不处理*/
+	}
 }
 /*
 * 功能描述： 处理VOBC停稳信息数据
@@ -7247,7 +7274,7 @@ static UINT8 RouteReturnToThroughCmdProc(const UINT16 signalId,const UINT8 fromC
 					pstLgcResInfo = GetLogSecTrainInfo(wLastLgcSecId);
 					if (NULL != pstLgcResInfo)
 					{
-						(void)ComMemCopy(pstLgcResInfo, stTmpResInfo, (UINT16)(sizeof(LogicTrainResStruct)*LOGIC_SECTION_RES_SUM_MAX));
+						(void)CommonMemCpy(pstLgcResInfo, (UINT32)(sizeof(LogicTrainResStruct)*LOGIC_SECTION_RES_SUM_MAX), stTmpResInfo, (UINT32)(sizeof(LogicTrainResStruct)*LOGIC_SECTION_RES_SUM_MAX));					
 					}
 					SetLogSecLockState(wLastLgcSecId, LOG_SECTION_LOCK_NO, returnRouteId, saveReRouteDir);
 
@@ -8379,7 +8406,8 @@ static void HLHTFAOVOBCDataProc(VobcToCiDataStruct* vobcToCiDataStru)
 					&& (WASHMACHINE_HEAD_STEADY_NO == vobcToCiDataStru->headWashStopSteadyInfo)
 					&& (WASHMACHINE_TAIL_STEADY_NO == vobcToCiDataStru->tailWashStopSteadyInfo)
 					&& (PASS_WASHMACHINE_REQUEST_INVALID == vobcToCiDataStru->passWashMachineRequest)
-					&& (PAUSE_TRAIN_WASH_REQUEST_INVALID == vobcToCiDataStru->washPauseRequest))
+					&& (PAUSE_TRAIN_WASH_REQUEST_INVALID == vobcToCiDataStru->washPauseRequest)
+					&& (WASHMACHINE_COUPING_STEADY_NO == vobcToCiDataStru->couplingWashStopSteadyInfo))
 				{/*所有洗车命令均无效认为无洗车请求或洗车作业完毕*/
 					SetWashMachineCurVobcID(washMachineId, 0u);/*清除当前洗车的VOBC ID*/
 					/*清除洗车机的相关驱动状态*/
@@ -8389,6 +8417,7 @@ static void HLHTFAOVOBCDataProc(VobcToCiDataStruct* vobcToCiDataStru)
 					SetPauseTrainWashRequestDrvSta(washMachineId, WASHMACHINE_PAUSE_DRVREQ_FALSE);
 					SetPassWashMachineReqtDrvSta(washMachineId, PASS_WASHMACHINE_DRVREQ_FALSE);
 					SetWashMachineWorkModeDrvState(washMachineId, WASHMACHINE_WORKMODE_INVALID_DRV);
+					SetCoupingStopSteadyDrvState(washMachineId, WASHMACHINE_COUPING_STEADY_NO);
 				}
 				else
 				{
@@ -8434,6 +8463,21 @@ static void HLHTFAOVOBCDataProc(VobcToCiDataStruct* vobcToCiDataStru)
 						}
 					}
 
+					if (WASHMACHINE_COUPING_STEADY_YES == vobcToCiDataStru->couplingWashStopSteadyInfo)
+					{/*联挂端停稳请求有效*/
+						if (1U == washMachineCurSum)
+						{
+							SetCoupingStopSteadyDrvState(washMachineId, WASHMACHINE_COUPING_STEADY_YES);
+						}
+					}
+					else
+					{
+						if (1U == washMachineCurSum)
+						{
+							SetCoupingStopSteadyDrvState(washMachineId, WASHMACHINE_COUPING_STEADY_NO);
+						}
+					}
+
 					if (WASHMACHINE_TAIL_STEADY_YES == vobcToCiDataStru->tailWashStopSteadyInfo)
 					{/*尾端停稳请求有效*/
 						if (1U == washMachineCurSum)
@@ -8493,6 +8537,7 @@ static void HLHTFAOVOBCDataProc(VobcToCiDataStruct* vobcToCiDataStru)
 						SetPauseTrainWashRequestDrvSta(washMachineId, WASHMACHINE_PAUSE_DRVREQ_FALSE);
 						SetPassWashMachineReqtDrvSta(washMachineId, PASS_WASHMACHINE_DRVREQ_FALSE);
 						SetWashMachineWorkModeDrvState(washMachineId, WASHMACHINE_WORKMODE_INVALID_DRV);
+						SetCoupingStopSteadyDrvState(washMachineId, WASHMACHINE_COUPING_STEADY_NO);
 					}
 				}
 			}
@@ -10004,17 +10049,7 @@ static void SetIvocWashDriveState(VobcToCiDataStruct* vobcToCiDataStru,const UIN
 			{
 				SetTrainTailStopSteadyDrvState(washMachineId, WASHMACHINE_TAIL_STEADY_NO);
 			}
-
+			
-			if (WASHMACHINE_COUPING_STEADY_YES == vobcToCiDataStru->couplingWashStopSteadyInfo)
-			{
-				/*尾端停稳请求有效*/
-				SetCoupingStopSteadyDrvState(washMachineId, WASHMACHINE_TAIL_STEADY_YES);
-			}
-			else
-			{
-				SetCoupingStopSteadyDrvState(washMachineId, WASHMACHINE_TAIL_STEADY_NO);
-			}
-
 			if (WASHMACHINE_PAUSE_DRVREQ_TRUE == vobcToCiDataStru->washPauseRequest)
 			{
 				/*暂停洗车请求有效*/
@@ -11036,7 +11071,7 @@ void RouteSecLockApplyCmdProc(const UINT16 wCurRLockRouteId, const UINT16 wPreRL
 							pstLgcResInfo = GetLogSecTrainInfo(pLogIdBuff[ii]);
 							if (NULL != pstLgcResInfo)
 							{
-								(void)ComMemCopy(pstLgcResInfo, stTmpResInfo, (UINT16)(sizeof(LogicTrainResStruct) * LOGIC_SECTION_RES_SUM_MAX));
+								(void)CommonMemCpy(pstLgcResInfo, (UINT32)((sizeof(LogicTrainResStruct)) * LOGIC_SECTION_RES_SUM_MAX),stTmpResInfo, (UINT32)((sizeof(LogicTrainResStruct)) * LOGIC_SECTION_RES_SUM_MAX));
 								SetLogSecLockState(pLogIdBuff[ii], LOG_SECTION_LOCK_NO, validRouteId, 0U);/*设置区段锁闭所属之前进路未锁闭*/
 								/*设置区段属于当前进路锁闭*/
 								SetLogSecLockState(pLogIdBuff[ii], LOG_SECTION_LOCK_NORMAL, wCurRLockRouteId, chRouteDir);
@@ -11116,7 +11151,7 @@ void LogRouteCleanOldLogSecLockProc(const UINT16 wPreRouteId)
 					pstLgcResInfo = GetLogSecTrainInfo(pLogSecIdBuff[ii]);
 					if (NULL != pstLgcResInfo)
 					{
-						(void)ComMemCopy(pstLgcResInfo, stTmpResInfo, (UINT16)(sizeof(LogicTrainResStruct) * LOGIC_SECTION_RES_SUM_MAX));
+						(void)CommonMemCpy(pstLgcResInfo, (UINT32)(sizeof(LogicTrainResStruct) * LOGIC_SECTION_RES_SUM_MAX), stTmpResInfo, (UINT32)(sizeof(LogicTrainResStruct) * LOGIC_SECTION_RES_SUM_MAX));
 						SetLogSecLockState(pLogSecIdBuff[ii], LOG_SECTION_LOCK_NO, wValidRouteId, 0U);  /*设置区段锁闭所属之前进路未锁闭*/
 
 						CpyLgcSecResTrain(pLogSecIdBuff[ii], cResTrainSum, stTmpResInfo);  /*拷贝逻辑区段列车资源信息*/
@@ -11781,17 +11816,23 @@ void OverlapUnlockApplyDeal(void)
 					}
 					else
 					{
-						; /*最接近的车获取失败，不向IVOC申请保护区段解锁*/
+						/*最接近的车获取失败，不向IVOC申请保护区段解锁*/
+						SetOverlapUnlockApplyTrainId(wOverlapId, 0U);
+						SetReqIvocUnlockStartCycNum(wOverlapId, 0U);
 					}
 				}
 				else
 				{
-					; /*保护区段无锁闭所属进路不处理向IVOC申请保护区段解锁*/
+					/*保护区段无锁闭所属进路不处理向IVOC申请保护区段解锁*/
+					SetOverlapUnlockApplyTrainId(wOverlapId, 0U);
+					SetReqIvocUnlockStartCycNum(wOverlapId, 0U);
 				}
 			}
 			else
 			{
-				; /*未申请保护区段解锁，RC不向IVOC申请保护区段解锁*/
+				 /*未申请保护区段解锁，RC不向IVOC申请保护区段解锁*/
+				SetOverlapUnlockApplyTrainId(wOverlapId, 0U);
+				SetReqIvocUnlockStartCycNum(wOverlapId, 0U);
 			}
 		}
 		else
@@ -12498,7 +12539,8 @@ void SignalTrainCrossPro(void)
 				}
 				else
 				{
-					/*非TACS主控，不记录列车ID*/
+					/*非TACS主控，不设置跨压和列车ID*/
+					cSignalCrossState = SIGNAL_CROSS_STATE_NO;
 				}
 			}
 			else

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

@@ -160,7 +160,7 @@ void OutputDataProcess(void)
 	(void)PsdDeviceToRelayStateProc();
 
 	/*更新洗车机继电器状态*/
-	(void)WashMachineDevToRelayStaProc();
+	WashMachineDevToRelayStaProc();
 
 	/*更新计轴复位继电器状态*/
 	/*虚拟联锁兼容*/
@@ -3549,7 +3549,7 @@ void NonRouteRelayStateProc(void)
 	UINT8 interfaceType = FUNC_SWITCH_UNDEF;/*试车线与车辆段接口类型*/
 	UINT8 i = 0u;
 	UINT16 agreeTryTrainRelayId = 0u;/*同意试车继电器ID*/
-	UINT16 wColWaysideTryTrainIndRelayId = 0u;/*轨旁试车指示器继电器ID*/
+	UINT16 wColWaysideTryTrainIndRelayId = 0U;/*轨旁试车指示器继电器ID*/
 	NonRouteDataStruct* pNonRoute = NULL;
 	UINT8 localCiId = 0U; /*本联锁ID*/
 	UINT8 nonRouteBelongCiId = 0U; /*非进路所属联锁ID*/
@@ -3591,7 +3591,7 @@ void NonRouteRelayStateProc(void)
 							/*不处理*/
 						}
 						wColWaysideTryTrainIndRelayId = GetWaysideTryTrainIndRelayId(pNonRoute->NonRouteId);
-						if (0 != wColWaysideTryTrainIndRelayId)
+						if (0U != wColWaysideTryTrainIndRelayId)
 						{
 							/*设置轨旁试车指示器继电器吸起*/
 							(void)SetRelayDriveState(wColWaysideTryTrainIndRelayId, RELAY_DRIVE_STATE_UP); 
@@ -3621,7 +3621,7 @@ void NonRouteRelayStateProc(void)
 							; /*不处理*/
 						}
 						wColWaysideTryTrainIndRelayId = GetWaysideTryTrainIndRelayId(pNonRoute->NonRouteId);
-						if (0 != wColWaysideTryTrainIndRelayId)
+						if (0U != wColWaysideTryTrainIndRelayId)
 						{
 							/*设置轨旁试车指示器继电器落下*/
 							(void)SetRelayDriveState(wColWaysideTryTrainIndRelayId, RELAY_DRIVE_STATE_DOWN); 
@@ -4965,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) ;
 	}	
@@ -4979,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) ;
 
@@ -8254,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;  /*非进路状态*/

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

@@ -1068,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;
@@ -1126,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;
+				ResetResInfoStruct(logicSectionId, mm);
-				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;
 			}
 			LogicSectionDataStruCC[logicSectionId].chLogSecLockBelLogRouteSum = 0U;
 			for (jj = 0U; jj < LOGSEC_RELATE_ROUTE_SUM_MAX; jj++)

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;
@@ -702,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)
 				{
@@ -1519,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;
@@ -2445,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;/* 延时小前方向 */
 			}
 
 
@@ -2913,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/InterlockLogicManage.c

@@ -3386,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();
@@ -3401,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)
 			{
 				/*属于本联锁保护区段*/
 
@@ -3428,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())
+				else if (((dwCurCycNum - dwPhySecDelayLockStartCyc) > dwBadEnsureCount)
-					&& (PROTECTSECLOCKDELAY_YES == GetProtectSecLockDelayTimeFlag(devId)))
+					&& (PROTECTSECLOCKDELAY_YES == cProSecDelayLockFlag))
 				{  /*标志设置超时则清除标志*/
 					SetProtectSecLockDelayTimeFlag(devId, PROTECTSECLOCKDELAY_NO);
 					SetPhySecLockDelayStartCycNum(devId, 0);  /*清物理区段延时锁闭周期号*/
@@ -4138,105 +4154,109 @@ UINT8 KeepOpenRouteSignalProc(const UINT16 routeId)
 */
 void RouteZongQuXiaoProc(const UINT16 routeId)
 {
-	UINT8 routeState = 0u;         /*进路状态*/
+	UINT8 routeState = 0U;         /*进路状态*/
-	UINT16 startSignalId = 0u;
+	UINT16 startSignalId = 0U;
 	UINT8 sigCurColor = SIGNAL_SHOWCOLOUR_INVALID;
-	UINT8 routeDelayUnlockflag = 0u; /* 进路延时解锁属性*/
+	UINT8 routeDelayUnlockflag = 0U; /* 进路延时解锁属性*/
-	UINT8 checkRouteCancel = 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);
+		cSignalInHumidRailFlag = GetSignalInHumidRailFlag(startSignalId);
-	if (PHYSEC_IN_HUMID_RAIL_NO == cSignalInHumidRailFlag)
+		chRouteVirCiId = GetRouteBelongVirCiId(routeId);  /*获取进路虚拟联锁ID*/
-	{
+		chCiType = GetLocalVirCiType(chRouteVirCiId);     /*获取联锁类型*/
-		/*总取消进路处理*/
+		/*信号机湿轨标志无效或者进路属于车辆段，则执行总取消*/
-		if ((ROUTE_STATE_XUANPAI == routeState) || (ROUTE_STATE_FIRST_XUANPAI == routeState))
+		if ((PHYSEC_IN_HUMID_RAIL_NO == cSignalInHumidRailFlag) || (CI_TYPE_CLD == chCiType))
 		{
-			/*进路选排或初选*/
+			/*总取消进路处理*/
-
+			if ((ROUTE_STATE_XUANPAI == routeState) || (ROUTE_STATE_FIRST_XUANPAI == routeState))
-			/*取消进路选排*/
-			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_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);
+					if (ROUTE_NEED_DELAY_UNLOCK == routeDelayUnlockflag)
-					/*设置延时解锁*/
+					{
-					SetRouteZongQuXiaoDelayFlag(routeId, ROUTE_ZQX_DELAY_YES);
+						/*设置进路延时解锁状态*/
+						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");
-	}
 }
 
 /*
@@ -4693,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);
-					/*停止发解锁申请*/
+				/*停止倒计时*/
-					SetOverlapUnlockApplyFlag(unlockOverlapId, UNLOCK_OVERLAP_APPLY_NO);
+				SetSecUtOrCtOccuStartCycNum(devId, 0u);
-					/*停止倒计时*/
-					SetSecUtOrCtOccuStartCycNum(devId, 0u);
-				}
 			}
 			else
 			{
@@ -4736,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
 			{
@@ -4759,7 +4779,7 @@ UINT8 UnlockRouteOverlapProc(const UINT16 routeId)
 		}
 		else
 		{
-			/*什么也不做*/
+			; /*什么也不做*/
 		}
 	}
 	return CI_ERROR;
@@ -9477,27 +9497,10 @@ void CiTrainTestLogicManage(void)
 	UINT16 wCollAgreeTryTrainRelayId = 0U;/*试车线采集同意试车继电器ID*/
 	UINT8 chRelayCollState = 0U;/*采集继电器状态*/
 	UINT8 ii = 0U;
-	UINT8 flag = 0U;
+	UINT8 flag = CI_ERROR;;
-	UINT8 chCldAndScxMergeFlag = GetCldAndScxMergeFlag();
+	
-	UINT8 localCiType = GetLocalCiType();
+	flag = GetLocalCiIsScx();
-
+	if (CI_SUCCESS == flag)
-	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)
 	{
 		for (; ii < NONROUTE_ID_NUM_MAX; ii++)
 		{
@@ -11584,7 +11587,7 @@ void AxisSecJumpLockLogicManage(void)
 					{/*未征用*/
 						/*设置征用*/
 						SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_YES, 0);
-						SetJumpPhySectionPortectSecUse(phyId, PHYSICAL_SECTION_USING_YES);/*设置物理区段关联防护道岔的区段征用*/
+						SetJumpPhySectionPortectSecUse(axisSectionId, PHYSICAL_SECTION_USING_YES);/*设置物理区段关联防护道岔的区段征用*/
 						/*转为选排*/
 						SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_XUANPAI);
 					}
@@ -11601,38 +11604,7 @@ void AxisSecJumpLockLogicManage(void)
 
 			case AXIS_SECTION_JUMPLOCK_STATE_LOCK:
 			{/*计轴区段跳跃锁闭处理*/
-				/*持续进行锁闭检查，检查通过，设置物理区段跳跃锁闭；检查不通过，设置未跳跃锁闭*/
+				AxisJumpLockStateManage(axisSectionId);
-				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);
-						SetAxisRelProSwitchLockSta(axisSectionId, SWITCH_LOCK_PROTECT_SET);
-						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);
-					SetAxisRelProSwitchLockSta(axisSectionId, SWITCH_LOCK_PROTECT_CANCEL);
-				}
 			}
 			break;
 			default:
@@ -11670,6 +11642,12 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	{
 		rtVal = CI_SUCCESS;
 	}
+
+	if (CI_SUCCESS == rtVal)
+	{
+		rtVal = JumpPhySecAllUseCheck(axisSecId);/*所有区段已设置上征用（不考虑相邻联锁，若防护道岔在相邻联锁则不跳跃锁闭）*/
+	}
+
 	if (CI_SUCCESS == rtVal)
 	{
 		rtVal = LockAxisSecProc(axisSecId);/*跳跃锁闭联锁条件检查*/
@@ -11677,11 +11655,9 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	axisSecSwitDrvOvtmFlag = ChekJumpLockSwitDrivOvtmStat(axisSecId);/*检查计轴区段关联道岔是否驱动超时*/
 	if (CI_SUCCESS == rtVal)
 	{/*检查成功*/
-		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_LOCK);
-		/*设置未征用*/
-		SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
 
-		SetJumpPhySectionPortectSecUse(phyId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_LOCK);/*状态机流程转*/
+
 	}
 	else if ((RETURN_LOCK_ERR_SWITPOS == rtVal) && (CI_SUCCESS == axisSecSwitDrvOvtmFlag))
 	{/*位置错误可驱动且驱动道岔没有超时*/
@@ -11692,7 +11668,7 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 		{
 			/*设置未征用*/
 			SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
-			SetJumpPhySectionPortectSecUse(phyId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+			SetJumpPhySectionPortectSecUse(axisSecId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
 
 			/*设置计轴区段跳跃状态空闲*/
 			SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
@@ -11702,7 +11678,7 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	{/*其它*/
 		/*设置未征用*/
 		SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
-		SetJumpPhySectionPortectSecUse(phyId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+		SetJumpPhySectionPortectSecUse(axisSecId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
 
 		/*设置计轴区段跳跃状态空闲*/
 		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
@@ -14497,10 +14473,23 @@ void PhySecJumpLockLogicManage(void)
 					chPhySecFLockType = GetPhySecFLockType(wPhyId); /*获取物理区段封锁类型*/
 					if ((PHY_SEC_FLOCK_TYPE_NONE == chPhySecFLockType))
 					{
+						ClearAxisSeceSwitchDanCaoPos(wAxisSectionId);/*清除单操*/
 						SetPhySecJumpLockState(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
 						SetAxisRelProSwitchLockSta(wAxisSectionId, SWITCH_LOCK_PROTECT_SET);
-			/*			SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);当周期先不给ZC发锁闭*/
+
-						SetAxisInCludeLogJumpLockState(wAxisSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+						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
 					{
@@ -14529,6 +14518,10 @@ void PhySecJumpLockLogicManage(void)
 					{
 						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
 					}
+					else
+					{
+						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+					}
 				}
 			}
 		}
@@ -16850,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

@@ -3702,6 +3702,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
 		else
 		{
 			/* zt 删除单轨相关代码 2022-02-15 */
+			reResult = CI_ERROR;
 		}
 
 		/*保护区段 内所有道岔【未封锁】*/

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

@@ -6538,103 +6538,134 @@ UINT16 GetRouteBingZhiSignalId(const UINT16 routeId)
 */
 UINT16 GetRouteChaZhiSignalId(const UINT16 routeId)
 {
-	UINT16 startSigId = 0u; /*始端信号机ID*/
+	UINT16 startSigId = 0U; /*始端信号机ID*/
-	UINT16 signalSum = 0u; /*信号机总数*/
+	UINT16 signalSum = 0U; /*信号机总数*/
-	UINT16 signalId = 0u; /*信号机ID*/
+	UINT16 signalId = 0U; /*信号机ID*/
-	UINT16 routeSecSum = 0u; /*进路区段总数*/
+	UINT16 routeSecSum = 0U; /*进路区段总数*/
-	RoutePhysicalSectionStruct *pRoutePhySecStru = NULL; /*进路区段数据*/
+	RoutePhysicalSectionStruct* pRoutePhySecStru = NULL; /*进路区段数据*/
-	UINT16 returnOutSecId = 0u; /*折返信号机外方区段ID*/
+	UINT16 returnOutSecId = 0U; /*折返信号机外方区段ID*/
-	UINT16 returnInSecId = 0u; /*折返信号机内方区段ID*/
+	UINT16 returnInSecId = 0U; /*折返信号机内方区段ID*/
-    UINT16 lockBelongRouteId = 0u; /*锁闭所属进路ID*/
+    UINT16 lockBelongRouteId = 0U; /*锁闭所属进路ID*/
-    UINT16 outSecId = 0u; /*外方区段ID*/
+    UINT16 outSecId = 0U; /*外方区段ID*/
-	UINT16 ii = 0u;
+	UINT16 ii = 0U;
-	UINT16 tmpSigId = 0u;
+	UINT16 tmpSigId = 0U;
-
+	UINT8 chPhySecType = 0U;
+	UINT16 wTempPhySecId = 0U;
+	UINT16 wReturnSignal = 0U;
+	UINT16 wTempSigId = 0U;
+	UINT8 chPhyLockState = 0U;
+	UINT16 wLockRouteId = 0U;
+	UINT16 wTempSigOutPhyId = 0U;
+	UINT16 wTempSigInPhyId = 0U;
 
     startSigId = GetRouteStartSignalId(routeId); /*获取进路始端信号机ID*/
 	signalSum = GetSignalCurSum(); /*获取信号机总数*/
 
-	if (PHYSICAL_SEC_TYPE_NOSWITCH == GetPhySecType(GetSignalOutFirstPhySecId(startSigId)))
+	outSecId = GetSignalOutFirstPhySecId(startSigId);
+	chPhySecType = GetPhySecType(outSecId);
+	if (PHYSICAL_SEC_TYPE_NOSWITCH == chPhySecType)
 	{ /*无岔区段*/
 
 		for (ii = 0u; ii < signalSum; ii++)
 		{
 			signalId = GetSignalId(ii); /*获取信号机ID*/
+			wTempPhySecId = GetSignalOutFirstPhySecId(signalId);
 
-			if ((GetSignalOutFirstPhySecId(startSigId) == GetSignalOutFirstPhySecId(signalId)) &&
+			if ((outSecId == wTempPhySecId) && (startSigId != signalId))
-				(startSigId != signalId))
 			{
-				return signalId;
+				wReturnSignal =  signalId;
+				break;
+			}
+			else
+			{
+				/*不处理*/
 			}
 		}
 	}
 	else
 	{ /*有岔*/
 
-		outSecId = GetSignalOutFirstPhySecId(startSigId); /*进路始端信号机外方区段ID*/
 		lockBelongRouteId = GetPhySecRLockBelongRouteId(outSecId); /*区段锁闭所属进路ID*/
 		
 		routeSecSum = GetRoutePhysicalSectionSum(lockBelongRouteId); /*获取进路区段总数*/
 		pRoutePhySecStru = GetRouteSectionData(lockBelongRouteId); /*获取进路区段数据*/
 		
-		if ((0u == routeSecSum) || (NULL == pRoutePhySecStru))
+		if ((0U == routeSecSum) || (NULL == pRoutePhySecStru))
 		{
-			return 0u;
+			/*不处理*/
-		}
-		if (routeSecSum == 1u)
-		{
-			/*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 (1U == routeSecSum)
-		}
-		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)))
 			{
-				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.c

@@ -9256,18 +9256,35 @@ UINT8 KeepRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 
 	if (CI_SUCCESS == reResult)
 	{/*进路保持开放防护道岔检查*/
-		if(CI_TRADITION_RAILWAY == lineIdentity)
+		if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
 		{
-			if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
+			/*支持二级侧防时，不检查防护道岔位置和可动性*/
+		}
+		else
+		{
+			/*进路关联防护道岔位置正确*/
+			devId = 0u;
+			devState = 0u;
+			checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+			if (checkResult == CI_SUCCESS)
 			{
-				/*支持二级侧防时，不检查防护道岔位置和可动性*/
+				/* 通过检查 */
+				reResult = CI_SUCCESS;
 			}
 			else
 			{
-				/*进路关联防护道岔位置正确*/
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+				/* 失败返回 */
+				reResult = CI_ERROR;
+			}
+
+			if (CI_SUCCESS == reResult)
+			{
+				/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
 				devId = 0u;
 				devState = 0u;
-				checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+				checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
 				if (checkResult == CI_SUCCESS)
 				{
 					/* 通过检查 */
@@ -9276,40 +9293,15 @@ UINT8 KeepRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 				else
 				{
 					/* 记录故障码 */
-					SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+					SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
 					/* 失败返回 */
 					reResult = CI_ERROR;
 				}
-
-				if (CI_SUCCESS == reResult)
-				{
-					/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
-					devId = 0u;
-					devState = 0u;
-					checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
-					if (checkResult == CI_SUCCESS)
-					{
-						/* 通过检查 */
-						reResult = CI_SUCCESS;
-					}
-					else
-					{
-						/* 记录故障码 */
-						SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
-						/* 失败返回 */
-						reResult = CI_ERROR;
-					}
-				}
-				else
-				{
-					reResult = CI_ERROR;
-				}
 			}
-		}
+			else
-		else
+			{
-		{
+				reResult = CI_ERROR;
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			}
-			reResult = CI_ERROR;
 		}
 	}
 	else
@@ -9466,12 +9458,29 @@ UINT8 KeepLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel
 
 	if (CI_SUCCESS == reResult)
 	{/*进路保持开放防护道岔检查*/
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+	 /*进路关联防护道岔位置正确*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
 		{
-			/*进路关联防护道岔位置正确*/
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+
+		if (CI_SUCCESS == reResult)
+		{
+			/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
 			devId = 0U;
 			devState = 0U;
-			checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+			checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
 			if (checkResult == CI_SUCCESS)
 			{
 				/* 通过检查 */
@@ -9480,38 +9489,13 @@ UINT8 KeepLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel
 			else
 			{
 				/* 记录故障码 */
-				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
 				/* 失败返回 */
 				reResult = CI_ERROR;
 			}
-
-			if (CI_SUCCESS == reResult)
-			{
-				/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
-				devId = 0U;
-				devState = 0U;
-				checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
-				if (checkResult == CI_SUCCESS)
-				{
-					/* 通过检查 */
-					reResult = CI_SUCCESS;
-				}
-				else
-				{
-					/* 记录故障码 */
-					SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
-					/* 失败返回 */
-					reResult = CI_ERROR;
-				}
-			}
-			else
-			{
-				reResult = CI_ERROR;
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
 			reResult = CI_ERROR;
 		}
 	}
@@ -9843,60 +9827,44 @@ UINT8 LockBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 
 	if (CI_SUCCESS == reResult)
 	{
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+		/*进路内所有道岔位置正确或位置不正确但可动作*/
+		devId = 0u;
+		devState = 0u;
+
+		checkResult = RouteSwitchPosAndMoveValidCheck(routeId, sendLevel);
+
+		if (CI_SUCCESS == checkResult)
 		{
-			/*进路内所有道岔位置正确或位置不正确但可动作*/
+			/* 通过检查 */
-			devId = 0u;
+			reResult = CI_SUCCESS;
-			devState = 0u;
-
-			checkResult = RouteSwitchPosAndMoveValidCheck(routeId, sendLevel);
-
-			if (CI_SUCCESS == checkResult)
-			{
-				/* 通过检查 */
-				reResult = CI_SUCCESS;
-			}
-			else
-			{
-				/* 失败返回 */
-				reResult = checkResult;
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/* 失败返回 */
-			reResult = CI_ERROR;
+			reResult = checkResult;
 		}
 	}
 
 	if (CI_SUCCESS == reResult)
 	{
-		if(CI_TRADITION_RAILWAY == lineIdentity)
+		/*
+		进路内所有道岔位置正确
+		不正确：RETURN_LOCK_ERR_SWITPOS
+		正确：CI_SUCCESS
+		*/
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAllSwitchPosCheck(routeId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
 		{
-			/* 
+			/* 通过检查 */
-			进路内所有道岔位置正确
+			reResult = CI_SUCCESS;
-				不正确：RETURN_LOCK_ERR_SWITPOS
-				正确：CI_SUCCESS
-			*/
-			devId = 0u;
-			devState = 0u;
-			checkResult = RouteAllSwitchPosCheck(routeId,&devId, &devState);
-			if (checkResult == CI_SUCCESS)
-			{
-				/* 通过检查 */
-				reResult = CI_SUCCESS;
-			}
-			else
-			{
-				/* 失败返回 */
-				reResult = RETURN_LOCK_ERR_SWITPOS;
-				
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/* 失败返回 */
-			reResult = CI_ERROR;
+			reResult = RETURN_LOCK_ERR_SWITPOS;
+
 		}
 	}
 	else
@@ -10196,60 +10164,44 @@ UINT8 LockLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel
 
 	if (CI_SUCCESS == reResult)
 	{
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+		/*进路内所有道岔位置正确或位置不正确但可动作*/
+		devId = 0U;
+		devState = 0U;
+
+		checkResult = RouteSwitchPosAndMoveValidCheck(routeId, sendLevel);
+
+		if (CI_SUCCESS == checkResult)
 		{
-			/*进路内所有道岔位置正确或位置不正确但可动作*/
+			/* 通过检查 */
-			devId = 0U;
+			reResult = CI_SUCCESS;
-			devState = 0U;
-
-			checkResult = RouteSwitchPosAndMoveValidCheck(routeId, sendLevel);
-
-			if (CI_SUCCESS == checkResult)
-			{
-				/* 通过检查 */
-				reResult = CI_SUCCESS;
-			}
-			else
-			{
-				/* 失败返回 */
-				reResult = checkResult;
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/* 失败返回 */
-			reResult = CI_ERROR;
+			reResult = checkResult;
 		}
 	}
 
 	if (CI_SUCCESS == reResult)
 	{
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+		/*
+		进路内所有道岔位置正确
+		不正确：RETURN_LOCK_ERR_SWITPOS
+		正确：CI_SUCCESS
+		*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteAllSwitchPosCheck(routeId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
 		{
-			/*
+			/* 通过检查 */
-			进路内所有道岔位置正确
+			reResult = CI_SUCCESS;
-				不正确：RETURN_LOCK_ERR_SWITPOS
-				正确：CI_SUCCESS
-			*/
-			devId = 0U;
-			devState = 0U;
-			checkResult = RouteAllSwitchPosCheck(routeId, &devId, &devState);
-			if (checkResult == CI_SUCCESS)
-			{
-				/* 通过检查 */
-				reResult = CI_SUCCESS;
-			}
-			else
-			{
-				/* 失败返回 */
-				reResult = RETURN_LOCK_ERR_SWITPOS;
-
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/* 失败返回 */
-			reResult = CI_ERROR;
+			reResult = RETURN_LOCK_ERR_SWITPOS;
+
 		}
 	}
 	else
@@ -12752,39 +12704,37 @@ UINT8 OpenBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 		}
 	}
 
-	if(CI_SUCCESS == reResult)
+	if (CI_SUCCESS == reResult)
-	{
+	{/*进路开放防护道岔检查*/
-		if(CI_TRADITION_RAILWAY == lineIdentity)
+		if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
 		{
-			/* 通过检查 */
+			/*支持二级侧防时，不检查防护道岔位置和可动性*/
-			reResult = CI_SUCCESS;
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/*进路关联防护道岔位置正确*/
-			reResult = CI_ERROR;
+			devId = 0u;
-		}
+			devState = 0u;
-	}
+			checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
-	else
+			if (checkResult == CI_SUCCESS)
-	{
-		/* 失败返回 */
-		reResult = CI_ERROR;
-	}
-
-	if (CI_SUCCESS == reResult)
-	{/*进路开放防护道岔检查*/
-		if(CI_TRADITION_RAILWAY == lineIdentity)
-		{
-			if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
 			{
-				/*支持二级侧防时，不检查防护道岔位置和可动性*/
+				/* 通过检查 */
+				reResult = CI_SUCCESS;
 			}
 			else
 			{
-				/*进路关联防护道岔位置正确*/
+				/* 记录故障码 */
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+				/* 失败返回 */
+				reResult = CI_ERROR;
+			}
+
+			if (CI_SUCCESS == reResult)
+			{
+				/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
 				devId = 0u;
 				devState = 0u;
-				checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+				checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
 				if (checkResult == CI_SUCCESS)
 				{
 					/* 通过检查 */
@@ -12793,40 +12743,15 @@ UINT8 OpenBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 				else
 				{
 					/* 记录故障码 */
-					SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+					SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
 					/* 失败返回 */
 					reResult = CI_ERROR;
 				}
-
-				if (CI_SUCCESS == reResult)
-				{
-					/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
-					devId = 0u;
-					devState = 0u;
-					checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
-					if (checkResult == CI_SUCCESS)
-					{
-						/* 通过检查 */
-						reResult = CI_SUCCESS;
-					}
-					else
-					{
-						/* 记录故障码 */
-						SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
-						/* 失败返回 */
-						reResult = CI_ERROR;
-					}
-				}
-				else
-				{
-					reResult = CI_ERROR;
-				}
 			}
-		}
+			else
-		else
+			{
-		{
+				reResult = CI_ERROR;
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			}
-			reResult = CI_ERROR;
 		}
 	}
 	else
@@ -12957,31 +12882,29 @@ UINT8 OpenLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel
 
 	if (CI_SUCCESS == reResult)
 	{
-		if (CI_TRADITION_RAILWAY == lineIdentity)
+	 /*进路关联防护道岔位置正确*/
+		devId = 0U;
+		devState = 0U;
+		checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+		if (checkResult == CI_SUCCESS)
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+			/* 失败返回 */
 			reResult = CI_ERROR;
 		}
-	}
-	else
-	{
-		/* 失败返回 */
-		reResult = CI_ERROR;
-	}
 
-	if (CI_SUCCESS == reResult)
+		if (CI_SUCCESS == reResult)
-	{/*进路开放防护道岔检查*/
-		if (CI_TRADITION_RAILWAY == lineIdentity)
 		{
-			/*进路关联防护道岔位置正确*/
+			/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
 			devId = 0U;
 			devState = 0U;
-			checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
+			checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
 			if (checkResult == CI_SUCCESS)
 			{
 				/* 通过检查 */
@@ -12990,38 +12913,13 @@ UINT8 OpenLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel
 			else
 			{
 				/* 记录故障码 */
-				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
+				SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
 				/* 失败返回 */
 				reResult = CI_ERROR;
 			}
-
-			if (CI_SUCCESS == reResult)
-			{
-				/*进路关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
-				devId = 0U;
-				devState = 0U;
-				checkResult = RouteRelatedProSwitchLockCheck(routeId, &devId, &devState);
-				if (checkResult == CI_SUCCESS)
-				{
-					/* 通过检查 */
-					reResult = CI_SUCCESS;
-				}
-				else
-				{
-					/* 记录故障码 */
-					SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_LOCK_STATUS, devState, sendLevel);
-					/* 失败返回 */
-					reResult = CI_ERROR;
-				}
-			}
-			else
-			{
-				reResult = CI_ERROR;
-			}
 		}
 		else
 		{
-			/* 失败返回 *//* zt 删除单轨相关代码 2022-02-15 */
 			reResult = CI_ERROR;
 		}
 	}
@@ -13183,7 +13081,7 @@ UINT8 OpenBlocRouteOverlapCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 		else
 		{
 			/* zt 删除单轨相关代码 2022-02-15 */
-			/*其他线路情况不处理*/
+			reResult = CI_ERROR;
 		}
 
 #if 0     /*进路办理完成并开灯，此时办理引导总锁，进路应保持原来状态不变*/
@@ -15655,7 +15553,7 @@ UINT8 JumpLockSwitchCheck(const UINT16 axisSecId,UINT8 funcId,UINT8 sendLevel)
 		if (CI_ERROR == reVal)
 		{
 			/* 记录故障码 */
-			SetErrorData(funcId,CI_DEVICE_TYPE_SWITCH,devId,ETYPE_SWT_FLOCK_STATE,devState,sendLevel); 
+			SetErrorData(funcId,CI_DEVICE_TYPE_SWITCH,devId, ETYPE_SWT_POSTION_STATE,devState,sendLevel);
 		}
 	}
 
@@ -15668,7 +15566,7 @@ UINT8 JumpLockSwitchCheck(const UINT16 axisSecId,UINT8 funcId,UINT8 sendLevel)
 		if (CI_ERROR == reVal)
 		{
 			/* 记录故障码 */
-			SetErrorData(funcId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_FLOCK_STATE, devState, sendLevel);
+			SetErrorData(funcId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_POSTION_STATE, devState, sendLevel);
 		}
 	}
 
@@ -15941,7 +15839,7 @@ UINT8 AxisSecPorteSwitchPosMoveCheck(UINT16 const axisSecId, UINT16* pDevId, UIN
 	/* 计轴区段道岔 */
 
 	/* 局部变量定义初始化 */
-	UINT16 i = 0u;           /* 循环变量 */
+	UINT8 i = 0u;           /* 循环变量 */
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8  switchPos = 0u;
@@ -15982,6 +15880,8 @@ UINT8 AxisSecPorteSwitchPosMoveCheck(UINT16 const axisSecId, UINT16* pDevId, UIN
 				}
 				else
 				{
+					*pDevId = devId;
+					*pDevState = devState;
 					reVal = CI_ERROR;
 				}
 			}
@@ -16044,7 +15944,7 @@ UINT8 AxisSecAllSwitchPosCheck(UINT16 const axisSecId,UINT16 *pDevId,UINT8 *pDev
 	AxisSwitchStruct* const dataIdBuf = GetAxisSwitchIdStru(axisSecId);
 
 	/* 局部变量定义初始化 */
-	UINT16 i = 0u;           /* 循环变量 */
+	UINT8 i = 0u;           /* 循环变量 */
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;    
 	UINT8 reVal = CI_ERROR;
@@ -16098,7 +15998,7 @@ UINT8 AxisSecAllProtSwitchPosCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8
 	AxisSwitchStruct*  dataIdBuf =NULL;
 
 	/* 局部变量定义初始化 */
-	UINT16 i = 0u;           /* 循环变量 */
+	UINT8 i = 0u;           /* 循环变量 */
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8 reVal = CI_ERROR;
@@ -16119,10 +16019,11 @@ UINT8 AxisSecAllProtSwitchPosCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8
 		for (i = 0u; i < checkSum; i++)
 		{
 			devId = dataIdBuf[i].SwitchId;
-			devState = GetSwitchCurPosition(devId);
+			devState = GetSwitchCurPosition(devId);	/*获取道岔当前位置*/
-			if (devState == dataIdBuf[i].SwitchPosition)
+			reVal = checkSwtLastValDrvPosStayorNot(devId, devState);	/*检查道岔上一次驱动是否还在有效期*/
+			if ((devState == dataIdBuf[i].SwitchPosition)&&(CI_SUCCESS == reVal))
 			{
-				/*道岔位置正确*/
+				/*道岔位置正确且无驱动*/
 
 			}
 			else
@@ -17122,7 +17023,6 @@ UINT8 LogicSecRltvPrtctSwFLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *
 	UINT16 wProtectSwSum = 0U;
 	UINT16* pProtectSwIdBuf = NULL;
 	LogsecSwitchStruct *pstLogicSecSwitchBuf = NULL;
-
 	chCheckSum = GetLogicSecSwitchSum(wLgcId);
 	pstLogicSecSwitchBuf = GetLogicSecSwitchIdStru(wLgcId);
 	if ((NULL != pDevId) && (NULL != pDevState) && (NULL != pYLockAlarmFlag) && (NULL != pstLogicSecSwitchBuf)
@@ -17228,7 +17128,7 @@ UINT8 LogicSecRltvPrtctSwPosCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pD
 	UINT8 chCheckSum = 0U;
 	UINT8 chProSwState = 0U;
 	LogsecSwitchStruct *pstLogicSecSwitchBuf = NULL;
-	
+
 	chCheckSum = GetLgcRelateProSwSum(wLgcId);/*获取指定ID逻辑区段关联防护道岔数目*/
 	pstLogicSecSwitchBuf = GetLgcRelateProSwStru(wLgcId);
 	if ((NULL != pDevId)
@@ -17244,12 +17144,17 @@ UINT8 LogicSecRltvPrtctSwPosCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pD
 			chDevId = pstLogicSecSwitchBuf[ii].SwitchId;
 			chDevState = GetSwitchCurPosition(chDevId);/*获取道岔当前位置*/
 			chProSwState = pstLogicSecSwitchBuf[ii].SwitchPosition;
+			chRetVal = checkSwtLastValDrvPosStayorNot(chDevId, chDevState);	/*检查道岔上一次驱动是否还在有效期*/
+			/*当前防护道岔不在逻辑区段包含道岔内*/
 			/*道岔位置一致*/
 			if ((chProSwState == chDevState)
+				&&(CI_SUCCESS == chRetVal)
 				&& ((SWITCH_POSITION_DINGWEI == chProSwState)
 					|| (SWITCH_POSITION_FANWEI == chProSwState)))
 			{
 				/*位置检查通过，继续检查*/
+
+			
 			}
 			else
 			{
@@ -17283,15 +17188,10 @@ UINT8 LogicSecRltvPrtctSwLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *p
 	/* 局部变量定义初始化 */
 	UINT8 chRetVal = CI_ERROR;
 	UINT8 ii = 0U;
-	UINT16 jj = 0U;
-	UINT8 kk = 0U;
 	UINT16 chDevId = 0U;
 	UINT8 chDevState = 0U;
-	UINT16 wLgcRelativeAxleSecId = 0U;
-
 	UINT8 chProtectSwitchSum = 0U;
 	LogsecSwitchStruct *chProtectSwitchIdBuf = NULL;
-
 	chProtectSwitchSum = GetLgcRelateProSwSum(wLgcId);/*获取指定ID逻辑区段关联防护道岔数目*/
 	chProtectSwitchIdBuf = GetLgcRelateProSwStru(wLgcId);
 
@@ -17303,9 +17203,9 @@ UINT8 LogicSecRltvPrtctSwLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *p
 		chRetVal = CI_SUCCESS;
 		for (ii = 0U; ii < chProtectSwitchSum; ii++)
 		{
-			chDevId = chProtectSwitchIdBuf[jj].SwitchId;
+			chDevId = chProtectSwitchIdBuf[ii].SwitchId;
 			chDevState = GetSwitchLockStatus(chDevId);
-
+			/*当前防护道岔不在逻辑区段包含道岔内*/
 			if ((SWITCH_LOCK_STATUS_PROTECT == chDevState) || (SWITCH_LOCK_STATUS_DAP == chDevState))
 			{
 				/*道岔已【防护锁闭】或【单锁且防护锁闭】*/
@@ -17321,7 +17221,7 @@ UINT8 LogicSecRltvPrtctSwLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *p
 			if (CI_SUCCESS != chRetVal)
 			{
 				break;
-			}
+			}	
 		}
 	}
 	else
@@ -18257,6 +18157,7 @@ UINT8 LogicSecResApplicabilityCheck(UINT16 const wLogicSecId)
 		else
 		{
 			/* 记录故障码 */
+			devState = GetRouteState(routeId);
 			SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, devState, sendLevel);
 			/* 失败返回 */
 			reResult = CI_ERROR;
@@ -26514,6 +26415,8 @@ UINT8 OtherCiOvlpRelProSwMovValCheck(const UINT16 wOverlapId)
 						cRetVal = CI_ERROR;  /*道岔位置不正确且道岔不可动作，返回失败*/
 					}
 				}
+
+
 			}
 			else
 			{
@@ -27865,7 +27768,7 @@ UINT8 PhySecLockMaskSideProtectCheck(UINT16 wPhySecId)
 						/*存在侧防条件时，先判断当前物理区段是否位于关键道岔所处物理区段后方*/
 						wSwtPhySecId = GetSwitchPhySectionId(pSideProtectData[i].KeysSwitchID);
 						cKeySwtPhySecIndex = GetPhySecInRoutePosIndex(wRLockBelongRouteId, wSwtPhySecId);
-						if ((ROUTE_PHYSICALSECTION_SUM_MAX > cKeySwtPhySecIndex) && (cKeySwtPhySecIndex < cCurPhySecIndex))
+						if (cKeySwtPhySecIndex < cCurPhySecIndex)
 						{
 							/*入参物理区段位于关键道岔所处物理区段后方，无需检查该条侧防条件*/
 						}
@@ -28266,7 +28169,7 @@ UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId)
 	/* 局部变量定义初始化 */
 	UINT8 reResult = CI_ERROR;          /*返回值*/
 	UINT8 phyUseState = 0u;/*物理区段征用检查*/
-	UINT8 phyId = 0u;
+	UINT16 phyId = 0u;
 
 
 
@@ -28282,11 +28185,15 @@ UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId)
 		/*无处理*/
 	}
 
-	/*检查计轴区段的防护道岔所在区段的征用*/
+	/*检查计轴区段的防护道岔所在区段和道岔征用*/
 	if (CI_SUCCESS == reResult)
 	{
 		reResult = JumpPhySectionPortectUseCheck(axisSecId);
 	}
+	else
+	{
+		/*无处理*/
+	}
 
 
 	/*检查计轴区段的道岔征用*/
@@ -28294,15 +28201,14 @@ UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId)
 	{
 		reResult = JumpPhySectionSwitchUseCheck(axisSecId);
 	}
-
+	else
-	/*检查计轴区段的防护道岔道岔征用*/
-	if (CI_SUCCESS == reResult)
 	{
-		reResult = JumpPhySectionSwitchUseCheck(axisSecId);
+		/*无处理*/
 	}
 
 
 
+
 	return reResult;
 }
 
@@ -28372,7 +28278,7 @@ UINT8 JumpLogicSecPortectUseCheck(const UINT16 wLgcId)
 			phyId = GetSwitchPhySectionId(chDevId);
 			phyUseState = GetPhySecUseState(phyId);
 			if((PHYSICAL_SECTION_USING_NO != phyUseState)||(SWITCH_USING_NO !=cSwitchUsingState))
-			{/**/
+			{/*存区段征用或存在道岔征用*/
 				chRetVal = CI_ERROR;
 				break;
 			}
@@ -28406,7 +28312,7 @@ UINT8 JumpPhySectionSwitchUseCheck(const UINT16 axisSecId)
 
 	/* 局部变量定义初始化 */
 	UINT8 i = 0u;           /* 循环变量 */
-	UINT16 SwitchId = 0u;
+	UINT16 wSwitchId = 0u;
 	UINT8 cSwitchUsingState = 0U;
 
 
@@ -28421,8 +28327,8 @@ UINT8 JumpPhySectionSwitchUseCheck(const UINT16 axisSecId)
 		/*开始检查计轴区段内道岔*/
 		for (i = 0u; i < checkSum; i++)
 		{
-			SwitchId = dataIdBuf[i].SwitchId;
+			wSwitchId = dataIdBuf[i].SwitchId;
-			cSwitchUsingState = GetSwitchUsingState(SwitchId);
+			cSwitchUsingState = GetSwitchUsingState(wSwitchId);
 			if (SWITCH_USING_NO != cSwitchUsingState)
 			{
 				retVal = CI_ERROR;
@@ -28613,7 +28519,7 @@ void SetAxisRelProSwitchLockSta(const UINT16 axisSecId, const UINT8 lockCommand)
 			cFuncRet = checkSwtLastValDrvPosStayorNot(protectSwitchId, dataIdBuf[ii].SwitchPosition);
 			if ((SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
 				|| ((cSwitchCurPos == dataIdBuf[ii].SwitchPosition) && (CI_SUCCESS == cFuncRet)))
-			{
+			{/*道岔可动作之前已经查了，这里还是重复查下*/
 				SetSwitchLockStatus(SWITCH_PLOCKTYPE_AXISSEC, axisSecId, protectSwitchId, lockCommand);  /*设置道岔防护锁闭状态*/
 
 			}
@@ -28642,7 +28548,7 @@ UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT
 {
 
 	/* 局部变量定义初始化 */
-	UINT16 i = 0u;           /* 循环变量 */
+	UINT8 i = 0u;           /* 循环变量 */
 	UINT16 devId = 0u;
 	UINT8  devState = 0u;
 	UINT8 reVal = CI_ERROR;
@@ -28687,61 +28593,6 @@ UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT
 	return reVal;
 }
 
-/*
-* 功能描述： 逻辑区段所处道岔防护道岔封锁状态检查
-* 参数说明： UINT16 const routeId, 逻辑区段ID
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
-* 返回值  ： CI_ERROR
-*            CI_SUCCESS
-* add by mpt 20260331
-*/
-UINT8 LogicSecRltvPrtctSwFlockCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState)
-{
-	/* 局部变量定义初始化 */
-	UINT8 chRetVal = CI_ERROR;
-	UINT8 ii = 0U;
-	UINT16 jj = 0U;
-	UINT16 chDevId = 0U;
-	UINT8 chDevState = 0U;
-	UINT8 chCheckSum = 0U;
-	LogsecSwitchStruct* pstLogicSecSwitchBuf = NULL;
-
-	chCheckSum = GetLgcRelateProSwSum(wLgcId);/*获取指定ID逻辑区段关联防护道岔数目*/
-	pstLogicSecSwitchBuf = GetLgcRelateProSwStru(wLgcId);
-	if ((NULL != pDevId)
-		&& (NULL != pDevState)
-		&& (NULL != pstLogicSecSwitchBuf)
-		&& (LOGSEC_RELATE_PRO_SW_SUM_MAX > chCheckSum))
-	{
-		chRetVal = CI_SUCCESS;
-		/*遍历逻辑区段关联防护道岔*/
-		for (ii = 0U; ii < chCheckSum; ii++)
-		{
-
-			chDevId = pstLogicSecSwitchBuf[ii].SwitchId;
-			chDevState = GetSwitchFLockState(chDevId);
-			if(SWITCH_LOCK_FENGSUO_NO == chDevState)
-			{
-				/*位置检查通过，继续检查*/
-			}
-			else
-			{
-				/*状态不一致返回故障状态*/
-				*pDevId = chDevId;
-				*pDevState = chDevState;
-				chRetVal = CI_ERROR;
-				break;
-			}
-		}
-	}
-	else
-	{
-		chRetVal = CI_ERROR;
-	}
-
-	return chRetVal;
-}
 
 /*
 * 功能描述： 设置逻辑区段关联防护道岔防护锁闭状态
@@ -28784,7 +28635,7 @@ void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand)
 			retVal = CI_ERROR;
 		}
 		else
-		{
+		{/*无处理*/
 		}
 	}
 
@@ -28812,4 +28663,75 @@ void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand)
 	{
 		retVal = CI_ERROR;
 	}
-}
+}
+/*
+* 功能描述：计轴区段所有道岔是否全部征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR  未全部征用
+*            CI_SUCCESS 全部征用
+*  add by mpt 20260403
+*/
+UINT8 JumpPhySecAllUseCheck(const UINT16 axisSecId)
+{
+	UINT8 retVal = CI_ERROR;
+	UINT8  checkSum = 0u;
+	AxisSwitchStruct* dataIdBuf = 0u;
+
+	/* 局部变量定义初始化 */
+	UINT8 i = 0u;           /* 循环变量 */
+	UINT16 wSwitchId = 0u;
+	UINT16 phyId = 0U;
+	UINT8 phyUseState = 0U;
+
+	checkSum = GetAxisSecRelateProSwSum(axisSecId);/*计轴区段关联防护道岔*/
+	dataIdBuf = GetAxisSecRelateProSwStru(axisSecId);
+
+
+	if (NULL == dataIdBuf)
+	{
+		/*无检查项*/
+		retVal = CI_ERROR;
+	}
+	else
+	{
+		retVal = CI_SUCCESS;
+		/*开始检查防护道岔*/
+		for (i = 0u; i < checkSum; i++)
+		{
+			wSwitchId = dataIdBuf[i].SwitchId;
+		 
+			phyId = GetSwitchPhySectionId(wSwitchId);
+			phyUseState = GetPhySecUseState(phyId);
+
+			if (PHYSICAL_SECTION_USING_YES != phyUseState)
+			{/*非征用*/
+				retVal = CI_ERROR;
+				break;
+			}
+			else
+			{
+				/*继续循环*/
+			}
+
+		}
+	}
+
+	if (CI_SUCCESS == retVal)
+	{
+		phyId = GetAxisSecRelativePhySecId(axisSecId);/*获取相关物理区段ID*/
+		phyUseState = GetPhySecUseState(phyId);
+	
+		if (PHYSICAL_SECTION_USING_YES != phyUseState)
+		{/*非征用*/
+			retVal = CI_ERROR;
+		}
+		else
+		{
+			/*无执行*/
+		}
+	}
+
+	return retVal;
+}
+
+

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

@@ -3025,22 +3025,22 @@ void SetAxisRelProSwitchLockSta(const UINT16 axisSecId, const UINT8 lockCommand)
 */
 UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
 /*
-* 功能描述： 逻辑区段所处道岔防护道岔封锁状态检查
-* 参数说明： UINT16 const routeId, 逻辑区段ID
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
-* 返回值  ： CI_ERROR
-*            CI_SUCCESS
-* add by mpt 20260331
-*/
-UINT8 LogicSecRltvPrtctSwFlockCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState);
-/*
 * 功能描述： 设置逻辑区段关联防护道岔防护锁闭状态
 * 参数说明： const UINT16 axisSecId, 计轴区段ID
 *            const UINT8 lockCommand, 锁闭状态
 * 返回值  ： void
 * add by mpt 20260331
 */
-void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand);
+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
-			reResult = CI_SUCCESS;
+	{
-		}
+		/* 记录故障码 */
-		else
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_TYPE, devState, sendLevel);
-		{
+		/* 失败返回 */
-			/* 记录故障码 */
+		reResult = CI_ERROR;
-			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
-			reResult = CI_SUCCESS;
+	{
-		}
+		/* 记录故障码 */
-		else
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_TYPE, devState, sendLevel);
-		{
+		/* 失败返回 */
-			/* 记录故障码 */
+		reResult = CI_ERROR;
-			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);
-		{/*传统线路*/
-			checkResult = OverlapSwitchPosCheck(overlapId,&devId,&devState);
-		}/* zt 删除单轨相关代码 2022-02-15 */
-		else
-		{/*线路类型错误*/
-			checkResult = CI_ERROR;
-		}
-
 		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
-			reResult = CI_SUCCESS;
+	{
-		}
+		/* 记录故障码 */
-		else
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_LEVEL, devState, sendLevel);
-		{
+		/* 失败返回 */
-			/* 记录故障码 */
+		reResult = CI_ERROR;
-			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)
 			{
-				/*防淹门联锁条件检查*/
+				reResult = CI_SUCCESS;
-				checkResult = CBTCRouteFloodGateCheck(routeId,functionId,sendLevel);
+			}
-				if (CI_SUCCESS == checkResult)
+			else
-				{
+			{
-					reResult = CI_SUCCESS;
+				reResult = CI_ERROR;
-				}
-				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
-			reResult = CI_SUCCESS;
+	{
-		}
+		/* 记录故障码 */
-		else
+		SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_LEVEL, devState, sendLevel);
-		{
+		/* 失败返回 */
-			/* 记录故障码 */
+		reResult = CI_ERROR;
-			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区段状态为【未锁闭】*/
-						/*道岔2区段状态为【未锁闭】*/
+					checkResult = switch2ndSecLockState;
-						checkResult = switch2ndSecLockState;
+					if (checkResult == PHYSICAL_SECTION_LOCK_NO)
-						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)
@@ -9910,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)
 				{
@@ -11655,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/Overlap/OverlapDataManage.c

@@ -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/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)     /*屏蔽门关联的出站进路数目最大值*/

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

@@ -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,6 +524,11 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 	UINT16 indexFind = 0U;
 	UINT8 devBelongThisLine = 0U;
 	UINT8 switchBoardNum = 0U;
+	UINT8 chLocalCiOCSswitch = 0U;
+	UINT8 chMainCotrolOCId = 0U;
+
+	chLocalCiOCSswitch = GetLocalCiOCSswitch();
+
 
 	switchLockStatus = GetSwitchLockStatus(DeviceId);
 
@@ -698,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;
+				if ((chMainCotrolOCId == m_Switches[i].OcId) || (OC_S_OFF == chLocalCiOCSswitch))
-				indexFind = i;
+				{/*当前有主控OC或OC-S功能关闭*/
-				break;
+					flagFind = 1u;
+					indexFind = i;
+					break;
+				}
 			}
 		}
 		if (1u == flagFind)
@@ -1632,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*/
@@ -1640,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:/*进路空闲码位*/
@@ -1659,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);
 		}

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();
+		if (CI_ERROR == chRtn1)
-		ClearAtsEaMsgFirst();
+		{
-		ClearAtsEaMsgSecond();
+			ClearAtsMsgFirst();
-		ClearAtsWlbMsgFirst();
+			ClearAtsEaMsgFirst();
-		ClearAtsWlbMsgSecond();
+			ClearAtsWlbMsgFirst();
-		ClearAtsDaMsgFirst();
+			ClearAtsDaMsgFirst();
-		ClearAtsDaMsgSecond();
+		}
-		ClearSndAtsScreenFstCfmMsg();
+		if (CI_ERROR == chRtn2)
-		ClearSndAtsEaFstCfmMsg();
+		{
-		ClearSndAtsWlbFstCfmMsg();
+			ClearSndAtsScreenFstCfmMsg();
-		ClearSndAtsDaFstCfmMsg();
+			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/ParsePackOcData.c

@@ -253,7 +253,7 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 	UINT8 chMainCotrolOCId = 0U;
 	UINT8 chControlCmd = 0U;
 	UINT8 chControlCmdNum = 0u;
-	UINT16 cmdIndex = 0u;
+	UINT32 cmdIndex = 0u;
 	UINT8 chOcOutControlCmd = 0u;
 	UINT8 chOcFindPostionCmd = 0u;
 	UINT8 chLocalCiOCSswitch = 0u;
@@ -348,11 +348,11 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 					{/*有OC-S且当前无主控，需寻表*/
 						drvCmd = OC_SWITCH_DRIVE_POS_KEEP;/*保持*/
 
-						chOcOutControlCmd = GetSwitchThisOcOutControlCmd(pOcData->OcDevices[kk].DeviceId, pOcData->OcId);
+						chOcOutControlCmd = GetSwitchThisOcOutControlCmd(pOcData->OcDevices[kk].DeviceId, (UINT8)pOcData->OcId);
 						
 						if (MAIN_CONTROL == chOcOutControlCmd)
 						{
-							chOcFindPostionCmd = GetSwitchThisOcFindPostionCmd(pOcData->OcDevices[kk].DeviceId, pOcData->OcId);
+							chOcFindPostionCmd = GetSwitchThisOcFindPostionCmd(pOcData->OcDevices[kk].DeviceId, (UINT8)pOcData->OcId);
 							drvCmd = ConvertSwitchFindPosToSwFindCmd(chOcFindPostionCmd);	
 						}
 					}
@@ -680,8 +680,8 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 						ii += 2u;
 						if (OC_S_ON == chLocalCiOCSswitch)
 						{/*OS-S开关打开*/
-							chControlCmd = GetSwitchThisOcOutControlCmd(pOcData->OcDevices[kk].DeviceId, pOcData->OcId);
+							chControlCmd = GetSwitchThisOcOutControlCmd(pOcData->OcDevices[kk].DeviceId, (UINT8)pOcData->OcId);
-							if ((MAIN_CONTROL == chControlCmd) || (STANDBY_CONTROL == chControlCmd) || (NO_CONTROL_FUN == chControlCmd))
+							if ((MAIN_CONTROL == chControlCmd) || (STANDBY_CONTROL == chControlCmd))
 							{
 								Ci2OcDataBuffer[ii] = chControlCmd;
 							}
@@ -701,6 +701,7 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 					}
 					default:
 					{/*无执行*/
+						break;
 					}
 				}
 			}
@@ -1198,7 +1199,7 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 	UINT32 dwUpToMainCyc = 0U;/*本机升主机周期号*/
 	UINT32 CiRecvOcSN = 0U;/*同步的CI数据中OC周期号*/
 	HLHTHeadContextStru* pstrHlhtHeadCtx = NULL;  /*CI同步的互联互通报文头上下文数据*/
-	UINT32 dwMainStandbyState = 0U;
+	UINT8 dwMainStandbyState = 0U;
 	UINT8 chSwitchBelongOThisOCRet = 0U;
 
 
@@ -1262,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初始通信帧*/
 
@@ -1302,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]);/*应用层数据长度*/
@@ -2172,7 +2173,7 @@ INT16 GetIndexBySignalId(UINT16 sigId)
 * 参数说明： UINT16 swId 道岔ID,UINT8 ocId OCID
 * 返回值  ： 索引      
 */
-INT16 GetIndexBySwitchId(UINT16 swId,UINT16 ocId)
+INT16 GetIndexBySwitchId(UINT16 swId,UINT8 ocId)
 {
 	INT16 retIndex = -1;
 
@@ -2180,7 +2181,7 @@ INT16 GetIndexBySwitchId(UINT16 swId,UINT16 ocId)
 
 	for (i=0u;i<m_SwitchNum;i++)
 	{
-		if ((m_Switches[i].DeviceId == swId)&&(ocId == m_Switches[i].OcId))
+		if ((m_Switches[i].DeviceId == swId)&&(ocId == (UINT8)m_Switches[i].OcId))
 		{
 			retIndex = (INT16)i;
 			break;
@@ -2260,7 +2261,7 @@ void InitOcSignals(void)
 void InitOcSwitchs(void)
 {
 	UINT16 i = 0u;
-	UINT16 j = 0u;
+	UINT8 j = 0u;
 	UINT8 k = 0U;
 	SwitchConfigDataStruct *pSwitch = NULL;
 	UINT8 localCi = 0u;
@@ -2290,8 +2291,9 @@ void InitOcSwitchs(void)
 					{
 						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_Switches[m_SwitchNum].OcId = pSwitch[i].belongOCConfigData[j].OcId;
 					m_SwitchNum++;
 				}
 			}
@@ -2360,7 +2362,7 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 	UINT8 chOcBelongCI = 0U;/*OC所属联锁*/
 	UINT8  chLocalCiId = GetSystemParaLocalCiId();
 	UINT8 chSwitchszPlusBoxId = 0U;
-	UINT8 index = 0u;
+
 	for (i=0U;i<m_OcToCiOrginDataNum;i++)/*遍历OC*/
 	{
 		chOcId = (UINT8)m_OcToCiOrginDataArr[i].OcId & 0xFFU;
@@ -2376,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))
@@ -2429,18 +2431,18 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 									m_Switches[ind].MainStandbyState[k] = pOcDevice->MainStandbyState[k];
 								}
 
-								chSwitchszPlusBoxId = GetSwitchszPlusBoxId(m_Switches[ind].DeviceId, m_Switches[ind].OcId);
+								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, m_Switches[ind].OcId, SWITCH_BOX_NORMAL);
+											SetSwitchOcPlusBoxSateState(m_Switches[ind].DeviceId, (UINT8)m_Switches[ind].OcId, SWITCH_BOX_NORMAL);
 										}
 										else
 										{
-											SetSwitchOcPlusBoxSateState(m_Switches[ind].DeviceId, m_Switches[ind].OcId, SWITCH_BOX_FAULT);
+											SetSwitchOcPlusBoxSateState(m_Switches[ind].DeviceId, (UINT8)m_Switches[ind].OcId, SWITCH_BOX_FAULT);
 										}
 										break;
 									}
@@ -2449,7 +2451,7 @@ void ConvertOcOriginDataToOcSigSwDev(UINT8 devId)
 								/*将板卡故障状态导入*/
 								for (k = 0U; k < m_Switches[ind].BoardNum; k++)
 								{
-									SetSwitchThisOCBoardState(m_Switches[ind].DeviceId, m_Switches[ind].OcId, m_Switches[ind].BoardAddr[k], m_Switches[ind].BoardState[k]);
+									SetSwitchThisOCBoardState(m_Switches[ind].DeviceId, (UINT8)m_Switches[ind].OcId, m_Switches[ind].BoardAddr[k], m_Switches[ind].BoardState[k]);
 									
 								}
 
@@ -3012,6 +3014,7 @@ UINT8 OcInputSignalStateCheck(const UINT8 chInput)
 			break;
 		default:
 			retVal = CI_ERROR;
+			break;
 	}
 	return retVal;
 }

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

@@ -440,7 +440,7 @@ INT16 GetIndexBySignalId(UINT16 sigId);
 * 参数说明： UINT16 swId 道岔ID,UINT8 ocId OCID
 * 返回值  ： 索引
 */
-INT16 GetIndexBySwitchId(UINT16 swId, UINT16 ocId);
+INT16 GetIndexBySwitchId(UINT16 swId, UINT8 ocId);
 
 /*
 * 功能描述： 通过轨道id获取索引

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

@@ -288,6 +288,13 @@ static UINT8 WashTrainRequestCheck(UINT8 Data);
 */
 static UINT8 HeadWashStopSteadyInfoCheck(UINT8 Data);
 /*
+* 功能描述： 联挂端洗车停稳信息接口校验
+* 参数说明： 入参：UINT8 Data 联挂端洗车停稳信息
+* 返回值  ： CI_ERROR: 接口校验失败
+*			 CI_SUCESS: 接口校验成功
+*/
+static UINT8 CoupingWashStopStedInfoCheck(UINT8 Data);
+/*
 * 功能描述： 暂停洗车请求信息接口校验
 * 参数说明： 入参：UINT8 Data 暂停洗车请求信息
 * 返回值  ： CI_ERROR: 接口校验失败
@@ -2100,7 +2107,7 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 	UINT16 sigId = 0U;				/*信号机ID*/
 	UINT32 curCycleNum = Get2oo2CurCycleNum();
 	UINT32 appCycleTime = GetSystemParaAppCycleTime();
-	UINT8 retVal = CI_SUCCESS;
+	UINT8 retVal = CI_ERROR;
 	UINT8 localCiId = GetSystemParaLocalCiId();  /*本地联锁ID*/
 	UINT32 ciEtcsId = 0U;
 	UINT32 vobcEtcsId = 0U;
@@ -2113,6 +2120,7 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 	UINT8 outStationSignalAllowOrNot = CI_VOBC_SIGNAL_DEFAULT;			/*信号机的允许或禁止状态*/
 	UINT32 signalIdInterConn = 0U;	/*互联互通4字节信号机ID*/
 	UINT16 wTempIndex = 0U;	/*临时记录下标*/
+	UINT8 chPackCheck = CI_SUCCESS;
 	ci_vobcPrtclVersion = GetVersionOfVOBCToCI();
 
 
@@ -2158,7 +2166,7 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 
 		ii += 2U;/*预留两个字节*/
 
-		if ((VOBC_CI_INFO_TYPE_PSD_CONTROL == vobcToCiDataStru->appInfoType) && (curCycleNum == vobcToCiDataStru->ComStartCycle))
+		if (VOBC_CI_INFO_TYPE_PSD_CONTROL == vobcToCiDataStru->appInfoType)
 		{/*只有当VOBC发送的信息类型是屏蔽门控制信息时，才组包如下内容；若信息类型为心跳帧，则只发送报文帧头（31+6）*/
 			LongToChar(vobcToCiDataStru->trackSecID,&CiToVobcDataBuffer[ii]);/*回复收到的轨道区段ID,依据CI-VOBCV2.9接口文档修改*/
 			ii += 4U;
@@ -2305,16 +2313,18 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 		}
 		else
 		{
-			/*信息类型错误，什么都不做*/
+			/*不组包发送上述帧*/
+			chPackCheck = CI_ERROR;
 		}
 
 		/*组点连式信息*/
 		if (curCycleNum ==  vobcToCiDataStru->strBlocLinkData.chBlocLinkCycle)
-		{
+		{			
 			/*-由于可以和屏蔽门控制帧同时发，所以判点连式周期-*/
 			if (0U == CiToVobcDataBuffer[33U])
 			{
-				/*没有组其他信息帧，填充预留*/
+				chPackCheck = CI_SUCCESS;
+				/*没有组其他信息帧，填充帧类型点连式*/
 				ShortToChar(CI_VOBC_INFO_TYPE_BLOCLINK, &CiToVobcDataBuffer[33U]);  /*报文类型，两字节*/
 				PackVobcBlocLinkData(CiToVobcDataBuffer, &ii, vobcToCiDataStru);	/*组点连式信息*/
 				/*应用层数据的报文长度 */
@@ -2339,26 +2349,32 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 		{
 			/*不处理*/
 		}
+		if (CI_SUCCESS == chPackCheck)
+		{
+			/*通用报文头中应用层报文总长度*/
+			CiToVobcDataBuffer[29U] = (UINT8)((UINT8)((ii - 31U) >> 8U) & 0xffU);
+			CiToVobcDataBuffer[30U] = (UINT8)((ii - 31U) & 0xffU);
 
-		/*通用报文头中应用层报文总长度*/
+			dstDevId = ((UINT16)CI_SYSTEM_TYPE_VOBC << 8U) | vobcToCiDataStru->VobcId;
-		CiToVobcDataBuffer[29U] = (UINT8) ((UINT8)((ii - 31U) >> 8U) & 0xffU);
+			outnetSafeSendRtn = OutnetSafeSend(dstDevId, 0U, &CiToVobcDataBuffer[0U], ii);
-		CiToVobcDataBuffer[30U] = (UINT8) ((ii - 31U) & 0xffU);
+			if (1U == outnetSafeSendRtn)
-
+			{ /*写队列成功*/
-		dstDevId = ((UINT16)CI_SYSTEM_TYPE_VOBC << 8U) | vobcToCiDataStru->VobcId;
-		outnetSafeSendRtn = OutnetSafeSend(dstDevId, 0U, &CiToVobcDataBuffer[0U], ii);
-		if (1U == outnetSafeSendRtn)
-		{ /*写队列成功*/
 #ifdef LOGPRINT/*日志打印宏*/                 
 #ifdef PLATFORM_2OO2/*2oo2平台打印*/
-			debug_infor_printf((const)"\nVOBC_CBTC_SEND:%d", ii);
+				debug_infor_printf((const)"\nVOBC_CBTC_SEND:%d", ii);
-			debug_out_array(0xAA, CiToVobcDataBuffer, ii);
+				debug_out_array(0xAA, CiToVobcDataBuffer, ii);
 #endif/*平台打印结束*/
 #endif
+			}
+			else
+			{
+				/*写队列失败*/
+				retVal = CI_ERROR;
+			}
 		}
 		else
 		{
-			/*写队列失败*/
+			/*不组包*/
-			retVal = CI_ERROR;
 		}
 	}
 	else
@@ -3327,36 +3343,51 @@ static UINT8 PackCiToVobcDataFAOHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 						}
 					}
 					else
-					{/*无站台发车按钮给VOBC发送站台无发车按钮状态*/
+					{
-						CiToVobcDataBuffer[ii] = PLATFORM_DEPAR_BUTTON_NO;
+						CiToVobcDataBuffer[ii] = PLATFORM_DEPAR_BUTTON_NO;;/*有些线路PSD不配置发车按钮继电器*/
 					}
 					/* IBP盘发车按钮检查*/
 					if(PLATFORM_DEPAR_BUTTON_STATE_VALID != CiToVobcDataBuffer[ii])
 					{
-						if (PSD_BUTTON_PANGLU_STATE_VALID == psdButtonPangluState)
+						/*无效、无站台*/
+
+						/*检查IBP按钮状态*/
+						wibpBtnRelayId = GetIbpConfmRelayId(psdId);
+						if ((0u != wibpBtnRelayId) && (UINT16_MAX != wibpBtnRelayId))
 						{
-							; /* 站台按钮旁路*/
+							if (PSD_BUTTON_PANGLU_STATE_VALID == psdButtonPangluState)
-						}
-						else
-						{
-							/*之前发车按钮无效，需要检查IBP按钮状态*/
-							wibpBtnRelayId = GetIbpConfmRelayId(psdId);
-							if ((0u != wibpBtnRelayId) && (UINT16_MAX != wibpBtnRelayId))
 							{
-								chibpState = GetPsdButtonIbpState(psdId); /*IBP按钮状态*/
+								/*无站台发车按钮给VOBC发送站台关门按钮默认值*/
-								if(PLATFORM_DEPAR_BUTTON_STATE_VALID == chibpState)
+								CiToVobcDataBuffer[ii] = PSD_RELATED_BUTTON_STATE_DEFAULT;
-								{
-									CiToVobcDataBuffer[ii] = chibpState;
-								}
-								else
-								{
-									; /*保持原状态不变*/
-								}
 							}
 							else
 							{
-								; /*保持原状态不变*/
+								chibpState = GetPsdButtonIbpState(psdId); /*IBP按钮状态（有效、无效、故障）*/
+								/* 有效 》 默认 》 无效*/
+								if (PLATFORM_DEPAR_BUTTON_STATE_INVALID == chibpState)
+								{
+									/*IBP按钮状态无效*/
+									if (PSD_RELATED_BUTTON_STATE_DEFAULT == CiToVobcDataBuffer[ii])
+									{
+										;/*组默认*/
+									}
+									else
+									{
+										/*站台发车按钮无效，给VOBC发送IBP按钮状态*/
+										CiToVobcDataBuffer[ii] = chibpState;
+									}
+								}
+								else
+								{
+									/*IBP按钮状态有效或者默认，给VOBC发送站台：IBP按钮状态即可*/
+									CiToVobcDataBuffer[ii] = chibpState;
+								}
 							}
+								
+						}
+						else
+						{
+							;/*无IBP、维持既有不动*/
 						}
 					}
 					else
@@ -6163,33 +6194,47 @@ static UINT8 PackCiToIvocPsdInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 						{/*无站台发车按钮给VOBC发送站台无发车按钮状态*/
 							pDataBuf[ii] = CI_IVOC_PSD_PDB_NO_BUTTON;
 						}
-						/* IBP盘发车按钮检查 */
+						/* IBP盘发车按钮检查*/
 						if(PLATFORM_DEPAR_BUTTON_STATE_VALID != pDataBuf[ii])
 						{
-							if (PSD_BUTTON_PANGLU_STATE_VALID == psdButtonPangluState)
+							/*无效、无站台*/
+							/*检查IBP按钮状态*/
+							wibpBtnRelayId = GetIbpConfmRelayId(wPsdId);
+							if ((0u != wibpBtnRelayId) && (UINT16_MAX != wibpBtnRelayId))
 							{
-								;/* 站台按钮旁路*/
+								if (PSD_BUTTON_PANGLU_STATE_VALID == psdButtonPangluState)
-							}
-							else
-							{ 
-								/*之前发车按钮无效，需要检查IBP按钮状态*/
-								wibpBtnRelayId = GetIbpConfmRelayId(wPsdId);
-								if ((0u != wibpBtnRelayId) && (UINT16_MAX != wibpBtnRelayId))
 								{
-									chibpState = GetPsdButtonIbpState(wPsdId); /*IBP按钮状态*/
+									/*无站台发车按钮给VOBC发送站台关门按钮默认值*/
-									if(PLATFORM_DEPAR_BUTTON_STATE_VALID == chibpState)
+									pDataBuf[ii] = PSD_RELATED_BUTTON_STATE_DEFAULT;
-									{
-										pDataBuf[ii] = chibpState;
-									}
-									else
-									{
-										; /*保持原状态不变*/
-									}
 								}
 								else
 								{
-									; /*保持原状态不变*/
+									chibpState = GetPsdButtonIbpState(wPsdId); /*IBP按钮状态（有效、无效、故障）*/
+									/* 有效 》 默认 》 无效*/
+									if (PLATFORM_DEPAR_BUTTON_STATE_INVALID == chibpState)
+									{
+										/*IBP按钮状态无效*/
+										if (PSD_RELATED_BUTTON_STATE_DEFAULT == pDataBuf[ii])
+										{
+											;/*组默认*/
+										}
+										else
+										{
+											/*站台发车按钮无效，给VOBC发送IBP按钮状态*/
+											pDataBuf[ii] = chibpState;
+										}
+									}
+									else
+									{
+										/*IBP按钮状态有效或者默认，给VOBC发送站台：IBP按钮状态即可*/
+										pDataBuf[ii] = chibpState;
+									}
 								}
+									
+							}
+							else
+							{
+								;/*无IBP、维持既有不动*/
 							}
 						}
 						else
@@ -6885,7 +6930,7 @@ static UINT8 PackCiToIvocFLockInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 		chStartLockStat = GetStartFLockFlag();
 
 		/*上电封锁状态*/
-		if (CI_START_LOCK_NO == chStartLockStat)
+		if (CI_START_FLOCK_NO == chStartLockStat)
 		{
 			pDataBuf[ii] = CI_IVOC_ALLLINE_FLOCK_NO;
 		}
@@ -7394,6 +7439,8 @@ static UINT8 PackCiToIvocSleepTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 	UINT16 wEnvelopeSendSumIndex = 0u;
 	UINT16 wTrainId = 0u;
 	UINT8 chLinkLogicDirUpAndDown = 0u;
+	UINT8 chTrainVirHeadScreenFlag = 0U;/*虚拟前筛标志*/
+	UINT8 chTrainVirTailScreenFlag = 0U;/*虚拟后筛标志*/
 
 	if ((NULL == pDataBuf)
 		|| (NULL == wDataLength))
@@ -7481,8 +7528,16 @@ static UINT8 PackCiToIvocSleepTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 					{
 						chRetVal = CI_ERROR;
 					}
-					/*前筛*/
+					/*前筛*/					
-					chHeadScreStat = strEnvelope.suspicHead;
+					chTrainVirHeadScreenFlag = GetTrainVirHeadScreenPassFlag(wTrainId);
+					if (TRAIN_VIR_SCREEN_PASS_FLAG_VALID == chTrainVirHeadScreenFlag)
+					{
+						chHeadScreStat = CI_IVOC_HEAD_SCREEN_PASS;
+					}
+					else
+					{
+						chHeadScreStat = strEnvelope.suspicHead;
+					}
 
 					if (CI_IVOC_HEAD_SCREEN_PASS == chHeadScreStat)
 					{
@@ -7497,8 +7552,16 @@ static UINT8 PackCiToIvocSleepTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 						chRetVal = CI_ERROR;
 						debug_infor_printf((const)"\n PackCiToIvocSleepTrainInfo HeadScreState_Error, state : %d  \n", chHeadScreStat);
 					}
-					/*后筛*/
+					/*后筛*/					
-					chTailScreStat = strEnvelope.suspicTail;
+					chTrainVirTailScreenFlag = GetTrainVirTailScreenPassFlag(wTrainId);
+					if (TRAIN_VIR_SCREEN_PASS_FLAG_VALID == chTrainVirTailScreenFlag)
+					{
+						chTailScreStat = CI_IVOC_TAIL_SCREEN_PASS;
+					}
+					else
+					{
+						chTailScreStat = strEnvelope.suspicTail;
+					}
 					if (CI_IVOC_TAIL_SCREEN_PASS == chTailScreStat)
 					{
 						pDataBuf[ii] |= BIT_VAL_00000001B << 4; /*后端筛选通过 01B*/
@@ -8983,34 +9046,49 @@ UINT8 PackCiToVobcDataFAOHLHToneSelf(VobcToCiDataStruct* vobcToCiDataStru)
 						CiToVobcDataBuffer[ii] = PLATFORM_DEPAR_BUTTON_NO;
 					}
 					/* IBP盘发车按钮检查*/
+
 					if(PLATFORM_DEPAR_BUTTON_STATE_VALID != CiToVobcDataBuffer[ii])
 					{
-						if ((PSD_BUTTON_PANGLU_STATE_VALID == psdButtonPangluState) || (1u == flag))
+						/*无效、无站台*/
+
+						/*检查IBP按钮状态*/
+						wibpBtnRelayId = GetIbpConfmRelayId(psdId);
+						if ((0u != wibpBtnRelayId) && (UINT16_MAX != wibpBtnRelayId))
 						{
-							;
+							if (PSD_BUTTON_PANGLU_STATE_VALID == psdButtonPangluState)
-						}
-						else
-						{
-							/*之前发车按钮无效，需要检查IBP按钮状态*/
-							wibpBtnRelayId = GetIbpConfmRelayId(psdId);
-							if ((0u != wibpBtnRelayId) && (UINT16_MAX != wibpBtnRelayId))
 							{
-								chibpState = GetPsdButtonIbpState(psdId); /*IBP按钮状态*/
+								/*无站台发车按钮给VOBC发送站台关门按钮默认值*/
-								if(PLATFORM_DEPAR_BUTTON_STATE_VALID == chibpState)
+								CiToVobcDataBuffer[ii] = PSD_RELATED_BUTTON_STATE_DEFAULT;
-								{
-									CiToVobcDataBuffer[ii] = chibpState;
-								}
-								else
-								{
-									; /*保持原状态不变*/
-								}
 							}
 							else
 							{
-								; /*保持原状态不变*/
+								chibpState = GetPsdButtonIbpState(psdId); /*IBP按钮状态（有效、无效、故障）*/
+								/* 有效 》 默认 》 无效*/
+								if (PLATFORM_DEPAR_BUTTON_STATE_INVALID == chibpState)
+								{
+									/*IBP按钮状态无效*/
+									if (PSD_RELATED_BUTTON_STATE_DEFAULT == CiToVobcDataBuffer[ii])
+									{
+										;/*组默认*/
+									}
+									else
+									{
+										/*站台发车按钮无效，给VOBC发送IBP按钮状态*/
+										CiToVobcDataBuffer[ii] = chibpState;
+									}
+								}
+								else
+								{
+									/*IBP按钮状态有效或者默认，给VOBC发送站台：IBP按钮状态即可*/
+									CiToVobcDataBuffer[ii] = chibpState;
+								}
 							}
+								
+						}
+						else
+						{
+							;/*无IBP、维持既有不动*/
 						}
-						
 					}
 					else
 					{
@@ -9158,6 +9236,7 @@ UINT8 PackCiToVobcDataFAOHLHToneSelf(VobcToCiDataStruct* vobcToCiDataStru)
 				CiToVobcDataBuffer[ii++] = washMachineState;                                  /*5洗车机故障：0x55无故障，0xaa故障*/
 				CiToVobcDataBuffer[ii++] = washModeState;                                     /*洗车模式：0x01:通过洗(侧洗)，0x02:端洗（全洗）*/
 				CiToVobcDataBuffer[ii++] = chWashWorkModeBack;                                /*洗车模式设置反馈：5个取值*/
+				CiToVobcDataBuffer[ii++] = GetCoupingWashAllowState(washMachineId);           /*联挂端洗车允许通过：0x55允许通过，0xaa禁止通过*/
 			}
 			else
 			{/*本联锁集中区没有洗车机,发送默认值,洗车机故障状态发送采集信息*/
@@ -9168,6 +9247,7 @@ UINT8 PackCiToVobcDataFAOHLHToneSelf(VobcToCiDataStruct* vobcToCiDataStru)
 				CiToVobcDataBuffer[ii++] = WASHMACHINE_COL_FALUT_NO_2;
 				CiToVobcDataBuffer[ii++] = XTA_MODE_STATE_NO;
 				CiToVobcDataBuffer[ii++] = WASH_WORKMODE_BACK_DEFAULT;
+				CiToVobcDataBuffer[ii++] = WASHMACHINE_COL_COUPINGWASH_NO;
 			}
 
 			ShortToChar(CI_VOBC_INFO_TYPE_FAO_INFO, &CiToVobcDataBuffer[33]);/*全自动运行洗车帧报文类型，两字节*/
@@ -9712,6 +9792,30 @@ static UINT8 HeadWashStopSteadyInfoCheck(UINT8 Data)
 	return retVal;
 }
 
+/*
+* 功能描述： 联挂端洗车停稳信息接口校验
+* 参数说明： 入参：UINT8 Data 联挂端洗车停稳信息
+* 返回值  ： CI_ERROR: 接口校验失败
+*			 CI_SUCESS: 接口校验成功
+*/
+static UINT8 CoupingWashStopStedInfoCheck(UINT8 Data)
+{
+	UINT8 coupingWashStopSteadyInfo = 0U;
+	UINT8 retVal = CI_ERROR;
+	coupingWashStopSteadyInfo = Data;
+
+	if ((WASHMACHINE_COUPING_STEADY_YES == coupingWashStopSteadyInfo) || (WASHMACHINE_COUPING_STEADY_NO == coupingWashStopSteadyInfo))
+	{
+		retVal = CI_SUCCESS;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+
+	return retVal;
+}
+
 /*
 * 功能描述： 暂停洗车请求信息接口校验
 * 参数说明： 入参：UINT8 Data 暂停洗车请求信息
@@ -11863,11 +11967,23 @@ UINT8 ParseFAOHLHTOtherTypeData(const UINT16 appInfoType, UINT8* dataBuf, UINT16
 			{
 				vobcToCiDataStru->chWashMachineWorkMode = dataBuf[ii];
 				ii += 1U;
+				chRetVal = CoupingWashStopStedInfoCheck(dataBuf[ii]);
 			}
 			else
 			{
 				chRetVal = CI_ERROR;
 			}
+
+			if (CI_SUCCESS == chRetVal)
+			{
+				vobcToCiDataStru->couplingWashStopSteadyInfo = dataBuf[ii];
+				ii += 1U;
+			}
+			else
+			{
+				chRetVal = CI_ERROR;
+			}
+
 		}
 		else if ((VOBC_CI_INFO_TYPE_HEART_FRAME == appInfoType) || (VOBC_CI_INFO_TYPE_LOGOUT_ASK == appInfoType))
 		{/*心跳帧或注销请求帧*/
@@ -14049,20 +14165,22 @@ void PackVobcBlocLinkData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcToCiDataStr
 	UINT8 k = 0U;
 	UINT32 dwTempHLHTId = 0U;
 	UINT8 chEsbPLState = 0U;
-	wIndex = *ii;
+	
 	if ((NULL != CiToVobcDataBuffer) && (NULL != ii) && (NULL != vobcToCiDataStru))
 	{
+		wIndex = *ii;
+
 		/*判断是否匹配到进路，若未匹配到进路不组应用数据*/
 		chRouteNum = GetBlocLinkRouteNum(vobcToCiDataStru->VobcId);
 		pRouteBuf = GetBlocLinkRouteBuf(vobcToCiDataStru->VobcId);
-		debug_infor_printf((const)"\nVOBC %d BlocLink RouteNum: %d\n", VobcToCiDataStru->VobcId, chRouteNum);
+		
-		for (k = 0U;k< chRouteNum;k++)
-		{
-			debug_infor_printf((const)"\nRouteID: %d\n", pRouteBuf[k]);
-		}
-	
 		if ((0U < chRouteNum) && (CI_VOBC_ROUTE_MAX >= chRouteNum) && (NULL != pRouteBuf))
 		{
+			for (k = 0U; k < chRouteNum; k++)
+			{
+				debug_infor_printf((const)"\nBlocLinkRouteID: %d\n", pRouteBuf[k]);
+			}
+
 			/*1 组下一个CI互联互通编号*/
 			PackNextCiId(CiToVobcDataBuffer, &wIndex,vobcToCiDataStru);
 
@@ -14081,7 +14199,7 @@ void PackVobcBlocLinkData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcToCiDataStr
 					{
 						LongToChar(dwTempHLHTId, &CiToVobcDataBuffer[wIndex]);     /*组道岔ID*/
 						wIndex += 4U;
-						chTempState = GetSwitchCurPosition(wSwitchBuffer[k]);     /*组道岔状态D*/
+						chTempState = GetSwitchCurPosition(wSwitchBuffer[k]);     /*组道岔状态*/
 						if (SWITCH_POSITION_DINGWEI == chTempState)
 						{
 							CiToVobcDataBuffer[wIndex++] = CI_IVOC_SWITCH_POSTION_DING;
@@ -14114,7 +14232,7 @@ void PackVobcBlocLinkData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcToCiDataStr
 					{
 						LongToChar(dwTempHLHTId, &CiToVobcDataBuffer[wIndex]);     /*组ID*/
 						wIndex += 4U;
-						CiToVobcDataBuffer[wIndex++] = GetPsdStateToVobc(wTempBuffer[k]);     /*组状态D*/
+						CiToVobcDataBuffer[wIndex++] = GetPsdStateToVobc(wTempBuffer[k]);     /*组状态*/
 					}
 					else
 					{
@@ -14161,17 +14279,8 @@ void PackVobcBlocLinkData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcToCiDataStr
 				wIndex += 2U;
 				for (k = 0U; k < chTempNum; k++)
 				{
-					chRet = dquQueryOutDevId(QFUN_IDMAP_SPKS_ID, wTempBuffer[k], &dwTempHLHTId);
+					LongToChar(wTempBuffer[k], &CiToVobcDataBuffer[wIndex]);     /*组ID*/
-					if (CI_SUCCESS == chRet)
+					wIndex += 4U;
-					{
-						LongToChar(dwTempHLHTId, &CiToVobcDataBuffer[wIndex]);     /*组ID*/
-						wIndex += 4U;
-					}
-					else
-					{
-						LongToChar(0U, &CiToVobcDataBuffer[wIndex]);     /*组无效值*/
-						wIndex += 4U;
-					}
 				}
 
 				/*7 组路径临时限速信息*/
@@ -14450,7 +14559,13 @@ static UINT8 PackMoveAuthorityData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcTo
 	UINT8 chRet = CI_ERROR;
 	UINT16* pRouteBuf = NULL;
 	UINT8 chRouteNum = 0U;
-
+	UINT8 chTempState = 0U;
+	UINT8 chRouteDir = 0U;
+	UINT16 wRouteLastPhy = 0U;
+	UINT16 wLogBelongPhyId = 0U;
+	UINT8 chTrainDir = 0U;
+	struct_PathPoint end = { 0U };    /*列车逻辑终点*/
+	UINT16 wEndLogSecId = 0U;
 	if ((NULL != CiToVobcDataBuffer) && (NULL != ii) && (NULL != vobcToCiDataStru))
 	{
 		wIndex = *ii;
@@ -14458,117 +14573,29 @@ static UINT8 PackMoveAuthorityData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcTo
 		chRouteNum = GetBlocLinkRouteNum(vobcToCiDataStru->VobcId);
 		pRouteBuf = GetBlocLinkRouteBuf(vobcToCiDataStru->VobcId);
 		if ((NULL != pRouteBuf) && (0U < chRouteNum))
-		{
+		{			
-			chRet = CI_SUCCESS;
+			chTempState = GetRouteType(pRouteBuf[chRouteNum - 1U]);
-			wEndSigId = GetRouteEndSignalId(pRouteBuf[chRouteNum - 1U]); /*匹配终端进路的终端信号机*/
+			chRouteDir = GetRouteConfigDirection(pRouteBuf[chRouteNum - 1U]);
-			wOverLapId = GetRouteOverlapLockedId(pRouteBuf[chRouteNum - 1U]);
+			chTrainDir = GetAblTrainDir(vobcToCiDataStru->VobcId);
-			chFlag = OverlapValidMaskCheck(wOverLapId);
+			wRouteLastPhy = GetRouteLastPhySectionId(pRouteBuf[chRouteNum - 1U]);
+		
+			/*车头位置*/
+			end.wLinkId = GetAblTrainMaxHeadLink(vobcToCiDataStru->VobcId);
+			end.dwOffset = GetAblTrainMaxHeadOffset(vobcToCiDataStru->VobcId);
+			wEndLogSecId = GetPointBelongLogSec(end);
+			wLogBelongPhyId = GetLgcSecRelativePhySecId(wEndLogSecId);	
 
-			if (CI_SUCCESS == chFlag)
+			/**进路是折返进路，车的方向与进路方向不同，车在进路最后区段**/
+			if ((ROUTE_TYPE_RETURN == chTempState) && (chRouteDir != chTrainDir) && (wRouteLastPhy == wLogBelongPhyId))
 			{
-				/*进路存在有效保护区段*/
+				/*最后一条进路车换端之后，未匹配到折出进路，安全防护点组车的大前，障碍点组默认值*/
-				chSigProtectDir = GetSignalDirection(wEndSigId);             /*信号机防护方向*/
+				chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, vobcToCiDataStru->strBlocLinkData.wTrainMaxSafeHeadLink, &dwLinkHLHTId);
-				chOverlapLogSum = GetOverlapLogicSectionSum(wOverLapId);
-				pOverlapLogBuf = GetOverlapLogicSectionBuf(wOverLapId);
-				if ((NULL != pOverlapLogBuf) && (0U < chOverlapLogSum) && (OVLP_LOGICSECTION_SUM_MAX > chOverlapLogSum))
-				{
-					if (LINK_DIRECTION == chSigProtectDir)
-					{
-						/*终端信号机防护方向与link一致，安全防护点取保护区段终点link,和link长度*/
-						wLinkId = GetLgcSecTmnlLink(pOverlapLogBuf[chOverlapLogSum - 1U]);
-						chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
-						if (CI_SUCCESS == chRet)
-						{
-							/***组安全防护点位置*/
-							LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
-							wIndex += 4U;
-							dwlinkLength = GetLgcSecTmnlOffset(pOverlapLogBuf[chOverlapLogSum - 1U]);
-							LongToChar(dwlinkLength, &CiToVobcDataBuffer[wIndex]);
-							wIndex += 4U;
-
-							/*终端信号机防护方向与link一致，障碍点取保护区段起点link,长度0*/
-							wLinkId = GetLgcSecOrgnLink(pOverlapLogBuf[0U]);
-							chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
-							if (CI_SUCCESS == chRet)
-							{
-								/***组障碍点点位置*/
-								LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
-								wIndex += 4U;
-								LongToChar(0U, &CiToVobcDataBuffer[wIndex]);
-								wIndex += 4U;
-
-							}
-							else
-							{
-								chRet = CI_ERROR;
-							}
-
-						}
-						else
-						{
-							chRet = CI_ERROR;
-						}
-
-					}
-					else if (NOT_LINK_DIRECTION == chSigProtectDir)
-					{
-						/*终端信号机防护方向与link相反，安全防护点取保护区段起点link,长度0*/
-						wLinkId = GetLgcSecOrgnLink(pOverlapLogBuf[chOverlapLogSum - 1U]);
-						chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
-						if (CI_SUCCESS == chRet)
-						{
-							/***组安全防护点位置*/
-							LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
-							wIndex += 4U;
-							LongToChar(0U, &CiToVobcDataBuffer[wIndex]);
-							wIndex += 4U;
-
-							/*终端信号机防护方向与link相反，障碍点取保护区段起点link,link长度*/
-							wLinkId = GetLgcSecTmnlLink(pOverlapLogBuf[0U]);
-							chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
-							if (CI_SUCCESS == chRet)
-							{
-								/***组障碍点位置*/
-								LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
-								wIndex += 4U;
-								dwlinkLength = GetLgcSecTmnlOffset(pOverlapLogBuf[chOverlapLogSum - 1U]);
-								LongToChar(dwlinkLength, &CiToVobcDataBuffer[wIndex]);
-								wIndex += 4U;
-							}
-							else
-							{
-								chRet = CI_ERROR;
-							}
-						}
-						else
-						{
-							chRet = CI_ERROR;
-						}
-
-
-					}
-					else
-					{
-						chRet = CI_ERROR;
-					}
-				}
-				else
-				{
-					chRet = CI_ERROR;
-				}
-			}
-			else
-			{
-				/*组安全防护点为进路终端信号机防护点link,link偏移量*/
-				wLinkId = GetSignalProtectLink(wEndSigId);
-				chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
 				if (CI_SUCCESS == chRet)
 				{
 					/***组安全防护点位置*/
 					LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
 					wIndex += 4U;
-					dwlinkLength = GetSignalProtectLinkOff(wEndSigId);
+					LongToChar(vobcToCiDataStru->strBlocLinkData.dwTrainMaxSafeHeadOffset, &CiToVobcDataBuffer[wIndex]);
-					LongToChar(dwlinkLength, &CiToVobcDataBuffer[wIndex]);
 					wIndex += 4U;
 
 					/***组障碍点组默认值*/
@@ -14583,7 +14610,134 @@ static UINT8 PackMoveAuthorityData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcTo
 				}
 
 			}
+			else
+			{
+				chRet = CI_SUCCESS;
+				wEndSigId = GetRouteEndSignalId(pRouteBuf[chRouteNum - 1U]); /*匹配终端进路的终端信号机*/
+				wOverLapId = GetRouteOverlapLockedId(pRouteBuf[chRouteNum - 1U]);
 
+				chFlag = OverlapValidMaskCheck(wOverLapId);
+
+				if (CI_SUCCESS == chFlag)
+				{
+					/*进路存在有效保护区段*/
+					chSigProtectDir = GetSignalDirection(wEndSigId);             /*信号机防护方向*/
+					chOverlapLogSum = GetOverlapLogicSectionSum(wOverLapId);
+					pOverlapLogBuf = GetOverlapLogicSectionBuf(wOverLapId);
+					if ((NULL != pOverlapLogBuf) && (0U < chOverlapLogSum) && (OVLP_LOGICSECTION_SUM_MAX > chOverlapLogSum))
+					{
+						if (LINK_DIRECTION == chSigProtectDir)
+						{
+							/*终端信号机防护方向与link一致，安全防护点取保护区段终点link,和link长度*/
+							wLinkId = GetLgcSecTmnlLink(pOverlapLogBuf[chOverlapLogSum - 1U]);
+							chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
+							if (CI_SUCCESS == chRet)
+							{
+								/***组安全防护点位置*/
+								LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
+								wIndex += 4U;
+								dwlinkLength = GetLgcSecTmnlOffset(pOverlapLogBuf[chOverlapLogSum - 1U]);
+								LongToChar(dwlinkLength, &CiToVobcDataBuffer[wIndex]);
+								wIndex += 4U;
+
+								/*终端信号机防护方向与link一致，障碍点取保护区段起点link,长度0*/
+								wLinkId = GetLgcSecOrgnLink(pOverlapLogBuf[0U]);
+								chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
+								if (CI_SUCCESS == chRet)
+								{
+									/***组障碍点点位置*/
+									LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
+									wIndex += 4U;
+									LongToChar(0U, &CiToVobcDataBuffer[wIndex]);
+									wIndex += 4U;
+
+								}
+								else
+								{
+									chRet = CI_ERROR;
+								}
+
+							}
+							else
+							{
+								chRet = CI_ERROR;
+							}
+
+						}
+						else if (NOT_LINK_DIRECTION == chSigProtectDir)
+						{
+							/*终端信号机防护方向与link相反，安全防护点取保护区段起点link,长度0*/
+							wLinkId = GetLgcSecOrgnLink(pOverlapLogBuf[chOverlapLogSum - 1U]);
+							chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
+							if (CI_SUCCESS == chRet)
+							{
+								/***组安全防护点位置*/
+								LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
+								wIndex += 4U;
+								LongToChar(0U, &CiToVobcDataBuffer[wIndex]);
+								wIndex += 4U;
+
+								/*终端信号机防护方向与link相反，障碍点取保护区段起点link,link长度*/
+								wLinkId = GetLgcSecTmnlLink(pOverlapLogBuf[0U]);
+								chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
+								if (CI_SUCCESS == chRet)
+								{
+									/***组障碍点位置*/
+									LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
+									wIndex += 4U;
+									dwlinkLength = GetLgcSecTmnlOffset(pOverlapLogBuf[chOverlapLogSum - 1U]);
+									LongToChar(dwlinkLength, &CiToVobcDataBuffer[wIndex]);
+									wIndex += 4U;
+								}
+								else
+								{
+									chRet = CI_ERROR;
+								}
+							}
+							else
+							{
+								chRet = CI_ERROR;
+							}
+
+
+						}
+						else
+						{
+							chRet = CI_ERROR;
+						}
+					}
+					else
+					{
+						chRet = CI_ERROR;
+					}
+				}
+				else
+				{
+					/*组安全防护点为进路终端信号机防护点link,link偏移量*/
+					wLinkId = GetSignalProtectLink(wEndSigId);
+					chRet = dquQueryOutDevId(QFUN_IDMAP_TRACKSEC_ID, wLinkId, &dwLinkHLHTId);
+					if (CI_SUCCESS == chRet)
+					{
+						/***组安全防护点位置*/
+						LongToChar(dwLinkHLHTId, &CiToVobcDataBuffer[wIndex]);
+						wIndex += 4U;
+						dwlinkLength = GetSignalProtectLinkOff(wEndSigId);
+						LongToChar(dwlinkLength, &CiToVobcDataBuffer[wIndex]);
+						wIndex += 4U;
+
+						/***组障碍点组默认值*/
+						LongToChar(0U, &CiToVobcDataBuffer[wIndex]);
+						wIndex += 4U;
+						LongToChar(UINT32_MAX, &CiToVobcDataBuffer[wIndex]);
+						wIndex += 4U;
+					}
+					else
+					{
+						chRet = CI_ERROR;
+					}
+
+				}
+			}
 			if (CI_SUCCESS == chRet)
 			{
 				*ii = wIndex;	/*输出长度*/
@@ -14592,6 +14746,7 @@ static UINT8 PackMoveAuthorityData(UINT8* CiToVobcDataBuffer, UINT16* ii, VobcTo
 			{
 				/*不处理*/
 			}
+			
 		}
 		else
 		{
@@ -15580,7 +15735,7 @@ static UINT8 GetPathFloodGateData(UINT16* pPathTempBuf, const UINT16 wTrainId)
 				wLogBelongPhyId = GetLgcSecRelativePhySecId(pLogSecBuf[j]);
 				chFloodGateNum = GetPhySecLocatedFloodSum(wLogBelongPhyId);
 				phFloodGateBuf = GetPhySecLocatedFloodId(wLogBelongPhyId);
-				if ((CI_VOBC_OTHER_EQUIPMENT_MAX > (chTempNum + chFloodGateNum)) && (NULL != phFloodGateBuf))
+				if ((((UINT16)CI_VOBC_OTHER_EQUIPMENT_MAX) > (((UINT16)chTempNum) + chFloodGateNum)) && (NULL != phFloodGateBuf))
 				{
 					for (m = 0U;m < chFloodGateNum;m++)
 					{
@@ -15624,7 +15779,7 @@ static UINT8 GetPathFloodGateData(UINT16* pPathTempBuf, const UINT16 wTrainId)
 						{
 							chFloodGateNum = GetPhySecLocatedFloodSum(pRoutePhyBuf[k].PhysicalSectionId);
 							phFloodGateBuf = GetPhySecLocatedFloodId(pRoutePhyBuf[k].PhysicalSectionId);
-							if ((CI_VOBC_OTHER_EQUIPMENT_MAX > (chTempNum + chFloodGateNum)) && (NULL != phFloodGateBuf))
+							if ((((UINT16)CI_VOBC_OTHER_EQUIPMENT_MAX) > (((UINT16)chTempNum) + chFloodGateNum)) && (NULL != phFloodGateBuf))
 							{
 								for (m = 0U; m < chFloodGateNum; m++)
 								{
@@ -15689,7 +15844,7 @@ static UINT8 GetPathFloodGateData(UINT16* pPathTempBuf, const UINT16 wTrainId)
 						{
 							chFloodGateNum = GetPhySecLocatedFloodSum(pOverLapPhyBuf[k]);
 							phFloodGateBuf = GetPhySecLocatedFloodId(pOverLapPhyBuf[k]);
-							if ((CI_VOBC_OTHER_EQUIPMENT_MAX > (chTempNum + chFloodGateNum)) && (NULL != phFloodGateBuf))
+							if ((((UINT16)CI_VOBC_OTHER_EQUIPMENT_MAX) > (((UINT16)chTempNum) + chFloodGateNum)) && (NULL != phFloodGateBuf))
 							{
 								for (m = 0U; m < chFloodGateNum; m++)
 								{
@@ -15744,7 +15899,7 @@ static UINT8 GetPathFloodGateData(UINT16* pPathTempBuf, const UINT16 wTrainId)
 static UINT8 GetDestinationType(UINT8 chRouteNum, UINT16* pRouteBuf)
 {
 	UINT8 chTempState = 0U;
-	UINT8 chRet = 0U;
+	UINT8 chRet = 0xff;
 	if ((NULL != pRouteBuf) && (CI_VOBC_ROUTE_MAX >= chRouteNum) && (0U < chRouteNum))
 	{
 		chTempState = GetRouteType(pRouteBuf[chRouteNum - 1U]);
@@ -15832,45 +15987,54 @@ static UINT8 PackCiToIvocComErrRcInfo(UINT8* pDataBuf, UINT16* wDataLength)
 		chTransRciSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_RC);
 		pTransRciId = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RC);
 
-		/*数据合法*/
+		if (0U == chTransRciSum)
-		if (NULL != pTransRciId)
 		{
+			/*如果RC没有相邻RC，故障RC数目返回0*/
 			chRetVal = CI_SUCCESS;
-
-			for (jj = 0U; jj < chTransRciSum; jj++)
-			{
-				chNearRciCommState = GetCiTransmitState(CI_SYSTEM_TYPE_RC, jj);  /*获取与相邻RC通信状态*/
-
-				/*通信正常*/
-				if ((TRANSMIT_2OO2_STATE_GOOD == chNearRciCommState) || (TRANSMIT_2OO2_STATE_LINK == chNearRciCommState))
-				{
-					;
-				}
-				else
-				{
-					/*当前通信故障RC数目未超限*/
-					if (CI_IVOC_COM_ERR_RC_NUM_MAX > chComErrRcNum)
-					{
-						/*通信故障，记录当前RC ID*/
-						wComRcId = ((CI_SYSTEM_TYPE_RC << 8U) || pTransRciId[jj]);
-						ShortToChar(wComRcId, &pDataBuf[ii]); 
-						ii += 2U;
-						chComErrRcNum++;		
-					}
-					else
-					{
-						chRetVal = CI_ERROR;
-						debug_infor_printf((const)"\n PackCiToIvocComErrRcInfo Error: chComErrRcNum more than Max\n");
-						break;
-					}
-				}
-			}
 		}
 		else
 		{
-			/*数据错误*/
+			/*数据合法*/
-			;
+			if (NULL != pTransRciId)
+			{
+				chRetVal = CI_SUCCESS;
+
+				for (jj = 0U; jj < chTransRciSum; jj++)
+				{
+					chNearRciCommState = GetCiTransmitState(CI_SYSTEM_TYPE_RC, pTransRciId[jj]);  /*获取与相邻RC通信状态*/
+
+					/*通信正常*/
+					if (TRANSMIT_STATE_GOOD == chNearRciCommState)
+					{
+						;
+					}
+					else
+					{
+						/*当前通信故障RC数目未超限*/
+						if (CI_IVOC_COM_ERR_RC_NUM_MAX > chComErrRcNum)
+						{
+							/*通信故障，记录当前RC ID*/
+							wComRcId = (UINT16)((CI_SYSTEM_TYPE_RC << 8U) | pTransRciId[jj]);
+							ShortToChar(wComRcId, &pDataBuf[ii]);
+							ii += 2U;
+							chComErrRcNum++;
+						}
+						else
+						{
+							chRetVal = CI_ERROR;
+							debug_infor_printf((const)"\n PackCiToIvocComErrRcInfo Error: chComErrRcNum more than Max\n");
+							break;
+						}
+					}
+				}
+			}
+			else
+			{
+				/*数据错误*/
+				;
+			}
 		}
+		
 
 	}
 

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

@@ -74,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接口*/
+	chDataType = GetLocalPublicDataType(); /*区分分支，与主线zc接口*/
-	if ((NULL != dataBuf) && (dataLength > 0u))
+	if ((NULL != dataBuf) && (0U < dataLength))
 	{
 		sourceId = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_ZC);/*获取与本联锁通信的ZC的ID，目前一个联锁最多只与一个ZC通信*/
 
@@ -119,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)
 				{
@@ -135,162 +135,247 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 				{
 					/*报文有效，继续解析*/
 					retVal = CI_SUCCESS;
+					if (DATA_TYPE_MAIN_BRANCH == chDataType)
 					{
-						if (DATA_TYPE_MAIN_BRANCH == 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)
 								{
-									; /* 无处理，继续解析下一包 */
+								case ZC_TO_TIOC_MASK_MSG:
-								}
+									/* 解析ZC-CI码位信息 */
-								else if (5u > wMsgLen)
+									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;
-									case ZC_TO_RC_CBTC_CROSS_MSG:
-										/*解析ZC-CI的CBTC主控列车跨压信息*/
-										retVal = ParseZcCbtcCrossData(&dataBuf[ii], wMsgCheckLen);
-										dwStep |= 0x00002U;
-										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) /*解析失败*/
 							{
-								/*校验数据长度*/
+								break;
-								if (ii > dataLength)
+							}
+							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*/
+							ii += wMsgCheckLen; /*继续*/
-							wMsgCheckLen = hlhtGalHead.totalDataLen;
-							retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
-							if (CI_ERROR == retVal)
-							{
-								debug_infor_printf((const)"\nParseZcToCiDataFrame_Error MaskOnly\n");
-								ClearZcData(); /*没解析通过则清空*/
-							}
-							else
-							{
-								; /*继续*/
-							}
 						}
-
+					}
-						if (CI_SUCCESS == retVal)
+					if (CI_SUCCESS == retVal)
+					{
+						if (hlhtGalHead.totalDataLen != (ii - 31U))
 						{
-							/*更新通信周期*/
+							retVal = CI_ERROR;
-							dwCurCyc = Get2oo2CurCycleNum();
+							debug_infor_printf((const)"\nParseZcToCiDataFrame_Error totalDataLen\n");
-							funRet = SetCiTransmitRecvDataCycNum(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0], dwCurCyc);
+						}
-							if (CI_ERROR == funRet)
+						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);
@@ -299,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;
@@ -1061,24 +1146,24 @@ UINT8 ParseZcSnowData(UINT8* dataBuf, UINT16 dataLen)
 */
 UINT8 PackCiToZcData( UINT8 deviceId)
 {
-	UINT8 localCi = 0u; /*本地联锁ID*/
+	UINT8 localCi = 0U; /*本地联锁ID*/
-    UINT8 CiToZcDataBuffer[CI_TO_ZC_DATA_LEN_MAX] = {0u};/*CI到ZC组帧数组*/
+    UINT8 CiToZcDataBuffer[CI_TO_ZC_DATA_LEN_MAX] = {0U};/*CI到ZC组帧数组*/
-    UINT16 SendMaskSum = 0u;
+    UINT16 SendMaskSum = 0U;
-	UINT16 ii = 0u;
+	UINT16 ii = 0U;
-	UINT32 ciEtcsId = 0u;	/*CI互联互通编号*/
+	UINT32 ciEtcsId = 0U;	/*CI互联互通编号*/
-	UINT32 zcEtcsId = 0u;	/*ZC互联互通编号*/
+	UINT32 zcEtcsId = 0U;	/*ZC互联互通编号*/
-	UINT32 emapCheckVer = 0u;	/*共用数据校验信息*/
+	UINT32 emapCheckVer = 0U;	/*共用数据校验信息*/
 	UINT8 retVal = CI_ERROR;
 	UINT32 curCycleNum = Get2oo2CurCycleNum();	/*联锁应用周期号*/
 	UINT32 appCycleTime = GetSystemParaAppCycleTime();	/*联锁应用周期*/
-	UINT8 ci_zcPrtclVersion = 0u;
+	UINT8 ci_zcPrtclVersion = 0U;
-	UINT16 dstDevId = 0;
+	UINT16 dstDevId = 0U;
-	UINT8 outnetSafeSendRtn = 0u;
+	UINT8 outnetSafeSendRtn = 0U;
 	UINT8 CIName2HlhtId = 0U;
 	UINT8 ZCName2HlhtId = 0U;
 	UINT8 CiEmapCheckVer = 0U;
-	UINT32 dwHlhtHSrcSN = 0u;
+	UINT32 dwHlhtHSrcSN = 0U;
-	UINT32 dwHlhtHRcvSN = 0u;
+	UINT32 dwHlhtHRcvSN = 0U;
 	UINT16 totallenIndex = 0U;
 	UINT16 wCrossFrameLen = 0U;
 	UINT8 chDataType = 0U;
@@ -1104,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;
         }
@@ -1131,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);/*获取线路标识*/
 
@@ -1159,20 +1244,22 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 			}
 
 			totallenIndex = ii;
-			ii += 2u;/*通用报文头中的应用层报文总长度*/
+			ii += 2U;/*通用报文头中的应用层报文总长度*/
-			if (DATA_TYPE_MAIN_BRANCH == chDataType)
+
+			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]);	
@@ -1182,27 +1269,33 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 			{
 				/*通用应用层报文长度(0x202报文长度)*/
 				/*刨去2字节应用报文总长度+2字节0202帧长度*/
-				ShortToChar((ii - (totallenIndex + 4u)), &CiToZcDataBuffer[totallenIndex + 2u]);
+				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
 			{
-				/*nothing*/
+				/*23分支 nothing*/
 			}
 
 			/*通用报文头中应用层报文总长度*/
 			/*刨去2字节应用报文总长度*/
-			ShortToChar(ii - (totallenIndex + 2u), &CiToZcDataBuffer[totallenIndex]);
+			ShortToChar(ii - (totallenIndex + 2U), &CiToZcDataBuffer[totallenIndex]);
 
 			/*清ZC数据*/
 			ClearZcData();
 
-			dstDevId = (UINT16)(CI_SYSTEM_TYPE_ZC << 8) | ((UINT16)deviceId);
+			dstDevId = (UINT16)(CI_SYSTEM_TYPE_ZC << 8U) | ((UINT16)deviceId);
-			outnetSafeSendRtn = OutnetSafeSend(dstDevId, 0u, &CiToZcDataBuffer[0], ii);
+			outnetSafeSendRtn = OutnetSafeSend(dstDevId, 0U, &CiToZcDataBuffer[0U], ii);
-			if (1u == outnetSafeSendRtn)
+			if (1U == outnetSafeSendRtn)
 			{ /*写队列成功*/
 #ifdef LOGPRINT/*日志打印宏*/			
 #ifdef PLATFORM_2OO2/*2oo2平台打印*/
@@ -1300,7 +1393,7 @@ static UINT16 PackRcTacsCrossData(UINT8 *pDataBuf)
 			/*非法值防护*/
 			if ((0u < wSignalId) && (CROSS_SIGNAL_ID_MAX >= wSignalId)
 				&& (0u < wCrossTacsTrainId) && (TACS_CROSS_ID_MAX >= wCrossTacsTrainId)
-				&& (ALL_TACS_CROSS_SUM_MAX >= wTacsCrossTrainSum))
+				&& (ALL_TACS_CROSS_SUM_MAX > wTacsCrossTrainSum))
 			{
 				/*TACS主控列车ID有效，赋值至待发送数组*/
 				wTacsCrossSignalBuf[wTacsCrossTrainSum] = wSignalId;
@@ -1348,14 +1441,6 @@ static UINT16 PackRcTacsCrossData(UINT8 *pDataBuf)
 	/*最后赋值长度*/
 	ShortToChar((Index - 2u), &pDataBuf[0u]);
 
-	/*打印*/
-	debug_infor_printf((const)"SendTacsCross Len=%d:", Index);
-	for (i = 0u; i < Index; i++)
-	{
-		debug_infor_printf((const)"%x-", pDataBuf[i]);
-	}
-	debug_infor_printf((const)"\n");
-
 	return Index;
 }
 
@@ -1583,6 +1668,8 @@ static UINT8 ParseZcCbtcCrossData(UINT8* pDataBuf, UINT16 dataLen)
 	if (NULL != pDataBuf)
 	{
 		cRetVal = CI_SUCCESS;
+		ZcToCiDataStru.cRecvCbtcCrossFrameTag = CI_SUCCESS;
+
 		wCrossNum = pDataBuf[ii];
 		ii++;
 

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

@@ -66,6 +66,7 @@ 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*/

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

@@ -427,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文件指针
@@ -1068,5 +1054,39 @@ INT16 AxisSecCfgDtStruFromLogicSecStr(LogsecSwitchStruct* pSrcSwitchStructBuf, U
 * 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");
+			(void)printf("RciCommonConfigDataInit Error\n");
-			debug_infor_printf((const)"CiPattern Init Error\n");
+			debug_infor_printf((const)"RciCommonConfigDataInit Error\n");
 #endif
 		}
 	}
@@ -2379,9 +2379,6 @@ UINT8 ReadSystemParamConfDataNew(const UINT8 ciId,SystemParameterStructNew* Syst
 			/*一个临时限速报文中包含的最大限速区段数量*/
 			SystemParameterStru->MaxSectionOfTsr = dquCICfgDtStr.SystemParaStrNew.MaxSectionOfTsr;
 
-			/*IVOC-OC通信故障判断时间(ms)*/
-			SystemParameterStru->IvocOcCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.IvocOcCommunicationErrorTime;
-
 			/*OC-TSL通信故障判断时间（ms）*/
 			SystemParameterStru->OcTslCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.OcTslCommunicationErrorTime;
 
@@ -3424,8 +3421,8 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
 	UINT8 ciId;
 	UINT8 jj = 0U;
 	UINT8 chLocalCiId = 0U;
-
+	UINT16 k = 0U;
-
+	 
 	chLocalCiId = GetSystemParaLocalCiId();
 	if (NULL != emapVerArr)
 	{
@@ -3484,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)
 		{

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));
+						(void)memset(RelayData.pRelayScreenStr, 0x00, sizeof(Relay_ScreenStruct) * RelayDataLen.RelayScreenStrLen);
-						/*动态申请空间失败*/
+						/*解析数据到 默认行车序列 结构体数组 */
-						if (NULL == RelayData.pRelayScreenStr)
+						for (j = 0u; j < RelayDataLen.RelayScreenStrLen; j++)
 						{
-							RelayDataLen.RelayScreenStrLen = 0U;
+							pScreenStr = RelayData.pRelayScreenStr + j;
-							rtnValue = 0U;
-						}
-						else
-						{
-							/*内存先设为无效*/
-							(void)memset(RelayData.pRelayScreenStr, 0x00, sizeof(Relay_ScreenStruct) * RelayDataLen.RelayScreenStrLen);
-							/*解析数据到 默认行车序列 结构体数组 */
-							for (j = 0u; j < RelayDataLen.RelayScreenStrLen; j++)
-							{
-								pScreenStr = RelayData.pRelayScreenStr + j;
 
-								/*填充数据结构体*/
+							/*填充数据结构体*/
-								rtnValue &= R_ScreenStructFromChar(pDataAddr, pScreenStr, (UINT16)rowLen);								
+							rtnValue &= R_ScreenStructFromChar(pDataAddr, pScreenStr, (UINT16)rowLen);
-								pDataAddr += 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));
+					   (void)memset(LSData.pLSOverlapLockCondStru, 0x00, sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen);
-					   /*动态申请空间失败*/
+
-					   if (NULL == LSData.pLSOverlapLockCondStru)
+					   /*解析数据到 默认行车序列 结构体数组 */
+					   rtnValue = 1u;
+					   for (j = 0u; j < LSDataLen.LSOverlapLockCondStruLen; j++)
 					   {
-						   /*将数组长度清0，防护数组访问越界*/
+						   pTempLSProtSecLockCondStru = LSData.pLSOverlapLockCondStru + j;
-						   LSDataLen.LSOverlapLockCondStruLen = 0u;
 
-						   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)
+						(void)CommonMemCpy(&LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j], (UINT32)sizeof(SideProtecStru), &LSData.pLSRouteSideProtecStru[k], (UINT32)sizeof(SideProtecStru));
-						{
+						break;/*找到则跳出*/
-							CommonMemCpy(&LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j], sizeof(SideProtecStru), &LSData.pLSRouteSideProtecStru[k], sizeof(SideProtecStru));
-							break;/*找到则跳出*/
-						}
-						else
-						{
-							/*继续遍历*/
-						}
 					}
-					if (k == LSDataLen.LSRouteSideProtecStruLen)
+					else
 					{
-						rtnValue = 0u;
+						/*继续遍历*/
 					}
 				}
-				else
+				if (k == LSDataLen.LSRouteSideProtecStruLen)
 				{
-					break;
+					rtnValue = 0u;
 				}
 			}			
 		}

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

@@ -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/dqucijdqstru.h

@@ -108,7 +108,6 @@
 
 /*道岔配置表*/
 #define OC_SWITCH_ID	((UINT8)2)
-#define LEN_OC_SWITCH	((UINT8)25)
 #define SWITCH_BOARD_MODE_MAX  5U  /*一个OC中道岔最多的模块数*/
 /*道岔继电器配置表*/
 #define OC_SWITCH_RELAY_ID	((UINT8)4)

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);
+	ASSER_ERROR((NULL == pTemp) || (0U == pTemp->ACCnt), errorCode, 0x80000000U);
-
+	if(0U == errorCode)
-	headRelStaID = rrm_PrepareAtsLgcStaOfAC(pTemp->ACID[pTemp->ACCnt - 1U]);
+	{ 
-
+		headRelStaID = rrm_PrepareAtsLgcStaOfAC(pTemp->ACID[pTemp->ACCnt - 1U]);
-	ASSER_ERROR((0xffffU == headRelStaID), errorCode, 0x40000000U);
 
+		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)
 		{
-			/*
+			/* 通过检查 */
-			进路内所有道岔位置正确
+			reResult = 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;
-
-			}
 		}
 		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_SUCCESS == reResult)
-	{/*进路办理防护道岔检查*/
-		if (CI_TRADITION_RAILWAY == lineIdentity)
 		{
-			/*进路关联防护道岔【未引导总锁】*/
+			/*进路关联防护道岔位置正确或位置不正确但可动作*/
 			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;   /*进路当前总数(本联锁和相邻联锁发送给本联锁的进路总数),进路的特殊处理*/

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
+	{
+		/*不处理*/
+	}
 }
 
 /*

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

@@ -1618,7 +1618,8 @@ void ClearLgcSecResTrain(UINT16 wLogSecId)
 		/*清0防脏*/
 		for (ii = chNeedKeepSum; ii < LOGIC_SECTION_RES_SUM_MAX; ii++)
 		{
-			(void)ComMemSet((UINT8*)&(LogicSectionDataStruCC[wBufIndex].szTrainResData[ii]), (UINT16)sizeof(LogicTrainResStruct), 0U);
+			/*重置资源信息结构体*/
+			ResetResInfoStruct(wBufIndex, ii);
 		}
 		LogicSectionDataStruCC[wBufIndex].chTrainInfoSum = chNeedKeepSum;
 	}
@@ -2811,7 +2812,7 @@ UINT8 GetLogSecResShareFlag(const UINT16 wLgcSecId)
 		/*返回错误*/
 		funRetVal = CI_ERROR;
 	}
-	return funRetVal;
+	return LOGIC_SECTION_RES_SHARE_YES;
 }
 
 /*
@@ -2886,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
@@ -3805,7 +3806,9 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 			else
 			{
 				/** 设置跳跃锁闭允许标志为允许 */
+
 			
+				ClearLogSeceSwitchDanCaoPos(logSectionId);/*清除单操位置*/
 				/** 设置逻辑区段跳跃锁闭 */
 				SetLogSecJumpLockState(logSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
 
@@ -3815,9 +3818,13 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 				devState = 0u;
 				retVal = LogicSecRltvPrtctSwLockCheck(logSectionId, &devId, &devState);
 				if (CI_SUCCESS == retVal)
-				{
+				{/*防护道岔锁检查*/
 					SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
 				}
+				else
+				{
+					SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
+				}
 			
 			}
 		}
@@ -4985,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)
@@ -5003,9 +5010,10 @@ void SetLogSecLogLockState(const UINT16 wLogSectionId, const UINT8 chLogLockStat
 			else
 			{
 				LogicSectionDataStruCC[wBufIndex].chTrainInfoSum = 0U;
-				(void)CommonMemSet(LogicSectionDataStruCC[wBufIndex].szTrainResData, \
+				for(index = 0U; index < LOGIC_SECTION_RES_SUM_MAX; index++)
-					(UINT32)sizeof(LogicSectionDataStruCC[wBufIndex].szTrainResData), \
+				{
-					0U, (UINT32)sizeof(LogicSectionDataStruCC[wBufIndex].szTrainResData));
+					ResetResInfoStruct(wBufIndex, index);
+				}
 			}
 
 		}
@@ -5189,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)
@@ -5204,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
 			{
@@ -5719,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
@@ -6385,10 +6396,6 @@ UINT8 ReqAlignmentInfoCalc(void)
 			{
 				break;
 			}
-			else
-			{
-				/*¼ÌÐøÖ´ÐÐ*/
-			}
 		}
 	}
 	else
@@ -6613,4 +6620,35 @@ void SetSendAtsLgcArbState(void)
 			; /* 数据获取失败 */
 		}
 	}
-}
+}
+
+/*
+* 功能描述： 重置资源信息结构体
+* 参数说明： 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

@@ -1469,7 +1469,13 @@ void SetLogSecPbTacsArbState(const UINT16 wLgcId, const UINT8 chArb);
 * 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最大值*/

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

@@ -1726,3 +1726,39 @@ UINT8 GetSwitchWhetherBelongThisOc(UINT16 switchId, UINT8 ocId)
 	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

@@ -39,6 +39,7 @@ typedef struct S_SwitchBelongOCConfigDataStr/*
 	UINT8 chSwitchBoardNum; /*道岔板卡数*/
 	UINT8 ModuleAddr[MAX_OC_SWITCH_INCLUDE_BOARD_NUM];	/*地址ID*/
 	UINT8 szPlusBoxId;	/*转辙机板所在插箱ID*/
+	UINT16 wThisOcOtherSwitchId; /*同OC属于同板卡的另一道岔ID*/
 }SwitchBelongOCConfigDataStr;
 
 typedef struct S_SwitchConfigDataStruct
@@ -120,6 +121,7 @@ typedef struct S_OC_SwitchConfigDataStruct
 	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道岔配置数据表*/
@@ -670,6 +672,18 @@ UINT8 GetSwitchThisOcOtherOCId(const UINT16 switchId, const UINT8 ocId);
 * 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

@@ -1159,14 +1159,11 @@ void SetSwitchDrivePostion(const UINT16 switchId, const UINT8 drivePosition)
 	UINT8 singleSwitchCurPosition = 0U;
 	UINT16 switchOtherId = 0U;		/*双动道岔另一道岔ID*/
 	UINT8 ciPattern = GetLocalCiPattern();
-	UINT32 dwCurCycleNum = 0u;
 
 	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
 	switchOtherId = GetDSwitchOtherId(switchId);
     bufIndex2 = GetSwitchConfigBufIndex(switchOtherId);  /*获取双动道岔数组下标*/
 
-	dwCurCycleNum = Get2oo2CurCycleNum();
-
 	if (bufIndex < SWITCH_SUM_MAX)
 	{
 
@@ -1190,9 +1187,7 @@ void SetSwitchDrivePostion(const UINT16 switchId, const UINT8 drivePosition)
 					/*设置驱动位置*/
 					SwitchDataStru[bufIndex].SwitchDrivePos = drivePosition;
 					/*道岔驱动开始时间*/
-					SetSwitchDriveStartCycNum(switchId, dwCurCycleNum);
+					SetSwitchDriveStartCycNum(switchId, Get2oo2CurCycleNum());
-					/*设置道岔驱动起始周期，直到有位置时才清0*/
-					SetSwitchOutputDrvCmdCycNum(switchId, dwCurCycleNum);
 				}
 			}
 			else
@@ -1228,10 +1223,7 @@ void SetSwitchDrivePostion(const UINT16 switchId, const UINT8 drivePosition)
 						/*设置驱动位置*/
 						SwitchDataStru[bufIndex2].SwitchDrivePos = drivePosition;
 						/*道岔驱动开始时间*/
-						SetSwitchDriveStartCycNum(switchOtherId, dwCurCycleNum);
+						SetSwitchDriveStartCycNum(switchOtherId, Get2oo2CurCycleNum());
-
-						/*设置道岔驱动起始周期，直到有位置时才清0*/
-						SetSwitchOutputDrvCmdCycNum(switchOtherId, dwCurCycleNum);
 					}
 				}
 				else
@@ -3278,7 +3270,7 @@ void SetSwitchOcPlusBoxSateState(const UINT16 switchId, const UINT8 ocId, const
 
 	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
 	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
-	if ((SWITCH_SUM_MAX > bufIndex) && (chOCIndex < SWITCH_BELONG_OC_MAX))
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX >chOCIndex))
 	{	
 		SwitchDataStru[bufIndex].belongOCData[chOCIndex].PlusBoxSate = state;	
 	}
@@ -3306,7 +3298,7 @@ UINT8 GetSwitchOcPlusBoxSateState(const UINT16 switchId, const UINT8 ocId)
 
 	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
 	chOCIndex = GetSwitchThisOCIndex(switchId, ocId);
-	if ((SWITCH_SUM_MAX > bufIndex) && (chOCIndex < SWITCH_BELONG_OC_MAX))
+	if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_BELONG_OC_MAX > chOCIndex))
 	{
 		ret = SwitchDataStru[bufIndex].belongOCData[chOCIndex].PlusBoxSate;
 	}
@@ -3371,7 +3363,7 @@ UINT8  GetSwitchThisOCBoardState(const UINT16 switchId, const UINT8 ocId)
 	UINT8 num = 0u;
 	UINT8 i = 0u;
 	UINT8 chSwitchThisOCBoardNum = 0u;
-	UINT8 chOCIndex = 0U;
+	UINT8 chOCIndex = 0u;
 	UINT8 addrAState = 0u;
 	UINT8 addrBState = 0u;
 	UINT8 retVal = SWITCH_BOARD_FAULT;
@@ -3384,20 +3376,23 @@ UINT8  GetSwitchThisOCBoardState(const UINT16 switchId, const UINT8 ocId)
 		chSwitchThisOCBoardNum = GetSwitchThisOCBoardNum(switchId, ocId);
 		if (SWITCH_BELONG_OC_MAX > chOCIndex)
 		{
-			for (i = 0; i < (chSwitchThisOCBoardNum/2u); i+=2u)
+			if (0u < chSwitchThisOCBoardNum)
 			{
-				addrAState = SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[i];
+				retVal = SWITCH_BOARD_NORMAL;/*先置为正常*/
-				addrBState = SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[i+1];
+				for (i = 0u; i < (chSwitchThisOCBoardNum - 1u); i += 2u)
-				if ((SWITCH_BOARD_FAULT == addrAState) && (SWITCH_BOARD_FAULT == addrBState))
 				{
-					retVal = SWITCH_BOARD_FAULT;
+					addrAState = SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[i];
-					break;
+					addrBState = SwitchDataStru[bufIndex].belongOCData[chOCIndex].BoardStateBuf[i + 1u];
+					if ((SWITCH_BOARD_FAULT == addrAState) && (SWITCH_BOARD_FAULT == addrBState))
+					{
+						retVal = SWITCH_BOARD_FAULT;
+						break;
+					}
 				}
 			}
-
+			else
-			if ((0U < chSwitchThisOCBoardNum) && (i == chSwitchThisOCBoardNum))
+			{/*异常分支，置为故障*/
-			{
+				retVal = SWITCH_BOARD_FAULT;
-				retVal = SWITCH_BOARD_NORMAL;
 			}
 
 		}
@@ -3529,7 +3524,7 @@ void SetSwitchOutputDrvCmdCycNum(const UINT16 switchId, const UINT32 cycNum)
 {
 	UINT16 bufIndex = 0u;  /*数组下标*/
 	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
-	if (bufIndex < SWITCH_SUM_MAX)
+	if (SWITCH_SUM_MAX >bufIndex)
 	{
 		SwitchDataStru[bufIndex].SwitchOutputDrvCmdCycNum = cycNum;
 	}
@@ -3546,7 +3541,7 @@ UINT32 GetSwitchOutputDrvCmdCycNum(const UINT16 switchId)
 	UINT32 retVal = CI_ERROR;
 
 	bufIndex = GetSwitchConfigBufIndex(switchId);  /*获取道岔数组下标*/
-	if (bufIndex < SWITCH_SUM_MAX)
+	if (SWITCH_SUM_MAX > bufIndex)
 	{
 		retVal = SwitchDataStru[bufIndex].SwitchOutputDrvCmdCycNum;
 	}

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,10 +59,10 @@
 
 /*联锁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)2)	/*子系统回归版本号*/
+#define VER_RETURN_SUBCI_CI_CID			 ((UINT8)0)	/*子系统回归版本号*/
 
 #ifdef SCADE_MODE
 /*SCADE软件版本号*/
@@ -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)3) /*子版本号*/
+#define VER_SOFT_SUBVERSION         ((UINT8)1) /*子版本号*/
 
 #endif
 
 /*可兼容的公共数据结构版本号*/
 #define VER_1_PUBLIC_FS_1            ((UINT8)31)
-#define VER_1_PUBLIC_FS_2            ((UINT8)5)
+#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)23)
 #define VER_2_PUBLIC_FS_2            ((UINT8)2)
 #define VER_2_PUBLIC_FS_3            ((UINT8)1)
-#define VER_2_PUBLIC_FS_4            ((UINT8)5)
+#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)50)
+#define VER_1_PRIVATE_FS_1            ((UINT8)52)
 #define VER_1_PRIVATE_FS_2            ((UINT8)0)
 
 #define VER_2_PRIVATE_FS_1            ((UINT8)0xFF)

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

@@ -23,6 +23,8 @@ 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功能或者联锁联锁 */
@@ -1541,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)
@@ -2458,7 +2499,7 @@ UINT16 GetTiocSystemParameterData(UINT32* pConfigDataAdderBuf, UINT16* pConfigDa
 			;/* 无处理 */
 		}
 
-		/* RC/CI系统控制转辙机板主控切换间隔时间(单位：S)  */
+		/* RC/CI系统控制转辙机板主控切换间隔时间(单位：ms)  */
 		wTmpLen = 1u + wTmpConfigDataSum;
 		if (wBufMaxLen >= wTmpLen)
 		{
@@ -2470,7 +2511,7 @@ UINT16 GetTiocSystemParameterData(UINT32* pConfigDataAdderBuf, UINT16* pConfigDa
 		{
 			;/* 无处理 */
 		}
-		/* RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S) */
+		/* RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms) */
 		wTmpLen = 1u + wTmpConfigDataSum;
 		if (wBufMaxLen >= wTmpLen)
 		{
@@ -2907,7 +2948,7 @@ OtherCiParaStruct GetOtherCiPara(const UINT8 chOtherCiId)
 /*
 * 功能描述：获取无C轨站型B轨有UT车时可追踪功能开关
 * 参数说明：无
-* 返回值：aa关闭 55打开
+* 返回值：aa打开 55关闭
 * by cgh 20240815
 */
 UINT8 GetNoCGFollowUtSwitch(void)
@@ -3280,9 +3321,9 @@ UINT32 GetSwitchMachineCutInterval(void)
 	return wSwitchMachineCutInterval;
 }
 /*
-* 功能描述：获取RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)
+* 功能描述：获取RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
 * 参数说明：无
-* 返回值：RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)
+* 返回值：RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
 * by mpt 20260324
 */
 UINT32 GetSwitchMachineDrvCutInterval(void)
@@ -3325,3 +3366,152 @@ 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

@@ -108,6 +108,7 @@ extern "C" {
 #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)/*实际联锁集中站数量 编号*/
@@ -259,9 +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_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
 {
@@ -375,7 +382,6 @@ typedef struct S_SystemParaStruct
 	UINT8	MaxTsrSpeed;/*临时限速最高限速*/
 	UINT16	MaxTsrNum;/*一次设置临时限速的最大个数*/
 	UINT16	MaxSectionOfTsr;/*一个临时限速报文中包含的最大逻辑区段数量*/
-	UINT32	IvocOcCommunicationErrorTime;/*IVOC-OC通信故障判断时间(ms),add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT32	TmcOcCommunicationErrorTime;/*TMC-OC通信故障判断时间(ms),add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT32	OcTslCommunicationErrorTime;/*OC-TSL通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
 	UINT8 LinkLogicDirUpAndDown;   /*系统定义逻辑方向与上下行方向的关系,add by yt，2022年3月1日，适配车车系统配置数据*/
@@ -395,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;
 
@@ -418,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*/
@@ -506,6 +519,8 @@ 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    
@@ -1353,7 +1368,7 @@ OtherCiParaStruct GetOtherCiPara(const UINT8 chOtherCiId);
 /*
 * 功能描述：获取无C轨站型B轨有UT车是可追踪功能开关
 * 参数说明：无
-* 返回值：aa关闭 55打开
+* 返回值：aa打开 55关闭
 * by cgh 20240815
 */
 UINT8 GetNoCGFollowUtSwitch(void);
@@ -1544,9 +1559,9 @@ void SetCiFunctionSwitchConfig(UINT8 chFunctionConfigIndex, UINT8 chSwitchVal);
 */
 UINT32 GetSwitchMachineCutInterval(void);
 /*
-* 功能描述：获取RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)
+* 功能描述：获取RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
 * 参数说明：无
-* 返回值：RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)
+* 返回值：RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：ms)
 * by mpt 20260324
 */
 UINT32 GetSwitchMachineDrvCutInterval(void);
@@ -1569,6 +1584,57 @@ UINT8 SetLocalCiOCSswitch(UINT8 funSwitch);
 * 返回值：本联锁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
 }

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

@@ -185,6 +185,12 @@ static void SetTrainAtsScreenProc(void);
 */
 static UINT32 GetTrainTransBadCyc(const UINT16 wTrainId);
 
+/*
+* 功能描述： 获取指定列车通信(IVOC)中断周期号
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ： 列车通信中断周期号
+*/
+static UINT32 GetTrainIvocTransBadCyc(const UINT16 wTrainId);
 /*
 * 功能描述： 设置指定列车包络能否转为UCT
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -536,6 +542,33 @@ UINT8 GetTrainTransitmitStat(const UINT16 wTrainId)
 	return chRetVal;
 }
 
+
+/*
+* 功能描述： 获取指定列车(IVOC)通信状态
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ： 0: 获取数据失败
+*			 0x55: 通信状态良好
+*			 0xAA: 丢失通信
+*			 0xFF: 通信状态未知
+* 创建: qw.liu 2022-02-24
+*/
+UINT8 GetTrainIvocTransitmitStat(const UINT16 wTrainId)
+{
+	UINT8 chRetVal = CI_ERROR;
+	UINT16 wBufIndex = 0U;
+
+	wBufIndex = GetTrainBufIndex(wTrainId);
+	if (TRAIN_SUM_MAX > wBufIndex)
+	{
+		chRetVal = gstTrainInfo[wBufIndex].chIvocTransmitStat;
+	}
+	else
+	{
+		chRetVal = CI_ERROR;
+	}
+
+	return chRetVal;
+}
 /*
 * 功能描述： 获取指定列车等级
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -1086,6 +1119,47 @@ UINT8 SetTrainTransmitStat(const UINT16 wTrainId,const UINT8 chTrainmitStat)
 	return chRetVal;
 }
 
+
+/*
+* 功能描述： 设置指定列车(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)
+{
+	UINT8 chRetVal = CI_ERROR;
+	UINT16 wBufIndex = 0U;
+
+	wBufIndex = GetTrainBufIndex(wTrainId);
+	if (TRAIN_SUM_MAX > wBufIndex)
+	{
+		if ((TRAIN_COMM_STATE_GOOD == chTrainmitStat)
+			|| (TRAIN_COMM_STATE_BAD == chTrainmitStat)
+			|| (TRAIN_COMM_STATE_UNKNOWN == chTrainmitStat))
+		{
+			gstTrainInfo[wBufIndex].chIvocTransmitStat = chTrainmitStat;
+
+			gstTrainInfo[wBufIndex].dwIvocTransBadCyc = Get2oo2CurCycleNum();
+			chRetVal = CI_SUCCESS;
+		}
+		else
+		{
+			chRetVal = CI_ERROR;
+		}
+	}
+	else
+	{
+		chRetVal = CI_ERROR;
+	}
+
+	return chRetVal;
+}
 /*
 * 功能描述： 设置指定列车运行等级
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -2869,6 +2943,7 @@ static void CalTrainSafePosition(void)
 			chResult &= SetTrainSafeHeadOffset(wTrainId, UINT32_MAX);
 			chResult &= SetTrainSafeTailLink(wTrainId, 0u);
 			chResult &= SetTrainSafeTailOffset(wTrainId, UINT32_MAX);
+			SetTrainMinSafeHead(wTrainId, 0u, UINT32_MAX, 0u);
 			if (CI_ERROR == chResult)
 			{
 				; /*暂不处理*/
@@ -3091,7 +3166,6 @@ UINT8 dsuTrainCrossSignal(const UINT16 wTrainId, const UINT16 wRouteId)
 	UINT16 wEndSignal = 0u;
 	struct_PathPoint strTrainMaxHead = { 0u };
 	struct_PathPoint strTrainMinTail = { 0u };
-	struct_PathPoint strTrainSafeMinHead = { 0u };
 	str_Zone strRouteZone = { 0u };
 	UINT8 chRtnVal = CI_ERROR;
 	str_PointInArea strRouteSwitch = { 0u };
@@ -3124,8 +3198,6 @@ UINT8 dsuTrainCrossSignal(const UINT16 wTrainId, const UINT16 wRouteId)
 	strTrainZone.pStart.dwOffset = strTrainMinTail.dwOffset;
 	strTrainZone.pEnd.wLinkId = strTrainMaxHead.wLinkId;
 	strTrainZone.pEnd.dwOffset = strTrainMaxHead.dwOffset;
-	strTrainSafeMinHead.wLinkId = GetTrainMinSafeHeadLink(wTrainId);
-	strTrainSafeMinHead.dwOffset = GetTrainMinSafeHeadOffset(wTrainId);
 	
 	chSwitchNum = GetRouteSwitchSum(wRouteId);
 	pRouteSwitch = GetRouteSwitchData(wRouteId);
@@ -3145,7 +3217,6 @@ UINT8 dsuTrainCrossSignal(const UINT16 wTrainId, const UINT16 wRouteId)
 		chRtnVal &= CheckLinkValid(strTrainMinTail.wLinkId, strTrainMinTail.dwOffset);
 		chRtnVal &= CheckLinkValid(strRouteZone.pStart.wLinkId, strRouteZone.pStart.dwOffset);
 		chRtnVal &= CheckLinkValid(strRouteZone.pEnd.wLinkId, strRouteZone.pEnd.dwOffset);
-		chRtnVal &= CheckLinkValid(strTrainSafeMinHead.wLinkId, strTrainSafeMinHead.dwOffset);
 	}
 	else
 	{
@@ -4325,6 +4396,7 @@ void NeighborOutTrainProc(UINT8 chTiocId)
 		{
 			SetTrainMsgFromTiocId(wTrainId, 0u);
 			(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
+			(void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
 		}
 		else
 		{
@@ -4381,6 +4453,7 @@ void NeighborGoodTrainProc(UINT8 chTiocId)
 			{
 				SetTrainMsgFromTiocId(wTrainId, 0u);
 				(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
+				(void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
 			}
 			else
 			{
@@ -6458,6 +6531,28 @@ static UINT32 GetTrainTransBadCyc(const UINT16 wTrainId)
 	return dwRetVal;
 }
 
+/*
+* 功能描述： 获取指定列车通信(IVOC)中断周期号
+* 参数说明： const UINT16 wTrainId, 列车ID
+* 返回值  ： 列车通信中断周期号
+*/
+static UINT32 GetTrainIvocTransBadCyc(const UINT16 wTrainId)
+{
+	UINT32 dwRetVal = 0u;
+	UINT16 wBufIndex = 0U;
+
+	wBufIndex = GetTrainBufIndex(wTrainId);
+	if (TRAIN_SUM_MAX > wBufIndex)
+	{
+		dwRetVal = gstTrainInfo[wBufIndex].dwIvocTransBadCyc;
+	}
+	else
+	{
+		;
+	}
+
+	return dwRetVal;
+}
 /*
 * 功能描述： 获取指定列车反馈区间疏散数量
 * 参数说明： const UINT16 wTrainId, 列车ID
@@ -7724,8 +7819,8 @@ UINT8 GetTrainResRecycleOTStat(const UINT16 wTrainId)
 	wBufIndex = GetTrainBufIndex(wTrainId);
 	if (TRAIN_SUM_MAX > wBufIndex)
 	{
-		trainTransimitStat = GetTrainTransitmitStat(wTrainId);
+		trainTransimitStat = GetTrainIvocTransitmitStat(wTrainId);
-		trainLoseCommCyc = GetTrainTransBadCyc(wTrainId);
+		trainLoseCommCyc = GetTrainIvocTransBadCyc(wTrainId);
 
 		/*列车通信不好*/
 		if (TRAIN_COMM_STATE_BAD == trainTransimitStat)
@@ -12905,6 +13000,7 @@ void InputMainTrainInformation(UINT16 wTrainId)
 				if (TRAIN_COMM_STATE_GOOD == chTransmitStat)
 				{
 					(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
+					(void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
 					SetTrainLevel(wTrainId, TRAIN_LEVEL_UR); 
 				}
 				else
@@ -13755,7 +13851,6 @@ static void DoubleTrianComStateJuge(const UINT16 wTrainId, const UINT8 chComBadF
 
 	chIvocCtxValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_IVOC, (UINT8)wTrainId);
 	chVobcCtxValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_VOBC, (UINT8)wTrainId);
-	trainMsgFromTiocId = GetTrainMsgFromTiocId(wTrainId);
 	
 	/*根据双车计算通信状态*/
 	if ((CI_ERROR == chIvocCtxValid) && (CI_ERROR == chVobcCtxValid))
@@ -13768,6 +13863,7 @@ static void DoubleTrianComStateJuge(const UINT16 wTrainId, const UINT8 chComBadF
 			if (0u == trainMsgFromTiocId)
 			{
 				(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
+				(void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
 			}
 			else
 			{/*什么也不执行*/
@@ -13779,6 +13875,19 @@ static void DoubleTrianComStateJuge(const UINT16 wTrainId, const UINT8 chComBadF
 		if (0U == chComBadFlag)
 		{/*前面没设置通信中断*/
 			(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_GOOD);
+			if (CI_SUCCESS == chIvocCtxValid)
+			{
+				(void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_GOOD);
+			}
+		}
+
+		if (CI_ERROR == chIvocCtxValid)
+		{
+			chTransmitStat = GetTrainIvocTransitmitStat(wTrainId);
+			if (TRAIN_COMM_STATE_GOOD == chTransmitStat)
+			{
+				(void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD);
+			}
 		}
 
 	}

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

@@ -227,6 +227,7 @@ typedef struct S_TrainInfoStru
 	UINT16  wTrainSpeed;                /*速度*/
 	UINT8	chTrainZeroState;			/*列车零速状态*/
 	UINT8	chTransmitStat;				/*与列车传输状态*/
+	UINT8   chIvocTransmitStat;			/*与IVOC列车传输状态*/
 	UINT8	chHeadScreenStat;			/*列车前筛标志*/
 	UINT8	chTailScreenStat;			/*列车后筛标志*/
 	TrainSafeLocStru strSafeLoc;		/*列车安全位置*/
@@ -252,6 +253,7 @@ typedef struct S_TrainInfoStru
 	UINT8 chStopSteadyState;			/*列车停准停稳状态*/
 	UINT8 chSleepCancleFlag;			/*清除休眠车标志*/
 	UINT32 dwTransBadCyc;				/*通信中断周期*/
+	UINT32 dwIvocTransBadCyc;				/*通信中断周期*/
 	UINT8 chEaNum;						/*通信列车回复的区间疏散数量*/
 	TrainEaStru strTrainEaInfo[EA_MAX_NUM];			/*列车恢复区间疏散信息*/
 	UINT8 chEaCmd;						/*区间疏散命令*/
@@ -436,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
@@ -595,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

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

@@ -14,7 +14,7 @@
 
 
 WashMachineDataStruct WashMachineDataStru[WASHMACHINE_SUM_MAX];       /*定义洗车机数据结构体*/
-
+UINT8 RouteDriveIntoResult = CI_ERROR;    /*判断进路是否有车驶入过*/
 
 /*
 * 功能描述： 获取指定ID洗车机数据

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

@@ -75,6 +75,7 @@ typedef struct S_WashMachineDataStruct
 
 
 extern WashMachineDataStruct WashMachineDataStru[WASHMACHINE_SUM_MAX];       /*定义洗车机数据结构体*/
+extern UINT8 RouteDriveIntoResult;    /*判断进路是否有车驶入过*/
 /*
 * 功能描述： 获取指定ID洗车机数据
 * 参数说明： 

TSCP/src/dqu_common/dqu_cbtc_common/dquCbtcConfigData.c

@@ -55,8 +55,10 @@ UINT8 dfsInitSubSystemCommonConfigData_DG(UINT8 *pDataAddr, UINT32 dataSize, UIN
 #endif
 /*初始化[各子系统公用数据配置]-CC(要求有且仅有1行数据)*/
 UINT8 dfsInitSubSystemCommonConfigData_CC(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount);
+#if 0
 /*车辆段配置数据结构体4-FAO ，互联互通与此版本一至*/
 UINT8 dfsInitTrainDepotConfigData(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount);
+#endif
 /* 边界计轴区段配置数据结构体 */
 UINT8 dfsInitBoundaryAxleConfigData(UINT8* pDataAddr, UINT32 dataSize, UINT16 rowCount);
 /*初始化[出入段线脱轨防护区域表]*/
@@ -76,7 +78,7 @@ static INIT_TASK_TAB_STRU g_struInitTaskTab[]=
 	{DQU_QFUN_TRUE, CBTC_CONFIG_DATA_ID,		 NULL,									5,1,0},
 	{DQU_QFUN_TRUE, CBTC_CONFIG_DATA_ID,		 dfsInitSubSystemCommonConfigData_HLT,	5,1,0},
 	{DQU_QFUN_TRUE, CBTC_CONFIG_DATA_ID,		 NULL,									5,1,0},
-	{DQU_QFUN_TRUE, CBTC_CONFIG_DEPOT_ID,		 dfsInitTrainDepotConfigData,			5,1,0},	
+	{DQU_QFUN_TRUE, CBTC_CONFIG_DEPOT_ID,		 NULL,									5,1,0},	
 	{DQU_QFUN_TRUE, CBTC_CONFIG_DATA_ID,		 dfsInitSubSystemCommonConfigData_CC,	5,1,0},
 	{DQU_QFUN_TRUE, CBTC_CONFIG_BOUNDARY_AXLE_ID,dfsInitBoundaryAxleConfigData,			5,1,0},
 	{DQU_QFUN_TRUE, CBTC_SPECIAL_EA_ID,          dfsInitSpecialEaConfigData,			5,1,0},
@@ -180,10 +182,11 @@ static UINT8 initConfigCbtcInfoTaskTab(void)
 		}
 		else
 		{
-			g_struInitTaskTab[2].bIsEffective = DQU_QFUN_FASLE;/*主线默认不执行，各子系统公用数据配置结构体3-CPK*/
+			g_struInitTaskTab[2].bIsEffective = DQU_QFUN_FASLE;	/*主线默认不执行，各子系统公用数据配置结构体3-CPK*/
-			g_struInitTaskTab[3].bIsEffective = DQU_QFUN_FASLE;/*主线默认不执行，各子系统公用数据配置结构体3-FAO*/
+			g_struInitTaskTab[3].bIsEffective = DQU_QFUN_FASLE;	/*主线默认不执行，各子系统公用数据配置结构体3-FAO*/
-			g_struInitTaskTab[4].bIsEffective = DQU_QFUN_FASLE;/*主线默认不执行，各子系统公用数据配置结构体3-HLT*/
+			g_struInitTaskTab[4].bIsEffective = DQU_QFUN_FASLE;	/*主线默认不执行，各子系统公用数据配置结构体3-HLT*/
-			g_struInitTaskTab[5].bIsEffective = DQU_QFUN_FASLE;/*主线默认不执行，各子系统公用数据配置结构体3-DG*/
+			g_struInitTaskTab[5].bIsEffective = DQU_QFUN_FASLE;	/*主线默认不执行，各子系统公用数据配置结构体3-DG*/
+			g_struInitTaskTab[6].bIsEffective = DQU_QFUN_FASLE;	/*主线默认不执行，车辆段配置*/
 		}
 		rtnValue = 1u;
 	}
@@ -320,10 +323,10 @@ UINT8 dfsInitTrainModelConfigData(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowC
 					|| ((0x3du == CI_SYSTEM_TYPE_RCI) && (0x10u == (UINT8)(tempTrainName >> 8u))))
 				{
 					/*CI只初始化0x14类型的車，RC只初始化0x10类型的車*/
-					g_pCbtcConfigDataStru->cbtcTrainTypeConfig[i].TrainName = ShortFromChar(pData);
+					g_pCbtcConfigDataStru->cbtcTrainTypeConfig[TrainCount].TrainName = ShortFromChar(pData);
 					pData += 2u;
 
-					g_pCbtcConfigDataStru->cbtcTrainTypeConfig[i].TrainType = *pData;
+					g_pCbtcConfigDataStru->cbtcTrainTypeConfig[TrainCount].TrainType = *pData;
 					pData += 1u;
 
 					TrainCount += 1u;
@@ -340,8 +343,16 @@ UINT8 dfsInitTrainModelConfigData(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowC
 			/*nothing*/
 		}
 
-		g_pCbtcConfigDataStru->TrainTypeConfigLen = (UINT32)TrainCount;
+		if (200u >= TrainCount)
-		rtnValue = 1u;
+		{
+			g_pCbtcConfigDataStru->TrainTypeConfigLen = (UINT32)TrainCount;
+			rtnValue = 1u;
+		}
+		else
+		{
+			/*车数超过限制，返回失败*/
+			rtnValue = 0U;
+		}
 	}
 	else
 	{
@@ -1086,8 +1097,7 @@ UINT8 dfsInitSubSystemCommonConfigData_CC(UINT8 *pDataAddr, UINT32 dataSize, UIN
 		g_pCbtcConfigDataStru->cbtcConfigData.TmcOcCommunicationErrorTime = LongFromChar(pDataAddr);
 		pDataAddr += 4u;
 
-		/*IVOC-RC通信故障判断时间（ms）*/
+		/*IVOC-RC通信故障判断时间（ms），跳过，使用CI-VOBC的*/
-		g_pCbtcConfigDataStru->cbtcConfigData.IvocOcCommunicationErrorTime = LongFromChar(pDataAddr);
 		pDataAddr += 4u;
 
 		/*RC-TSL通信故障判断时间（ms）*/
@@ -1109,7 +1119,7 @@ UINT8 dfsInitSubSystemCommonConfigData_CC(UINT8 *pDataAddr, UINT32 dataSize, UIN
 		g_pCbtcConfigDataStru->cbtcConfigData.cAwakeCheckSpksSwitch = *pDataAddr;  /*唤醒过程中检查SPKS状态开关*/
 		pDataAddr += 1U;
 
-		g_pCbtcConfigDataStru->cbtcConfigData.dwVobcCiackUpCommErrorTime = LongFromChar(pDataAddr);  /*RC与IVOC后备通道通信故障判断时间*/
+		/*RC与IVOC后备通道通信故障判断时间，跳过，统一使用VOBC的*/
 		pDataAddr += 4U;
 
 		g_pCbtcConfigDataStru->cbtcConfigData.cHitSoftWallSwitch = *pDataAddr;  /*撞软墙功能开关*/
@@ -1132,7 +1142,7 @@ UINT8 dfsInitSubSystemCommonConfigData_CC(UINT8 *pDataAddr, UINT32 dataSize, UIN
 	return rtnValue;
 }
 
-
+#if 0
 /**********************************************
 函数功能：初始化[车辆段配置信息]
 输入参数：pDataAddr:表数据首地址
@@ -1181,7 +1191,7 @@ UINT8 dfsInitTrainDepotConfigData(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowC
 	}
 	return rtnValue;
 }
-
+#endif
 /*-----------------------------数据查询接口函数-----------------------*/
 
 /*设置当前查询函数据源*/
@@ -1285,7 +1295,7 @@ UINT8 dquGetCbtcConfigData (CBTC_CONFIG_DATA_STRU* pCbtcConfigDataStru)
 	}
 	return rtnValue;
 }
-
+#if 0
 /*********************************************
 *函数功能：获得车辆段配置信息
 *输入参数：无
@@ -1323,7 +1333,7 @@ UINT8 dquGetCbtcDepotInfo(CBTC_DEPOT_INFO_STRU *pCbtcDepotInfo, UINT16 *Length)
 
 	return rtnValue;
 }
-
+#endif
 /**********************************************
 * 函数功能：初始化[边界计轴区段配置]-CC
 * 输入参数：pDataAddr: 表数据首地址

TSCP/src/dqu_common/dqu_cbtc_common/dquCbtcConfigData.h

@@ -67,7 +67,6 @@ extern "C" {
 		UINT32	dwLineMinTrainLength;				/*系统配置数据，线路最小车长*/
 		UINT8	chWLSFunSwitch;						/* 是否支持全线免筛功能，0x55 不支持 0xAA支持 */
 		UINT32	TmcOcCommunicationErrorTime;		/*TMC-OC通信故障判断时间(ms),add by yt，2022年3月1日，适配车车系统配置数据*/
-		UINT32	IvocOcCommunicationErrorTime;		/*IVOC-OC通信故障判断时间(ms),add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT32	OcTslCommunicationErrorTime;		/*OC-TSL通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT32	MaxMALength;						/*线路最差情况下紧急制动距离（单位m）,add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT8	chDynamicTestSwitch;				/*是否支持动态测试开关 配置中 aa关闭 55打开*/
@@ -153,10 +152,10 @@ extern "C" {
 
 		CBTC_TRAIN_INFO_STRU   cbtcTrainInfo[10];                 /*列车性能参数配置结构体数组，初始化函数完成填充*/
 		UINT32   TrainInfoLen;									 /*数组长度*/
-
+#if 0
 		CBTC_DEPOT_INFO_STRU   cbtcDepotInfo[10];                 /*车辆段配置信息结构体数组，初始化函数完成填充*/
 		UINT32   DepotConfigLen;								/*数组长度*/
-
+#endif
 		CBTC_CONFIG_DATA_STRU  cbtcConfigData;                   /*各子系统公用数据配置结构体数组，初始化函数完成填充*/
 
 		CBTC_BOUNDARY_AXLE_CONFIG_STRU cbtcBoundaryAxleInfo[100];  /*边界计轴区段配置信息结构体数组，初始化函数完成填充*/
@@ -199,7 +198,7 @@ extern "C" {
 	/*获取各子系统公用数据配置表*/
 	UINT8 dquGetCbtcConfigData (CBTC_CONFIG_DATA_STRU* pCbtcConfigDataStru);
 	
-
+#if 0
 	/*
 	函数功能：获得车辆段配置信息
 	输入参数：无
@@ -207,7 +206,7 @@ extern "C" {
 					Length配置信息数量
 	返回值： 0失败 1成功 */
 	UINT8 dquGetCbtcDepotInfo(CBTC_DEPOT_INFO_STRU *pCbtcDepotInfo, UINT16 *Length);
-	
+#endif
 	
 #ifdef __cplusplus
 }

TSCP/src/dqu_common/dqu_emap_common/dquEmapInit.c

@@ -86,6 +86,48 @@ UINT16  wMiddleLinkId[MIDDLE_LINK_MAX_NUM];
 ************************************/
 static UINT8 AxleSgmtStru_CC();
 
+/*根据版本配置数据处理过程函数
+**修改记录：
+**1、依据互联互通数据结构V18.0.0修改，m by sds 20200211
+**2、修改不需要初始化的表格信息项 m by sds 2020-8-19
+**3、增加车车初始化的表格信息 m by qw.liu 2022-2-22
+*/
+static UINT8 initConfigEmapTaskTab();
+
+/*********************************************
+*函数功能：进路表数据结构
+*参数说明：无
+*返回值：0，失败；1，成功
+UINT16  wIncludeAxleSgmtNum;				进路包含的计轴区段数目
+UINT16  wIncludeAxleSgmtId[8];				包含的计轴区段编号
+UINT16  wAxleSgmtLockStatus[8];				包含的计轴区段锁闭状态
+
+UINT16  wObsNum;							进路包含障碍物数目
+UINT16  wObsType[8];							障碍物类型
+UINT16  wObsID[8];								障碍物ID
+UINT16	wObsNeedLockStatus[8];					障碍物需要联锁状态
+备注：内部调用函数，合库、燕房、单轨使用
+*********************************************/
+static UINT8 RouteStru_DFT();
+
+/*********************************************
+*函数功能：进路表数据结构
+*参数说明：无
+*返回值：0，失败；1，成功
+UINT16  wIncludeAxleSgmtNum;				进路包含的计轴区段数目
+UINT16  wIncludeAxleSgmtId[8];				包含的计轴区段编号
+UINT16  wAxleSgmtLockStatus[8];				包含的计轴区段锁闭状态
+
+UINT16  wObsNum;							进路包含障碍物数目
+UINT16  wObsType[8];							障碍物类型
+UINT16  wObsID[8];								障碍物ID
+UINT16	wObsNeedLockStatus[8];					障碍物需要联锁状态
+备注：内部调用函数，互联互通使用
+修改记录:
+1、更新进路范围内CBTC接近区段的范围判断 使用宏值信息替代，防止遗忘更新,不修复编码规范问题 m by sds 2020-8-21
+*********************************************/
+static UINT8 RouteStru_CC();
+
 /*
 函数功能：删除数组中重复的数，内部使用函数
 参数说明：输入参数：input 输入数组；len 输入数组大小；
@@ -93,7 +135,7 @@ static UINT8 AxleSgmtStru_CC();
 返回值：去重后数组的长度
 author: qxt 20180716
 */
-static UINT8 RemoveRep(UINT16 input[],UINT8 len,UINT16 output[]);
+static UINT16 RemoveRep(UINT16 input[],UINT16 len,UINT16 output[]);
 /*----------内部函数声明结束--------------*/
 
 
@@ -577,7 +619,6 @@ void SetFilterStopPointAttr(UINT32 filterAttr)
 UINT8 dfsEmapInitExp(UINT8 *pDataBuf,DSU_EMAP_STRU *dsuEmapStru,DSU_STC_LIMIT_LINKIDX_STRU *dsuLimitStcLinkIdx,UINT8 mode,UINT16 timeSlice)
 {
 	UINT32 DataID=0U;
-	UINT16 wPos=0U;
 	UINT8 rtnValue=2U;
 	UINT16 wFreqTimes=0U;
 	UINT8 bExeState=DQU_QFUN_FASLE;
@@ -6402,7 +6443,6 @@ static UINT8 LogicSgmtStru_CC(void)
 {
 	UINT16 ii = UINT16_MAX;                              /*循环变量*/
 	UINT16 jj = UINT16_MAX;                              /*循环变量*/
-	UINT16 nn = UINT16_MAX;                              /*循环变量*/
 	UINT16 kk = UINT16_MAX; 
 	DSU_LOGIC_SGMT_STRU  * pTempLogicSgmtStru = NULL;    /*临时变量*/
 	DSU_AXLE_SGMT_STRU  *pTempAxleSgmtStru = NULL;       /*临时变量*/
@@ -6547,7 +6587,7 @@ static UINT8 LogicSgmtStru_CC(void)
 
 					if ((UINT32_MAX != dwLen) && (MAX_LOGSEC_INCLUDE_LINK_NUM >= wlinkNum))
 					{
-						linkInfo.cLinkCnt = wlinkNum;
+						linkInfo.cLinkCnt = (UINT8)wlinkNum;
 
 						for (mm = 0U; mm < wlinkNum; mm++)
 						{
@@ -7957,7 +7997,6 @@ UINT8 GetPointInfoFromAccessLink(UINT16 AccessLinkId, UINT16 Dirction, UINT16*
 	DSU_CBTC_ACCESS_LINK_STRU*  pCBTCAccessLinkStru=NULL;    /*临时变量*/
 	UINT16 i, j = 0;                                       /*循环变量*/
 	DSU_LOGIC_SGMT_STRU*  pLogicSgmtStru=NULL;               /*临时变量*/
-	DSU_AXLE_SGMT_STRU*  pAxleSgmtStru=NULL;                 /*临时变量--计轴区段*/
 	UINT8 rtnValue = 0U;
 
 	/*电子地图数据*/
@@ -12497,13 +12536,10 @@ UINT8 initRC(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 	UINT8 rtnValue = 2U;
 	UINT8 *pData = NULL;
 	UINT8 initFlag = 0U;
-	UINT8 checkFlag = 0U;
 	DSU_CI_STRU *pCurrentStru = NULL; /*结构体临时指针变量*/
 	DSU_CI_STRU stru = { 0 };   			/*结构体临时指针变量*/
 	UINT16 j = 0U;
 	static UINT32 rowDataLen = 0U;
-	UINT16 wStruDataLen = 0U;
-	UINT16 wDataIndexLen = 0U;
 
 	/*电子地图数据*/
 	DSU_EMAP_INDEX_STRU *dsuEmapIndexStru = NULL;
@@ -12552,6 +12588,70 @@ UINT8 initRC(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 
 	initFlag = EmapInitFunStepCtrl(0x02);
 	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
+	{
+		/*降低复杂度*/
+		rtnValue = initRCSndStep(dsuEmapIndexStru, dsuStaticHeadStru, dsuDataLenStru);
+	}
+
+	initFlag = EmapInitFunStepCtrl(0x03);
+	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
+	{
+		/*解析数据到 结构体数组 */
+		for (j = g_struInitTaskTab[g_wCurInitStruProg].wCurInitPos; j < dsuDataLenStru->wRCLen; j++)
+		{
+			pCurrentStru = dsuStaticHeadStru->pRCStruStru + j;
+
+			pData = pDataAddr + rowDataLen*j;
+			/*填充数据结构体*/
+			initFlag = RC_STRU_init(pData, pCurrentStru);
+			if (0U == initFlag)
+			{
+				/*init函数参数空指针*/
+				rtnValue = 0U;
+			}
+			else
+			{
+				/*完成对应填充索引*/
+				dsuEmapIndexStru->dsuRCIndex[pCurrentStru->wIndex] = j;
+				initFlag = EmapInitLoopStepLenCtrl(j);
+			}
+			/*循环分步切割处理*/
+			if ((0U == rtnValue) || (DQU_QFUN_TRUE == initFlag))
+			{
+				break;
+			}
+		}
+
+		if ((0U != rtnValue) && (j == dsuDataLenStru->wRCLen))
+		{
+			rtnValue = 1;
+		}
+	}
+
+	return rtnValue;
+}
+
+/**********************************************
+函数功能：初始化[电子地图-RC表信息]:计算索引---拆分复杂度使用
+输入参数：无
+输出参数：
+电子地图数据
+DSU_EMAP_INDEX_STRU *dsuEmapIndexStru
+DSU_STATIC_HEAD_STRU *dsuStaticHeadStru
+DSU_DATA_LEN_STRU *dsuDataLenStru
+返回值:2处理中,0失败
+**********************************************/
+UINT8 initRCSndStep(DSU_EMAP_INDEX_STRU *dsuEmapIndexStru, DSU_STATIC_HEAD_STRU *dsuStaticHeadStru, DSU_DATA_LEN_STRU *dsuDataLenStru)
+{
+	UINT8 rtnValue = 2U;
+	UINT16 wStruDataLen = 0;
+	UINT16 wDataIndexLen = 0;
+	UINT8 checkFlag = 0U;
+	if ((NULL == dsuEmapIndexStru) || (NULL == dsuStaticHeadStru) || (NULL == dsuDataLenStru))
+	{
+		rtnValue = 0U;
+	}
+	else
 	{
 		if (0x01 == g_IsEmapAllocMemory)
 		{
@@ -12608,42 +12708,6 @@ UINT8 initRC(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 			}
 		}
 	}
-
-	initFlag = EmapInitFunStepCtrl(0x03);
-	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
-	{
-		/*解析数据到 结构体数组 */
-		for (j = g_struInitTaskTab[g_wCurInitStruProg].wCurInitPos; j < dsuDataLenStru->wRCLen; j++)
-		{
-			pCurrentStru = dsuStaticHeadStru->pRCStruStru + j;
-
-			pData = pDataAddr + rowDataLen*j;
-			/*填充数据结构体*/
-			initFlag = RC_STRU_init(pData, pCurrentStru);
-			if (0U == initFlag)
-			{
-				/*init函数参数空指针*/
-				rtnValue = 0U;
-			}
-			else
-			{
-				/*完成对应填充索引*/
-				dsuEmapIndexStru->dsuRCIndex[pCurrentStru->wIndex] = j;
-				initFlag = EmapInitLoopStepLenCtrl(j);
-			}
-			/*循环分步切割处理*/
-			if ((0U == rtnValue) || (DQU_QFUN_TRUE == initFlag))
-			{
-				break;
-			}
-		}
-
-		if ((0U != rtnValue) && (j == dsuDataLenStru->wRCLen))
-		{
-			rtnValue = 1;
-		}
-	}
-
 	return rtnValue;
 }
 
@@ -16032,12 +16096,9 @@ UINT8 GetDeviceInfoInLink()
 
 	DSU_LINK_STRU *pLinkStru=NULL; /*Link临时变量结结构体*/
 	DSU_SIGNAL_STRU *pSignalStru=NULL; /*信号机临时变量结构体*/
-	DSU_BALISE_STRU *pBaliseStru=NULL; /*应答器临时变量结结构体*/
 	DSU_SCREEN_STRU *pScreenStru=NULL; /*安全屏蔽门临时变量结结构体*/
 	DSU_EMERG_STOP_STRU *pESBStru=NULL;/*紧急停车按钮临时变量结结构体*/
 	DSU_STATION_STRU *pStationStru=NULL;/*停车区域临时变量结结构体*/
-	DSU_STOPPOINT_STRU *pStopPointStru=NULL;/*停车点临时变量结结构体*/
-	DSU_PLAT_FORM_STRU *pPlatformStru=NULL;/*站台临时变量结结构体*/
 
 	DSU_DEVICE_IN_LINK_STRU *pTempDeviceStru=NULL;
 
@@ -16564,29 +16625,29 @@ UINT8 GetGradeInfoCrossLink()
 返回值：去重后数组的长度
 author: qxt 20180716
 */
-static UINT8 RemoveRep(UINT16 input[],UINT8 len,UINT16 output[])
+static UINT16 RemoveRep(UINT16 input[],UINT16 len,UINT16 output[])
 {
-	UINT8 i=0U , j=0U;
+	UINT16 i=0U , j=0U;
-	UINT8 flag=1;/*重复标记，1代表无重复，0代表有重复*/
+	UINT8 flag=1U;/*重复标记，1代表无重复，0代表有重复*/
-	UINT8 count=0U;/*返回值*/
+	UINT16 count=0U;/*返回值*/
     
 	/*参数检查*/
-	if (len>0)
+	if (0U < len)
 	{
 		output[count++]=input[0];/*先给数组的第一个值赋值*/
-		for (i=1;i<len;i++)
+		for (i=1U;i<len;i++)
 		{
-			flag=1;/*每次循环需将标志位重新置位*/
+			flag=1U;/*每次循环需将标志位重新置位*/
-			for(j=0;j<count;j++)
+			for(j=0U ; j<count ; j++)
 			{
 				if (input[i]==output[j])
 				{
 					/*有重复的数，将标志位置位置为0，跳出循环*/
-					flag=0;
+					flag=0U;
 					break;
 				}
 			}
-			if (1==flag)
+			if (1U==flag)
 			{   /*无重复的数，将存入当前的数*/
 				output[count++]=input[i];
 			}

TSCP/src/dqu_common/dqu_emap_common/dquEmapInit.h

@@ -438,6 +438,18 @@ rowCount:
 **********************************************/
 UINT8 initRC(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount);
 
+/**********************************************
+函数功能：初始化[电子地图-RC表信息]:计算索引---拆分复杂度使用
+输入参数：无
+输出参数：
+电子地图数据
+DSU_EMAP_INDEX_STRU *dsuEmapIndexStru
+DSU_STATIC_HEAD_STRU *dsuStaticHeadStru
+DSU_DATA_LEN_STRU *dsuDataLenStru
+返回值:2处理中,0失败
+**********************************************/
+UINT8 initRCSndStep(DSU_EMAP_INDEX_STRU *dsuEmapIndexStru, DSU_STATIC_HEAD_STRU *dsuStaticHeadStru, DSU_DATA_LEN_STRU *dsuDataLenStru);
+
 /**********************************************
 函数功能：初始化[ATS信息]:计算索引
 输入参数：pDataAddr:表数据首地址

TSCP/src/dqu_common/dqu_emap_common/dquStructInit.c

@@ -1884,77 +1884,77 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 	if((NULL != pDataAdd) && (NULL != pRouteStru))
 	{
 		UINT8 * pData = pDataAdd;
-		UINT8 i=0U;
+		UINT16 i=0U;
 		static UINT8 runCount=0U;/*执行该函数的次数 用于判定是否为第一次进入*/
-		static UINT8 maxBlocAccessLinkNum=MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式接近区段最大数量*/
+		static UINT16 maxBlocAccessLinkNum=MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式接近区段最大数量*/
-		static UINT8 maxCBTCAccessLinkNum=MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际CBTC接近区段最大数量*/
+		static UINT16 maxCBTCAccessLinkNum=MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际CBTC接近区段最大数量*/
-		static UINT8 maxBlocTRGAreLinkNum=MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式触发区段最大数量*/
+		static UINT16 maxBlocTRGAreLinkNum=MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式触发区段最大数量*/
 
 		 /*进路ID*/
 		pRouteStru->wId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*进路名称*/
-		for (i = 0; i<24; i++)
+		for (i = 0U; i< 24U; i++)
 		{
 			pRouteStru->szCaption[i] = *pData;
-			pData += 1;
+			pData += 1U;
 		}
 
 		/*进路性质*/
 		pRouteStru->wRouteType = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*起始信号机编号*/
 		pRouteStru->wStartSignalId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*终止信号机编号*/
 		pRouteStru->wEndSignalId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*起点所处link编号*/		/*新增---严广学*/
 		pRouteStru->wOrgnLkId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*终点所处link编号*/		/*新增---严广学*/
 		pRouteStru->wTmnlLkId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*包含道岔数目*/
 		pRouteStru->wIncludePointNum = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 
-		for (i = 0; i<16; i++)
+		for (i = 0U; i<16U; i++)
 		{
 			/*道岔编号*/
 			pRouteStru->wPointId[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*道岔状态*/
 			pRouteStru->wPointStatus[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 		}
 
 		/*保护区段数目*/
 		pRouteStru->wProtectLinkNum = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 
-		for (i = 0; i<4; i++)
+		for (i = 0U; i<4U; i++)
 		{
 			/*保护区段编号*/
 			pRouteStru->wProtectLinkId[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*保护区段关联道岔编号*/
 			pRouteStru->wProtectLinkRelatePointId[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*保护区段关联道岔状态*/
 			pRouteStru->wProtectLinkRelatePointStatus[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 		}
 
 
@@ -1967,20 +1967,20 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 			/* 获取点式接近区段数目 */
 			pRouteStru->wBlogAccessLinkNum = ShortFromChar(pData);
 			maxBlocAccessLinkNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/* 根据获取到的点式接近区段数目进行数据填充 */
-			for (i = 0; i<pRouteStru->wBlogAccessLinkNum; i++)
+			for (i = 0U; i<pRouteStru->wBlogAccessLinkNum; i++)
 			{
 				pRouteStru->wBlogAccessLinkId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*获取CBTC接近区段数目*/
-			for (i = 0; i<MAX_BLOC_ACCESS_LINK_NUM; i++)
+			for (i = 0U; i<MAX_BLOC_ACCESS_LINK_NUM; i++)
 			{
 				pRouteStru->wCBTCAccessLinkNum = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 
 				/* 不断读取数据，丢弃无效值，直到读取到正确的值时，退出 */
 				if ((pRouteStru->wCBTCAccessLinkNum != DSU_NULL_16)
@@ -1998,17 +1998,17 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 			}
 
 			/* 根据获取到的CBTC接近区段数目进行数据填充 */
-			for (i = 0; i<pRouteStru->wCBTCAccessLinkNum; i++)
+			for (i = 0U; i<pRouteStru->wCBTCAccessLinkNum; i++)
 			{
 				pRouteStru->wCBTCAccessLinkId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*所属CI区域编号*/
-			for (i = 0; i<MAX_CBTC_ACCESS_LINK_NUM; i++)
+			for (i = 0U; i<MAX_CBTC_ACCESS_LINK_NUM; i++)
 			{
 				pRouteStru->wManageCI = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 
 				/* 不断读取数据，丢弃无效值，直到读取到正确的值时，退出 */
 				if (pRouteStru->wManageCI != DSU_NULL_16)
@@ -2024,26 +2024,26 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 
 			/*进路属性*/
 			pRouteStru->wAttribute = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 
 			/*点式触发区段数量	*/
 			pRouteStru->wBlocTrgAreaNum = ShortFromChar(pData);
 			maxBlocTRGAreLinkNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*点式触发区段ID*/
-			for (i = 0; i<pRouteStru->wBlocTrgAreaNum; i++)
+			for (i = 0U; i<pRouteStru->wBlocTrgAreaNum; i++)
 			{
 				pRouteStru->wBlocTrgAreaId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*cbtc触发区段数量	*/
-			for (i = 0; i<MAX_BLOC_TRG_AREA_NUM; i++)
+			for (i = 0U; i<MAX_BLOC_TRG_AREA_NUM; i++)
 			{
 				pRouteStru->wCbtcTrgAreaNum = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 
 				/* 不断读取数据，丢弃无效值，直到读取到正确的值时，退出 */
 				if ((pRouteStru->wCbtcTrgAreaNum != DSU_NULL_16)
@@ -2059,10 +2059,10 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 			}
 
 			/*cbtc触发区段ID*/
-			for (i = 0; i<pRouteStru->wCbtcTrgAreaNum; i++)
+			for (i = 0U; i<pRouteStru->wCbtcTrgAreaNum; i++)
 			{
 				pRouteStru->wCbtcTrgAreaId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*执行次数+1*/
@@ -2073,58 +2073,58 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 
 			/* 获取点式接近区段数目 */
 			pRouteStru->wBlogAccessLinkNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/* 根据获取到的点式接近区段数目进行数据填充 */
-			for (i = 0; i<maxBlocAccessLinkNum; i++)
+			for (i = 0U; i<maxBlocAccessLinkNum; i++)
 			{
 				pRouteStru->wBlogAccessLinkId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*获取CBTC接近区段数目*/
 			pRouteStru->wCBTCAccessLinkNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/* 根据获取到的CBTC接近区段数目进行数据填充 */
-			for (i = 0; i<maxCBTCAccessLinkNum; i++)
+			for (i = 0U; i<maxCBTCAccessLinkNum; i++)
 			{
 				pRouteStru->wCBTCAccessLinkId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*所属CI区域编号*/
 			pRouteStru->wManageCI = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*进路属性*/
 			pRouteStru->wAttribute = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 
 			/*点式触发区段数量	*/
 			pRouteStru->wBlocTrgAreaNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*点式触发区段ID*/
-			for (i = 0; i<maxBlocTRGAreLinkNum; i++)
+			for (i = 0U; i<maxBlocTRGAreLinkNum; i++)
 			{
 				pRouteStru->wBlocTrgAreaId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 
 			/*cbtc触发区段数量	*/
 			pRouteStru->wCbtcTrgAreaNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*cbtc触发区段ID-依据实际数量进行数据获取*/
-			for (i = 0; i<pRouteStru->wCbtcTrgAreaNum; i++)
+			for (i = 0U; i<pRouteStru->wCbtcTrgAreaNum; i++)
 			{
 				pRouteStru->wCbtcTrgAreaId[i] = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 			}
 		}
-		rtnValue = 1;
+		rtnValue = 1U;
 	}
 	return rtnValue;
 }
@@ -2268,78 +2268,78 @@ static UINT8 ROUTE_STRU_init_CPK(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 {
 	UINT8 * pData = pDataAdd;
-	UINT8 i = 0;
+	UINT16 i = 0U;
-	static UINT8 runCount = 0;/*执行该函数的次数 用于判定是否为第一次进入*/
+	static UINT8 runCount = 0U;/*执行该函数的次数 用于判定是否为第一次进入*/
-	static UINT8 maxCBTCAccessLinkNum = MAX_CBTC_ACCESS_LINK_NUM;/*进路包含的实际CBTC接近区段最大数量*/
+	static UINT16 maxCBTCAccessLinkNum = MAX_CBTC_ACCESS_LINK_NUM;/*进路包含的实际CBTC接近区段最大数量*/
-	static UINT8 maxBLOCAccessLinkNum = MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式接近区段最大数量*/
+	static UINT16 maxBLOCAccessLinkNum = MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式接近区段最大数量*/
 	UINT8 reval = 0U;/*初始赋值为失败*/
 	 /*输入参数空指针防护*/
 	if ((NULL != pDataAdd) && (NULL != pRouteStru))
 	{
 		pRouteStru->wId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*进路名称*/
-		for (i = 0; i < 24; i++)
+		for (i = 0U; i < 24U; i++)
 		{
 			pRouteStru->szCaption[i] = *pData;
-			pData += 1;
+			pData += 1U;
 		}
 
 		/*进路性质*/
 		pRouteStru->wRouteType = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*起始信号机编号*/
 		pRouteStru->wStartSignalId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*终止信号机编号*/
 		pRouteStru->wEndSignalId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*起点所处link编号*/		/*新增---严广学*/
 		pRouteStru->wOrgnLkId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*终点所处link编号*/		/*新增---严广学*/
 		pRouteStru->wTmnlLkId = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 		/*包含道岔数目*/
 		pRouteStru->wIncludePointNum = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 
-		for (i = 0; i < 16; i++)
+		for (i = 0U; i < 16U; i++)
 		{
 			/*道岔编号*/
 			pRouteStru->wPointId[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*道岔状态*/
 			pRouteStru->wPointStatus[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 		}
 
 		/*保护区段数目*/
 		pRouteStru->wProtectLinkNum = ShortFromChar(pData);
-		pData += 2;
+		pData += 2U;
 
 
-		for (i = 0; i < 4; i++)
+		for (i = 0U; i < 4U; i++)
 		{
 			/*保护区段编号*/
 			pRouteStru->wProtectLinkId[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*保护区段关联道岔编号*/
 			pRouteStru->wProtectLinkRelatePointId[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			/*保护区段关联道岔状态*/
 			pRouteStru->wProtectLinkRelatePointStatus[i] = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 		}
 		
 		/* 程序中"CBTC接近区段数目"为固定值,导致一旦数据表中数据增加就要修改代码,为优化此问题修改结构体添充逻辑, by cgh  2023-4-14 */
@@ -2348,7 +2348,7 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 		{
 			/*点式接近区段数目*/
 			pRouteStru->wBlogAccessLinkNum = ShortFromChar(pData);
-			pData += 2;
+			pData += 2U;
 
 			if (MAX_BLOC_ACCESS_LINK_NUM >= pRouteStru->wBlogAccessLinkNum)
 			{
@@ -2356,17 +2356,17 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 				maxBLOCAccessLinkNum = pRouteStru->wBlogAccessLinkNum;
 
 				/*点式接近区段编号*/
-				for (i = 0; i < pRouteStru->wBlogAccessLinkNum; i++)
+				for (i = 0U; i < pRouteStru->wBlogAccessLinkNum; i++)
 				{
 					pRouteStru->wBlogAccessLinkId[i] = ShortFromChar(pData);
-					pData += 2;
+					pData += 2U;
 				}
 
 				/*获取CBTC接近区段数目*/
-				for (i = 0; i < MAX_BLOC_ACCESS_LINK_NUM; i++)
+				for (i = 0U; i < MAX_BLOC_ACCESS_LINK_NUM; i++)
 				{
 					pRouteStru->wCBTCAccessLinkNum = ShortFromChar(pData);
-					pData += 2;
+					pData += 2U;
 
 					/* 不断读取数据，丢弃无效值，直到读取到正确的值时，退出 */
 					if (pRouteStru->wCBTCAccessLinkNum != DSU_NULL_16)
@@ -2386,17 +2386,17 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 					maxCBTCAccessLinkNum = pRouteStru->wCBTCAccessLinkNum;
 
 					/* 根据获取到的CBTC接近区段数目进行数据填充 */
-					for (i = 0; i < pRouteStru->wCBTCAccessLinkNum; i++)
+					for (i = 0U; i < pRouteStru->wCBTCAccessLinkNum; i++)
 					{
 						pRouteStru->wCBTCAccessLinkId[i] = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 					}
 
 					/*所属CI区域编号*/
-					for (i = 0; i < MAX_CBTC_ACCESS_LINK_NUM; i++)
+					for (i = 0U; i < MAX_CBTC_ACCESS_LINK_NUM; i++)
 					{
 						pRouteStru->wManageCI = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 
 						/* 不断读取数据，丢弃无效值，直到读取到正确的值时，退出 */
 						if (pRouteStru->wManageCI != DSU_NULL_16)
@@ -2411,20 +2411,20 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 					}
 					/*进路属性*/
 					pRouteStru->wAttribute = ShortFromChar(pData);
-					pData += 2;
+					pData += 2U;
 
 					/*cbtc触发区段数量	*/
 					pRouteStru->wCbtcTrgAreaNum = ShortFromChar(pData);
-					pData += 2;
+					pData += 2U;
 
 					if (MAX_CBTC_TRG_AREA_NUM >= pRouteStru->wCbtcTrgAreaNum)
 					{
 						/*CBTC触发区段数量合法，继续读取*/
-						for (i = 0; i < pRouteStru->wCbtcTrgAreaNum; i++)
+						for (i = 0U; i < pRouteStru->wCbtcTrgAreaNum; i++)
 						{
 							/*cbtc触发区段ID*/
 							pRouteStru->wCbtcTrgAreaId[i] = ShortFromChar(pData);
-							pData += 2;
+							pData += 2U;
 						}
 
 						reval = 1U;  /*数据均合法，返回成功*/
@@ -2446,55 +2446,55 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 			{				
 				/*点式接近区段数目*/
 				pRouteStru->wBlogAccessLinkNum = ShortFromChar(pData);
-				pData += 2;
+				pData += 2U;
 
 				if (MAX_BLOC_ACCESS_LINK_NUM >= pRouteStru->wBlogAccessLinkNum)
 				{
 					/*点式接近区段数量合法，继续读取*/
-					for (i = 0; i < maxBLOCAccessLinkNum; i++)
+					for (i = 0U; i < maxBLOCAccessLinkNum; i++)
 					{
 						/*点式接近区段编号*/
 						pRouteStru->wBlogAccessLinkId[i] = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 					}
 
 					/*CBTC接近区段数目*/
 					pRouteStru->wCBTCAccessLinkNum = ShortFromChar(pData);
-					pData += 2;
+					pData += 2U;
 
 					if (MAX_CBTC_ACCESS_LINK_NUM >= pRouteStru->wCBTCAccessLinkNum)
 					{
 						/*CBTC接近区段数量合法，继续读取*/
-						for (i = 0; i < maxCBTCAccessLinkNum; i++)
+						for (i = 0U; i < maxCBTCAccessLinkNum; i++)
 						{
 							/*CBTC接近区段编号*/
 							pRouteStru->wCBTCAccessLinkId[i] = ShortFromChar(pData);
-							pData += 2;
+							pData += 2U;
 						}
 
 						/*所属CI区域编号*/
 						pRouteStru->wManageCI = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 						/*进路属性*/
 						pRouteStru->wAttribute = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 
 #if 0
 						/*点式触发区段数量	*/
 						pRouteStru->wBlocTrgAreaNum = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 
 						/*点式触发区段ID*/
-						for (i = 0; i < 13; i++)
+						for (i = 0U; i < 13; i++)
 						{
 							pRouteStru->wBlocTrgAreaId[i] = ShortFromChar(pData);
-							pData += 2;
+							pData += 2U;
 						}
 #endif
 
 						/*cbtc触发区段数量	*/
 						pRouteStru->wCbtcTrgAreaNum = ShortFromChar(pData);
-						pData += 2;
+						pData += 2U;
 
 						if (MAX_CBTC_TRG_AREA_NUM < pRouteStru->wCbtcTrgAreaNum)
 						{
@@ -2504,10 +2504,10 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru)
 						else
 						{
 							/*cbtc触发区段ID*/
-							for (i = 0; i < pRouteStru->wCbtcTrgAreaNum; i++)
+							for (i = 0U; i < pRouteStru->wCbtcTrgAreaNum; i++)
 							{
 								pRouteStru->wCbtcTrgAreaId[i] = ShortFromChar(pData);
-								pData += 2;
+								pData += 2U;
 							}
 
 							reval = 1U;  /*数据均合法，返回成功*/
@@ -3492,7 +3492,11 @@ static UINT8 CI_STRU_init_CC(UINT8 * pDataAdd, DSU_CI_STRU * pCIStru)
 		pCIStru->chCldAndScxMergeFlag = *pData;
 		pData += 1U;
 
-		rtnValue = 1;
+		/*联锁厂商定义*/
+		pCIStru->chCiFactoryType = *pData;
+		pData += 1U;
+	
+		rtnValue = 1U;
 	}
 	return rtnValue;
 }
@@ -4171,8 +4175,8 @@ UINT8 DSU_FLOOD_GATE_STRU_init(UINT8 * pDataAdd, DSU_FLOOD_GATE_STRU * pFloodGat
 {
 	UINT8 rtnValue = 0U;
 	static UINT8 runCount = 0U;/*执行该函数的次数 用于判定是否为第一次进入*/
-	static UINT8 maxProtectAxisNum = MAX_PROTECT_AXIS_NUM;/*进路包含的实际点式接近区段最大数量*/
+	static UINT16 maxProtectAxisNum = MAX_PROTECT_AXIS_NUM;/*进路包含的实际点式接近区段最大数量*/
-	UINT8 i = 0;
+	UINT16 i = 0U;
 	UINT8 chDataType = gLocalPublicDataType;
 	/*输入参数空指针防护*/
 	if ((NULL != pDataAdd) && (NULL != pFloodGateStru))

TSCP/src/dqu_common/dqu_emap_common/dsuStruct.h

@@ -755,6 +755,7 @@ typedef struct DSU_CIStruct
 	UINT8 cWLScreenType;				/* 全线免筛有效属性 0x55无效 0xAA有效 */
 	UINT32 dwLocalShareCheckData; /*与本控区RC/CI校验信息----20250827北京10需求新增 */
 	UINT8 chCldAndScxMergeFlag;/*试车线与车辆段合设开关*/
+	UINT8 chCiFactoryType; /*联锁厂商定义*/
 }DSU_CI_STRU;
 
 
@@ -933,7 +934,7 @@ typedef struct DSU_SpksButton
 	UINT16  wManageCI;							/*所属CI区域编号*/
 	UINT16  wManageVirCI;							/*所属虚拟CI区域编号*/
 	/* 以下项在数据代码分离项目中，从数据文件中删除，它的值需要动态计算---祁晓婷 */
-	UINT8 wLinkNum;/*包含LINK数量*/	
+	UINT16 wLinkNum;/*包含LINK数量*/	
 	UINT16 wIncLinkId[SPKS_INCLUDE_LINK_NUM];/*包含LINK编号*/
 	UINT16 wPlatFormId;  /*站台ID*/
 }DSU_SPKS_BUTTON_STRU;

TSCP/src/dqu_common/dqu_idmap_common/dquIdmapInit.c

@@ -86,10 +86,10 @@ UINT8 dfsIdmapInit(CHAR * FSName)
 	/*28.0.0.14不具备RC/IVOC编号对照表*/
 	funcRtn = dquGetPublicFSVersion(FSName, szFSPUBVersionFS);
 	funcRtn &= CheckTiocPublicFsVersion(szFSPUBVersionFS);
-	if (NULL!=g_dsuIdmapStru)
+	if (NULL != g_dsuIdmapStru)
 	{
 		/*初始化一次就行了*/
-		if (dfsIdmapInitFlag == 1)
+		if (1U == dfsIdmapInitFlag)
 		{
 			rtnValue = 1U;
 			return rtnValue;
@@ -110,7 +110,7 @@ UINT8 dfsIdmapInit(CHAR * FSName)
 		}
 		else
 		{
-			rtnValue = 0U;;
+			rtnValue = 0U;
 			
 		}
 		
@@ -125,7 +125,7 @@ UINT8 dfsIdmapInit(CHAR * FSName)
 		}
 		else
 		{
-			rtnValue = 0U;;
+			rtnValue = 0U;
 
 		}
 		
@@ -140,7 +140,7 @@ UINT8 dfsIdmapInit(CHAR * FSName)
 		}
 		else
 		{
-			rtnValue = 0U;;
+			rtnValue = 0U;
 
 		} 
 
@@ -213,7 +213,6 @@ UINT8 dfsIdmapInit(CHAR * FSName)
 UINT8 dfsIdmapInitExp(UINT8 * pDataBuf,DSU_IDMAP_STRU *dsuIdmapStru,UINT8 mode,UINT16 timeSlice)
 {
 	UINT32 DataID;
-	UINT16 wPos=0U;
 	UINT8 rtnValue=0U;
 	UINT16 wFreqTimes=0U;
 	UINT8 bExeState=DQU_QFUN_FASLE;
@@ -793,13 +792,10 @@ UINT8 initRCNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 	UINT8 rtnValue = 2U;
 	UINT8 *pData = NULL;
 	UINT8 initFlag = 0U;
-	UINT8 checkFlag = 0U;
 	DSU_CI_NUM_STRU *pCurrentStru = NULL; /*结构体临时指针变量*/
 	DSU_CI_NUM_STRU stru = { 0 };   			/*结构体临时指针变量*/
 	UINT16 j = 0U;
 	static UINT32 rowDataLen = 0;
-	UINT16 wStruDataLen = 0;
-	UINT16 wDataIndexLen = 0;
 
 	/*编号对照表数据*/
 	DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru = NULL;
@@ -848,6 +844,68 @@ UINT8 initRCNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 
 	initFlag = IdmapInitFunStepCtrl(0x02);
 	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
+	{
+		/*降低复杂度*/
+		rtnValue = initRCNumSndStep(dsuIdmapLenStru, dsuIdmapIndexStru, dsuStaticIdmapStru);
+	}
+
+	initFlag = IdmapInitFunStepCtrl(0x03);
+	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
+	{
+		/*解析数据到结构体数组 */
+		for (j = g_struInitTaskTab[g_wCurInitStruProg].wCurInitPos; j < dsuIdmapLenStru->wRCNumLen; j++)
+		{
+			pCurrentStru = dsuStaticIdmapStru->pRCNumStru + j;
+
+			pData = pDataAddr + rowDataLen*j;
+			/*填充数据结构体*/
+			initFlag = CINumStru_init(pData, pCurrentStru);
+			if (0U == initFlag)
+			{
+				/*init函数参数空指针*/
+				rtnValue = 0U;;
+			}
+			else
+			{
+				/*完成对应填充索引*/
+				dsuIdmapIndexStru->dsuRCNumIndex[pCurrentStru->wIndexId] = j;
+				initFlag = IdmapInitLoopStepLenCtrl(j);
+			}
+			/*循环分步切割处理*/
+			if ((0U == initFlag) || (DQU_QFUN_TRUE == initFlag))
+			{
+				break;
+			}
+		}
+
+		if ((0U != rtnValue) && (j == dsuIdmapLenStru->wRCNumLen))
+		{
+			rtnValue = 1;
+		}
+	}
+
+	return rtnValue;
+}
+
+/**********************************************
+函数功能：初始化[编号对照表-RC]:计算索引--拆圈复杂度使用
+输出参数：
+DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru
+DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru
+DSU_IDMAP_LEN_STRU *dsuIdmapLenStru
+返回值:2处理中 0失败
+**********************************************/
+UINT8 initRCNumSndStep(DSU_IDMAP_LEN_STRU *dsuIdmapLenStru, DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru, DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru)
+{
+	UINT8 rtnValue = 2U;
+	UINT16 wStruDataLen = 0;
+	UINT16 wDataIndexLen = 0;
+	UINT8 checkFlag = 0U;
+	if ((NULL == dsuIdmapIndexStru) || (NULL == dsuStaticIdmapStru) || (NULL == dsuIdmapLenStru))
+	{
+		rtnValue = 0U;
+	}
+	else
 	{
 		if (0x01 == g_IsIdmapAllocMemory)
 		{
@@ -904,42 +962,6 @@ UINT8 initRCNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 			}
 		}
 	}
-
-	initFlag = IdmapInitFunStepCtrl(0x03);
-	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
-	{
-		/*解析数据到结构体数组 */
-		for (j = g_struInitTaskTab[g_wCurInitStruProg].wCurInitPos; j < dsuIdmapLenStru->wRCNumLen; j++)
-		{
-			pCurrentStru = dsuStaticIdmapStru->pRCNumStru + j;
-
-			pData = pDataAddr + rowDataLen*j;
-			/*填充数据结构体*/
-			initFlag = CINumStru_init(pData, pCurrentStru);
-			if (0U == initFlag)
-			{
-				/*init函数参数空指针*/
-				rtnValue = 0U;;
-			}
-			else
-			{
-				/*完成对应填充索引*/
-				dsuIdmapIndexStru->dsuRCNumIndex[pCurrentStru->wIndexId] = j;
-				initFlag = IdmapInitLoopStepLenCtrl(j);
-			}
-			/*循环分步切割处理*/
-			if ((0U == initFlag) || (DQU_QFUN_TRUE == initFlag))
-			{
-				break;
-			}
-		}
-
-		if ((0U != rtnValue) && (j == dsuIdmapLenStru->wRCNumLen))
-		{
-			rtnValue = 1;
-		}
-	}
-
 	return rtnValue;
 }
 
@@ -2414,13 +2436,10 @@ UINT8 initIvocNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 	UINT8 rtnValue = 2U;
 	UINT8 *pData = NULL;
 	UINT8 initFlag = 0U;
-	UINT8 checkFlag = 0U;
 	DSU_VOBC_NUM_STRU *pCurrentStru = NULL; /*结构体临时指针变量*/
 	DSU_VOBC_NUM_STRU stru = { 0 };   			/*结构体临时指针变量*/
 	UINT16 j = 0U;
 	static UINT32 rowDataLen = 0;
-	UINT16 wStruDataLen = 0;
-	UINT16 wDataIndexLen = 0;
 
 	/*编号对照表数据*/
 	DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru = NULL;
@@ -2469,6 +2488,68 @@ UINT8 initIvocNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 
 	initFlag = IdmapInitFunStepCtrl(0x02);
 	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
+	{
+		rtnValue = initIvocNumSndStep(dsuIdmapIndexStru, dsuStaticIdmapStru, dsuIdmapLenStru);
+	}
+
+	initFlag = IdmapInitFunStepCtrl(0x03);
+	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
+	{
+		/*解析数据到结构体数组 */
+		for (j = g_struInitTaskTab[g_wCurInitStruProg].wCurInitPos; j < dsuIdmapLenStru->wIvocNumLen; j++)
+		{
+			pCurrentStru = dsuStaticIdmapStru->pIvocNumStru + j;
+
+			pData = pDataAddr + rowDataLen*j;
+			/*填充数据结构体*/
+			initFlag = VOBCNumStru_init(pData, pCurrentStru);
+			if (0U == initFlag)
+			{
+				/*init函数参数空指针*/
+				rtnValue = 0U;;
+			}
+			else
+			{
+				/*完成对应填充索引*/
+				dsuIdmapIndexStru->dsuIvocNumIndex[pCurrentStru->wIndexId] = j;
+				initFlag = IdmapInitLoopStepLenCtrl(j);
+			}
+			/*循环分步切割处理*/
+			if ((0U == rtnValue) || (DQU_QFUN_TRUE == initFlag))
+			{
+				break;
+			}
+		}
+
+		if ((0U != rtnValue) && (j == dsuIdmapLenStru->wIvocNumLen))
+		{
+			rtnValue = 1;
+		}
+	}
+
+	return rtnValue;
+}
+
+/**********************************************
+函数功能：初始化[编号对照表IVOC]:计算索引----拆分复杂度使用
+输出参数：
+编号对照表数据
+DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru;
+DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru;
+DSU_IDMAP_LEN_STRU *dsuIdmapLenStru;
+返回值:2处理中,0失败
+**********************************************/
+UINT8 initIvocNumSndStep(DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru,DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru,DSU_IDMAP_LEN_STRU *dsuIdmapLenStru)
+{
+	UINT8 rtnValue = 2U;
+	UINT16 wStruDataLen = 0;
+	UINT16 wDataIndexLen = 0;
+	UINT8 checkFlag = 0U;
+	if ((NULL == dsuIdmapIndexStru) || (NULL == dsuStaticIdmapStru) || (NULL == dsuIdmapLenStru))
+	{
+		rtnValue = 0U;
+	}
+	else
 	{
 		if (0x01 == g_IsIdmapAllocMemory)
 		{
@@ -2483,7 +2564,7 @@ UINT8 initIvocNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 			else
 			{
 				/*初始化为0xFF*/
-				(void)CommonMemSet(dsuIdmapIndexStru->dsuIvocNumIndex,(UINT32)(dsuIdmapIndexStru->IVOCNUMINDEXSIZE * 2 + 2),0xFF, (UINT32)(dsuIdmapIndexStru->IVOCNUMINDEXSIZE * 2 + 2));
+				(void)CommonMemSet(dsuIdmapIndexStru->dsuIvocNumIndex, (UINT32)(dsuIdmapIndexStru->IVOCNUMINDEXSIZE * 2 + 2), 0xFF, (UINT32)(dsuIdmapIndexStru->IVOCNUMINDEXSIZE * 2 + 2));
 			}
 
 			if (2U == rtnValue)
@@ -2525,42 +2606,6 @@ UINT8 initIvocNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount)
 			}
 		}
 	}
-
-	initFlag = IdmapInitFunStepCtrl(0x03);
-	if ((2U == rtnValue) && (DQU_QFUN_TRUE == initFlag))
-	{
-		/*解析数据到结构体数组 */
-		for (j = g_struInitTaskTab[g_wCurInitStruProg].wCurInitPos; j < dsuIdmapLenStru->wIvocNumLen; j++)
-		{
-			pCurrentStru = dsuStaticIdmapStru->pIvocNumStru + j;
-
-			pData = pDataAddr + rowDataLen*j;
-			/*填充数据结构体*/
-			initFlag = VOBCNumStru_init(pData, pCurrentStru);
-			if (0U == initFlag)
-			{
-				/*init函数参数空指针*/
-				rtnValue = 0U;;
-			}
-			else
-			{
-				/*完成对应填充索引*/
-				dsuIdmapIndexStru->dsuIvocNumIndex[pCurrentStru->wIndexId] = j;
-				initFlag = IdmapInitLoopStepLenCtrl(j);
-			}
-			/*循环分步切割处理*/
-			if ((0U == rtnValue) || (DQU_QFUN_TRUE == initFlag))
-			{
-				break;
-			}
-		}
-
-		if ((0U != rtnValue) && (j == dsuIdmapLenStru->wIvocNumLen))
-		{
-			rtnValue = 1;
-		}
-	}
-
 	return rtnValue;
 }
 
@@ -4658,9 +4703,7 @@ UINT8 initIteNum(UINT8* pDataAddr, UINT32 dataSize, UINT16 rowCount)
 	UINT8* pData = NULL;
 	UINT8 initFlag = 0U;
 	UINT8 checkFlag = 0U;
-	DSU_ITE_NUM_STRU* pCurrentStru = NULL;  /*结构体临时指针变量*/
 	DSU_ITE_NUM_STRU stru = { 0U };  /*结构体临时指针变量*/
-	UINT16 j = 0U;
 	static UINT32 rowDataLen = 0U;
 	UINT16 wStruDataLen = 0U;
 	UINT16 wDataIndexLen = 0U;

TSCP/src/dqu_common/dqu_idmap_common/dquIdmapInit.h

@@ -84,6 +84,16 @@ rowCount:
 **********************************************/
 UINT8 initRCNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount);
 
+/**********************************************
+函数功能：初始化[编号对照表-RC]:计算索引--拆圈复杂度使用
+输出参数：
+DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru
+DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru
+DSU_IDMAP_LEN_STRU *dsuIdmapLenStru
+返回值:2处理中 0失败
+**********************************************/
+UINT8 initRCNumSndStep(DSU_IDMAP_LEN_STRU *dsuIdmapLenStru, DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru, DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru);
+
 /**********************************************
 函数功能：初始化[ATS]:计算索引
 输入参数：pDataAddr:表数据首地址
@@ -184,6 +194,17 @@ rowCount:
 **********************************************/
 UINT8 initIvocNum(UINT8 *pDataAddr, UINT32 dataSize, UINT16 rowCount);
 
+/**********************************************
+函数功能：初始化[编号对照表IVOC]:计算索引----拆分复杂度使用
+输出参数：
+编号对照表数据
+DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru;
+DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru;
+DSU_IDMAP_LEN_STRU *dsuIdmapLenStru;
+返回值:2处理中,0失败
+**********************************************/
+UINT8 initIvocNumSndStep(DSU_IDMAP_INDEX_STRU *dsuIdmapIndexStru, DSU_STATIC_IDMAP_STRU *dsuStaticIdmapStru, DSU_IDMAP_LEN_STRU *dsuIdmapLenStru);
+
 /**********************************************
 函数功能：初始化[防淹门]:计算索引
 输入参数：pDataAddr:表数据首地址

TSCP/src/dqu_common/dqu_idmap_common/dquIdmapQuery.h

@@ -380,6 +380,14 @@ UINT16 dquGetIvocIndex(UINT16 dataPos);
 ***************************************************/
 UINT8 dquQueryOutAxleDevId(UINT16 devIndex, UINT32 szOutDevId[2U]);
 
+/**************************************************
+*函数功能：获取数据库中VOBC编号表的结构体的数量
+*输入参数：无
+*输出参数：无
+*返 回 值：VOBC编号表的结构体的数量
+***************************************************/
+UINT16 dquGetVobcNumLen(void);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/protocol/fsfb/common_fsfb/FsfbMessageInfo.c

@@ -977,18 +977,26 @@ static UINT8 CreateTsdOrSbtMsg(const UINT8* pAppData, UINT16 DataLen, UINT8 appl
 			ret = 1u; /*-< ���ú�������ֵΪ�ɹ�*/
 			break; /*-< �˳�*/
 		case APPLCAT_TDM: /*-< TD����*/
-			*outPutDataLen = TSD_SIZE; /*-< ����������ݳ���*/
 			/*��·״̬����*/
 			pPNode->FsfbLinInfo.RecvLinkStatus = Fsfb_WaitSse; /*-< ���ý�����·״̬Ϊ��SSE*/
 			/* ����TSD֡ͷ */
 			SetFsfbMsgHead(applyCat, FSFB_TSD_MSG, pPNode->FsfbLinInfo.sendSrcAdd, pPNode->FsfbLinInfo.sendDestAdd, OutTsdOrSbtMsg); /*-< ���ú�������TSD֡ͷ*/
 			/*�ж����ݳ����Ƿ�ΪTSD �����ݳ��� */
-			if (DataLen != TSD_DF_SIZE) /*-< ���ݳ��ȴ���*/
+			if ((TSD_DF_SIZE != DataLen) && (TSD_DF_TWO_SIZE != DataLen)) /*-< ���ݳ��ȴ���*/
 			{
 				ret = 0u; /*-< ���ú�������ֵΪʧ��*/
 			}
 			else
 			{
+				if ((TSD_DF_SIZE == DataLen))
+				{
+					(*outPutDataLen) = TSD_SIZE; /*-< ����������ݳ���*/
+				}
+				else
+				{
+					(*outPutDataLen) = TSD_TWO_SIZE; /*-< ����������ݳ���*/
+				}
+
 				ret = 1u; /*-< ���ú�������ֵΪ�ɹ�*/
 			}
 			break; /*-< �˳�*/

TSCP/src/protocol/fsfb/common_fsfb/FsfbProtcl.c

@@ -706,6 +706,7 @@ static UINT8 FsfbStructInit(FSFB_INFO_STRU* pFsfbStruct)
 	}
 	else
 	{
+		ComMemSet(pFsfbStruct->AppArray, sizeof(UINT8) * pFsfbStruct->AppArraySize, 0U); /*-< ���������*/
 		LongToChar(0, pFsfbStruct->AppArray); /*-< ����������鳤��Ϊ0*/
 	}
 
@@ -720,6 +721,7 @@ static UINT8 FsfbStructInit(FSFB_INFO_STRU* pFsfbStruct)
 	}
 	else
 	{
+		ComMemSet(pFsfbStruct->VarArray, sizeof(UINT8) * pFsfbStruct->VarArraySize, 0U); /*-< ������������*/
 		ShortToChar(0u, pFsfbStruct->VarArray); /*-< �����м�������鳤��Ϊ0*/
 	}
 

TSCP/src/protocol/fsfb/common_fsfb/FsfbProtclConfigMessage.h

@@ -35,6 +35,7 @@
 
 /* 消息帧长度 */
 #define TSD_SIZE     58 
+#define TSD_TWO_SIZE (74U) /*À©³äºóTSD³¤¶È*/
 #define SSE_SIZE     20
 #define SSR_SIZE     25
 #define SBT_SIZE    138
@@ -45,6 +46,7 @@
 
 /* 报文data feild Size */
 #define TSD_DF_SIZE  36
+#define TSD_DF_TWO_SIZE  (52U) /*À©³äºóTSD_DF³¤¶È*/
 #define BTC_DF_SIZE   8
 #define SBT_DF_SIZE 116
 #define ABT_DF_SIZE   0

TSCP/src/protocol/fsfb/common_fsfb/FsfbRecordDelare.h

@@ -1,6 +1,6 @@
 /********************************************************
 *                                                                                                            
-* 文件名  ： FsfbRecordDelare.h 
+* 文件名  ： FsfbRecordDelare.h
 * 版权说明： 北京交控科技有限工司 
 * 版本号  ： 1.0
 * 创建时间： 2013.09.09

TSCP/src/protocol/fsfb/common_fsfb/fsfbProtclStruct.h

@@ -170,7 +170,7 @@ typedef struct
 	UINT8 *RecordArray;				/* Fsfb层记录数组 */
 	UINT16 RecordArraySize;			/* Fsfb层记录数组大小 */
 	UINT8 *AppArray;				/* 输出模块的出口1，表示外网输出数据 */
-	UINT16 AppArraySize;			/* Fsfb层输出模块的出口数组长度 */
+	UINT32 AppArraySize;			/* Fsfb层输出模块的出口数组长度 */
 	UINT8 *VarArray;
 	UINT16 VarArraySize;
 	QueueStruct DataToApp;			/* Fsfb层协议输入给应用的数据队列 */

TSCP/src/protocol/protocol_cbtc/common_dqu_protocol/dsuProtclFun.c

@@ -41,6 +41,7 @@ static UINT8 StDsuPtclFindSheet(SheetInfo* sheetInfo, UINT8 data[], const UINT32
 static void StDsuPtclSetDevNum(UINT8 locType, UINT8 oppType, SheetInfo* outDevIpSheet, SheetInfo* inDevIpSheet, UINT16* dupOppHlhtIdLen, UINT32* dupOppHlhtId, UINT16 outInDevIpRowCount, UINT8* devNum);
 static UINT8 GetCommOppDevTypes(SheetInfo* commSheet, UINT8 locType, UINT8* oppTypes, UINT8* oppTypePtls, UINT16* oppTypeNum, const UINT16 maxOppTypeNum);
 static void GetCommOppDevNum(SheetInfo* devIpSheet, UINT8 oppType, UINT16* dupOppHlhtIdsLen, UINT32* dupOppHlhtIds, const UINT16 maxDupOppHlhtIdsLen, UINT8* devNum);
+static void StDsuPtclCommRelSetDevNum(UINT16 locTypeId, UINT8 oppType, UINT8* devNum);
 
 /**
  * @brief DsuCommonInfoInit 适配层查询函数初始化
@@ -255,7 +256,20 @@ UINT8 DsuGetProtclTypeInfo(UINT16 locTypeId, DSU_PROTCL_TYPE_STRU* dsuProtclType
 						}
 
 						devNum = 0u; /*-< 清设备数量为0*/
-						StDsuPtclSetDevNum(locType, oppType[i], &outDevIpSheet, &inDevIpSheet, &dupOppHlhtIdLen, dupOppHlhtId, (UINT16)(outInDevIpRowCount), &devNum); /*-< 调用设置设备数量函数*/
+
+						StDsuPtclCommRelSetDevNum(locTypeId, oppType[i], &devNum); /*-< 调用根据设备通信关系得到设备数量函数*/
+						if (0U == devNum) /*-< 得到设备数量*/
+						{
+							StDsuPtclSetDevNum(locType, oppType[i], &outDevIpSheet, &inDevIpSheet, &dupOppHlhtIdLen, dupOppHlhtId, (UINT16)(outInDevIpRowCount), &devNum); /*-< 调用设置设备数量函数*/
+						}
+						else
+						{
+							if (LEU_TYPE == oppType[i]) /*-< 通信类型为LEU*/
+							{
+								devNum *= 2U; /*-< LEU链路数需乘2,有两种通道*/
+							}
+							devNum += 1U; /*-< 统一富裕出一个链路*/
+						}
 
 						/*加到对应协议类型的通信设备数量上*/
 						switch (oppTypePtl[i]) /*-< 判断对方协议类型*/
@@ -717,3 +731,48 @@ static void GetCommOppDevNum(SheetInfo* devIpSheet, UINT8 oppType, UINT16* dupOp
 		}
 	}
 }
+
+/**
+ * @brief StDsuPtclCommRelSetDevNum 根据设备通信关系得到设备数量
+ * @param locTypeId 本方类型ID 取值范围:0x0000-0xFFFF
+ * @param oppType 对方类型 取值范围:0x00-0xFF
+ * @param devNum 设备数量 取值范围:0x00-0xFF
+ */
+static void StDsuPtclCommRelSetDevNum(UINT16 locTypeId, UINT8 oppType, UINT8* devNum)
+{
+	SheetInfo commRelSheet = { 0U };
+	UINT16 rowIdx = 0U;
+	UINT16 curLocTypeId = 0U;
+	UINT8 comDevNum = 0U;
+	UINT8 comIdx = 0U;
+	UINT16 comTypeId = 0U;
+	UINT8 comType = 0U;
+
+	if ((NULL != devNum) && (NULL != g_pDataBuf))/*-< 参数是否非空*/
+	{
+		(*devNum) = 0u; /*-< 清设备数量为0*/
+
+		InitSheet(&commRelSheet, g_pDataBuf, g_DataBufLen, DSU_DEVICE_IP_CONFIG_TYPE, DSU_DATA_IP_ZCDSU_COMM_ID); /*-< 读取地面设备通信关系配置表*/
+		if (NULL != commRelSheet.Data) /*-< 检查内网-RSSP链接信息表-长度合法*/
+		{
+			for (rowIdx = 0U; rowIdx < commRelSheet.RowCount; rowIdx++)
+			{
+				curLocTypeId = ShortFromChar(&commRelSheet.Data[rowIdx * commRelSheet.ColLen]); /*-< 得到当前类型ID*/
+				if (curLocTypeId == locTypeId)
+				{
+					comDevNum = (UINT8)ShortFromChar(&commRelSheet.Data[(rowIdx * commRelSheet.ColLen) + 2U]); /*-< 得到通信数量*/
+					for (comIdx = 0U; comIdx < comDevNum; comIdx++)
+					{
+						comTypeId = ShortFromChar(&commRelSheet.Data[(rowIdx * commRelSheet.ColLen) + 4U + (2U * comIdx)]); /*-< 得到通信类型ID*/
+						comType = (UINT8)((comTypeId >> 8U) & 0x00FFU);
+						if (comType == oppType)
+						{
+							(*devNum)++;
+						}
+					}
+					break;
+				}
+			}
+		}
+	}
+}

TSCP/src/protocol/protocol_cbtc/common_dqu_protocol/dsuProtclFun.h

@@ -47,6 +47,7 @@ extern "C" {
 #define PSC_TYPE	((UINT8)0x61)	/*PSC设备类型*/
 #define ITE_TYPE	((UINT8)0x18)	/*ITE设备类型*/
 #define OC_TYPE	    ((UINT8)0x64)	/*OCC设备类型*/
+#define LEU_TYPE	((UINT8)0x5E)	/*LEU设备类型*/
 
 	/*设备通信协议表0x4002*/
 	typedef struct

TSCP/src/protocol/sfp_record_cbtc1/common_sfp_nr_config/sfpConfig.h

@@ -21,7 +21,6 @@
 
 #define PRTCL_RECORD_SIMPLIFY_BIN	/*二进制记录开关*/
 #define USE_DSU_SFP	/*使用SFP查询函数*/
-#define SWAP_CRC /*½»»»CRC*/
 
 #else
 #endif