调试日志修改

TSCP/src/APP/PU13_integration_config/ci_integrate_config.h

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

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

@@ -16,12 +16,12 @@
 #include "NonAutoReturnDataManage.h"
 #include "DynamicRouteDataManage.h"
 #include "../Deployment/DeploymentExtern.h"
+
 /*交换变量*/
 extern UINT16 TransmitStateDataCurSum;	/*通信关系状态数据当前总数*/
 extern UINT8 ComCycNumForCiToAts;		/*联锁到ATS通信周期记录*/
 extern UINT8 ComCycNumForCiToXianDi;	/*联锁到现地通信周期记录*/
 
-
 extern TransmitStateDataStruct TransmitStateDataStru[TRANSMIT_OBJECT_SUM_MAX * TRANSMIT_OBJECT_DEVICE_SUM_MAX];  /*定义通信状态结构体*/
 
 
@@ -895,7 +895,11 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		/*拷贝OC站（集中站和非集中站）指示器结构体*/
 		(void)memcpy(pCiAppDataPointer + curIndex, g_OCStationIndicDataStru, (INDICATOR_SUM_MAX) * sizeof(OCStationIndicDataStru));
 		curIndex = curIndex + (UINT32)((INDICATOR_SUM_MAX) * sizeof(OCStationIndicDataStru));
-
+		/*计算一次CRC*/
+		crcLength = curIndex - crcIndex;
+		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
+		debug_infor_printf((const)"2oo2 IndicatorDataStru-g_OCStationIndicDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
+		crcIndex = curIndex;
         /*拷贝错误数据结构体*/
 		(void)memcpy(pCiAppDataPointer + curIndex, ErrorDataStru, (ERROR_DATA_SUM_MAX)*sizeof(ErrorDataStruct));
 	    curIndex = curIndex + (UINT32)((ERROR_DATA_SUM_MAX)*sizeof(ErrorDataStruct));
@@ -906,11 +910,19 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		curIndex = curIndex + (ROUTE_LONG_SUM_MAX)*sizeof(LongRouteDataStruct);
 #endif
 		curIndex += CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void *)LongRouteDataStru, ROUTE_LONG_SUM_MAX, (UINT16)sizeof(LongRouteDataStruct));
-
+		/*计算一次CRC*/
+		crcLength = curIndex - crcIndex;
+		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
+		debug_infor_printf((const)"2oo2 g_OCStationIndicDataStru-LongRouteDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
+		crcIndex = curIndex;
 		/*拷贝通信状态结构体*/
 		(void)memcpy(pCiAppDataPointer + curIndex, TransmitStateDataStru, (TRANSMIT_OBJECT_SUM_MAX * TRANSMIT_OBJECT_DEVICE_SUM_MAX)*sizeof(TransmitStateDataStruct));
 		curIndex = curIndex + (UINT32)((TRANSMIT_OBJECT_SUM_MAX * TRANSMIT_OBJECT_DEVICE_SUM_MAX)*sizeof(TransmitStateDataStruct));
-
+		/*计算一次CRC*/
+		debug_out_array(0xAA, TransmitStateDataStru, (TRANSMIT_OBJECT_SUM_MAX * TRANSMIT_OBJECT_DEVICE_SUM_MAX) * sizeof(TransmitStateDataStruct));
+		crcLength = curIndex - crcIndex;
+		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
+		debug_infor_printf((const)"2oo2 LongRouteDataStru-TransmitStateDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
         /*拷贝CI操作命令反馈结构体数组*/
         (void)memcpy(pCiAppDataPointer + curIndex, CiSendCmdDataStru, (CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX)*sizeof(CommandDataStruct));
 		curIndex = curIndex + (UINT32)((CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX)*sizeof(CommandDataStruct));
@@ -918,7 +930,11 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
         /*拷贝CI发送到其他联锁命令结构体数组*/
         (void)memcpy(pCiAppDataPointer + curIndex, SendCiCmdDataStru, (SENDCI_CMD_DATA_STRU_SUM_MAX)*sizeof(ToCiCommandDataStruct));
 		curIndex = curIndex + (UINT32)((SENDCI_CMD_DATA_STRU_SUM_MAX)*sizeof(ToCiCommandDataStruct));
-
+		/*计算一次CRC*/
+		crcLength = curIndex - crcIndex;
+		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
+		debug_infor_printf((const)"2oo2 TransmitStateDataStru-SendCiCmdDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
+		crcIndex = curIndex;
         /*拷贝与联锁通信的Vobc信息*/
 		curResult = CopyValidGetVobcDataStru(pCiAppDataPointer + curIndex, VobcToCiDataStru, VOBC_TO_CI_SUM_MAX);
 		curIndex = curIndex + curResult;
@@ -926,7 +942,10 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		/*拷贝使用后备模式与联锁通信的Vobc信息*/
 		curResult = CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void *)VobcBackUpToCiDataStru, VOBC_BACKUP_TO_CI_SUM_MAX, (UINT16)sizeof(VobcBackUpToCiDataStruct));
 		curIndex = curIndex + curResult;
-
+		/*计算一次CRC*/
+		crcLength = curIndex - crcIndex;
+		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
+		debug_infor_printf((const)"2oo2 SendCiCmdDataStru-VobcBackUpToCiDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
 		/*拷贝与联锁通信的ITE信息*/
 		curResult = CopyValidGetIteDataStru(pCiAppDataPointer + curIndex, IteToCiDataStru, ITE_TO_CI_SUM_MAX);
 		curIndex = curIndex + curResult;
@@ -942,7 +961,7 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		/*计算一次CRC*/
 		crcLength = curIndex - crcIndex;
 		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 IndicatorDataStru-AllAutoReturnDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
+		debug_infor_printf((const)"2oo2 VobcBackUpToCiDataStru-AllAutoReturnDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
 		crcIndex = curIndex;
 
         /*拷贝车库门数据结构体*/
@@ -1324,6 +1343,11 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_LocalSnowModel), (UINT32)sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 
+		/*计算一次CRC*/
+		crcLength = curIndex - crcIndex;
+		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
+		debug_infor_printf((const)"2oo2 Deploy_GetTransferData-g_LocalSnowModel CRC:%x, Length:%d\n", crcResult, crcLength);
+
 		/*拷贝本地相邻联锁接受命令信息*/
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT16), (const void*)(&RecvCiCmdDataStruCurSum), (UINT32)sizeof(UINT16));
 		curIndex = curIndex + (UINT32)sizeof(UINT16);
@@ -1359,7 +1383,7 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		/*计算一次CRC*/
 		crcLength = curIndex - crcIndex;
 		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 Deploy_GetTransferData-g_LocalSnowModel CRC:%x, Length:%d\n", crcResult, crcLength);
+		debug_infor_printf((const)"2oo2 RecvCiCmdDataStruCurSum-gPlatDataGPIOTolercance CRC:%x, Length:%d\n", crcResult, crcLength);
 	}
 	return curIndex;
 }
@@ -1983,6 +2007,7 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			/*拷贝平台IO电源采集容忍数据*/
 			(void)CommonMemCpy((void*)(&gPlatDataGPIOTolercance), (UINT32)sizeof(PlatGPIOToleranceDataStruct), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(PlatGPIOToleranceDataStruct));
 			curIndex = curIndex + (UINT32)sizeof(PlatGPIOToleranceDataStruct);
+
 #endif
 			rtn = 1u;
 		}

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

@@ -87,15 +87,14 @@ UINT8 aam_PrepareACStatus(UINT16 ACID)
  * @param[in] UINT16 ACID 基准计轴ID
  * @param[in] UINT8 dir 查询方向
  * @param[out] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
+ * @param[out] UINT8* DirectionPointFlag  是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
  * @return UINT8_MAX 查询失败
            0~AC_MAXCNT_IN_SWITCH  查询成功
  * @note 无
  */
-UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH])
+UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH], UINT8* DirectionPointFlag)
 {
-	UINT8 cDirectionPointFlag = 0U;			/*是否具有方向变化点标志*/
+	return elm_PrepareAdjacentAC(ACID, dir, arACID, DirectionPointFlag);
-
-	return elm_PrepareAdjacentAC(ACID, dir, arACID, &cDirectionPointFlag);
 }
 
 /**

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

@@ -89,11 +89,12 @@ UINT8 aam_PrepareACStatus(UINT16 ACID);
  * @param[in] UINT16 ACID 基准计轴ID
  * @param[in] UINT8 dir 查询方向
  * @param[out] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
+ * @param[out] UINT8* DirectionPointFlag  是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
  * @return UINT8_MAX 查询失败
            0~AC_MAXCNT_IN_SWITCH  查询成功
  * @note 无
  */
-UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH]);
+UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH], UINT8* DirectionPointFlag);
 
 /**
  * @brief 通过计轴区段ID查找计轴区段位置

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

@@ -182,9 +182,12 @@ UINT8 aam_SetAxisAssert(UINT16 acIndex,const AxisAsserStruct* pBuff)
  */
 void aam_ResetAxisAssertByACIndex(UINT16 acIndex)
 {
+	UINT8 chCanArbTag = 0U;/*保留Arb判断*/
 	if ((0U != acIndex) && (acIndex < AXIS_SECTION_SUM_MAX))
 	{
+		chCanArbTag = gs_AxisAssert[acIndex].redunOverCanArb;
 		(void)CommonMemSet(&gs_AxisAssert[acIndex], (UINT32)sizeof(AxisAsserStruct),0, (UINT32)sizeof(AxisAsserStruct));
+		gs_AxisAssert[acIndex].redunOverCanArb = chCanArbTag;
 	}
 }
 

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

@@ -319,8 +319,15 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 	UINT8 cAxisCommBadArbFlag = AAM_COMM_BAD_ARB_NO;
 	UINT8 chPhyTrainCheck = CI_SUCCESS;
 	UINT8 cAcCbtcAttr = 0U;  /*计轴区段CBTC区域属性*/
+	UINT8 cAcRelEnvelopeCnt = 0U;  /*计轴区段包络数量*/
+	UINT32 dwOccupyStartCyc = 0U;/*计轴占用起始周期号*/
+	UINT32 dwCurCyc = 0U;/*当前周期号*/
+	UINT8 DirectionPointSameSide = DIRECTIONPOINT_FLAG_INVALID;
+	UINT8 DirectionPointConvertSide = DIRECTIONPOINT_FLAG_INVALID;
+	EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
 
 	chSwitch = aam_PrepareArbSwitch();
+	dwCurCyc = Get2oo2CurCycleNum(); 
 	if (CI_SUCCESS == chSwitch)
 	{
 		;
@@ -337,10 +344,10 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 	else
 	{
 		/** 查询前方计轴*/
-		acSameCnt = aam_PrepareAdjacentAC(acID, EMAP_SAME_DIR, acSameID);
+		acSameCnt = aam_PrepareAdjacentAC(acID, EMAP_SAME_DIR, acSameID, &DirectionPointSameSide);
 
 		/** 查询后方计轴 */
-		acConvertCnt = aam_PrepareAdjacentAC(acID, EMAP_CONVER_DIR, acConvertID);
+		acConvertCnt = aam_PrepareAdjacentAC(acID, EMAP_CONVER_DIR, acConvertID,&DirectionPointConvertSide);
 
 		/** 获取区段由占用变空闲持续时间 */
 		maxRedunTimes = aam_PrepareRedunTimes();
@@ -358,14 +365,23 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 		}
 		else
 		{
-			/** 检查附近区段状态*/
+			/*仅在待判断计轴当周期由空闲变占用时检查*/
-			chNearbyCheck = aam_CheckNearbyTrainType(acID);
+			dwOccupyStartCyc = GetAxisSecOccCyc(acID);
+			if (dwCurCyc == dwOccupyStartCyc)
+			{
+				/** 检查附近区段状态*/
+				chNearbyCheck = aam_CheckNearbyTrainType(acID);
+			}
+			else
+			{
+				chNearbyCheck = CI_SUCCESS;
+			}
 
 			/** 处理前方计轴车辆接近*/
-			sameTrainType = aam_SearchNearbyTrainType(acID, EMAP_SAME_DIR, acSameCnt, acSameID);
+			sameTrainType = aam_CheckNearbyTrainEnvelopeType(acID, EMAP_SAME_DIR, acSameCnt, acSameID, DirectionPointSameSide);
 
 			/** 处理后方计轴车辆接近 */
-			convertTrainType = aam_SearchNearbyTrainType(acID, EMAP_CONVER_DIR, acConvertCnt, acConvertID);
+			convertTrainType = aam_CheckNearbyTrainEnvelopeType(acID, EMAP_CONVER_DIR, acConvertCnt, acConvertID, DirectionPointConvertSide);
 
 			/*检查所属物理区段有无故障车*/
 			chPhyTrainCheck = aam_CheckPhyTrain(acID);
@@ -393,30 +409,27 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 			{
 				; /*继续处理*/
 			}
-			/** 判断相邻范围内计轴坏车最近占用时间检查通过 */
+			
-			if ((CI_ERROR == chNearbyCheck))
+			/*有 坏车接近 或左右相邻计轴均无车接近 立即清除冗余计时*/
+			if ((AAM_BAD_NEAR == sameTrainType) || (AAM_BAD_NEAR == convertTrainType))
 			{
-				/*有 坏车接近 或左右相邻计轴均无车接近 立即清除冗余计时*/
+				/** 清除之前的冗余计时位 */
-				if ((AAM_BAD_NEAR == sameTrainType) || (AAM_BAD_NEAR == convertTrainType))
+				funRtn = aam_ClearPassTrainFlag(acIndex);
-				{
+				ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x20000000u);
-					/** 清除之前的冗余计时位 */
-					funRtn = aam_ClearPassTrainFlag(acIndex);
-					ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x20000000u);
 
-					funRtn = aam_ClearRedunTime(acIndex);
+				funRtn = aam_ClearRedunTime(acIndex);
-					ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x10000000u);
+				ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x10000000u);
 
-					aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
+				aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
-					AAM_LOG(AAM_LOG_FATAL, "info:AC%d not match ARB  condition, NearByTrainCheck:%d.\n", acID, chNearbyCheck);
+				AAM_LOG(AAM_LOG_FATAL, "info:AC%d not match ARB  condition, NearByTrainCheck:%d.\n", acID, chNearbyCheck);
-				}
+			}
-				else
+			else if (CI_ERROR == chNearbyCheck)
-				{
+			{
-					/** 冗余计时位加1*/
+				/** 范围内坏车失败 UT冗余*/
-					aam_AddRedunTime(acIndex, maxRedunTimes);
+				aam_AddRedunTime(acIndex, maxRedunTimes);
 
-					/*置标志位*/
+				/*置标志位*/
-					aam_SetAxisRedunCanArbFlag(acIndex, REDUN_OVER_ARB_NO);
+				aam_SetAxisRedunCanArbFlag(acIndex, REDUN_OVER_ARB_NO);
-				}
 			}
 			else
 			{
@@ -435,21 +448,14 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 			{
 				if (AAM_STATUS_ARB == tmpACStatus)
 				{
-					/** 计轴已经ARB 检查防护范围 防护失败不应维持ARB*/
+					/** 计轴已经ARB 不检查防护范围*/
-					if (CI_ERROR == chNearbyCheck)
+					cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(acID, strEnvelopeInfo);
+					if ((0U < cAcRelEnvelopeCnt) && (SECTION_REL_ENVELOPE_SUM_MAX > cAcRelEnvelopeCnt))
 					{
-						/** 清除之前的冗余计时位 */
+						/*ARB区段存在包络，不进行ARB连续占用判断*/
-						funRtn = aam_ClearPassTrainFlag(acIndex);
-						ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x20000000u);
-
-						funRtn = aam_ClearRedunTime(acIndex);
-						ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x10000000u);
-
-						aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
-						AAM_LOG(AAM_LOG_FATAL, "info:AC%d  keep ARB Fail, NearByTrainCheck:%d.\n", acID, chNearbyCheck);
 					}
 					else
-					{						
+					{
 						/*ARB计轴区段同向相邻计轴区段连续占用*/
 						funRtn = aam_ArbContinuousOccCheck(acID, acSameCnt, acSameID);
 
@@ -1559,7 +1565,7 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 	UINT8 retVal = CI_ERROR;
 	UINT8 phyAcNum = 0u;
 	UINT16*  pACBuff = NULL;
-	UINT16 wBasePhyid = 0U;
+	UINT16 wBasePhyid = 0U;/*基准物理区段*/
 	UINT8 jj = 0U;
 	UINT8 ii = 0U;
 	UINT8 chKeepcheck = CI_SUCCESS; /*继续检查标志*/
@@ -1567,11 +1573,13 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 	UINT32 cyCheckUtCyc = 0U; /*检查周期数*/
 	UINT32 dwRecentUtCyc = 0U; /*最近坏车占用周期号*/
 	UINT16 wCheckPhySec = 0U; /*待检查区段*/
-	UINT16* wAdjacentPhyBuf = NULL; /*直接相连区段数组*/
+	UINT16* pAdjacentPhyBuf = NULL; /*直接相连区段数组*/
 	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
 	UINT8 chNearSecNum = 0U; /*间接相邻数量*/
-	UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
+	UINT16* pNearSecBuf = NULL; /*间接相连区段数组*/
-
+	UINT8 chSwitchPosCheck = CI_ERROR;/*当前道岔检查结果*/
+	UINT8 chTransitAcNum = 0U; /*跳转计轴数量*/
+	UINT16* pTransitAcBuf = NULL; /*跳转计轴数组*/
 	cyCheckUtCyc = GetArbProtectCheckTime();
 	wBasePhyid = aam_PrepareACBelongPhyid(ACID);
 	
@@ -1608,12 +1616,79 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 	{
 		/*Step2 :当前物理区段直接相邻物理区段所有计轴无坏车*/
 		chAdjacentPhyNum = GetAdjacentPhySecNum(wBasePhyid);
-		wAdjacentPhyBuf = GetAdjacentPhySecBuf(wBasePhyid);
+		pAdjacentPhyBuf = GetAdjacentPhySecBuf(wBasePhyid);
-		if ((0U != chAdjacentPhyNum) && (NULL != wAdjacentPhyBuf))
+		if ((0U != chAdjacentPhyNum) && (NULL != pAdjacentPhyBuf))
 		{
 			for (ii = 0; ii < chAdjacentPhyNum; ii++)
 			{
-				wCheckPhySec = wAdjacentPhyBuf[ii];
+				wCheckPhySec = pAdjacentPhyBuf[ii];
+				chSwitchPosCheck = GetAdjacentPhySecAcCheck(wBasePhyid, wCheckPhySec);
+				if (CI_SUCCESS == chSwitchPosCheck)
+				{	
+					/* 邻近区段有坏车曾占用再取消，认为坏车接近*/
+					phyAcNum = GetPAxisSectionSum(wCheckPhySec);
+					pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);			
+					/*遍历计轴上最近坏车占用周期*/
+					if ((0U != phyAcNum) && (NULL != pACBuff))
+					{
+						for (jj = 0; jj < phyAcNum; jj++)
+						{
+							dwRecentUtCyc = GetAxisRecentUtOccupyCyc(pACBuff[jj]);
+							chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);							
+							if (CI_TIME_IN == chTimeFlag)
+							{
+								/*还在时间范围内*/
+								chKeepcheck = CI_ERROR;
+								retVal = CI_ERROR;
+								debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step2, PhySec = %d\n", ACID, wCheckPhySec);
+								break;
+							}
+						}
+					}
+					else
+					{
+						chKeepcheck = CI_ERROR;
+					}
+				}
+				else
+				{
+					;/*不处理*/
+					debug_infor_printf((const)"ACid: %d ,AdjacentSec Skip PhySec = %d\n", ACID, wCheckPhySec);
+				}
+			}
+		}
+		else
+		{
+			chKeepcheck = CI_ERROR;
+		}
+	}
+
+	if (CI_SUCCESS == chKeepcheck)
+	{
+		/*Step3 :当前物理区段间接相邻物理区段所有计轴无坏车*/
+		chNearSecNum = GetNearPhySecNum(wBasePhyid);
+		pNearSecBuf = GetIndirectNearPhySecBuf(wBasePhyid);
+		for (ii = 0; ii < chNearSecNum; ii++)
+		{
+			wCheckPhySec = pNearSecBuf[ii];
+			chTransitAcNum = GetPhySecNearSecTransitAcNum(wBasePhyid, wCheckPhySec);
+			pTransitAcBuf = GetPhySecNearSecTransitAcBuf(wBasePhyid, wCheckPhySec);
+			chSwitchPosCheck = CI_ERROR;
+			if (NULL != pTransitAcBuf)
+			{
+				for (jj = 0; jj < chTransitAcNum; jj++)
+				{
+					chSwitchPosCheck = GetTransitPhySecAcCheck(wBasePhyid, pTransitAcBuf[jj]);
+					if (CI_SUCCESS == chSwitchPosCheck)
+					{		
+						break;
+					}
+				}
+			}
+					
+			if (CI_SUCCESS == chSwitchPosCheck) 
+			{
+				/* 邻近可达区段有坏车曾占用再取消，认为坏车接近*/
 				phyAcNum = GetPAxisSectionSum(wCheckPhySec);
 				pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
 				/*遍历计轴上最近坏车占用周期*/
@@ -1628,7 +1703,7 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 							/*还在时间范围内 认为坏车接近*/
 							chKeepcheck = CI_ERROR;
 							retVal = CI_ERROR;
-							debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step2, PhySec = %d\n", ACID, wCheckPhySec);
+							debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step3, PhySec = %d\n", ACID, wCheckPhySec);
 							break;
 						}
 					}
@@ -1638,43 +1713,14 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 					chKeepcheck = CI_ERROR;
 				}
 			}
-		}
-		else
-		{
-			chKeepcheck = CI_ERROR;
-		}
-	}
-
-	if (CI_SUCCESS == chKeepcheck)
-	{
-		/*Step3 :当前物理区段间接相邻物理区段所有计轴无坏车*/
-		chNearSecNum = GetNearPhySecNum(wBasePhyid);
-		dwNearSecBuf = GetIndirectNearPhySecBuf(wBasePhyid);
-		for (ii = 0; ii < chNearSecNum; ii++)
-		{
-			wCheckPhySec = dwNearSecBuf[ii];
-			phyAcNum = GetPAxisSectionSum(wCheckPhySec);
-			pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
-			/*遍历计轴上最近坏车占用周期*/
-			if ((0U != phyAcNum) && (NULL != pACBuff))
-			{
-				for (jj = 0; jj < phyAcNum; jj++)
-				{
-					dwRecentUtCyc = GetAxisRecentUtOccupyCyc(pACBuff[jj]);
-					chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);
-					if (CI_TIME_IN == chTimeFlag)
-					{
-						/*还在时间范围内 认为坏车接近*/
-						chKeepcheck = CI_ERROR;
-						retVal = CI_ERROR;
-						debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step3, PhySec = %d\n", ACID, wCheckPhySec);
-						break;
-					}
-				}
-			}
 			else
 			{
-				chKeepcheck = CI_ERROR;
+				;/*不可达状态 坏车占用不影响*/
+				debug_infor_printf((const)"ACid: %d ,NearSec Skip PhySec = %d\n", ACID, wCheckPhySec);
+			}
+			if (CI_SUCCESS != chKeepcheck)
+			{
+				break;
 			}
 		}
 	}
@@ -2111,16 +2157,18 @@ 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*/
-	UINT8 cAcRelEnvelopeCnt = 0U;
+	UINT8 cAcRelEnvelopeCnt = 0U;  /*计轴区段包络数量*/
 	EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
 	UINT32 dwNearAxleOccStartCycNum = 0U;  /*相邻计轴区段占用起始周期*/
 	UINT8 cRcId = 0U;
 	UINT8 cFunRtn = 0U;
 	UINT16 wNearAcIndex = 0U;
+	UINT8 cPhySecPreOccState = 0U;  /*区段上周期占用状态*/
+	UINT8 cAxisSecTXSafeLocFlag = 0U;  /*计轴区段列车安全位置覆盖标志*/
 
 	wBufIndex = GetAxisSecConfigBufIndex(wAcId);  /*获取区段数组下标*/
 
@@ -2137,12 +2185,18 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
 				wNearRelPhySecId = GetAxisSecRelativePhySecId(pNearAcId[ii]);
 				if (0U != wNearRelPhySecId)
 				{
-					cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(pNearAcId[ii], strEnvelopeInfo);
+					cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(pNearAcId[ii], strEnvelopeInfo);  /*获取相邻计轴区段的包络信息*/
-					dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
+					dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);  /*获取相邻计轴区段采集占用起始周期*/
+					cPhySecPreOccState = GetPhySecPreOccupyState(wNearRelPhySecId);  /*获取相邻计轴区段上周期采集占用状态*/
+					cAxisSecTXSafeLocFlag =GetAxisTXSafeLocFlag(pNearAcId[ii]);  /*获取相邻计轴区段列车安全位置覆盖标志*/
+
 					if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
-						&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
+						&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum)
+						&& (SECTION_OCCUPY_NO == cPhySecPreOccState)
+						&& (AXIS_SECTION_SAFELOC_YES != cAxisSecTXSafeLocFlag))
 					{
-						cRetVal = CI_ERROR;  /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
+						/*相邻计轴区段无包络&&占用起始时间超过了“与计轴通信中断超时判断时间”&&相邻计轴区段上周期采集为空闲&&相邻计轴区段无列车安全位置覆盖*/
+						cRetVal = CI_ERROR;
 
 						cFunRtn = aam_PrepareACIsSelf(pNearAcId[ii], &cRcId);  /*判断相邻区段是否为本控区区段*/
 
@@ -2162,7 +2216,7 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
 					}
 					else
 					{
-						/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
+						/*继续检查*/
 					}
 				}
 				else
@@ -2182,4 +2236,210 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
 	}
 
 	return cRetVal;
+}
+
+/**
+* 功能：查询计轴区段邻近范围内包络类型
+*  @param[in] UINT16 ACID 基准计轴ID
+ * @param[in] UINT8 dir 查询方向
+ * @param[in] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
+ * @param[in] UINT8 DirectionPointFlag  是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
+* 返回值：
+		AAM_NO_TRAIN_NEAR 无车接近
+		AAM_BAD_NEAR 坏车
+		AAM_GOOD_OCC 好车占用
+		AAM_SLEEP_OCC 休眠车
+		AAM_GOOD_FAR_AWAY 好车远离
+		AAM_GOOD_NEAR 好车接近
+* Create:  fan 2026/04/11
+*/
+UINT8 aam_CheckNearbyTrainEnvelopeType(UINT16 baseACID, UINT8 Dir, UINT8 acCnt, UINT16 acID[AC_MAXCNT_IN_SWITCH], UINT8 DirectionPointFlag)
+{
+	UINT8 chAdjacentTrainType = AAM_BAD_NEAR;
+	UINT8 chFirstStepTrainType = AAM_BAD_NEAR;
+	UINT8 chSndStepTrainType = AAM_BAD_NEAR;
+	UINT8 ii = 0U;
+	UINT8 jj = 0U;
+	UINT8 kk = 0U;
+	UINT8 chRetTrainType = AAM_BAD_NEAR;
+	UINT16 wTempAcList[AC_MAXCNT_IN_SWITCH] = { 0U };
+	UINT8 chFirstStepAcCnt = 0U;
+	UINT16 wFirstStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
+	UINT8 chSndStepAcCnt = 0U;
+	UINT16 wSndStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
+	UINT32 dwArbProtectLen = 0U;/*ARB防护距离*/
+	UINT16 wArbProtectDis = GetSystemParaValue(ARB_CHECK_ALXE_SEC_LEN);
+	UINT32 dwCheckAcLen = 0U; /*找到计轴长度*/
+	UINT32 dwTempAcLen = 0U; /*计轴长度*/
+	UINT8 chChangePoitFlag = DIRECTIONPOINT_FLAG_INVALID;
+	UINT8 chTemp = 0U;
+	UINT8 chChangePoitCnt = 0U;
+	UINT8 chFirstDir = Dir;
+	UINT8 chSndDir = Dir;
+	UINT8 chLocalId = 0U;/*本联锁ID*/
+	UINT8 chAcBelongCi = 0U;
+	UINT8 chRelEnvelopeCnt = 0u;
+	UINT16 envelopeIds[SECTION_REL_ENVELOPE_SUM_MAX] = { 0u };
+	EnvelopeStruct* pTempEnvelope = NULL;/*包络信息*/
+	UINT8 chUseNvram = 0U;
+	dwArbProtectLen = (UINT32)(wArbProtectDis * 100U);
+	chLocalId = GetSystemParaLocalCiId();
+	if (0U == acCnt)
+	{
+		/*失败返回MAX 尽头线为0*/
+		chRetTrainType = AAM_NO_TRAIN_NEAR;
+	}
+	else if(AC_MAXCNT_IN_SWITCH >= acCnt)
+	{
+		for (ii = 0U; ii < acCnt; ii++)
+		{
+			wTempAcList[0] = acID[ii];
+			dwCheckAcLen = GetAxisSecTotalLen(acID[ii]);
+			chAdjacentTrainType = aam_SearchNearbyTrainType(baseACID, Dir, 1U, wTempAcList);
+			chAcBelongCi = GetAxisSectionBelongCiId(acID[ii]);
+
+			if (chAcBelongCi == chLocalId)
+			{
+				/*额外检查属于本联锁的直接相邻区段 无NVRAM车 */
+				chRelEnvelopeCnt = elm_GetEnvelopeIDsInAC(acID[ii], envelopeIds);
+				if (0u != chRelEnvelopeCnt)
+				{
+					for (jj = 0u; jj < chRelEnvelopeCnt; jj++)
+					{
+						pTempEnvelope = elm_GetEnvelopeInfoByID(envelopeIds[jj]);
+						for (kk = 0u; kk < pTempEnvelope->trianCnt; kk++)
+						{
+							chUseNvram = GetTrainNvramPosFlag(pTempEnvelope->trainID[kk]);
+							if (TRAIN_NVRAM_POS_FLAG_NO != chUseNvram)
+							{
+								chAdjacentTrainType = AAM_BAD_NEAR;
+								break;
+							}
+						}
+					}
+				}
+			}
+			/** 根据列车包络数量进行处理 */
+			if ((0U == ii) || (AAM_BAD_NEAR == chAdjacentTrainType))
+			{
+				chRetTrainType = chAdjacentTrainType;/*记录第一个结果 或更新为最坏结果*/
+			}
+			if ((AAM_NO_TRAIN_NEAR == chAdjacentTrainType) && (dwArbProtectLen > dwCheckAcLen))
+			{
+				/*路径无车 继续查找*/
+				chFirstDir = TransDirectionPointDir(DirectionPointFlag, Dir, &chChangePoitCnt);
+				chFirstStepAcCnt = aam_PrepareAdjacentAC(acID[ii], chFirstDir, wFirstStepID, &chChangePoitFlag);
+				if (UINT8_MAX != chFirstStepAcCnt)
+				{
+					for (jj = 0U; jj < chFirstStepAcCnt; jj++)
+					{
+						wTempAcList[0] = wFirstStepID[jj];
+
+						chFirstStepTrainType = aam_SearchNearbyTrainType(acID[ii], chFirstDir, 1U, wTempAcList);
+						dwTempAcLen = GetAxisSecTotalLen(wFirstStepID[jj]);
+						if ((AAM_NO_TRAIN_NEAR == chFirstStepTrainType) && (dwArbProtectLen >(dwCheckAcLen + dwTempAcLen)))
+						{
+							/*路径无车 继续查找*/
+							chSndDir = TransDirectionPointDir(chChangePoitFlag, chFirstDir, &chChangePoitCnt);
+							chSndStepAcCnt = aam_PrepareAdjacentAC(wFirstStepID[jj], chSndDir, wSndStepID, &chTemp);
+							if (UINT8_MAX != chSndStepAcCnt)
+							{
+								for (kk = 0U; kk < chSndStepAcCnt; kk++)
+								{
+									wTempAcList[0] = wSndStepID[kk];
+									chSndStepTrainType = aam_SearchNearbyTrainType(wFirstStepID[jj], chSndDir, 1U, wTempAcList);
+									/*更新最坏结果*/
+									chFirstStepTrainType = GetWorseNearbyTrainType(chFirstStepTrainType, chSndStepTrainType);
+									if (AAM_BAD_NEAR == chFirstStepTrainType)
+									{
+										/*可以停止遍历其他计轴*/
+										break;
+									}
+								}
+							}
+							else
+							{
+								/*异常防护*/
+								chFirstStepTrainType = AAM_BAD_NEAR;
+								break;
+							}
+						}
+						else
+						{
+							;/*停止当前路线*/
+						}
+						/*更新最坏结果*/
+						chAdjacentTrainType = GetWorseNearbyTrainType(chAdjacentTrainType, chFirstStepTrainType);
+						if (AAM_BAD_NEAR == chAdjacentTrainType)
+						{
+							/*可以停止遍历其他计轴*/
+							break;
+						}
+					}
+				}
+				else
+				{
+					/*异常防护*/
+					chAdjacentTrainType = AAM_BAD_NEAR;
+					break;
+				}
+			}
+			else
+			{
+				;/*停止当前路线*/
+			}
+			/*更新最坏结果*/
+			chRetTrainType = GetWorseNearbyTrainType(chRetTrainType, chAdjacentTrainType);
+			if (AAM_BAD_NEAR == chRetTrainType)
+			{
+				/*可以停止遍历其他计轴*/
+				break;
+			}
+		}
+	}
+	else
+	{
+		;/*返回坏车*/
+	}
+	return chRetTrainType;
+}
+
+
+/**
+* 功能：更新路线上更有风险的结果
+* 输入参数：UINT8 chPreType当前记录类型  UINT8 chAfterType比较的更新列车类型 
+* 返回值：
+AAM_NO_TRAIN_NEAR 无车接近
+AAM_BAD_NEAR 坏车
+AAM_GOOD_OCC 好车占用
+AAM_SLEEP_OCC 休眠车
+AAM_GOOD_FAR_AWAY 好车远离
+AAM_GOOD_NEAR 好车接近
+* Create:  fan 2026/04/11
+*/
+UINT8 GetWorseNearbyTrainType(UINT8 chPreType, UINT8 chAfterType)
+{
+	/*定义结果严重程度： 坏车接近>休眠车>好车占用>其他>无车*/
+	UINT8 chRetval = AAM_BAD_NEAR;
+	if ((AAM_BAD_NEAR == chPreType)||(AAM_BAD_NEAR == chAfterType))
+	{
+		chRetval = AAM_BAD_NEAR;
+	}
+	else if ((AAM_SLEEP_OCC == chPreType) || (AAM_SLEEP_OCC == chAfterType))
+	{
+		chRetval = AAM_SLEEP_OCC;
+	}
+	else if ((AAM_GOOD_OCC == chPreType) || (AAM_GOOD_OCC == chAfterType))
+	{
+		chRetval = AAM_GOOD_OCC;
+	}
+	else if(AAM_NO_TRAIN_NEAR == chPreType)
+	{
+		chRetval = chAfterType;
+	}
+	else
+	{
+		chRetval = chPreType;
+	}
+	return chRetval;
 }

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

@@ -233,4 +233,36 @@ UINT8 aam_CheckPhyTrain(UINT16 ACID);
 */
 UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH]);
 
+
+/**
+* 功能：查询计轴区段邻近范围内包络类型
+* 输入参数：UINT16 ACID 计轴区段
+* @param[in] UINT16 ACID 基准计轴ID
+* @param[in] UINT8 dir 查询方向
+* @param[in] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
+* @param[in] UINT8 DirectionPointFlag  是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
+AAM_NO_TRAIN_NEAR 无车接近
+AAM_BAD_NEAR 坏车
+AAM_GOOD_OCC 好车占用
+AAM_SLEEP_OCC 休眠车
+AAM_GOOD_FAR_AWAY 好车远离
+AAM_GOOD_NEAR 好车接近
+* Create:  fan 2026/04/11
+*/
+UINT8 aam_CheckNearbyTrainEnvelopeType(UINT16 baseACID, UINT8 Dir, UINT8 acCnt, UINT16 acID[AC_MAXCNT_IN_SWITCH], UINT8 DirectionPointFlag);
+
+
+/**
+* 功能：更新路线上更有风险的列车类型结果
+* 输入参数：UINT8 chPreType当前记录类型  UINT8 chAfterType比较的更新列车类型
+* 返回值：
+AAM_NO_TRAIN_NEAR 无车接近
+AAM_BAD_NEAR 坏车
+AAM_GOOD_OCC 好车占用
+AAM_SLEEP_OCC 休眠车
+AAM_GOOD_FAR_AWAY 好车远离
+AAM_GOOD_NEAR 好车接近
+* Create:  fan 2026/04/11
+*/
+UINT8 GetWorseNearbyTrainType(UINT8 chPreType, UINT8 chAfterType);
 #endif /*AXIS_ASSERT_MANAGE_API_H_*/

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

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

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

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

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

@@ -667,65 +667,205 @@ void SetCfpOtherOcEData(const UINT16 wCfpId, const UINT8 chEnvelopeIndex, const
 * @param wCfpId 分界点ID
 * @return 无
 * @note 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接
+* @note 内部优化 20260413 相邻联锁发送按照分界点计轴向内方计算一个ARB防护距离
 */
 void SetCfpLocalOcEData(const UINT16 wCfpId)
 {
 	UINT16 wIndex = 0u;
 	UINT8 chEnvelopeNum = 0u;
 	UINT16 wLinkId = 0u;
-	UINT16 wAcId = 0u;
+	UINT16 tmpACCnt = 0U;
+	UINT16 tmpAcIdBuf[AC_MAXCNT_IN_SWITCH] = { 0U };
 	UINT8 chEnvelopeIndex = 0u;
 	EnvelopeStruct szTmpEnvelope[SECTION_REL_ENVELOPE_SUM_MAX] = { 0u };
 	UINT8 chLocalId = 0u;
 	UINT16 wLinkTioc = 0u;
-
+	UINT16 wArbProtectDis = GetSystemParaValue(ARB_CHECK_ALXE_SEC_LEN);
+	UINT32 dwCheckAcLen = 0U; /*找到计轴长度*/
+	UINT32 dwFirstStepAcLen = 0U; /*找到计轴长度*/
+	UINT32 dwArbProtectLen = 0U;/*ARB防护距离*/
+	UINT8 chLocalCiType = 0U;
+	UINT8 chDir = 0U; /*分界点计轴方向*/
+	UINT8 chFirstStepAcCnt = 0U;
+	UINT16 wFirstStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
+	UINT8 chSndStepAcCnt = 0U;
+	UINT16 wSndStepID[AC_MAXCNT_IN_SWITCH] = { 0U }; 
+	UINT8 chChangePoint = 0U;
+	UINT8 ii = 0U;
+	UINT8 jj = 0U;
+	UINT8 chCfpAcIndex = 0U;
+	UINT8 chStepCheck = CI_ERROR;
+	UINT8 chNextDir = 0U;
+	UINT8 chPointNum = 0u;					
+	UINT8 chAcBelongTioc = 0U;
+	UINT8 chFail = CI_SUCCESS;
 	wIndex = GetCfpBufIndex(wCfpId);
 	chLocalId = GetSystemParaLocalCiId();
+	dwArbProtectLen = (UINT32)(wArbProtectDis * 100U);
+	chLocalCiType = GetLocalCiType();
 	/* 输入合法 */
 	if (CUTOFF_POINT_SUM_MAX > wIndex)
 	{
 		wLinkId = GetCfpInFirstLink(wCfpId);
-		wAcId = GetLinkBelongAcId(wLinkId);
+		/*清除脏数据*/
-		chEnvelopeNum = elm_GetEnvelopeInAC(wAcId, szTmpEnvelope);
+		g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = 0U;
-		if (SECTION_REL_ENVELOPE_SUM_MAX == chEnvelopeNum)
+		(void)CommonMemSet(&g_CutoffPointDataBuf[wIndex].szLocalEnvelope, (UINT32)((OTHER_RC_SEND_ENVELOPE_SUM_MAX)*sizeof(CfpEnvelopeStruct)), 0U, (UINT32)((OTHER_RC_SEND_ENVELOPE_SUM_MAX)*sizeof(CfpEnvelopeStruct)));
+		chStepCheck = GetAxisSeqFromLinkSeq(&wLinkId, 1u, tmpAcIdBuf, &tmpACCnt, AC_MAXCNT_IN_SWITCH);
+		chDir = GetCfpLocDir(wCfpId);
+		if ((CI_SUCCESS == chStepCheck) && (0u != tmpACCnt))
 		{
-			;
+			for (chCfpAcIndex = 0U; chCfpAcIndex < tmpACCnt; chCfpAcIndex++)
-		}
-		else
-		{/* 将包络信息添加到分界点动态数据 */
-			g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = chEnvelopeNum;
-			for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
 			{
-				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].envelopeType = szTmpEnvelope[chEnvelopeIndex].envelopeType;
+				chEnvelopeNum = elm_GetEnvelopeInAC(tmpAcIdBuf[chCfpAcIndex], szTmpEnvelope);
-				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].headTrainID = szTmpEnvelope[chEnvelopeIndex].headTrainID;
+				chFail = CI_SUCCESS;
-				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].tailTrainID = szTmpEnvelope[chEnvelopeIndex].tailTrainID;
+				if (SECTION_REL_ENVELOPE_SUM_MAX == chEnvelopeNum)
-				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos = szTmpEnvelope[chEnvelopeIndex].startPos;
-				wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk);
-				/* 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接*/
-				if (wLinkTioc != chLocalId)
 				{
-					(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
+					/*查找失败 添加坏车包络*/
-						g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off, \
+					chEnvelopeNum = 1U;
-						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
+					(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[0]);
-						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off);
 				}
-				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos = szTmpEnvelope[chEnvelopeIndex].endPos;
+				/*将包络信息添加到分界点动态数据 */
-				wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk);
+				g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum += chEnvelopeNum;
-				if (wLinkTioc != chLocalId)
+				
+				for (chEnvelopeIndex = 0U; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
 				{
-					(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
+					chStepCheck = CutCfpOtherOcEData(tmpAcIdBuf[chCfpAcIndex], &szTmpEnvelope[chEnvelopeIndex], chDir);
-						g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off, \
+					if (CI_ERROR == chStepCheck)
-						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
+					{
-						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off);
+						/*截取失败设置坏车*/
-				}
+						(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[chEnvelopeIndex]);
-				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trianCnt = szTmpEnvelope[chEnvelopeIndex].trianCnt;
+					}
-				(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID), \
+					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].envelopeType = szTmpEnvelope[chEnvelopeIndex].envelopeType;
-					szTmpEnvelope[chEnvelopeIndex].trainID, (UINT32)sizeof(szTmpEnvelope[chEnvelopeIndex].trainID));
+					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].headTrainID = szTmpEnvelope[chEnvelopeIndex].headTrainID;
+					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].tailTrainID = szTmpEnvelope[chEnvelopeIndex].tailTrainID;
+					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos = szTmpEnvelope[chEnvelopeIndex].startPos;
+					wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk);
+					/* 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接*/
+					if (wLinkTioc != chLocalId)
+					{
+						(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off, \
+							&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
+							&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off);
+					}
+					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos = szTmpEnvelope[chEnvelopeIndex].endPos;
+					wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk);
+					if (wLinkTioc != chLocalId)
+					{
+						(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off, \
+							&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
+							&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off);
+					}
+					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trianCnt = szTmpEnvelope[chEnvelopeIndex].trianCnt;
+					(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID), \
+						szTmpEnvelope[chEnvelopeIndex].trainID, (UINT32)sizeof(szTmpEnvelope[chEnvelopeIndex].trainID));
 
-				(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort), \
+					(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort), \
-					szTmpEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(szTmpEnvelope[chEnvelopeIndex].ACTPort));
+						szTmpEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(szTmpEnvelope[chEnvelopeIndex].ACTPort));
+				}
+
+				if (0U == chEnvelopeNum)
+				{
+					/*分界点无包络计轴 向本联锁内方继续查找*/
+					chStepCheck = GetAcSwitchPosCheck(tmpAcIdBuf[chCfpAcIndex]);/*本计轴道岔位置不满足时停止检查*/
+					dwCheckAcLen = GetAxisSecTotalLen(tmpAcIdBuf[chCfpAcIndex]);
+					if ((dwArbProtectLen > dwCheckAcLen) && (CI_TYPE_CLD != chLocalCiType)&&(CI_SUCCESS == chStepCheck))
+					{
+						chFirstStepAcCnt = elm_PrepareAdjacentAC(tmpAcIdBuf[chCfpAcIndex], chDir, wFirstStepID, &chChangePoint);
+						if (AC_MAXCNT_IN_SWITCH < chFirstStepAcCnt)
+						{
+							chFail = CI_ERROR;
+							(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[0]);
+							(void)CutCfpOtherOcEData(tmpAcIdBuf[chCfpAcIndex], &szTmpEnvelope[0], chDir);
+						}
+						else
+						{
+							for (ii = 0U; ii < chFirstStepAcCnt; ii++)
+							{
+								chAcBelongTioc = GetAxisSectionBelongCiId(tmpAcIdBuf[chCfpAcIndex]);
+								if (chAcBelongTioc == chLocalId)
+								{
+									chStepCheck = SetCfpLocalArbDistanceData(wFirstStepID[ii], wCfpId, chDir);
+									dwFirstStepAcLen = GetAxisSecTotalLen(wFirstStepID[ii]);
+									if ((dwArbProtectLen > (dwCheckAcLen + dwFirstStepAcLen)) && (CI_SUCCESS == chStepCheck))
+									{
+										chNextDir = TransDirectionPointDir(chChangePoint, chDir, &chPointNum);
+										chSndStepAcCnt = elm_PrepareAdjacentAC(wFirstStepID[ii], chNextDir, wSndStepID, &chChangePoint);
+										if (AC_MAXCNT_IN_SWITCH < chFirstStepAcCnt)
+										{
+											chFail = CI_ERROR;
+											(void)elm_CreatTempUKTEnvelope(wFirstStepID[ii], chNextDir, &szTmpEnvelope[0]);
+											(void)CutCfpOtherOcEData(wFirstStepID[ii], &szTmpEnvelope[0], chNextDir);
+										}
+										else
+										{
+											for (jj = 0U; jj < chSndStepAcCnt; jj++)
+											{
+												chAcBelongTioc = GetAxisSectionBelongCiId(tmpAcIdBuf[chCfpAcIndex]);
+												if (chAcBelongTioc == chLocalId)
+												{
+													(void)SetCfpLocalArbDistanceData(wSndStepID[jj], wCfpId, chNextDir);
+												}
+												/*不继续添加*/
+											}
+										}
+									}
+									else
+									{
+										;/*不查找下一计轴*/
+									}
+								}
+							}
+						}
+						if (CI_ERROR == chFail)
+						{
+							/* 异常防护 生成UKT*/
+							chEnvelopeIndex = g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum;
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].envelopeType = szTmpEnvelope[0].envelopeType;
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].headTrainID = szTmpEnvelope[0].headTrainID;
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].tailTrainID = szTmpEnvelope[0].tailTrainID;
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos = szTmpEnvelope[0].startPos;
+							wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk);
+							/* 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接*/
+							if (wLinkTioc != chLocalId)
+							{
+								(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
+									g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off, \
+									&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
+									&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off);
+							}
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos = szTmpEnvelope[0].endPos;
+							wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk);
+							if (wLinkTioc != chLocalId)
+							{
+								(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
+									g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off, \
+									&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
+									&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off);
+							}
+							g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trianCnt = szTmpEnvelope[0].trianCnt;
+							(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID), \
+								szTmpEnvelope[0].trainID, (UINT32)sizeof(szTmpEnvelope[0].trainID));
+
+							(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort), \
+								szTmpEnvelope[0].ACTPort, (UINT32)sizeof(szTmpEnvelope[0].ACTPort));
+							g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum++;
+						}
+					}
+				}
+				else
+				{
+					;/*找到列车包络 不再查找该计轴后续方向*/
+				}
 			}
 		}
+		else
+		{
+
+		}
+	
+	
 	}
 	else
 	{
@@ -739,7 +879,7 @@ void SetCfpLocalOcEData(const UINT16 wCfpId)
 * @param CfpEnvelopeStruct szEnvelope 包络数据
 * @return 包络数量
 */
-UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[SECTION_REL_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX])
+UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX])
 {
 	UINT16 wCfpIndex = 0u;
 	UINT16 wCfpId = 0u;
@@ -880,22 +1020,16 @@ UINT8 GetCfpLocalOcCtNum(const UINT16 wCfpId)
 
 /**
 * @brief 截取分界点相邻OC发来的包络数据
-* @param wCfpId 分界点ID
+* @param wAcId 截取计轴ID UINT8 chDir 方向
-* @param CfpEnvelopeStruct* strEnvelope 包络数据
+* @param EnvelopeStruct* strEnvelope 包络数据
 * @return CI_ ERROR 截取失败
 *	      CI_ SUCCESS 截取成功
 * by cgh 20240111
+* modify fan20260413：按照计轴进行包络截取
 */
-UINT8 CutCfpOtherOcEData(const UINT16 wCfpId, CfpEnvelopeStruct* strEnvelope)
+UINT8 CutCfpOtherOcEData(const UINT16 wAcId, EnvelopeStruct* strEnvelope, UINT8 chDir)
 {
 	UINT8 chReval = CI_ERROR;
-	UINT8 chLocalCiId = 0U;/*本地联锁ID*/
-	UINT16 wLinkTioc = 0U;/*LINK所属联锁ID*/
-	UINT16 wCfpLinkId = 0U;/*分界点LINK ID*/
-	UINT32 dwCfpLinkOffset = 0U;/*分界点LINK偏移量*/
-	UINT16 wCfpSameLocLinkId = 0U;/*分界点同位点LINK ID*/
-	UINT32 dwCfpSameLocLinkOffset = 0U;/*分界点同位点LINK偏移量*/
-	UINT16 wLinkBelongAxieId = 0U;/*LINK所属计轴区段ID*/
 	UINT8 chAxieIncLinkSum = 0U;/*计轴区段包含LINK数目*/
 	UINT16* szAxieIncLink = NULL;/*计轴区段包含LINK*/
 	UINT8 ii = 0U;
@@ -904,111 +1038,85 @@ UINT8 CutCfpOtherOcEData(const UINT16 wCfpId, CfpEnvelopeStruct* strEnvelope)
 	UINT8 chEnvelopeEndFlag = 0U;/*包络终端是否在计轴区段标志*/
 	ELM_AxisLocStruct tmpAxieSecLoc = { 0U };/*计轴区段位置*/
 
-	if (CUTOFF_POINT_SUM_MAX > wCfpId)
+	if (AXIS_SECTION_SUM_MAX > wAcId)
 	{
 		/*只截取UCT包络*/
 		if ((TYPE_UCT_ENVELOPE == strEnvelope->envelopeType) || (TYPE_CT_ENVELOPE == strEnvelope->envelopeType))
 		{
-			chLocalCiId = GetSystemParaLocalCiId();
+			chAxieIncLinkSum = GetAxisLinkSum(wAcId);
-			wCfpLinkId = GetCfpLink(wCfpId);
+			szAxieIncLink = GetAxisLinkIdBuf(wAcId);
-			dwCfpLinkOffset = GetCfpOffset(wCfpId);
+			chKeepFlag = elm_PrepareACLoc(wAcId, chDir, &tmpAxieSecLoc);
-			wLinkTioc = GetLinkManageTiocById(wCfpLinkId);
-
-			if (chLocalCiId == wLinkTioc)
-			{
-				/*分界点数据配置的位置为本联锁，需要转换为相邻联锁的同位点*/
-				chKeepFlag = dsuCheckSameLoc(wCfpLinkId, dwCfpLinkOffset, &wCfpSameLocLinkId, &dwCfpSameLocLinkOffset);
-			}
-			else
-			{
-				/*分界点LINK属于相邻联锁，此时使用分界点对应的LINK数据*/
-				chKeepFlag = CI_SUCCESS;
-				wCfpSameLocLinkId = wCfpLinkId;
-				dwCfpSameLocLinkOffset = dwCfpLinkOffset;
-			}
 
 			if (CI_SUCCESS == chKeepFlag)
 			{
-				wLinkBelongAxieId = GetLinkBelongAcId(wCfpSameLocLinkId);
+				for (ii = 0U; ii < chAxieIncLinkSum; ii++)
-				chAxieIncLinkSum = GetAxisLinkSum(wLinkBelongAxieId);
-				szAxieIncLink = GetAxisLinkIdBuf(wLinkBelongAxieId);
-				chKeepFlag = elm_PrepareACLoc(wLinkBelongAxieId, ELM_DIR_SAME, &tmpAxieSecLoc);
-
-				if (CI_SUCCESS == chKeepFlag)
 				{
-					for (ii = 0U; ii < chAxieIncLinkSum; ii++)
+					if (szAxieIncLink[ii] == strEnvelope->startPos.Lnk)
 					{
-						if (szAxieIncLink[ii] == strEnvelope->startPos.Lnk)
+						chEnvelopeStartFlag = CI_SUCCESS;
-						{
+						break;
-							chEnvelopeStartFlag = CI_SUCCESS;
-							break;
-						}
-						else
-						{
-							; /*继续找*/
-						}
-					}
-
-					for (ii = 0U; ii < chAxieIncLinkSum; ii++)
-					{
-						if (szAxieIncLink[ii] == strEnvelope->endPos.Lnk)
-						{
-							chEnvelopeEndFlag = CI_SUCCESS;
-							break;
-						}
-						else
-						{
-							; /*继续找*/
-						}
-					}
-
-					chReval = CI_SUCCESS;
-					if ((CI_SUCCESS == chEnvelopeStartFlag) && (CI_SUCCESS == chEnvelopeEndFlag))
-					{
-						; /*包络始端端均在计轴区段内，不截取*/
-					}
-					else if (CI_SUCCESS == chEnvelopeStartFlag)
-					{
-						/*包络始端在计轴区段内*/
-						strEnvelope->endPos.Dir = strEnvelope->startPos.Dir;
-						if (EMAP_SAME_DIR == strEnvelope->startPos.Dir)
-						{
-							/*包络始端方向为逻辑正方向，截取的包络终端为计轴区段终点*/
-							strEnvelope->endPos.Lnk = tmpAxieSecLoc.endPos.Lnk;
-							strEnvelope->endPos.Off = tmpAxieSecLoc.endPos.Off;
-						}
-						else
-						{
-							/*包络始端方向为逻辑反方向，截取的包络终端为计轴区段起点*/
-							strEnvelope->endPos.Lnk = tmpAxieSecLoc.startPos.Lnk;
-							strEnvelope->endPos.Off = tmpAxieSecLoc.startPos.Off;
-						}
-					}
-					else if (CI_SUCCESS == chEnvelopeEndFlag)
-					{
-						/*包络终端在计轴区段内*/
-						strEnvelope->startPos.Dir = strEnvelope->endPos.Dir;
-						if (EMAP_SAME_DIR == strEnvelope->endPos.Dir)
-						{
-							/*包络尾方向为逻辑正方向，截取的包络终端为计轴区段起点*/
-							strEnvelope->startPos.Lnk = tmpAxieSecLoc.startPos.Lnk;
-							strEnvelope->startPos.Off = tmpAxieSecLoc.startPos.Off;
-						}
-						else
-						{
-							/*包络尾方向为逻辑反方向，截取的包络终端为计轴区段终点*/
-							strEnvelope->startPos.Lnk = tmpAxieSecLoc.endPos.Lnk;
-							strEnvelope->startPos.Off = tmpAxieSecLoc.endPos.Off;
-						}
 					}
 					else
 					{
-						chReval = CI_ERROR;
+						; /*继续找*/
+					}
+				}
+
+				for (ii = 0U; ii < chAxieIncLinkSum; ii++)
+				{
+					if (szAxieIncLink[ii] == strEnvelope->endPos.Lnk)
+					{
+						chEnvelopeEndFlag = CI_SUCCESS;
+						break;
+					}
+					else
+					{
+						; /*继续找*/
+					}
+				}
+
+				chReval = CI_SUCCESS;
+				if ((CI_SUCCESS == chEnvelopeStartFlag) && (CI_SUCCESS == chEnvelopeEndFlag))
+				{
+					; /*包络始端端均在计轴区段内，不截取*/
+				}
+				else if (CI_SUCCESS == chEnvelopeStartFlag)
+				{
+					/*包络始端在计轴区段内*/
+					strEnvelope->endPos.Dir = strEnvelope->startPos.Dir;
+					if (EMAP_SAME_DIR == strEnvelope->startPos.Dir)
+					{
+						/*包络始端方向为逻辑正方向，截取的包络终端为计轴区段终点*/
+						strEnvelope->endPos.Lnk = tmpAxieSecLoc.endPos.Lnk;
+						strEnvelope->endPos.Off = tmpAxieSecLoc.endPos.Off;
+					}
+					else
+					{
+						/*包络始端方向为逻辑反方向，截取的包络终端为计轴区段起点*/
+						strEnvelope->endPos.Lnk = tmpAxieSecLoc.startPos.Lnk;
+						strEnvelope->endPos.Off = tmpAxieSecLoc.startPos.Off;
+					}
+				}
+				else if (CI_SUCCESS == chEnvelopeEndFlag)
+				{
+					/*包络终端在计轴区段内*/
+					strEnvelope->startPos.Dir = strEnvelope->endPos.Dir;
+					if (EMAP_SAME_DIR == strEnvelope->endPos.Dir)
+					{
+						/*包络尾方向为逻辑正方向，截取的包络终端为计轴区段起点*/
+						strEnvelope->startPos.Lnk = tmpAxieSecLoc.startPos.Lnk;
+						strEnvelope->startPos.Off = tmpAxieSecLoc.startPos.Off;
+					}
+					else
+					{
+						/*包络尾方向为逻辑反方向，截取的包络终端为计轴区段终点*/
+						strEnvelope->startPos.Lnk = tmpAxieSecLoc.endPos.Lnk;
+						strEnvelope->startPos.Off = tmpAxieSecLoc.endPos.Off;
 					}
 				}
 				else
 				{
-					;  /*返回失败*/
+					chReval = CI_ERROR;
 				}
 			}
 			else
@@ -1728,4 +1836,86 @@ void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpT
 			trainInfo->dwDis = dwLocalOffSet + dwDis;
 		}
 	}
+}
+/**
+* @brief 根据分界点内方计轴向内查找ARB防护距离内可达计轴上包络
+* 输入参数： wAcId 本联锁分界点计轴 wCfpId分界点 UINT8 chDir 方向
+* 返回值： CI_SUCCESS(计轴无包络 需继续查找) CI_ERROR（计轴存在包络）
+* Create fanwen 2026.4.13
+**/
+UINT8 SetCfpLocalArbDistanceData(const UINT16 wAcId, const UINT16 wCfpId,UINT8 chDir)
+{
+	UINT8 retVal = CI_ERROR;
+	UINT8 chEnvelopeNum = 0U;
+	EnvelopeStruct szTmpEnvelope[SECTION_REL_ENVELOPE_SUM_MAX] = { 0u };
+	UINT16 wIndex = GetCfpBufIndex(wCfpId);
+	UINT8 ii = 0u;/*索引*/
+	UINT8 chLocalId = 0u;
+	UINT16 wLinkTioc = 0u;
+	UINT8 chCurNum = 0U;
+	UINT8 chStepCheck = CI_ERROR;
+	chLocalId = GetSystemParaLocalCiId();
+	chEnvelopeNum = elm_GetEnvelopeInAC(wAcId, szTmpEnvelope);
+	chCurNum = g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum;
+	if (SECTION_REL_ENVELOPE_SUM_MAX == chEnvelopeNum)
+	{
+		/*查找失败 添加坏车包络*/
+		chEnvelopeNum = 1U;
+		(void)elm_CreatTempUKTEnvelope(wAcId, chDir, &szTmpEnvelope[0]);
+	}
+	if (0U != chEnvelopeNum)
+	{
+		if (OTHER_RC_SEND_ENVELOPE_SUM_MAX > chCurNum + chEnvelopeNum)
+		{
+			/* 将包络信息添加到分界点动态数据 */
+			g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = chCurNum + chEnvelopeNum;
+			for (ii  = 0U;  ii < chEnvelopeNum; ii ++)
+			{
+				/*仅截取本计轴*/
+				chStepCheck = CutCfpOtherOcEData(wAcId, &szTmpEnvelope[ii], chDir);
+				if (CI_ERROR == chStepCheck)
+				{
+					/*截取失败设置坏车*/
+					(void)elm_CreatTempUKTEnvelope(wAcId, chDir, &szTmpEnvelope[ii]);
+				}
+				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].envelopeType = szTmpEnvelope[ii].envelopeType;
+				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].headTrainID = szTmpEnvelope[ii].headTrainID;
+				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].tailTrainID = szTmpEnvelope[ii].tailTrainID;
+				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos = szTmpEnvelope[ii].startPos;
+				wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Lnk);
+				/* 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接*/
+				if (wLinkTioc != (UINT16)chLocalId)
+				{
+					(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Lnk, \
+						g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Off, \
+						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Lnk, \
+						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Off);
+				}
+				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos = szTmpEnvelope[ii].endPos;
+				wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Lnk);
+				if (wLinkTioc != (UINT16)chLocalId)
+				{
+					(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Lnk, \
+						g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Off, \
+						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Lnk, \
+						&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Off);
+				}
+				g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].trianCnt = szTmpEnvelope[ii].trianCnt;
+				(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].trainID, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].trainID), \
+					szTmpEnvelope[ii].trainID, (UINT32)sizeof(szTmpEnvelope[ii].trainID));
+
+				(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].ACTPort), \
+					szTmpEnvelope[ii].ACTPort, (UINT32)sizeof(szTmpEnvelope[ii].ACTPort));
+			}
+		}
+		else
+		{
+			;
+		}
+	}
+	else
+	{
+		retVal = CI_SUCCESS;/*对应计轴无包络*/
+	}
+	return retVal;
 }

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

@@ -65,9 +65,9 @@ typedef struct
 	CfpTrainInfoStru otherTiocTrainInfo;								/* 接收到的其他联锁的列车信息 */
 	CfpTrainInfoStru localTiocTrainInfo;								/* 待发送到其他联锁的列车信息 */
 	UINT8 chLocalTiocEnvelopeNum;										/* 待发送到其他联锁的包络数量 */
-	CfpEnvelopeStruct szLocalEnvelope[SECTION_REL_ENVELOPE_SUM_MAX];	/* 待发送到其他联锁的包络数量 */
+	CfpEnvelopeStruct szLocalEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX];	/* 待发送到其他联锁的包络数量 */
 	UINT8 chOtherTiocEnvelopeNum;										/* 接收到的其他联锁的包络数量 */
-	CfpEnvelopeStruct szOtherEnvelope[SECTION_REL_ENVELOPE_SUM_MAX];	/* 接收到的其他联锁的包络信息 */
+	CfpEnvelopeStruct szOtherEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX];	/* 接收到的其他联锁的包络信息 */
 	UINT8 chCtNum;														/* 分界点通信车数量 */
 	CfpCtTrainStruct szLocalCtTrain[TRAIN_SUM_MAX];						/* 分界点通信车信息 */
 	CfpRRMDataStruct szCfpRRMData;                                      /* 分界点远程RM数据*/
@@ -179,7 +179,7 @@ void SetCfpLocalOcEData(const UINT16 wCfpId);
 * @param CfpEnvelopeStruct szEnvelope 包络数据
 * @return 包络数量
 */
-UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[SECTION_REL_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX]);
+UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX]);
 
 /*
 * 功能描述： 获取边界点数据存储地址
@@ -212,13 +212,13 @@ UINT8 GetCfpLocalOcCtNum(const UINT16 wCfpId);
 
 /**
 * @brief 截取分界点相邻OC发来的包络数据
-* @param wCfpId 分界点ID
+* @param wAcId 截取计轴ID
-* @param CfpEnvelopeStruct* strEnvelope 包络数据
+* @param EnvelopeStruct* strEnvelope 包络数据 chDir方向
 * @return CI_ ERROR 截取失败
 *	      CI_ SUCCESS 截取成功
 * by cgh 20240111
 */
-UINT8 CutCfpOtherOcEData(const UINT16 wCfpId,CfpEnvelopeStruct* strEnvelope);
+UINT8 CutCfpOtherOcEData(const UINT16 wAcId, EnvelopeStruct* strEnvelope, UINT8 chDir);
 
 /**
 * @brief 获取分界点跨控区RRM源RC ID
@@ -367,6 +367,14 @@ void OtherCfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet,
 */
 void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpTrainInfoStru* trainInfo, UINT8 cDir);
 
+/**
+* @brief 根据分界点内方计轴向内查找ARB防护距离内可达计轴上包络
+* 输入参数： wAcId 本联锁分界点计轴 wCfpId分界点 UINT8 chDir 方向
+* 返回值： CI_SUCCESS(计轴无包络 需继续查找) CI_ERROR（计轴存在包络）
+* Create fanwen 2026.4.13
+**/
+UINT8 SetCfpLocalArbDistanceData(const UINT16 wAcId, const UINT16 wCfpId, UINT8 chDir);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -21,6 +21,7 @@
 #include "dquCIInterFace.h"
 #include "LogicalRouteDataManage.h"
 #include "../LogicProcess/LogicalRouteLogicCheck.h"
+#include "InterlockLogicCheck.h"
 
 UINT8 AllSignalBrightFlag = CI_ALL_SIGNAL_BRIGHT_NO;					                  /*全站亮灯标志*/
 
@@ -5949,6 +5950,8 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
 	UINT8 routeTrainNear = 0u;
 	UINT8 physicalCheck = 0u;
 	UINT8 phyPLockRouteState = 0u;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
 
 	physicalSecId = GetAxisSecRelativePhySecId(axisSectionId);
 	routeRlockId = GetPhySecRLockBelongRouteId(physicalSecId);/*物理区段进路锁闭所属进路ID*/
@@ -6093,9 +6096,41 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
 			}
 		}
 	}
+
+	/*计轴区段内所有道岔未引导总锁*/
+	if (CI_SUCCESS == reVal)
+	{
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecSwitchYZLockCheck(axisSectionId, &devId, &devState);
+	}
+
+	/*计轴区段的防护道岔未引导总锁*/
+	if (CI_SUCCESS == reVal)
+	{
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecProtSwtYLockCheck(axisSectionId, &devId, &devState);
+	}
+
+	if (CI_SUCCESS == reVal)
+	{/*检查防护道岔位置*/
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecAllProtSwitchPosCheck(axisSectionId, &devId, &devState);
+	}
+
+	if (CI_SUCCESS == reVal)
+	{/*检查防护道岔封锁状态*/
+		devId = 0u;
+		devState = 0u;
+		reVal = AxisSecProtSwitchFLockCheck(axisSectionId, &devId, &devState);
+	}
+
 	return reVal;
 }
 
+
 /*
 * 功能描述： 检查指定进路内的指定逻辑区段ID前（包含指定逻辑区段ID）的区段无UT占用
 * 参数说明： UINT16 routeId, 进路ID
@@ -6222,6 +6257,8 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 	UINT8 logSecLockState = 0U;
 	UINT8 logSecLockRouteNum = 0U;
 	UINT8 chFailStep = 0U;
+	UINT8 cYLockAlarmFlag = FLAG_UNSET;  /*引导总锁报警标志*/
+	UINT8 cYLockState = 0U;  /*引导总锁状态*/
 
 	bufIndex = GetlogSectionBufIndex(logSectionId);  /*获取区段数组下标*/
 	/**区段下标合法*/
@@ -6238,7 +6275,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 		logicCheck = LogicIntruSecVainCheck(logSectionId, &devId, &devState); /*逻辑区段侵限检查*/
 		logSecLockState = GetLogSecLogLockState(logSectionId);
 		logSecLockRouteNum = GetLogSecLockBelLogRouteSum(logSectionId);
-		
+
 		if (NULL == pLgcSecSwitchStru)
 		{
 			reVal = CI_ERROR;
@@ -6253,12 +6290,12 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 			{
 				/*调车进路锁闭*/
 				reVal = CI_ERROR;
-				chFailStep  = 1U;
+				chFailStep = 1U;
 			}
 		}
 		if (CI_SUCCESS == reVal)
 		{
-			if ((0u < logSecLockRouteNum) ||(LOG_SECTION_LOGLOCK_NO != logSecLockState))
+			if ((0u < logSecLockRouteNum) || (LOG_SECTION_LOGLOCK_NO != logSecLockState))
 			{
 				/*逻辑区段存在逻辑进路锁闭锁闭*/
 				reVal = CI_ERROR;
@@ -6282,7 +6319,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 						|| ((LOGICSECTION_OCCUPY_CT == curLogSecOccState) && (CI_ERROR == checkSulicTrain)))
 					{
 						reVal = CI_ERROR;
-						chFailStep =3U;
+						chFailStep = 3U;
 						break;
 					}
 					else
@@ -6301,7 +6338,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				routeLevel = GetRouteLevel(routePlockId);  /*获取防护锁闭所属进路监督级别*/
 				phyPLockRouteState = GetRouteState(routePlockId);  /*获取进路状态*/
 
-																   /** VBTC进路 */
+				/** VBTC进路 */
 				if (ROUTE_LEVEL_CBTC == routeLevel)
 				{
 					reVal = CI_SUCCESS; /*返回成功*/
@@ -6348,7 +6385,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 		if ((CI_SUCCESS == reVal) && (0u < routeRlockId))
 		{
 			routeLevel = GetRouteLevel(routeRlockId);  /*获取锁闭所属进路监督级别*/
-													   /*点式*/
+			/*点式*/
 			if (ROUTE_LEVEL_BLOC == routeLevel)
 			{
 				routeTrainNear = RouteHaveTrainNear(routeRlockId);
@@ -6372,7 +6409,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 
 			if ((0u != chLgcSecSwitchSum) && (NULL != pLgcSecSwitchStru))
 			{
-				for (ii = 0u; ii< chLgcSecSwitchSum; ii++)
+				for (ii = 0u; ii < chLgcSecSwitchSum; ii++)
 				{
 					curSwitchId = pLgcSecSwitchStru[ii].SwitchId;
 					if ((0u != curSwitchId) && (UINT16_MAX != curSwitchId))
@@ -6380,8 +6417,11 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 						switchCurPosition = GetSwitchCurPosition(curSwitchId);	/*获取道岔当前位置*/
 						retFlag = checkSwtLastValDrvPosStayorNot(curSwitchId, switchCurPosition);	/*检查道岔上一次驱动是否还在有效期*/
 						switchFLockState = GetSwitchFLockState(curSwitchId);	/*获取道岔封锁状态*/
-						if ((pLgcSecSwitchStru[ii].SwitchPosition != switchCurPosition) || (CI_ERROR == retFlag) || (SWITCH_LOCK_FENGSUO_YES == switchFLockState))
+						cYLockState = GetSwitchYLockState(curSwitchId);
-						{/*（判断当前计轴包含的道岔位置与道岔当前的位置有一个不同）或（某个道岔上一次驱动仍然有效）或（道岔封锁）*/
+						
+						if ((pLgcSecSwitchStru[ii].SwitchPosition != switchCurPosition) || (CI_ERROR == retFlag) || (SWITCH_LOCK_FENGSUO_YES == switchFLockState)
+							|| (SWITCH_LOCK_YINZONG_NO != cYLockState))
+						{/*（判断当前计轴包含的道岔位置与道岔当前的位置有一个不同）或（某个道岔上一次驱动仍然有效）或（道岔封锁）或（道岔引导总锁）*/
 							reVal = CI_ERROR;
 							chFailStep = 8U;
 							break;
@@ -6487,8 +6527,31 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				reVal = CI_SUCCESS;
 			}
 		}
+
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔封锁状态检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwFLockCheck(logSectionId, &devId, &devState, &cYLockAlarmFlag);/*封锁检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 13U;
+			}
+		}
+
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔位置检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwPosCheck(logSectionId, &devId, &devState);/*位置检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 14U;
+			}
+		}
+
 	}
-	else 
+	else
 	{
 		reVal = CI_ERROR;
 	}
@@ -6788,10 +6851,17 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 	AxisSwitchStruct* pRouteSwitchStru = NULL;					/*道岔数据结构指针*/
 	UINT8 innerSwitchRetVal = CI_ERROR;							/*检查计轴区段内道岔是否可被驱动的结果*/
 
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
+
 	switchSum = GetAxisSwitchSum(axisSecId);
 	pRouteSwitchStru = GetAxisSwitchIdStru(axisSecId);
 
-	if((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX))
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
+
+	if ((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX) || (NULL == pRouteSwitchStru) || (NULL == pProtectSwitchStru))
 	{
 		innerSwitchRetVal = CI_ERROR;
 	}
@@ -6800,13 +6870,13 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 		innerSwitchRetVal = CI_SUCCESS;
 
 		/* 单操相反位置取消驱动检查 */
-		for(ii = 0u; ii < switchSum; ii++)
+		for (ii = 0u; ii < switchSum; ii++)
 		{
 			switchId = pRouteSwitchStru[ii].SwitchId;
 			switchExpPosition = pRouteSwitchStru[ii].SwitchPosition;
 			switchDancaoPosition = GetSwitchDanCaoPostition(switchId);
 
-			if(	(SWITCH_POSITION_INVALID == switchDancaoPosition)
+			if ((SWITCH_POSITION_INVALID == switchDancaoPosition)
 				||
 				(switchDancaoPosition == switchExpPosition))
 			{/*单操无效 或者 单操位置与动作位置一样*/
@@ -6819,8 +6889,34 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 				break;
 			}
 		}
-		
+
-		if(innerSwitchRetVal == CI_SUCCESS)
+		if (innerSwitchRetVal == CI_SUCCESS)
+		{
+			/* 单操相反位置取消驱动检查 */
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPosition = pProtectSwitchStru[ii].SwitchPosition;
+				switchDancaoPosition = GetSwitchDanCaoPostition(switchId);
+
+				if ((SWITCH_POSITION_INVALID == switchDancaoPosition)
+					||
+					(switchDancaoPosition == switchExpPosition))
+				{/*单操无效 或者 单操位置与动作位置一样*/
+					innerSwitchRetVal = CI_SUCCESS;
+				}
+				else
+				{
+					/*单操到相反位置取消道岔的驱动*/
+					innerSwitchRetVal = CI_ERROR;
+					break;
+				}
+			}
+		}
+
+
+
+		if (innerSwitchRetVal == CI_SUCCESS)
 		{
 			/*驱动计轴区段道岔*/
 			AxisSecDrvInnerSwitch(axisSecId, SWITCH_NEED_DRIV_TRUE);
@@ -6829,16 +6925,16 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 		{
 			AxisSecDrvInnerSwitch(axisSecId, SWITCH_NEED_DRIV_FALSE);
 		}
-		
+
 	}
 
 	return innerSwitchRetVal;
-	
+
 }
 
 
 /*
-功能描述: 	驱动计轴区段内道岔处理
+功能描述: 	驱动计轴区段内道岔，计轴区段关联防护道岔处理
 输入参数:	const UINT16 axisSecId 计轴区段ID
 输出参数:	const UINT8 DrivFlag 道岔驱动标志
 返回值:		无
@@ -6850,22 +6946,36 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
 	UINT8 switchExpPos = 0u; 								/*道岔期望位置*/
 	AxisSwitchStruct* pAxisSecSwitchStru = NULL; 				/*道岔数据*/
 	UINT8 ii = 0u;											/*循环变量*/
-	UINT8 funRtn = CI_ERROR;
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
 
 	switchSum = GetAxisSwitchSum(axisSecId); /*获取计轴区段道岔数目*/
 	pAxisSecSwitchStru = GetAxisSwitchIdStru(axisSecId); /*获取计轴区段内道岔数据*/
-	
 
-	if(SWITCH_NEED_DRIV_TRUE == DrivFlag)
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
-	{/*需要驱动计轴区段内道岔*/
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
+
+	if ((NULL != pAxisSecSwitchStru) && (NULL != pProtectSwitchStru))
+	{
+		if (SWITCH_NEED_DRIV_TRUE == DrivFlag)
+		{/*需要驱动计轴区段内道岔*/
+
+			for (ii = 0u; ii < switchSum; ii++)
+			{
+				switchId = pAxisSecSwitchStru[ii].SwitchId;
+				switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
+			}
+
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPos = pProtectSwitchStru[ii].SwitchPosition;
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段防护道岔的驱动状态为驱动中*/
+			}
 
-		for(ii = 0u; ii < switchSum; ii++)
-		{
-			switchId = pAxisSecSwitchStru[ii].SwitchId;
-			switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
-			funRtn = SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
 		}
-				
 	}
 }
 
@@ -7319,20 +7429,20 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 	UINT8 retValue = CI_ERROR;
 	UINT8 chLogSecLogLockState = 0U;  /*逻辑区段逻辑锁闭状态*/
 	UINT8 cLockBelongLogicRouteNum = 0U;  /*逻辑区段逻辑锁闭所属逻辑进路数量*/
-
+	UINT8 chLogSecJumpLockState = 0U;
 	/*获取道岔关联逻辑区段信息*/
 	logSecSum = GetSwitchLogSecSum(switchId);
 	logSecBuf = GetSwitchLogSecBuf(switchId);
 
 	/*逻辑区段数据正常*/
-	if(0u != logSecSum)
+	if (0u != logSecSum)
 	{
 		/*检查逻辑区段锁闭状态*/
-		for(i = 0u; i < logSecSum; i++)
+		for (i = 0u; i < logSecSum; i++)
 		{
 			logLockState = GetLogSecLockState(logSecBuf[i]);
 			/*找到锁闭区段*/
-			if(LOG_SECTION_LOCK_NO != logLockState)
+			if (LOG_SECTION_LOCK_NO != logLockState)
 			{
 				*logOccOrLockId = logSecBuf[i];
 				*pState = logLockState;
@@ -7343,8 +7453,9 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 				/*检查逻辑区段逻辑锁闭状态*/
 				chLogSecLogLockState = GetLogSecLogLockState(logSecBuf[i]);
 				cLockBelongLogicRouteNum = GetLogSecLockBelLogRouteSum(logSecBuf[i]);
+				chLogSecJumpLockState = GetLogSecJumpLockState(logSecBuf[i]);
 
-				if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum))
+				if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum) && (LOGIC_SECTION_JUMP_LOCK_NO == chLogSecJumpLockState))
 				{
 					retValue = CI_SUCCESS;
 				}
@@ -7359,7 +7470,7 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 			if (CI_ERROR == retValue)
 			{
 				break; /*有条件检查不通过，跳出*/
-			}	
+			}
 		}
 	}
 	else
@@ -11366,4 +11477,85 @@ UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId)
 	}
 
 	return wRetVal;
-}
+}
+
+/*
+功能描述:
+	清除逻辑区段关联道岔单操位置
+输入参数:
+	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

@@ -1898,4 +1898,30 @@ void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCut
 */
 UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId);
 
+/*
+功能描述:
+	清除逻辑区段关联道岔单操位置
+输入参数:
+	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/ERROR/ErrorDefine.h

@@ -385,16 +385,6 @@
 #define ETYPE_LOGSEC_XIANSU_STATE                   ((UINT8)0xC5)       /*逻辑区段限速设置*/
 #define ETYPE_LOGSEC_FIRSTLOCK_STATE                ((UINT8)0xC6)       /*逻辑区段为第一个锁闭区段检查*/
 #define ETYPE_LOGSEC_CBTC_PROPERTY                  ((UINT8)0xC7)       /*逻辑区段CBTC属性检查*/
-#define ETYPE_LOGSEC_CONTINUOUS                     ((UINT8)0xC8)       /*逻辑区段连续性检查*/
-
-/*动态路径故障类型*/
-#define ETYPE_PART_ROUTE_RES             ((UINT8)0xD0)       /*动态路径资源检查*/
-#define ETYPE_PART_ROUTE_MATCH_ROUTE     ((UINT8)0xD1)       /*动态路径匹配进路检查*/
-#define ETYPE_PART_ROUTE_SCREEN          ((UINT8)0xD2)       /*动态路径列车筛选检查*/
-#define ETYPE_PART_ROUTE_REPEAT          ((UINT8)0xD3)       /*动态路径重复办理检查*/
-#define ETYPE_PART_ROUTE_SEC_ATTR        ((UINT8)0xD4)       /*动态路径区段属性检查*/
-#define ETYPE_PART_ROUTE_TRAIN_COMM      ((UINT8)0xD5)       /*动态路径列车通信状态检查*/
-#define ETYPE_PART_ROUTE_TRAIN_POS       ((UINT8)0xD6)       /*动态路径列车位置检查*/
 
 /* 系统故障 */
 /* 设备类型 EFUNC_LOGIC_MANAGE_SYETEM */

TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeDefine.h

@@ -28,6 +28,7 @@
 #define TRAIN_IN_ENVELOPE_SUM_MAX (15u)                                                       /*列车包络中包含的列车最大数量(开区间)*/
 #define SECTION_IN_ENVELOPE_SUM_MAX (10u)                                                     /*列车包络中包含的区段最大个数(开区间)*/
 #define SECTION_REL_ENVELOPE_SUM_MAX (15u)                                                    /*区段关联的包络最大个数(开区间)*/
+#define OTHER_RC_SEND_ENVELOPE_SUM_MAX (50u)                                                    /*相邻联锁发送最大包络数量*/
 #define TRAIN_REL_ENVELOPE_SUM_MAX (15u)                                                      /*列车关联的包络最大个数(开区间)*/
 #define MAX_ENVELOPE_LOG_NUM  (10000U)														  /*包络日志打印缓存大小*/
 

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

@@ -1199,7 +1199,7 @@ void elm_AddNextOCEnvelopetoBuff(UINT8 OCid)
 	UINT16 buffIndex = ENVELOPE_UNVAILD_INDEX;
 	UINT32 errorCode = 0u;
 	EnvelopeStruct tempEnvelope = {0u};
-	CfpEnvelopeStruct InfEnvelope[SECTION_REL_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX] = {0u};
+	CfpEnvelopeStruct InfEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX] = {0u};
 
 	/** 获取OC发送的包络信息个数 */
 	envelopeCnt = elm_PrepareNextOcInfEnvelope(OCid,InfEnvelope);

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

@@ -6161,7 +6161,7 @@ void PhySecResetToRelayStateProc(void)
 		{/*采集到ZFWJ落下，不执行计轴复位逻辑处理*/
 			retValid = CI_ERROR;
 			tmpRet = SetRelayStateUpdateCycNum(relayZFWId, 0u);	/*清除ZFW总复位继电器有效起始周期号*/
-
+			CleanPhySecResetStartCycNum();/*清除复位起始周期号*/
 			if (CI_ERROR == tmpRet)
 			{
 				/*错误处理*/
@@ -11800,8 +11800,8 @@ void ProcessPhyOCcStateToAxisSection(void)
 						{
 							chSwitchPos = GetSwitchCurPosition(pSwitchInfo[chIndex].SwitchId);
 							if ((SWITCH_POSITION_DINGWEI != chSwitchPos) && (SWITCH_POSITION_FANWEI != chSwitchPos))
-							{/* 物理区段占用，道岔四开，设置物理区段所有计轴区段占用 */
+							{/* 物理区段占用，道岔四开，继续检查 */
-								break;
+								chHitTimes++;
 							}
 							else
 							{
@@ -16442,4 +16442,47 @@ UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId)
 	}
 
 	return cRetVal;
+}
+
+
+/*
+* 功能描述：清除物理区段复位起始周期
+* 参数说明：无
+* 返 回 值：无
+* 注：解决复位指令执行期间，总复位未按下一直下发复位指令的问题
+* Created By fan 2026.03.24
+*/
+void CleanPhySecResetStartCycNum(void)
+{
+	UINT16 wPhysecNum = 0U;
+	UINT16 wPhySecId = 0U;
+	UINT16 ii = 0U;
+	UINT8 chZfwValid = CI_ERROR;
+	UINT16 wZFWrelayId = 0U;
+	UINT8 chLocalCi = 0U;
+	chLocalCi = GetSystemParaLocalCiId();
+	wPhysecNum = GetPhySecCurSum();
+	wZFWrelayId = GetZFWRelayId(chLocalCi);/*检查集中区是否存在总复位继电器*/
+	if (0U < wZFWrelayId)
+	{
+		/*集中区存在计轴复位继电器 复位过程中总复位未按下 清除复位起始周期*/
+		for (ii = 0U; ii < wPhysecNum; ii++)
+		{
+			wPhySecId = GetPhySecId(ii);
+			chZfwValid = GetZFWValidByPhySecId(wPhySecId);
+			/*区段配置总复位继电器且总复位继电器落下*/
+			if (CI_ERROR == chZfwValid)
+			{
+				SetPhySecResetStartCycNum(wPhySecId, 0U);
+			}
+			else
+			{
+				;/*不处理*/
+			}
+		}
+	}
+	else
+	{
+		;/*不处理*/
+	}
 }

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

@@ -984,6 +984,15 @@ UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
 */
 UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
 
+/*
+* 功能描述：清除物理区段复位起始周期
+* 参数说明：无
+* 返 回 值：无
+* 注：解决复位指令执行期间，总复位未按下一直下发复位指令的问题
+* Created By fan 2026.03.24
+*/
+void CleanPhySecResetStartCycNum(void);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -1432,6 +1432,7 @@ void ProcessZcToCiData(void)
 					{
 						SetAxisJumpLockState(pAxisSectionIdBuf[jj], AXIS_SECTION_JUMPLOCK_STATE_IDLE);/*通信中断设置计轴区段跳跃锁闭状态为空闲*/
 						(void)SetAxisSecJumpLockApplyCylce(pAxisSectionIdBuf[jj], 0U);/*清零计轴区段跳跃锁闭申请周期号*/
+						SetAxisRelProSwitchLockSta(pAxisSectionIdBuf[jj], SWITCH_LOCK_PROTECT_CANCEL);/*取消防护锁闭*/
 					}
 				}
 			}
@@ -2442,8 +2443,8 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 	UINT8 cLogSecSeqDir = CI_SYSTEM_DIRECTION_NONE;	/* 逻辑区段序列方向 */
 	UINT8 cFunRetVal = CI_ERROR; /* 接收函数返回值用于判断报警 */
 	UINT16 recordErrorNum = 0u;
-	UINT8 cLogSecSum = 0U;          /*逻辑区段数量*/
+	UINT8 cSectionSum = 0U;          /*区段数量*/
-	UINT16* pLogSecIdBuff = NULL;   /*逻辑区段ID数组*/
+	UINT16* pSectionIdBuff = NULL;   /*区段ID数组*/
 	UINT16 OverlapRouteId = 0U;
 
 	localCiId = GetSystemParaLocalCiId();          /*获取本机联锁ID*/
@@ -2912,8 +2913,8 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 			virCiID = AtsOrXianDiToCiCmdStru[ii].VirCIid;
 			cmdType = AtsOrXianDiToCiCmdStru[ii].CommandType;
 			trainId = AtsOrXianDiToCiCmdStru[ii].wTrainIdParam; /*命令相关的列车ID*/
-			cLogSecSum = AtsOrXianDiToCiCmdStru[ii].chLogicSecSum;
+			cSectionSum = AtsOrXianDiToCiCmdStru[ii].chSectionSum;
-			pLogSecIdBuff = AtsOrXianDiToCiCmdStru[ii].wLogicSecData;
+			pSectionIdBuff = AtsOrXianDiToCiCmdStru[ii].wSectionData;
 			recordErrorNum = GetErrorDataCurSum();
 		    /*反馈命令收到信息，根据输入命令类型判断*/
 			OrderCheckReVal = CheckIsGeneralOrder(AtsOrXianDiToCiCmdStru[ii].CommandType);
@@ -3476,32 +3477,28 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 		        break;
 		       
 		    case ATS_CMD_PHYSEC_RESET_ONE:
-		        checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_PHYSEC, CmdDeviceId);
+				cFunRetVal = CheckAxisResetCmd(virCiID, cmdType, cSectionSum, pSectionIdBuff);	/*检查命令是否能执行*/
-				belongVirCIid = GetPhySecBelongVirCiId(CmdDeviceId);
+				if(CI_SUCCESS == cFunRetVal)
-				OrderCheckReVal = CheckOrderWhetherDoing(virCiID,belongVirCIid,cmdType,CmdDeviceId);/*检查命令能否被执行*/
+				{/*检查通过*/
-				if((CI_TRUE == checkRetVal)&&(CI_SUCCESS == OrderCheckReVal))
-				{
 					checkRetVal = AFFIRM_SUCCESS;
 				}
 				else
 				{
 					checkRetVal = AFFIRM_FAIL;
 				}
-				SetCiSendCmdBackData_OrderBack(commandId,CmdDeviceId,cmdDevType,terminalId,AtsOrXianDiToCiCmdStru[ii].CommandType,RESPONSE_FIRST,checkRetVal,virCiID); 
+				SetAixsResetCiSendCmdBackData(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_FIRST, checkRetVal, virCiID, cSectionSum, pSectionIdBuff);
 		        break;
 
 		    case ATS_CMD_PHYSEC_RESET_TWO:
-				checkRetVal = CheckSecondOrderValid(commandId,CmdDeviceId,cmdDevType,terminalId,AtsOrXianDiToCiCmdStru[ii].CommandType,virCiID);
+				checkRetVal = CheckAxisResetSndOrderValid(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, virCiID, cSectionSum, pSectionIdBuff);
 				if(CI_SUCCESS  == checkRetVal)
 		        {
-		        	checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_PHYSEC, CmdDeviceId);
+					cFunRetVal = CheckAxisResetCmd(virCiID, cmdType, cSectionSum, pSectionIdBuff);	 /*检查命令是否能执行*/	        	
-					belongVirCIid = GetPhySecBelongVirCiId(CmdDeviceId);
+					if(CI_SUCCESS == cFunRetVal)
-					OrderCheckReVal = CheckOrderWhetherDoing(virCiID,belongVirCIid,cmdType,CmdDeviceId);/*检查命令能否被执行*/
-					if((CI_TRUE == checkRetVal)&&(CI_SUCCESS == OrderCheckReVal))
 					{
 						checkRetVal = AFFIRM_SUCCESS;
-		                /*区段计轴复位命令*/
+		                /*批量计轴复位命令*/
-						SetSectionResetLogicManage(CmdDeviceId, PHYSICAL_SECTION_PRE_RESET_NO);
+						BatchAixsResetLogicManage(cSectionSum, pSectionIdBuff, PHYSICAL_SECTION_PRE_RESET_NO);
 					}
 					else
 					{
@@ -3512,7 +3509,7 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 		        {
 					checkRetVal = AFFIRM_FAIL;   
 		        }
-		        SetCiSendCmdBackData_OrderBack(commandId,CmdDeviceId,cmdDevType,terminalId,AtsOrXianDiToCiCmdStru[ii].CommandType,RESPONSE_SECOND,checkRetVal,virCiID);
+				SetAixsResetCiSendCmdBackData(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_SECOND, checkRetVal, virCiID, cSectionSum, pSectionIdBuff);
 		        break;
 
 		    case ATS_CMD_BUTTON_SET_STOPCHECK:/*设置停止检查*/
@@ -4072,7 +4069,7 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 				break;
 			case ATS_CMD_ROUTE_PART_APPLY:
 				/*申请部分路径*/
-				RoutePartApplyLogicManage(cLogSecSeqDir, trainId, cLogSecSum, pLogSecIdBuff);
+				RoutePartApplyLogicManage(cLogSecSeqDir, trainId, cSectionSum, pSectionIdBuff);
 				break;
 			case ATS_CMD_OPEN_XIANSU_SIGNAL_FIRST:
 				checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_SIGNAL, CmdDeviceId);
@@ -4279,8 +4276,8 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 	UINT16 trainId = 0U;
 	UINT16 OverlapRouteId = 0U;
 	UINT8 cLogSecSeqDir = CI_SYSTEM_DIRECTION_NONE;	 /* 逻辑区段序列方向 */
-	UINT8 cLogSecSum = 0U;          /*逻辑区段数量*/
+	UINT8 cSectionSum = 0U;          /*区段数量*/
-	UINT16* pLogSecIdBuff = NULL;   /*逻辑区段ID数组*/
+	UINT16* pSectionIdBuff = NULL;   /*区段ID数组*/
 
 	/*解析ATS命令*/
 	AtsToCiCmdSum = GetCiRevCmdStruCurSum();
@@ -4615,8 +4612,8 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 		virCiID = AtsToCiCmdStru[ii].VirCIid;
 		trainId = AtsToCiCmdStru[ii].wTrainIdParam;
 		cLogSecSeqDir = (UINT8)(AtsToCiCmdStru[ii].CommandParam & 0xFFu);
-		cLogSecSum = AtsToCiCmdStru[ii].chLogicSecSum;
+		cSectionSum = AtsToCiCmdStru[ii].chSectionSum;
-		pLogSecIdBuff = AtsToCiCmdStru[ii].wLogicSecData;
+		pSectionIdBuff = AtsToCiCmdStru[ii].wSectionData;
 
 		/*反馈命令收到信息*/
 		checkReVal = CheckIsGeneralOrder(AtsToCiCmdStru[ii].CommandType);
@@ -4911,8 +4908,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
             break; 
 
 		case ATS_CMD_PHYSEC_RESET_ONE:
-
+			checkRetVal = CheckAxisResetCmd(virCiID, cmdDevType, cSectionSum, pSectionIdBuff);	/*检查命令是否能执行*/
-			checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_PHYSEC, CmdDeviceId);
 			if(CI_TRUE == checkRetVal)
 			{
 				checkRetVal = AFFIRM_SUCCESS;
@@ -4921,20 +4917,19 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 			{
 				checkRetVal = AFFIRM_FAIL;
 			}
-			SetCiSendCmdBackData_OrderBack(commandId,CmdDeviceId,cmdDevType,terminalId,AtsToCiCmdStru[ii].CommandType,RESPONSE_FIRST,checkRetVal,virCiID); 
+			SetAixsResetCiSendCmdBackData(commandId, CmdDeviceId, cmdDevType, terminalId, AtsToCiCmdStru[ii].CommandType, RESPONSE_FIRST, checkRetVal, virCiID, cSectionSum, pSectionIdBuff);
 			break;
 
 		case ATS_CMD_PHYSEC_RESET_TWO:
-			checkRetVal = CheckSecondOrderValid(commandId,CmdDeviceId,cmdDevType,terminalId,AtsToCiCmdStru[ii].CommandType,virCiID);
+			checkRetVal = CheckAxisResetSndOrderValid(commandId,CmdDeviceId,cmdDevType,terminalId,AtsToCiCmdStru[ii].CommandType,virCiID, cSectionSum, pSectionIdBuff);
 			if(CI_SUCCESS  == checkRetVal)
 			{
-				checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_PHYSEC, CmdDeviceId);
+				checkRetVal = CheckAxisResetCmd(virCiID, cmdDevType, cSectionSum, pSectionIdBuff);	/*检查命令是否能执行*/
-
 				if(CI_TRUE == checkRetVal)
 				{
 					checkRetVal = AFFIRM_SUCCESS;
-					/*区段计轴复位命令*/
+					/*批量计轴复位命令*/
-					SetSectionResetLogicManage(CmdDeviceId, PHYSICAL_SECTION_PRE_RESET_NO);
+					BatchAixsResetLogicManage(cSectionSum, pSectionIdBuff, PHYSICAL_SECTION_PRE_RESET_NO);
 				}
 				else
 				{
@@ -4945,7 +4940,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 			{
 				checkRetVal = AFFIRM_FAIL;   
 			}
-			SetCiSendCmdBackData_OrderBack(commandId,CmdDeviceId,cmdDevType,terminalId,AtsToCiCmdStru[ii].CommandType,RESPONSE_SECOND,checkRetVal,virCiID);
+			SetAixsResetCiSendCmdBackData(commandId, CmdDeviceId, cmdDevType, terminalId, AtsToCiCmdStru[ii].CommandType, RESPONSE_SECOND, checkRetVal, virCiID, cSectionSum, pSectionIdBuff);
 			break;
 
         case ATS_CMD_ROUTE_CHANGDIAO_SET:/*办理长调进路*/
@@ -5433,7 +5428,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 			break;
 		case ATS_CMD_ROUTE_PART_APPLY:
 			/*申请部分路径*/
-			RoutePartApplyLogicManageCLD(cLogSecSeqDir, trainId, cLogSecSum, pLogSecIdBuff);
+			RoutePartApplyLogicManageCLD(cLogSecSeqDir, trainId, cSectionSum, pSectionIdBuff);
 			break;
 		case ATS_CMD_GET_CTRL_POWER: 
 			/*获取联锁控制权*/
@@ -11787,9 +11782,12 @@ void UpdateHumidRailFlag(void)
 	UINT16 wOutFstPhySecId = 0U;  /*信号外方第一物理区段ID*/
 	UINT8 cOutFstPSInHumidRailFlag = PHYSEC_IN_HUMID_RAIL_NO;
 	UINT8 cLocalHumidRailState = CI_LOCAL_SNOW_UNVALID;  /*本地湿轨状态*/
+	UINT8 chLocalCiType = 0U; /*本联锁属性*/
 
+	chLocalCiType = GetLocalCiType();
 	cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_ZQX_CHECK_HUMID_RAIL);
-	if (FUNC_SWITCH_ON == cFuncSwitch)
+
+	if ((FUNC_SWITCH_ON == cFuncSwitch) &&((CI_TYPE_SCX == chLocalCiType) || (CI_TYPE_ZX == chLocalCiType)))
 	{
 		/****** 更新物理区段的湿轨标志 ******/
 		wCurPhySecNum = GetPhySecCurSum();

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

@@ -902,33 +902,6 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
 	case ETYPE_OTHER_DOWNWASH_NOT_ALLOW_PASS:
 		returnValue = CI_BACK_WASH_PASS_ALLOW_NOT;			/*洗车库/线未同意通过*/
 		break;
-	case ETYPE_LOGSEC_CONTINUOUS:
-		returnValue = CI_BACK_DYM_ROUTE_CONTINUOUS;
-		break;
-	case ETYPE_PART_ROUTE_RES:
-		returnValue = CI_BACK_DYM_ROUTE_RES;
-		break;
-	case ETYPE_PART_ROUTE_MATCH_ROUTE:
-		returnValue = CI_BACK_DYM_ROUTE_MATCH_ROUTE;
-		break;
-	case ETYPE_PART_ROUTE_SCREEN:
-		returnValue = CI_BACK_DYM_ROUTE_SCREEN;
-		break;
-	case ETYPE_LOGSEC_CBTC_PROPERTY:
-		returnValue = CI_BACK_DYM_ROUTE_SEC_CBTC;
-		break;
-	case ETYPE_PART_ROUTE_REPEAT:
-		returnValue = CI_BACK_DYM_ROUTE_REPEAT;
-		break;
-	case ETYPE_PART_ROUTE_SEC_ATTR:
-		returnValue = CI_BACK_DYM_ROUTE_SEC_ATTR;
-		break;
-	case ETYPE_PART_ROUTE_TRAIN_COMM:
-		returnValue = CI_BACK_DYM_ROUTE_TRAIN_COMM;
-		break;
-	case ETYPE_PART_ROUTE_TRAIN_POS:
-		returnValue = CI_BACK_DYM_ROUTE_TRAIN_POS;
-		break;
 	default:/*数据错误*/
 		returnValue = 0U;
 		break;

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

@@ -959,6 +959,7 @@ UINT8 InitialAxisSectionData(void)
 		AxisSectionDataStru[axisSectionId].dwAxisOccCycNum = 0U;
 		AxisSectionDataStru[axisSectionId].wPosMonitorTrainId = 0U;
 		AxisSectionDataStru[axisSectionId].dwUtOccupyCycNum = 0U;
+		AxisSectionDataStru[axisSectionId].cAxisTXSafeLocFlag = AXIS_SECTION_SAFELOC_NO;  /*初始化计轴区段无通信车安全位置覆盖*/
 	}
 	reVal = CI_SUCCESS;
 	return reVal;

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

@@ -1902,6 +1902,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 4u;
 				ShortToChar(newAxisSecData[deviceId].wPosMonitorTrainId, &outString[outStringLength]);  /*监督有效的列车ID*/
 				outStringLength += 2u;
+				outString[outStringLength] = newAxisSecData[deviceId].cAxisTXSafeLocFlag;  /*计轴区段列车安全位置覆盖标志：0x55-无效；0xAA-有效*/
+				outStringLength++;
 			}
 		}
 		else

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

@@ -1646,6 +1646,7 @@ void RouteNearLockErrManage(const UINT16 routeId)
 	UINT8 routeRepeatStat = 0U;
 	UINT8 routeTrainNear = 0U;
 	UINT8 cFuncRetVal = CI_ERROR;
+	UINT8 cFuncSwitch = 0U;
 
 	/*获取进路始端信号机ID*/
 	startSignalId = GetRouteStartSignalId(routeId);
@@ -1673,18 +1674,28 @@ void RouteNearLockErrManage(const UINT16 routeId)
 		{/*之前驱动开放*/
 			if ((CI_SUCCESS == autoSignalValid) || (ROUTE_REPEATOPEN_SET_YES == routeRepeatStat))
 			{ /*自动信号或者重开*/
-
+				cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_REOPRN_SET_NEAR);
-				if (CI_SUCCESS == routeTrainNear)
+				if(FUNC_SWITCH_ON == cFuncSwitch)
-				{/*进路有车接近*/
+				{
+					/*“重开信号是否记忆进路接近锁闭状态开关”配置为0xAA时，默认设置进路接近*/
 					SetRouteStateManage(routeId, ROUTE_STATE_NEAR_OPEN);   /*-->设置接近开放*/
-
 					RouteNearOpenManage(routeId); /*-->进路接近开放管理*/
 				}
 				else
-				{/*进路无车接近*/
+				{
-					SetRouteStateManage(routeId, ROUTE_STATE_YUXIAN_OPEN);  /*-->设置预先开放*/
+					/*“重开信号是否记忆进路接近锁闭状态开关”配置为0x55时，根据接近区段占用状态设置进路接近/未接近*/
+					if (CI_SUCCESS == routeTrainNear)
+					{/*进路有车接近*/
+						SetRouteStateManage(routeId, ROUTE_STATE_NEAR_OPEN);   /*-->设置接近开放*/
 
-					RouteYuXianOpenManage(routeId);  /*进路预先开放管理*/
+						RouteNearOpenManage(routeId); /*-->进路接近开放管理*/
+					}
+					else
+					{/*进路无车接近*/
+						SetRouteStateManage(routeId, ROUTE_STATE_YUXIAN_OPEN);  /*-->设置预先开放*/
+
+						RouteYuXianOpenManage(routeId);  /*进路预先开放管理*/
+					}
 				}
 			}
 			else
@@ -4517,9 +4528,12 @@ void RouteZongRenJieProc(const UINT16 routeId)
 
 		checkResultSecAndQXZC = RouteExceptLastSecOccuClrCheck(routeId);
 		if (CI_SUCCESS == checkResultSecAndQXZC)
-		{   /*所有区段空闲或最后一个区段占用*/
+		{   /*所有区段空闲或最后一个区段占用，也需要延时解锁*/
 
-			SetRouteStateManage(routeId, ROUTE_STATE_IDLE);  /*-->设置进路空闲*/
+			/*总人解办理*/
+			SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK);  /*-->设置进路延时解锁*/
+			/*延时后全部解锁*/
+			SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/
 		}
 		else if ((ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta) && (CI_ERROR_QXZC != checkResultSecAndQXZC))
 		{/*当总人解引导进路时，有取消照查继电器且未吸起则不能解锁引导进路*/
@@ -8358,6 +8372,87 @@ void SetSectionResetLogicManage(const UINT16 phySecId, const UINT8 resetType)
 	}
 }
 
+/*
+* 功能描述： 批量计轴复位命令逻辑管理
+* 参数说明： const UINT8 cPhySecSum  物理区段数量
+*		     const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返回值  ： void
+*/
+void BatchAixsResetLogicManage(const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[], const UINT8 resetType)
+{
+	UINT8 const functionId = EFUNC_SET_SEC_RESET_LOGIC_MANAGE; /*函数故障码*/
+	UINT8 retValid = CI_ERROR;	/*计轴总复位继电器状态有效性值，默认为无效*/
+	UINT8 occupyState = 0U; /*占用状态*/
+	UINT8 ii = 0U;
+	UINT16 phySecId = 0U;	/*物理区段ID*/
+	UINT8 cCheckRetVal = CI_ERROR;	/*检查结果*/
+	UINT8 cBreakFlag = CI_SUCCESS;   /*跳出标志*/
+	UINT32 dwCurCyc = 0U;  /*周期号*/
+	dwCurCyc = Get2oo2CurCycleNum();
+	if ((pPhySecIdBuff != NULL) && (cPhySecSum != 0U))
+	{
+		for (ii = 0U; ii < cPhySecSum; ii++)
+		{
+			phySecId = pPhySecIdBuff[ii];
+			if ((0U < phySecId) && (PHYSICAL_SECTION_SUM_MAX > phySecId))
+			{
+				occupyState = GetPhySecCurOccupyState(phySecId);
+				if (SECTION_OCCUPY_YES == occupyState) /*采集占用*/
+				{
+					occupyState = GetPhySecCurTxOccupyState(phySecId);
+					if (LOGICSECTION_OCCUPY_TX == occupyState) /*CT占用*/
+					{
+						SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, phySecId, ETYPE_PS_NO_UT_CT_OCU_STATE, occupyState, ESEND_LEVEL_ATS);
+						cCheckRetVal = CI_ERROR;
+						cBreakFlag = CI_ERROR;
+					}
+					else
+					{
+						retValid = GetZFWValidByPhySecId(phySecId); /*获取物理区段计轴总复位继电器状态有效性*/
+						if (CI_SUCCESS == retValid)
+						{
+							cCheckRetVal = CI_SUCCESS;
+						}
+						else
+						{							
+							SetCiSendCmdBackInfoData(CI_BACK_PSEC_RESET_ZFW_ERROR, CI_DEVICE_TYPE_PHYSEC, phySecId, 0U, 0U);
+							cCheckRetVal = CI_ERROR;
+							cBreakFlag = CI_ERROR;
+						}
+					}
+				}
+				else	/*无占压，反馈计轴复位失败,反馈计轴空闲*/
+				{
+					SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, phySecId, ETYPE_PS_MERGY_OCU_STATE, occupyState, ESEND_LEVEL_ATS);
+					cCheckRetVal = CI_ERROR;
+					cBreakFlag = CI_ERROR;
+				}
+				if (cBreakFlag == CI_ERROR)
+				{
+					break;	/*条件满足，退出循环*/
+				}
+			}
+		}
+		if (CI_SUCCESS == cCheckRetVal)
+		{/*有效，执行计轴复位功能*/
+			for (ii = 0U; ii < cPhySecSum; ii++)
+			{
+				SetPhySecSectionResetType(pPhySecIdBuff[ii], resetType);
+				SetPhySecResetStartCycNum(pPhySecIdBuff[ii], dwCurCyc);/*设置当前周期号位计轴复位命令起始周期号*/
+			}
+		}
+		else
+		{
+			/*无效，不执行计轴复位功能*/
+		}
+	}
+	else
+	{
+		/*数据有误，无计轴需复位*/
+	}
+}
+
+
 /*
 * 功能描述： 设置折返进路为通过进路管理
 * 参数说明： const UINT16 signalId, 通过信号机ID
@@ -11094,6 +11189,7 @@ void UnlockSwitchLogicManage(void)
 	UINT8 unlockFlag = 0U;/*解锁标志*/
 	UINT8 funcSwitch = 0U;
 	UINT8 chPhySecLogLockState = 0U;/*物理区段逻辑锁闭状态*/
+	UINT8 chPhySecJumpLockState = 0U;
 
 	localCiId = GetSystemParaLocalCiId();				/*获取本机联锁ID*/
 	funcSwitch = GetCiFunctionSwitchConfig(FUNC_ROUTE_DRV_SWITCH_EARLY);
@@ -11124,10 +11220,11 @@ void UnlockSwitchLogicManage(void)
 					phyLockStatus = GetPhySecLockState(hostPhyId);/*获取物理区段锁闭状态*/
 					chFuncRet1 = GetSwitchLogSecLockState(hostSwitchId, &wDevId, &chDevState);
 					chPhySecLogLockState = PhySecLogLockStateCheck(hostPhyId);
+					chPhySecJumpLockState = GetPhySecJumpLockState(hostPhyId);
 
 					if ((PHYSICAL_SECTION_LOCK_NO == phyLockStatus) && (CI_SUCCESS == chFuncRet1)
-						&& (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState))
+						&& (LOG_SECTION_LOGLOCK_NO == chPhySecLogLockState) && (PHYSICAL_SECTION_JUMP_LOCK_NO == chPhySecJumpLockState))
-					{/*区段锁闭状态为未锁闭(物理区段未被进路锁，逻辑区段未被进路锁，物理区段未被逻辑进路锁)*/
+					{/*区段锁闭状态为未锁闭(物理区段未被进路锁，逻辑区段未被进路锁，物理区段未被逻辑进路锁,未被跳跃锁闭)*/
 						unlockFlag = 1u;
 					}
 					else
@@ -11390,6 +11487,9 @@ void CheckLogSecJumpLockManage(void)
 	UINT8 logJumpLockState = LOGIC_SECTION_JUMP_LOCK_NO;
 	UINT8 localCi = 0u;/*本联锁*/
 	UINT16 logJumpLockTrainId = 0u;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
+	UINT8 retVal = CI_ERROR;
 
 
 	localCi = GetSystemParaLocalCiId();
@@ -11409,8 +11509,19 @@ void CheckLogSecJumpLockManage(void)
 					checkResult = CheckLogJumpLockApply(logicSecId);
 					if (CI_SUCCESS == checkResult)
 					{
-						/** 检查条件满足，设置跳跃锁闭允许标志为允许 */
+						devId = 0u;
-						SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+						devState = 0u;
+						retVal = LogicSecRltvPrtctSwLockCheck(logicSecId, &devId, &devState);
+						if (CI_SUCCESS == retVal)
+						{
+							/** 检查条件满足，设置跳跃锁闭允许标志为允许 */
+							SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+						}
+						else
+						{
+							/** 检查条件不满足，设置跳跃锁闭允许标志为禁止 */
+							SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
+						}
 					}
 					else
 					{
@@ -11465,7 +11576,6 @@ void AxisSecJumpLockLogicManage(void)
 	UINT8 applyFlag = 0u;/*申请标志*/
 	UINT8 cancelApplyFlag = 0u;/*取消申请标志*/
 	UINT16 phyId = 0u;/*物理区段ID*/
-	UINT8 phyUseState = 0u;/*物理区段征用状态*/
 	UINT8 jumpLockState = 0u;/*跳跃锁闭状态*/
 	UINT8 secBelongCi = 0u;/*区段所属联锁*/
 	UINT8 localCi = 0u;/*本联锁*/
@@ -11478,6 +11588,7 @@ void AxisSecJumpLockLogicManage(void)
 	UINT32 applyCycle = 0u;/*跳跃锁闭申请周期*/
 	UINT32 curCycle = 0u;/*当前周期号*/
 	UINT8 chPhySecJmpState = 0U;
+	UINT8 chJumpPhySectionUseCheck = 0U;
 
 	localCi = GetSystemParaLocalCiId();
 	axisSectionDataSum = GetTotalAxisCurNum();
@@ -11493,7 +11604,6 @@ void AxisSecJumpLockLogicManage(void)
 		jumpLockState = GetAxisJumpLockState(axisSectionId);/*获取跳跃锁闭状态*/
 
 		phyId = GetAxisSecRelativePhySecId(axisSectionId);/*获取相关物理区段ID*/
-		phyUseState = GetPhySecUseState(phyId);/*获取物理区段征用状态*/
 
 		secBelongCi = GetPhySecBelongCiId(phyId);
 
@@ -11531,10 +11641,12 @@ void AxisSecJumpLockLogicManage(void)
 					(AXSEC_CANCEL_JUMPLOCK_APPLY_NO == cancelApplyFlag))
 				{/*有跳跃锁闭申请*/
 
-					if (PHYSICAL_SECTION_USING_NO == phyUseState)
+					chJumpPhySectionUseCheck = JumpPhySectionUseCheck(axisSectionId);
+					if (CI_SUCCESS == chJumpPhySectionUseCheck)
 					{/*未征用*/
 						/*设置征用*/
 						SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_YES, 0);
+						SetJumpPhySectionPortectSecUse(axisSectionId, PHYSICAL_SECTION_USING_YES);/*设置物理区段关联防护道岔的区段征用*/
 						/*转为选排*/
 						SetAxisJumpLockState(axisSectionId, AXIS_SECTION_JUMPLOCK_STATE_XUANPAI);
 					}
@@ -11551,36 +11663,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);
-						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);
-				}
 			}
 			break;
 			default:
@@ -11618,16 +11701,22 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	{
 		rtVal = CI_SUCCESS;
 	}
+
+	if (CI_SUCCESS == rtVal)
+	{
+		rtVal = JumpPhySecAllUseCheck(axisSecId);/*所有区段已设置上征用（不考虑相邻联锁，若防护道岔在相邻联锁则不跳跃锁闭）*/
+	}
+
 	if (CI_SUCCESS == rtVal)
 	{
 		rtVal = LockAxisSecProc(axisSecId);/*跳跃锁闭联锁条件检查*/
 	}
-	axisSecSwitDrvOvtmFlag = ChekJumpLockSwitDrivOvtmStat(axisSecId);/*检查计轴区段内道岔是否驱动超时*/
+	axisSecSwitDrvOvtmFlag = ChekJumpLockSwitDrivOvtmStat(axisSecId);/*检查计轴区段关联道岔是否驱动超时*/
 	if (CI_SUCCESS == rtVal)
 	{/*检查成功*/
-		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_LOCK);
+
-		/*设置未征用*/
+		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_LOCK);/*状态机流程转*/
-		SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+
 	}
 	else if ((RETURN_LOCK_ERR_SWITPOS == rtVal) && (CI_SUCCESS == axisSecSwitDrvOvtmFlag))
 	{/*位置错误可驱动且驱动道岔没有超时*/
@@ -11638,6 +11727,8 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 		{
 			/*设置未征用*/
 			SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+			SetJumpPhySectionPortectSecUse(axisSecId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+
 			/*设置计轴区段跳跃状态空闲*/
 			SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
 		}
@@ -11646,6 +11737,8 @@ void AxisJumpLockXuanPaiManage(const UINT16 axisSecId)
 	{/*其它*/
 		/*设置未征用*/
 		SetPhySecUseState(phyId, PHYSICAL_SECTION_USING_NO, 0);
+		SetJumpPhySectionPortectSecUse(axisSecId, PHYSICAL_SECTION_USING_NO);/*设置物理区段的防护道岔所在区段取消防护征用*/
+
 		/*设置计轴区段跳跃状态空闲*/
 		SetAxisJumpLockState(axisSecId, AXIS_SECTION_JUMPLOCK_STATE_IDLE);
 	}
@@ -13033,7 +13126,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
 		cCheckStep++;
 		if (CI_ERROR == keepWork)
 		{
-			SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_LOGSEC_CONTINUOUS, 0U, cSendLevel);
+			SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_CONTINUOUS, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 		}
 		else
 		{
@@ -13139,7 +13232,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
 			
 			if (CI_ERROR == keepWork)
 			{
-				SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
+				SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_MATCH_ROUTE, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 				break;  /*拆分失败，停止遍历*/
 			}
 			else
@@ -13202,7 +13295,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
 
 			if (CI_ERROR == keepWork)
 			{
-				SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
+				SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_MATCH_ROUTE, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 			}
 			else
 			{
@@ -13220,7 +13313,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
 
 		if (CI_ERROR == keepWork)
 		{
-			SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SCREEN, 0U, cSendLevel);
+			SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_SCREEN, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 		}
 		else
 		{
@@ -13418,7 +13511,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
 							}
 							else
 							{
-								SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_REPEAT, 0U, cSendLevel);
+								SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_REPEAT, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 								debug_infor_printf((const)"Dynamic Logic Route Set Is Error: LogicRoute Repeat Set!\n");  /*逻辑进路重复办理或非停车区域*/
 							}
 						}
@@ -13442,7 +13535,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
 				}
 				else
 				{
-					SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_LOGSEC_CBTC_PROPERTY, 0U, cSendLevel);
+					SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_SEC_CBTC, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 					debug_infor_printf((const)"Dynamic Logic Route Set Is Error: LogSec Is Not CBTC Property!\n");  /*逻辑进路办理办理失败，逻辑区段非CBTC属性*/
 				}
 			}
@@ -13693,6 +13786,8 @@ static void TrainTransitmitStatJumpLockProcess(const UINT16 logSectionId, const
 						/** 清除区段跳跃锁闭延时解锁起始周期号和延时解锁设置标志*/
 						SetLogSecJumpDelayUnlocStartCyc(logSectionId, 0u);
 						SetLogSecJumpDelayUnlockFlag(logSectionId, LOGIC_JUMPUNLOCK_DELAY_SET_NO);
+						/*取消防护锁闭*/
+						SetLogSecRelProSwitchLockSta(logSectionId, SWITCH_LOCK_PROTECT_CANCEL);
 					}
 					else
 					{
@@ -14401,6 +14496,8 @@ void PhySecJumpLockLogicManage(void)
 	UINT32 dwApplyCycle = 0U;/*跳跃锁闭申请周期号*/
 	UINT8 chPhySecFLockType = 0U;/*物理区段封锁类型*/
 	UINT8 chPhySecJempState = 0U;/*物理区段跳跃锁闭状态*/
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
 
 	wAxisSectionDataSum = GetTotalAxisCurNum();
 
@@ -14423,9 +14520,23 @@ void PhySecJumpLockLogicManage(void)
 					chPhySecFLockType = GetPhySecFLockType(wPhyId); /*获取物理区段封锁类型*/
 					if ((PHY_SEC_FLOCK_TYPE_NONE == chPhySecFLockType))
 					{
+						ClearAxisSeceSwitchDanCaoPos(wAxisSectionId);/*清除单操*/
 						SetPhySecJumpLockState(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
-						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+						SetAxisRelProSwitchLockSta(wAxisSectionId, SWITCH_LOCK_PROTECT_SET);
-						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
 					{
@@ -14447,8 +14558,17 @@ void PhySecJumpLockLogicManage(void)
 				}
 				else
 				{  /*联锁内部锁闭，当持续检查锁闭条件满足时，再次给ZC发锁闭*/
-
+					devId = 0u;
-					SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+					devState = 0u;
+					chTempcheck = AxisRelatedProSwitchLockCheck(wAxisSectionId, &devId, &devState);
+					if (CI_SUCCESS == chTempcheck)
+					{
+						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
+					}
+					else
+					{
+						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+					}
 				}
 			}
 		}
@@ -14457,6 +14577,7 @@ void PhySecJumpLockLogicManage(void)
 		{/*有取消跳跃申请*/
 			SetPhySecJumpLockState(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
 			SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+			SetAxisRelProSwitchLockSta(wAxisSectionId, SWITCH_LOCK_PROTECT_CANCEL);/*取消防护锁闭*/
 		}
 	}
 }
@@ -15467,7 +15588,10 @@ void SetLogRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrnId,
 	UINT8 chLogRouteLogicLockState = 0U;		/*逻辑进路逻辑区段锁闭状态*/
 	UINT8 chRouteTrainEnterFlag = 0U;/*列车处于进路位置*/
 	UINT16 wLogSignalId = 0U;	/*逻辑进路包含的信号机*/
-
+	UINT16 wBelongPhySec = 0U;
+	UINT8 chQcxFlag = 0U;/*牵出线属性*/
+	UINT8 chKeepFlag = CI_ERROR;
+	UINT8 chTrainLevel = TRAIN_LEVEL_UR;
 	wLogicRLockLogRouteId = GetLogSecBelongLogRouteId(wLogSectionId, wTrnId);
 	wLogRouteState = GetLogicalRouteState(wLogicRLockLogRouteId);
 	chLogRouteLogicLockState = GetLogSecLogLockState(wLogSectionId);
@@ -15475,53 +15599,85 @@ void SetLogRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrnId,
 	{
 		if (LOG_SECTION_LOGLOCK_NORMAL == chLogRouteLogicLockState)
 		{
-			wLogSignalId = GetLogicalRouteRelateBeginSigId(wLogicRLockLogRouteId);
+			wBelongPhySec = GetLgcSecRelativePhySecId(wLogSectionId);
-			if (0U != wLogSignalId)
+			chQcxFlag = GetPhySecQcxFlag(wBelongPhySec);
+			if (PHYSICAL_SECTION_QCX_YES == chQcxFlag)
 			{
-				chRouteTrainEnterFlag = dsuLogRouteMinHeadTrainCrosSig(wTrnId, wLogicRLockLogRouteId);
+				/*牵出线区段RM列车检查区段外方进路*/
-			}
+				chTrainLevel = GetTrainLevel(wTrnId);
-			else
+				if (TRAIN_LEVEL_VBTC == chTrainLevel)
-			{
-				chRouteTrainEnterFlag = TRAIN_ENTER_ROUTE_FULL;		/*无始端信号机，列车已经完全驶入进路*/
-			}
-			if ((TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag)
-				|| (TRAIN_ENTER_ROUTE_HEAD == chRouteTrainEnterFlag))
-			{
-				if ((ROUTE_LOGICAL_STATE_OPEN == wLogRouteState))
 				{
-					if (CI_SUCCESS == wLogicSecLogRouteCheckState)
+					chKeepFlag = CI_SUCCESS;
-					{
-						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_USABLE);
-					}
-					else
-					{
-						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
-					}
-				}
-				else if ((ROUTE_LOGICAL_STATE_UNLOCKWAIT==wLogRouteState) && (TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag))
-				{
-					/*若列车已出清逻辑进路最后一个逻辑区段但未解锁（进路保持等待解锁状态）*/
-					if (CI_SUCCESS == wLogicSecLogRouteCheckState)
-					{
-						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_USABLE);
-					}
-					else
-					{
-						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
-					}
 				}
 				else
 				{
-					SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
+					/*检查牵出线外方信号机办理列车进路/折返进路*/
+					chKeepFlag = CheckQcxLiecheRoute(wBelongPhySec);
 				}
 			}
-			else if ((TRAIN_ENTER_ROUTE_FULL == chRouteTrainEnterFlag)
+			else if (PHYSICAL_SECTION_QCX_NO == chQcxFlag)
-				|| (TRAIN_ENTER_ROUTE_TAIL == chRouteTrainEnterFlag)
-				|| (TRAIN_ENTER_ROUTE_CROSS == chRouteTrainEnterFlag))
 			{
-				if (CI_SUCCESS == wLogicSecLogRouteCheckState)
+				chKeepFlag = CI_SUCCESS;
+			}
+			else
+			{
+				/*异常防护*/
+				chKeepFlag = CI_ERROR;
+			}
+			if (CI_SUCCESS == chKeepFlag)
+			{
+				wLogSignalId = GetLogicalRouteRelateBeginSigId(wLogicRLockLogRouteId);
+				if (0U != wLogSignalId)
 				{
-					SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_USABLE);
+					chRouteTrainEnterFlag = dsuLogRouteMinHeadTrainCrosSig(wTrnId, wLogicRLockLogRouteId);
+				}
+				else
+				{
+					chRouteTrainEnterFlag = TRAIN_ENTER_ROUTE_FULL;		/*无始端信号机，列车已经完全驶入进路*/
+				}
+				if ((TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag)
+					|| (TRAIN_ENTER_ROUTE_HEAD == chRouteTrainEnterFlag))
+				{
+					if ((ROUTE_LOGICAL_STATE_OPEN == wLogRouteState))
+					{
+						if (CI_SUCCESS == wLogicSecLogRouteCheckState)
+						{
+							SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_USABLE);
+						}
+						else
+						{
+							SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
+						}
+					}
+					else if ((ROUTE_LOGICAL_STATE_UNLOCKWAIT == wLogRouteState) && (TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag))
+					{
+						/*若列车已出清逻辑进路最后一个逻辑区段但未解锁（进路保持等待解锁状态）*/
+						if (CI_SUCCESS == wLogicSecLogRouteCheckState)
+						{
+							SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_USABLE);
+						}
+						else
+						{
+							SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
+						}
+					}
+					else
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
+					}
+				}
+				else if ((TRAIN_ENTER_ROUTE_FULL == chRouteTrainEnterFlag)
+					|| (TRAIN_ENTER_ROUTE_TAIL == chRouteTrainEnterFlag)
+					|| (TRAIN_ENTER_ROUTE_CROSS == chRouteTrainEnterFlag))
+				{
+					if (CI_SUCCESS == wLogicSecLogRouteCheckState)
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_USABLE);
+					}
+					else
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
+					}
 				}
 				else
 				{
@@ -15560,7 +15716,10 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 	UINT16 autoRouteSetFlag = AUTO_ROUTE_SET_NO;
 	UINT16 wLockBelongRouteId = 0U;  /*进路锁闭所属进路*/
 	UINT16 wRouteLastLogSecId = 0U;  /*进路内方最后一个逻辑区段*/
-
+	UINT16 wBelongPhySec = 0U;
+	UINT8 chQcxFlag = 0U;/*牵出线属性*/
+	UINT8 chKeepFlag = CI_ERROR;
+	UINT8 chTrainLevel = TRAIN_LEVEL_UR;
 	chLogicLockState = GetLogSecLockState(wLogSectionId);			/*正常进路锁闭状态*/
 	wLogicRLockRouteId = GetLogSecLockBelongRoute(wLogSectionId);         /*获取进路ID*/
 	routeState = GetRouteState(wLogicRLockRouteId);                       /*获取进路状态*/
@@ -15572,36 +15731,94 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 	if ((LOG_SECTION_LOCK_NORMAL == chLogicLockState)
 		|| (LOG_SECTION_LOCK_DELAY == chLogicLockState))
 	{
-		chRouteTrainEnterFlag = dsuTrainMinHeadCrossSignal(wTrainId, wLogicRLockRouteId);
+		wBelongPhySec = GetLgcSecRelativePhySecId(wLogSectionId);
-
+		chQcxFlag = GetPhySecQcxFlag(wBelongPhySec);
-		chTrainMaxHeadCross = dsuTrainCrossSignal(wTrainId, wLogicRLockRouteId);/*判断列车大前是否驶入进路*/
+		if (PHYSICAL_SECTION_QCX_YES == chQcxFlag)
-
-		/*列车未在进路中 或者列车小前进入进路但未越过跨压距离*/
-		if ((TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag) || (TRAIN_ENTER_ROUTE_HEAD == chRouteTrainEnterFlag))
 		{
-			if ((ROUTE_STATE_YUXIAN_OPEN == routeState)
+			/*牵出线区段RM列车检查区段外方进路*/
-				|| (ROUTE_STATE_NEAR_OPEN == routeState)
+			chTrainLevel = GetTrainLevel(wTrainId);
-				|| (ROUTE_STATE_HALF_UNLOCK == routeState))
+			if (TRAIN_LEVEL_VBTC == chTrainLevel)
 			{
-				if (CI_SUCCESS == wLogicSecCheckState)
+				chKeepFlag = CI_SUCCESS;
-				{
-					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
-				}
-				else
-				{
-					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
-				}
 			}
-			else if ((ROUTE_STATE_AUTO_UNLOCK == routeState)  && (TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag))
+			else
 			{
-				/*若列车已出清进路最后一个逻辑区段但未解锁，保持资源可用（只有一个区段的进路出清后为接近锁闭正常时，资源不可用，采用三点检查解锁）*/
+				/*检查牵出线外方信号机办理列车进路/折返进路*/
-				if (CI_SUCCESS == wLogicSecCheckState)
+				chKeepFlag = CheckQcxLiecheRoute(wBelongPhySec);
+			}
+		}
+		else if (PHYSICAL_SECTION_QCX_NO == chQcxFlag)
+		{
+			chKeepFlag = CI_SUCCESS;
+		}
+		else
+		{
+			/*异常防护*/
+			chKeepFlag = CI_ERROR;
+		}
+		if (CI_SUCCESS == chKeepFlag)
+		{
+			chRouteTrainEnterFlag = dsuTrainMinHeadCrossSignal(wTrainId, wLogicRLockRouteId);
+
+			chTrainMaxHeadCross = dsuTrainCrossSignal(wTrainId, wLogicRLockRouteId);/*判断列车大前是否驶入进路*/
+
+			/*列车未在进路中 或者列车小前进入进路但未越过跨压距离*/
+			if ((TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag) || (TRAIN_ENTER_ROUTE_HEAD == chRouteTrainEnterFlag))
+			{
+				if ((ROUTE_STATE_YUXIAN_OPEN == routeState)
+					|| (ROUTE_STATE_NEAR_OPEN == routeState)
+					|| (ROUTE_STATE_HALF_UNLOCK == routeState))
 				{
-					wLockBelongRouteId = GetLogSecLockBelongRoute(wLogSectionId);  /*获取逻辑区段锁闭所属进路*/
+					if (CI_SUCCESS == wLogicSecCheckState)
-					wRouteLastLogSecId = GetRouteInLastLogSecId(wLockBelongRouteId);  /*获取进路内方最后一个逻辑区段ID*/
-					if (wRouteLastLogSecId == wLogSectionId)
 					{
-						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);  /*进路自动解锁正常且列车不在进路内，仅进路内方最后一个逻辑区段资源状态可用*/
+						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
+					}
+					else
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
+					}
+				}
+				else if ((ROUTE_STATE_AUTO_UNLOCK == routeState) && (TRAIN_ENTER_ROUTE_NO == chRouteTrainEnterFlag))
+				{
+					/*若列车已出清进路最后一个逻辑区段但未解锁，保持资源可用（只有一个区段的进路出清后为接近锁闭正常时，资源不可用，采用三点检查解锁）*/
+					if (CI_SUCCESS == wLogicSecCheckState)
+					{
+						wLockBelongRouteId = GetLogSecLockBelongRoute(wLogSectionId);  /*获取逻辑区段锁闭所属进路*/
+						wRouteLastLogSecId = GetRouteInLastLogSecId(wLockBelongRouteId);  /*获取进路内方最后一个逻辑区段ID*/
+						if (wRouteLastLogSecId == wLogSectionId)
+						{
+							SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);  /*进路自动解锁正常且列车不在进路内，仅进路内方最后一个逻辑区段资源状态可用*/
+						}
+						else
+						{
+							SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
+						}
+					}
+					else
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
+					}
+				}
+				else if ((ROUTE_STATE_NEAR_LOCK == routeState) &&
+					((TRAIN_ENTER_ROUTE_HEAD == chTrainMaxHeadCross) || (TRAIN_ENTER_ROUTE_CROSS == chTrainMaxHeadCross)))
+				{
+					/*点式进路在列车驶入进路但未跨压时已关闭信号（接近锁闭正常），若此时大前已驶入进路，需要保持资源可用*/
+					/*CBTC进路在列车驶入进路但未跨压时已关闭信号（接近锁闭正常），若此时大前已驶入进路，需要保持资源可用   ——列车驶入点式进路后升级，使进路转变为CBTC进路后，需要保持资源仍然可用 LC 20240626*/
+					if (CI_SUCCESS == wLogicSecCheckState)
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
+					}
+					else
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
+					}
+				}
+				else if ((ROUTE_STATE_NEAR_LOCKERR == routeState) && (AUTO_ROUTE_SET_YES == autoRouteSetFlag) && (TRAIN_ENTER_ROUTE_HEAD == chRouteTrainEnterFlag))
+				{
+					/*自动通过进路在列车驶入后转为接近锁闭异常，修复列车驶入进路但未跨压时，资源不可用的问题 LC20240625*/
+					if (CI_SUCCESS == wLogicSecCheckState)
+					{
+						SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
 					}
 					else
 					{
@@ -15612,47 +15829,21 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 				{
 					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
 				}
-			}
-			else if ((ROUTE_STATE_NEAR_LOCK == routeState) && 
-				((TRAIN_ENTER_ROUTE_HEAD == chTrainMaxHeadCross) || (TRAIN_ENTER_ROUTE_CROSS == chTrainMaxHeadCross)))
-			{
-				/*点式进路在列车驶入进路但未跨压时已关闭信号（接近锁闭正常），若此时大前已驶入进路，需要保持资源可用*/
-				/*CBTC进路在列车驶入进路但未跨压时已关闭信号（接近锁闭正常），若此时大前已驶入进路，需要保持资源可用   ——列车驶入点式进路后升级，使进路转变为CBTC进路后，需要保持资源仍然可用 LC 20240626*/
-				if (CI_SUCCESS == wLogicSecCheckState)
-				{
-					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
-				}
-				else
-				{
-					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
-				}
-			}
-			else if ((ROUTE_STATE_NEAR_LOCKERR == routeState) && (AUTO_ROUTE_SET_YES == autoRouteSetFlag) && (TRAIN_ENTER_ROUTE_HEAD == chRouteTrainEnterFlag))
-			{
-				/*自动通过进路在列车驶入后转为接近锁闭异常，修复列车驶入进路但未跨压时，资源不可用的问题 LC20240625*/
-				if (CI_SUCCESS == wLogicSecCheckState)
-				{
-					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
-				}
-				else
-				{
-					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
-				}
-			}
-			else
-			{
-				SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
-			}
 
-		}
+			}
-		/*列车跨压信号机  或者列车完全在进路中  或者列车车尾在进路*/
+			/*列车跨压信号机  或者列车完全在进路中  或者列车车尾在进路*/
-		else if ((TRAIN_ENTER_ROUTE_FULL == chRouteTrainEnterFlag)
+			else if ((TRAIN_ENTER_ROUTE_FULL == chRouteTrainEnterFlag)
-			|| (TRAIN_ENTER_ROUTE_TAIL == chRouteTrainEnterFlag)
+				|| (TRAIN_ENTER_ROUTE_TAIL == chRouteTrainEnterFlag)
-			|| (TRAIN_ENTER_ROUTE_CROSS == chRouteTrainEnterFlag))
+				|| (TRAIN_ENTER_ROUTE_CROSS == chRouteTrainEnterFlag))
-		{
-			if (CI_SUCCESS == wLogicSecCheckState)
 			{
-				SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
+				if (CI_SUCCESS == wLogicSecCheckState)
+				{
+					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_USABLE);
+				}
+				else
+				{
+					SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
+				}
 			}
 			else
 			{
@@ -15663,7 +15854,7 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 		{
 			SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
 		}
-}
+	}
 	else
 	{
 		/*无锁闭状态 或锁闭状态异常*/
@@ -15751,7 +15942,7 @@ void RoutePartApplyLogicManageCLD(const UINT8 cLogSecSeqDir, const UINT16 wTrain
 
 		if (CI_SUCCESS != keepWork)
 		{
-			SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
+			SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_MATCH_ROUTE, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 		}
 		else
 		{
@@ -15771,7 +15962,7 @@ void RoutePartApplyLogicManageCLD(const UINT8 cLogSecSeqDir, const UINT16 wTrain
 
 		if (CI_SUCCESS != keepWork)
 		{
-			SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SCREEN, 0U, cSendLevel);
+			SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_SCREEN, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 		}
 		else
 		{
@@ -16533,4 +16724,158 @@ void TrainJumpBackApplyProc(void)
 			}
 		}
 	}
-}
+}
+/*
+* 功能描述：牵出线区段外方进路检查
+* 参数说明： const UINT16 wPhySecId 牵出线区段
+* 返回值  ：CI_SUCCESS列车进路已办理 CI_ERROR未办理列车进路
+* by fan 20260415
+*/
+UINT8 CheckQcxLiecheRoute(UINT16 wPhySecId)
+{
+	UINT16 wStatrSigRtSum = 0U;/*获取以该信号机为始端信号机的进路数目*/
+	UINT16* szStartSigRouteBuf = NULL;/*获取以该信号机为始端信号机的进路数组*/
+	UINT16 wSigId = 0U;/*信号机ID*/
+	UINT16 jj = 0U;
+	UINT16 ii = 0U;
+	UINT8 chRouteState = 0U;/*进路状态*/
+	UINT8 chRouteType = 0U;/*进路类型*/
+	UINT8 chRtnval = CI_ERROR;
+	UINT16 wSigSum = 0U;/*信号机总数*/
+	UINT16 wSigOutSec = 0U;
+	/*遍历以该信号机为始端信号机的进路，存在列车进路非空闲*/
+	wSigSum = GetSignalCurSum();
+	
+	for (ii = 0u; ii < wSigSum; ii++)
+	{
+		wSigId = GetSignalId(ii);
+		wStatrSigRtSum = GetStartSignalRouteSum(wSigId);/*获取以该信号机为始端信号机的进路数目*/
+		szStartSigRouteBuf = GetStartSignalRouteBuf(wSigId);/*获取以该信号机为始端信号机的进路数组*/
+		wSigOutSec = GetSignalOutFirstPhySecId(wSigId);
+		/*信号机外方区段存在且与牵出线区段一致、信号机存在关联进路*/
+		if ((0U != wSigOutSec) && (wSigOutSec == wPhySecId) && (0U != wStatrSigRtSum))
+		{
+			for (jj = 0U; jj < wStatrSigRtSum; jj++)
+			{/*查找以信号机为始端信号机的开放的进路ID*/
+				chRouteState = GetRouteState(szStartSigRouteBuf[jj]);/*获取进路状态*/
+				chRouteType = GetRouteType(szStartSigRouteBuf[jj]);/*进路类型*/
+				/*列车进路（车辆段折返进路初始化为列车进路） 接近开放或接近锁闭正常*/
+				if ((ROUTE_TYPE_LIECHE == chRouteType)
+					&&((ROUTE_STATE_NEAR_OPEN == chRouteState)||(ROUTE_STATE_NEAR_LOCK == chRouteState)))
+				{
+					chRtnval = CI_SUCCESS;
+					break;
+				}
+			}
+		}
+		if (CI_SUCCESS == chRtnval)
+		{
+			break;
+		}
+	}
+	return chRtnval;
+}
+/*
+* 功能描述： 计轴区段跳跃锁闭状态机管理
+* 参数说明： 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);
+	}
+
+}
+

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

@@ -1155,6 +1155,29 @@ void OverlapZhaoChaRelayUpDateManage(void);
 * Create: fan 20250725
 */
 void TrainJumpBackApplyProc(void);
+/*
+* 功能描述： 批量计轴复位命令逻辑管理
+* 参数说明： const UINT8 cPhySecSum  物理区段数量
+*		     const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返回值  ： void
+*/
+void BatchAixsResetLogicManage(const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[], const UINT8 resetType);
+
+/*
+* 功能描述：牵出线区段外方进路检查
+* 参数说明： const UINT16 wPhySecId 牵出线区段
+* 返回值  ：CI_SUCCESS列车进路已办理 CI_ERROR未办理列车进路
+* by fan 20260415
+*/
+UINT8 CheckQcxLiecheRoute(UINT16 wPhySecId);
+
+/*
+* 功能描述： 计轴区段跳跃锁闭状态机管理
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+* 返回值  ： void
+* add by mpt 20260407
+*/
+void AxisJumpLockStateManage(const UINT16 axisSectionId);
 
 #ifdef __cplusplus
 }

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

@@ -427,6 +427,26 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
 	{
 	    ;
 	}
+	/*风井占用检查*/
+	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
+	{
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAirShaftSecOccuCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+		}
+		else
+		{
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
 	
 	/* 侵限区段SPKS联锁条件检查 */
 	if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
@@ -4341,7 +4361,6 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
 	{
 	    ;
 	}
-
 /*使用新增的函数RouteIntruSecVainSPKSErrCheck*/
 #if 0
 	/*侵限区段侵限条件不满足检查*/

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

@@ -1676,17 +1676,6 @@ UINT8 LogRouteNextLogSecLockCheck(UINT16 const wLogicSecId, UINT16 const wLogRou
 */
 UINT8 LogicSecRltvPrtctSwLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
 
-/*
-* 功能描述： 逻辑区段所处道岔防护道岔位置检查
-* 参数说明： UINT16 const routeId, 进路ID
-*            UINT16 *pDevId,    设备Id（返回）
-*            UINT8 *pDevState,  设备状态（返回）
-* 返回值  ： CI_ERROR
-*            CI_SUCCESS
-* 创建    ： qw.liu 2022-03-01
-*/
-UINT8 LogicSecRltvPrtctSwPosCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
-
 /*
 * 功能描述： 逻辑区段所处道岔防护道岔未封锁检查
 * 参数说明： UINT16 const routeId, 进路ID
@@ -1699,6 +1688,18 @@ UINT8 LogicSecRltvPrtctSwPosCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pD
 */
 UINT8 LogicSecRltvPrtctSwFLockCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState, UINT8* pYLockAlarmFlag);
 
+/*
+* 功能描述： 逻辑区段所处道岔防护道岔位置检查
+* 参数说明： UINT16 const routeId, 进路ID
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* 创建    ： qw.liu 2022-03-01
+*/
+UINT8 LogicSecRltvPrtctSwPosCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
+
+
 /*
 * 功能描述： 逻辑区段所处道岔未封锁检查
 * 参数说明： UINT16 const routeId, 进路ID
@@ -2784,5 +2785,175 @@ UINT8 TrainOccSameSecCheck(const UINT16 wPhySecId, const UINT16 wTrainId);
 */
 UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId);
 
+/*
+* 功能描述： 进路风井区段占用检查
+* 参数说明： UINT16 routeId,    进路号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）（占用/空闲）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* by yx 2026.03.04
+*/
+UINT8 RouteAirShaftSecOccuCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
+/*
+* 功能描述： 进路风井区段锁闭检查
+* 参数说明： UINT16 routeId,    进路号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* by yx 2026.03.04
+*/
+UINT8 RouteAirShaftSecLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述： 计轴区段所有防护道岔位置正确检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add mpt 20260331
+*/
+UINT8 AxisSecAllProtSwitchPosCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述： 计轴区段道岔封锁状态检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* Add by mpt 20260331
+*/
+UINT8 AxisSecProtSwitchFLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述： 检查计轴区段跳跃锁闭是否有防护道岔驱动超时
+* 参数说明： const UINT16 routeId, 进路ID
+* 返回值  ： UINT8
+			 CI_SUCCESS:计轴区段防护道岔无道岔驱动超时
+			 CI_ERROR:计轴区段防护道岔驱动超时
+add by mpt 20260331
+*/
+UINT8 ChekJumpLockProtectSwitDrivOvtmStat(const UINT16 axisSecId);
+
+/*
+* 功能描述： 计轴区段的防护道岔位置和动作有效性检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 AxisSecPorteSwitchPosMoveCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState, UINT8 funcId, UINT8 sendLevel);
+
+/*
+* 功能描述： 区段征用、区段防护道岔区段征用、区段内道岔道岔征用检查、区段内防护道岔道岔征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId);
+/*
+* 功能描述：区段防护道岔区段、防护道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*  add by mpt 20260331
+*/
+UINT8 JumpPhySectionPortectUseCheck(const UINT16 axisSecId);
+
+/*
+* 功能描述：逻辑区段防护道岔区段征用、道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add by mpt 20260331
+*/
+UINT8 JumpLogicSecPortectUseCheck(const UINT16 wLgcId);
+
+/*
+* 功能描述：计轴区段所在道岔道岔征用检查
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+*  add by mpt 20260331
+*/
+UINT8 JumpPhySectionSwitchUseCheck(const UINT16 axisSecId);
+
+/*
+* 功能描述：设置跳跃锁闭防护道岔区段征用状态
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+*           const UINT8 state 状态
+* 返回值  ： void
+*  add by mpt 20260331
+*/
+void SetJumpPhySectionPortectSecUse(const UINT16 axisSecId, const UINT8 state);
+
+/*
+* 功能描述：设置逻辑区段的防护道岔区段征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+*           const UINT8 state 状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetJumpLogicSecPortectUse(const UINT16 wLgcId, const UINT8 state);
+
+/*
+* 功能描述： 设置计轴区段关联防护道岔防护锁闭状态
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+*            const UINT8 lockCommand, 锁闭状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetAxisRelProSwitchLockSta(const UINT16 axisSecId, const UINT8 lockCommand);
+
+/*
+* 功能描述： 计轴区段关联防护道岔防护锁闭检查
+* 参数说明： UINT16 const routeId,    计轴区段号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR
+*            CI_SUCCESS
+* add mpt 20260331
+*/
+UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+
+/*
+* 功能描述： 设置逻辑区段关联防护道岔防护锁闭状态
+* 参数说明： const UINT16 axisSecId, 计轴区段ID
+*            const UINT8 lockCommand, 锁闭状态
+* 返回值  ： void
+* add by mpt 20260331
+*/
+void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand);
+
+/*
+* 功能描述：计轴区段所有道岔是否全部征用
+* 参数说明：const UINT16 axisSecId 计轴区段ID
+* 返回值  ： CI_ERROR  未全部征用
+*            CI_SUCCESS 全部征用
+*  add by mpt 20260403
+*/
+UINT8 JumpPhySecAllUseCheck(const UINT16 axisSecId);
+
+
+/*
+* 功能描述： 计轴区段防护道岔引导总锁状态检查
+* 参数说明： UINT16 const axisSecId,    计轴区段编号
+*            UINT16 *pDevId,    设备Id（返回）
+*            UINT8 *pDevState,  设备状态（返回）
+* 返回值  ： CI_ERROR 0 失败
+*            CI_SUCCESS 1 成功
+* Add by LQ 20260518
+*/
+UINT8 AxisSecProtSwtYLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
+
 #endif
 
+
+
+

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

@@ -209,6 +209,7 @@ UINT8 SetCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 	UINT8 reResult = CI_ERROR;          /*返回值*/
 	UINT8 checkResult = CI_ERROR;       /*检查结果*/
 
+	UINT16 devId = 0u;                   /*设备ID*/
 	UINT8 devState = 0u;                 /*设备状态*/
 
 	/*虚拟联锁兼容*/
@@ -336,6 +337,53 @@ UINT8 SetCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 
 		}
 	}
+	/*风井区段占用检查*/
+	if (CI_SUCCESS == reResult)
+	{
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAirShaftSecOccuCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	/*风井区段锁闭检查*/
+	if (CI_SUCCESS == reResult)
+	{
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAirShaftSecLockCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_LOCK_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
 
 	if (CI_SUCCESS == reResult)
 	{
@@ -1661,6 +1709,54 @@ UINT8 LockCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 		}
 	}
 
+	/*风井区段占用检查*/
+	if (CI_SUCCESS == reResult)
+	{
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAirShaftSecOccuCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+
+	/*风井区段锁闭检查*/
+	if (CI_SUCCESS == reResult)
+	{
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAirShaftSecLockCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_LOCK_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+
 	if (CI_SUCCESS == reResult)
 	{
 		/* 道岔联锁条件检查 */
@@ -3587,6 +3683,31 @@ UINT8 OpenCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 			reResult = CI_ERROR;
 		}
 	}
+
+	/*风井区段占用检查*/
+	if (CI_SUCCESS == reResult)
+	{
+		devId = 0u;
+		devState = 0u;
+		checkResult = RouteAirShaftSecOccuCheck(routeId, &devId, &devState);
+		if (CI_SUCCESS == checkResult)
+		{
+			/* 通过检查 */
+			reResult = CI_SUCCESS;
+		}
+		else
+		{
+			/* 记录故障码 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
+			/* 失败返回 */
+			reResult = CI_ERROR;
+		}
+	}
+	else
+	{
+		/*不处理*/
+	}
+	
     /* 道岔联锁条件检查 */
 	if (CI_SUCCESS == reResult)
 	{
@@ -8968,6 +9089,7 @@ UINT8 SetCbtcRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 			reResult = CI_ERROR;
 		}
 	}
+	
     /* 返回结果 */
     return reResult;
 }

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

@@ -18,6 +18,7 @@
 #include "../IO/OutputDataProcess.h"
 #include "EnvelopeManageAPI.h"
 #include "../DataManage/PlatDataManage.h"
+#include "../IO/InputDataProcess.h"
 
 /*解包使用*/
 CommandDataStruct CiRevCmdDataStru[ATSORXIANDI_TO_CI_CMD_DATA_STRU_SUM_MAX] = {0u}; /*CI操作命令结构体数组*/
@@ -191,7 +192,7 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt
 	UINT16 preAtsRouteSteCmdNum = 0u; /*检查ATS进路办理命令数*/
 	UINT16 wCmdStartByteNum = 0u;/*单条命令长度校验用*/
 	UINT16 wParseCmdLength = 0u;
-	UINT8 chLogicSecIndex = 0u;
+	UINT8 chSecIndex = 0u;
 	UINT32 dwHlhtTrainId = 0u;/*互联互通列车编号*/
 	UINT16 wTrainId = 0;/*列车ID 高字节类型，低字节编号*/
 	UINT16 logId = 0;/*vobc时是使用端编号 1-TC1 2-TC2 0-2IP车（首尾冗余车）*/
@@ -200,7 +201,7 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt
 	UINT32 dwCmdId = 0u;
 	UINT16 wTerminalId = 0u;
 	UINT8 chVirCi = 0u;
-	UINT8 chLogSecNum = 0u;
+	UINT8 chSectionNum = 0u;
 	UINT8 chToaCmdNum = 0u;
 	UINT32 dwCmdParam_DevID = 0u;
 	UINT16 dwCmdParam_Type = 0u;
@@ -314,7 +315,7 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt
 							ii += 4u;
 							(void)dquHlhtId2VobcName(dwHlhtTrainId, &wTrainId, &logId);/*4字节互联互通编号转2字节*/
 
-							chLogSecNum = dataBuf[ii++];/*逻辑区段数量*/
+							chSectionNum = dataBuf[ii++];/*区段数量,命令类型为0x93,0x94代表逻辑区段数量，0x0b,0x0c代表物理区段数量*/
 							/*对命令编号、命令设备ID进行防护*/
 							dwCmdParam_DevID = dwCmdParam & 0xffff0000u;
 							dwCmdParam_Type = (UINT16)(dwCmdParam & 0x0000ff00u);
@@ -334,7 +335,7 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt
 								{
 									chToaCmdNum++;
 									chRetVal = ToaAddCmd(chCmdType, wTrainId, dwCmdId, wTerminalId, chVirCi, dwCmdParam);
-									if ((CI_SUCCESS == chRetVal) && (0u != chLogSecNum))
+									if ((CI_SUCCESS == chRetVal) && (0u != chSectionNum))
 									{
 										chRetVal = CI_ERROR;
 									}
@@ -353,12 +354,12 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt
 									CiRevCmdDataStru[jj].wTrainIdParam = wTrainId;  /* 列车ID*/
 									CiRevCmdDataStru[jj].OverLapRouteID = oVerlap_RouteId;  /* 保护区段关联进路ID*/
 
-									CiRevCmdDataStru[jj].chLogicSecSum = chLogSecNum;/*逻辑区段数量*/
+									CiRevCmdDataStru[jj].chSectionSum = chSectionNum;/*区段数量*/
-									if (MAX_ROUTE_IN_LT_NUM > CiRevCmdDataStru[jj].chLogicSecSum)
+									if (MAX_ROUTE_IN_LT_NUM > CiRevCmdDataStru[jj].chSectionSum)
 									{
-										for (chLogicSecIndex = 0u; chLogicSecIndex < CiRevCmdDataStru[jj].chLogicSecSum; chLogicSecIndex++)
+										for (chSecIndex = 0u; chSecIndex < CiRevCmdDataStru[jj].chSectionSum; chSecIndex++)
 										{
-											CiRevCmdDataStru[jj].wLogicSecData[chLogicSecIndex] = ShortFromChar(&dataBuf[ii]);/*逻辑区段ID*/
+											CiRevCmdDataStru[jj].wSectionData[chSecIndex] = ShortFromChar(&dataBuf[ii]);/*区段ID序列，命令类型为0x93,0x94代表逻辑区段序列，0x0b,0x0c代表物理区段序列*/
 											ii += 2u;
 										}
 									}
@@ -503,7 +504,6 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 	UINT8 cTiocCutReason = 0u;
 	UINT8 cTiocCutState = REVERSE_CUT_STATE_DEFAULT;
 	UINT32 dwTrainId = 0u;
-	UINT8 cLogId = 0u;
 	UINT8 cFunRetVal = CI_ERROR;
 	UINT8 ocstionPowerIndic = 0U;
 
@@ -522,6 +522,7 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 	UINT8 chVirHeadScreStat = TRAIN_VIR_SCREEN_PASS_FLAG_INVALID;	    /*列车虚拟前筛标志*/
 	UINT8 chVirTailScreStat = TRAIN_VIR_SCREEN_PASS_FLAG_INVALID;		/*列车虚拟后筛标志*/
 	UINT16 wTrainId = 0u;				/*列车ID*/
+	UINT8 cPhySecIndex = 0U;
 	UINT8 chRetVal = CI_ERROR;
 	UINT8 indicatorType = 0u; /*设备类型*/
 
@@ -767,11 +768,9 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 
 				if (0u != CiSendCmdDataStru[jj].wTrainIdParam)
 				{
-					cLogId = (UINT8)(CiSendCmdDataStru[jj].wTrainIdParam & 0xFFu);
+					cFunRetVal = dquDevName2HlhtId(CiSendCmdDataStru[jj].wTrainIdParam, 0U, &dwTrainId);
-					cFunRetVal = dquDevName2HlhtId(CiSendCmdDataStru[jj].wTrainIdParam, cLogId, &dwTrainId);
 					if (CI_ERROR == cFunRetVal)
 					{
-						cLogId = 0u;
 						dwTrainId = 0u;
 					}
 					else
@@ -781,13 +780,12 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 				}
 				else
 				{
-					cLogId = 0u;
 					dwTrainId = 0u;
 				}
 				LongToChar(dwTrainId, &ciToXianDiDataBuffer[ii]);
 				ii += 4u;
 
-				ciToXianDiDataBuffer[ii++] = 0u;/*逻辑区段数量*/
+				ciToXianDiDataBuffer[ii++] = 0u;/*区段数量*/							
 			}
 
 			ShortToChar((UINT16)(ii - curIndex - 2U), &ciToXianDiDataBuffer[curIndex]);  /*命令帧总长度*/
@@ -3092,4 +3090,218 @@ void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
 	{
 		/*入参检查失败，不处理*/
 	}
+}
+
+/*
+* 功能描述：检查批量计轴复位命令
+* 参数说明：UINT8 virCIid 输入虚拟联锁ID
+*		UINT8 orderType  命令类型
+*       const UINT8 cPhySecSum  物理区段数量
+*		const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返 回 值：无
+* Created By yx 2026.04.14
+*/
+UINT8 CheckAxisResetCmd(UINT8 virCIid, UINT8 cmdType, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[])
+{
+	UINT8 ii = 0U;
+	UINT8 checkRetVal = CI_FALSE;
+	UINT8 belongVirCIid = 0U;
+	UINT8 OrderCheckReVal = 0U;
+	UINT8 retVal = CI_ERROR;
+	UINT16 wPhySecId = 0U;  /*物理区段ID*/
+	if ((NULL != pPhySecIdBuff) && (0U != cPhySecSum))
+	{
+		for (ii = 0U; ii < cPhySecSum; ii++)
+		{
+			wPhySecId = pPhySecIdBuff[ii];
+			checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_PHYSEC, wPhySecId);
+			belongVirCIid = GetPhySecBelongVirCiId(wPhySecId);
+			OrderCheckReVal = CheckOrderWhetherDoing(virCIid, belongVirCIid, cmdType, wPhySecId);	/*检查命令能否被执行*/
+			if ((CI_TRUE == checkRetVal) && (CI_SUCCESS == OrderCheckReVal))
+			{
+				/*继续检查*/
+			}
+			else
+			{/*检查失败*/
+				retVal = CI_ERROR;
+				break;
+			}			
+		}
+		/*所有区段都检查完成且全部通过*/
+		if (ii == cPhySecSum)
+		{
+			retVal = CI_SUCCESS;
+		}
+	}
+	else
+	{
+		/*数据错误，返回失败*/
+	}	
+	return retVal;
+}
+
+/*
+* 功能描述： 针对批量计轴复位一次二次命令的反馈
+* 参数说明： const UINT32 commandId, 命令ID
+*			 const UINT16 deviceId, 设备ID
+*            const UINT8 deviceType, 设备类型
+*            const UINT16 termial_id,终端ID
+*			 const UINT8 order_type，命令类型
+*			 const UINT8 response_type, 回复类型
+*            const UINT8 affirm_result, 确认结果
+*			 const UINT8 virCIid, 虚拟联锁ID
+*			 const UINT8 cPhySecSum  物理区段数量
+*			 const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返回值  ： 无
+*/
+void SetAixsResetCiSendCmdBackData(const UINT32 commandId, const UINT16 deviceId, const UINT8 deviceType, const UINT16 termial_id, const UINT8 order_type, const UINT8 response_type, const UINT8 affirm_result, const UINT8 virCIid, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[])
+{
+	UINT32 curCycleNum = 0U;
+	UINT32 appCycTime = 0U;/*联锁周期数*/
+	UINT16 ii = 0U;
+	UINT8 jj = 0U;
+	UINT16 cmdDeviceId = 0U;
+	UINT8 cmdDevType = 0U;	
+	UINT32 deviceInfo = 0U;  /*设备信息*/
+	UINT32 firstOrderTimeCount = 0U;
+	UINT8 checkVaild = CI_SUCCESS;
+	curCycleNum = Get2oo2CurCycleNum();
+	appCycTime = GetSystemParaAppCycleTime();/*获取联锁周期号*/
+	firstOrderTimeCount = GetFirstOrderTimeCount();
+	/*要发送二次命令时，清除暂存的一次命令*/
+	if (RESPONSE_SECOND == response_type)
+	{
+		for (ii = 0U; ii < CiSendBackDataTempStruSum; ii++)
+		{
+			cmdDeviceId = (UINT16)(CiSendBackDataTempStru[ii].CommandParam >> 16U);
+			cmdDevType = (UINT8)(CiSendBackDataTempStru[ii].CommandParam >> 8U);
+			if ((termial_id == CiSendBackDataTempStru[ii].termial_id) && (commandId == CiSendBackDataTempStru[ii].CommandId)
+				&& (deviceType == cmdDevType) && (deviceId == cmdDeviceId) && (virCIid == CiSendBackDataTempStru[ii].VirCIid)
+				&& (cPhySecSum == CiSendBackDataTempStru[ii].chSectionSum))
+			{
+				for (jj = 0U; jj < cPhySecSum; jj++)
+				{
+					if (pPhySecIdBuff[jj] != CiSendBackDataTempStru[ii].wSectionData[jj])
+					{
+						checkVaild = CI_ERROR;
+						break;
+					}
+					else
+					{
+						/*继续对比*/
+					}
+				}
+				if (CI_SUCCESS == checkVaild)
+				{
+					(void)CommonMemSet((void*)&CiSendBackDataTempStru[ii], (UINT32)sizeof(CommandDataStruct), 0U, (UINT32)sizeof(CommandDataStruct));
+				}
+				else
+				{
+					/*不是同一个一次二次命令*/
+				}
+				
+			}
+		}
+	}	
+	/*清除暂存一次命令后，将无效命令清除，并将数量置为有效命令的数量*/
+	ClearCiSendBackDataTempStruData();
+
+	if (CiSendCmdStruCurSum < CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX)
+	{
+		deviceInfo = (((deviceInfo | (UINT32)deviceId) << 16U) | ((deviceInfo | (UINT32)deviceType) << 8U) | (UINT32)0U);
+
+		CiSendCmdDataStru[CiSendCmdStruCurSum].CommandType = CI_BACK_ORDER_REPEAT;/*分类号0x70*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].CommandId = commandId;/*命令ID  */
+		CiSendCmdDataStru[CiSendCmdStruCurSum].CommandParam = deviceInfo;/*设备ID+设备类型+参数(时间值)*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].termial_id = termial_id; /*终端ID*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].order_type = order_type;/*命令类型*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].response_type = response_type;/*回复类型*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].affirm_result = affirm_result; /*确认结果*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].setCurNum = 0U; /*一次命令设置周期*/
+		CiSendCmdDataStru[CiSendCmdStruCurSum].firstCmd_time = 0U;
+		CiSendCmdDataStru[CiSendCmdStruCurSum].VirCIid = virCIid;
+		CiSendCmdDataStru[CiSendCmdStruCurSum].OCid = 0U;
+		CiSendCmdDataStru[CiSendCmdStruCurSum].chSectionSum = cPhySecSum;	/*物理区段数量*/
+		if ((pPhySecIdBuff != NULL) && (cPhySecSum > 0U))
+		{
+			(void)CommonMemCpy((void*)CiSendCmdDataStru[CiSendCmdStruCurSum].wSectionData, (UINT32)cPhySecSum * sizeof(UINT16), (const void*)pPhySecIdBuff, (UINT32)cPhySecSum * sizeof(UINT16));	/*物理区段序列*/
+		}
+		if ((RESPONSE_FIRST == CiSendCmdDataStru[CiSendCmdStruCurSum].response_type) && (AFFIRM_SUCCESS == CiSendCmdDataStru[CiSendCmdStruCurSum].affirm_result))
+		{/*针对一次命令设置命令周期*/
+			CiSendCmdDataStru[CiSendCmdStruCurSum].setCurNum = curCycleNum; /*一次命令设置周期*/
+			CiSendCmdDataStru[CiSendCmdStruCurSum].firstCmd_time = (UINT8)((firstOrderTimeCount * appCycTime) / 1000U);
+			/*暂存1次命令*/
+			if (CiSendBackDataTempStruSum < CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX)
+			{
+				(void)CommonMemCpy(&CiSendBackDataTempStru[CiSendBackDataTempStruSum], (UINT32)sizeof(CommandDataStruct), &CiSendCmdDataStru[CiSendCmdStruCurSum], (UINT32)sizeof(CommandDataStruct));
+				CiSendBackDataTempStruSum++;
+			}
+			else
+			{
+				debug_infor_printf((const)"Error:CiSendBackDataTempStru,%d exceed max %d\n", CiSendBackDataTempStruSum, CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX);
+			}
+		}
+		CiSendCmdStruCurSum++;
+	}
+	else
+	{
+		debug_infor_printf((const)"Error:SetAixsResetCiSendCmdBackData,%d exceed max %d\n", CiSendCmdStruCurSum, CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX);
+	}
+}
+
+/*
+* 功能描述： 批量计轴复位二次命令有效性检查
+* 参数说明： const UINT32 commandId, 命令ID
+*			 const UINT16 deviceId, 设备ID
+*            const UINT8 deviceType, 设备类型
+*            const UINT16 termial_id,终端ID
+*			 const UINT8 order_type，命令类型
+*			 const UINT8 virCIid, 虚拟联锁ID
+*			 const UINT8 cPhySecSum  物理区段数量
+*			 const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返回值  ：CI_ERROR : 失败
+*			CI_SUCCESS: 成功
+*/
+UINT8 CheckAxisResetSndOrderValid(const UINT32 commandId, const UINT16 deviceId, const UINT8 deviceType, const UINT16 termial_id, const UINT8 order_type, const UINT8 virCiID, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[])
+{
+	UINT16 ii = 0U;
+	UINT16 jj = 0U;
+	UINT8 reVal = CI_ERROR;
+	UINT8 firstOrder = 0U;
+	UINT16 cmdDeviceId = 0U;
+	UINT8 cmdDevType = 0U;
+	UINT8 checkVaild = CI_SUCCESS;
+	firstOrder = FindFirstOrder(order_type);
+	for (ii = 0U; ii < CiSendBackDataTempStruSum; ii++)
+	{
+		cmdDeviceId = (UINT16)(CiSendBackDataTempStru[ii].CommandParam >> 16U);
+		cmdDevType = (UINT8)(CiSendBackDataTempStru[ii].CommandParam >> 8U);
+		if ((deviceId == cmdDeviceId) && (deviceType == cmdDevType) && (commandId == CiSendBackDataTempStru[ii].CommandId)
+			&& (termial_id == CiSendBackDataTempStru[ii].termial_id) && (firstOrder == CiSendBackDataTempStru[ii].order_type)
+			&& (0U != firstOrder) && (virCiID == CiSendBackDataTempStru[ii].VirCIid) && (cPhySecSum == CiSendBackDataTempStru[ii].chSectionSum))
+		{
+			for (jj = 0U; jj < cPhySecSum; jj++)
+			{
+				if (pPhySecIdBuff[jj] != CiSendBackDataTempStru[ii].wSectionData[jj])
+				{
+					checkVaild = CI_ERROR;
+					break;
+				}
+				else
+				{
+					/*继续对比*/
+				}
+			}
+			if (CI_SUCCESS == checkVaild)
+			{
+				reVal = CI_SUCCESS;
+			}
+			else
+			{
+				reVal = CI_ERROR;
+			}
+			break;
+		}
+	}
+	return reVal;
 }

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

@@ -91,8 +91,8 @@ typedef struct S_CommandDataStruct
 	UINT8 VirCIid;/*虚拟联锁ID*/
 	/*车车新加*/
 	UINT16 wTrainIdParam;		/*列车ID 20220301车车新增*/
-	UINT8 chLogicSecSum;		/*逻辑区段数量 20220301车车新增*/
+	UINT8 chSectionSum;		/*区段数量,命令类型为0x93,0x94代表逻辑区段数量，0x0b,0x0c代表物理区段数量*/
-	UINT16 wLogicSecData[MAX_ROUTE_IN_LT_NUM];/*逻辑区段序列 20220301车车新增*/
+	UINT16 wSectionData[MAX_ROUTE_IN_LT_NUM];/*区段序列，命令类型为0x93,0x94代表逻辑区段序列，0x0b,0x0c代表物理区段序列*/
 	UINT8 OCid;/*OC ID*/
 	UINT16 OverLapRouteID;		/*保护区段关联进路ID 20240319车车新增*/
 	
@@ -408,6 +408,49 @@ UINT8 GetOcPscConfirmFlag(UINT8 index);
 */
 void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
 
+/*
+* 功能描述：检查批量计轴复位命令
+* 参数说明：UINT8 virCIid 输入虚拟联锁ID
+*		UINT8 orderType  命令类型
+*       const UINT8 cPhySecSum  物理区段数量
+*		const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返 回 值：无
+* Created By yx 2026.04.14
+*/
+UINT8 CheckAxisResetCmd(UINT8 virCIid, UINT8 cmdType, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[]);
+
+/*
+* 功能描述： 针对批量计轴复位一次二次命令的反馈
+* 参数说明： const UINT32 commandId, 命令ID
+*			 const UINT16 deviceId, 设备ID
+*            const UINT8 deviceType, 设备类型
+*            const UINT16 termial_id,终端ID
+*			 const UINT8 order_type，命令类型
+*			 const UINT8 response_type, 回复类型
+*            const UINT8 affirm_result, 确认结果
+*			 const UINT8 virCIid, 虚拟联锁ID
+*			 const UINT8 cPhySecSum  物理区段数量
+*			 const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返回值  ： 无
+* Created By yx 2026.04.14
+*/
+void SetAixsResetCiSendCmdBackData(const UINT32 commandId, const UINT16 deviceId, const UINT8 deviceType, const UINT16 termial_id, const UINT8 order_type, const UINT8 response_type, const UINT8 affirm_result, const UINT8 virCIid, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[]);
+
+/*
+* 功能描述： 批量计轴复位二次命令有效性检查
+* 参数说明： const UINT32 commandId, 命令ID
+*			 const UINT16 deviceId, 设备ID
+*            const UINT8 deviceType, 设备类型
+*            const UINT16 termial_id,终端ID
+*			 const UINT8 order_type，命令类型
+*			 const UINT8 virCIid, 虚拟联锁ID
+*			 const UINT8 cPhySecSum  物理区段数量
+*			 const UINT16 pPhySecIdBuff[]  物理区段ID数组
+* 返回值  ：CI_ERROR : 失败
+*			CI_SUCCESS: 成功
+* Created By yx 2026.04.14
+*/
+UINT8 CheckAxisResetSndOrderValid(const UINT32 commandId, const UINT16 deviceId, const UINT8 deviceType, const UINT16 termial_id, const UINT8 order_type, const UINT8 virCiID, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[]);
 #ifdef __cplusplus
 }
 #endif

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

@@ -617,7 +617,6 @@ UINT8 CheckCi2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength,UINT
 	UINT16 cmdNum = 0u,		cmdNumIndex = 0u;
 	UINT16 stationLen = 0u,	stationLenIndex = 0u;
 	UINT16 tmpStationLen = 0u;
-	UINT16 tmpTotalLen = 0u;
 	UINT16 logsecLockStateNumIndex = 0u;
 	UINT16 logsecLockStateNum = 0u;
 	UINT16 wCfpInfoNum = 0u;
@@ -1345,7 +1344,7 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 	UINT8 cFlashTrainInfoFlag = 0u;/* 是否刷新列车信息 */
 	UINT16 dwTmpIndex = 0u;
 	CfpTrainInfoStru tmpTrainInfo = { 0u };
-	CfpEnvelopeStruct tmpEnvelopeInfo = { 0u };
+	CfpEnvelopeStruct tmpOtherEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX] = {0u};	/* 接收到的其他联锁的包络信息 */
 	UINT8 chEnvelopeNum = 0u;
 	UINT8 chEnvelopeIndex = 0u;
 	UINT8 chTrainIndex = 0u;
@@ -2643,214 +2642,224 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 
 				/* 分界点收到相邻OC发来的包络数量 */
 				chEnvelopeNum = dataBuf[ii++];
-				if (CUTOFF_POINT_SUM_MAX >= chEnvelopeNum)
+				if (OTHER_RC_SEND_ENVELOPE_SUM_MAX >= chEnvelopeNum)
 				{
-					SetCfpOtherOcENum(deviceId, chEnvelopeNum);
+					for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
+					{
+						tmpOtherEnvelope[chEnvelopeIndex].envelopeType = dataBuf[ii++];	/* 包络类型 */
+						if ((TYPE_UKT_ENVELOPE == tmpOtherEnvelope[chEnvelopeIndex].envelopeType)
+							|| (TYPE_UCT_ENVELOPE == tmpOtherEnvelope[chEnvelopeIndex].envelopeType)
+							|| (TYPE_CT_ENVELOPE == tmpOtherEnvelope[chEnvelopeIndex].envelopeType))
+						{
+							;/*1:通信车 2：丢失通信车 3：隐藏车*/
+						}
+						else
+						{
+							reVal = CI_ERROR;
+						}
+
+						tmpOtherEnvelope[chEnvelopeIndex].headTrainID = ShortFromChar(&dataBuf[ii]);/* 前车ID */
+						ii += 2u;
+
+						tmpOtherEnvelope[chEnvelopeIndex].tailTrainID = ShortFromChar(&dataBuf[ii]);/* 后车ID */
+						ii += 2u;
+
+						tmpOtherEnvelope[chEnvelopeIndex].startPos.Dir = dataBuf[ii++];/* 起点方向 */
+
+						tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 起点link */
+						ii += 2u;
+
+						tmpOtherEnvelope[chEnvelopeIndex].startPos.Off = LongFromChar(&dataBuf[ii]);/* 起点offset */
+						ii += 4u;
+
+						tmpOtherEnvelope[chEnvelopeIndex].endPos.Dir = dataBuf[ii++];/* 终点方向 */
+
+						tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 终点link */
+						ii += 2u;
+
+						tmpOtherEnvelope[chEnvelopeIndex].endPos.Off = LongFromChar(&dataBuf[ii]);/* 终点offset */
+						ii += 4u;
+
+						wLinkTioc = GetLinkManageTiocById(tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk);
+						if (wLinkTioc == localCiId)
+						{
+							(void)dsuCheckSameLoc(tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk, tmpOtherEnvelope[chEnvelopeIndex].startPos.Off, &tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk, &tmpOtherEnvelope[chEnvelopeIndex].startPos.Off);
+						}
+
+						wLinkTioc = GetLinkManageTiocById(tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk);
+						if (wLinkTioc == localCiId)
+						{
+							(void)dsuCheckSameLoc(tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk, tmpOtherEnvelope[chEnvelopeIndex].endPos.Off, &tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk, &tmpOtherEnvelope[chEnvelopeIndex].endPos.Off);
+						}
+
+						/*分界点相邻OC发来的包络截取转移至发送联锁处理*/
+
+						tmpOtherEnvelope[chEnvelopeIndex].ACCnt = elm_PrepareACBtwPoints(tmpOtherEnvelope[chEnvelopeIndex].startPos, tmpOtherEnvelope[chEnvelopeIndex].endPos, tmpOtherEnvelope[chEnvelopeIndex].ACID);
+						/* 内部优化 20220419 wqm elm_PrepareACBtwPoints返回0或者返回列车包络中包含的区段最大个数时，此处都应设置返回为CI_ERROR*/
+						if ((SECTION_IN_ENVELOPE_SUM_MAX == tmpOtherEnvelope[chEnvelopeIndex].ACCnt) || (0u == tmpOtherEnvelope[chEnvelopeIndex].ACCnt))
+						{
+							reVal = CI_ERROR;
+						}
+						else
+						{
+							for (chAcIndex = 0u; chAcIndex < tmpOtherEnvelope[chEnvelopeIndex].ACCnt; chAcIndex++)
+							{
+								wTiocId = GetAxisBelongTioc(tmpOtherEnvelope[chEnvelopeIndex].ACID[chAcIndex]);
+								if ((localCiId == wTiocId) || (0u == wTiocId))
+								{
+									reVal = CI_ERROR;
+									break;
+								}
+								else
+								{
+									;
+								}
+							}
+						}
+
+
+						tmpOtherEnvelope[chEnvelopeIndex].trianCnt = dataBuf[ii++];/* 包含列车数量 */
+
+						for (chTrainIndex = 0u; chTrainIndex < tmpOtherEnvelope[chEnvelopeIndex].trianCnt; chTrainIndex++)
+						{
+							tmpOtherEnvelope[chEnvelopeIndex].trainID[chTrainIndex] = ShortFromChar(&dataBuf[ii]);/* 列车ID */
+							ii += 2u;
+
+							tmpOtherEnvelope[chEnvelopeIndex].ACTPort[chTrainIndex] = dataBuf[ii++];  /* 列车激活端——UCT跨分界点RRM用 */
+						}
+
+						if (CI_SUCCESS != reVal)
+						{
+							break;
+						}
+					}
+					if (CI_SUCCESS == reVal)
+					{
+						/*全部解析通过 写入分界点接收到的包络数据 */
+						SetCfpOtherOcENum(deviceId, chEnvelopeNum);
+						for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
+						{
+							SetCfpOtherOcEData(deviceId, chEnvelopeIndex, tmpOtherEnvelope[chEnvelopeIndex]);
+						}
+						
+					}
 				}
 				else
 				{
 					reVal = CI_ERROR;
 				}
 
-				for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
+				
+				if (CI_SUCCESS == reVal)
 				{
-					tmpEnvelopeInfo.envelopeType = dataBuf[ii++];	/* 包络类型 */
+					chCtNum = dataBuf[ii++];
-					if ((TYPE_UKT_ENVELOPE == tmpEnvelopeInfo.envelopeType)
+					for (chCtIndex = 0u; chCtIndex < chCtNum; chCtIndex++)
-						|| (TYPE_UCT_ENVELOPE == tmpEnvelopeInfo.envelopeType)
-						|| (TYPE_CT_ENVELOPE == tmpEnvelopeInfo.envelopeType))
 					{
-						;/*1:通信车 2：丢失通信车 3：隐藏车*/
+						wTrainId = ShortFromChar(&dataBuf[ii]);		/* 列车ID */
-					}
-					else
-					{
-						reVal = CI_ERROR;
-					}
-
-					tmpEnvelopeInfo.headTrainID = ShortFromChar(&dataBuf[ii]);/* 前车ID */
-					ii += 2u;
-
-					tmpEnvelopeInfo.tailTrainID = ShortFromChar(&dataBuf[ii]);/* 后车ID */
-					ii += 2u;
-
-					tmpEnvelopeInfo.startPos.Dir = dataBuf[ii++];/* 起点方向 */
-
-					tmpEnvelopeInfo.startPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 起点link */
-					ii += 2u;
-
-					tmpEnvelopeInfo.startPos.Off = LongFromChar(&dataBuf[ii]);/* 起点offset */
-					ii += 4u;
-
-					tmpEnvelopeInfo.endPos.Dir = dataBuf[ii++];/* 终点方向 */
-
-					tmpEnvelopeInfo.endPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 终点link */
-					ii += 2u;
-
-					tmpEnvelopeInfo.endPos.Off = LongFromChar(&dataBuf[ii]);/* 终点offset */
-					ii += 4u;
-
-					wLinkTioc = GetLinkManageTiocById(tmpEnvelopeInfo.startPos.Lnk);
-					if (wLinkTioc == localCiId)
-					{
-						(void)dsuCheckSameLoc(tmpEnvelopeInfo.startPos.Lnk, tmpEnvelopeInfo.startPos.Off, &tmpEnvelopeInfo.startPos.Lnk, &tmpEnvelopeInfo.startPos.Off);
-					}
-					
-					wLinkTioc = GetLinkManageTiocById(tmpEnvelopeInfo.endPos.Lnk);
-					if (wLinkTioc == localCiId)
-					{
-						(void)dsuCheckSameLoc(tmpEnvelopeInfo.endPos.Lnk, tmpEnvelopeInfo.endPos.Off, &tmpEnvelopeInfo.endPos.Lnk, &tmpEnvelopeInfo.endPos.Off);
-					}
-
-					/*截取分界点相邻OC发来的包络数据*/
-					reVal = CutCfpOtherOcEData(deviceId,&tmpEnvelopeInfo);
-
-					tmpEnvelopeInfo.ACCnt = elm_PrepareACBtwPoints(tmpEnvelopeInfo.startPos, tmpEnvelopeInfo.endPos, tmpEnvelopeInfo.ACID);
-					/* 内部优化 20220419 wqm elm_PrepareACBtwPoints返回0或者返回列车包络中包含的区段最大个数时，此处都应设置返回为CI_ERROR*/
-					if ((SECTION_IN_ENVELOPE_SUM_MAX == tmpEnvelopeInfo.ACCnt) || (0u == tmpEnvelopeInfo.ACCnt))
-					{
-						reVal = CI_ERROR;
-					}
-					else
-					{
-						for (chAcIndex = 0u; chAcIndex < tmpEnvelopeInfo.ACCnt; chAcIndex++)
-						{
-							wTiocId = GetAxisBelongTioc(tmpEnvelopeInfo.ACID[chAcIndex]);
-							if ((localCiId == wTiocId) || (0u == wTiocId))
-							{
-								reVal = CI_ERROR;
-								break;
-							}
-							else
-							{
-								;
-							}
-						}
-					}
-
-
-					tmpEnvelopeInfo.trianCnt = dataBuf[ii++];/* 包含列车数量 */
-
-					for (chTrainIndex = 0u; chTrainIndex < tmpEnvelopeInfo.trianCnt; chTrainIndex++)
-					{
-						tmpEnvelopeInfo.trainID[chTrainIndex] = ShortFromChar(&dataBuf[ii]);/* 列车ID */
 						ii += 2u;
 
-						tmpEnvelopeInfo.ACTPort[chTrainIndex] = dataBuf[ii++];  /* 列车激活端——UCT跨分界点RRM用 */
+						g_szTiocCt[chTiocIndex].szCtId[g_szTiocCt[chTiocIndex].chCtNum++] = wTrainId;
+
+						SetTrainMsgFromTiocId(wTrainId, (UINT8)sourceId);
+
+						(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_GOOD);
+
+						chLevel = dataBuf[ii++];
+						(void)SetTrainLevel(wTrainId, chLevel);			/* 列车运行级别 */
+
+						dwTrainDelay = LongFromChar(&dataBuf[ii]);	/* TIOC与列车通信延时 */
+						ii += 4u;
+						(void)SetTrainMsgDelayTime(wTrainId, dwTrainDelay);
+
+						wSpeed = ShortFromChar(&dataBuf[ii]);
+						ii += 2u;
+						(void)SetTrainSpeed(wTrainId, wSpeed);			/* 列车速度 */
+
+						chSpeedDir = dataBuf[ii++];
+						(void)SetTrainSpeedDir(wTrainId, chSpeedDir);		/* 速度方向 */
+
+						chTrainDir = dataBuf[ii++];
+						(void)SetTrainDir(wTrainId, chTrainDir);			/* 列车运行方向 */
+
+						wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最大安全前link */
+						ii += 2u;
+						(void)SetTrainMaxHeadLink(wTrainId, wLinkId);
+
+						dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最大安全前Offset */
+						ii += 4u;
+						(void)SetTrainMaxHeadOffset(wTrainId, dwOffset);
+
+						wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最小安全前link */
+						ii += 2u;
+						(void)SetTrainMinHeadLink(wTrainId, wLinkId);
+
+						dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最小安全前Offset */
+						ii += 4u;
+						(void)SetTrainMinHeadOffset(wTrainId, dwOffset);
+
+						wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最大安全后link */
+						ii += 2u;
+						(void)SetTrainMaxTailLink(wTrainId, wLinkId);
+
+						dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最大安全后Offset */
+						ii += 4u;
+						(void)SetTrainMaxTailOffset(wTrainId, dwOffset);
+
+						wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最小安全后link */
+						ii += 2u;
+						(void)SetTrainMinTailLink(wTrainId, wLinkId);
+
+						dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最小安全后Offset */
+						ii += 4u;
+						(void)SetTrainMinTailOffset(wTrainId, dwOffset);
+
+						/*设置列车最大安全后端、最小安全前端、最大安全前端的运行方向*/
+						reVal = SetTrainOtherPointDir(wTrainId, chTrainDir);
+
 					}
 
-					if (CI_SUCCESS == reVal)
+					/*分界点远程RM跨控区申请信息*/
+					cRrmSrcRcId = dataBuf[ii++];  /*源RC ID*/
+					wRrmTrainId = ShortFromChar(&dataBuf[ii]);						/* RRM列车ID */
+					ii += 2U;
+					wRrmTrainNextStaId = ShortFromChar(&dataBuf[ii]);				/* RRM列车申请的下一站台ID */
+					ii += 2U;
+					chRrmSrcApplyState = dataBuf[ii++];				/* 跨控区远程RM时，源TIOC申请状态 */
+					chRrmDstAllowState = dataBuf[ii++];				/* 跨控区远程RM时，目标TIOC允许状态 */
+
+					SetCfpRrmSrcRcId(deviceId, cRrmSrcRcId);
+					SetCfpRrmTrainId(deviceId, wRrmTrainId);
+					SetCfpRrmTrainNextStaId(deviceId, wRrmTrainNextStaId);
+					if (cRrmSrcRcId != localCiId)
 					{
-						/* 写入分界点接收到的包络数据 */
+						SetCfpRrmSrcApplyState(deviceId, chRrmSrcApplyState);
-						SetCfpOtherOcEData(deviceId, chEnvelopeIndex, tmpEnvelopeInfo);
 					}
 					else
 					{
-						;
+						/*本控区为源RC，不设置*/
+					}
+
+					SetCfpRrmDstAllowState(deviceId, chRrmDstAllowState);
+
+					wCfpRelAdjaRcSignalId = ShortFromChar(&dataBuf[ii]);
+					ii += 2U;
+					cCfpSignalLightUpFlag = dataBuf[ii];  /*分界点信号机亮灯标志*/
+					ii++;
+
+					belongCiId = GetSignalBelongCiId(wCfpRelAdjaRcSignalId);
+
+					if ((0U != belongCiId) && (belongCiId == localCiId))
+					{
+						SetSleepTrainLightUpSignalFlag(wCfpRelAdjaRcSignalId, cCfpSignalLightUpFlag);  /*设置来自分界点的休眠车点亮信号机标志有效*/
+					}
+					else
+					{
+						/*非本控区信号机，不处理*/
 					}
 				}
-
-				chCtNum = dataBuf[ii++];
-				for (chCtIndex = 0u; chCtIndex < chCtNum; chCtIndex++)
-				{
-					wTrainId = ShortFromChar(&dataBuf[ii]);		/* 列车ID */
-					ii += 2u;
-
-					g_szTiocCt[chTiocIndex].szCtId[g_szTiocCt[chTiocIndex].chCtNum++] = wTrainId;
-
-					SetTrainMsgFromTiocId(wTrainId, (UINT8)sourceId);
-
-					(void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_GOOD);
-
-					chLevel = dataBuf[ii++];
-					(void)SetTrainLevel(wTrainId, chLevel);			/* 列车运行级别 */
-
-					dwTrainDelay = LongFromChar(&dataBuf[ii]);	/* TIOC与列车通信延时 */
-					ii += 4u;
-					(void)SetTrainMsgDelayTime(wTrainId, dwTrainDelay);
-
-					wSpeed = ShortFromChar(&dataBuf[ii]);
-					ii += 2u;
-					(void)SetTrainSpeed(wTrainId, wSpeed);			/* 列车速度 */
-
-					chSpeedDir = dataBuf[ii++];
-					(void)SetTrainSpeedDir(wTrainId, chSpeedDir);		/* 速度方向 */
-
-					chTrainDir = dataBuf[ii++];
-					(void)SetTrainDir(wTrainId, chTrainDir);			/* 列车运行方向 */
-
-					wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最大安全前link */
-					ii += 2u;
-					(void)SetTrainMaxHeadLink(wTrainId, wLinkId);
-
-					dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最大安全前Offset */
-					ii += 4u;
-					(void)SetTrainMaxHeadOffset(wTrainId, dwOffset);
-
-					wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最小安全前link */
-					ii += 2u;
-					(void)SetTrainMinHeadLink(wTrainId, wLinkId);
-
-					dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最小安全前Offset */
-					ii += 4u;
-					(void)SetTrainMinHeadOffset(wTrainId, dwOffset);
-
-					wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最大安全后link */
-					ii += 2u;
-					(void)SetTrainMaxTailLink(wTrainId, wLinkId);
-
-					dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最大安全后Offset */
-					ii += 4u;
-					(void)SetTrainMaxTailOffset(wTrainId, dwOffset);
-
-					wLinkId = ShortFromChar(&dataBuf[ii]);		/* 列车最小安全后link */
-					ii += 2u;
-					(void)SetTrainMinTailLink(wTrainId, wLinkId);
-
-					dwOffset = LongFromChar(&dataBuf[ii]);		/* 列车最小安全后Offset */
-					ii += 4u;
-					(void)SetTrainMinTailOffset(wTrainId, dwOffset);
-
-					/*设置列车最大安全后端、最小安全前端、最大安全前端的运行方向*/
-					reVal = SetTrainOtherPointDir(wTrainId, chTrainDir);
-
-				}
-
-				/*分界点远程RM跨控区申请信息*/
-				cRrmSrcRcId = dataBuf[ii++];  /*源RC ID*/
-				wRrmTrainId = ShortFromChar(&dataBuf[ii]);						/* RRM列车ID */
-				ii += 2U;
-				wRrmTrainNextStaId = ShortFromChar(&dataBuf[ii]);				/* RRM列车申请的下一站台ID */
-				ii += 2U;
-				chRrmSrcApplyState = dataBuf[ii++];				/* 跨控区远程RM时，源TIOC申请状态 */
-				chRrmDstAllowState = dataBuf[ii++];				/* 跨控区远程RM时，目标TIOC允许状态 */
-
-				SetCfpRrmSrcRcId(deviceId, cRrmSrcRcId);
-				SetCfpRrmTrainId(deviceId, wRrmTrainId);
-				SetCfpRrmTrainNextStaId(deviceId, wRrmTrainNextStaId);
-				if (cRrmSrcRcId != localCiId)
-				{
-					SetCfpRrmSrcApplyState(deviceId, chRrmSrcApplyState);
-				}
 				else
 				{
-					/*本控区为源RC，不设置*/
+					break;
-				}
-				
-				SetCfpRrmDstAllowState(deviceId, chRrmDstAllowState);
-
-				wCfpRelAdjaRcSignalId = ShortFromChar(&dataBuf[ii]);
-				ii += 2U;
-				cCfpSignalLightUpFlag = dataBuf[ii];  /*分界点信号机亮灯标志*/
-				ii++;
-
-				belongCiId = GetSignalBelongCiId(wCfpRelAdjaRcSignalId);
-
-				if ((0U != belongCiId) && (belongCiId == localCiId))
-				{
-					SetSleepTrainLightUpSignalFlag(wCfpRelAdjaRcSignalId, cCfpSignalLightUpFlag);  /*设置来自分界点的休眠车点亮信号机标志有效*/
-				}
-				else
-				{
-					/*非本控区信号机，不处理*/
 				}
 			}
 		}
@@ -3834,7 +3843,6 @@ void PackCiToCiDataFrameUseCfg(UINT8 dstCiId,UINT8* dataFrame, UINT16* dataLengt
 	UINT8 routeBelongCi = 0u;
 	UINT8 belongCiId = 0u;
 	UINT8 startLockFlag = 0u;
-	UINT16 secPLockBelongRouteId = 0u;
 	UINT16 logSectionSum = 0u;
 	UINT16* logIdBuf = NULL;
 	UINT16 logLockBelongRouteId = 0u;
@@ -5167,7 +5175,6 @@ UINT8 ParseCiToCiDataFrameHLHT(UINT8* dataBuf, const UINT16 dataLength, const UI
 	UINT32 ii = 0u;
 	UINT8 startLockState = 0u;
 	UINT8 chTransmitRecvDataCycResult = 0U;/*通信状态更新结果*/
-	UINT8 ch2oo2SheBeiType = 0U;/*设备类型*/
 	UINT32 dwBadEnsureTime = 0U;  /*通信中断判断周期数*/
 	UINT32 dwAppCycleTime = 0U;  /*CI应用周期*/
 
@@ -9577,7 +9584,6 @@ UINT8 ParseCiToCiDataCheck(UINT8* dataBuf, UINT16 dataLength,UINT8 *errNo)
 {
 	UINT8 reVal = CI_ERROR;
 	UINT8 errorNo_length = 0U;
-	UINT8 errorNO_Type = 0U;
 	UINT16 ii = 0U;			/*数据索引*/
 
 	/*入参防护*/
@@ -10920,7 +10926,6 @@ UINT8 CheckCiToCiSignalData(const UINT8* dataBuf, UINT16* index)
 	UINT8 chSignalMaintainState = 0U;/*信号机维修点灯状态*/
 	UINT8 chSignalDsState = 0U;/*信号机断丝状态*/
 	UINT8 chDsState = 0U; /*信号机断丝按位校验*/
-	UINT8 chSignalVBLNearFlag = 0U;	/*信号机VBL列车接近标志*/
 	UINT8 chCheckSigCurColorResult = CI_ERROR;/*信号机当前显示颜色合法性检查结果*/
 	UINT8 cCutBtnState = 0U;  /*旁路按钮状态*/
 
@@ -14571,7 +14576,7 @@ UINT8 CiToCiEnvelopeCheck(const UINT8* dataBuf, UINT16* index)
 			chEnvelopeNum = dataBuf[ii];
 			ii++;
 
-			if (SECTION_REL_ENVELOPE_SUM_MAX >= chEnvelopeNum)
+			if (OTHER_RC_SEND_ENVELOPE_SUM_MAX >= chEnvelopeNum)
 			{
 				for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
 				{

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

@@ -1563,6 +1563,8 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 	UINT8 CiTypeOfRoute = 0u;		/*当前进路所属联锁类型*/
 	UINT8 ciTrainTestState = 0u;	/*试车线联锁状态*/
 	UINT8 routeAutoTriggerFlag = GetRouteAutoTriggerFlag(DeviceId);     /*获取进路自动触发标志*/
+
+	UINT32 xuanpaiStartCycNum = GetRouteXuanPaiStartCycNum(DeviceId);/*进路选排开始周期数*/
 	switch (MaskType)
 	{
 	case MASK_TYPE_ROUTE_IDLE:/*进路空闲码位*/
@@ -1576,7 +1578,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/ParsePackVobcData.c

@@ -5131,9 +5131,10 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocPosMonitorInfo Error \n", pstVobcToCiDataStru->VobcId);
 			}
 
+			/*给IVOC组未接近开放进路信息（预先开放）*/
 			if (CI_SUCCESS == chRetVal)
 			{
-				/*组包成功*/
+				chRetVal = PackCiToIvocOpenRouteNotNearInfo(cszCiToIvocDataBuf, &ii, pstVobcToCiDataStru->VobcId);
 			}
 			else
 			{
@@ -5141,8 +5142,18 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocJumpBackReply Error \n", pstVobcToCiDataStru->VobcId);
 			}
 
-			/*预留10字节*/
+			if (CI_SUCCESS == chRetVal)
-			ii += 5U;
+			{
+				/*组包成功*/
+			}
+			else
+			{
+				/*发生组包错误*/
+				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocOpenRouteNotNearInfo Error \n", pstVobcToCiDataStru->VobcId);
+			}
+
+			/*预留4字节*/
+			ii += 4U;
 		}
 		else if ((IVOC_CI_INFO_TYPE_LOGOUT_ASK == pstVobcToCiDataStru->appInfoType) && (curCycleNum == pstVobcToCiDataStru->ComStartCycle))
 		{/*组注销请求回复帧*/
@@ -7043,6 +7054,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))
@@ -7131,8 +7144,15 @@ 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)
 					{
 						pDataBuf[ii] |= BIT_VAL_00000001B << 2; /*前端筛选通过 01B*/
@@ -7147,7 +7167,15 @@ static UINT8 PackCiToIvocSleepTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 						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*/
@@ -9391,7 +9419,9 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 				chTempBreakFlag = 0U;
 				chTempRemoveFlag = 0U;
 				chTempAddFlag = 0U;
+				pRouteLogSecId = NULL;
 				wLogicSecId = GetLogicSecId(wLogicSecIndex);
+
 				if ((0U < wLogicSecId) && (UINT16_MAX > wLogicSecId))
 				{
 					chLogSecHaveResOpp = GetLogSecHaveResOpp(wLogicSecId);
@@ -9401,6 +9431,8 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 						wRLockRouteId = GetLogSecLockBelongRoute(wLogicSecId);
 						wPLockRouteId = GetLogSecPLockRouteId(wLogicSecId);
 						chLogLockDir = GetLogSecLockDir(wLogicSecId);
+						pAPoint.Lnk = 0U;
+						pAPoint.Off = 0U;
 						
 						if (0U < wRLockRouteId)
 						{
@@ -9418,8 +9450,15 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 							; /*继续下一个*/
 						}
 
-						pAPoint.Lnk = GetLgcSecOrgnLink(pRouteLogSecId[0]);
+						if (NULL != pRouteLogSecId)
-						pAPoint.Off = 0U;
+						{
+							pAPoint.Lnk = GetLgcSecOrgnLink(pRouteLogSecId[0]);
+							pAPoint.Off = 0U;
+						}
+						else
+						{
+							;
+						}
 						
 						if ((CI_SYSTEM_DIRECTION_UP == chLogLockDir) || (CI_SYSTEM_DIRECTION_DOWN == chLogLockDir))
 						{
@@ -9482,6 +9521,9 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 								chLogRelateLogLockDir = GetLogSecLockDir(wRelateLogSecId[jj]);
 								wRLockRouteId = GetLogSecLockBelongRoute(wRelateLogSecId[jj]);
 								wPLockRouteId = GetLogSecPLockRouteId(wRelateLogSecId[jj]);
+								pBPoint.Lnk = 0U;
+								pBPoint.Off = 0U;
+
 								if (0U < wRLockRouteId)
 								{
 									wRouteLogSecSum = GetRouteLogSectionSum(wRLockRouteId);
@@ -9503,13 +9545,17 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 								{
 									; /*继续查找*/
 								}
-								if (NULL != pRouteLogSecId)
+
+								if ((NULL != pRouteLogSecId) && (0U < pAPoint.Lnk) && (0U < pBPoint.Lnk))
 								{
 									/*可能涉及到相邻联锁，如果数据没做，指针可能为空，此时需要防一下*/
-									chDirChangedNum = GetDirChangeNumBtwPoints(&pAPoint, &pBPoint);
+									/*两个比较的区段均有锁闭才去检查方向变化点数目和锁闭方向*/
+
 									if ((CI_SYSTEM_DIRECTION_UP == chLogRelateLogLockDir) || (CI_SYSTEM_DIRECTION_DOWN == chLogRelateLogLockDir))
 									{
 										/*当前逻辑区段锁闭方向和关联逻辑区段锁闭方向必须有效*/
+										chDirChangedNum = GetDirChangeNumBtwPoints(&pAPoint, &pBPoint);
+										
 										if (0U == (chDirChangedNum % 2U))
 										{
 											/*2条进路之间方向变化点数目为偶数，则锁闭方向不一致则资源对顶*/
@@ -11938,29 +11984,48 @@ static UINT8 PackCiToVobcSigInfo(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wT
 								{
 									chSigState = CI_VOBC_SIGNAL_YES;
 								}
+
+								/*完整锁闭就不继续找了*/
 								chKeepFlag = CI_SUCCESS;
 							}
-							else if ((ROUTE_STATE_AUTO_UNLOCK == chRouteState) || (ROUTE_STATE_NEAR_LOCK == chRouteState))
+							else if (ROUTE_STATE_NEAR_LOCK == chRouteState)
 							{
 								chSigState = CI_VOBC_SIGNAL_NO;
-								/*禁止信号（正常关闭）0XAA：接近锁闭正常、自动解锁正常*/
+								/*禁止信号（正常关闭）0XAA：接近锁闭正常*/
 								chKeepFlag = CI_SUCCESS;
 							}
+							else if (ROUTE_STATE_AUTO_UNLOCK == chRouteState)
+							{
+								chSigState = CI_VOBC_SIGNAL_NO;
+								/*禁止信号（正常关闭）0XAA：自动解锁正常*/
+							}
 							else if ((ROUTE_STATE_FIRST_LOCKERR == chRouteState) || (ROUTE_STATE_YUXIAN_LOCK == chRouteState)
-								|| (ROUTE_STATE_NEAR_LOCKERR == chRouteState) || (ROUTE_STATE_DELAY_UNLOCK == chRouteState)
+								|| (ROUTE_STATE_NEAR_LOCKERR == chRouteState) || (ROUTE_STATE_DELAY_UNLOCK == chRouteState))
-								|| (ROUTE_STATE_AUTO_UNLOCKERR == chRouteState))
 							{
 								chSigState = CI_VOBC_SIGNAL_ERR;
-								/*禁止信号（异常关闭）0XCC：进路状态为初锁异常、预先锁闭、接近锁闭异常、延时解锁、自动解锁异常、*/
+								/*禁止信号（异常关闭）0XCC：进路状态为初锁异常、预先锁闭、接近锁闭异常、延时解锁*/
+								/*完整锁闭就不继续找了*/
 								chKeepFlag = CI_SUCCESS;
 							}
+							else if (ROUTE_STATE_AUTO_UNLOCKERR == chRouteState)
+							{
+								chSigState = CI_VOBC_SIGNAL_ERR;
+								/*禁止信号（异常关闭）0XCC：进路状态为自动解锁异常、*/
+							}
 							else if (ROUTE_STATE_IDLE == chRouteState)
 							{
 								; /*空闲继续查找下一条*/
 							}
+							else if ((ROUTE_STATE_HALF_FIRST_XUAN == chRouteState) || (ROUTE_STATE_HALF_XUANPAI == chRouteState)
+								|| (ROUTE_STATE_HALF_LOCK == chRouteState) || (ROUTE_STATE_HALF_UNLOCKDELAY == chRouteState)
+								|| (ROUTE_STATE_HALF_UNLOCK == chRouteState))
+							{
+								/*默认值0XFF:部分锁闭初选、部分锁闭选排、部分锁闭、部分进路等待解锁、部分进路延时解锁*/
+								chSigState = CI_VOBC_SIGNAL_DEFAULT;
+							}
 							else
 							{
-								/*默认值0XFF:初选、选排、初锁、引导选排、引导锁闭、引导锁闭异常、引导开放、部分锁闭初选、部分锁闭选排、部分锁闭、部分进路等待解锁、部分进路延时解锁*/
+								/*默认值0XFF:初选、选排、初锁、引导选排、引导锁闭、引导锁闭异常、引导开放*/
 								chSigState = CI_VOBC_SIGNAL_DEFAULT;
 								chKeepFlag = CI_SUCCESS;
 							}
@@ -12677,4 +12742,104 @@ UINT8 PackCiToIvocJumpBackReply(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTr
 
 	return chRetVal;
 
+}
+
+/*
+* 功能描述：组包Ci到Ivoc未接近开放进路信息(预先开放)
+* 参数说明： UINT8* dataBuf, 数据缓冲区
+*            UINT16 *dataLength, 数据长度 输出参数
+*			 UINT16 wTrainId 列车ID
+* 返 回 值：CI_ERROR 0 失败
+*			CI_SUCCESS 1 成功
+* Create： fan 20251202
+*/
+UINT8 PackCiToIvocOpenRouteNotNearInfo(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId)
+{
+	UINT8 chRetVal = CI_ERROR;
+	UINT16 ii = 0U;/*存储下标*/
+	UINT16 jj = 0U;/*循环下标*/
+	UINT8 chYuXianRouteSum = 0U; /*预先开放进路总数*/
+	UINT8 chLocalCI= 0U;/*联锁ID*/
+	UINT8 chLocalCIType = 0U;/*本联锁类型*/
+	UINT16 routeCurSum = 0U; 	/*获取进路总数*/
+	UINT16 wRouteNumIndex = 0U;/*进路数量下标*/
+	UINT16 routeId = 0U;
+	UINT8 routeBelongCiId = 0u;/*进路所属联锁*/
+	UINT8 routeState = 0U; /*进路状态*/
+	UINT16 wFirstLogSecId = 0U; /*第一逻辑区段*/
+	LogicTrainResStruct * pLogicSecTrainResInfo = NULL;/*逻辑区段对应列车资源信息*/
+	UINT16 wTrnID = 0U;
+	chLocalCI = GetSystemParaLocalCiId();
+	chLocalCIType = GetLocalCiType();
+	routeCurSum = GetRouteCurSum();
+	if ((NULL == pDataBuf) || (NULL == wDataLength))
+	{
+		chRetVal = CI_ERROR;
+	}
+	else
+	{
+
+		ii = *wDataLength;
+		wRouteNumIndex = ii;  /*跳过进路数量*/
+		ii++;
+		chRetVal = CI_SUCCESS;
+
+		if ((CI_TYPE_ZX == chLocalCIType) || (CI_TYPE_SCX == chLocalCIType))
+		{
+			for (jj = 0u; jj < routeCurSum; jj++)
+			{
+				routeId = GetRouteId(jj);                           /*获取进路ID*/
+				routeBelongCiId = GetRouteBelongCiId(routeId);           /*获取进路所属联锁ID*/
+				routeState = GetRouteState(routeId);
+				if ((ROUTE_STATE_YUXIAN_OPEN == routeState) && (routeBelongCiId == chLocalCI))
+				{
+					/*仅处理本联锁预先开放进路*/
+					wFirstLogSecId = GetRouteInFirstLogSecId(routeId);
+					wTrnID = ((UINT16)(CI_SYSTEM_TYPE_VOBC * 256U)) + wTrainId;
+					pLogicSecTrainResInfo = GetLogSecTrainInfoById(wFirstLogSecId, wTrnID);
+					if (NULL != pLogicSecTrainResInfo)
+					{
+						/*存在列车资源*/
+						ShortToChar(routeId, &pDataBuf[ii]);  /*组进路ID*/
+						ii += 2U;
+						chYuXianRouteSum++;
+						if (CI_IVOC_YUXIANOPEN_ROUTE_MAX < chYuXianRouteSum)
+						{
+							chRetVal = CI_ERROR;
+							break;
+						}
+						else
+						{
+							; /*继续*/
+						}
+					}
+					else
+					{
+						;/*不处理*/
+					}
+				}
+				else
+				{
+					;/*不处理*/
+				}
+			}
+		}
+		else
+		{
+			chYuXianRouteSum = 0U;/*车辆段发送数量为0*/
+		}
+	}
+
+	if (CI_SUCCESS == chRetVal)
+	{
+		pDataBuf[wRouteNumIndex] = chYuXianRouteSum;  /*组预先开放进路数量*/
+		*wDataLength = ii;  /*传出数据长度*/
+	}
+	else
+	{
+		chRetVal = CI_ERROR;
+	}
+
+	return chRetVal;
+
 }

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

@@ -222,8 +222,8 @@
 #define CI_IVOC_URGENT_NO		        ((UINT8)0xaaU)		  /*CI到IVOC 紧急制动状态无效*/
 
 #define CI_VOBC_BACKUP_SEND_ROUTE_SUM		((UINT8)5U)	/*CI到车载后备通道进路数量最大值*/
-
 #define CI_IVOC_LOST_POSITION	((UINT8)0x55U)		  /*CI到车载特控报文 丢位置*/
+#define CI_IVOC_YUXIANOPEN_ROUTE_MAX		((UINT8)200U)		  /*列车到站台的逻辑区段最大数量 合法[0,200]*/
 
 #ifdef __cplusplus
 extern "C" {
@@ -714,6 +714,17 @@ void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId);
 * Create： fan 20250725
 */
 UINT8 PackCiToIvocJumpBackReply(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
+
+/*
+* 功能描述：组包Ci到Ivoc未接近开放进路信息(预先开放)
+* 参数说明： UINT8* dataBuf, 数据缓冲区
+*            UINT16 *dataLength, 数据长度 输出参数
+*			 UINT16 wTrainId 列车ID
+* 返 回 值：CI_ERROR 0 失败
+*			CI_SUCCESS 1 成功
+* Create： fan 20250725
+*/
+UINT8 PackCiToIvocOpenRouteNotNearInfo(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
 #ifdef __cplusplus
 }
 #endif

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

@@ -495,6 +495,14 @@ UINT8 RelayInit(CHAR* FSName)
 		debug_infor_printf((const)"LinkSpecialEaDataInit fail.\r\n");
 	}
 
+
+	/*计轴区段防护道岔初始化*/
+	funcRtn *= AxisSecProtectSwitchInit();
+	if (0u == funcRtn)
+	{
+		debug_infor_printf((const)"AxisSecProtectSwitchInit fail.\r\n");
+	}
+
 	return funcRtn;
 }
 
@@ -722,9 +730,6 @@ UINT8 SystemParameterStructInit(CHAR* FSName)
 					/*对向行驶双车间隔最小安全距离(cm)*/
 					dquCICfgDtStr.SystemParaStrNew.OppositeTrackDistance = pCbtcConfigDataStru.OppositeTrackDistance;
 
-					/*站台追踪时，列车间隔距离（cm）*/
-					dquCICfgDtStr.SystemParaStrNew.StationTrackDistance = pCbtcConfigDataStru.StationTrackDistance;
-
 					/*线路最差情况下紧急制动距离（单位m）*/
 					dquCICfgDtStr.SystemParaStrNew.MaxMALength = pCbtcConfigDataStru.MaxMALength;
 
@@ -1999,6 +2004,7 @@ UINT8 PhySgmtCfgDtStruFromDquSgmtStr(DSU_PHYSICAL_SGMT_STRU* pPhysicalSgmt, Phys
 		}
 		pPsclSgmtCfgDtStr->PhySecType = pPhysicalSgmt->Type;
 		pPsclSgmtCfgDtStr->LjkSecFlag = pPhysicalSgmt->LjkFlag;
+		pPsclSgmtCfgDtStr->QcxSecFlag = pPhysicalSgmt->QcxFlag;
 		pPsclSgmtCfgDtStr->BelongAxleSysID = pPhysicalSgmt->BelongAxleSysID;
 		pPsclSgmtCfgDtStr->AxisSectionSum = 0u;
 		pPsclSgmtCfgDtStr->LocatedFloodGateSum = 0U;		/*所在防淹门数量初始化为0*/
@@ -4861,17 +4867,6 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
 		else
 		{
 		}
-		
-		/*设置进路入库属性*/
-		pRouteCfgDtStr->cRouteRukuProperty = ROUTE_RUKU_PROPERTY_NO;
-		if (0x0010U == (pDsuRouteStr->wRouteType & 0x0010U))
-		{
-			pRouteCfgDtStr->cRouteRukuProperty = ROUTE_RUKU_PROPERTY_YES;
-		}
-		else
-		{
-			/*非入库进路，不处理*/
-		}
 
 		/*自动信号属性*/
 		pRouteCfgDtStr->AutoSigProperty = ROUTE_AUTOSIG_PROPERTY_NO;
@@ -6965,6 +6960,7 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
 	callFun *= InitRelay_DCAgreeStru(FSName);/*初始化调车同意继电器表*/
 	callFun *= InitLS_SGBJStru(FSName);  /*初始化声光报警表*/
 	callFun *= InitLS_TransRouteRtnDataStruct(FSName);  /*初始化转换轨折返信号机表*/
+	callFun *= InitLS_AirShaftRouteStru(FSName);	/*初始化风井进路检查表*/
 
 	/*电子地图初始化失败，函数失败退出*/
 	if(0u == callFun)
@@ -7125,7 +7121,9 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
 			for (i = 0u; i < dquCICfgDtStr.lgcSctCfgDtStrLen; i++)
 			{
 				execRet = LogRelateRouteDataInit(dquCICfgDtStr.RouteCfgDtStr, &(dquCICfgDtStr.lgcSctCfgDtStr[i]));/*逻辑区段关联进路计算*/
+				execRet *= LogRelateOverlapDataInit(dquCICfgDtStr.OvlapCfgDtStr, &(dquCICfgDtStr.lgcSctCfgDtStr[i]));/*逻辑区段关联保护区段计算*/
 				execRet *= LogRelateProSwDataInit(dquCICfgDtStr.RouteCfgDtStr, &(dquCICfgDtStr.lgcSctCfgDtStr[i]));/*逻辑区段关联防护道岔计算*/
+
 				if (execRet > 0u)
 				{
 
@@ -7210,6 +7208,31 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
 			}
 		}
 	}
+	if (1U == rtnvalue)
+	{
+		for (i = 0U; i < LSDataLen.LSRouteStrLen; i++)
+		{
+			if (i >= ROUTE_SUM_MAX)
+			{
+				rtnvalue = 0U;
+			}
+			else
+			{
+			}
+			execRet = AirShaftSectionDataInit(&(dquCICfgDtStr.RouteCfgDtStr[i]), LSData.pLSAirShaftRouteStru);  /*进路风井进路物理区段计算*/
+			if (execRet > 0U)
+			{
+			}
+			else
+			{
+				rtnvalue = 0U;  /*计算失败，返回0*/
+			}
+			if (1U != rtnvalue)
+			{
+				break;
+			}
+		}
+	}
 	return rtnvalue;
 }
 
@@ -11689,7 +11712,7 @@ UINT8 LogRelateProSwDataInit(RouteConfigDataStruct* RouteCfgDtStr, LogicSectionC
 						for (mm = 0U; mm < pLgScCfgDtStr->chRelateProSwSum; mm++)
 						{/*关联防护道岔ID去重*/
 							if ((pLgScCfgDtStr->wRelateProSwId[mm].SwitchId == dquCICfgDtStr.RouteCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuRouteIndex[pLgScCfgDtStr->wRelateRouteId[kk]]].RouteProtectSwitchStru[hh].ProtectSwitchId)
-								&&(pLgScCfgDtStr->wRelateProSwId[mm].SwitchPosition == dquCICfgDtStr.RouteCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuRouteIndex[pLgScCfgDtStr->wRelateRouteId[kk]]].RouteProtectSwitchStru[hh].ProtectPosition))
+								&& (pLgScCfgDtStr->wRelateProSwId[mm].SwitchPosition == dquCICfgDtStr.RouteCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuRouteIndex[pLgScCfgDtStr->wRelateRouteId[kk]]].RouteProtectSwitchStru[hh].ProtectPosition))
 							{
 								chProtectSwFlag = 1U;
 								break;
@@ -11734,6 +11757,11 @@ UINT8 LogRelateProSwDataInit(RouteConfigDataStruct* RouteCfgDtStr, LogicSectionC
 	{
 		rtnvalue = 1U;
 	}
+
+	if (1U == rtnvalue)
+	{/*将逻辑区段所属保护区段的防护道岔存储入逻辑区段结构体*/
+		rtnvalue = LogRelateProSwDataByOverlapInit(pLgScCfgDtStr);
+	}
 	return rtnvalue;
 }
 
@@ -12753,3 +12781,332 @@ static UINT8 LinkSpecialEaDataInit(CHAR* FSName)
 	return retVal;
 }
 
+/*********************************************
+*函数功能：进路配置风井区段数据初始化
+*参数说明：RouteConfigDataStruct* pRouteCfgDtStr 进路配置数据结构体指针
+*           LS_AirShaftStruct* pAirShaftSecStruct 风井进路结构体指针
+*返回值：0，失败；1，成功
+*Create： yx 2026.03.04
+*********************************************/
+UINT8 AirShaftSectionDataInit(RouteConfigDataStruct* pRouteCfgDtStr, LS_AirShaftStruct* pAirShaftSecStruct)
+{
+	UINT8 rtnvalue = CI_ERROR;
+	UINT16 i = 0U;
+	UINT8 j = 0U;
+	if ((NULL != pRouteCfgDtStr) && (NULL != pAirShaftSecStruct))
+	{
+		rtnvalue = CI_SUCCESS;
+		/*先初始化为默认值*/
+		pRouteCfgDtStr->airShaftRouteSecSum = 0U;
+		(void)CommonMemSet((void*)pRouteCfgDtStr->wAirShaftRouteSecIdBuf, (UINT32)sizeof(pRouteCfgDtStr->wAirShaftRouteSecIdBuf), 0U, (UINT32)sizeof(pRouteCfgDtStr->wAirShaftRouteSecIdBuf));
+		/*遍历风井区段表，初始化进路配置数据*/
+
+		for (i = 0U; i < LSDataLen.LSAirShaftRouteStruLen; i++)
+		{
+			/*查找对应进路*/
+			if (pRouteCfgDtStr->RouteId == pAirShaftSecStruct[i].wRouteId)
+			{
+				pRouteCfgDtStr->airShaftRouteSecSum = pAirShaftSecStruct[i].airShaftSecSum;
+				/*初始化数据*/
+				for (j = 0U; j < AIR_SHAFT_ROUTE_SECTION_NUM_MAX; j++)
+				{
+					pRouteCfgDtStr->wAirShaftRouteSecIdBuf[j] = pAirShaftSecStruct[i].wAirShaftSecId[j];
+				}
+				break;
+			}
+			else
+			{
+
+			}
+		}
+	}
+	else if ((NULL != pRouteCfgDtStr) && (NULL == pAirShaftSecStruct))
+	{/*风井进路检查表未配置数据*/
+		pRouteCfgDtStr->airShaftRouteSecSum = 0U;
+		(void)CommonMemSet((void*)pRouteCfgDtStr->wAirShaftRouteSecIdBuf, (UINT32)sizeof(pRouteCfgDtStr->wAirShaftRouteSecIdBuf), 0U, (UINT32)sizeof(pRouteCfgDtStr->wAirShaftRouteSecIdBuf));
+		rtnvalue = CI_SUCCESS;
+	}
+	else
+	{
+		/*入参非法，返回0*/
+	}
+
+	return rtnvalue;
+}
+
+/*********************************************
+*函数功能：逻辑区段关联防护道岔（遍历保护区段）
+*参数说明：pLogCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+* add mpt 20260331
+*********************************************/
+UINT8 LogRelateProSwDataByOverlapInit(LogicSectionConfigDataStruct* pLgScCfgDtStr)
+{
+	UINT8 rtnvalue = 0U;
+	UINT8 ii = 0U;
+	UINT16 jj = 0U;
+	UINT8 kk = 0U;
+	UINT8 hh = 0U;
+	UINT8 mm = 0U;
+	UINT16 wProtectSwSum = 0U;/*逻辑区段关联防护道岔数量计数*/
+	UINT16 wProtectSwId = 0U;/*逻辑区段关联防护道岔ID过渡变量*/
+	UINT8 chProtectSwFlag = 0U;/*逻辑区段关联防护道岔去重标志*/
+	UINT8 chMaxCheck = CI_SUCCESS;
+
+	if (NULL != pLgScCfgDtStr)
+	{
+		if (0u == pLgScCfgDtStr->chRelateRouteSum)
+		{
+			/*逻辑区段关联防护道岔计算*/
+			for (ii = 0; ii < pLgScCfgDtStr->chLogsecSwitchSum; ii++)
+			{/*遍历逻辑区段包含的所有道岔*/
+				wProtectSwSum = dquCICfgDtStr.SwchCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuPointIndex[pLgScCfgDtStr->LogsecSwitchIdStru[ii].SwitchId]].wProtectSwitchNum;
+				for (jj = 0; jj < wProtectSwSum; jj++)
+				{/*遍历道岔对应的防护道岔*/
+					wProtectSwId = dquCICfgDtStr.SwchCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuPointIndex[pLgScCfgDtStr->LogsecSwitchIdStru[ii].SwitchId]].wszProtectSwitchIdBuf[jj];
+					chProtectSwFlag = 0U;
+					for (kk = 0U; kk < pLgScCfgDtStr->chRelateOverLapSum; kk++)
+					{/*遍历逻辑区段关联的保护区段*/
+						for (hh = 0U; hh < dquCICfgDtStr.OvlapCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuProtectLinkIndex[pLgScCfgDtStr->wRelateOverLapIdBuf[kk]]].ProtectSwitchSum; hh++)
+						{/*查询逻辑区段关联保护区段，若保护区段包含该防护道岔，则逻辑区段关联防护道岔的位置与保护区段一致*/
+							if (dquCICfgDtStr.OvlapCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuProtectLinkIndex[pLgScCfgDtStr->wRelateOverLapIdBuf[kk]]].ProtectSwitchStru[hh].ProtectSwitchId == wProtectSwId)
+							{
+								for (mm = 0U; mm < pLgScCfgDtStr->chRelateProSwSum; mm++)
+								{/*关联防护道岔ID去重*/
+									if ((pLgScCfgDtStr->wRelateProSwId[mm].SwitchId == dquCICfgDtStr.OvlapCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuProtectLinkIndex[pLgScCfgDtStr->wRelateOverLapIdBuf[kk]]].ProtectSwitchStru[hh].ProtectSwitchId)
+										&& (pLgScCfgDtStr->wRelateProSwId[mm].SwitchPosition == dquCICfgDtStr.OvlapCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuProtectLinkIndex[pLgScCfgDtStr->wRelateOverLapIdBuf[kk]]].ProtectSwitchStru[hh].ProtectPosition))
+									{
+										chProtectSwFlag = 1U;
+										break;
+									}
+								}
+								if (1U != chProtectSwFlag)
+								{/*当前防护道岔数组中不包含此ID才进行添加*/
+									if (LOGSEC_RELATE_PRO_SW_SUM_MAX > pLgScCfgDtStr->chRelateProSwSum)
+									{
+										pLgScCfgDtStr->wRelateProSwId[pLgScCfgDtStr->chRelateProSwSum].SwitchId = dquCICfgDtStr.OvlapCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuProtectLinkIndex[pLgScCfgDtStr->wRelateOverLapIdBuf[kk]]].ProtectSwitchStru[hh].ProtectSwitchId;
+										pLgScCfgDtStr->wRelateProSwId[pLgScCfgDtStr->chRelateProSwSum].SwitchPosition = dquCICfgDtStr.OvlapCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuProtectLinkIndex[pLgScCfgDtStr->wRelateOverLapIdBuf[kk]]].ProtectSwitchStru[hh].ProtectPosition;
+										(pLgScCfgDtStr->chRelateProSwSum)++;
+									}
+									else
+									{
+										chMaxCheck = CI_ERROR;
+									}
+									break;
+								}
+							}
+						}
+						if (CI_ERROR == chMaxCheck)
+						{
+							break;
+						}
+					}
+					if (CI_ERROR == chMaxCheck)
+					{
+						break;
+					}
+				}
+				if (CI_ERROR == chMaxCheck)
+				{
+					break;
+				}
+			}
+			if (CI_ERROR == chMaxCheck)
+			{
+				rtnvalue = 0U;
+			}
+			else
+			{
+				rtnvalue = 1U;
+			}
+		}
+		else
+		{
+			rtnvalue = 1U;
+		}
+		
+	}
+
+	return rtnvalue;
+}
+
+/*********************************************
+*函数功能：逻辑区段关联保护区段相关数据初始化
+*参数说明：pOverlapCfgDtStr保护区段配置数据结构体指针   pLogCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+* add by mpt 20260331
+*********************************************/
+UINT8 LogRelateOverlapDataInit(OverlapConfigDataStruct* pOverlapCfgDtStr, LogicSectionConfigDataStruct* pLogCfgDtStr)
+{
+	UINT16 i = 0U;
+	UINT16 j = 0U;
+	UINT8 rtnvalue = 0U;
+	UINT8 chMaxCheck = CI_SUCCESS;
+
+	if ((NULL != pOverlapCfgDtStr) && (NULL != pLogCfgDtStr))
+	{
+		/*逻辑区段包含保护区段数目初始化为0*/
+		pLogCfgDtStr->chRelateOverLapSum = 0U;
+		for (i = 0U; i < dquCICfgDtStr.OvlapCfgDtStrLen; i++)
+		{/*遍历所有保护区段,若包含此逻辑区段，即此保护区段为本逻辑区段关联保护区段*/
+			for (j = 0; j < pOverlapCfgDtStr[i].cLogicSectionSum; j++)
+			{
+				if (pOverlapCfgDtStr[i].szLogicSectionIdBuf[j] == pLogCfgDtStr->LogicSectionId)
+				{
+					if (LOGSEC_RELATE_OVERLAP_SUM_MAX > pLogCfgDtStr->chRelateOverLapSum)
+					{
+						pLogCfgDtStr->wRelateOverLapIdBuf[pLogCfgDtStr->chRelateOverLapSum] = pOverlapCfgDtStr[i].OverlapId;
+						pLogCfgDtStr->chRelateOverLapSum++;
+					}
+					else
+					{
+						chMaxCheck = CI_ERROR;
+					}
+					break;
+				}
+			}
+			if (CI_ERROR == chMaxCheck)
+			{
+				break;
+			}
+		}
+		if (CI_ERROR == chMaxCheck)
+		{
+			rtnvalue = 0U;
+		}
+		else
+		{
+			rtnvalue = 1U;
+		}
+	}
+
+	return rtnvalue;
+}
+
+/*********************************************
+*函数功能：逻辑区段配置数据结构体计算
+*参数说明：LogsecSwitchStruct* pSrcSwitchStructBuf 源数据
+		   UINT8 chSrclen 源数据长度
+		   AxisSwitchStruct* pDstSwitchStructBuf 目标数据
+		   UINT8 dstLen 目标数据长度
+*返回值：-1，失败；其他为长度
+*add by  mpt 20260331
+*********************************************/
+INT16 AxisSecCfgDtStruFromLogicSecStr(LogsecSwitchStruct* pSrcSwitchStructBuf, UINT8 chSrclen, AxisSwitchStruct* pDstSwitchStructBuf, UINT8 dstLen)
+{
+	UINT8 i = 0u;
+	UINT8 j = 0u;
+	INT16 rtnvalue = -1;
+	UINT8 tempLen = 0u;
+
+	if ((NULL != pSrcSwitchStructBuf) && (NULL != pDstSwitchStructBuf))
+	{
+		rtnvalue = 0;
+		tempLen = dstLen;
+		for (i = 0u; i < chSrclen; i++)
+		{
+			for (j = 0u; j < dstLen; j++)
+			{
+				if ((pSrcSwitchStructBuf[i].SwitchId == pDstSwitchStructBuf[j].SwitchId) && (pSrcSwitchStructBuf[i].SwitchPosition == pDstSwitchStructBuf[j].SwitchPosition))
+				{/*输入的源数据在目标数据中已经找到了，则跳出*/
+					break;
+				}
+				else
+				{
+					/*继续*/
+				}
+			}
+			if (j == dstLen)
+			{/*在目标数据中未找到本条防护道岔配置*/
+				if (AXIS_RELATE_PRO_SW_SUM_MAX > tempLen)
+				{
+					pDstSwitchStructBuf[tempLen].SwitchId = pSrcSwitchStructBuf[i].SwitchId;
+					pDstSwitchStructBuf[tempLen].SwitchPosition = pSrcSwitchStructBuf[i].SwitchPosition;
+					tempLen++;
+				}
+				else
+				{
+					rtnvalue = -1;
+					break;
+				}
+			}
+			else
+			{
+				/*充分数据无需添加*/
+			}
+		}
+	}
+	else
+	{
+		/*返回失败*/
+		rtnvalue = -1;
+	}
+
+	if (0 == rtnvalue)
+	{
+		rtnvalue = (INT16)tempLen;
+	}
+
+	return rtnvalue;
+}
+
+/*********************************************
+*函数功能：计轴区段防护道岔初始化
+*参数说明：void
+*返回值：0，失败；1，成功
+* add mpt 20260331
+*********************************************/
+UINT8 AxisSecProtectSwitchInit(void)
+{
+	UINT16 j = 0u;
+	UINT16 i = 0u;
+	INT16 ret = 0;
+	UINT16 k = 0u;
+	UINT8 rtnvalue = 0u;
+	AxisSectionConfigDataStruct* pAxScCfgDtStr = NULL;
+
+	for (k = 0u; k < dquCICfgDtStr.AxisCfgDtStrLen; k++)
+	{
+		pAxScCfgDtStr = &dquCICfgDtStr.AxisSctCfgDtStr[k];
+
+
+		for (i = 0u; i < pAxScCfgDtStr->LogSectionSum; i++)
+		{
+			for (j = 0u; j < dquCICfgDtStr.lgcSctCfgDtStrLen; j++)
+			{
+				if (dquCICfgDtStr.lgcSctCfgDtStr[j].LogicSectionId == pAxScCfgDtStr->LogSectionIdBuf[i])
+				{
+					/*拷贝拷贝*/
+					ret = AxisSecCfgDtStruFromLogicSecStr(dquCICfgDtStr.lgcSctCfgDtStr[j].wRelateProSwId, dquCICfgDtStr.lgcSctCfgDtStr[j].chRelateProSwSum, pAxScCfgDtStr->wRelateProSwId, pAxScCfgDtStr->chRelateProSwSum);
+					if (-1 != ret)
+					{
+						pAxScCfgDtStr->chRelateProSwSum = (UINT8)ret;/*更新数量*/
+					}
+					break;
+				}
+			}
+			if (-1 == ret)
+			{
+				break;
+			}
+		}
+
+
+		if (-1 == ret)
+		{
+			break;
+		}
+	}
+
+	if (-1 == ret)
+	{
+		rtnvalue = 0u;
+	}
+	else
+	{
+		rtnvalue = 1u;
+	}
+
+	return rtnvalue;
+}
+

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

@@ -937,5 +937,51 @@ UINT8 AgLinkExistRelCGFlagCalc(LinkDataConfigStru* pLinkScCfgDtStr);
 *********************************************/
 UINT8 BGLinkRelAGLinkCal(LinkDataConfigStru* pLinkScCfgDtStr);
 
+/*********************************************
+*函数功能：风井区段数据初始化
+*参数说明：RouteConfigDataStruct* pRouteCfgDtStr 进路配置数据结构体指针
+*           LS_AirShaftStruct* pAirShaftSecStruct 风井进路结构体指针
+*返回值：0，失败；1，成功
+*Create： yx 2026.03.04
+*********************************************/
+UINT8 AirShaftSectionDataInit(RouteConfigDataStruct* pRouteCfgDtStr, LS_AirShaftStruct* pAirShaftSecStruct);
+/*********************************************
+*函数功能：逻辑区段关联防护道岔（遍历保护区段）
+*参数说明：pLogCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+* add mpt 20260331
+*********************************************/
+UINT8 LogRelateProSwDataByOverlapInit(LogicSectionConfigDataStruct* pLgScCfgDtStr);
+
+/*********************************************
+*函数功能：逻辑区段关联保护区段相关数据初始化
+*参数说明：pOverlapCfgDtStr保护区段配置数据结构体指针   pLogCfgDtStr配置数据结构体指针
+*返回值：0，失败；1，成功
+* add by mpt 20260331
+*********************************************/
+UINT8 LogRelateOverlapDataInit(OverlapConfigDataStruct* pOverlapCfgDtStr, LogicSectionConfigDataStruct* pLogCfgDtStr);
+
+/*********************************************
+*函数功能：逻辑区段配置数据结构体计算
+*参数说明：LogsecSwitchStruct* pSrcSwitchStructBuf 源数据
+           UINT8 chSrclen 源数据长度
+           AxisSwitchStruct* pDstSwitchStructBuf 目标数据
+           UINT8 dstLen 目标数据长度
+*返回值：-1，失败；其他为长度
+*add by  mpt 20260331
+*********************************************/
+INT16 AxisSecCfgDtStruFromLogicSecStr(LogsecSwitchStruct* pSrcSwitchStructBuf, UINT8 chSrclen, AxisSwitchStruct* pDstSwitchStructBuf, UINT8 dstLen);
+
+/*********************************************
+*函数功能：计轴区段防护道岔初始化
+*参数说明：void
+*返回值：0，失败；1，成功
+* add mpt 20260331
+*********************************************/
+UINT8 AxisSecProtectSwitchInit(void);
+
 #endif
 
+
+
+

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

@@ -2421,9 +2421,6 @@ UINT8 ReadSystemParamConfDataNew(const UINT8 ciId,SystemParameterStructNew* Syst
 			/*对向行驶双车间隔最小安全距离(cm)*/
 			SystemParameterStru->OppositeTrackDistance = dquCICfgDtStr.SystemParaStrNew.OppositeTrackDistance;
 
-			/*站台追踪时，列车间隔距离（cm）*/
-			SystemParameterStru->StationTrackDistance = dquCICfgDtStr.SystemParaStrNew.StationTrackDistance;
-
 			/*线路最差情况下紧急制动距离（单位m）*/
 			SystemParameterStru->MaxMALength = dquCICfgDtStr.SystemParaStrNew.MaxMALength;
 

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

@@ -96,6 +96,7 @@
 
 #define TRANSROUTE_ZHEFANSIG_ID ((UINT8)27)	   /*CI联锁表 -- 转换轨进路折返信号机id表*/
 
+#define AIR_SHAFT_DATA_ID ((UINT8)28)	   /*CI联锁表 -- 风井进路检查表*/
 #define CONTACT_DATA_LEN			((UINT8)12U)
 
 /*单轨使用*/
@@ -141,6 +142,7 @@
 #define LOGIC_LTARL_DFNC_SWITCH_NUM	 ((UINT8)8)   /*逻辑区段的侧防道岔数目*/
 
 #define SGBJ_RELATED_PHYSEC_SUM_MAX  ((UINT16)6)  /*声光报警器关联的物理区段数量最大值*/
+#define AIR_SHAFT_SECTION_SUM_MAX  ((UINT8)16)  /*风井区段数量最大值*/
 
 /*长进路表数据结构体*/
 typedef struct S_LongRouteStruct
@@ -413,5 +415,11 @@ typedef struct S_TransRouteZFSigStruct
 	UINT16 wTransRouteZFSigId;  /*转换轨折返信号机ID*/
 } LS_TransRouteZFSigStruct;
 
+typedef struct S_AirShaftStruct
+{
+	UINT16 wRouteId;                /*进路ID */
+	UINT8 airShaftSecSum;  /*风井区段数量*/
+	UINT16 wAirShaftSecId[AIR_SHAFT_SECTION_SUM_MAX];   /*风井区段ID*/
+} LS_AirShaftStruct;
 #endif
 

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

@@ -1065,4 +1065,50 @@ UINT8 LS_TransZFSigFromChar(UINT8* pDataAddr, LS_TransRouteZFSigStruct* pTransRo
 		rtnvalue = 1u;
 	}
 	return rtnvalue;
+}
+/*********************************************
+*函数功能：从数据到风井进路检查表转换
+*参数说明：
+*		pDataAddr数据地址，
+*		pAirShaftRouteStr 风井进路检查表数据结构体
+*返回值：0，失败；1，成功
+*创建  ：2026.03.04 yx 增加读取风井进路检查表
+*********************************************/
+UINT8 LS_AirShaftStruFromChar(UINT8* pDataAddr, LS_AirShaftStruct* pAirShaftRouteStr)
+{
+	UINT8* pData = pDataAddr;
+
+	UINT8 i = 0u;
+
+	UINT8 rtnvalue = 0u;
+
+	if ((NULL != pDataAddr) && (NULL != pAirShaftRouteStr))
+	{
+
+		/*进路ID*/
+		pAirShaftRouteStr->wRouteId = dquCiShortFromChar(pData);
+		pData += 2u;
+		if (AIR_SHAFT_SECTION_SUM_MAX >= *pData)
+		{
+			pAirShaftRouteStr->airShaftSecSum = *pData;
+			/*风井区段数量*/
+			pData += 1u;
+			for (i = 0u; i < AIR_SHAFT_SECTION_SUM_MAX; i++)
+			{
+				/*区段ID*/
+				pAirShaftRouteStr->wAirShaftSecId[i] = dquCiShortFromChar(pData);
+				pData += 2u;
+			}
+			rtnvalue = 1u;
+		}
+		else
+		{
+			rtnvalue = 0u;
+		}		
+	}
+	else
+	{
+		rtnvalue = 0u;
+	}
+	return rtnvalue;
 }

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

@@ -202,4 +202,13 @@ UINT8 LS_LgcSecInvEachStruFromChar(UINT8* pDataAddr, LS_EachLgcIntrudeStruct* pL
 *********************************************/
 UINT8 LS_TransZFSigFromChar(UINT8* pDataAddr, LS_TransRouteZFSigStruct* pTransRouteZFSigStru);
 
+/*********************************************
+*函数功能：从数据到风井进路检查表转换
+*参数说明：
+*		pDataAddr数据地址，
+*		pAirShaftRouteStr 风井进路检查表数据结构体
+*返回值：0，失败；1，成功
+*创建  ：2026.03.04 yx 增加读取风井进路检查表
+*********************************************/
+UINT8 LS_AirShaftStruFromChar(UINT8* pDataAddr, LS_AirShaftStruct* pAirShaftRouteStr);
 #endif

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

@@ -2359,4 +2359,92 @@ UINT8 InitLS_TransRouteRtnDataStruct(CHAR* LSDataName)
 		}
 	}
 	return rtnValue;
+}
+/*********************************************
+*函数功能：填充风井进路进路检查表数据结构体数组
+*参数说明：LSDataName指针
+*返回值：0，失败；1，成功
+* 创建：2026.03.04 by yx
+*********************************************/
+UINT8 InitLS_AirShaftRouteStru(CHAR* LSDataName)
+{
+	UINT8 funcRtn = 0u;
+	LS_AirShaftStruct* pAirShaftRouteStr = NULL;   /*临时风井进路检查表结构体变量*/
+	UINT8* pDataAddr = NULL;         /*数据地址*/
+	UINT32 DataSize = 0u;          /*数据大小（字节数）*/
+	UINT16 i = 0u;
+	UINT16 realRowCount = 0u; /*实际表数据的行数*/
+	UINT16 realRowLen = 0u; /*实际表数据的一行的长度*/
+	UINT8 rtnValue = 0u;
+
+	/*已经初始化了，不用老是调用执行过程*/
+	if (NULL != LSData.pLSAirShaftRouteStru)
+	{
+		rtnValue = 1u;
+	}
+	else
+	{
+		rtnValue = 1u;
+		/*读取配置数据*/
+		funcRtn = dquGetConfigDataNew(LSDataName, LS_DATA_TYPE, AIR_SHAFT_DATA_ID, &pDataAddr, &DataSize, &realRowCount);
+		if (0u == funcRtn)
+		{
+			/*函数调用失败*/
+			rtnValue = 0u;
+			debug_infor_printf((const)"\nAIR_SHAFT_DATA_ID NO IN FS\n");
+		}
+		else
+		{
+			if ((0u != DataSize) && (0u != realRowCount))
+			{
+				if (0u != (DataSize % realRowCount))
+				{
+					debug_infor_printf((const)"\nTIOC_LS_DATA,LS_AirShaft_TABLE len %d %d not equal to fs\n", DataSize, realRowCount);
+					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (LS_DATA_TYPE << 8) + AIR_SHAFT_DATA_ID, PRINT_ONCE);
+					rtnValue = 0u;
+				}
+				else
+				{
+					/*数据实际一行的数据字节长度*/
+					realRowLen = (UINT16)(DataSize / realRowCount);
+					LSDataLen.LSAirShaftRouteStruLen = realRowCount;
+					/*动态申请空间*/
+					LSData.pLSAirShaftRouteStru = (LS_AirShaftStruct*)MyNew((UINT32)(sizeof(LS_AirShaftStruct) * LSDataLen.LSAirShaftRouteStruLen));
+					/*动态申请空间失败*/
+					if (NULL == LSData.pLSAirShaftRouteStru)
+					{
+						LSDataLen.LSAirShaftRouteStruLen = 0u;
+						rtnValue = 0u;
+					}
+					else
+					{
+						/*内存先设为无效*/
+						(void)CommonMemSet((void*)LSData.pLSAirShaftRouteStru, (UINT32)sizeof(LS_AirShaftStruct) * LSDataLen.LSAirShaftRouteStruLen, 0U, (UINT32)sizeof(LS_AirShaftStruct) * LSDataLen.LSAirShaftRouteStruLen);
+						/*解析数据到 默认行车序列 结构体数组 */
+						for (i = 0u; i < LSDataLen.LSAirShaftRouteStruLen; i++)
+						{
+							pAirShaftRouteStr = LSData.pLSAirShaftRouteStru + i;
+
+							/*填充数据结构体*/
+							rtnValue &= LS_AirShaftStruFromChar(pDataAddr, pAirShaftRouteStr);
+							if (CI_ERROR == rtnValue)
+							{
+								rtnValue = 0u;
+								break;
+							}
+							pDataAddr += realRowLen;
+
+						}
+					}
+				}
+
+			}
+			else
+			{
+				debug_infor_printf((const)"\nAIR_SHAFT_ROUTE_DATA_ERR  DataSize %d  realRowCount %d\n ", DataSize, realRowCount);
+			}
+
+		}
+	}
+	return rtnValue;
 }

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

@@ -44,6 +44,7 @@ typedef struct S_LSDataStruct
 	LS_ContactLineStruct* pLSContactLineStr;		/*逻辑区段关联联络线设备检查条件结构体*/
 	LS_EachLgcIntrudeStruct* pLSLgcInvEachStru;/*逻辑区段互相侵限表*/
 	LS_TransRouteZFSigStruct* pLSTransRouteZFSigStru; /*转换轨折返信号机结构体*/
+	LS_AirShaftStruct* pLSAirShaftRouteStru;	/*风井进路检查表*/
 }LSDataStruct;
 /*联锁数据结构*/
 typedef struct S_LSDataStructLen
@@ -75,6 +76,7 @@ typedef struct S_LSDataStructLen
 	UINT16 LSContactStruLen;		/*逻辑区段关联联络线设备检查条件表长度*/
 	UINT16 LSLgcInvEachLen;	/*逻辑区段互相侵限条件表长度*/
 	UINT16 LSTransRouteZFSigStruLen; /*转换轨折返信号机表长度*/
+	UINT16 LSAirShaftRouteStruLen; /*风井进路检查表长度*/
 }LSDataStructLen;
 
 /*********定义全局的联锁信息数据变量*******/
@@ -262,5 +264,12 @@ UINT8 InitLS_ContactConfigDataStruct(CHAR* LSDataName);
 *********************************************/
 UINT8 InitLS_TransRouteRtnDataStruct(CHAR* LSDataName);
 
+/*********************************************
+*函数功能：填充风井进路进路检查表数据结构体数组
+*参数说明：LSDataName指针
+*返回值：0，失败；1，成功
+* 创建：2026.03.04 by yx
+*********************************************/
+UINT8 InitLS_AirShaftRouteStru(CHAR* LSDataName);
 #endif
 

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

@@ -3297,33 +3297,6 @@ UINT16 GetRouteTransRoutZFSigID(const UINT16 routeId)
 	return retVal;
 }
 
-/*
-* 功能描述：获取指定ID进路的入库属性
-* 参数说明：const UINT16 wRouteId 进路ID
-* 返 回 值：0 获取失败
-*           0x55 入库进路
-*			0xaa 非入库进路
-* Created By LQ 2024.09.05
-*/
-UINT8 GetRouteRukuProperty(const UINT16 wRouteId)
-{
-	UINT8 cRetVal = CI_ERROR;
-	UINT16 bufIndex = 0U;  /*数组下标*/
-
-	bufIndex = GetRouteConfigBufIndex(wRouteId);  /*获取进路数组下标*/
-
-	if (bufIndex < ROUTE_SUM_MAX)
-	{
-		cRetVal = RouteConfigDataStru[bufIndex].cRouteRukuProperty;
-	}
-	else
-	{
-		cRetVal = CI_ERROR;
-	}
-
-	return cRetVal;
-}
-
 /*
 * 功能描述： 获取指定不属于本联锁进路是否有道岔属于本联锁
 * 参数说明： const UINT16 wRouteId, 进路ID
@@ -3524,4 +3497,53 @@ UINT8 CheckRouteProSwitchBelCi(const UINT16 wRouteId,UINT8* chCiId)
 	}
 
 	return chRetVal;
+}
+/*
+* 功能描述： 获取指定ID进路关联的风井物理区段数量
+* 参数说明： const UINT16 routeId 进路ID
+* 返回值  ：  0: 获取数据失败
+*			 >0: 关联的风井物理区段数量
+* 创建：2026.03.04 by yx
+*/
+UINT8 GetRouteAiaShaftSecNum(const UINT16 routeId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
+
+	if (bufIndex < ROUTE_SUM_MAX)
+	{
+		retVal = RouteConfigDataStru[bufIndex].airShaftRouteSecSum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID进路关联的风井物理区段ID数组
+* 参数说明： const UINT16 routeId 进路ID
+* 返回值  ： NULL: 获取数据失败
+*			 非NULL: 关联的风井物理区段ID数组
+* 创建：2026.03.04 by yx
+*/
+UINT16* GetRouteAiaShaftSecIdBuf(const UINT16 routeId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16* retVal = NULL;
+
+	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
+
+	if (bufIndex < ROUTE_SUM_MAX)
+	{
+		retVal = RouteConfigDataStru[bufIndex].wAirShaftRouteSecIdBuf;
+	}
+	else
+	{
+		retVal = NULL;
+	}
+	return retVal;
 }

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

@@ -279,7 +279,8 @@ typedef struct S_RouteConfigDataStruct
 	UINT16 szRelatedSGBJId[ROUTE_RELATED_SGBJ_NUM_MAX];  /*进路关联的声光报警器ID*/
 	UINT8 cCbtcProperty;  /*进路CBTC区域属性，0x55：CBTC区域，0xAA：非CBTC区域*/
 	UINT16 wRelatedTransZFSigId;  /*进路关联转换轨折返信号机id 未配置默认0*/
-	UINT8 cRouteRukuProperty;  /*是否为入库进路：0x55 入库进路；0xaa 非入库进路*/
+	UINT8 airShaftRouteSecSum;		/*风井进路物理区段数量*/
+	UINT16 wAirShaftRouteSecIdBuf[AIR_SHAFT_ROUTE_SECTION_NUM_MAX];	/*风井进路物理区段ID数组*/
 }RouteConfigDataStruct;
 
 /*******************************全局变量声明*******************************/
@@ -1303,16 +1304,6 @@ UINT16 GetRouteLeaveLogicSecId(const UINT16 routeId);
 */
 UINT16 GetRouteTransRoutZFSigID(const UINT16 routeId);
 
-/*
-* 功能描述：获取指定ID进路的入库属性
-* 参数说明：const UINT16 wRouteId 进路ID
-* 返 回 值：0 获取失败
-*           0x55 入库进路
-*			0xaa 非入库进路
-* Created By LQ 2024.09.05
-*/
-UINT8 GetRouteRukuProperty(const UINT16 wRouteId);
-
 /*
 * 功能描述： 获取指定不属于本联锁进路是否有道岔属于本联锁
 * 参数说明： const UINT16 wRouteId, 进路ID
@@ -1342,6 +1333,23 @@ UINT8 CheckRouteSwitchBelCi(const UINT16 wRouteId, UINT8* chCiId);
 */
 UINT8 CheckRouteProSwitchBelCi(const UINT16 wRouteId, UINT8* chCiId);
 
+/*
+* 功能描述： 获取指定ID进路关联的风井物理区段数量
+* 参数说明： const UINT16 routeId 进路ID
+* 返回值  ：  0: 获取数据失败
+*			 >0: 关联的风井物理区段数量
+* 创建：2026.03.04 by yx
+*/
+UINT8 GetRouteAiaShaftSecNum(const UINT16 routeId);
+
+/*
+* 功能描述： 获取指定ID进路关联的风井物理区段ID数组
+* 参数说明： const UINT16 routeId 进路ID
+* 返回值  ： NULL: 获取数据失败
+*			 非NULL: 关联的风井物理区段ID数组
+* 创建：2026.03.04 by yx
+*/
+UINT16* GetRouteAiaShaftSecIdBuf(const UINT16 routeId);
 #ifdef __cplusplus
 }
 #endif

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

@@ -61,6 +61,7 @@
 #define ROUTE_APPLY_RECD_TRAIN_SUM_MAX	((UINT8)20)		/*定义ITS申请路径命令能支持的列车数量最大值*/ /*增加 WQM 20220310*/
 
 #define ROUTE_RELATED_SGBJ_NUM_MAX         ((UINT16)50U)     /*定义进路关联的最大声光报警器数目*/
+#define AIR_SHAFT_ROUTE_SECTION_NUM_MAX         ((UINT8)16U)     /*定义风井进路关联的最大风井物理区段数目*/
 
 /*物理区段检查标志*/
 #define ROUTE_PHYSICALSECTION_CHECK_NO      ((UINT8)0x55)	/*联锁条件不检查*/
@@ -373,9 +374,6 @@
 #define ROUTE_CBTC_PROPERTY_YES            ((UINT8)0x55)    /*进路具有CBTC区域属性（所有link均具有CBTC区域属性）*/
 #define ROUTE_CBTC_PROPERTY_NO             ((UINT8)0xaa)    /*进路不具有CBTC区域属性（存在link不具有CBTC区域属性）*/
 
-#define ROUTE_RUKU_PROPERTY_YES    ((UINT8)0x55U)  /*Èë¿â½ø·*/
-#define ROUTE_RUKU_PROPERTY_NO     ((UINT8)0xaaU)  /*·ÇÈë¿â½ø·*/
-
 #define ROUTE_NEAR_SEC_HAVE_UT			((UINT8)0x55)      /*接近区段有故障车*/
 #define ROUTE_NEAR_SEC_NOT_HAVE_UT      ((UINT8)0xaa)      /*接近区段无故障车*/
 
@@ -386,5 +384,9 @@
 #define ROUTE_TO_LEAD_FLAG_NO			((UINT8)0x55)      /*普通进路转引导进路标志无效*/
 #define ROUTE_TO_LEAD_FLAG_YES          ((UINT8)0xaa)      /*普通进路转引导进路标志有效*/
 
+#define ROUTE_COUPLINK_RESULT_GET			     ((UINT8)0x55)       /*收到联挂结果*/
+#define ROUTE_COUPLINK_RESULT_NOT                ((UINT8)0xaa)      /*未收到联挂结果*/
+
+
 #endif 
 

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

@@ -1150,4 +1150,56 @@ UINT8 GetAxisSecCbtcProperty(const UINT16 axisSectionId)
 	}
 
 	return retVal;
-}
+}
+
+/*
+* 功能描述： 获取指定ID计轴区段关联防护道岔数目
+* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 道岔数目
+*  创建	  :  mpt 20260331
+*/
+UINT8 GetAxisSecRelateProSwSum(const UINT16 wAxisSecId)
+{
+	UINT16 wBufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取计轴区段数组下标*/
+
+	if (AXIS_SECTION_SUM_MAX > wBufIndex)
+	{
+		retVal = AxisSectionConfigDataStru[wBufIndex].chRelateProSwSum;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
+
+/*
+* 功能描述： 获取指定ID计轴区段关联防护道岔结构体
+* 参数说明： const UINT16 wLogicSecId, 计轴区段ID
+* 返回值  ： NULL: 获取数据失败
+*			非NULL: 道岔ID数组指针
+* 创建	  : mpt 20260331
+*/
+AxisSwitchStruct* GetAxisSecRelateProSwStru(const UINT16 wAxisSecId)
+{
+	UINT16 wBufIndex = 0u;  /*数组下标*/
+	AxisSwitchStruct* retVal = NULL;
+
+	wBufIndex = GetAxisSecConfigBufIndex(wAxisSecId);  /*获取数组下标*/
+
+	if (AXIS_SECTION_SUM_MAX > wBufIndex)
+	{
+		retVal = AxisSectionConfigDataStru[wBufIndex].wRelateProSwId;
+	}
+	else
+	{
+		retVal = NULL;
+	}
+	return retVal;
+}
+

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

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

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

@@ -658,6 +658,7 @@ UINT32 GetAxisRecentUtOccupyCyc(const UINT16 wAxisSectionId)
 
 	return wRetVal;
 }
+
 /*
 * 功能描述：设置指定ID计轴区段最近坏车占用周期号
 * 参数说明：const UINT16 wAxisSectionId 计轴区段ID UINT32 周期号
@@ -776,7 +777,7 @@ void AxisSecUtOccpyUpdate(void)
 					}
 					else
 					{
-						;  /*不更新*/
+						;/*不更新最近坏车周期*/
 					}
 				}
 			}
@@ -786,4 +787,131 @@ void AxisSecUtOccpyUpdate(void)
 			; /*由相邻联锁设置*/
 		}
 	}
+}
+
+/*
+* 功能描述：获取指定ID计轴区段列车安全位置覆盖标志
+* 参数说明：const UINT16 axisSectionId 计轴区段ID
+* 返 回 值：0x55 无效
+*			0xAA 有效
+* Created By LQ 2025.12.01
+*/
+UINT8 GetAxisTXSafeLocFlag(const UINT16 axisSectionId)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT8 retVal = AXIS_SECTION_SAFELOC_NO;
+
+	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);  /*获取区段数组下标*/
+
+	if (AXIS_SECTION_SUM_MAX > bufIndex)
+	{
+		retVal = AxisSectionDataStru[bufIndex].cAxisTXSafeLocFlag;
+	}
+	else
+	{
+		retVal = AXIS_SECTION_SAFELOC_NO;
+	}
+
+	return retVal;
+}
+
+/*
+* 功能描述：设置指定ID计轴区段列车安全位置覆盖标志
+* 参数说明：const UINT16 axisSectionId 计轴区段ID
+*			const UINT8 cFlag 标志
+* 返 回 值：无
+* Created By LQ 2025.12.01
+*/
+void SetAxisTXSafeLocFlag(const UINT16 axisSectionId, const UINT8 cFlag)
+{
+	UINT16 bufIndex = 0U;  /*数组下标*/
+
+	bufIndex = GetAxisSecConfigBufIndex(axisSectionId);
+
+	if (AXIS_SECTION_SUM_MAX > bufIndex)
+	{
+		if ((AXIS_SECTION_SAFELOC_NO == cFlag) || (AXIS_SECTION_SAFELOC_YES == cFlag))
+		{
+			AxisSectionDataStru[bufIndex].cAxisTXSafeLocFlag = cFlag;
+		}
+		else
+		{
+			/*不处理*/
+		}
+	}
+	else
+	{
+		/*不做处理*/
+	}
+}
+
+/*
+* 功能描述：清除计轴区段列车安全位置覆盖标志
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.12.01
+*/
+void ClearAxisTXSafeLocFlag(void)
+{
+	UINT16 aAxisSecDataSum = 0U;  /*计轴区段总数*/
+	UINT16 wAxisSecId = 0U;  /*计轴区段ID*/
+	UINT16 bufIndex = 0U;  /*数组下标*/
+	UINT16 ii = 0U;
+
+	aAxisSecDataSum = GetTotalAxisCurNum();
+
+	for (ii = 0U; ii < aAxisSecDataSum; ii++)
+	{
+		wAxisSecId = GetAxisSecId(ii);
+		bufIndex = GetAxisSecConfigBufIndex(wAxisSecId);
+		if (AXIS_SECTION_SUM_MAX > bufIndex)
+		{
+			AxisSectionDataStru[wAxisSecId].cAxisTXSafeLocFlag = AXIS_SECTION_SAFELOC_NO;  /*重置计轴区段无通信车安全位置覆盖标志无效*/
+		}
+		else
+		{
+			/*ID非法，不处理*/
+		}
+	}
+}
+
+/*
+* 功能描述：获取存在计轴道岔位置是否满足（四开视为满足）
+* 参数说明：UINT16 wAcId 计轴区段
+* 返回值  ：CI_ERROR  CI_SUCCESS满足 
+* Create fan 20260410
+*/
+UINT8 GetAcSwitchPosCheck(UINT16 wAcId)
+{
+	AxisSwitchStruct* axisSwitchStru = NULL;
+	UINT8 axisSwitchSum = 0U;/*计轴条件道岔数量*/
+	UINT8 jj = 0U;
+	UINT8 retValue = CI_SUCCESS;/*本函数检查ARB使用 成功时需要检查未安全侧*/
+	UINT8 switchCurPosition = 0U;/*道岔位置*/
+	axisSwitchStru = GetAxisSwitchIdStru(wAcId);
+	axisSwitchSum = GetAxisSwitchSum(wAcId);
+	if (NULL != axisSwitchStru)
+	{
+		for (jj = 0U; jj < axisSwitchSum; jj++)
+		{
+			switchCurPosition = GetSwitchCurPosition(axisSwitchStru[jj].SwitchId);	/*获取道岔当前位置*/
+																					/*四开时保留可达性*/
+			if (((SWITCH_POSITION_FANWEI == switchCurPosition) || (SWITCH_POSITION_DINGWEI == switchCurPosition))
+				&& (axisSwitchStru[jj].SwitchPosition != switchCurPosition))
+			{
+				retValue = CI_ERROR;
+				break;
+			}
+			else
+			{
+				/*四开或道岔位置满足*/
+				/*计轴关联多个道岔时需所有道岔满足*/
+			}
+		}
+	}
+	else
+	{
+		;
+	}
+	return retValue;
 }

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

@@ -44,6 +44,7 @@ typedef struct S_AxisSectionDataStruct
 	UINT32 dwAxisOccCycNum;         /*计轴占用起始周期*/
 	UINT16 wPosMonitorTrainId;  /*计轴区段关联的位置监督有效的列车ID*/
 	UINT32 dwUtOccupyCycNum;         /*最近坏车占用周期*/
+	UINT8 cAxisTXSafeLocFlag;  /*计轴区段列车安全位置覆盖标志：0x55-无效；0xAA-有效*/
 } AxisSectionDataStruct;
 
 
@@ -247,6 +248,7 @@ UINT32 GetAxisRecentUtOccupyCyc(const UINT16 wAxisSectionId);
 * Created By fan 2024.08.19
 */
 void SetAxisRecentUtOccupyCyc(const UINT16 wAxisSectionId, const UINT32 dwCycNum);
+
 /**
 * 功能：查询更新计轴上坏车占用状态
 * 输入参数：无
@@ -255,6 +257,39 @@ void SetAxisRecentUtOccupyCyc(const UINT16 wAxisSectionId, const UINT32 dwCycNum
 */
 void AxisSecUtOccpyUpdate(void);
 
+/*
+* 功能描述：获取指定ID计轴区段列车安全位置覆盖标志
+* 参数说明：const UINT16 axisSectionId 计轴区段ID
+* 返 回 值：0x55 无效
+*			0xAA 有效
+* Created By LQ 2025.12.01
+*/
+UINT8 GetAxisTXSafeLocFlag(const UINT16 axisSectionId);
+
+/*
+* 功能描述：设置指定ID计轴区段列车安全位置覆盖标志
+* 参数说明：const UINT16 axisSectionId 计轴区段ID
+*			const UINT8 cFlag 标志
+* 返 回 值：无
+* Created By LQ 2025.12.01
+*/
+void SetAxisTXSafeLocFlag(const UINT16 axisSectionId, const UINT8 cFlag);
+
+/*
+* 功能描述：清除计轴区段列车安全位置覆盖标志
+* 参数说明：无
+* 返 回 值：无
+* Created By LQ 2025.12.01
+*/
+void ClearAxisTXSafeLocFlag(void);
+
+/*
+* 功能描述：获取存在计轴道岔位置是否满足（四开视为满足）
+* 参数说明：UINT16 wAcId 计轴区段
+* 返回值  ：CI_ERROR  CI_SUCCESS满足
+* Create fan 20260410
+*/
+UINT8 GetAcSwitchPosCheck(UINT16 wAcId);
 
 #ifdef __cplusplus
 }

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

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

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

@@ -3747,6 +3747,9 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 {
 	UINT16 bufIndex = 0u;  /*数组下标*/
 	UINT8 checkResult = CI_ERROR;
+	UINT16 devId = 0u;                   /*设备ID*/
+	UINT8 devState = 0u;                 /*设备状态*/
+	UINT8 retVal = 0u;
 
 	/** 获取逻辑区段数组下标*/
 	bufIndex = GetlogSectionBufIndex(logSectionId);
@@ -3768,9 +3771,26 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 			else
 			{
 				/** 设置跳跃锁闭允许标志为允许 */
-				SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+
+
+				ClearLogSeceSwitchDanCaoPos(logSectionId);/*清除单操位置*/
 				/** 设置逻辑区段跳跃锁闭 */
 				SetLogSecJumpLockState(logSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+
+				SetLogSecRelProSwitchLockSta(logSectionId, SWITCH_LOCK_PROTECT_SET);
+
+				devId = 0u;
+				devState = 0u;
+				retVal = LogicSecRltvPrtctSwLockCheck(logSectionId, &devId, &devState);
+				if (CI_SUCCESS == retVal)
+				{/*防护道岔锁检查*/
+					SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
+				}
+				else
+				{
+					SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
+				}
+
 			}
 		}
 		/** 逻辑区段跳跃锁闭未锁闭*/
@@ -3780,6 +3800,8 @@ void LogJumpLockCmdManage(const UINT16 logSectionId, const UINT8 jumpLockState)
 			SetLogSecJumpLockPermFlag(logSectionId, LOGIC_JUMPUNLOCK_PERMISSIVE_NO);
 			/** 设置跳跃锁闭未锁闭 */
 			SetLogSecJumpLockState(logSectionId, LOGIC_SECTION_JUMP_LOCK_NO);
+
+			SetLogSecRelProSwitchLockSta(logSectionId, SWITCH_LOCK_PROTECT_CANCEL);
 		}
 		else
 		{
@@ -4578,11 +4600,24 @@ UINT8 GetLogSecHaveResOpp(const UINT16 wLogicSecId)
 		/*当前逻辑区段具备进路锁闭或着进路锁闭兼防护锁闭*/
 		wRouteLogSecSum = GetRouteLogSectionSum(wRLockRouteId);
 		pRouteLogSecId = GetRouteLogSectionIdBuf(wRLockRouteId);
-		if ((pRouteLogSecId[wRouteLogSecSum - 1U] == wLogicSecId) && (LOG_SECTION_LOCK_NORMAL == chLogSecLockState))
+
+		if (NULL != pRouteLogSecId)
 		{
-			/*当前待查询逻辑区段为进路最后一个区段并且是正常锁闭，满足条件*/
+			if ((pRouteLogSecId[wRouteLogSecSum - 1U] == wLogicSecId) && (LOG_SECTION_LOCK_NORMAL == chLogSecLockState))
-			retVal = CI_SUCCESS;
+			{
+				/*当前待查询逻辑区段为进路最后一个区段并且是正常锁闭，满足条件*/
+				retVal = CI_SUCCESS;
+			}
+			else
+			{
+				; /*不满足条件*/
+			}
 		}
+		else
+		{
+			; /*可能相邻联锁进路，为空初始化失败*/
+		}
+		
 	}
 	else if (0U < wPLockRouteId)
 	{
@@ -4593,11 +4628,22 @@ UINT8 GetLogSecHaveResOpp(const UINT16 wLogicSecId)
 		chLogSecLockDir = GetLogSecLockDir(wLogicSecId);
 		chLogSecLockSysDir = ConvertDirectionToLogic(chLogSecLockDir);
 
-		if (((pLogicSectionIdBuf[chLogicSectionSum - 1U] == wLogicSecId) && (DIR_SAME == chLogSecLockSysDir))
+		if (NULL != pLogicSectionIdBuf)
-			|| ((pLogicSectionIdBuf[0] == wLogicSecId) && (DIR_CONVERT == chLogSecLockSysDir)))
 		{
-			/*当前待查询逻辑区段锁闭方向与逻辑方向相同，则保护区段最后一个区段满足条件；与逻辑方向相反，保护区段第一个逻辑区段满足条件*/
+			if (((pLogicSectionIdBuf[chLogicSectionSum - 1U] == wLogicSecId) && (DIR_SAME == chLogSecLockSysDir))
-			retVal = CI_SUCCESS;
+				|| ((pLogicSectionIdBuf[0] == wLogicSecId) && (DIR_CONVERT == chLogSecLockSysDir)))
+			{
+				/*当前待查询逻辑区段锁闭方向与逻辑方向相同，则保护区段最后一个区段满足条件；与逻辑方向相反，保护区段第一个逻辑区段满足条件*/
+				retVal = CI_SUCCESS;
+			}
+			else
+			{
+				; /*可能相邻联锁数据，为空初始化失败*/
+			}
+		}
+		else
+		{
+			; /*可能相邻联锁进路，为空初始化失败*/
 		}
 	}
 	else

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

@@ -174,6 +174,31 @@ UINT8 GetPhySecLjkFlag(const UINT16 phySectionId)
 	return retVal;
 }
 
+/*
+* 功能描述： 获取指定ID物理区段牵出线区段标志
+* 参数说明： const UINT16 phySectionId, 区段ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 牵出线区段标志：0x55非牵出线 0xAA牵出线区段
+* Create fan 20260415
+*/
+UINT8 GetPhySecQcxFlag(const UINT16 phySectionId)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = CI_ERROR;
+
+	bufIndex = GetPhySecConfigBufIndex(phySectionId);  /*获取区段数组下标*/
+
+	if (bufIndex < PHYSICAL_SECTION_SUM_MAX)
+	{
+		retVal = PhysicalSectionConfigDataStru[bufIndex].QcxSecFlag;
+	}
+	else
+	{
+		retVal = CI_ERROR;
+	}
+	return retVal;
+}
+
 
 /*
 * 功能描述： 获取指定ID物理区段轨道继电器ID
@@ -1104,9 +1129,7 @@ void AddAdjacentPhySec(const UINT16 wPhySecId)
 	UINT8 k = 0U;
 	UINT16* pACBuff = NULL; /*物理区段计轴数组*/
 	UINT16 wAcStratLink = 0U;/*计轴始端link*/
-	UINT16 wAxisID = 0U; /*计轴器编号*/
 	UINT16 wAcTerminLink = 0U; /*计轴终端link*/
-	UINT16 phySectionConfigDataSum = 0u;      /*物理区段设备配置数据总数*/
 	UINT8 chAcLinkSum = 0;
 	UINT16* pAclinkBuf = NULL;
 	UINT16 wStartNearLink = 0U; /*计轴始端相邻link*/
@@ -1158,10 +1181,14 @@ void AddAdjacentPhySec(const UINT16 wPhySecId)
 					if (PhysicalSectionConfigDataStru[bufIndex].AdjacentPhySecBuf[k] == wStartNearSec)
 					{
 						chStartAddFlag = CI_SUCCESS;
+						/*已存在，增加可达条件计轴*/
+						AddNeighborPhyConditionAc(wPhySecId, k, pACBuff[jj]);
 					}
 					if (PhysicalSectionConfigDataStru[bufIndex].AdjacentPhySecBuf[k] == wTmmNearSec)
 					{
 						chTmmAddFlag = CI_SUCCESS;
+						/*已存在，增加可达条件计轴*/
+						AddNeighborPhyConditionAc(wPhySecId, k, pACBuff[jj]);
 					}
 				}
 				/*添加直接相邻区段*/
@@ -1169,6 +1196,8 @@ void AddAdjacentPhySec(const UINT16 wPhySecId)
 					&&  (PHYSEC_ADJACENT_SEC_SUM_MAX> PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum))
 				{
 					PhysicalSectionConfigDataStru[bufIndex].AdjacentPhySecBuf[PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum] = wStartNearSec;
+					/*增加可达条件计轴*/
+					AddNeighborPhyConditionAc(wPhySecId, PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum, pACBuff[jj]);
 					PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum++;
 				}
 				else
@@ -1179,6 +1208,7 @@ void AddAdjacentPhySec(const UINT16 wPhySecId)
 					&& (PHYSEC_ADJACENT_SEC_SUM_MAX>PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum))
 				{
 					PhysicalSectionConfigDataStru[bufIndex].AdjacentPhySecBuf[PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum] = wTmmNearSec;
+					AddNeighborPhyConditionAc(wPhySecId, PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum, pACBuff[jj]);
 					PhysicalSectionConfigDataStru[bufIndex].chAdjacentPhySecNum++;
 				}
 				else
@@ -1227,7 +1257,7 @@ void AddNearPhySec(const UINT16 wPhySecId)
 	}
 	chAdjacentPhyNum = GetAdjacentPhySecNum(wPhySecId);
 	wAdjacentPhyBuf = GetAdjacentPhySecBuf(wPhySecId);/*本联锁直接相邻*/
-	for (ii = 0; ii < chAdjacentPhyNum; ii++)
+	for (ii = 0U; ii < chAdjacentPhyNum; ii++)
 	{
 		wAdjacentPhySec = wAdjacentPhyBuf[ii];
 		dwPhySecLen = GetPhySecRelayMinAcLen(wAdjacentPhySec);
@@ -1242,7 +1272,7 @@ void AddNearPhySec(const UINT16 wPhySecId)
 			/*直接相邻的长度不足*/
 			chNearSecNum = GetAdjacentPhySecNum(wAdjacentPhySec);
 			dwNearSecBuf = GetAdjacentPhySecBuf(wAdjacentPhySec);
-			for (jj = 0; jj < chNearSecNum; jj++)
+			for (jj = 0U; jj < chNearSecNum; jj++)
 			{
 				/*添加间接邻近的区段*/
 				dwIndirectLen = GetPhySecRelayMinAcLen(dwNearSecBuf[jj]);
@@ -1258,13 +1288,13 @@ void AddNearPhySec(const UINT16 wPhySecId)
 				else
 				{
 					/*待检查区域仍在本联锁和相邻RC发送范围*/
-					chAddCheck = CheckNearPhySec(dwNearSecBuf[jj], wPhySecId);
+					chAddCheck = CheckNearPhySec(dwNearSecBuf[jj], wPhySecId, wAdjacentPhySec, 0U);
 					chBelongCi = GetPhySecBelongCiId(dwNearSecBuf[jj]);
 					chCiType = GetCiType(chBelongCi);
 					if (CI_SUCCESS == chAddCheck)
 					{
 						/*添加成功*/
-
+		
 						/*判断是否再找一轮*/
 						if (CI_TYPE_CLD == chCiType)
 						{
@@ -1274,7 +1304,7 @@ void AddNearPhySec(const UINT16 wPhySecId)
 						{
 							chTwoStepNearSecNum = GetAdjacentPhySecNum(dwNearSecBuf[jj]);
 							dwTwoStepNearSecBuf = GetAdjacentPhySecBuf(dwNearSecBuf[jj]);
-							for (kk = 0; kk < chTwoStepNearSecNum; kk++)
+							for (kk = 0U; kk < chTwoStepNearSecNum; kk++)
 							{
 								/*添加间隔两步邻近的区段*/
 								dwIndirectLen = GetPhySecRelayMinAcLen(dwTwoStepNearSecBuf[kk]);
@@ -1287,7 +1317,7 @@ void AddNearPhySec(const UINT16 wPhySecId)
 								}
 								else
 								{
-									chAddCheck = CheckNearPhySec(dwTwoStepNearSecBuf[kk], wPhySecId);
+									chAddCheck = CheckNearPhySec(dwTwoStepNearSecBuf[kk], wPhySecId, wAdjacentPhySec,dwNearSecBuf[jj]);
 									/*暂不再查*/
 								}
 							}
@@ -1344,28 +1374,25 @@ UINT16* GetAdjacentPhySecBuf(const UINT16 wPhySecId)
 }
 /*
 * 功能描述：检查物理区段已有邻近范围内有无该区段 无则添加
-* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec基准，wAdjPhySecId 直接相邻跳转区段,wSndPreSec一步间接跳转
 * 返回值  ：CI_SUCCESS 新添加 CI_ERROR 已有 
 *Create fan 20240822
 */
-UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec)
+UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec, const UINT16 wPrePhySecId,const UINT16 wSndPreSec)
 {
 	UINT8 retValue = CI_SUCCESS;
 	UINT8 ii = 0U;
 	UINT8 jj = 0U;
 	UINT16* wAdjacentPhyBuf = NULL; /*直接相连区段数组*/
-	UINT16 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
+	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
 	UINT8 chNearSecNum = 0U; /*间接相邻数量*/
-	UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
 	UINT16 bufIndex = 0U;
-	UINT8 chCiType = 0U;
+	UINT16 wTransitAc = 0U; /*跳转计轴*/
-	UINT8 chBelongCi = 0U;
+	UINT8 chTransitAcNum = 0U;/*跳转计轴数量*/
-
 	bufIndex = GetPhySecConfigBufIndex(basePhysec);  /*获取区段数组下标*/
 	chAdjacentPhyNum = GetAdjacentPhySecNum(basePhysec);
 	wAdjacentPhyBuf = GetAdjacentPhySecBuf(basePhysec);
 	chNearSecNum = PhysicalSectionConfigDataStru[bufIndex].chNearPhySecNum;
-
 	/*不是基准区段*/
 	if (wPhySecId == basePhysec)
 	{
@@ -1384,23 +1411,51 @@ UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec)
 			}
 		}
 	}
+	/*第二步 检查上一区段中存在跳转计轴*/
+	if (CI_SUCCESS == retValue)
+	{
+		if (0U == wSndPreSec)
+		{
+			/*一步间接*/
+			wTransitAc = GetTransitAcFromPreSec(wPhySecId, basePhysec, wPrePhySecId);
+		}
+		else
+		{
+			/*二步间接*/
+			wTransitAc = GetSndTransitAcFromPreSce(wPhySecId, basePhysec, wPrePhySecId, wSndPreSec);
+		}
+		if (0U == wTransitAc)
+		{
+			/*未获取到满足条件的计轴*/
+			retValue = CI_ERROR;
+		}
+	}
 	
-	/*第二步 检查已有间接相邻*/
+	/*第三步 检查已有间接相邻*/
 	if (CI_SUCCESS == retValue)
 	{
 		for (jj = 0; jj < chNearSecNum; jj++)
 		{
 			if (wPhySecId == PhysicalSectionConfigDataStru[bufIndex].IndirectNearPhySecBuf[jj])
 			{
-				retValue = CI_ERROR;
+				/*增加跳转计轴*/
-				break;
+				chTransitAcNum = PhysicalSectionConfigDataStru[bufIndex].TransitAcData[jj].RelateAcNum;
+				if (PHYSICAL_INCLUDE_AXIS_SUM_MAX > chTransitAcNum)
+				{
+					PhysicalSectionConfigDataStru[bufIndex].TransitAcData[jj].AcIdBuf[chTransitAcNum] = wTransitAc;
+					PhysicalSectionConfigDataStru[bufIndex].TransitAcData[jj].RelateAcNum++;
+				}
+				retValue = CI_ERROR;/*不需要添加为间接相邻区段*/
 			}
 		}
 	}
-	/*添加*/
+
 	if ((CI_SUCCESS == retValue) &&(PHYSEC_INDIRECTNEAR_SEC_SUM_MAX>chNearSecNum))
 	{
+		/*新增间接相邻区段 记录第一个跳转计轴*/
 		PhysicalSectionConfigDataStru[bufIndex].IndirectNearPhySecBuf[chNearSecNum] = wPhySecId;
+		PhysicalSectionConfigDataStru[bufIndex].TransitAcData[chNearSecNum].AcIdBuf[0] = wTransitAc;
+		PhysicalSectionConfigDataStru[bufIndex].TransitAcData[chNearSecNum].RelateAcNum++;
 		PhysicalSectionConfigDataStru[bufIndex].chNearPhySecNum++;
 	}
 	else
@@ -1464,7 +1519,6 @@ UINT8 PhySectionNearConfigDataManage(void)
 	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
 	UINT8 chNearSecNum = 0U; /*间接相邻数量*/
 	UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
-	UINT8 chLocalCiType = GetLocalCiType();
 	UINT8 chLocal = GetSystemParaLocalCiId();
 	UINT8 chBelongCi = 0U;
 
@@ -1610,4 +1664,373 @@ UINT16 GetPhyIdByIndexInAxle(const UINT8 chAxleId, const UINT16 wIndexInAxle)
 	}
 
 	return wReval;
+}
+
+/*
+* 功能描述：添加直接相邻区段检查计轴数据
+* 参数说明： const UINT16 wPhySecId 物理区段 UINT8 chIndex相邻区段索引 UINT16 AcId计轴ID
+* 返回值  ：无
+*Create fan 20260303
+*/
+void AddNeighborPhyConditionAc(const UINT16 wPhySecId, UINT8 chIndex, UINT16 AcId)
+{
+	UINT16 bufIndex = 0U;
+	UINT8 chAcIndec = 0U;/*计轴索引*/
+	bufIndex = GetPhySecConfigBufIndex(wPhySecId);  /*获取区段数组下标*/	
+	if ((PHYSICAL_SECTION_SUM_MAX > bufIndex)&&(PHYSEC_ADJACENT_SEC_SUM_MAX>chIndex))
+	{
+		chAcIndec = PhysicalSectionConfigDataStru[bufIndex].AdjacentSecAcData[chIndex].RelateAcNum;
+		if (PHYSICAL_INCLUDE_AXIS_SUM_MAX > chAcIndec)
+		{
+			PhysicalSectionConfigDataStru[bufIndex].AdjacentSecAcData[chIndex].AcIdBuf[chAcIndec] = AcId;
+			PhysicalSectionConfigDataStru[bufIndex].AdjacentSecAcData[chIndex].RelateAcNum++;
+		}
+		else
+		{
+			;/*数组上限 不添加*/
+		}
+	}
+	else
+	{
+		;/*不处理*/
+	}
+}
+
+/*
+* 功能描述： 获取指定ID物理区段的ARB防护范围区段的跳转计轴序列
+* 参数说明： const UINT16 phySectionId, 物理区段ID  UINT16 wNearSecID 相邻区段
+* 返回值  ： 0: 获取数据失败
+*			>0: 计轴区段ID数组指针
+*Create fan 202604010
+*/
+UINT16* GetPhySecNearSecTransitAcBuf(const UINT16 phySectionId, const UINT16 wNearSecID)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT16 * retVal = NULL;
+	UINT8 i = 0U;
+	bufIndex = GetPhySecConfigBufIndex(phySectionId);  /*获取区段数组下标*/
+
+	if (PHYSICAL_SECTION_SUM_MAX> bufIndex)
+	{
+		for (i = 0U; i < PhysicalSectionConfigDataStru[bufIndex].chNearPhySecNum; i++)
+		{
+			if (PhysicalSectionConfigDataStru[bufIndex].IndirectNearPhySecBuf[i] == wNearSecID)
+			{
+				retVal = PhysicalSectionConfigDataStru[bufIndex].TransitAcData[i].AcIdBuf;
+				break;
+			}
+		}
+		
+	}
+	else
+	{
+		retVal = NULL;
+	}
+	return retVal;
+}
+
+/*
+* 功能描述： 获取指定ID物理区段到某个临近区段的直接跳转计轴数量
+* 参数说明： const UINT16 phySectionId, 物理区段ID  UINT16 wNearSecID 相邻区段
+* 返回值  ： 0: 获取数据失败
+*			>0: 计轴区段ID数组指针
+*Create fan 202604010
+*/
+UINT8 GetPhySecNearSecTransitAcNum(const UINT16 phySectionId, const UINT16 wNearSecID)
+{
+	UINT16 bufIndex = 0u;  /*数组下标*/
+	UINT8 retVal = 0U;
+	UINT8 i = 0U;
+	bufIndex = GetPhySecConfigBufIndex(phySectionId);  /*获取区段数组下标*/
+
+	if (PHYSICAL_SECTION_SUM_MAX> bufIndex)
+	{
+		for (i = 0U; i < PhysicalSectionConfigDataStru[bufIndex].chNearPhySecNum; i++)
+		{
+			if (PhysicalSectionConfigDataStru[bufIndex].IndirectNearPhySecBuf[i] == wNearSecID)
+			{
+				retVal = PhysicalSectionConfigDataStru[bufIndex].TransitAcData[i].RelateAcNum;
+				break;
+			}
+		}
+	}
+	else
+	{
+		retVal = 0U;
+	}
+	return retVal;
+}
+/*
+* 功能描述：检查间接相邻区段的上一跳转区段是否属于区段的直接相邻范围
+* 参数说明： const UINT16 wPhySecId，const UINT16 wPreSecId
+* 返回值  ：CI_SUCCESS 是 CI_ERROR否
+* Create fan 20260303
+*/
+UINT8 CheckPhySecIfAdjacent(const UINT16 wPhySecId, const UINT16 wPreSecId)
+{
+	UINT8 retVal = CI_ERROR;
+	UINT16* wAdjacentPhyBuf = NULL; /*直接相连区段数组*/
+	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
+	UINT8 ii = 0U;
+	chAdjacentPhyNum = GetAdjacentPhySecNum(wPhySecId);
+	wAdjacentPhyBuf = GetAdjacentPhySecBuf(wPhySecId);/*直接相邻数组*/
+	for (ii = 0U; ii < chAdjacentPhyNum; ii++)
+	{
+		if (wPreSecId == wAdjacentPhyBuf[ii])
+		{
+			retVal = CI_SUCCESS;
+			break;
+		}
+		else
+		{
+			;/*继续*/
+		}
+	}
+	return retVal;
+}
+/*
+* 功能描述：获取物理区段直接相邻区段条件计轴检查结果(是否可达)
+* 参数说明： const UINT16 wPhySecId UINT16 wNearSec 直接相邻区段
+* 返回值  ：直接相邻区段条件计轴检查结果 CI_ERROR不可达 CI_SUCCESS可达
+* Create fan 20260303
+*/
+UINT8 GetAdjacentPhySecAcCheck(const UINT16 wPhySecId, UINT16 wNearSec)
+{
+	UINT16 bufIndex = 0U;
+	UINT8 retValue = CI_SUCCESS;/*SUCCESS时检查对应区段，为安全态*/
+	UINT8 k = 0U;/*计轴索引*/
+	UINT8 jj = 0U;
+	UINT8 ii = 0U;
+	UINT16 wAcId = 0U;
+	UINT8 chCheckAcNum = 0U;
+	UINT16* ConditionAcBuf = NULL; /*条件计轴数组*/
+	AxisSwitchStruct* axisSwitchStru = NULL;
+	UINT8 axisSwitchSum = 0U;/*计轴条件道岔数量*/
+	UINT16 curSwitchId = 0U;/*计轴关联道岔*/
+	UINT8 switchCurPosition = 0U;/*道岔位置*/
+	UINT8 chAcCheckResult = CI_ERROR;/*单个条件计轴检查结果*/
+	UINT16* wAdjacentPhyBuf = NULL; /*直接相连区段数组*/
+	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
+	chAdjacentPhyNum = GetAdjacentPhySecNum(wPhySecId);
+	wAdjacentPhyBuf = GetAdjacentPhySecBuf(wPhySecId);/*直接相邻数组*/
+	bufIndex = GetPhySecConfigBufIndex(wPhySecId);  /*获取区段数组下标*/
+	if (PHYSICAL_SECTION_SUM_MAX > bufIndex)
+	{
+		for (ii = 0U; ii < chAdjacentPhyNum; ii++)
+		{
+			if (wNearSec == wAdjacentPhyBuf[ii])
+			{
+				chCheckAcNum = PhysicalSectionConfigDataStru[bufIndex].AdjacentSecAcData[ii].RelateAcNum;
+				ConditionAcBuf = PhysicalSectionConfigDataStru[bufIndex].AdjacentSecAcData[ii].AcIdBuf;
+				for (k = 0U; k <chCheckAcNum; k++)
+				{
+					wAcId = ConditionAcBuf[k];
+					axisSwitchStru = GetAxisSwitchIdStru(wAcId);
+					axisSwitchSum = GetAxisSwitchSum(wAcId);
+					chAcCheckResult = CI_SUCCESS;/*无岔认为一定可达*/
+					for (jj = 0U; jj < axisSwitchSum; jj++)
+					{
+						curSwitchId = axisSwitchStru[jj].SwitchId;
+						switchCurPosition = GetSwitchCurPosition(curSwitchId);	/*获取道岔当前位置*/
+						/*四开时保留可达性*/
+						if (((SWITCH_POSITION_FANWEI == switchCurPosition) || (SWITCH_POSITION_DINGWEI == switchCurPosition))
+							&& (axisSwitchStru[jj].SwitchPosition != switchCurPosition))
+						{
+							chAcCheckResult = CI_ERROR;
+							break;
+						}
+						else
+						{
+							/*四开或道岔位置满足*/
+							/*计轴关联多个道岔时需所有道岔满足*/
+						}
+					}
+					if (CI_SUCCESS == chAcCheckResult)
+					{
+						/*只要有一个条件计轴满足，则相邻区段可达, 无岔必可达*/
+						retValue = CI_SUCCESS;
+						break;
+					}
+					else
+					{
+						retValue = CI_ERROR;
+					}
+				}
+				break;/*已找到对应区段 停止检查*/
+			}
+			else
+			{
+				;/*非检查区段 不处理*/
+			}
+		}
+
+	}
+	else
+	{
+		;/*返回需进行检查*/
+	}
+	return retValue;
+}
+
+/*
+* 功能描述：获取存在跳转计轴时 间隔相邻区段是否可达
+* 参数说明： constUINT16 wBasePhySec基准区段  wTransitAcId 上一跳转计轴区段
+* 返回值  ：CI_ERROR不可达 CI_SUCCESS可达
+* Create fan 20260410
+*/
+UINT8 GetTransitPhySecAcCheck(const UINT16 wBasePhySec, UINT16 wTransitAcId)
+{
+	UINT8 retValue = CI_SUCCESS;/*SUCCESS时检查对应区段，为安全态*/
+	UINT16 wPreSec = 0U;
+	UINT8 jj = 0U;
+	UINT8 chAdvacentCheck = CI_ERROR;/*是否一步间接*/
+	UINT16 wFiestStepSec = 0U;
+	UINT8 chTransitAcNum = 0U; /*跳转计轴数量*/
+	UINT16* chTransitAcBuf = NULL; /*跳转计轴数组*/
+	UINT8 chStepCheck = CI_SUCCESS;
+	wPreSec = GetAxisSecRelativePhySecId(wTransitAcId);
+	if (0U != wPreSec)
+	{
+		/*待检查区段与上一区段之间的可达性由跳转计轴保证*/
+		retValue = GetAcSwitchPosCheck(wTransitAcId);
+		chAdvacentCheck = CheckPhySecIfAdjacent(wBasePhySec, wPreSec);
+		if (CI_SUCCESS == chAdvacentCheck)
+		{		
+			/*一步间接：检查条件计轴+基准区段的道岔位置*/
+			retValue &= GetAdjacentPhySecAcCheck(wBasePhySec, wPreSec);/*基准区段的道岔满足*/
+		}
+		else
+		{
+			/*二步间接：检查条件计轴+一步间接区段的所有条件计轴中存在满足且基准道岔位置满足的区段*/
+			chTransitAcNum = GetPhySecNearSecTransitAcNum(wBasePhySec, wPreSec);
+			chTransitAcBuf = GetPhySecNearSecTransitAcBuf(wBasePhySec, wPreSec);
+			if ((NULL != chTransitAcBuf)&&(0U < chTransitAcNum))
+			{
+				for (jj = 0; jj < chTransitAcNum; jj++)
+				{
+					wFiestStepSec = GetAxisSecRelativePhySecId(chTransitAcBuf[jj]);
+					chStepCheck = GetAcSwitchPosCheck(chTransitAcBuf[jj]);
+					chStepCheck &= GetAdjacentPhySecAcCheck(wBasePhySec, wFiestStepSec);/*基准区段到直接相邻的道岔满足*/
+					if (CI_SUCCESS == chStepCheck)
+					{
+						break;
+					}
+				}
+			}
+			else
+			{
+				chStepCheck = CI_ERROR;/*不存在跳转条件*/
+			}
+			retValue &= chStepCheck;
+		}
+	}
+	
+	/*检查跳转区段中存在*/
+	return retValue;
+}
+
+/*
+* 功能描述：检查在物理区段中获取符合条件的跳转计轴ID
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec基准区段，wAdjPhySecId 间接区段的上一跳转区段
+* 返回值  ：CI_SUCCESS 新添加 CI_ERROR 已有
+*Create fan 20260410
+*/
+UINT16 GetTransitAcFromPreSec(const UINT16 wPhySecId, const UINT16 basePhysec, const UINT16 wPrePhySecId)
+{
+	UINT16 retAcId = 0U;
+	UINT8 phyAcNum = 0; /*物理区段计轴*/
+	UINT16* pACBuff = NULL; /*物理区段计轴数组*/
+	UINT16 wAcStratLink = 0U; /*计轴始端link*/
+	UINT16 wAcTerminLink = 0U; /*计轴终端link*/
+	UINT8 chAcLinkSum = 0;
+	UINT16* pAclinkBuf = NULL;
+	UINT16 wStartNearLink = 0U; /*计轴始端相邻link*/
+	UINT16 wTmmNearLink = 0U;/*计轴终端相邻link*/
+	UINT16 wStartNearSec = 0U;
+	UINT16 wTmmNearSec = 0U;
+	UINT8 jj = 0U;
+	/*跳转区段中找一端链接基准 一端为待检查的区段跳转计轴*/
+	phyAcNum = GetPAxisSectionSum(wPrePhySecId);
+	pACBuff = GetPAxisSectionIdBuf(wPrePhySecId);
+	if ((0U != phyAcNum) && (NULL != pACBuff))
+	{
+		/*遍历跳转区段的关联计轴*/
+		for (jj = 0u; jj < phyAcNum; jj++)
+		{
+			chAcLinkSum = GetAxisLinkSum(pACBuff[jj]);
+			pAclinkBuf = GetAxisLinkIdBuf(pACBuff[jj]);
+			wAcStratLink = pAclinkBuf[0];
+			wAcTerminLink = pAclinkBuf[chAcLinkSum - (UINT8)1U];
+			/*获取始端相邻物理区段*/
+			wStartNearLink = GetLinkOrgnJointMainLkIdById(wAcStratLink);
+			wStartNearSec = GetLinkRelatedPhySec(wStartNearLink);
+
+			/*获取终端相邻物理区段*/
+			wTmmNearLink = GetLinkTmnlJointMainLkById(wAcTerminLink);
+			wTmmNearSec = GetLinkRelatedPhySec(wTmmNearLink);
+
+			if (((wStartNearSec == basePhysec) && (wTmmNearSec == wPhySecId))
+				|| ((wStartNearSec == wPhySecId) && (wTmmNearSec == basePhysec)))
+			{
+				/*在跳转区段中找到跳转计轴*/
+				retAcId = pACBuff[jj];
+				break;
+			}
+		}
+	}
+	return retAcId;
+}
+
+/*
+* 功能描述：检查在二步间接物理区段中获取符合条件的跳转计轴ID
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec基准，wAdjPhySecId 直接相邻跳转区段,wSndPreSec一步间接跳转
+* 返回值  ：0未找到 >0 计轴ID
+*Create fan 20260410
+*/
+UINT16 GetSndTransitAcFromPreSce(const UINT16 wPhySecId, const UINT16 basePhysec, const UINT16 wAdjPhySecId, const UINT16 wSndPreSec)
+{
+	UINT16 retAcId = 0U;/*符合条件二步跳转计轴*/
+	UINT16 wAcStratLink = 0U; /*计轴始端link*/
+	UINT16 wAcTerminLink = 0U; /*计轴终端link*/
+	UINT8 chAcLinkSum = 0;
+	UINT16* pAclinkBuf = NULL;
+	UINT16 wFirstStartNearLink = 0U; /*第一跳转计轴始端相邻link*/
+	UINT16 wFirstTmmNearLink = 0U;/*第一跳转计轴终端相邻link*/
+	UINT16 wFirstStepAc = 0U;/*基准到一步间接中的跳转计轴*/
+	UINT16 wSndStepAc = 0U;/*直接相邻到二步间接中的跳转计轴*/
+	wFirstStepAc = GetTransitAcFromPreSec(wSndPreSec, basePhysec, wAdjPhySecId);
+	wSndStepAc = GetTransitAcFromPreSec(wPhySecId, wAdjPhySecId, wSndPreSec);
+	if ((0U != wFirstStepAc) && (0U != wSndStepAc))
+	{
+		chAcLinkSum = GetAxisLinkSum(wFirstStepAc);
+		pAclinkBuf = GetAxisLinkIdBuf(wFirstStepAc);
+		wAcStratLink = pAclinkBuf[0];
+		wAcTerminLink = pAclinkBuf[chAcLinkSum - (UINT8)1U];
+		/*获取始端相邻link*/
+		wFirstStartNearLink = GetLinkOrgnJointMainLkIdById(wAcStratLink);
+		/*获取终端相邻link*/
+		wFirstTmmNearLink = GetLinkTmnlJointMainLkById(wAcTerminLink);
+
+
+		/*获取第二跳转计轴的始端终端*/
+		chAcLinkSum = GetAxisLinkSum(wSndStepAc);
+		pAclinkBuf = GetAxisLinkIdBuf(wSndStepAc);
+		wAcStratLink = pAclinkBuf[0];
+		wAcTerminLink = pAclinkBuf[chAcLinkSum - (UINT8)1U];
+
+		/*是否相等*/
+		if ((wFirstStartNearLink == wAcStratLink)
+			|| (wFirstStartNearLink == wAcTerminLink)
+			|| (wFirstTmmNearLink == wAcStratLink)
+			|| (wFirstTmmNearLink == wAcTerminLink))
+		{
+			retAcId = wSndStepAc;
+		}
+		else
+		{
+			retAcId = 0U;
+		}
+		
+	}
+	return retAcId;
 }

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

@@ -26,7 +26,14 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	
+
+/*直接相邻区段检查条件计轴结构体*/
+typedef struct S_AdjacentSec_Condition_AcBuf
+{
+	UINT8 RelateAcNum;  /*条件计轴数量*/
+	UINT16 AcIdBuf[PHYSICAL_INCLUDE_AXIS_SUM_MAX];	/*条件计轴ID数组*/
+}NeighborSecConditionAcStruct;
+
 typedef struct S_PhysicalSectionConfigData
 {
     UINT16 PhysicalSectionId;      /*物理区段ID (配置字段)*/
@@ -36,6 +43,7 @@ typedef struct S_PhysicalSectionConfigData
 	UINT8 managedByZcFlag;         /*是否由ZC管辖(配置字段)*/
 	UINT8 PhySecType;              /*物理区段类型(无岔区段/有岔区段) (配置字段)*/
 	UINT8 LjkSecFlag;              /*列检库区段标志(非列检库区段/列检库区段) (配置字段)*/
+	UINT8 QcxSecFlag;              /*牵出线区段标志(非牵出线区段/牵出线区段) (配置字段)*/
 	UINT16 GdRelayId;              /*轨道继电器ID (配置字段)*/
 	UINT16 wGdRelayId2;            /*轨道继电器ID2 (配置字段) 迪斯尼*/
 	UINT16 RepGdRelayId;		/*复视轨道继电器ID*/
@@ -70,13 +78,16 @@ typedef struct S_PhysicalSectionConfigData
 	UINT8 chNearPhySecNum;  /*物理区段单位距离非直接相邻内物理区段数量*/
 	UINT32 wPhySecLen;			/*物理区段长度：关联最短计轴长度*/
 	UINT16 AdjacentPhySecBuf[PHYSEC_ADJACENT_SEC_SUM_MAX];  /*物理区段直接相邻物理区段数组*/
+	NeighborSecConditionAcStruct AdjacentSecAcData[PHYSEC_ADJACENT_SEC_SUM_MAX];/*直接相邻区段的检查计轴*/
 	UINT16 IndirectNearPhySecBuf[PHYSEC_INDIRECTNEAR_SEC_SUM_MAX];  /*单位距离内内间接邻近物理区段数组*/
+	NeighborSecConditionAcStruct TransitAcData[PHYSEC_INDIRECTNEAR_SEC_SUM_MAX];/*到间接相邻区段的跳转计轴*/
 	UINT8 chArbPossibleTag; /*是否能判Arb*/
 	UINT16 wIndexInAxle; /*在计轴系统中的索引*/
 } PhysicalSectionConfigDataStruct;
 
 
 
+
 typedef struct S_OC_PhysicalSectionConfigDataStruct
 {
 	UINT16 PhysicalSectionId;				/*物理区段ID(配置字段)*/
@@ -164,6 +175,15 @@ UINT8 GetPhySecType(const UINT16 phySectionId);
 */
 UINT8 GetPhySecLjkFlag(const UINT16 phySectionId);
 
+/*
+* 功能描述： 获取指定ID物理区段牵出线区段标志
+* 参数说明： const UINT16 phySectionId, 区段ID
+* 返回值  ： 0: 获取数据失败
+*			>0: 牵出线区段标志：0x55非牵出线 0xAA牵出线区段
+* Create fan 20260415
+*/
+UINT8 GetPhySecQcxFlag(const UINT16 phySectionId);
+
 /*
 * 功能描述： 获取指定ID物理区段轨道继电器ID
 * 参数说明： const UINT16 phySectionId, 物理区段ID    
@@ -457,11 +477,11 @@ UINT8 GetAdjacentPhySecNum(const UINT16 wPhySecId);
 UINT16* GetAdjacentPhySecBuf(const UINT16 wPhySecId);
 /*
 * 功能描述：检查物理区段已有邻近范围内有无该区段 无则添加
-* 参数说明： const UINT16 wPhySecId，UINT16 basePhysec
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec基准，wPrePhySecId 直接相邻跳转区段,wSndPreSec一步间接跳转
 * 返回值  ：CI_SUCCESS 新添加 CI_ERROR 已有
 *Create fan 20240822
 */
-UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec);
+UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec, const UINT16 wPrePhySecId, const UINT16 wSndPreSec);
 
 /*
 * 功能描述：获取物理区段范围内间接相邻区段数量
@@ -511,6 +531,71 @@ void SetPhyPossibleArbTag(const UINT16 wPhySecId, UINT8 chArbTag);
 * by cgh 20250415
 */
 UINT16 GetPhyIdByIndexInAxle(const UINT8 chAxleId, const UINT16 wIndexInAxle);
+/*
+* 功能描述：添加直接相邻区段检查计轴数据
+* 参数说明： const UINT16 wPhySecId 物理区段 UINT8 chIndex相邻区段索引 UINT16 AcId计轴ID
+* 返回值  ：无
+*Create fan 20260303
+*/
+void AddNeighborPhyConditionAc(const UINT16 wPhySecId, UINT8 chIndex, UINT16 AcId);
+
+/*
+* 功能描述： 获取指定ID物理区段的ARB防护范围区段的跳转计轴序列
+* 参数说明： const UINT16 phySectionId, 物理区段ID  UINT16 wNearSecID相邻区段
+* 返回值  ： 0: 获取数据失败
+*			>0: 计轴区段ID数组指针
+*Create fan 202604010
+*/
+UINT16* GetPhySecNearSecTransitAcBuf(const UINT16 phySectionId, const UINT16 wNearSecID);
+
+/*
+* 功能描述： 获取指定ID物理区段的ARB防护范围区段的跳转计轴数量
+* 参数说明： const UINT16 phySectionId, 物理区段ID  UINT16 wNearSecID相邻区段
+* 返回值  ： 0: 获取数据失败
+*			>0: 计轴区段ID数组指针
+*Create fan 202604010
+*/
+UINT8 GetPhySecNearSecTransitAcNum(const UINT16 phySectionId, const UINT16 wNearSecID);
+/*
+* 功能描述：检查间接相邻区段的上一跳转区段是否属于区段的直接相邻范围
+* 参数说明： const UINT16 wPhySecId，const UINT16 wPreSecId
+* 返回值  ：CI_SUCCESS 是 CI_ERROR否
+* Create fan 20260303
+*/
+UINT8 CheckPhySecIfAdjacent(const UINT16 wPhySecId, const UINT16 wPreSecId);
+
+/*
+* 功能描述：获取物理区段直接相邻区段条件计轴检查结果(是否可达)
+* 参数说明： const UINT16 wPhySecId UINT16 wNearSec 直接相邻区段
+* 返回值  ：直接相邻区段条件计轴检查结果 CI_ERROR不可达 CI_SUCCESS可达
+* Create fan 20260303
+*/
+UINT8 GetAdjacentPhySecAcCheck(const UINT16 wPhySecId, UINT16 wNearSec);
+
+/*
+* 功能描述：获取存在跳转计轴时 一步间隔相邻区段是否可达
+* 参数说明： constUINT16 wBasePhySec基准区段   wTransitAcId 跳转计轴区段
+* 返回值  ：CI_ERROR不可达 CI_SUCCESS可达
+* Create fan 20260410
+*/
+UINT8 GetTransitPhySecAcCheck(const UINT16 wBasePhySec , UINT16 wTransitAcId);
+
+
+/*
+* 功能描述：检查在物理区段中获取符合条件的跳转计轴ID
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec基准区段，wAdjPhySecId 间接区段的上一跳转区段
+* 返回值  ：CI_SUCCESS 新添加 CI_ERROR 已有
+*Create fan 20260410
+*/
+UINT16 GetTransitAcFromPreSec(const UINT16 wPhySecId, const UINT16 basePhysec, const UINT16 wPrePhySecId);
+
+/*
+* 功能描述：检查在二步间接物理区段中获取符合条件的跳转计轴ID
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec基准，wAdjPhySecId 直接相邻跳转区段,wSndPreSec一步间接跳转
+* 返回值  ：0未找到 >0 计轴ID
+*Create fan 20260410
+*/
+UINT16 GetSndTransitAcFromPreSce(const UINT16 wPhySecId, const UINT16 basePhysec, const UINT16 wAdjPhySecId, const UINT16 wSndPreSec);
 
 #ifdef __cplusplus
 }

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

@@ -41,6 +41,8 @@
 #define LOGSEC_RELATE_ESB_MAX  ((UINT8)0X04U)       /*定义逻辑区段关联紧急按钮数量最大值*//* add 20240410   fan*/
 
 #define QINXIAN_SWITCH_MAX_NUM  ((UINT8)0X16U)       /*定义侵限区段关联条件道岔的最大数量 add 20240607   LC */
+#define LOGSEC_RELATE_OVERLAP_SUM_MAX        ((UINT16)200)       /*定义逻辑区段关联保护区段数量最大值 add 20260330 mpt*/
+#define AXIS_RELATE_PRO_SW_SUM_MAX  ((UINT16)100)       /*定义计轴区段关联防护道岔数量最大值*/
 
 #define PHYSEC_ADJACENT_SEC_SUM_MAX  ((UINT8)15)       /*定义物理区段直接相邻物理区段最大个数*//* add 20240821   fan*/
 #define PHYSEC_INDIRECTNEAR_SEC_SUM_MAX  ((UINT8)100)       /*定义距离一定范围内间接邻近物理区段最大个数*//* add 20240821   fan*/
@@ -52,6 +54,9 @@
 /*列检库区段标识*/
 #define PHYSICAL_SECTION_LJK_NO             ((UINT8)0x55)    /*非列检库区段*/
 #define PHYSICAL_SECTION_LJK_YES            ((UINT8)0xaa)    /*列检库区段*/
+/*牵出线区段标识*/
+#define PHYSICAL_SECTION_QCX_NO             ((UINT8)0x55)    /*非牵出线区段*/
+#define PHYSICAL_SECTION_QCX_YES            ((UINT8)0xaa)    /*牵出线区段*/
 
 /*物理区段征用状态*/
 #define PHYSICAL_SECTION_USING_NO           ((UINT8)0x11)    /*未征用*/
@@ -364,4 +369,8 @@
 #define AXIS_SEC_CBTC_PROPERTY_YES        ((UINT8)0x55)    /*计轴区段具有CBTC区域属性（所有link均具有CBTC区域属性）*/
 #define AXIS_SEC_CBTC_PROPERTY_NO         ((UINT8)0xaa)    /*计轴区段不具有CBTC区域属性（存在link不具有CBTC区域属性）*/
 
+/*计轴区段列车安全位置覆盖标志*/
+#define AXIS_SECTION_SAFELOC_NO		      ((UINT8)0x55U)    /*无效*/
+#define AXIS_SECTION_SAFELOC_YES          ((UINT8)0xAAU)    /*有效*/
+
 #endif

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

@@ -19,7 +19,6 @@ SwitchDataStruct SwitchDataStru[SWITCH_SUM_MAX];   /*
 
 
 
-
 /*
 * 功能描述： 获取指定ID道岔数据
 * 参数说明： 
@@ -115,19 +114,19 @@ UINT8 GetSwitchLockStatus(const UINT16 switchId)
 
 /*
 * 功能描述： 设置指定ID道岔锁闭状态
-* 参数说明： 
+* 参数说明：
 *			 const UINT8 lockType,锁闭类型
 *			 const UINT16 pLockId,锁闭id
 *			 const UINT16 switchId, 道岔ID
 *			 const UINT8 lockCommand, 锁闭命令
-* 返回值  ：void   
+* 返回值  ：void
 */
-void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16 switchId, const UINT8 lockCommand)
+void SetSwitchLockStatus(const UINT8 pLockType, const UINT16 pLockId, const UINT16 switchId, const UINT8 lockCommand)
 {
 	UINT16 bufIndex = 0u;  /*数组下标*/
 	UINT8 retVal = CI_ERROR;
 	UINT8 switchLockStatus = 0u;
-	UINT16 ii =0u;/*游标*/
+	UINT16 ii = 0u;/*游标*/
 	UINT16 jj = 0u;/*游标*/
 	UINT16 kk = 0u;/*游标*/
 
@@ -146,244 +145,244 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 		switch (pLockType)
 		{
 		case SWITCH_PLOCKTYPE_DANSUO:/*锁闭类型为单锁*/
-			{
+		{
-				if (SWITCH_LOCK_DANSUO_SET == lockCommand )
+			if (SWITCH_LOCK_DANSUO_SET == lockCommand)
-				{/*设置单锁*/
+			{/*设置单锁*/
-					if ((SWITCH_LOCK_STATUS_PROTECT == switchLockStatus) || (SWITCH_LOCK_STATUS_DAP == switchLockStatus))
+				if ((SWITCH_LOCK_STATUS_PROTECT == switchLockStatus) || (SWITCH_LOCK_STATUS_DAP == switchLockStatus))
-					{
+				{
-						SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_DAP;        /*设置道岔单锁且防护锁闭状态*/
+					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_DAP;        /*设置道岔单锁且防护锁闭状态*/
-					}
-					else
-					{
-						SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_DANSUO;     /*设置道岔单锁状态*/
-					}
-					
-				}
-				else if (SWITCH_LOCK_DANSUO_CANCEL == lockCommand)
-				{/*取消单锁*/
-					if (SWITCH_LOCK_STATUS_PROTECT == switchLockStatus)
-					{
-						SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_PROTECT;    /*保持道岔防护锁闭状态*/
-					}
-					else if (SWITCH_LOCK_STATUS_DAP == switchLockStatus)
-					{
-						SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_PROTECT;    /*设置道岔防护锁闭状态*/
-					}
-					else
-					{
-						SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_NO;         /*设置道岔未锁闭状态*/
-					}
 				}
 				else
 				{
-					/*非法值不处理*/
+					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_DANSUO;     /*设置道岔单锁状态*/
 				}
-				retVal = CI_SUCCESS;
+
-				break;
 			}
+			else if (SWITCH_LOCK_DANSUO_CANCEL == lockCommand)
+			{/*取消单锁*/
+				if (SWITCH_LOCK_STATUS_PROTECT == switchLockStatus)
+				{
+					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_PROTECT;    /*保持道岔防护锁闭状态*/
+				}
+				else if (SWITCH_LOCK_STATUS_DAP == switchLockStatus)
+				{
+					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_PROTECT;    /*设置道岔防护锁闭状态*/
+				}
+				else
+				{
+					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_NO;         /*设置道岔未锁闭状态*/
+				}
+			}
+			else
+			{
+				/*非法值不处理*/
+			}
+			retVal = CI_SUCCESS;
+			break;
+		}
 		case SWITCH_PLOCKTYPE_ROUTE:/*锁闭类型为被进路防护锁闭*/
-			{				
+		{
-				if (SWITCH_LOCK_PROTECT_SET == lockCommand)
+			if (SWITCH_LOCK_PROTECT_SET == lockCommand)
-				{/*设置防护锁闭*/
+			{/*设置防护锁闭*/
-					findFlag = 0u;/*置未找到*/
+				findFlag = 0u;/*置未找到*/
-					emptyIndex = -1;/*空位索引*/
+				emptyIndex = -1;/*空位索引*/
-					/*查找被防护锁闭进路id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的进路数量*/
+				/*查找被防护锁闭进路id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的进路数量*/
-					for (ii=0U;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
+				for (ii = 0U; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
-					{
-						if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
-						{
-							if (0U == SwitchDataStru[bufIndex].PLockedRouteIdArr[ii])
-							{
-								emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
-							}
-						}
-
-						if (pLockId == SwitchDataStru[bufIndex].PLockedRouteIdArr[ii])
-						{/*找到被锁闭的id*/
-							findFlag = 1u;
-						}
-					}
-
-					if (0u == findFlag)
-					{/*没找到被锁闭id*/
-						if (emptyIndex >= 0)
-						{/*且空位存在*/
-							SwitchDataStru[bufIndex].PLockedRouteIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
-							SwitchDataStru[bufIndex].PLockedRouteNum++; /*被锁闭id数量增加1个*/
-						}
-						else
-						{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
-							debug_infor_printf((const)"Set switch id %d PLOCK by routeId %d fail,no empty space\n",bufIndex,pLockId);
-						}
-					}
-				}
-				else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
-				{/*取消防护锁闭*/
-					targetIndex = -1;/*目标索引*/
-					/*如果没找到，返回*/
-					/*找到，设为0，且把数量-1*/
-					for (ii=0;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
-					{
-						if (SwitchDataStru[bufIndex].PLockedRouteIdArr[ii] == pLockId)
-						{
-							targetIndex = (INT16)ii;
-							SwitchDataStru[bufIndex].PLockedRouteIdArr[ii] = 0U;/*设为0*/
-							break;
-						}
-					}
-
-					if (targetIndex >=0)/*找到了*/
-					{
-						if (SwitchDataStru[bufIndex].PLockedRouteNum > 0U)
-						{
-							SwitchDataStru[bufIndex].PLockedRouteNum--;/*减1处理*/
-						}
-					}
-
-				}
-				else
 				{
-					/*非法命令，不处理*/
+					if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
+					{
+						if (0U == SwitchDataStru[bufIndex].PLockedRouteIdArr[ii])
+						{
+							emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
+						}
+					}
+
+					if (pLockId == SwitchDataStru[bufIndex].PLockedRouteIdArr[ii])
+					{/*找到被锁闭的id*/
+						findFlag = 1u;
+					}
+				}
+
+				if (0u == findFlag)
+				{/*没找到被锁闭id*/
+					if (emptyIndex >= 0)
+					{/*且空位存在*/
+						SwitchDataStru[bufIndex].PLockedRouteIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
+						SwitchDataStru[bufIndex].PLockedRouteNum++; /*被锁闭id数量增加1个*/
+					}
+					else
+					{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
+						debug_infor_printf((const)"Set switch id %d PLOCK by routeId %d fail,no empty space\n", bufIndex, pLockId);
+					}
 				}
-				
-				
-				retVal = CI_SUCCESS;
-				break;
 			}
+			else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+			{/*取消防护锁闭*/
+				targetIndex = -1;/*目标索引*/
+				/*如果没找到，返回*/
+				/*找到，设为0，且把数量-1*/
+				for (ii = 0; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (SwitchDataStru[bufIndex].PLockedRouteIdArr[ii] == pLockId)
+					{
+						targetIndex = (INT16)ii;
+						SwitchDataStru[bufIndex].PLockedRouteIdArr[ii] = 0U;/*设为0*/
+						break;
+					}
+				}
+
+				if (targetIndex >= 0)/*找到了*/
+				{
+					if (SwitchDataStru[bufIndex].PLockedRouteNum > 0U)
+					{
+						SwitchDataStru[bufIndex].PLockedRouteNum--;/*减1处理*/
+					}
+				}
+
+			}
+			else
+			{
+				/*非法命令，不处理*/
+			}
+
+
+			retVal = CI_SUCCESS;
+			break;
+		}
 		case SWITCH_PLOCKTYPE_OVERLAP:/*锁闭类型为被保护区段防护锁闭*/
-			{
+		{
-				if (SWITCH_LOCK_PROTECT_SET == lockCommand)
+			if (SWITCH_LOCK_PROTECT_SET == lockCommand)
-				{/*设置防护锁闭*/
+			{/*设置防护锁闭*/
-					findFlag = 0u;/*置未找到*/
+				findFlag = 0u;/*置未找到*/
-					emptyIndex = -1;/*空位索引*/
+				emptyIndex = -1;/*空位索引*/
-					/*查找被防护锁闭保护区段id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的保护区段数量*/
+				/*查找被防护锁闭保护区段id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的保护区段数量*/
-					for (ii=0;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
+				for (ii = 0; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
-					{
-						if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
-						{
-							if (0u == SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii])
-							{
-								emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
-							}
-						}
-
-						if (pLockId == SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii])
-						{/*找到被锁闭的id*/
-							findFlag = 1u;
-						}
-					}
-
-					if (0u == findFlag)
-					{/*没找到被锁闭id*/
-						if (emptyIndex >= 0)
-						{/*且空位存在*/
-							SwitchDataStru[bufIndex].PLockedOverlapIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
-							SwitchDataStru[bufIndex].PLockedOverlapNum++; /*被锁闭id数量增加1个*/
-						}
-						else
-						{
-							debug_infor_printf((const)"Set switch id %d PLOCK by overlapId %d fail,no empty space\n",bufIndex,pLockId);
-						}
-					}
-				}
-				else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
-				{/*取消防护锁闭*/
-					targetIndex = -1;/*目标索引*/
-					/*如果没找到，返回*/
-					/*找到，设为0，且把数量-1*/
-					for (ii=0u;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
-					{
-						if (SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii] == pLockId)
-						{
-							targetIndex = (INT16)ii;
-							SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii] = 0U;/*设为0*/
-							break;
-						}
-					}
-
-					if (targetIndex >=0)/*找到了*/
-					{
-						if (SwitchDataStru[bufIndex].PLockedOverlapNum > 0U)
-						{
-							SwitchDataStru[bufIndex].PLockedOverlapNum--;/*减1处理*/
-						}
-					}
-
-				}
-				else
 				{
-					/*非法命令，不处理*/
+					if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
+					{
+						if (0u == SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii])
+						{
+							emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
+						}
+					}
+
+					if (pLockId == SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii])
+					{/*找到被锁闭的id*/
+						findFlag = 1u;
+					}
+				}
+
+				if (0u == findFlag)
+				{/*没找到被锁闭id*/
+					if (emptyIndex >= 0)
+					{/*且空位存在*/
+						SwitchDataStru[bufIndex].PLockedOverlapIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
+						SwitchDataStru[bufIndex].PLockedOverlapNum++; /*被锁闭id数量增加1个*/
+					}
+					else
+					{
+						debug_infor_printf((const)"Set switch id %d PLOCK by overlapId %d fail,no empty space\n", bufIndex, pLockId);
+					}
 				}
-				retVal = CI_SUCCESS;
-				break;
 			}
+			else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+			{/*取消防护锁闭*/
+				targetIndex = -1;/*目标索引*/
+				/*如果没找到，返回*/
+				/*找到，设为0，且把数量-1*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii] == pLockId)
+					{
+						targetIndex = (INT16)ii;
+						SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii] = 0U;/*设为0*/
+						break;
+					}
+				}
+
+				if (targetIndex >= 0)/*找到了*/
+				{
+					if (SwitchDataStru[bufIndex].PLockedOverlapNum > 0U)
+					{
+						SwitchDataStru[bufIndex].PLockedOverlapNum--;/*减1处理*/
+					}
+				}
+
+			}
+			else
+			{
+				/*非法命令，不处理*/
+			}
+			retVal = CI_SUCCESS;
+			break;
+		}
 		case SWITCH_PLOCKTYPE_NONROUTE:/*锁闭类型为被非进路防护锁闭*/
-			{
+		{
-				if (SWITCH_LOCK_PROTECT_SET == lockCommand)
+			if (SWITCH_LOCK_PROTECT_SET == lockCommand)
-				{/*设置防护锁闭*/
+			{/*设置防护锁闭*/
-					findFlag = 0u;/*置未找到*/
+				findFlag = 0u;/*置未找到*/
-					emptyIndex = -1;/*空位索引*/
+				emptyIndex = -1;/*空位索引*/
-					/*查找被防护非进路id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的非进路数量*/
+				/*查找被防护非进路id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的非进路数量*/
-					for (ii=0u;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
-					{
-						if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
-						{
-							if (0u == SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii])
-							{
-								emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
-							}
-						}
-
-						if (pLockId == SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii])
-						{/*找到被锁闭的id*/
-							findFlag = 1u;
-						}
-					}
-
-					if (0u == findFlag)
-					{/*没找到被锁闭id*/
-						if (emptyIndex >= 0)
-						{/*且空位存在*/
-							SwitchDataStru[bufIndex].PLockedNonRouteIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
-							SwitchDataStru[bufIndex].PLockedNonRouteNum++; /*被锁闭id数量增加1个*/
-						}
-						else
-						{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
-							debug_infor_printf((const)"Set switch id %d PLOCK by nonRouteId %d fail,no empty space\n",bufIndex,pLockId);
-						}
-					}
-				}
-				else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
-				{/*取消防护锁闭*/
-					targetIndex = -1;/*目标索引*/
-					/*如果没找到，返回*/
-					/*找到，设为0，且把数量-1*/
-					for (ii=0u;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
-					{
-						if (SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii] == pLockId)
-						{
-							targetIndex = (INT16)ii;
-							SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii] = 0;/*设为0*/
-							break;
-						}
-					}
-
-					if (targetIndex >=0)/*找到了*/
-					{
-						if (SwitchDataStru[bufIndex].PLockedNonRouteNum > 0U)
-						{
-							SwitchDataStru[bufIndex].PLockedNonRouteNum--;/*减1处理*/
-						}
-					}
-
-				}
-				else
 				{
-					/*非法命令，不处理*/
+					if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
+					{
+						if (0u == SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii])
+						{
+							emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
+						}
+					}
+
+					if (pLockId == SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii])
+					{/*找到被锁闭的id*/
+						findFlag = 1u;
+					}
+				}
+
+				if (0u == findFlag)
+				{/*没找到被锁闭id*/
+					if (emptyIndex >= 0)
+					{/*且空位存在*/
+						SwitchDataStru[bufIndex].PLockedNonRouteIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
+						SwitchDataStru[bufIndex].PLockedNonRouteNum++; /*被锁闭id数量增加1个*/
+					}
+					else
+					{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
+						debug_infor_printf((const)"Set switch id %d PLOCK by nonRouteId %d fail,no empty space\n", bufIndex, pLockId);
+					}
 				}
-				retVal = CI_SUCCESS;
-				break;
 			}
+			else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+			{/*取消防护锁闭*/
+				targetIndex = -1;/*目标索引*/
+				/*如果没找到，返回*/
+				/*找到，设为0，且把数量-1*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii] == pLockId)
+					{
+						targetIndex = (INT16)ii;
+						SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii] = 0;/*设为0*/
+						break;
+					}
+				}
+
+				if (targetIndex >= 0)/*找到了*/
+				{
+					if (SwitchDataStru[bufIndex].PLockedNonRouteNum > 0U)
+					{
+						SwitchDataStru[bufIndex].PLockedNonRouteNum--;/*减1处理*/
+					}
+				}
+
+			}
+			else
+			{
+				/*非法命令，不处理*/
+			}
+			retVal = CI_SUCCESS;
+			break;
+		}
 		case SWITCH_PLOCKTYPE_LOGROUTE:/*锁闭类型为被逻辑进路防护锁闭*/
 		{
 			SetSwitchLockStaUseByLogRoute(pLockId, switchId, lockCommand);
@@ -391,29 +390,96 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 			break;
 		}
 		case SWITCH_PLOCKTYPE_NOROUTE_NOOVERLAP_NONONROUTE:/*解除道岔防护锁闭*/
-			{/*解除道岔防护锁闭，解除被进路/保护区段/非进路锁闭，清所有ID*/
+		{/*解除道岔防护锁闭，解除被进路/保护区段/非进路锁闭，清所有ID*/
-				SwitchDataStru[bufIndex].PLockedRouteNum = 0u;
+			SwitchDataStru[bufIndex].PLockedRouteNum = 0u;
-				SwitchDataStru[bufIndex].PLockedOverlapNum = 0u;
+			SwitchDataStru[bufIndex].PLockedOverlapNum = 0u;
-				SwitchDataStru[bufIndex].PLockedNonRouteNum = 0u;
+			SwitchDataStru[bufIndex].PLockedNonRouteNum = 0u;
-				SwitchDataStru[bufIndex].PLockedLogRouteNum = 0u;
+			SwitchDataStru[bufIndex].PLockedLogRouteNum = 0u;
-				for (ii=0u;ii<SWITCH_MAX_PROTECT_LOCKED_NUM;ii++)
+			for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+			{
+				SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii] = 0u;
+				SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii] = 0u;
+				SwitchDataStru[bufIndex].PLockedRouteIdArr[ii] = 0u;
+				SwitchDataStru[bufIndex].PLockedLogRouteIdArr[ii] = 0u;
+			}
+
+			retVal = CI_SUCCESS;
+		}
+		break;
+		case SWITCH_PLOCKTYPE_AXISSEC:/*锁闭类型为被计轴区段防护锁闭*/
+		{
+			if (SWITCH_LOCK_PROTECT_SET == lockCommand)
+			{/*设置防护锁闭*/
+				findFlag = 0u;/*置未找到*/
+				emptyIndex = -1;/*空位索引*/
+				/*查找被防护计轴区段id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的计轴区段数量*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
 				{
-					SwitchDataStru[bufIndex].PLockedNonRouteIdArr[ii] = 0u;
+					if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
-					SwitchDataStru[bufIndex].PLockedOverlapIdArr[ii] = 0u;
+					{
-					SwitchDataStru[bufIndex].PLockedRouteIdArr[ii] = 0u;
+						if (0u == SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii])
-					SwitchDataStru[bufIndex].PLockedLogRouteIdArr[ii] = 0u;
+						{
+							emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
+						}
+					}
+
+					if (pLockId == SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii])
+					{/*找到被锁闭的id*/
+						findFlag = 1u;
+					}
 				}
 
-				retVal = CI_SUCCESS;
+				if (0u == findFlag)
+				{/*没找到被锁闭id*/
+					if (emptyIndex >= 0)
+					{/*且空位存在*/
+						SwitchDataStru[bufIndex].PLockedAxisSecIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
+						SwitchDataStru[bufIndex].PLockedAxisSecNum++; /*被锁闭id数量增加1个*/
+					}
+					else
+					{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
+						debug_infor_printf((const)"Set switch id %d PLOCK by axis %d fail,no empty space\n", bufIndex, pLockId);
+					}
+				}
 			}
-			break;
+			else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
-		default:
+			{/*取消防护锁闭*/
+				targetIndex = -1;/*目标索引*/
+				/*如果没找到，返回*/
+				/*找到，设为0，且把数量-1*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii] == pLockId)
+					{
+						targetIndex = (INT16)ii;
+						SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii] = 0;/*设为0*/
+						break;
+					}
+				}
+
+				if (targetIndex >= 0)/*找到了*/
+				{
+					if (SwitchDataStru[bufIndex].PLockedAxisSecNum > 0U)
+					{
+						SwitchDataStru[bufIndex].PLockedAxisSecNum--;/*减1处理*/
+					}
+				}
+
+			}
+			else
 			{
-				/*类型非法，置返回标志错误*/
+				/*非法命令，不处理*/
-				retVal = CI_ERROR;
-				break;
 			}
-			
+			retVal = CI_SUCCESS;
+			break;
+		}
+		default:
+		{
+			/*类型非法，置返回标志错误*/
+			retVal = CI_ERROR;
+			break;
+		}
+
 		}
 		if (CI_SUCCESS == retVal)
 		{
@@ -423,7 +489,7 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 				(SWITCH_LOCK_STATUS_DAP == SwitchDataStru[bufIndex].LockStatus))/*道岔状态包含单锁*/
 			{
 				if (SwitchDataStru[bufIndex].PLockedNonRouteNum + SwitchDataStru[bufIndex].PLockedOverlapNum +
-					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStru[bufIndex].PLockedLogRouteNum > 0u)
+					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStru[bufIndex].PLockedLogRouteNum + SwitchDataStru[bufIndex].PLockedAxisSecNum > 0u)
 				{/*被防护锁闭的设备数目大于0*/
 					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_DAP;
 				}
@@ -442,7 +508,7 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 			else
 			{/*不包含单锁*/
 				if (SwitchDataStru[bufIndex].PLockedNonRouteNum + SwitchDataStru[bufIndex].PLockedOverlapNum +
-					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStru[bufIndex].PLockedLogRouteNum > 0u)
+					SwitchDataStru[bufIndex].PLockedRouteNum + SwitchDataStru[bufIndex].PLockedLogRouteNum + SwitchDataStru[bufIndex].PLockedAxisSecNum > 0u)
 				{/*被防护锁闭的设备数目大于0*/
 					SwitchDataStru[bufIndex].LockStatus = SWITCH_LOCK_STATUS_PROTECT;
 				}

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

@@ -82,11 +82,15 @@ typedef struct S_SwitchDataStruct
 	UINT8 chSwitchJichaState; /*道岔挤岔状态*/
 	UINT8 cSwitchUsingState;  /*道岔征用状态：0x11：未征用，0x22：征用，0x44：申请征用，0x88：申请取消征用*/
 	UINT32 SwitchCollTolerateCycNum; /*道岔采集四开容忍周期*/
+	UINT8 PLockedAxisSecNum;/*被防护锁闭的计轴区段id数量，只能在本文件使用*/
+	UINT16 PLockedAxisSecIdArr[SWITCH_MAX_PROTECT_LOCKED_NUM];/*被防护锁闭的计轴区段id数组，只能在本文件使用*/
+
 } SwitchDataStruct;
 
+
+
 /*******************************全局变量声明*******************************/
 extern SwitchDataStruct SwitchDataStru[SWITCH_SUM_MAX];   /*定义道岔数据结构体*/
-
 /*
 * 功能描述： 获取指定ID道岔数据
 * 参数说明： 

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

@@ -34,7 +34,7 @@
 #define SWITCH_LOCK_STATUS_DANSUO	    ((UINT8)0x5a)    /*데傑*/
 #define SWITCH_LOCK_STATUS_PROTECT	    ((UINT8)0xa5)    /*렝빱傑균*/
 #define SWITCH_LOCK_STATUS_DAP	        ((UINT8)0xaa)    /*데傑할렝빱傑균*/
-
+#define SWITCH_PLOCKTYPE_AXISSEC	    ((UINT8)0x7)    /*被计轴区段防护锁闭*/
 /*돛뀄傑균쭉서榴檄(쏭痰黨럽웩)*/
 #define SWITCH_LOCK_STATUS_DANSUO_NO	((UINT8)0x01)    /*灌데傑*/
 #define SWITCH_LOCK_STATUS_PROTECT_NO   ((UINT8)0x10)    /*灌렝빱傑균*/

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

@@ -61,7 +61,7 @@
 /*版本号*/
 #define VER_MAIN_SUBCI_CI_CID            ((UINT8)22)   /*子系统主版本号*/
 #define VER_SUB_SUBCI_CI_CID			 ((UINT8)0)	/*子系统子版本号*/
-#define VER_BRUNCH_CI_CID			     ((UINT8)2)	/*分支版本号..........主线填0....分支填1 调试填2 */
+#define VER_BRUNCH_CI_CID			     ((UINT8)6)	/*分支版本号..........主线填0....分支填1 调试填2 */
 #define VER_RETURN_SUBCI_CI_CID			 ((UINT8)1)	/*子系统回归版本号*/
 
 #ifdef SCADE_MODE
@@ -76,7 +76,7 @@
 #define VER_SOFT_PRODUCT            ((UINT8)40) /*产品编号*/
 #define VER_SOFT_MODUAL_APP             ((UINT8)1)  /*模块编号*/
 #define VER_SOFT_MIANVERSION        ((UINT8)22)  /*主版本号*/
-#define VER_SOFT_SUBVERSION         ((UINT8)8) /*子版本号*/
+#define VER_SOFT_SUBVERSION         ((UINT8)22) /*子版本号*/
 
 #endif
 
@@ -84,7 +84,7 @@
 #define VER_1_PUBLIC_FS_1            ((UINT8)30)
 #define VER_1_PUBLIC_FS_2            ((UINT8)21)
 #define VER_1_PUBLIC_FS_3            ((UINT8)0)
-#define VER_1_PUBLIC_FS_4            ((UINT8)0)
+#define VER_1_PUBLIC_FS_4            ((UINT8)2)
 
 #define VER_2_PUBLIC_FS_1            ((UINT8)0)
 #define VER_2_PUBLIC_FS_2            ((UINT8)0)
@@ -99,7 +99,7 @@
 
 /*可兼容的私有数据结构版本号*/
 #define VER_1_PRIVATE_FS_1            ((UINT8)44)
-#define VER_1_PRIVATE_FS_2            ((UINT8)1)
+#define VER_1_PRIVATE_FS_2            ((UINT8)3)
 
 #define VER_2_PRIVATE_FS_1            ((UINT8)0xFF)
 #define VER_2_PRIVATE_FS_2            ((UINT8)0xFF)

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

@@ -111,7 +111,6 @@ UINT32 dwArbNearSecNoUtCount = 0U;		/*ARB
 UINT32 dwNonReturnBtnErrEnsureTime = 0U;/*无人折返按钮故障判断周期数*/
 UINT32 dwOcCollTolerateCount = 0U;  /*OC采集容忍周期数*/
 UINT8 gCTFlyingRedunCount = 0u;
-UINT16 StationTrackDistance = 0U; /*公共数据-站台追踪时，列车间隔距离（cm）*/
 UINT32 LineMinTrainLength = 0U; /*公共数据-线路最小车长*/
 CiOcRelateion CiOcRelationArr[CI_SUM_MAX];/*ci oc关系数组*/
 
@@ -323,7 +322,6 @@ void SystemParaTimeToCycleCount(void)
 	paraVal = GetSystemParaValue(ARB_CHECK_ALXE_TIME); 
 	dwArbNearSecNoUtCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*ARB区段检查相邻区段上次UT占用经过时间  (配置单位ms)*/
 
-	StationTrackDistance = SystemParameterStruNew.StationTrackDistance;        /*公共数据-站台追踪时，列车间隔距离（cm）*/
 	LineMinTrainLength = SystemParameterStruNew.dwLineMinTrainLength;        /*公共数据-线路最小车长*/
 
 	paraVal = GetSystemParaValue(NONRETURN_BTN_ERR_ENSURE_TIME);
@@ -1257,17 +1255,6 @@ UINT16 GetSigCrossMaxLen(void)
 	return wSigCrossMaxLen;
 }
 
-/*
-* 功能描述： 获取退行防护最大距离
-* 参数说明： void
-* 返回值  ： UINT32
-* 创建    ：qw.liu 2022-03-03
-*/
-UINT16 GetBackProtectMaxLen(void)
-{
-
-	return StationTrackDistance;
-}
 
 /*
 * 功能描述： 获取线路最小车长

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

@@ -97,6 +97,7 @@ extern "C" {
 #define FUNC_LEADROUTE_ESB_CHECK                        ((UINT8)68)		  /*引导进路是否检查ESB状态(0x55:不检查;0xAA:检查)*/
 #define FUNC_SWITCH_ZX_ALLCLOSE_USEBLUE                 ((UINT8)69)		  /*杭德需求：正线灭灯均亮蓝灯开关：0xAA打开 0x55关闭*/
 #define FUNC_NVRAM_TRAIN_FlYING_OVER                    ((UINT8)70)		  /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
+#define FUNC_REOPRN_SET_NEAR                            ((UINT8)71)		  /*重开信号是否记忆进路接近锁闭状态开关：0xAA-重开后默认设置接近 0x55-重开后根据接近区段占用状态设置接近/未接近*/
 
 
 #define CiSum_ID						((UINT16)1)/*实际联锁集中站数量 编号*/
@@ -1006,13 +1007,6 @@ UINT16 GetSigLightUpExAxleSecLen(void);
 */
 UINT16 GetSigCrossMaxLen(void);
 
-/*
-* 功能描述： 获取退行防护最大距离
-* 参数说明： void
-* 返回值  ： UINT32
-* 创建    ：qw.liu 2022-03-03
-*/
-UINT16 GetBackProtectMaxLen(void);
 
 /*
 * 功能描述： 获取线路最小车长

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

@@ -2521,10 +2521,15 @@ static void CalTrainSafePosition(void)
 	UINT8 chResult = CI_ERROR;
 	UINT32 dwTailDistance = 0U;/*退行距离*/
 	UINT8 chTrainIsSwTrackFlag = CI_ERROR;/*列车休眠唤醒轨标志*/
-
+	ELM_TrainSafeLocStruct strTrainSafeLoc = { 0U };    /*列车安全位置*/
-	wTailDis = GetBackProtectMaxLen();
+	UINT8 ii = 0U;
+	UINT8 cSafeLocRelAcNum = 0U;  /*安全位置覆盖的计轴区段数量*/
+	UINT16 szSafeLocRelAcId[SECTION_IN_ENVELOPE_SUM_MAX] = { 0U };      /*安全位置覆盖的计轴区段ID*/
 	
-										   /*遍历所有列车*/
+	/*计算列车安全位置前，周期清除计轴区段列车安全位置覆盖标志为无效*/
+	ClearAxisTXSafeLocFlag();
+
+	/*遍历所有列车*/
 	for (trainCycle = 0u; trainCycle < TRAIN_SUM_MAX; trainCycle++)
 	{
 		wTrainId = GetTrainId(trainCycle);
@@ -2583,6 +2588,7 @@ static void CalTrainSafePosition(void)
 				/*by cgh 20240417 列车安全位置计算，当判断列车速度方向向后且非停准停稳，加退行包络不区分站台区间；*/
 				if ((TRAIN_SPEED_FRONT != chTrainSpeedDir) && (TRAIN_SS_YES != chSss))
 				{
+					wTailDis = strTrainInfo.StationTrackDistance;
 					if (wTailDis < (UINT32)dwHeadDistance)
 					{
 						/* 最大退行防护距离 */
@@ -2623,7 +2629,20 @@ static void CalTrainSafePosition(void)
 				}
 				else
 				{
-					;
+					/*安全位置更新后，根据列车安全位置设置计轴区段列车安全位置覆盖标志为有效（该标志用于ARB连续占用判断）*/
+					chResult = elm_PrepareTrainSafeLoc(wTrainId, &strTrainSafeLoc);  /*获取列车安全位置*/
+					if (CI_SUCCESS == chResult)
+					{
+						cSafeLocRelAcNum = elm_PrepareACBtwPoints(strTrainSafeLoc.startPos, strTrainSafeLoc.endPos, szSafeLocRelAcId);  /*获取列车安全位置包含的计轴区段*/
+						for (ii = 0U; ii < cSafeLocRelAcNum; ii++)
+						{
+							SetAxisTXSafeLocFlag(szSafeLocRelAcId[ii], AXIS_SECTION_SAFELOC_YES);  /*设置对应计轴区段列车安全位置覆盖标志为有效*/
+						}
+					}
+					else
+					{
+						/*获取列车安全位置失败，不处理*/
+					}					
 				}
 			}
 			else
@@ -7143,7 +7162,7 @@ UINT8 TrainResAndDirCheck(const UINT16 wTrainId, const UINT8 cQueryDir, const UI
 			}
 			else
 			{
-				SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_RES, 0U, cSendLevel);
+				SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_RES, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 				/*不处理*/
 			}
 

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

@@ -152,10 +152,10 @@
 
 #define TRAIN_ABL_LOGSEC_SUM			100U					/*ABL列车脚下包含的进路内的逻辑区段数量*/
 #define TRAIN_ABL_RETURNLOGSEC_SUM		10U						/*ABL列车查询范围内的折返逻辑区段数量*/
-#define TRAIN_ABL_SPKS_SUM				20U						/*ABL列车查询范围内的SPKS数量*/
+#define TRAIN_ABL_SPKS_SUM				30U						/*ABL列车查询范围内的SPKS数量*/
 #define TRAIN_ABL_PSD_SUM				10U						/*ABL列车查询范围内的PSD数量*/
 #define TRAIN_ABL_ESB_SUM				10U						/*ABL列车查询范围内的ESB数量*/
-#define TRAIN_ABL_SWITCH_SUM			100U						/*ABL列车查询范围内的道岔数量*/
+#define TRAIN_ABL_SWITCH_SUM			100U					/*ABL列车查询范围内的道岔数量*/
 #define TRAIN_ABL_PROSEC_SUM			20U						/*ABL列车查询范围内的保护区段数量*/
 #define TRAIN_ABL_XIANSUSEC_SUM			100U					/*ABL列车查询范围内的限速区段数量*/
 #define TRAIN_ABL_FLOODGATE_SUM			10U						/*ABL列车查询范围内的防淹门数量*/

TSCP/src/DRV/imx8_drv_gpio.c

@@ -9,51 +9,20 @@ static volatile uintptr_t gpio_base_4;
 static volatile uintptr_t gpio_base_5;
 
 static uintptr_t tbase;
-static volatile unsigned int cnt = 0;
+static volatile unsigned int cnt;
 static int val;
 static pthread_t timer_thread;
-static pthread_t gpioFeedbackIrq_thread;
-static pthread_t gpioChanAIrq_thread;
-static pthread_t gpioChanBIrq_thread;
 static struct sigevent event;
 static intrspin_t spinner;
 
-static struct sigevent gpioFeedbackIrqEvent = {0};
+char drv_vsr[4] = {93u, 8u, 0u, 9u};
-static struct sigevent gpioChanAIrqEvent = {0};
-static struct sigevent gpioChanBIrqEvent = {0};
-static uint32_t irqCnt[3U] = {0};
-
-
-/*AB Sync*/
-static volatile uint8_t s_isABSyncStart = 0u;
-static volatile uint8_t s_ECapPause[3u] = {0u};//采集开关控制
-static volatile uint32_t s_ABSynDuty = 0u;//定义双系心跳信号输出的占空比：0.5--对应输出是50%
-static volatile struct SCapInfo s_CapInfo[3u] = {0U};
-static volatile ABSynMsgType g_userSetSyncMsgType = ABSynMsgType_0;
-
-static float sSyncMsgErrInfo[ABSynMsgType_MAX] = {0.0f};
-
-static void calculate(uint8_t index,float *Duty,float *Period,uint32_t* pPulseCnt);
-static ABSynMsgType drvPWMAnalyze(float Duty,float Period);
-static void pulseCount(uint8_t index);
-static void drvGetABSyn(float *Duty,float *Period,uint32_t* pPulseCnt);
-static void Task_ABSyncPulse(void);
-
-void* gpioChanAIrq( void * arg);
-const struct sigevent *gpioChanAIrq_handler (void *not_used, int id);
-void* gpioChanBIrq( void * arg);
-const struct sigevent *gpioChanBIrq_handler (void *not_used, int id);
-void* gpioFeedbackIrq( void * arg);
-const struct sigevent *gpioFeedbackIrq_handler (void *not_used, int id);
-
-char drv_vsr[4] = {93, 8, 0, 30};
 
 /*GPIO init*/
 int imx8_gpio_init(void)
 {
 
 	int ret = 0;
-	gpio_base_0 = mmap_device_io((size_t)IMX_GPIO_SIZE, (uint64_t)IMX_GPIO0_BASE);
+	gpio_base_0 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO0_BASE);
 	if(gpio_base_0 == MAP_DEVICE_FAILED)
 	{
 		perror("Can't map device base 0 I/O");
@@ -64,7 +33,7 @@ int imx8_gpio_init(void)
 
 	}
 
-	gpio_base_1 = mmap_device_io((size_t)IMX_GPIO_SIZE, (uint64_t)IMX_GPIO1_BASE);
+	gpio_base_1 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO1_BASE);
 	if(gpio_base_1 == MAP_DEVICE_FAILED)
 	{
 		perror("Can't map device base 1 I/O");
@@ -75,7 +44,7 @@ int imx8_gpio_init(void)
 
 	}
 
-	gpio_base_2 = mmap_device_io((size_t)IMX_GPIO_SIZE, (uint64_t)IMX_GPIO2_BASE);
+	gpio_base_2 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO2_BASE);
 	if(gpio_base_2 == MAP_DEVICE_FAILED)
 	{
 		perror("Can't map device base 2 I/O");
@@ -86,7 +55,7 @@ int imx8_gpio_init(void)
 
 	}
 
-	gpio_base_3 = mmap_device_io((size_t)IMX_GPIO_SIZE, (uint64_t)IMX_GPIO3_BASE);
+	gpio_base_3 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO3_BASE);
 	if(gpio_base_3 == MAP_DEVICE_FAILED)
 	{
 		perror("Can't map device base 3 I/O");
@@ -97,7 +66,7 @@ int imx8_gpio_init(void)
 
 	}
 
-	gpio_base_4 = mmap_device_io((size_t)IMX_GPIO_SIZE, (uint64_t)IMX_GPIO4_BASE);
+	gpio_base_4 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO4_BASE);
 	if(gpio_base_4 == MAP_DEVICE_FAILED)
 	{
 		perror("Can't map device base 4 I/O");
@@ -108,7 +77,7 @@ int imx8_gpio_init(void)
 
 	}
 
-	gpio_base_5 = mmap_device_io((size_t)IMX_GPIO_SIZE, (uint64_t)IMX_GPIO5_BASE);
+	gpio_base_5 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO5_BASE);
 	if(gpio_base_5 == MAP_DEVICE_FAILED)
 	{
 		perror("Can't map device base 5 I/O");
@@ -684,6 +653,7 @@ const struct sigevent *handler (void *not_used, int id)
 void* timer( void * arg)
 {
 	int ret = 0;
+
     ret = ThreadCtl (_NTO_TCTL_IO, 0);
     SIGEV_INTR_INIT (&event);
 
@@ -709,9 +679,6 @@ void* timer( void * arg)
 		ret = InterruptWait(0, 0);
 		ret = InterruptUnmask(IMX_GPT0_IRQ, val);
     }
-
-    /*you will never reach here*/
-    return NULL;
 }
 
 /*create 8khz timer*/
@@ -739,20 +706,10 @@ int imx8_create_timer_pthread(void)
 /*25% timer irq function*/
 const struct sigevent *handler_25 (void *not_used, int id)
 {
-	unsigned int cpuid = 0;
 
 	cnt++;
-	InterruptLock( &spinner );
 
-	cpuid = imx8_read_cpuid();
+	InterruptLock( &spinner );
-	if (1U == cpuid)
-	{
-		Task_ABSyncPulse();
-	}
-	else
-	{
-		/*do nothing*/
-	}
 
 	if((cnt%(uint32_t)4) == (uint32_t)0)
 	{
@@ -806,9 +763,6 @@ void* timer_25( void * arg)
 		ret = InterruptUnmask(IMX_GPT0_IRQ, val);
     }
 
-    /*you will never reach here*/
-    ret = NULL;
-    return ret;
 
 }
 
@@ -834,6 +788,7 @@ int imx8_create_timer_pthread_25(void)
 }
 /************************************************************************/
 
+
 int imx8_gpio_release(void)
 {
 	int ret = 0;
@@ -905,715 +860,3 @@ int imx8_gpio_release(void)
 
 	return ret;
 }
-
-const struct sigevent *gpioFeedbackIrq_handler (void *not_used, int id)
-{
-	if (NULL == not_used)
-	{
-		return &gpioFeedbackIrqEvent;
-	}
-	uint8_t index = *(uint8_t*)not_used;
-	InterruptLock( &spinner );
-	irqCnt[index]++;
-	pulseCount(index);
-	InterruptUnlock( &spinner );
-    return &gpioFeedbackIrqEvent;
-}
-
-void* gpioFeedbackIrq( void * arg)
-{
-	int feedval = 0;
-	uint8_t index = 2u;
-	uint32_t regVal = 0u;
-
-    (void)ThreadCtl (_NTO_TCTL_IO, NULL);
-
-	/*disable gpio irq*/
-    regVal = (in32(gpio_base_3 + IMX_GPIO_IMR) & (uint32_t)~(1UL << 26U));
-	out32(gpio_base_3 + IMX_GPIO_IMR, regVal);
-	/*config gpio irq*/
-	/*dir is input*/
-	regVal = (in32(gpio_base_3 + IMX_GPIO_GDIR) &  (uint32_t)~(1UL << 26U));
-	out32(gpio_base_3 + IMX_GPIO_GDIR, regVal);
-	/*select trigger way--rising edge sensitive*/
-	regVal = (in32(gpio_base_3 + IMX_GPIO_ICR2) | (uint32_t)(2UL << 20U));
-	out32(gpio_base_3 + IMX_GPIO_ICR2, regVal);
-	/*clear isr reg*/
-	regVal = (in32(gpio_base_3 + IMX_GPIO_ISR) | (uint32_t)(1UL << 26U));
-	out32(gpio_base_3 + IMX_GPIO_ISR, regVal);
-	/*reg intr service*/
-    SIGEV_INTR_INIT(&gpioFeedbackIrqEvent);
-    feedval = InterruptAttach(666, gpioFeedbackIrq_handler, (const void*)&index, 1,_NTO_INTR_FLAGS_TRK_MSK);
-#if 0
-	printf("gpio 3_26 irq init finished\n");
-	printf("gpio3 IMR val is %x\n",in32(gpio_base_3 + IMX_GPIO_IMR));
-	printf("gpio3 ISR val is %x\n",in32(gpio_base_3 + IMX_GPIO_ISR));
-	printf("gpio3 GDIR val is %x\n",in32(gpio_base_3 + IMX_GPIO_GDIR));
-	printf("gpio3 ICR2 val is %x\n",in32(gpio_base_3 + IMX_GPIO_ICR2));
-#endif
-	/*enable gpio irq*/
-	regVal = (in32(gpio_base_3 + IMX_GPIO_IMR) | (uint32_t)(1UL << 26U));
-	out32(gpio_base_3 + IMX_GPIO_IMR, regVal);
-
-
-    while(1)
-    {
-		(void)InterruptWait(0, NULL);
-		(void)InterruptUnmask(666, feedval);
-    }
-
-    /*you will never reach here*/
-    return NULL;
-
-}
-
-
-
-const struct sigevent *gpioChanBIrq_handler (void *not_used, int id)
-{
-	if (NULL == not_used)
-	{
-		return &gpioChanBIrqEvent;
-	}
-	uint8_t index = *(uint8_t*)not_used;
-	InterruptLock( &spinner );
-	irqCnt[index]++;
-	pulseCount(index);
-	InterruptUnlock( &spinner );
-    return &gpioChanBIrqEvent;
-}
-
-void* gpioChanBIrq( void * arg)
-{
-	int chanBval = 0;
-	uint8_t index = 1u;
-	uint32_t regVal = 0u;
-
-    (void)ThreadCtl (_NTO_TCTL_IO, NULL);
-
-	/*disable gpio irq*/
-    regVal = (in32(gpio_base_4 + IMX_GPIO_IMR) & (uint32_t)~(1UL << 2U));
-	out32(gpio_base_4 + IMX_GPIO_IMR, regVal);
-	/*config gpio0_12 irq*/
-	/*dir is input*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_GDIR) & (uint32_t)~(1UL << 2U));
-	out32(gpio_base_4 + IMX_GPIO_GDIR, regVal);
-	/*select trigger way--rising edge sensitive*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_ICR1) | (uint32_t) (2UL << 4U));
-	out32(gpio_base_4 + IMX_GPIO_ICR1, regVal);
-	/*clear isr reg*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_ISR) | (uint32_t)(1UL << 2U));
-	out32(gpio_base_4 + IMX_GPIO_ISR, regVal);
-	/*reg intr service*/
-    SIGEV_INTR_INIT(&gpioChanBIrqEvent);
-    /*This step maybe enable the IMR?*/
-    chanBval = InterruptAttach(674, gpioChanBIrq_handler, (const void*)&index, 1,_NTO_INTR_FLAGS_TRK_MSK);
-#if 0
-	printf("Chan B(4_2) irq init finished\n");
-	printf("gpio4 IMR val is %x\n",in32(gpio_base_4 + IMX_GPIO_IMR));
-	printf("gpio4 ISR val is %x\n",in32(gpio_base_4 + IMX_GPIO_ISR));
-	printf("gpio4 GDIR val is %x\n",in32(gpio_base_4 + IMX_GPIO_GDIR));
-	printf("gpio4 ICR1 val is %x\n",in32(gpio_base_4 + IMX_GPIO_ICR1));
-#endif
-	/*enable gpio irq*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_IMR) | (uint32_t)(1UL << 2U));
-	out32(gpio_base_4 + IMX_GPIO_IMR, regVal);
-
-
-    while(1)
-    {
-		(void)InterruptWait(0, NULL);
-		(void)InterruptUnmask(674, chanBval);
-    }
-
-    /*you will never reach here*/
-    return NULL;
-}
-
-
-const struct sigevent *gpioChanAIrq_handler (void *not_used, int id)
-{
-	if (NULL == not_used)
-	{
-		return &gpioChanAIrqEvent;
-	}
-	uint8_t index = *(uint8_t*)not_used;
-	InterruptLock( &spinner );
-	irqCnt[index]++;
-	pulseCount(index);
-	InterruptUnlock( &spinner );
-    return &gpioChanAIrqEvent;
-}
-
-void* gpioChanAIrq( void * arg)
-{
-	int chanAval = 0;
-	uint8_t index = 0u;
-	uint32_t regVal = 0u;
-
-    (void)ThreadCtl (_NTO_TCTL_IO, NULL);
-
-	/*disable gpio irq*/
-    regVal = in32(gpio_base_4 + IMX_GPIO_IMR) & (uint32_t)~(1UL << 1U);
-	out32(gpio_base_4 + IMX_GPIO_IMR, regVal);
-	/*config gpio0_9 irq*/
-	/*dir is input*/
-	regVal = in32(gpio_base_4 + IMX_GPIO_GDIR) &  (uint32_t)~(1UL << 1U);
-	out32(gpio_base_4 + IMX_GPIO_GDIR,regVal);
-	/*select trigger way--rising edge sensitive*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_ICR1) | (uint32_t)(2UL << 2U));
-	out32(gpio_base_4 + IMX_GPIO_ICR1, regVal);
-	/*clear isr reg*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_ISR) | (uint32_t)(1UL << 1U));
-	out32(gpio_base_4 + IMX_GPIO_ISR, regVal);
-	/*reg intr service*/
-    SIGEV_INTR_INIT(&gpioChanAIrqEvent);
-    chanAval = InterruptAttach(673, gpioChanAIrq_handler, (const void*)&index, 1,_NTO_INTR_FLAGS_TRK_MSK);
-#if 0
-	printf("gpio ChanA(4_1) irq init finished\n");
-	printf("gpio4 IMR val is %x\n",in32(gpio_base_4 + IMX_GPIO_IMR));
-	printf("gpio4 ISR val is %x\n",in32(gpio_base_4 + IMX_GPIO_ISR));
-	printf("gpio4 GDIR val is %x\n",in32(gpio_base_4 + IMX_GPIO_GDIR));
-	printf("gpio4 ICR1 val is %x\n",in32(gpio_base_4 + IMX_GPIO_ICR1));
-#endif
-	/*enable gpio irq*/
-	regVal = (in32(gpio_base_4 + IMX_GPIO_IMR) | (uint32_t)(1UL << 1U));
-	out32(gpio_base_4 + IMX_GPIO_IMR, regVal);
-
-
-    while(1)
-    {
-		(void)InterruptWait(0, NULL);
-		(void)InterruptUnmask(673, chanAval);
-    }
-
-    /*you will never reach here*/
-    return NULL;
-}
-
-int imx8_create_gpio_irq_pthread(void)
-{
-	int ret = 0;
-
-	ret = pthread_create(&gpioFeedbackIrq_thread, NULL, gpioFeedbackIrq, NULL);
-	ret = pthread_create(&gpioChanAIrq_thread, NULL, gpioChanAIrq, NULL);
-	ret = pthread_create(&gpioChanBIrq_thread, NULL, gpioChanBIrq, NULL);
-
-    return ret;
-}
-
-
-/*  函数功能：双系心跳信号功能开启。
- *  输入参数：无。
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：板级初始化之后调用一次该函数启动功能。
- */
-void drvStartABSynSwitch(void)
-{
-	int i = 0;
-
-    s_CapInfo[0U].isLocked = 0;
-    s_CapInfo[1U].isLocked = 0;
-
-    for (i=0;i<(uint8_t)ABSynMsgType_MAX;i++)
-    {
-    	sSyncMsgErrInfo[i] = 0.0f;
-    }
-
-	(void)imx8_output(5,1);
-    s_isABSyncStart = 1;
-}
-
-
-/*  函数功能：双系心跳信号功能关闭
- *  输入参数：无。
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：
- */
-void drvStopABSynSwitch(void)
-{
-    s_isABSyncStart = 0;
-	(void)imx8_output(5,0);
-}
-/*  函数功能：发送双系硬通信信号。
- *  输入参数：MsgType：硬通信的信息：ABSynMsgType_0..ABSynMsgType_7
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：倒切方案由于硬件限制，发送频率不高于500Hz,最大使用ABSynMsgType_4。
- */
-void drvSetABSynMsg(ABSynMsgType MsgType)
-{
-    g_userSetSyncMsgType = MsgType;
-    switch((uint8_t)MsgType)
-   {
-	   case 0:
-		   s_ABSynDuty = 0;
-		   break;
-	   case 1://200hz
-		   s_ABSynDuty = 80;
-		   break;
-	   case 2://300hz
-		   s_ABSynDuty = 53;
-		   break;
-	   case 3://400hz
-		   s_ABSynDuty = 40;
-		   break;
-	   case 4://500hz
-		   s_ABSynDuty = 32;
-		   break;
-	   case 5://600hz
-		   s_ABSynDuty = 27;
-		   break;
-	   case 6://700hz
-		   s_ABSynDuty = 23;
-		   break;
-	   case 7://800hz
-		   s_ABSynDuty = 20;
-		   break;
-	   default:
-		   s_ABSynDuty =0;
-		   break;
-   }
-}
-
-
-/*  函数功能：输出PWM
- *  输入参数：无。
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：放在定时器中断服务程序中，产生PWM
- */
-static void Task_ABSyncPulse(void)
-{
-    static uint32_t PulseCount = 0u;
-    static uint32_t  PinValue = 1u;
-    uint32_t regVal = 0u;
-    uint32_t syncDuty = 0u;
-
-    if(s_isABSyncStart == 1u)
-    {
-        PulseCount++;
-        syncDuty = s_ABSynDuty;
-        if((syncDuty > 0u) && (PulseCount >= syncDuty))
-        {
-			PulseCount = 0;
-			PinValue ^= 0x1u;
-			if (0U == PinValue)
-			{
-				regVal = (in32(gpio_base_0 + IMX_GPIO_DR) & (uint32_t)~(1UL << 6U));
-				out32(gpio_base_0 + IMX_GPIO_DR,regVal);
-			}
-			else
-			{
-				regVal = (in32(gpio_base_0 + IMX_GPIO_DR) | (uint32_t)(1UL << 6U));
-				out32(gpio_base_0 + IMX_GPIO_DR, regVal);
-
-			}
-        }
-    }
-}
-
-
-
-
-/*  函数功能：获取双系硬通信的反馈。
- *  输入参数：无。
- *  输出参数：pABSynMsgType *pMsgType,   采集到的type信息
- *  返回值    ：UINT8,
- *            0x00,正常。
- *            0x81,命令与反馈不一致
- *            0x82,指针为空
- *  使用注意：发送与采集间隔至少为40ms。
- */
-uint8_t drvFeedbackkABSynMsg(ABSynMsgType *pMsgType)
-{
-	uint8_t ret = 0U;
-    float Duty = 0.0f;
-    float period = 0.0f;
-    uint32_t  PulseCnt = 0u;
-	if (NULL != pMsgType)
-	{
-		calculate(2U,&Duty,&period,&PulseCnt);
-		*pMsgType = drvPWMAnalyze(Duty,period);
-		if (g_userSetSyncMsgType == *pMsgType)
-		{
-			ret =0u;
-		}
-		else
-		{
-			ret = 0x81u;
-		}
-	}
-	else
-	{
-		ret = 0x82U;
-	}
-	return ret;
-}
-
-/*  函数功能：查询当前各通道收到的外部脉冲个数。
- *  输入参数：无。
- *  输出参数： uint8_t index -- 通道索引：0-对方A系通道 1-对方B系通道 2-自身反馈通道
- *          uint32_t* pPulseCnt -- 外部存储变量地址
- *  返回值    ：uint8_t 0-成功   1-失败：入参错误。
- */
-uint8_t drvCheckABSynPulCnt(uint8_t index,uint32_t* pPulseCnt)
-{
-	uint8_t ret = 0U;
-	if ((index > 2U) || (NULL == pPulseCnt))
-	{
-		ret = 1u;
-		return ret;
-	}
-
-	*pPulseCnt = s_CapInfo[index].capCount;
-
-	return ret;
-}
-
-
-/*  函数功能：获取对系双通道硬通信信号。
- *  输入参数：无。
- *  输出参数：pMsgType[0]:对方A系发出的硬通信信息:ABSynMsgType_0..ABSynMsgType_15
- *         pMsgType[1]：对方B系发出的硬通信信息：ABSynMsgType_0..ABSynMsgType_15
- *         pPulseCnt[0]:收到对方A系发出的脉冲计数,如果此数为0，说明对方A系停止输出脉冲
- *         pPulseCnt[1]:收到对方B系发出的脉冲计数,如果此数为0，说明对方B系停止输出脉冲
- *  返回值    ：无。
- */
-void drvGetABSynMsg(ABSynMsgType *pMsgType,uint32_t* pPulseCnt)
-{
-    float Duty[2] = {0.0f};
-    float  Period[2] = {0.0f};
-
-    if(( NULL != pMsgType) && (NULL != pPulseCnt))
-    {
-        drvGetABSyn(Duty,Period,pPulseCnt);
-        pMsgType[0] = drvPWMAnalyze(Duty[0],Period[0]);
-        pMsgType[1] = drvPWMAnalyze(Duty[1],Period[1]);
-    }
-    else
-    {
-        ;
-    }
-
-}
-
-
-/*  函数功能：获取当前系间信号脉冲的最大误差值。
- *  输入参数：uint8_t index
- *  输出参数：无
- *  返回值    ：float -- 误差百分比。
- */
-float drvGetSyncSigErr(ABSynMsgType msgType)
-{
-	uint8_t index = 0u;
-	float ret = -1.0f;
-	if (msgType < ABSynMsgType_MAX)
-	{
-		index = (uint8_t)msgType;
-		ret = sSyncMsgErrInfo[index];
-	}
-
-	return ret;
-}
-
-/*  函数功能：获取双系硬切系信号的占空比及频率。
- *  输入参数：无。
- *  输出参数：Duty[0]:对系CPU1占空比,保留3位有效小数,如30%占空比表示为0.300
- *           Period[0]：对系CPU1频率,单位为Hz
- *           Duty[1]:对系CPU2占空比,保留3位有效小数,如30%占空比表示为0.300
- *           Period[1]：对系CPU2频率,单位为Hz
- *  返回值    ：无。
- *  使用注意：Period为0时表示错误。
- */
-static void drvGetABSyn(float *Duty,float *Period,uint32_t* pPulseCnt)
-{
-	if ((NULL == Duty) || (NULL == Period) || (NULL == pPulseCnt))
-	{
-		return;
-	}
-    /*使用IO中断方式*/
-    calculate(0U,&Duty[0],&Period[0],&pPulseCnt[0]);
-    calculate(1U,&Duty[1],&Period[1],&pPulseCnt[1]);
-}
-
-
-/*  函数功能：PWM信号解析为双系MsgType。
- *  输入参数：Duty:采集到的PWM占空比
- *         Period：采集到的PWM频率
- *  输出参数：无。
- *  返回值    ：ABSynMsgType：双系通信的具体信息。
- *  使用注意：。
- */
-static ABSynMsgType drvPWMAnalyze(float Duty,float Period)
-{
-    ABSynMsgType ABSynMsgTypetemp = ABSynMsgType_0;
-    float syncErr = 0.0f;
-    float tmp = 0.0f;
-    float baseFreq = 0.0f;
-    uint8_t index = 0u;
-
-    if((Duty > 0.45f) && (Duty < 0.55f) )
-    {
-	   if((Period > 150.0f) && (Period < 250.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_1;
-	   }
-	   else if((Period > 250.0f) && (Period < 350.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_2;
-	   }
-	   else if((Period > 350.0f) && (Period < 450.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_3;
-	   }
-	   else if((Period > 450.0f) && (Period < 550.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_4;
-	   }
-	   else if((Period > 550.0f) && (Period < 650.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_5;
-	   }
-	   else if((Period > 650.0f) && (Period < 750.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_6;
-	   }
-	   else if((Period > 750.0f) && (Period < 850.0f))
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_7;
-	   }
-	   else
-	   {
-		   ABSynMsgTypetemp = ABSynMsgType_0;
-	   }
-   }
-   else//占空比无或不正常
-   {
-	   ABSynMsgTypetemp = ABSynMsgType_0;
-   }
-
-   index = (uint8_t)ABSynMsgTypetemp;
-   baseFreq = (float)(index + 1u) * 100.0f;
-   tmp = (Period > baseFreq) ? (Period - baseFreq) : (baseFreq - Period);
-   syncErr = tmp / baseFreq * 100.0f;
-   tmp = sSyncMsgErrInfo[index];
-   tmp = (syncErr > tmp) ? syncErr : tmp;
-   sSyncMsgErrInfo[index] = tmp;
-
-   return ABSynMsgTypetemp;
-}
-
-/*使用io中断获取对端脉冲频率*/
-static void calculate(uint8_t index,float *Duty,float *Period,uint32_t* pPulseCnt)
-{
-	uint32_t curTimeStamp = 0u;
-	uint32_t startTimeStamp = 0u;
-	float tmp = 0.0f;
-
-	if ((index > 2U) || (NULL == Duty) || (NULL == Period) || (NULL == pPulseCnt))
-	{
-		return;
-	}
-
-	s_ECapPause[index] = 1U;
-	curTimeStamp = s_CapInfo[index].cap1CurrentTime;
-	startTimeStamp = s_CapInfo[index].cap1StartTime;
-
-	uint32_t useTime = (curTimeStamp > startTimeStamp) ? \
-			(curTimeStamp - startTimeStamp) : \
-			(0xFFFFFFFFU - startTimeStamp + curTimeStamp);
-
-	tmp = (float)useTime / (float)s_CapInfo[index].capCount;
-	s_CapInfo[index].fre = (32000.0f / tmp);
-
-	*Period = s_CapInfo[index].fre;
-	*Duty = 0.5f;
-	*pPulseCnt = s_CapInfo[index].capCount;
-	s_CapInfo[index].cap1CurrentTime = 0u;
-	s_CapInfo[index].cap1StartTime = 0u;
-	s_CapInfo[index].capCount = 0u;
-	s_CapInfo[index].isLocked = 0u;
-	s_ECapPause[index] = 0U;
-}
-
-
-static void pulseCount(uint8_t index)
-{
-	uint8_t capPause = 0u;
-	uint8_t syncStart = 0u;
-    if (index < 3u)
-    {
-    	capPause = s_ECapPause[index];
-    	syncStart = s_isABSyncStart;
-    	if ((0u == capPause) && (1u == syncStart))
-    	{
-			if(0u == s_CapInfo[index].isLocked)
-			{
-				s_CapInfo[index].isLocked = 1u;
-				s_CapInfo[index].capCount = 0u;
-				s_CapInfo[index].cap1StartTime = cnt;
-			}
-			s_CapInfo[index].cap1CurrentTime = cnt;
-			s_CapInfo[index].capCount++;
-		}
-    	else
-    	{
-    		/*do nothing*/
-    	}
-    }
-}
-
-
-/************************************************************************/
-/*
-* @brief 读取phy寄存器相关维护信息
-*
-* 该函数通过创建套接字并发送SIOCGDRVSPEC控制命令，读取指定网络接口的PHY寄存器状态
-*
-* @param[in]
-* 	const char* fecx 需要检查的网络接口名称（如"fec0","fec1"）
-* 	uint16_t infoLen - 寄存器信息数组长度，此长度应该大于等于12
-* @param[out]
-*   uint16_t * Info - 寄存器信息数组存储首地址
-* @return rtn 返回状态
-*   - n: n为实际读取的寄存器个数
-*   - -1: 链路异常或操作失败
-*
-*/
-int drvPhyRegInfoUpdate(const char* fecx,uint16_t *Info,uint16_t infoLen)
-{
-    /*- 变量初始化*/
-    int sockfd = -1;
-    int rtn = -1;
-    int n = 0;
-    /*uint16_t regInfo[12u] = {0u};*/
-    uint8_t regList[12] = {0u,1u,4u,5u,6u,7u,8u,9u,10u,15u,21u,31u};
-    uint8_t i = 0u;
-
-	if ((NULL == fecx) || (NULL == Info) || (0u == infoLen))
-	{
-		return rtn;
-	}
-
-    /*- 创建DGRAM类型套接字*/
-	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (-1 == sockfd)
-	{
-        perror("socket");
-    }
-    else
-    {
-        /*- 配置网络接口名称*/
-        strncpy((char*)&phycmd.ifd.ifd_name, fecx, IFNAMSIZ);
-
-        /*- 设置PHY寄存器访问参数*/
-        phycmd.ifd.ifd_cmd = READ_PHY_REG;    /* PHY寄存器读取命令 */
-        phycmd.ifd.ifd_len = sizeof(phy_access_t);
-        phycmd.ifd.ifd_data = (void*)&phycmd.req;
-        phycmd.req.phy_id = 7U;               /* PHY设备地址 */
-        phycmd.req.phy_reg = 1U;              /* PHY状态寄存器地址 */
-        phycmd.req.phy_data = 0U;          /* 初始化数据域 */
-
-        n = ((12U <= infoLen)? 12 : (int)infoLen);
-
-        for(i = 0u;i < n;i++)
-        {
-        	 phycmd.req.phy_reg = regList[i];        /* PHY状态寄存器地址 */
-        	/*- 发送驱动控制命令获取PHY状态*/
-        	devctl(sockfd, SIOCGDRVSPEC, &phycmd,sizeof(phycmd),0);
-        	Info[i] = phycmd.req.phy_data;
-        }
-        rtn = n;
-        close(sockfd);
-    }
-    /*- 返回最终检测结果*/
-    return rtn;
-}
-
-
-#if 0
-/*调试接口*/
-void checkisr(void)
-{
-	static int ret = 0;
-	printf("irq cnt 0 is %d\n",irqCnt[0]);
-	printf("irq cnt 1 is %d\n",irqCnt[1]);
-	printf("irq cnt 2 is %d\n",irqCnt[2]);
-	printf("cur cnt  is %d\n",cnt);
-}
-#endif
-
-
-/************************************************************************/
-/*
-* @brief 通过PHY寄存器检查指定网卡链路状态
-*
-* 该函数通过创建套接字并发送SIOCGDRVSPEC控制命令，读取指定网络接口的PHY寄存器状态，
-* 根据寄存器值的特定位判断链路是否正常。
-*
-* @param[in] fecx 需要检查的网络接口名称（如"fec0","fec1"）
-* @return rtn 返回状态
-*   - 0: 链路状态正常（PHY寄存器bit2为1）
-*   - -1: 链路异常或操作失败
-*
-* @note 函数执行流程：
-*   1. 创建UDP套接字
-*   2. 配置phycmd控制结构体：
-*      - ifd_name: 网络接口名称
-*      - ifd_cmd: 使用READ_PHY_REG命令
-*      - phy_id: PHY地址7
-*      - phy_reg: 寄存器地址1（状态寄存器）
-*   3. 通过devctl发送控制命令
-*   4. 解析phy_data寄存器值的bit2判断链路状态
-*/
-int phytool(const char* fecx)
-{
-    /*- 变量初始化*/
-    int sockfd = -1;
-    int rtn = -1;
-
-	if (NULL == fecx)
-	{
-		return rtn;
-	}
-
-    /*- 创建DGRAM类型套接字*/
-	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (-1 == sockfd)
-	{
-        perror("socket");
-    }
-    else
-    {
-        /*- 配置网络接口名称*/
-        strncpy((char*)&phycmd.ifd.ifd_name, fecx, IFNAMSIZ);
-
-        /*- 设置PHY寄存器访问参数*/
-        phycmd.ifd.ifd_cmd = READ_PHY_REG;    /* PHY寄存器读取命令 */
-        phycmd.ifd.ifd_len = sizeof(phy_access_t);
-        phycmd.ifd.ifd_data = (void*)&phycmd.req;
-        phycmd.req.phy_id = 7U;               /* PHY设备地址 */
-        phycmd.req.phy_reg = 1U;              /* PHY状态寄存器地址 */
-        phycmd.req.phy_data = 0U;          /* 初始化数据域 */
-
-        /*- 发送驱动控制命令获取PHY状态*/
-        devctl(sockfd, SIOCGDRVSPEC, &phycmd,sizeof(phycmd),0);
-
-        close(sockfd);
-
-        /*- 解析状态寄存器bit2（0x04）链路状态标志*/
-        if(1U == ((phycmd.req.phy_data & 0x04U)>>2U))
-        {
-            rtn = 0;  /* 链路正常 */
-        }
-        else
-        {
-            ; /* 保持默认失败状态 */
-        }
-    }
-    /*- 返回最终检测结果*/
-    return rtn;
-}

TSCP/src/DRV/imx8_drv_gpio.h

@@ -17,51 +17,6 @@
 #include <pthread.h>
 #include <threads.h>
 
-#include <net/if.h>
-#include <sys/ioctl.h>
-#include <devctl.h>
-
-
-/*双系脉冲通信信号类型定义*/
-typedef enum {     //占空比-频率
-    ABSynMsgType_0,//0.0-0,ErrorDuty-ErrorFrequency固定为驱动程序检测到以下故障中的一种：a、未收到有效的PWM信号(包含：无PWM信号、信号参数不符合预设的范围)
-    ABSynMsgType_1,//0.5-200 固定为驱动程序检测到以下故障中的一种：a、发送端的MsgType不是规定的枚举类型;
-    ABSynMsgType_2,//0.5-300 固定为驱动程序检测到以下故障中的一种：a、双系PWM信号使能标志没有周期翻转(main函数跑飞);
-    ABSynMsgType_3,//0.5-400 平台自由确定其含义
-    ABSynMsgType_4,//0.5-500 平台自由确定其含义
-    ABSynMsgType_5,//0.5-600 平台自由确定其含义
-    ABSynMsgType_6,//0.5-700 平台自由确定其含义
-    ABSynMsgType_7,//0.5-800 平台自由确定其含义
-    ABSynMsgType_MAX = 0x08
-} ABSynMsgType;
-
-struct SCapInfo{
-    uint8_t vaild;//0无效 1有效
-    uint8_t isLocked;//1锁定
-    uint32_t capCount;
-    uint32_t cap1StartTime;      //first rising
-    uint32_t cap1CurrentTime;      //first falling
-    uint32_t cycle;         //周期
-    uint32_t pulseWidth;    //脉宽
-    float dutyCycle;        //占空比
-    float fre;           //频率
-};
-
-
-#define  READ_PHY_REG   0x400U
-
-typedef struct {
-		uint8_t  phy_id;
-        uint8_t  phy_reg;
-        uint16_t phy_data;
-}phy_access_t;
-
-static struct ifdrv2{
-    struct ifdrv ifd;
-    phy_access_t req;
-}phycmd;
-
-
 #define IMX_GPIO0_BASE                         0x5D080000
 #define IMX_GPIO1_BASE                         0x5D090000
 #define IMX_GPIO2_BASE                         0x5D0A0000
@@ -74,18 +29,8 @@ static struct ifdrv2{
 #define IMX_GPIO_DR            0x0U
 #define IMX_GPIO_GDIR          0x4U
 #define IMX_GPIO_PSR           0x8U
-/*20250707--zhangzhongqi add*/
-#define IMX_GPIO_ICR1          0xCU
-#define IMX_GPIO_ICR2          0x10U
-#define IMX_GPIO_IMR           0x14U
-#define IMX_GPIO_ISR           0x18U
-#define IMX_GPIO_EDGE_SEL      0x1CU
-#define IMX_GPIO_SIZE          0x20U
 
 
-#define IMX_GPIO0_IRQ          168
-#define IMX_GPIO1_IRQ          169
-
 /*timer regisger */
 #define IMX_GPT0_BASE    	0x5D140000
 #define IMX_GPT_SIZE     	0x10000
@@ -138,111 +83,3 @@ const struct sigevent *handler_25 (void *not_used, int id);
 const struct sigevent *handler (void *not_used, int id);
 void* timer_25( void * arg);
 void* timer( void * arg);
-
-/*  函数功能：创建脉冲检测中断线程
- *  输入参数：void
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：板级初始化之后调用一次该函数启动功能。
- */
-int imx8_create_gpio_irq_pthread(void);
-/*  函数功能：发送双系硬通信信号。
- *  输入参数：MsgType：硬通信的信息：ABSynMsgType_0..ABSynMsgType_7
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：倒切方案由于硬件限制，发送频率不高于500Hz,最大使用ABSynMsgType_4。
- */
-void drvSetABSynMsg(ABSynMsgType MsgType);
-/*  函数功能：获取对系双通道硬通信信号。
- *  输入参数：无。
- *  输出参数：pMsgType[0]:对方A系发出的硬通信信息:ABSynMsgType_0..ABSynMsgType_15
- *         pMsgType[1]：对方B系发出的硬通信信息：ABSynMsgType_0..ABSynMsgType_15
- *         pPulseCnt[0]:收到对方A系发出的脉冲计数,如果此数为0，说明对方A系停止输出脉冲
- *         pPulseCnt[1]:收到对方B系发出的脉冲计数,如果此数为0，说明对方B系停止输出脉冲
- *  返回值    ：无。
- */
-void drvGetABSynMsg(ABSynMsgType *pMsgType,uint32_t* pPulseCnt);
-/*  函数功能：双系心跳信号功能开启。
- *  输入参数：无。
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：板级初始化之后调用一次该函数启动功能。
- */
-void drvStartABSynSwitch(void);
-
-/*  函数功能：双系心跳信号功能关闭
- *  输入参数：无。
- *  输出参数：无。
- *  返回值    ：无。
- *  使用注意：
- */
-void drvStopABSynSwitch(void);
-
-/*  函数功能：获取双系硬通信的反馈。
- *  输入参数：无。
- *  输出参数：pABSynMsgType *pMsgType,   采集到的type信息
- *  返回值    ：UINT8,
- *            0x00,正常。
- *            0x81,命令与反馈不一致
- *            0x82,指针为空
- *  使用注意：发送与采集间隔至少为40ms。
- */
-uint8_t drvFeedbackkABSynMsg(ABSynMsgType *pMsgType);
-
-/*  函数功能：获取当前系间信号脉冲的最大误差值。
- *  输入参数：uint8_t index
- *  输出参数：无
- *  返回值    ：float -- 误差百分比。
- */
-float drvGetSyncSigErr(ABSynMsgType msgType);
-
-/*  函数功能：查询当前各通道收到的外部脉冲个数。
- *  输入参数：无。
- *  输出参数： uint8_t index -- 通道索引：0-自身反馈通道 1-对方A系通道 2-对方B系通道
- *          uint32_t* pPulseCnt -- 外部存储变量地址
- *  返回值    ：uint8_t 0-成功   1-失败：入参错误。
- */
-uint8_t drvCheckABSynPulCnt(uint8_t index,uint32_t* pPulseCnt);
-
-
-/************************************************************************/
-/*
-* @brief 读取phy寄存器相关维护信息
-*
-* 该函数通过创建套接字并发送SIOCGDRVSPEC控制命令，读取指定网络接口的PHY寄存器状态
-*
-* @param[in]
-* 	const char* fecx 需要检查的网络接口名称（如"fec0","fec1"）
-* 	uint16_t infoLen - 寄存器信息数组长度，此长度应该大于等于12
-* @param[out]
-*   uint16_t * Info - 寄存器信息数组存储首地址
-* @return rtn 返回状态
-*   - n: n为实际读取的寄存器个数
-*   - -1: 链路异常或操作失败
-*
-*/
-int drvPhyRegInfoUpdate(const char* fecx,uint16_t *Info,uint16_t infoLen);
-
-/************************************************************************/
-/*
-* @brief 通过PHY寄存器检查指定网卡链路状态
-*
-* 该函数通过创建套接字并发送SIOCGDRVSPEC控制命令，读取指定网络接口的PHY寄存器状态，
-* 根据寄存器值的特定位判断链路是否正常。
-*
-* @param[in] fecx 需要检查的网络接口名称（如"fec0","fec1"）
-* @return rtn 返回状态
-*   - 0: 链路状态正常（PHY寄存器bit2为1）
-*   - -1: 链路异常或操作失败
-*
-* @note 函数执行流程：
-*   1. 创建UDP套接字
-*   2. 配置phycmd控制结构体：
-*      - ifd_name: 网络接口名称
-*      - ifd_cmd: 使用READ_PHY_REG命令
-*      - phy_id: PHY地址7
-*      - phy_reg: 寄存器地址1（状态寄存器）
-*   3. 通过devctl发送控制命令
-*   4. 解析phy_data寄存器值的bit2判断链路状态
-*/
-int phytool(const char* fecx);

TSCP/src/MSCP/CFM/CFM_Net.c

@@ -47,7 +47,7 @@
 
 #define CFM_INNET_SAFE_MSG_SIZE (5120u)
 #define CFM_INNET_RAW_MSG_SIZE  (2048u)
-#define CFM_OUTNET_SAFE_MSG_SIZE (5120u)
+#define CFM_OUTNET_SAFE_MSG_SIZE (6144u)
 #define CFM_OUTNET_RAW_MSG_SIZE (5120u)
 #define CFM_OUTNET_HEART_MSG_SIZE (1000u)
 #define CFM_SYN_MSG_SIZE (1000u)
@@ -525,6 +525,7 @@ ENUM_CM_RETURN CFM_2oo2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
 {
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	ENUM_CM_RETURN ret = ENUM_CM_FALSE;
 
     /*- 锁定互斥锁 */
     rt = CM_Mutex_Lock(s_CFM_2oo2_Time.mutex);
@@ -537,7 +538,7 @@ ENUM_CM_RETURN CFM_2oo2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
         *pOffset = s_CFM_2oo2_Time.offset;
         /*- 清除时钟同步结果 */
         s_CFM_2oo2_Time.isOK = ENUM_CM_FALSE;
-        rt = ENUM_CM_TRUE;
+		ret = ENUM_CM_TRUE;
     }
     else
 	{
@@ -547,7 +548,7 @@ ENUM_CM_RETURN CFM_2oo2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
     rt = CM_Mutex_Unlock(s_CFM_2oo2_Time.mutex);
     CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_15, TSCP_DARK_ASSERT_2);
     /*- 返回执行结果 */
-    return rt;
+	return ret;
 }
 /**
 * @brief 通用2oo2数据发送
@@ -1177,6 +1178,7 @@ ENUM_CM_RETURN CFM_2x2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
 
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	ENUM_CM_RETURN ret = ENUM_CM_FALSE;
     /*- 指针不为空 */
 	if((NULL != pDelay) && (NULL != pOffset))
 	{
@@ -1191,7 +1193,7 @@ ENUM_CM_RETURN CFM_2x2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
 			*pOffset = s_CFM_2x2_Time.offset;
 			/*- 清除时钟同步结果 */
 			s_CFM_2x2_Time.isOK = ENUM_CM_FALSE;
-			rt = ENUM_CM_TRUE;
+			ret = ENUM_CM_TRUE;
 		}
 		else
 		{
@@ -1210,7 +1212,7 @@ ENUM_CM_RETURN CFM_2x2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
 		MSCP_LOG_MSG("pDelay == NULL || pOffset == NULL\n");
 	}
     /*- 返回执行结果 */
-    return rt;
+	return ret;
 }
 /**
 * @brief 周期同步线程
@@ -3319,7 +3321,8 @@ static CM_THREAD_FUNC_T t_RemoteUpdateThread(IN CM_Thread_Arg_Struct_T* arg)
 						{
 							/*- 不是当前应该收到的过程报文丢弃不处理*/
 							MSCP_LOG_MSG("0xa4u The packet should not be received in the current state!!! \n");
-							(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_10, TSCP_DARK_ASSERT_4));						}
+							(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_10, TSCP_DARK_ASSERT_4));
+						}
 					}
 					else
 					{
@@ -4040,6 +4043,7 @@ static CM_THREAD_FUNC_T t_ClearArpThread(void)
 {
 	static STRU_HARDWARE_BOOT_COM_T lastComRecord;
 	CM_UINT32 cycle = DFM_GetBirthCount();
+	CM_UINT8 cmdBuf[100] = {0};
 #if QNX
     void* pmask = NULL;
     /*- 本线程锁定在 A53 core 1 */
@@ -4052,14 +4056,9 @@ static CM_THREAD_FUNC_T t_ClearArpThread(void)
 		if((cycle > (g_Hardware_boot_com_state.CCU_A_Count + 100u))&&(lastComRecord.CCU_A_Count != g_Hardware_boot_com_state.CCU_A_Count))
 		{
 			lastComRecord.CCU_A_Count = g_Hardware_boot_com_state.CCU_A_Count;
-			if(g_PFM_Cfg.CPU_ID == 1u)
+			snprintf(cmdBuf, sizeof(cmdBuf), "arp -d %s", g_PFM_Cfg.CC_R_IP);
-			{
+			(void)system(cmdBuf);
-				(void)system("arp -d 192.168.1.60");
+			MSCP_LOG_MSG("%s\n", cmdBuf);
-			}
-			else
-			{
-				(void)system("arp -d 192.168.2.60");
-			}
 			MSCP_LOG_MSG("clear arp cycle = %d,g_Hardware_boot_com_state.CCU_A_Count=%d,lastComRecord.CCU_A_Count=%d\n",cycle,g_Hardware_boot_com_state.CCU_A_Count,lastComRecord.CCU_A_Count);
 		}
 		else
@@ -4070,14 +4069,9 @@ static CM_THREAD_FUNC_T t_ClearArpThread(void)
 		if((cycle > (g_Hardware_boot_com_state.CCU_B_Count + 100u))&&(lastComRecord.CCU_B_Count != g_Hardware_boot_com_state.CCU_B_Count))
 		{
 			lastComRecord.CCU_B_Count = g_Hardware_boot_com_state.CCU_B_Count;
-			if(g_PFM_Cfg.CPU_ID == 1u)
+			snprintf(cmdBuf, sizeof(cmdBuf), "arp -d %s", g_PFM_Cfg.CC_B_IP);
-			{
+			(void)system(cmdBuf);
-				(void)system("arp -d 192.168.1.61");
+			MSCP_LOG_MSG("%s\n", cmdBuf);
-			}
-			else
-			{
-				(void)system("arp -d 192.168.2.61");
-			}
 			MSCP_LOG_MSG("clear arp cycle = %d,g_Hardware_boot_com_state.CCU_B_Count=%d,lastComRecord.CCU_B_Count=%d\n",cycle,g_Hardware_boot_com_state.CCU_B_Count,lastComRecord.CCU_B_Count);
 		}
 		else
@@ -4094,14 +4088,9 @@ static CM_THREAD_FUNC_T t_ClearArpThread(void)
 			if((cycle > (g_Hardware_boot_com_state.SEB_A_Count + 100u))&&(lastComRecord.SEB_A_Count != g_Hardware_boot_com_state.SEB_A_Count))
 			{
 				lastComRecord.SEB_A_Count = g_Hardware_boot_com_state.SEB_A_Count;
-				if(g_PFM_Cfg.CPU_ID == 1u)
+				snprintf(cmdBuf, sizeof(cmdBuf), "arp -d %s", g_PFM_Cfg.EXTEND_R_IP);
-				{
+				(void)system(cmdBuf);
-					(void)system("arp -d 192.168.1.70");
+				MSCP_LOG_MSG("%s\n", cmdBuf);
-				}
-				else
-				{
-					(void)system("arp -d 192.168.2.70");
-				}
 				MSCP_LOG_MSG("clear arp cycle = %d,g_Hardware_boot_com_state.SEB_A_Count=%d,lastComRecord.SEB_A_Count=%d\n",cycle,g_Hardware_boot_com_state.SEB_A_Count,lastComRecord.SEB_A_Count);
 			}
 			else
@@ -4112,14 +4101,9 @@ static CM_THREAD_FUNC_T t_ClearArpThread(void)
 			if((cycle > (g_Hardware_boot_com_state.SEB_B_Count + 100u))&&(lastComRecord.SEB_B_Count != g_Hardware_boot_com_state.SEB_B_Count))
 			{
 				lastComRecord.SEB_B_Count = g_Hardware_boot_com_state.SEB_B_Count;
-				if(g_PFM_Cfg.CPU_ID == 1u)
+				snprintf(cmdBuf, sizeof(cmdBuf), "arp -d %s", g_PFM_Cfg.EXTEND_B_IP);
-				{
+				(void)system(cmdBuf);
-					(void)system("arp -d 192.168.1.71");
+				MSCP_LOG_MSG("%s\n", cmdBuf);
-				}
-				else
-				{
-					(void)system("arp -d 192.168.2.71");
-				}
 				MSCP_LOG_MSG("clear arp cycle = %d,g_Hardware_boot_com_state.SEB_B_Count=%d,lastComRecord.SEB_B_Count=%d\n",cycle,g_Hardware_boot_com_state.SEB_B_Count,lastComRecord.SEB_B_Count);
 			}
 			else

TSCP/src/MSCP/DFM/DFM_DRV.h

@@ -48,9 +48,6 @@ CM_INT32 DFM_output(CM_UINT8 channel, CM_UINT8 level);
 /*- 切系按钮 */
 CM_INT32 DFM_switchButton(void);
 
-/*- 看门狗指示灯 */
-void DFM_ledMonitor(CM_UINT8 light);
-
 /*-通道电流电压读取*/
 CM_INT32 DFM_Read_ina3321(INOUT CM_INT32* channel_1_shunt, INOUT CM_FLOAT32* channel_1_bus, INOUT CM_INT32* channel_2_shunt, INOUT CM_FLOAT32* channel_2_bus, INOUT CM_INT32* channel_3_shunt, INOUT CM_FLOAT32* channel_3_bus);
 

TSCP/src/MSCP/DFM/DFM_DRV_QNX.c

@@ -619,6 +619,11 @@ void DFM_Network_Check(void)
     (void)system("drvtools -link9131 3 >> networkcheck.txt");
 
     FILE *file = fopen(filename, "r");
+    if(NULL == file)
+    {
+    	printf("open networkcheck.txt error\n");
+    }
+    else{
     while (NULL != fgets(pFileBuf, sizeof(pFileBuf), file)) {
 		if('w' != pFileBuf[0])
 		{
@@ -632,5 +637,6 @@ void DFM_Network_Check(void)
     }
     /* 关闭文件 */
 	(void)fclose(file);
+    }
     return;
 }

TSCP/src/MSCP/MSCP_APP_API.c

@@ -74,14 +74,12 @@ CM_UINT8 MSCP_AppRecvMsg(IN ENUM_MSCP_MSG_CHN_T ch,
         case ENUM_MSG_OUTNET_SAFE: /*-< 外网安全通信 */
             /*- 从外网安全协议读取应用接收报文 */
             *pRxLen = Prtcl_OutnetSafe_AppRecv(pSrcName, pSrcLogicID, pLifeTime, rxBuf, rxSize);
-            rt = 1u;
             /*- 返回 */
             break;
         case ENUM_MSG_INNET_SAFE: /*-< 内网安全通信 */
             *pSrcLogicID = 0u;
             /*- 从内网安全协议读取应用接收报文 */
             *pRxLen = Prtcl_InnetSafe_AppRecv(pSrcName, pLifeTime, rxBuf, rxSize);
-            rt = 1u;
             /*- 返回 */
             break;
         case ENUM_MSG_INNET_MAINTENANCE: /*-< 远程部署功能内网安全通信 */
@@ -89,7 +87,6 @@ CM_UINT8 MSCP_AppRecvMsg(IN ENUM_MSCP_MSG_CHN_T ch,
             /*- 从内网安全协议读取应用接收报文 */
             *pRxLen = Prtcl_InnetSafe_RmRecv(pSrcName, pLifeTime, rxBuf, rxSize);
 			MSCP_LOG_BIN(rxBuf,*pRxLen);
-            rt = 1u;
             /*- 返回 */
             break;
         case ENUM_MSG_ERROR: /*-< 保留字 */
@@ -103,7 +100,14 @@ CM_UINT8 MSCP_AppRecvMsg(IN ENUM_MSCP_MSG_CHN_T ch,
             /*- 返回 */
             break;
         }
-
+		if(0u < *pRxLen)
+		{
+			rt = 1u;
+		}
+		else
+		{
+			rt = 0u;
+		}
     }
     else
 	{

TSCP/src/MSCP/MSCP_main.c

@@ -117,7 +117,6 @@ static void SelfCheckInit(void);
 static void selfCheckSemWait(void);
 
 static void selfCheckSemPost(void);
-
 /**
 * @brief 主程序入口
 * @details 调用初始化入口和周期循环入口
@@ -189,6 +188,8 @@ static void MSCP_Init(void)
     PFM_LOG_SET_STOPTIMER(TSCP_DARK_TSCPINIT);
     /*- 应用版本号初始化，必须在应用软件初始化前 */
     PFM_CFG_RegisterVerson_Init();
+	/*- 初始化读取main id，在应用初始化之前*/
+	PFM_CFG_MAINID_Init();
     /*- 应用软件初始化内网安全协议参数-以及配置文件参数 */
     APP_API_Data_Init();
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_API_DATA);
@@ -657,7 +658,7 @@ static void SelfCheckInit(void)
 {
 #ifdef QNX
     /*- 文件自检初始化 */
-    PFM_FileInit();
+    //PFM_FileInit();
 	/*- 内存自检初始化*/
     PFM_MemCheck_Init();
 	/*- CPU自检初始化*/
@@ -916,10 +917,3 @@ static void s_LogicProc(ENUM_CM_RETURN(*pAppfunc)(void))
     	/*- 无处理  */
     }
 }
-
-
-
-
-
-
-

TSCP/src/MSCP/PFM/PFM_Cfg.c

@@ -40,11 +40,11 @@
 CM_CHAR FS_FILE_PATH[100];
 
 /** 平台软件版本号 */
-const CM_UINT8 MSCP_SW_VERION[4] = { 93u, 1u, 1u, 53u };
+const CM_UINT8 MSCP_SW_VERION[4] = { 93u, 18u, 0u, 2u };
 /** 驱动软件版本号 */
 CM_UINT8 MSCP_DRV_VERION[4] = {0};
 /** 与维护一体机接口文档版本号(接口文档发生改变时升级版本号) */
-CM_UINT16 TSCP_DOC_VERION[2] = {31u,0u};
+CM_UINT16 TSCP_DOC_VERION[2] = {34u,11u};
 /** 操作系统版本号 */
 CM_UINT8 TSCP_QNX_VERION[10] = {0u};
 
@@ -62,6 +62,26 @@ STRU_APP_VERSON g_App_Verson;
 static STRU_APP_CFG_T g_AppCfgInterface;
 static void s_str2md5(IN const CM_CHAR* str, OUT CM_UINT8 md5[16]);
 static void PFM_CFG_Check_BoardID(void);
+void PFM_CFG_MAINID_Init(void)
+{
+    g_PFM_Cfg.CPU_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI,"ID","CPU_ID");
+    CM_NM_ASSERT(0u != g_PFM_Cfg.CPU_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    g_PFM_Cfg.BOARD_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI, "ID", "BOARD_ID");
+    CM_NM_ASSERT(0u != g_PFM_Cfg.BOARD_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_2);
+    PFM_CFG_Check_BoardID();
+    g_PFM_Cfg.OUTNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "OUTNET_ID");
+    CM_NM_ASSERT(0u != g_PFM_Cfg.OUTNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_3);
+    g_PFM_Cfg.INNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID");
+    CM_NM_ASSERT(0u != g_PFM_Cfg.INNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_4);
+    g_PFM_Cfg.INNET_ID_RM = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID_RM");
+    MSCP_LOG_MSG("Remote Update INNET_ID_RM = 0x%.2x",g_PFM_Cfg.INNET_ID_RM);
+    (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_PFMCFG_INIT1, 5, \
+    					sizeof(CM_UINT8),g_PFM_Cfg.CPU_ID,
+    					sizeof(CM_UINT8),g_PFM_Cfg.BOARD_ID,
+						sizeof(CM_UINT16),g_PFM_Cfg.OUTNET_ID,
+    					sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID,
+						sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID_RM);
+}
 /**
 * @brief 平台配置文件初始化
 */
@@ -79,27 +99,7 @@ void PFM_CFG_Init(void)
     (void)printf("MSCP start version:%d.%d.%d.%d \n",
             MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3]);
     /*- 读取ID信息 */
-    g_PFM_Cfg.CPU_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI,"ID","CPU_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.CPU_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_1);
-    g_PFM_Cfg.BOARD_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI, "ID", "BOARD_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.BOARD_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_2);
 
-    /*检查配置文件ID与硬件ID是否一致*/
-    PFM_CFG_Check_BoardID();
-
-    g_PFM_Cfg.OUTNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "OUTNET_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.OUTNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_3);
-    g_PFM_Cfg.INNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.INNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_4);
-
-    g_PFM_Cfg.INNET_ID_RM = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID_RM");
-    MSCP_LOG_MSG("Remote Update INNET_ID_RM = 0x%.2x",g_PFM_Cfg.INNET_ID_RM);
-    (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_PFMCFG_INIT1, 5, \
-    					sizeof(CM_UINT8),g_PFM_Cfg.CPU_ID,
-    					sizeof(CM_UINT8),g_PFM_Cfg.BOARD_ID,
-						sizeof(CM_UINT16),g_PFM_Cfg.OUTNET_ID,
-    					sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID,
-						sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID_RM);
     (void)strcpy(FS_FILE_PATH,g_AppCfgInterface.FS_NAME);
     (void)strcpy(g_PFM_Cfg.APP_NAME,g_AppCfgInterface.APP_NAME);
     MSCP_LOG_MSG("FS_NAME:%s\n",FS_FILE_PATH);
@@ -274,7 +274,7 @@ void PFM_CFG_Init(void)
     g_PFM_Cfg.CC_R_InnetRaw_Port = g_AppCfgInterface.OutNetRed.InnetRaw_Port;
     g_PFM_Cfg.CC_R_Heart_Port = 53003;
 
-    g_PFM_Cfg.CC_B_OutnetSafe_Port = g_AppCfgInterface.OutNetBlue.OutnetSafe_Port;;
+    g_PFM_Cfg.CC_B_OutnetSafe_Port = g_AppCfgInterface.OutNetBlue.OutnetSafe_Port;
 	g_PFM_Cfg.CC_B_OutnetRaw_Port = g_AppCfgInterface.OutNetBlue.OutnetRaw_Port;
     g_PFM_Cfg.CC_B_InnetRaw_Port = g_AppCfgInterface.OutNetBlue.InnetRaw_Port;
     g_PFM_Cfg.CC_B_Heart_Port = 53003;

TSCP/src/MSCP/PFM/PFM_Cfg.h

@@ -346,6 +346,10 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
     void PFM_CFG_IfconfigIp(void);
 
     void PFM_CFG_SendDarkCfg(void);
+    /**
+     * @brief 初始化读取mainid 必须在函数PFM_CFG_Init前执行
+     */
+    void PFM_CFG_MAINID_Init(void);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/MSCP/PFM/PFM_InputOutput.c

@@ -87,6 +87,11 @@ static CM_INT32 s_2oo2OutputCheckFrame_Pack(OUT CM_UINT8 buf[], IN CM_UINT32 Buf
 static CM_INT32 s_2x2OutputCheckFrame_Pack(OUT CM_UINT8 *buf, IN CM_UINT32 BufSize);
 /* 输入阶段的2x2同步 */
 static void s_input_2x2sync(void);
+
+/**
+ * @brief 输出阶段的2取校验
+ */
+static void s_output_2oo2check(IN CM_UINT8* check_2oo2_Buf, IN CM_UINT32 check_2oo2_Len);
 /**
 * @brief 输入阶段的2x2同步
 */
@@ -639,9 +644,7 @@ void PFM_OutputProc(void)
     CM_UINT8 check_2oo2_Buf[500] = { 0u }; /* 输出校验帧数组 */
     CM_INT32 check_2x2_Len = 0;          /* 输出校验帧长度 */
     CM_UINT8 check_2x2_Buf[500] = { 0u }; /* 输出校验帧数组 */
-    CM_INT32 i = 0;                 /* 循环变量 */
+    CM_INT32 i = 0, ret = 0;                 /* 循环变量 */
-    CM_UINT8 buf_peer[500] = { 0u }; /* 邻机接收缓冲区 */
-    CM_INT32 ret = 0;               /* 临时变量 */
     ENUM_2x2_STATE_T state_2x2 = ENUM_2x2_SHUTDOWN; /* 本系热备状态 */
 
 
@@ -680,18 +683,8 @@ void PFM_OutputProc(void)
     /*- 是否开启了2oo2功能 */
     if (0x55u == g_PFM_Cfg.M_2oo2_Enable)
     {
-        /*- 2oo2交换输出校验帧 */
+        /* 2取校验 */
-        ret = SFM_2oo2_Exchange_Currency(check_2oo2_Buf, check_2oo2_Len, buf_peer, (CM_UINT32)check_2oo2_Len, ENUM_2oo2_OUTPUT_CHECK);
+        (void)s_output_2oo2check(check_2oo2_Buf, (CM_UINT32)check_2oo2_Len);
-
-        /*- 检查2oo2双机的输出校验帧是否一致 */
-        CM_RE_ASSERT(check_2oo2_Len == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_3, TSCP_DARK_ASSERT_1);
-        ret = CM_Memcmp(check_2oo2_Buf, buf_peer, (CM_SIZE_T)check_2oo2_Len);
-        if(0 != ret)
-        {
-        	MSCP_LOG_DATALEN(check_2oo2_Buf,check_2oo2_Len,"Ouput check_2oo2_Buf");
-        	MSCP_LOG_DATALEN(buf_peer,check_2oo2_Len,"Ouput buf_peer");
-        	CM_RE_ASSERT(0, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_3, TSCP_DARK_ASSERT_2);
-        }
     }
     else
     {
@@ -705,6 +698,8 @@ void PFM_OutputProc(void)
     if (0x55u == g_PFM_Cfg.M_2x2_Enable)
     {
         /*- 输出阶段2x2处理 */
+        ret = SFM_2oo2_Exchange_Currency(check_2x2_Buf, check_2x2_Len, &check_2x2_Buf[check_2x2_Len], sizeof(check_2x2_Buf) - check_2x2_Len, ENUM_2oo2_OUTPUT_EX);
+        check_2x2_Len += ret;
         SFM_2x2_OutputProc(check_2x2_Buf, check_2x2_Len);
     }
     else
@@ -790,7 +785,6 @@ void PFM_OutputProc(void)
 void PFM_EndProc(void)
 {
     /*- 变量初始化 */
-    CM_UINT32 crc = 0u;   /* crc值 */
     CM_UINT8 mybuf[8] = { 0u };  /* 本机2oo2缓冲区 */
     CM_UINT8 peerbuf[8] = { 0u };/* 邻机2oo2缓冲区 */
     CM_INT32 len = 0; /* 长度 */
@@ -803,16 +797,16 @@ void PFM_EndProc(void)
     if (0x55u == g_PFM_Cfg.M_2oo2_Enable)
     {
         /*- 生成跟随数据的特征信息 */
-        crc = CM_Crc32(g_TxAppFollow, (CM_UINT32)g_TxAppFollow_len);
         CM_LongToChar((CM_UINT32)g_TxAppFollow_len, mybuf);
-        CM_LongToChar(crc, mybuf + 4);
+        CM_Memcpy(&mybuf[4u], 4u, g_TxAppFollow, 4u);
         /*- 2oo2交换特征信息 */
         len = SFM_2oo2_Exchange_Currency(mybuf, 8, peerbuf, 8u, ENUM_2oo2_OUTPUT_CHECK);
         /*- 2oo2严格比较特征信息 */
         CM_RE_ASSERT(8 == len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
         if(0 == CM_Memcmp(mybuf, peerbuf, (CM_SIZE_T)8))
         {
-        	/*- 无处理 */
+        	/* 填入另一个CPU的CRC，本机的CRC在接口函数里设置的时候已计算，直接使用 */
+            CM_Memcpy(&g_TxAppFollow[4u], 4u, &peerbuf[4u], 4u);
         }
         else
         {
@@ -1831,5 +1825,41 @@ void PFM_GetRciTempBuf(OUT CM_UINT16* RedBuf, OUT CM_UINT16* BlueBuf)
 		MSCP_LOG_MSG("RED or BLUE Buf is NULL\n");
 	}
 }
+/**
+ * @brief 输出阶段的2取校验
+ */
+static void s_output_2oo2check(IN CM_UINT8* check_2oo2_Buf, IN CM_UINT32 check_2oo2_Len)
+{
+    CM_INT32 ret = 0, i = 0;
+    CM_UINT8 buf_peer[500] = {0u};
+    /*- 2oo2交换输出校验帧 */
+    CM_ASSERT(NULL != check_2oo2_Buf, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_15, TSCP_DARK_ASSERT_1);
+    ret = SFM_2oo2_Exchange_Currency(check_2oo2_Buf, check_2oo2_Len, buf_peer, (CM_UINT32)check_2oo2_Len, ENUM_2oo2_OUTPUT_CHECK);
 
+    /*- 检查2oo2双机的输出校验帧是否一致 */
+    CM_RE_ASSERT(check_2oo2_Len == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_15, TSCP_DARK_ASSERT_2);
+    ret = CM_Memcmp(check_2oo2_Buf, buf_peer, (CM_SIZE_T)check_2oo2_Len);
+    if(0 != ret)
+    {
+        MSCP_LOG_DATALEN(check_2oo2_Buf,check_2oo2_Len,"Ouput check_2oo2_Buf");
+        MSCP_LOG_DATALEN(buf_peer,check_2oo2_Len,"Ouput buf_peer");
+        for (i = 1; i <= g_2x2oo2_data_num; i++)
+        {
+            if ((CM_UINT32)CM_TRUE == g_2x2oo2_tx[g_2x2oo2_base][i].b_2oo2_Enable)
+            {
+                ret = CM_Memcmp(check_2oo2_Buf + 4 + (i - 1) * 8, buf_peer + 4 + (i - 1) * 8, 8);
+                if(ret != 0)
+                {
+                    MSCP_LOG_MSG("2oo2 output compare err, INDEX = %d, len = %d\n", i, (CM_SIZE_T)g_2x2oo2_tx[g_2x2oo2_base][i].buf_len);
+                    MSCP_LOG_BIN(g_2x2oo2_tx[g_2x2oo2_base][i].p_buf, (CM_SIZE_T)g_2x2oo2_tx[g_2x2oo2_base][i].buf_len);
+                }
+            }
+            else
+            {
+                /*二取标志未使能*/
+            }
+        }
+        CM_RE_ASSERT(0, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_15, TSCP_DARK_ASSERT_3);
+    }
+}
 

TSCP/src/MSCP/PFM/PFM_Log.c

@@ -28,6 +28,7 @@
 #include <sys/timeb.h>
 #include <stdlib.h>
 #include "CM_IniFile.h"
+#include "CFM_Raw.h"
 
 extern CM_UINT32 g_MSCP_SysCount;
 ENUM_INIT_STAGE_FLAG g_InitUpdateFlag = ENUM_ERROR;/*- 初始化阶段标志*/
@@ -44,7 +45,14 @@ static STRU_2OO2_NET_NO_PACK_T s_2oo2_AutoReboot = {
 		
 static CM_UINT8 PFM_LOG_SHUTDOWN(CM_UINT32 darkBuf, CM_UINT32 MaintenanceFlag, const CM_CHAR *filename, const CM_CHAR *func, CM_INT32 line);
 static void PFM_LOG_MaintenanceMode(ENUM_BOARD_STATE_T boardState, CM_UINT32 MaintenanceFlag);
-static void PFM_LOG_ManageCrashlog(void);
+/* @brief 通用循环日志管理
+* @param file_type 文件类型标识
+*        0: 宕机日志 (crashlog)
+*        1: 跟踪日志 (.kev)
+*        2: 线程日志 (threads)
+* @return 无
+*/
+static void PFM_LOG_ManageFiles(CM_UINT8 file_type);
 /**
 * @brief 设置初始化阶段标志
 * @param ENUM_INIT_STAGE_FLAG stage 设置初始化阶段
@@ -219,6 +227,37 @@ void MSCP_PFM_LOG_DARK(IN const CM_UINT8 infoType, IN const CM_UINT16 code, IN c
 	(void)CFM_DarkLog_Storage(infoType, code, infoLen, info);
 }
 
+void MSCP_ASSERT_TraceLog(void)
+{
+	CM_CHAR trace_cmd[256] = {0};
+	CM_CHAR pidin_cmd[256] = {0};
+	CM_INT32 ret = 0;
+    (void)sprintf(trace_cmd, 
+             "tracelogger -c -n %d -s%d -f %s &", PFM_RECORD_BUF, PFM_RECORD_TIME_S, PFM_LATEST_TRACE_NAME);
+	ret = system(trace_cmd);
+	if (-1 == ret) 
+	{
+        (void)printf("ERROR: Failed to start tracelogger: %s\n", strerror(errno));
+		MSCP_LOG_MSG("assert's tracelogger or threads_log system fail\n");
+    }
+	else
+	{
+		;
+	}
+	(void)sprintf(pidin_cmd, 
+             "pidin -p %d threads >> %s &", getpid(),PFM_LATEST_THREADS_NAME);
+	ret = system(pidin_cmd);   
+    if (-1 == ret) 
+	{
+        (void)printf("ERROR: Failed to start pidin: %s\n", strerror(errno));
+		MSCP_LOG_MSG("assert's pidin or threads_log system fail\n");
+    }
+	else
+	{
+		;
+	}
+    CM_Sleep(PFM_RECORD_TIME_S + 1u);
+}
 
 /**
 * @brief 断言
@@ -313,6 +352,7 @@ void MSCP_ASSERT(unsigned int x, unsigned int MaintenanceFlag, unsigned short Mo
 		/*- 安全关断*/
 		DFM_saftyOff();
 
+		MSCP_ASSERT_TraceLog();
 		/*- 设置LED指示灯*/
 		if(ENUM_INIT_DRV <= PFM_LOG_GET_INIT_STAGE())
 		{
@@ -452,10 +492,12 @@ void MSCP_REBOOT_ASSERT(unsigned int x, unsigned int MaintenanceFlag,unsigned sh
 		{
 			CFM_LogCiphertextSend();
 		}
+		MSCP_ASSERT_TraceLog();
 		/*- 是否执行重启命令*/
 		if(AutoReboot_Flag == 0x55u)
 		{
 			(void)printf("See You Later!!!\n");
+			CM_Sleep(2000u);
 			(void)system("shutdown");
 			/*- 休眠等待重启 */
 			CM_Sleep(CM_UINT32_MAX);
@@ -575,7 +617,9 @@ void MSCP_Read_Del_Logfile(void)
 		}
 		/*- 关闭文件描述符 */
 		(void)fclose(pfile);
-		PFM_LOG_ManageCrashlog();
+		PFM_LOG_ManageFiles(0u);
+		PFM_LOG_ManageFiles(1u);
+		PFM_LOG_ManageFiles(2u);
 	}
 	else
 	{
@@ -820,7 +864,7 @@ static CM_UINT8 PFM_LOG_SHUTDOWN(CM_UINT32 darkBuf, CM_UINT32 MaintenanceFlag, c
 * @param darkBuf 故障码 取值范围：0~0xffffffff
 * @return 无
 */
-static void PFM_LOG_MaintenanceMode(CM_UINT32 MaintenanceFlag, CM_UINT32 darkBuf)
+static void PFM_LOG_MaintenanceMode(ENUM_BOARD_STATE_T MaintenanceFlag, CM_UINT32 darkBuf)
 {
 	/*- 变量初始化 */
 	CM_UINT64 sMaintenanceTack = CM_GetTick()/CM_UNSIGNED_MILLION;
@@ -897,49 +941,90 @@ void PFM_SendLastAssertLog(void)
 }
 
 /**
-* @brief 宕机日志管理
+* @brief 通用循环日志管理
+* @param file_type 文件类型标识
+*        0: 宕机日志 (crashlog)
+*        1: 跟踪日志 (.kev)
+*        2: 线程日志 (threads)
 * @return 无
 */
-static void PFM_LOG_ManageCrashlog(void)
+static void PFM_LOG_ManageFiles(CM_UINT8 file_type)
 {
 	/*- 读宕机文件*/
-	FILE *pcrash_num = NULL;
+    FILE *p_file = NULL;
-	CM_CHAR str_crash_new_name[256] = {0};
+    CM_CHAR str_new_name[256] = {0};
-	CM_CHAR str_crash_old_name[256] = {0};
+    CM_CHAR str_old_name[256] = {0};
-	CM_UINT32 i  = 0;
+    CM_CHAR final_name[256] = {0};
+    CM_CHAR base_name[64] = {0};
+    CM_CHAR extension[16] = {0};
+    CM_CHAR latest_file[128] = {0};
+    CM_UINT32 max_count = 0u;
+    CM_UINT32 i = 0u;
+	CM_UINT8 typeValid = 1u;
+    switch(file_type)
+    {
+        case 0u: /* 宕机日志 */
+            (void)strcpy(base_name, "crashlog_");
+            (void)strcpy(extension, ".txt");
+            (void)strcpy(latest_file, "crashlog.txt");
+            max_count = PFM_MAX_TRACE_COUNT;
+            break;
+        case 1u: /* 跟踪日志 */
+            (void)strcpy(base_name, PFM_BASE_TRACE_NAME);
+            (void)strcpy(extension, ".kev");
+            (void)strcpy(latest_file, PFM_LATEST_TRACE_NAME);
+            max_count = PFM_MAX_TRACE_COUNT;
+            break;
+        case 2u: /* 线程日志 */
+            (void)strcpy(base_name, PFM_BASE_THREADS_NAME);
+            (void)strcpy(extension, ".txt");
+            (void)strcpy(latest_file, PFM_LATEST_THREADS_NAME);
+            max_count = PFM_MAX_TRACE_COUNT;
+            break;
+        default:
+			typeValid = 0u;
+            break; /* 无效的文件类型 */
+    }
+    if(1u == typeValid)
+	{
 	/*- 查找第一个不存在的文件名 */
-	for(i = 0u;i<10u;i++)
+		for(i = 1u; i <= max_count; i++)
 	{
 		/*- 通过打开文件成功检测文件是否存在 */
-		sprintf(str_crash_new_name,"crashlog_%d.txt",i + 1u);
+			(void)sprintf(str_new_name, "%s%d%s", base_name, i, extension);
-		pcrash_num = fopen(str_crash_new_name,"r");
+			p_file = fopen(str_new_name, "r");
 		/*- 找到第一个不存在的文件名 */
-		if(NULL == pcrash_num)
+			if(NULL == p_file)
 		{
-			/*- 跳出 */
+				(void)strcpy(final_name, str_new_name);
 			break;
 		}
 		else
 		{
 			/*- 关闭文件 */
-			fclose(pcrash_num);
+				(void)fclose(p_file);
 		}
 	}
 
 	/*- 如果所有文件名都存在，删除最旧的日志（crashlog_1.txt）*/
-	if(10u == i)
+		if(i > max_count)
 	{
-		(void)strcpy(str_crash_old_name,"crashlog_1.txt");
+			(void)sprintf(str_old_name,"%s%d%s", base_name, 1u, extension);
-		(void)remove(str_crash_old_name);
+			(void)remove(str_old_name);
-		for(i = 2u;i <= 10u; i++)
+			for(i = 2u; i <= max_count; i++)
 		{
-			(void)sprintf(str_crash_new_name,"crashlog_%d.txt",i);
+				(void)sprintf(str_new_name, "%s%d%s", base_name, i, extension);
-			(void)rename(str_crash_new_name,str_crash_old_name);
+				(void)sprintf(str_old_name, "%s%d%s", base_name, i - 1u, extension);
-			(void)strcpy(str_crash_old_name,str_crash_new_name);
+				(void)rename(str_new_name, str_old_name);
 		}
+			(void)strcpy(final_name, str_new_name);
 	}
 	/*- 对文件重新命名 */
-	(void)rename("crashlog.txt",str_crash_new_name);
+		if(final_name[0] != 0)
+		{
+			(void)rename(latest_file, final_name);
+		}
+	}
 }
 /*
  * @brief 暗文日志故障码生成指针函数

TSCP/src/MSCP/PFM/PFM_Log.h

@@ -169,6 +169,13 @@ void MSCP_PFM_LOG_MSG(IN const CM_CHAR *filename, IN CM_INT32 line, IN const CM_
 
 /* 记录二进制日志 */
 #define MSCP_LOG_BIN(buf,len)  (MSCP_PFM_LOG_BIN(__FILE__,__FUNCTION__,(CM_INT32)__LINE__,(buf),(len)))
+#define PFM_MAX_TRACE_COUNT (10u)      
+#define PFM_BASE_TRACE_NAME "trace_log_" // 文件名前缀 (trace_crash_1.kev)
+#define PFM_LATEST_TRACE_NAME "trace_log_latest.kev"
+#define PFM_BASE_THREADS_NAME "threads_state_" // 文件名前缀 (threads_state_1.txt)
+#define PFM_LATEST_THREADS_NAME "threads_state_latest.txt"
+#define PFM_RECORD_TIME_S (5u)
+#define PFM_RECORD_BUF (1024)		/* 1024 * 16KB = 16MB*/
 /* 函数实现 */
 void MSCP_PFM_LOG_BIN(IN const CM_CHAR *filename, IN const CM_CHAR *func, IN CM_INT32 line, IN const CM_UINT8 *Buf, IN CM_UINT32 Len);
 
@@ -202,6 +209,7 @@ void MSCP_LOG_DATALEN(IN CM_UINT8 *Buf, IN CM_UINT32 Len, IN char *Annotation);
 CM_UINT8 PFM_LOG_GET_STOP_FLAG(void);
 
 void PFM_SendLastAssertLog(void);
+void MSCP_ASSERT_TraceLog(void);
 CM_UINT32 *PFM_DarkLogGenerate(CM_UINT16 mode, CM_UINT16 fault, CM_UINT16 num);
 #define DARK_FAULT_CODE_MERGE(Mode,faultCode,funNum) (PFM_DarkLogGenerate(Mode,faultCode,funNum))
 /***************************暗文日志故障码信息编码表****************************/

TSCP/src/MSCP/PFM/PFM_RemoteUpdate.c

@@ -2219,16 +2219,23 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 			MSCP_LOG_MSG("error pack 0xa8 localState = %d partnerState = %d\n", localState, partnerState);
 			(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_14, TSCP_DARK_ASSERT_9));
 		}
+		else if(s_packFirstRecvTimer != s_packFirstSendTimer)
+		{
+			s_packSwitchAccredit = 1u;
+			s_switchAuthorization = 12u;
+			MSCP_LOG_MSG("error pack 0xa8 s_firstTimer = %d packTimer = %d\n", s_packFirstSendTimer, s_packFirstRecvTimer);
+			(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_14, TSCP_DARK_ASSERT_10));
+		}
 		else
 		{
 			/*- 二次至切系状态状态 */
 			s_switchRmFlag = 0x55u;
 			s_packSwitchAccredit = 0u;
 			s_switchAuthorization = 0u;
+			s_firstState = ENUM_2x2_SHUTDOWN;
 		}
 		/*再次应答*/
 		recvType = 0x58u;
-		s_firstState = ENUM_2x2_SHUTDOWN;
 	}
 	/*- 切系命令请求回复 */
 	PFM_RemoteSwitch_Send(recvType,packTimer,s_packSwitchAccredit,s_switchAuthorization);

TSCP/src/MSCP/SFM/SFM_2oo2.c

@@ -54,6 +54,7 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
 static void s_2oo2_Send_Crash(IN const CM_UINT8 *Data, IN CM_INT32 DataLen, STRU_2OO2_CTRL_T *p_2oo2_Ctrl,IN ENUM_2oo2_MSG_T msgType);
 /* 维护模式2oo2接收 */
 static CM_INT32 s_2oo2_Recv_Crash(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT ENUM_2oo2_MSG_T *pMsgType,STRU_2OO2_CTRL_T *p_2oo2_Ctrl);
+static ENUM_CM_RETURN s_isClac2oo2Crc(ENUM_2oo2_MSG_T type);
 /**
 * @brief 2oo2上电初始化
 * @param vitalBuf 关键数据数组
@@ -245,6 +246,9 @@ static void s_2oo2_Send(IN const CM_UINT8 *Data, IN CM_INT32 DataLen, STRU_2OO2_
     CM_UINT16 FrameIndex = 0u;   /* 帧序号 */
     CM_UINT32 FrameLen = 0u;     /* 帧长度 */
     CM_UINT32 SysCyc = SFM_2x2_GetSysCount(); /*系统周期号*/
+    CM_UINT32 crc = 0u;
+    ENUM_CM_RETURN clacCrcFlag = ENUM_CM_TRUE;         /* 判断是否计算CRC*/
+    clacCrcFlag = s_isClac2oo2Crc(msgType);
     PFM_LOG_SET_STOPTIMER(TSCP_DARK_2OO2);
     /*- 入口检查 */
     CM_ASSERT(((DataLen >= 0) && (NULL != Data) && (NULL != p_2oo2_Ctrl) && (NULL != p_2oo2_Ctrl->DataSend)), SFM_2oo2_MODE, DARK_FAULT_CODE_FUN_ORDER_5, TSCP_DARK_ASSERT_1);
@@ -281,9 +285,17 @@ static void s_2oo2_Send(IN const CM_UINT8 *Data, IN CM_INT32 DataLen, STRU_2OO2_
 		{
 			CM_ShortToChar(FrameIndex, p_2oo2_Ctrl->UDP_Cache + 23);         /* 帧序号 */
 			(void)CM_Memcpy((void*)(p_2oo2_Ctrl->UDP_Cache + 25),(CM_SIZE_T)NET_20K_SIZE, (const void*)(Data + ((FrameIndex - 1u)*NET_20K_SIZE)), (CM_SIZE_T)NET_20K_SIZE); /* parasoft-suppress MISRA2004-17_1 MISRA2004-17_4 "指针运算提高代码执行效率" */
-
+            if(ENUM_CM_TRUE == clacCrcFlag)
+            {
+                CM_LongToChar(NET_20K_SIZE + 25u, p_2oo2_Ctrl->UDP_Cache);        /* 长度（填写满帧） */
+                crc = CM_Crc32(p_2oo2_Ctrl->UDP_Cache, NET_20K_SIZE + 25);
+                CM_LongToChar(crc, &p_2oo2_Ctrl->UDP_Cache[NET_20K_SIZE + 25]);
+                (void)p_2oo2_Ctrl->DataSend(p_2oo2_Ctrl->UDP_Cache, (CM_INT32)(29u + NET_20K_SIZE));  /* 交给通信层发送 */
+            }
+            else
+            {
 			(void)p_2oo2_Ctrl->DataSend(p_2oo2_Ctrl->UDP_Cache, (CM_INT32)(25u + NET_20K_SIZE));  /* 交给通信层发送 */
-
+            }
 		}
 
 		/*- 发送尾帧 */
@@ -291,8 +303,17 @@ static void s_2oo2_Send(IN const CM_UINT8 *Data, IN CM_INT32 DataLen, STRU_2OO2_
 		FrameLen = (CM_UINT32)DataLen - ((FrameIndex - 1u)*NET_20K_SIZE);
 		(void)CM_Memcpy((void*)(p_2oo2_Ctrl->UDP_Cache + 25), (CM_SIZE_T)NET_20K_SIZE, (const void*)(Data + ((FrameIndex - 1u)*NET_20K_SIZE)), (CM_SIZE_T)FrameLen); /* parasoft-suppress MISRA2004-17_1 MISRA2004-17_4 "指针运算提高代码执行效率" */
 		CM_LongToChar(21u + FrameLen, p_2oo2_Ctrl->UDP_Cache);       /*长度*/
-
+        if(ENUM_CM_TRUE == clacCrcFlag)
+        {
+            CM_LongToChar(25u + FrameLen, p_2oo2_Ctrl->UDP_Cache);       /*长度*/
+            crc = CM_Crc32(p_2oo2_Ctrl->UDP_Cache, FrameLen + 25);
+            CM_LongToChar(crc, &p_2oo2_Ctrl->UDP_Cache[FrameLen + 25]);
+            (void)p_2oo2_Ctrl->DataSend(p_2oo2_Ctrl->UDP_Cache, (CM_INT32)CM_UNSIGNED_INT_EXP(29u + FrameLen));   /* 交给通信层发送 */
+        }
+        else
+        {
 		(void)p_2oo2_Ctrl->DataSend(p_2oo2_Ctrl->UDP_Cache, (CM_INT32)CM_UNSIGNED_INT_EXP(25u + FrameLen));   /* 交给通信层发送 */
+        }
 		PFM_LOG_SET_STOPTIMER(TSCP_DARK_NULL);
     }
     else
@@ -313,6 +334,7 @@ static void s_2oo2_ARQ_Send(STRU_2OO2_CTRL_T *p_2oo2_Ctrl,IN ENUM_2oo2_MSG_T msg
 {
     /*- 变量初始化 */
     CM_UINT32 SysCyc = SFM_2x2_GetSysCount(); /*系统周期号*/
+    CM_UINT32 crc = 0u;
 	/*- 入口检查 */
     CM_ASSERT(((NULL != p_2oo2_Ctrl) && (NULL != p_2oo2_Ctrl->DataSend)), SFM_2oo2_MODE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_1);
     /*
@@ -327,15 +349,17 @@ static void s_2oo2_ARQ_Send(STRU_2OO2_CTRL_T *p_2oo2_Ctrl,IN ENUM_2oo2_MSG_T msg
     4字节 CRC(含长度)
     */
     /*- 填充报文头 */
-    CM_LongToChar(19u, p_2oo2_Ctrl->UDP_Cache);        /* 长度（暂时填写满帧） */
+    CM_LongToChar(23u, p_2oo2_Ctrl->UDP_Cache);        /* 长度（暂时填写满帧） */
     CM_LongToChar(p_2oo2_Ctrl->LocalID, p_2oo2_Ctrl->UDP_Cache + 4);  /* 源ID */
     CM_LongToChar(p_2oo2_Ctrl->PeerID, p_2oo2_Ctrl->UDP_Cache + 8);   /* 目的ID */
     CM_LongToChar(SysCyc, p_2oo2_Ctrl->UDP_Cache + 12);              /* 周期号 */
     CM_LongToChar(p_2oo2_Ctrl->SN, p_2oo2_Ctrl->UDP_Cache + 16);      /* 序列号 */
     p_2oo2_Ctrl->UDP_Cache[20] = (CM_UINT8)msgType;                  /* 类型 */
     CM_ShortToChar(FrameIndex, p_2oo2_Ctrl->UDP_Cache + 21);         /* 重传序号 */
+    crc = CM_Crc32(p_2oo2_Ctrl->UDP_Cache, 23);
+    CM_LongToChar(crc, p_2oo2_Ctrl->UDP_Cache + 23);
 
-    (void)p_2oo2_Ctrl->DataSend(p_2oo2_Ctrl->UDP_Cache, (CM_INT32)23);   /* 交给通信层发送 */
+    (void)p_2oo2_Ctrl->DataSend(p_2oo2_Ctrl->UDP_Cache, (CM_INT32)27);   /* 交给通信层发送 */
 }
 /**
 * @brief 2oo2接收支持重传
@@ -366,7 +390,9 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
     CM_INT32 allLen = 0;      /* 收到的报文总长度 */
     CM_UINT8 type = 0u;       /* 报文类型 */
     CM_UINT16 ARQ_Cut = 0u;   /* 记录重传请求次数 */
-
+    CM_UINT32 msgCrc = 0u;    /* 报文CRC */
+    CM_UINT32 calcCrc = 0u;   /* 本地计算CRC */
+    ENUM_CM_RETURN clacCrcFlag = ENUM_CM_TRUE;         /* 判断是否计算CRC*/
     CM_UINT16 ARQ_FrameStart = 0u;/* 重传帧序号 */
     CM_UINT8 MineRcvSuccessFlag = CM_FALSE;/*本机接收完成标志*/
     CM_UINT8 PeerRcvSuccessFlag = CM_FALSE;/*对系接收完成标志*/
@@ -385,7 +411,7 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
         /*- 从通信层接收2oo2报文 */
         rxLen = p_2oo2_Ctrl->DataRecv(p_2oo2_Ctrl->UDP_Cache, (CM_UINT32)sizeof(p_2oo2_Ctrl->UDP_Cache));
         /*- 收到的报文长度是否大于23 */
-        if (23 <= rxLen)
+        if (25 <= rxLen)
         {
             
             /*- 解析2oo2报文头 */
@@ -408,11 +434,22 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
             msgCyc = CM_LongFromChar(p_2oo2_Ctrl->UDP_Cache + 12);
             msgSN = CM_LongFromChar(p_2oo2_Ctrl->UDP_Cache + 16);
             type = p_2oo2_Ctrl->UDP_Cache[20];
+            clacCrcFlag = s_isClac2oo2Crc(type);
+            if(ENUM_CM_TRUE == clacCrcFlag)
+            {
+				msgCrc = CM_LongFromChar(p_2oo2_Ctrl->UDP_Cache + msgLen);
+				calcCrc = CM_Crc32(p_2oo2_Ctrl->UDP_Cache, msgLen);
+            }
+            else
+            {
+                calcCrc = msgCrc;
+            }
 			if (((msgLen + 4u) == (CM_UINT32)rxLen)
 				&& (SrcID == p_2oo2_Ctrl->PeerID)
 				&& (DstID == p_2oo2_Ctrl->LocalID)
 				&& (msgCyc == sysCyc)
-				&& (msgSN == p_2oo2_Ctrl->SN))
+				&& (msgSN == p_2oo2_Ctrl->SN)
+                && (msgCrc == calcCrc))
 			{
 				switch(type)
 				{
@@ -444,7 +481,14 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
 					if (CM_FALSE == MineRcvSuccessFlag)
 					{
 						pData = p_2oo2_Ctrl->UDP_Cache + 25;
+                        if(ENUM_CM_TRUE == clacCrcFlag)
+                        {
+                            DataLen = (CM_INT32)msgLen - 25;
+                        }
+                        else
+                        {
 						DataLen = (CM_INT32)msgLen - 21;
+                        }
 						/*- 分帧接收2oo2报文 */
 						ret = SFM_FrameSave(&p_2oo2_Ctrl->FrameCtrl, type, FrameNum, FrameIndex, pData, DataLen, RxData, &allLen, RxSize);
 						/*- 是否收齐了完整2oo2报文 */
@@ -477,9 +521,9 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
 			}
 			else
 			{
-				MSCP_LOG_MSG("len=[%d,%d]src=[%d,%d]dst=[%d,%d]cyc=[%d,%d]sn=[%d,%d],type=%d\n",
+				MSCP_LOG_MSG("len=[%d,%d]src=[%d,%d]dst=[%d,%d]cyc=[%d,%d]sn=[%d,%d],type=%d, crc:%d, calcrc:%d\n",
 							rxLen, msgLen, SrcID, p_2oo2_Ctrl->PeerID, DstID, p_2oo2_Ctrl->LocalID,
-							msgCyc, sysCyc, msgSN, p_2oo2_Ctrl->SN,type);
+							msgCyc, sysCyc, msgSN, p_2oo2_Ctrl->SN,type, msgCrc, calcCrc);
 				(void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_2OO2_RCV_ERR,11u,
 										sizeof(CM_INT32),rxLen,
 										sizeof(CM_UINT32),msgLen,
@@ -975,7 +1019,7 @@ void SFM_2oo2_Reset_AutoRbootCut(void)
 			RM_Reset_FaultRbootCut(0);
 			CM_RE_ASSERT(cut == 0u, SFM_2oo2_MODE, DARK_FAULT_CODE_FUN_ORDER_12, TSCP_DARK_ASSERT_2);
 			/*- 同时修改时间阈值*/
-			g_PFM_Cfg.M_AutoClear_Second += g_PFM_Cfg.M_AutoClear_Days*24u*60u*60u;;
+			g_PFM_Cfg.M_AutoClear_Second += g_PFM_Cfg.M_AutoClear_Days*24u*60u*60u;
 		}
 		else
 		{
@@ -983,6 +1027,19 @@ void SFM_2oo2_Reset_AutoRbootCut(void)
 		}
 	}
 }
+static ENUM_CM_RETURN s_isClac2oo2Crc(ENUM_2oo2_MSG_T type){
+    ENUM_CM_RETURN rt = ENUM_CM_TRUE;
+    switch (type)
+    {
+    case ENUM_2oo2_INPUT_EX:
+    case ENUM_2oo2_END_EX:
+        rt = ENUM_CM_FALSE;
+        break;
+    default:
+        break;
+    }
+    return rt;
+}
 
 /**
  * @brief 初始化2取控制数据以及清空2取缓冲区

TSCP/src/MSCP/SFM/SFM_2x2.c

@@ -65,7 +65,7 @@ static CM_UINT8 g_TxBaseFollow[SFM_FOLLOW_BUFF_SIZE]; /**< 发送的平台跟随
 static CM_INT32 g_RxAppFollow_len = 0;               /**< 收到的应用跟随数据长度 */
 static CM_UINT8 g_RxAppFollow[MSCP_FOLLOW_BUFF_SIZE*2]; /**< 收到的应用跟随数据报文 */
 static CM_INT32 g_RxAppFollowCrc_len = 0;               /**< 收到的应用跟随数据长度 */
-static CM_UINT8 g_RxAppFollowCrc[8]; /**< 收到的应用跟随数据报文 */
+static CM_UINT8 g_RxAppFollowCrc[12]; /**< 收到的应用跟随数据报文 */
 CM_INT32 g_TxAppFollow_len = 0;               /**< 发送的应用跟随数据长度 */
 CM_UINT8 g_TxAppFollow[MSCP_FOLLOW_BUFF_SIZE*2]; /**< 发送的应用跟随数据报文 */
 
@@ -96,7 +96,27 @@ static CM_BOOL s_State_2x2_Analysis(OUT STRU_2X2_STATE_CTRL_T *p_partner_state,C
 /*2x状态同步*/
 static ENUM_CM_RETURN s_State_2x2Sync(OUT STRU_2X2_STATE_CTRL_T *p_partner_state);
 static void s_State_Transition(void);
+/**
+ * @brief 输入阶段,主系发送平台跟随数据前的2oo2比较
+ */
+static void s_2x2_BaseFollow_2oo2Check_Send(void);
+/**
+ * @brief 输入阶段，非主系进行相关CRC校验后跟随
+ */
+static void s_2x2_BaseFollow_Sync(void);
+/**
+ * @brief 周期末阶段，备系接收主系应用跟随CRC后的比较逻辑
+ */
+static void s_2x2_AppFollow_SyncCheck(void);
+/**
+ * @brief 输出阶段，备系接收主系输出数据CRC后的比较逻辑
+ */
+static void s_2x2_Output_SyncCheck(IN const CM_UINT8 *CheckBuf, CM_INT32 CheckLen);
 
+/**
+ * 统一置切系标志
+ */
+static void s_2x2_CloseSwitchFlag(void);
 /**
 * @brief 2X状态切换独立线程
 */
@@ -206,7 +226,7 @@ static void s_State_Switch(void)
 			{
 				s_timeSecond = CM_GetTick();
 				/*- 当次按下时间距第一次按下时间相差3s,则判断是否需要切系 */
-				if(s_timeSecond - s_timeFirst >= MSCP_2X2_SWITCH_3S)
+				if((s_timeSecond - s_timeFirst) >= MSCP_2X2_SWITCH_3S)
 				{
 					/*- 如果未切系则准备切系,如果以切系则休眠后继续等待松开按钮,防止持续按压 */
 					if((s_LocalState == s_2x2_state_Ctrl.LocalState) && (s_PartnerState == s_2x2_state_Ctrl.PartnerState))
@@ -686,6 +706,7 @@ static void s_State_Transition(void)
 		s_2x2_state_Ctrl.PartnerState = ENUM_2x2_SHUTDOWN;
 		/*通信SN号清空-防止对系重新上电后不接收新的SN号*/
 		s_2x2_state_Ctrl.RxSN = 0u;
+		s_2x2_state_Ctrl.RxStateSysCyc = 0u;
 	}
 	else
 	{
@@ -725,7 +746,7 @@ static void s_State_Transition(void)
 			{
 				/*- 无处理 */
 				SFM_LOG_MSG_2X("Transition:2x2:OFFLINE>SLAVE SysCyc:%d,BF:%d,AF:%d,COK:%d,OUT:%d,TS:%d,AFC:%d\n",
-						s_2x2_state_Ctrl.SysCyc,s_2x2_state_Ctrl.LastRxInputSysCyc,
+						s_2x2_state_Ctrl.SysCyc,s_2x2_state_Ctrl.LastRxInputSysCyc,s_2x2_state_Ctrl.LastFollowCyc,
 						s_2x2_state_Ctrl.LastCheckOKCount,s_2x2_state_Ctrl.OutPutCheckFailFlag,
 						s_2x2_state_Ctrl.TimeSyncFlag,
 						s_2x2_state_Ctrl.AppFollowCmpFlag);
@@ -765,7 +786,7 @@ static void s_State_Transition(void)
 			/*如果自己将离开离线状态，复位离线计时器*/
 			s_2x2_state_Ctrl.offLineCounter = 0u;
 		}
-		else if ((ENUM_2x2_OFFLINE == s_2x2_state_Ctrl.PartnerState) || (ENUM_2x2_SHUTDOWN == s_2x2_state_Ctrl.PartnerState))
+		else if (((ENUM_2x2_OFFLINE == s_2x2_state_Ctrl.PartnerState) || (ENUM_2x2_SHUTDOWN == s_2x2_state_Ctrl.PartnerState)) && (CM_TRUE == s_2x2_state_Ctrl.preMasterAllowed))
 		{
 			/*如果对系宕机或离线，累积离线计时*/
 			if (s_2x2_state_Ctrl.offLineCounter <= (MSCP_2x2_OFFLINE_WAIT * (s_2x2_thread_Ctrl.number_Cyc - 1u)))
@@ -842,22 +863,14 @@ static void s_State_Transition(void)
 		/*- 返回 */
 		break;
 	case ENUM_2x2_MASTER:/*-< 主系 */
+		s_2x2_state_Ctrl.preMasterAllowed = CM_TRUE;		/* 主系降离线后，之后出现双离线可通过预升主升主*/
 		/*如果健康度表示需要切系，则自己降离线*/
 		/*- 自己是否健康度不足 */
 		if (ENUM_CM_TRUE == Flag_Sick_Down)
 		{
 			/*- 本系降离线 */
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
-			s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+			s_2x2_CloseSwitchFlag();
-			s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
-			s_2x2_state_Ctrl.aidSwitchFlag = 0u;
 #if 0
 			s_2x2_state_Ctrl.RxBaseFollowSysCyc = 0u; /**< 收到的对系跟随数据的周期号，2oo2交换 */
 			s_2x2_state_Ctrl.RxAppFollowSysCyc = 0u;  /**< 收到的对系应用跟随数据的周期号，2oo2交换 */
@@ -899,37 +912,19 @@ static void s_State_Transition(void)
 			}
 
 		}
-		else if((ENUM_2x2_SLAVE == s_2x2_state_Ctrl.PartnerState) && (ENUM_2x2_SWITCH_OPEN == s_2x2_state_Ctrl.LocalSwitchState) &&
+		else if((ENUM_2x2_SLAVE == s_2x2_state_Ctrl.PartnerState) && (ENUM_2x2_SLAVE == s_2x2_state_Ctrl.LastPartnerState) && (ENUM_2x2_SWITCH_OPEN == s_2x2_state_Ctrl.LocalSwitchState) &&
 				(ENUM_2x2_SWITCH_OPEN == s_2x2_state_Ctrl.PartnerSwitchState) && (1u == s_2x2_state_Ctrl.ctrSwitchFlag) && (0u == s_2x2_state_Ctrl.MicroCyc))
 		{
 			/*- 检测到对系是备系，且双系切系按钮状态为ENUM_2x2_SWITCH_OPEN，主系降为备系*/
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_SLAVE;
-			s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+			s_2x2_CloseSwitchFlag();
-			s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
-			s_2x2_state_Ctrl.aidSwitchFlag = 0u;
 			SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>SLAVE(SWITCH)\n");
 		}
 		else if((ENUM_2x2_SLAVE == s_2x2_state_Ctrl.PartnerState) && (1u == s_2x2_state_Ctrl.aidSwitchFlag) && (0u == s_2x2_state_Ctrl.MicroCyc))
 		{
 			/*- 检测到对系是备系，且允许AID切系， 主系降为备系*/
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_SLAVE;
-			s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+			s_2x2_CloseSwitchFlag();
-			s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
-			s_2x2_state_Ctrl.aidSwitchFlag = 0u;
 			SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>SLAVE(AID SWITCH)\n");
 		}
 		else
@@ -939,6 +934,7 @@ static void s_State_Transition(void)
 		/*- 返回 */
 		break;
 	case ENUM_2x2_SLAVE:/*-< 备系 */
+		s_2x2_state_Ctrl.preMasterAllowed = CM_FALSE;		/* 备系降离线后，禁止通过预升主升主*/
 		/*- 自己是否健康度不足 */
 		if (ENUM_CM_TRUE == Flag_Sick_Down)
 		{
@@ -967,6 +963,11 @@ static void s_State_Transition(void)
 			{
 				/*不存在断线，判断为宕机或断电升主*/
 				/*- 本系升主 */
+				if(ENUM_2x2_SLAVE != s_2x2_state_Ctrl.LastLocalState && ENUM_2x2_MASTER != s_2x2_state_Ctrl.LastLocalState)
+				{
+					/* 升备后应用还没有成功跟随过，禁止升主，主系宕机，跟随宕机*/
+					CM_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_6);
+				}
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_MASTER;
 				s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
 				s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
@@ -980,6 +981,7 @@ static void s_State_Transition(void)
 				s_2x2_state_Ctrl.PartnerState = ENUM_2x2_SHUTDOWN;
 				/*通信SN号清空-防止对系重新上电后不接收新的SN号*/
 				s_2x2_state_Ctrl.RxSN = 0u;
+				s_2x2_state_Ctrl.RxStateSysCyc = 0u;
 				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER！！！(ALL interrupt)\n");
 			}
 			else
@@ -994,42 +996,37 @@ static void s_State_Transition(void)
 				CM_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_5);
 			}
 		}
-		else if((ENUM_2x2_OFFLINE == s_2x2_state_Ctrl.PartnerState) ||
+		else if((ENUM_2x2_MASTER != s_2x2_state_Ctrl.PartnerState) &&/*TODO 对系状态必须是最新的*/
-				((ENUM_2x2_MASTER != s_2x2_state_Ctrl.PartnerState) &&/*TODO 对系状态必须是最新的*/
+				 (ENUM_2x2_MASTER == s_2x2_state_Ctrl.LastLocalState))
-				 (ENUM_2x2_MASTER == s_2x2_state_Ctrl.LastLocalState)))
 		{
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_MASTER;
-			s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+			s_2x2_CloseSwitchFlag();
-			s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
-			s_2x2_state_Ctrl.aidSwitchFlag = 0u;
 			SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER(ROLLBACK\n");
 		}
+		else if(ENUM_2x2_OFFLINE == s_2x2_state_Ctrl.PartnerState)
+		{
+			if(ENUM_2x2_SLAVE != s_2x2_state_Ctrl.LastLocalState)
+			{
+				s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
+				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>OFFLINE(Master OFFLINE SLAVE DOWN\n");
+			}
+			else
+			{
+				s_2x2_state_Ctrl.LocalState = ENUM_2x2_MASTER;
+				s_2x2_CloseSwitchFlag();
+				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER(Master OFFLINE SLAVE UP\n");
+			}
+		}
 		/*- 与主系输出不一致 或应用跟随数据不一致*/
 		else if((1u == s_2x2_state_Ctrl.OutPutCheckFailFlag) || (1u == s_2x2_state_Ctrl.AppFollowCmpFlag))
 		{
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 			SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>OFFLINE(OutPut failed)\n");
-			s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+			s_2x2_CloseSwitchFlag();
-			s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
-			s_2x2_state_Ctrl.aidSwitchFlag = 0u;
 		}
 		else if((ENUM_2x2_MASTER == s_2x2_state_Ctrl.PartnerState) &&
 				((1u == s_2x2_state_Ctrl.aidSwitchFlag)||(1u == s_2x2_state_Ctrl.ctrSwitchFlag)) &&
-				 (0u == s_2x2_state_Ctrl.MicroCyc))
+				 (0u == s_2x2_state_Ctrl.MicroCyc) && (ENUM_2x2_SLAVE == s_2x2_state_Ctrl.LastLocalState))
 		{
 			/*是否满足至少一个以太网和任一通道*/
 			if(((ENUM_CM_TRUE == MSCP_Get_2X_Com_State(&s_2x2_state_Ctrl.MineComOKCount[0],0u)) &&
@@ -1051,16 +1048,7 @@ static void s_State_Transition(void)
 				/*报警禁止切系*/
 				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>SLAVE(NOT MASTER)\n");
 			}
-			s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+			s_2x2_CloseSwitchFlag();
-			s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
-			s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
-			s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
-			s_2x2_state_Ctrl.aidSwitchFlag = 0u;
 		}
 		/*- 与对系是否同步超时 */
 		else if ((s_2x2_state_Ctrl.SysCyc - s_2x2_state_Ctrl.LastCheckOKCount)  >= MSCP_2X2_SYNC_TIMEOUT_CYC)
@@ -1123,7 +1111,7 @@ static CM_THREAD_FUNC_T  SFM_2x2_StateChange_Thread(void)
 			/*- 无处理*/
 		}
 		/*微小周期执行*/
-		for(s_2x2_state_Ctrl.MicroCyc = 0;s_2x2_state_Ctrl.MicroCyc < s_2x2_thread_Ctrl.number_Cyc;s_2x2_state_Ctrl.MicroCyc++)
+		for(s_2x2_state_Ctrl.MicroCyc = 0u;s_2x2_state_Ctrl.MicroCyc < s_2x2_thread_Ctrl.number_Cyc;s_2x2_state_Ctrl.MicroCyc++)
 		{
 			/*- 记录起始时间*/
 			sTick = CM_GetTick();
@@ -1175,7 +1163,7 @@ static CM_THREAD_FUNC_T  SFM_2x2_StateChange_Thread(void)
 				/*- 记录当前时间*/
 				CM_Sleep(1);
 				curTick[5] = CM_GetTick();
-			}while(((curTick[5] - sTick) < MSCP_2X2_THREAD_TIME*CM_UNSIGNED_MILLION) && (s_2x2_state_Ctrl.MicroCyc < s_2x2_thread_Ctrl.number_Cyc-1u) /*ms*/);
+			}while(((curTick[5] - sTick) < (MSCP_2X2_THREAD_TIME*CM_UNSIGNED_MILLION)) && (s_2x2_state_Ctrl.MicroCyc < (s_2x2_thread_Ctrl.number_Cyc-1u)) /*ms*/);
 			SFM_LOG_MSG_2X("2x2_StateChange_Thread[%d],ST:%dms,2T1:%dms,XT:%dms,2T2:%dms,TT:%dms,OT:%dms,M:%d,S:%d\n",s_2x2_state_Ctrl.MicroCyc,
 					(curTick[0] - sTick)/CM_UNSIGNED_MILLION,(curTick[1] - sTick)/CM_UNSIGNED_MILLION,
 					(curTick[2] - sTick)/CM_UNSIGNED_MILLION,(curTick[3] - sTick)/CM_UNSIGNED_MILLION,
@@ -1435,6 +1423,7 @@ void SFM_2x2_Init(IN const CM_UINT8 *VitalBuf, IN CM_UINT16 VitalLen, INOUT CM_U
         CM_Sem_Init(&s_2x2_thread_Ctrl.m_Start);
         CM_Sem_Init(&s_2x2_thread_Ctrl.m_Stop);
 
+		s_2x2_state_Ctrl.preMasterAllowed = CM_TRUE;
         /*初始化应用跟随数据缓冲区*/
         g_TxAppFollow_len = 4;
         CM_LongToChar(0u, g_TxAppFollow);
@@ -1499,11 +1488,11 @@ void SFM_2x2_Init(IN const CM_UINT8 *VitalBuf, IN CM_UINT16 VitalLen, INOUT CM_U
             {
                 offset = (myOffset + peerOffset) / 2u;
             }
-            else if (myOffset < MSCP_CYC_TIME * CM_UNSIGNED_MILLION)
+            else if (myOffset < (MSCP_CYC_TIME * CM_UNSIGNED_MILLION))
             {
                 offset = myOffset;
             }
-            else if (peerOffset < MSCP_CYC_TIME * CM_UNSIGNED_MILLION)
+            else if (peerOffset < (MSCP_CYC_TIME * CM_UNSIGNED_MILLION))
             {
                 offset = peerOffset;
             }
@@ -1931,7 +1920,7 @@ static void s_2x2_Recv(void)
 							if (ENUM_CM_TRUE == ret)
 							{
 								/*- 更新跟随报文状态 */
-								CM_RE_ASSERT(8 <= g_RxBaseFollow_len, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_4);
+								CM_RE_ASSERT(16 <= g_RxBaseFollow_len, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_4);
 								s_2x2_Ctrl.RxBaseFollowSysCyc = msgCyc;
 								MSCP_LOG_MSG("2x2 RxBaseFollowCyc = %d,rcvlen = %d,Time:%d us\r\n", msgCyc,g_RxBaseFollow_len,NOW_USED_TIME);
 							}
@@ -1998,7 +1987,7 @@ static void s_2x2_Recv(void)
 							if (ENUM_CM_TRUE == ret)
 							{
 								/*- 更新跟随报文状态 */
-								CM_RE_ASSERT(8 == g_RxAppFollowCrc_len, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_18);
+								CM_RE_ASSERT(12 == g_RxAppFollowCrc_len, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_18);
 								s_2x2_Ctrl.RxAppFollowSysCyc = msgCyc;
 								MSCP_LOG_MSG("2x2 RxAppFollowCrcCyc = %d,rcvlen = %d,Time:%d us\r\n", msgCyc,g_RxAppFollowCrc_len,NOW_USED_TIME);
 							}
@@ -2105,13 +2094,13 @@ static void s_2x2_Recv(void)
 								CM_RE_ASSERT(FrameNum <= (SFM_OUTNETSAFE_BUFF_SIZE / NET_20K_SIZE), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_15);
 								CM_RE_ASSERT(FrameIndex <= FrameNum, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_16);
 								ret = SFM_2X_FrameSave(&s_2x2_FrameCtrl, (CM_UINT8)type, FrameNum, FrameIndex, pData, DataLen,
-									g_2x2oo2_rx[g_2x2oo2_base][type-g_2x2oo2_data_num].p_rmt_peer_buf,
+									g_2x2oo2_rx[g_2x2oo2_base][(CM_INT32)type-g_2x2oo2_data_num].p_rmt_peer_buf,
-									&g_2x2oo2_rx[g_2x2oo2_base][type-g_2x2oo2_data_num].rmt_peer_len,
+									&g_2x2oo2_rx[g_2x2oo2_base][(CM_INT32)type-g_2x2oo2_data_num].rmt_peer_len,
-									(CM_UINT32)g_2x2oo2_rx[g_2x2oo2_base][type-g_2x2oo2_data_num].buf_size);
+									(CM_UINT32)g_2x2oo2_rx[g_2x2oo2_base][(CM_INT32)type-g_2x2oo2_data_num].buf_size);
 								/*记录对系邻机数据长度*/
-								s_2x2_Ctrl.InPutDoublePassLen[type-g_2x2oo2_data_num][1] = g_2x2oo2_rx[g_2x2oo2_base][type-g_2x2oo2_data_num].rmt_peer_len;	
+								s_2x2_Ctrl.InPutDoublePassLen[(CM_INT32)type-g_2x2oo2_data_num][1] = g_2x2oo2_rx[g_2x2oo2_base][(CM_INT32)type-g_2x2oo2_data_num].rmt_peer_len;	
 								/*- 是否收齐了全部数据同步报文 */
-								if ((ENUM_CM_TRUE == ret) && (type == g_2x2RcvMaxNum[1]))
+								if ((ENUM_CM_TRUE == ret) && ((CM_UINT8)type == g_2x2RcvMaxNum[1]))
 								{
 									/*- 更新对系输入状态 */
 									s_2x2_Ctrl.InputPeerSysCyc = msgCyc;
@@ -2186,38 +2175,30 @@ void SFM_2x2_InputProc(void)
     STRU_2X2_CTRL_T peerCtrl; /* 邻机热备状态 */
     CM_INT32 ret = 0;       /* 临时变量 */
     CM_UINT32 sysCyc = SFM_2x2_GetSysCount();  /* 系统周期号 */
-    CM_UINT32 len_prtcl = 0u; /* 协议跟随数据长度 */
-    CM_UINT32 len_sfprtcl = 0u; /* 协议跟随数据长度 */
-    CM_UINT32 len_pfm = 0u;   /* 平台跟随数据长度 */
     CM_UINT64 sTick = 0u; /* 起始Tick */
     CM_UINT64 delta_Tick = 0u; /* Tickze增量 */
     CM_UINT64 curTick = 0u; /* 当前Tick */
     CM_UINT32 len = 0u;        /* 临时变量 */
 	/*######################## 发送跟随数据（主系）########################*/
     PFM_CFC_Check(33);
-	/*- 本系是否为主 */
+	/*- 填写适配层(-1)跟随数据 */
-	if ((ENUM_2x2_MASTER == s_2x2_Ctrl.LocalState))
+	len = SFM_GetPrtclFollowData(g_TxBaseFollow + 4, (CM_UINT32)(sizeof(g_TxBaseFollow)) - 4u);
+	CM_LongToChar(len, g_TxBaseFollow);
+	g_TxBaseFollow_len = (CM_INT32)len + 4;
+	/*- 填写内网sfp跟随数据 */
+	len = SFM_GetSfpPrtclFollowData(g_TxBaseFollow + g_TxBaseFollow_len, (CM_UINT32)(sizeof(g_TxBaseFollow)- g_TxBaseFollow_len - 4u));
+	g_TxBaseFollow_len += len;
+	/*- 填写平台跟随数据 */
+	/*- 填写平台跟随数据 */
+	CM_RE_ASSERT(g_TxBaseFollow_len <= ((CM_INT32)sizeof(g_TxBaseFollow) - 12u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_7, TSCP_DARK_ASSERT_9);/*输出缓冲至少空闲8字节*/
+	CM_LongToChar(8u, g_TxBaseFollow + g_TxBaseFollow_len);
+	CM_LongToChar(sysCyc, g_TxBaseFollow + g_TxBaseFollow_len + 4u);
+	CM_LongToChar(SFM_GetTxSn(), g_TxBaseFollow + g_TxBaseFollow_len + 8u);
+	g_TxBaseFollow_len += 12u;
+	/* 2取比较后,若为主系执行发送*/
+	if(0x55u == g_PFM_Cfg.M_2oo2_Enable)
 	{
-		/*- 填写适配层(-1)跟随数据 */
+		s_2x2_BaseFollow_2oo2Check_Send();
-	   len = SFM_GetPrtclFollowData(g_TxBaseFollow + 4, (CM_UINT32)(sizeof(g_TxBaseFollow)) - 4u);
-	   CM_LongToChar(len, g_TxBaseFollow);
-	   g_TxBaseFollow_len = (CM_INT32)len + 4;
-	   /*- 填写内网sfp跟随数据 */
-	   len = SFM_GetSfpPrtclFollowData(g_TxBaseFollow + g_TxBaseFollow_len, (CM_UINT32)(sizeof(g_TxBaseFollow)- g_TxBaseFollow_len - 4u));
-	   g_TxBaseFollow_len += len;
-	   /*- 填写平台跟随数据 */
-	   /*- 填写平台跟随数据 */
-	   CM_RE_ASSERT(g_TxBaseFollow_len <= ((CM_INT32)sizeof(g_TxBaseFollow) - 12u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_7, TSCP_DARK_ASSERT_9);/*输出缓冲至少空闲8字节*/
-	   CM_LongToChar(8u, g_TxBaseFollow + g_TxBaseFollow_len);
-	   CM_LongToChar(sysCyc, g_TxBaseFollow + g_TxBaseFollow_len + 4u);
-	   CM_LongToChar(SFM_GetTxSn(), g_TxBaseFollow + g_TxBaseFollow_len + 8u);
-	   g_TxBaseFollow_len += 12u;
-	   /*- 发送 */
-	   SFM_2x2_Send(g_TxBaseFollow, (CM_UINT32)g_TxBaseFollow_len, ENUM_2x2_MSG_BASE_FOLLOW);
-	}
-	else
-	{
-	  /*- 无处理 */
 	}
 	MSCP_LOG_MSG("timecurr 3.1 Input 2x2Send = %lld us\n", NOW_USED_TIME);
     /*########################2x2对系数据接收########################*/
@@ -2302,27 +2283,9 @@ void SFM_2x2_InputProc(void)
     if ((ENUM_2x2_OFFLINE == s_2x2_Ctrl.LocalState)
         || (ENUM_2x2_SLAVE == s_2x2_Ctrl.LocalState))
     {
-    	if ((g_RxBaseFollow_len >= 12u) && (s_2x2_Ctrl.RxBaseFollowSysCyc > 0u))/*通过数据长度判断是否有新数据*/
+    	if ((g_RxBaseFollow_len >= 16) && (s_2x2_Ctrl.RxBaseFollowSysCyc > 0u))/*通过数据长度判断是否有新数据*/
 		{
-    		/*- 适配层协议数据跟随*/
+			s_2x2_BaseFollow_Sync();
-			len_prtcl = CM_LongFromChar(g_RxBaseFollow);
-			CM_RE_ASSERT(len_prtcl <= ((CM_UINT32)g_RxBaseFollow_len - 4u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_7, TSCP_DARK_ASSERT_3);
-			SFM_SetPrtclFollowData(g_RxBaseFollow + 4u);
-
-			/*- sfp协议数据跟随*/
-			len_sfprtcl = CM_LongFromChar(g_RxBaseFollow + 4u + len_prtcl);
-			CM_RE_ASSERT(len_prtcl + len_sfprtcl <= ((CM_UINT32)g_RxBaseFollow_len - 8u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_7, TSCP_DARK_ASSERT_10);
-			SFM_SetSfpPrtclFollowData(len_sfprtcl, g_RxBaseFollow + 4u + len_prtcl + 4u);
-
-            /*- 平台数据跟随*/
-            len_pfm = CM_LongFromChar(g_RxBaseFollow + 4u + len_prtcl + 4u);
-            CM_RE_ASSERT(len_pfm == ((CM_UINT32)g_RxBaseFollow_len - len_prtcl - len_sfprtcl - 12u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_7, TSCP_DARK_ASSERT_4);
-            CM_RE_ASSERT(len_pfm == 8u, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_7, TSCP_DARK_ASSERT_5);
-			/*此处使用临时周期号接收,在周期末同步*/
-            s_2x2_Ctrl.SysCycSync = CM_LongFromChar(g_RxBaseFollow + 12u + len_prtcl + len_sfprtcl); /* parasoft-suppress BD-PB-CHECKRET "此处无需检查CM_LongFromChar()的返回值" */
-            SFM_SetTxSn(CM_LongFromChar(g_RxBaseFollow + 12u + len_prtcl + len_sfprtcl + 4u));
-
-			/*- 本周期是否跟随成功 */
 			/*- 记录本次跟随时间 */
 			s_2x2_Ctrl.LastFollowCyc = s_2x2_Ctrl.RxBaseFollowSysCyc;
 			MSCP_LOG_MSG("follow cyc = %d->%d\n",s_2x2_Ctrl.LastFollowCyc,sysCyc);
@@ -2465,47 +2428,7 @@ void SFM_2x2_OutputProc(IN const CM_UINT8 *CheckBuf, CM_INT32 CheckLen)
         if ((sysCyc == s_2x2_Ctrl.RxCheckSysCyc) && (CheckLen == s_2x2_Ctrl.RxCheckLen))
         {
             /*- 进行输出比较 */
-            ret = CM_Memcmp((const void*)CheckBuf, (void*)s_2x2_Ctrl.RxCheckFrame, (CM_SIZE_T)CheckLen);
+			s_2x2_Output_SyncCheck(CheckBuf, CheckLen);
-            /*- 输出比较是否一致 */
-            if (0 == ret)
-            {
-                /*- 更新输出比较状态 */
-                s_2x2_Ctrl.LastCheckOKCount = SFM_2x2_GetSysCount();
-                s_2x2_Ctrl.OutPutCheckFailFlag = 0u;
-                MSCP_LOG_MSG("Out Put Success!\n");
-            }
-            else
-    		{
-            	/*- 更新OutPutCheckFailFlag则降级为离线,因为如果收到输出数据但是比较失败,则降为离线状态  */
-            	s_2x2_Ctrl.OutPutCheckFailFlag = 1u;
-            	for(i = 0u;i < CheckLen;i++)
-            	{
-            		if(CheckBuf[i] == s_2x2_Ctrl.RxCheckFrame[i])
-            		{
-
-            		}
-            		else
-            		{
-            			/*- 跳出 */
-            			break;
-            		}
-            	}
-    			/*记录暗文日志*/
-    			(void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_2X2_OUT_CHECK_FAIL,3u,
-    										sizeof(CM_UINT8),s_2x2_Ctrl.OutPutCheckFailFlag,
-    										sizeof(CM_UINT32),i,
-    										sizeof(CM_UINT32),s_2x2_Ctrl.RxCheckSysCyc);
-            	MSCP_LOG_MSG("Out Put failed_[%d]!\n",i);
-            	MSCP_LOG_BIN(CheckBuf,CheckLen);
-            	if(ENUM_2x2_SLAVE == s_2x2_Ctrl.LocalState)
-            	{
-            		CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_3);
-            	}
-            	else
-            	{
-            		/*- 无处理 */
-            	}
-    		}
         }
         else
         {
@@ -2600,7 +2523,7 @@ static void SFM_2x2_RecvAppFollowData(CM_UINT32 sysCyc, ENUM_2x2_STATE_T stat)
 			{
 				/*- 接收应用跟随数据的CRC和长度*/
 				MSCP_LOG_MSG("B-A:g_RxAppFollowCrc_len:%lld\n",g_RxAppFollowCrc_len);
-				g_RxAppFollow_len = SFM_2oo2_Exchange_Currency(g_RxAppFollowCrc, 0, g_RxAppFollowCrc, sizeof(g_RxAppFollowCrc), ENUM_2oo2_END_EX);
+				g_RxAppFollowCrc_len = SFM_2oo2_Exchange_Currency(g_RxAppFollowCrc, 0, g_RxAppFollowCrc, sizeof(g_RxAppFollowCrc), ENUM_2oo2_END_EX);
 			}
 			else
 			{
@@ -2634,7 +2557,6 @@ void SFM_2x2_EndProc(void)
     ENUM_2x2_STATE_T stat = SFM_2x2_GetLocal2x2State(); /* 本机热备状态 */
     ENUM_CM_RETURN retFollowUp = ENUM_CM_FALSE;
     CM_UINT64 curTickTest[10] = {0u}; /* 当前时刻 */
-    CM_INT32 cmp_ret = 1;
 
     switch(stat)
     {
@@ -2643,12 +2565,12 @@ void SFM_2x2_EndProc(void)
     	if(ENUM_2x2_SLAVE == SFM_2x2_GetPartner2x2State())
     	{
             /*- 发送跟随数据 */
-    		SFM_2x2_Send(g_TxAppFollow, (CM_UINT32)8, ENUM_2x2_MSG_APP_FOLLOW_CRC);
+    		SFM_2x2_Send(g_TxAppFollow, (CM_UINT32)12, ENUM_2x2_MSG_APP_FOLLOW_CRC);
             MSCP_LOG_MSG("Iam master partner is slave send appfollowcrc\n");
     	}
     	else
     	{
-    		SFM_2x2_Send(g_TxAppFollow + 4, (CM_UINT32)g_TxAppFollow_len, ENUM_2x2_MSG_APP_FOLLOW);
+    		SFM_2x2_Send(g_TxAppFollow + 8, (CM_UINT32)g_TxAppFollow_len, ENUM_2x2_MSG_APP_FOLLOW);
         	MSCP_LOG_MSG("Iam master partner is offline send appfollow\n");
     	}
     	curTickTest[1] = CM_GetTick();
@@ -2658,19 +2580,7 @@ void SFM_2x2_EndProc(void)
     	curTickTest[0] = CM_GetTick();
     	if (s_2x2_Ctrl.RxAppFollowSysCyc >= sysCyc)
     	{
-        	cmp_ret = CM_Memcmp(g_TxAppFollow, g_RxAppFollowCrc, 8);//如果同步失败 备系降为离线
+			s_2x2_AppFollow_SyncCheck();
-        	if(0 == cmp_ret)
-        	{
-        		/*- 跟随数据和主系一致*/
-        		s_2x2_Ctrl.AppFollowCmpFlag = 0u;
-        		MSCP_LOG_MSG("CRC cmp is OK\n");
-        	}
-        	else
-        	{
-            	/*- 比较失败 降离线*/
-        		s_2x2_Ctrl.AppFollowCmpFlag = 1u;
-        		MSCP_LOG_MSG("CRC cmp is fail\n");
-        	}
     	}
     	else
     	{
@@ -2703,7 +2613,7 @@ void SFM_2x2_EndProc(void)
     }
     MSCP_LOG_MSG("slef stata is %d use time = %lld\n",stat,(curTickTest[1] - curTickTest[0]) / 1000u);
     /*更新周期号*/
-	if ((s_2x2_Ctrl.RxBaseFollowSysCyc >= sysCyc) && (ENUM_2x2_MASTER != stat))
+	if ((s_2x2_Ctrl.SysCycSync >= sysCyc) && (ENUM_2x2_MASTER != stat))
 	{
 		g_MSCP_SysCount = s_2x2_Ctrl.SysCycSync;
 	}
@@ -2872,8 +2782,9 @@ CM_UINT8 SFM_2x2_SetFollowData(IN const CM_UINT8 Data[], IN CM_UINT32 Len)
     	g_TxAppFollow_len = (CM_INT32)CM_UNSIGNED_INT_EXP(Len + 4u);
     	crc = CM_Crc32(Data, Len);
     	CM_LongToChar(crc, g_TxAppFollow);
-    	CM_LongToChar(Len, g_TxAppFollow + 4);
+		/* 预留4字节记录另一CPU的CRC */
-    	(void)CM_Memcpy((void*)(g_TxAppFollow + 8), sizeof(g_TxAppFollow) - 8u, Data, (CM_SIZE_T)Len);
+    	CM_LongToChar(Len, g_TxAppFollow + 8);
+    	(void)CM_Memcpy((void*)(g_TxAppFollow + 12), sizeof(g_TxAppFollow) - 12u, Data, (CM_SIZE_T)Len);
     	rt = 1u;
     }
     else
@@ -3404,3 +3315,264 @@ void SFM_2x2_SemPost(void)
     }
 }
 
+/**
+ * 统一置切系标志
+ */
+static void s_2x2_CloseSwitchFlag(void)
+{
+	s_2x2_state_Ctrl.LocalSwitchState = ENUM_2x2_SWITCH_CLOSE;
+	s_2x2_state_Ctrl.PeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
+	s_2x2_state_Ctrl.PartnerSwitchState = ENUM_2x2_SWITCH_CLOSE;
+	s_2x2_state_Ctrl.PartPeerSwitchState = ENUM_2x2_SWITCH_CLOSE;
+	s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
+	s_2x2_state_Ctrl.PeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
+	s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
+	s_2x2_state_Ctrl.PartPeerAIDSwitchState = ENUM_2x2_AIDSWITCH_OVER;
+	s_2x2_state_Ctrl.ctrSwitchFlag = 0u;
+	s_2x2_state_Ctrl.aidSwitchFlag = 0u;
+}
+/**
+ * @brief 输入阶段平台跟随数据的2oo2比较
+ */
+static void s_2x2_BaseFollow_2oo2Check_Send(void)
+{
+	CM_UINT32 crc = 0u;
+	CM_UINT8 mine_buf[8u] = {0}, peer_buf[8u] = {0};
+	CM_INT32 ret = 0;
+	/*- 计算本机跟随数据中协议部分的CRC值 */
+	crc = CM_Crc32(g_TxBaseFollow, g_TxBaseFollow_len - 12);
+	CM_LongToChar(g_TxBaseFollow_len, mine_buf);
+	CM_LongToChar(crc, mine_buf + 4u);
+	ret = SFM_2oo2_Exchange_Currency(mine_buf, 8u, peer_buf, 8u, ENUM_2oo2_INPUT_EX);
+	/*- 计算对机跟随数据的CRC值 */
+	CM_RE_ASSERT(ret == 8, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_19, TSCP_DARK_ASSERT_1);
+	/*- 比较本机和对机跟随数据的CRC值 */
+	if(0 != CM_Memcmp(mine_buf, peer_buf, (CM_SIZE_T)8u))
+	{
+		MSCP_LOG_DATALEN(g_TxBaseFollow, g_TxBaseFollow_len, "PFM_InputProc g_TxBaseFollow_len");
+		CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_19, TSCP_DARK_ASSERT_2);
+	}
+	/*- 比较成功，填入CRC后发送 */
+	if(g_TxBaseFollow_len <= (sizeof(g_TxBaseFollow) - 4u))
+	{
+		(void)CM_Memcpy(g_TxBaseFollow + g_TxBaseFollow_len, sizeof(g_TxBaseFollow) - g_TxBaseFollow_len - 4u, mine_buf + 4, 4u);
+		g_TxBaseFollow_len += 4u;
+		if(s_2x2_Ctrl.LocalState == ENUM_2x2_MASTER)
+		{
+			SFM_2x2_Send(g_TxBaseFollow, (CM_UINT32)g_TxBaseFollow_len, ENUM_2x2_MSG_BASE_FOLLOW);
+		}
+	}
+
+}
+/**
+ * @brief 周期末阶段，备系接收主系应用跟随CRC后的比较逻辑
+ */
+static void s_2x2_AppFollow_SyncCheck(void)
+{
+	CM_UINT32 mine_crc = 0u, partner_crc1 = 0u, partner_crc2 = 0u;
+	static CM_UINT32 error_tolerate = 1u;
+	mine_crc = CM_LongFromChar(g_TxAppFollow);
+	partner_crc1 = CM_LongFromChar(g_RxAppFollowCrc);
+	partner_crc2 = CM_LongFromChar(g_RxAppFollowCrc + 4u);
+
+	/* 主系双CPU的CRC不一致 */
+	if(partner_crc1 != partner_crc2)
+	{
+		/* 备系本机与主系其中一个CRC一致 容忍*/
+		if(mine_crc == partner_crc1 || mine_crc == partner_crc2)
+		{
+			if(error_tolerate++ >= 1u)
+			{
+				MSCP_LOG_MSG("MASTER APPFOLLOW CRC ERROR OVER TOLERATE %d\n", error_tolerate);
+				s_2x2_Ctrl.AppFollowCmpFlag = 1u;
+			}
+			else
+			{
+				s_2x2_Ctrl.AppFollowCmpFlag = 0u;
+				MSCP_LOG_MSG("MASTER APPFOLLOW CRC ERROR TOLERATE %d\n", error_tolerate);
+			}
+		}
+		/* 备系本机与主系都不一致 比较失败宕机*/
+		else
+		{
+			MSCP_LOG_MSG("APPFOLLOW CRC cmp is fail 1\n");
+			s_2x2_Ctrl.AppFollowCmpFlag = 1u;
+			CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_21, TSCP_DARK_ASSERT_1);
+		}
+	}
+	/* 主系双CPU的CRC一致 但与备系本机不一致 比较失败*/
+	else if(mine_crc != partner_crc1)
+	{
+		s_2x2_Ctrl.AppFollowCmpFlag = 1u;
+		MSCP_LOG_MSG("APPFOLLOW CRC cmp is fail 2\n");
+	}
+	/* 主系双CPU的CRC一致 且与备系本机一致 比较成功*/
+	else
+	{
+		MSCP_LOG_MSG("APPFOLLOW CRC cmp is OK\n");
+		s_2x2_Ctrl.AppFollowCmpFlag = 0u;
+		error_tolerate = 0u;
+	}
+
+	if(1u == s_2x2_Ctrl.AppFollowCmpFlag)
+	{
+		/* 比较失败则设置容忍次数大于0（可能本周期备系校验错误降为离线，但下周期主系失效，导致备系进入容忍分支，认为校验成功又升备） */
+		error_tolerate = ((error_tolerate >= 1u) ? error_tolerate : 1u);
+		MSCP_LOG_DATALEN(g_TxAppFollow + 8, g_TxAppFollow_len, "PFM_AppFollow_SyncCheck g_TxAppFollow");
+	}
+}
+/**
+ * @brief 输出阶段，备系接收主系输出数据CRC后的比较逻辑
+ */
+static void s_2x2_Output_SyncCheck(IN const CM_UINT8 *CheckBuf, CM_INT32 CheckLen)
+{
+	CM_UINT32 i = 0u;
+	CM_INT32 ret = -1, ret_p1p2 = -1, ret_m1p1 = -1, ret_m1p2 = -1;	/* 记录对系双CRC比较、本机和对系cpu1、本机和对系cpu2比较结果 */
+	CM_UINT32 singleCheckLen = CheckLen / 2u;	/* checkbuf记录了两个CPU的校验信息，长度的一半为单个CPU校验数据长度 */
+	static CM_UINT32 error_tolerate = 1u;
+    /*- 入参检查 */
+    CM_ASSERT(NULL != CheckBuf, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_20, TSCP_DARK_ASSERT_1);
+	/* 接收的校验数据长度校验 */
+	CM_RE_ASSERT(CheckLen == s_2x2_Ctrl.RxCheckLen, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_20, TSCP_DARK_ASSERT_2);
+	/* 比较接收的主系校验帧中，主系的两个CPU的CRC，记录结果ret_p1p2 */
+	ret_p1p2 = CM_Memcmp((const void*)s_2x2_Ctrl.RxCheckFrame, (const void*)&s_2x2_Ctrl.RxCheckFrame[singleCheckLen], (CM_SIZE_T)singleCheckLen);
+	/* 比较备系本机与主系某一个CPU的CRC，记录结果ret_m1p1 */
+	ret_m1p1 = CM_Memcmp((const void*)CheckBuf, (const void*)&s_2x2_Ctrl.RxCheckFrame[0], (CM_SIZE_T)singleCheckLen);
+	/* 比较备系本机与主系另一个CPU的CRC，记录结果ret_m1p2 */
+	ret_m1p2 = CM_Memcmp((const void*)CheckBuf, (const void*)&s_2x2_Ctrl.RxCheckFrame[singleCheckLen], (CM_SIZE_T)singleCheckLen);
+	/* 对系（主系）发送的双CPU的CRC不一致 */
+	if(0 != ret_p1p2)
+	{
+		/* 备系本机与主系其中一个CRC一致 容忍*/
+		if(0 == ret_m1p1 || 0 == ret_m1p2)
+		{
+			if(error_tolerate++ >= 1u)
+			{
+				MSCP_LOG_MSG("MASTER OUTPUT CRC ERROR OVER TOLERATE %d\n", error_tolerate);
+				s_2x2_Ctrl.OutPutCheckFailFlag = 1u;
+			}
+			else
+			{
+				s_2x2_Ctrl.OutPutCheckFailFlag = 0u;
+				s_2x2_Ctrl.LastCheckOKCount = SFM_2x2_GetSysCount();
+				MSCP_LOG_MSG("MASTER OUTPUT CRC ERROR TOLERATE %d\n", error_tolerate);
+			}
+		}
+		/* 备系本机与主系都不一致 比较失败*/
+		else
+		{
+			MSCP_LOG_MSG("OUTPUT CRC cmp is fail 1\n");
+			s_2x2_Ctrl.OutPutCheckFailFlag = 1u;			
+		}
+	}
+	/* 对系（主系）发送的双CPU的CRC一致，比较失败 */
+	else if(0 != ret_m1p1)
+	{
+		MSCP_LOG_MSG("OUTPUT CRC cmp is fail 2\n");
+		s_2x2_Ctrl.OutPutCheckFailFlag = 1u;
+		for(i = 0u;i < singleCheckLen;i++)
+		{
+			if(CheckBuf[i] == s_2x2_Ctrl.RxCheckFrame[i])
+			{
+
+			}
+			else
+			{
+				/*- 跳出 */
+				break;
+			}
+		}
+		/*记录暗文日志*/
+		(void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_2X2_OUT_CHECK_FAIL,3u,
+									sizeof(CM_UINT8),s_2x2_Ctrl.OutPutCheckFailFlag,
+									sizeof(CM_UINT32),i,
+									sizeof(CM_UINT32),s_2x2_Ctrl.RxCheckSysCyc);
+	}
+	/* 主系双CPU的CRC一致 且与备系本机一致 比较成功*/
+	else
+	{
+		MSCP_LOG_MSG("OUTPUT CRC cmp is OK\n");
+		/*- 更新输出比较状态 */
+		s_2x2_Ctrl.LastCheckOKCount = SFM_2x2_GetSysCount();
+		s_2x2_Ctrl.OutPutCheckFailFlag = 0u;
+		error_tolerate = 0u;
+	}
+	/* 备系比较失败宕机*/
+	if(1u == s_2x2_Ctrl.OutPutCheckFailFlag)
+	{
+		/* 比较失败则设置容忍次数大于0（可能本周期备系校验错误降为离线，但下周期主系失效，导致备系进入容忍分支，认为校验成功又升备） */
+		error_tolerate = ((error_tolerate >= 1u) ? error_tolerate : 1u);
+		/* 打印比较不一致的通道数据 */
+        for (i = 1; i <= g_2x2oo2_data_num; i++)
+        {
+            if ((CM_UINT32)CM_TRUE == g_2x2oo2_tx[g_2x2oo2_base][i].b_2x2_Enable)
+            {
+                ret = CM_Memcmp(CheckBuf + 4 + (i - 1) * 8, s_2x2_Ctrl.RxCheckFrame + 4 + (i - 1) * 8, 8);
+                if(ret != 0)
+                {
+                    MSCP_LOG_MSG("2x2 output compare err, INDEX = %d, len = %d\n", i, (CM_SIZE_T)g_2x2oo2_tx[g_2x2oo2_base][i].buf_len);
+                    MSCP_LOG_BIN(g_2x2oo2_tx[g_2x2oo2_base][i].p_buf, (CM_SIZE_T)g_2x2oo2_tx[g_2x2oo2_base][i].buf_len);
+                }
+            }
+            else
+            {
+                /*二取标志未使能*/
+            }
+        }
+		if(ENUM_2x2_SLAVE == s_2x2_Ctrl.LocalState)
+		{
+			CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_20, TSCP_DARK_ASSERT_3);
+		}
+	}
+}
+/**
+ * @brief 输入阶段，非主系进行相关CRC校验后跟随
+ */
+static void s_2x2_BaseFollow_Sync(void)
+{
+	CM_UINT32 len_prtcl = 0u; /* 协议跟随数据长度 */
+    CM_UINT32 len_sfprtcl = 0u; /* 协议跟随数据长度 */
+    CM_UINT32 len_pfm = 0u;   /* 平台跟随数据长度 */
+	CM_UINT32 calcCrc = 0u, rxCrc = 0u, txCrc = 0u; /* CRC相关变量 */
+	CM_UINT32 offset = 0u;	/* 解包用offset*/
+	/*- 适配层协议数据跟随*/
+	g_RxBaseFollow_len -= 4;/*去除CRC的长度*/
+	calcCrc = CM_Crc32(g_RxBaseFollow, (CM_UINT32)g_RxBaseFollow_len - 12u);
+	offset = (CM_UINT32)g_RxBaseFollow_len;
+	rxCrc = CM_LongFromChar(&g_RxBaseFollow[offset]);
+	offset = (CM_UINT32)g_TxBaseFollow_len - 4u;
+	txCrc = CM_LongFromChar(&g_TxBaseFollow[offset]);
+	if((ENUM_2x2_SLAVE == s_2x2_Ctrl.LocalState) && (txCrc != rxCrc))
+	{
+		/* 备系自己产生的平台跟随数据与主系不一致，做日志记录 */
+		MSCP_LOG_MSG("2x2 BaseFollow CRC Err,TxCrc = %d,RxCrc = %d,Time:%d us\r\n", txCrc,rxCrc,NOW_USED_TIME);
+	}
+	/*- 比较收到的跟随数据与发送的跟随数据*/
+	if(calcCrc == rxCrc)
+	{
+		offset = 0u;
+		len_prtcl = CM_LongFromChar((void*)&g_RxBaseFollow[offset]);
+		offset += 4u;
+		CM_RE_ASSERT(len_prtcl <= ((CM_UINT32)g_RxBaseFollow_len - 4u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_22, TSCP_DARK_ASSERT_1);
+		SFM_SetPrtclFollowData((void*)&g_RxBaseFollow[offset]);
+		offset += len_prtcl;
+
+		/*- sfp协议数据跟随*/
+		len_sfprtcl = CM_LongFromChar((void*)&g_RxBaseFollow[offset]);
+		offset += 4u;
+		CM_RE_ASSERT(len_prtcl + len_sfprtcl <= ((CM_UINT32)g_RxBaseFollow_len - 8u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_22, TSCP_DARK_ASSERT_2);
+		SFM_SetSfpPrtclFollowData(len_sfprtcl, (void*)&g_RxBaseFollow[offset]);
+		offset += len_sfprtcl;
+
+		/*- 平台数据跟随*/
+		len_pfm = CM_LongFromChar((void*)&g_RxBaseFollow[offset]);
+		offset += 4u;
+		CM_RE_ASSERT(len_pfm == ((CM_UINT32)g_RxBaseFollow_len - len_prtcl - len_sfprtcl - 12u), SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_22, TSCP_DARK_ASSERT_3);
+		CM_RE_ASSERT(len_pfm == 8u, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_22, TSCP_DARK_ASSERT_4);
+	}
+	/*此处使用临时周期号接收,在周期末同步*/
+	offset = (CM_UINT32)g_RxBaseFollow_len - 8u;
+	s_2x2_Ctrl.SysCycSync = CM_LongFromChar((void*)&g_RxBaseFollow[offset]); /* parasoft-suppress BD-PB-CHECKRET "此处无需检查CM_LongFromChar()的返回值" */
+	offset += 4u;
+	SFM_SetTxSn(CM_LongFromChar((void*)&g_RxBaseFollow[offset]));
+}

TSCP/src/MSCP/SFM/SFM_2x2.h

@@ -247,6 +247,8 @@ extern CM_UINT32 g_MSCP_SysCount;
 	    ENUM_2x2_AID_SWITCH_STATE  PartnerAIDSwitchState; /**< 对系的主动切系按钮状态 */
 	    ENUM_2x2_AID_SWITCH_STATE  PartPeerAIDSwitchState; /**< 对系的邻机的主动切系按钮状态 */
 	    CM_UINT8 aidSwitchFlag; /**< aid切系控制标志 */
+		/* 离线是否允许升预升主*/
+		CM_BOOL preMasterAllowed;
 	}STRU_2X2_STATE_CTRL_T;
 	/*2x状态切换线程参数*/
 	typedef struct

TSCP/src/MSCP/SFM/SFM_Prtcl.c

@@ -94,8 +94,8 @@ void SFM_PrtclOutInit(void)
         s_OutnetPrtcl.LocalID = (CM_UINT8)(OutnetID % 256u);
         s_OutnetPrtcl.LocalType = (CM_UINT8)(OutnetID / 256u);
         s_OutnetPrtcl.CycleNum = &g_MSCP_SysCount;
-        s_OutnetPrtcl.InputSize = 6000u;
+		s_OutnetPrtcl.InputSize = 7200u;
-        s_OutnetPrtcl.OutputSize = 6000u;
+		s_OutnetPrtcl.OutputSize = 7200u;
         s_OutnetPrtcl.RecordArraySize = 30000u;
         s_OutnetPrtcl.MaxNumPerCycle = 35u; /* 以zc举例：包数*4*2*2*2 */
 #if QNX
@@ -711,11 +711,13 @@ CM_UINT32 Prtcl_OutnetSafe_AppRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT16* pSrcL
         else
     	{
     		/*- 无处理*/
+			MSCP_LOG_MSG("Outnet Recv, msglen:%d, qstatus:%d, rxsize:%d\n", msgLen, qStatus, rxSize);
     	}
     }
     else
 	{
 		/*- 无处理*/
+		MSCP_LOG_MSG("Outnet Recv, msglen:%d, qstatus:%d, rxsize:%d\n", msgLen, qStatus, rxSize);
 	}
 
     /*- 解锁接收队列 */
@@ -836,11 +838,13 @@ CM_UINT32 Prtcl_InnetSafe_AppRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLifeTi
         else
     	{
     		/*- 无处理*/
+			MSCP_LOG_MSG("Innet Recv, msglen:%d, qstatus:%d, rxsize:%d\n", msgLen, qStatus, rxSize);
     	}
     }
     else
 	{
 		/*- 无处理*/
+		MSCP_LOG_MSG("Innet Recv, msglen:%d, qstatus:%d, rxsize:%d\n", msgLen, qStatus, rxSize);
 	}
 
     /*- 解锁接收队列 */
@@ -984,12 +988,14 @@ CM_UINT32 Prtcl_InnetSafe_RmRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLifeTim
 				else
 				{
 					/*- 无处理*/
+					MSCP_LOG_MSG("Rm Recv, msglen:%d, qstatus:%d, rxsize:%d\n", msgLen, qStatus, rxSize);
 					break;
 				}
 			}
 			else
 			{
 				/*- 无处理*/
+				MSCP_LOG_MSG("Rm Recv, msglen:%d, qstatus:%d, rxsize:%d\n", msgLen, qStatus, rxSize);
 				break;
 			}
     	}while(1);

TSCP/src/dqu_common/dqu_cbtc_common/dquCbtcConfigData.c

@@ -346,6 +346,9 @@ UINT8 dfsInitTrainPerformConfigData(UINT8 *pDataAddr, UINT32 dataSize, UINT16 ro
 				/*线路最大下坡坡度*/
 				g_pCbtcConfigDataStru->cbtcTrainInfo[i].WorstGrade = ShortFromChar(pData);
 				pData += 2;
+				/*站台追踪时，列车间隔距离*/
+				g_pCbtcConfigDataStru->cbtcTrainInfo[i].StationTrackDistance = ShortFromChar(pData);
+				pData += 2;
 			}
 		}
 

TSCP/src/dqu_common/dqu_cbtc_common/dquCbtcConfigData.h

@@ -42,6 +42,7 @@ extern "C" {
 		UINT16 TrainLength; /*列车长度*/
 		UINT8 TrainMaxTracAcc;	/*列车最大牵引加速度*/	
 		UINT16 WorstGrade;	    /*线路最大下坡坡度*/	
+		UINT16 StationTrackDistance; /*站台追踪时，列车间隔距离*/
 	} CBTC_TRAIN_INFO_STRU;
 
 
@@ -76,7 +77,6 @@ extern "C" {
 		UINT32	OcTslCommunicationErrorTime;/*OC-TSL通信故障判断时间（ms）,add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT8 LinkLogicDirUpAndDown;   /*系统定义逻辑方向与上下行方向的关系,add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT16  OppositeTrackDistance;    /*对向行驶双车间隔最小安全距离（cm）,add by yt，2022年3月1日，适配车车系统配置数据*/
-		UINT16  StationTrackDistance;     /*站台追踪时，列车间隔距离(cm),add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT32  MaxMALength;              /*线路最差情况下紧急制动距离（单位m）,add by yt，2022年3月1日，适配车车系统配置数据*/
 		UINT32 dwLineMinTrainLength;		/*系统配置数据，线路最小车长*/
 		UINT8  chZXDynamicTestSwitch;		/*正线是否支持动态测试 配置中 aa关闭 55打开*/

TSCP/src/dqu_common/dqu_emap_common/dquStructInit.c

@@ -3704,7 +3704,17 @@ UINT8 PHYSICAL_SGMT_STRU_init(UINT8 * pDataAdd, DSU_PHYSICAL_SGMT_STRU * pPhysic
 		/*物理区段所属计轴子系统ID*/
 		pPhysicalSgmtStru->BelongAxleSysID = ShortFromChar(pData);
 		pData += 2;
-		rtnValue = 1;
+
+		pPhysicalSgmtStru->QcxFlag = *pData;
+		if ((0x55U != pPhysicalSgmtStru->QcxFlag) && (0xAAU != pPhysicalSgmtStru->QcxFlag))
+		{
+			rtnValue = 0U;
+		}
+		else
+		{
+			pData++;
+			rtnValue = 1U;
+		}	
 	}
 	return rtnValue;
 }

TSCP/src/dqu_common/dqu_emap_common/dsuStruct.h

@@ -860,6 +860,7 @@ typedef struct DSU_PhysicalSgmt/*
 	CHAR    szName[32];					/*名称*/
 	UINT8   Type;                       /*物理区段类型*/
 	UINT8   LjkFlag;                    /*列检库标志*/
+	UINT8   QcxFlag;                    /*牵出线标志*/
 	UINT16  BelongAxleSysID;            /*物理区段所属计轴子系统ID*/
 }DSU_PHYSICAL_SGMT_STRU;
 

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

@@ -1,15 +1,15 @@
 /********************************************************
 *                                                                                                            
-* 文件名  ： FsfbRecordDelare.h 
+* �ļ��FsfbRecordDelare.hare.h 
-* 版权说明： 北京交控科技有限工司 
+* ��Ȩ˵���� �������ؿƼ����޹�˾ 
-* 版本号  ： 1.0
+* �汾��  �� 1.0
-* 创建时间： 2013.09.09
+* ����ʱ�䣺 2013.09.09
-* 作者    ： 王佩佩
+* ����    �� ������
-* 功能描述： FSFB协议记录相关宏定义。
+* ���������� FSFBЭ���¼��غ궨�塣
-* 使用注意： 
+* ʹ��ע�⣺ 
 *   
-* 修改记录： 
+* �޸ļ�¼�� 
-*	2010.05.10 修改		追加FSFB新周期开始标识。
+*	2010.05.10 �޸�		׷��FSFB�����ڿ�ʼ��ʶ��
 *
 ********************************************************/ 
 
@@ -19,93 +19,93 @@
 
 
 /********************************************************************************
-宏定义
+�궨��
 ********************************************************************************/
 
-/* 各个标志位 */
+/* ������־λ */
-#define FSFB_CYCLE_TAG (0xF4FB) /* FSFB新周期开始标识 */
+#define FSFB_CYCLE_TAG (0xF4FB) /* FSFB�����ڿ�ʼ��ʶ */
-#define IN_RED (0x01) /*输入红网处理*/
+#define IN_RED (0x01) /*�����������*/
-#define IN_BLUE (0x02) /*输入蓝网处理*/
+#define IN_BLUE (0x02) /*������������*/
-#define IN_FRAME_LEN_ERR (0x03) /*输入数据帧长度错误*/
+#define IN_FRAME_LEN_ERR (0x03) /*��������֡���ȴ���*/
-#define IN_READ_FRAME_ERR (0x04) /*读取数据帧长度错误*/
+#define IN_READ_FRAME_ERR (0x04) /*��ȡ����֡���ȴ���*/
-#define IN_READ_FRAME (0x05) /*读取数据帧*/
+#define IN_READ_FRAME (0x05) /*��ȡ����֡*/
-#define IN_CRC_ERR (0x06) /*CRC错误*/
+#define IN_CRC_ERR (0x06) /*CRC����*/
-#define IN_NO_LNK (0x07) /*无链路*/
+#define IN_NO_LNK (0x07) /*����·*/
-#define IN_CAT_ERR (0x08) /*输入帧种类错误*/
+#define IN_CAT_ERR (0x08) /*����֡�������*/
-#define IN_ADDR_ERR (0x09) /*输入帧种类错误*/
+#define IN_ADDR_ERR (0x09) /*����֡�������*/
-#define IN_SSR_STATUS_ERR (0x0A) /*输入SSR收状态错误*/
+#define IN_SSR_STATUS_ERR (0x0A) /*����SSR��״̬����*/
-#define IN_SSR_SSE_TC_ERR (0x0B) /*输入SSR的SSE序号错误*/
+#define IN_SSR_SSE_TC_ERR (0x0B) /*����SSR��SSE��Ŵ���*/
-#define IN_ABT_STATUS (0x0C) /*输入ABT收状态*/
+#define IN_ABT_STATUS (0x0C) /*����ABT��״̬*/
-#define IN_ABT_SVC_ERR (0x0D) /*输入ABT的SVC错误*/
+#define IN_ABT_SVC_ERR (0x0D) /*����ABT��SVC����*/
-#define IN_ABT_OLD_ERR (0x0E) /*输入ABT旧序号错误*/
+#define IN_ABT_OLD_ERR (0x0E) /*����ABT����Ŵ���*/
-#define IN_ABT_SSE_BTC (0x0F) /*输入ABT发SSE或BTC*/
+#define IN_ABT_SSE_BTC (0x0F) /*����ABT��SSE��BTC*/
-#define IN_BTD_LEN_ERR (0x10) /*输入BTD的长度错误*/
+#define IN_BTD_LEN_ERR (0x10) /*����BTD�ij��ȴ���*/
-#define IN_BTD_STATUS (0x11) /*输入BTD收状态*/
+#define IN_BTD_STATUS (0x11) /*����BTD��״̬*/
-#define IN_BTD_LOST_ERR (0x12) /*输入BTD丢失超容忍*/
+#define IN_BTD_LOST_ERR (0x12) /*����BTD��ʧ������*/
-#define IN_BTD_DELAY_ERR (0x13) /*输入BTD延迟超容忍*/
+#define IN_BTD_DELAY_ERR (0x13) /*����BTD�ӳٳ�����*/
-#define IN_BTD_SVC_ERR (0x14) /*输入BTD的SVC错误*/
+#define IN_BTD_SVC_ERR (0x14) /*����BTD��SVC����*/
-#define OUT_APP (0x15) /*输出数据*/
+#define OUT_APP (0x15) /*�������*/
-#define OUT_FRAME_LEN_ERR (0x16) /*输出应用帧数据长度错误*/
+#define OUT_FRAME_LEN_ERR (0x16) /*���Ӧ��֡���ݳ��ȴ���*/
-#define OUT_READ_ERR (0x17) /*输出读应用数据错误*/
+#define OUT_READ_ERR (0x17) /*�����Ӧ�����ݴ���*/
-#define OUT_APP_FRAME (0x18) /*输出应用帧数据*/
+#define OUT_APP_FRAME (0x18) /*���Ӧ��֡����*/
-#define OUT_FRAME_TYPE_ERR (0x19) /*输出帧类型错误*/
+#define OUT_FRAME_TYPE_ERR (0x19) /*���֡���ʹ���*/
-#define OUT_ADDR_ERR (0x1A) /*输出地址错误*/
+#define OUT_ADDR_ERR (0x1A) /*�����ַ����*/
-#define OUT_FIND_LNK_ERR (0x1B) /*输出查询链路错误*/
+#define OUT_FIND_LNK_ERR (0x1B) /*�����ѯ��·����*/
-#define OUT_INSERT_NODE_ERR (0x1C) /*输出插入节点错误*/
+#define OUT_INSERT_NODE_ERR (0x1C) /*�������ڵ����*/
-#define OUT_INIT_NODE_ERR (0x1D) /*输出初始化节点错误*/
+#define OUT_INIT_NODE_ERR (0x1D) /*�����ʼ���ڵ����*/
-#define OUT_DATA_TYPE (0x1E) /*输出数据类型*/
+#define OUT_DATA_TYPE (0x1E) /*�����������*/
-#define OUT_LNK (0x1F) /*输出链路*/
+#define OUT_LNK (0x1F) /*�����·*/
-#define OUT_RP_LNK (0x20) /*输出RP链路*/
+#define OUT_RP_LNK (0x20) /*���RP��·*/
-#define OUT_ALL_LEN_ERR (0x21) /*输出数据总长度错误*/
+#define OUT_ALL_LEN_ERR (0x21) /*��������ܳ��ȴ���*/
 
 
 
-#define FSFB_RCV_TAG		0xF4				/* FSFB输入单元标识 */
+#define FSFB_RCV_TAG		0xF4				/* FSFB���뵥Ԫ��ʶ */
-#define FSFB_OUT_TAG		0xF5				/* FSFB输出单元标识 */
+#define FSFB_OUT_TAG		0xF5				/* FSFB�����Ԫ��ʶ */
-#define FSFB_MSG_IN_TAG		0x04				/* FSFB输入一帧消息起始标识(B 0000 0100) */
+#define FSFB_MSG_IN_TAG		0x04				/* FSFB����һ֡��Ϣ��ʼ��ʶ(B 0000 0100) */
-#define FSFB_MSG_OUT_TAG	0x08				/* FSFB输出一帧消息起始标识(B 0000 1000) */
+#define FSFB_MSG_OUT_TAG	0x08				/* FSFB���һ֡��Ϣ��ʼ��ʶ(B 0000 1000) */
-#define FSFB_NODE_OUT_TAG	0x0C				/* FSFB输出一帧消息起始标识(B 0000 1100) */
+#define FSFB_NODE_OUT_TAG	0x0C				/* FSFB���һ֡��Ϣ��ʼ��ʶ(B 0000 1100) */
-#define FSFB_OUT_E_TAG		0x0F				/* FSFB输出单元结束标识(B 0000 1111) */
+#define FSFB_OUT_E_TAG		0x0F				/* FSFB�����Ԫ������ʶ(B 0000 1111) */
 
 /************************************************************************
- * 错误码编码原则，协议错误码一共16bit
+ * ���������ԭ��Э�������һ��16bit
- * D15~D12：保留
+ * D15~D12������
- * D11~D10：错误等级
+ * D11~D10������ȼ�
- * D9~D8：模块位置
+ * D9~D8��ģ��λ��
- * D7~D4：包括各个模块特有的错误，在模块不同时次4位代表的含义不同
+ * D7~D4����������ģ�����еĴ�����ģ�鲻ͬʱ��4λ�����ĺ��岻ͬ
- * 区别于队列链表等底层错误
+ * �����ڶ��������ȵײ����
- * D3~D0：函数出错处理，不论模块是否相同此4位代表的含义相同                                                                     
+ * D3~D0��������������������ģ���Ƿ���ͬ��4λ�����ĺ�����ͬ                                                                     
 ************************************************************************/
-/* 错误等级 */
+/* ����ȼ� */
 #define FSFB_ERR                                 0x0800
 #define FSFB_WARN                                0x0400
 
-/* 模块位置 */
+/* ģ��λ�� */
-#define  FSFB_RECEIVE                            0x0200		/* 输入模块 */
+#define  FSFB_RECEIVE                            0x0200		/* ����ģ�� */
-#define  FSFB_OUTPUT                             0x0100		/* 输出模块 */
+#define  FSFB_OUTPUT                             0x0100		/* ���ģ�� */
 
-/* 各模块特有错误 */
+/* ��ģ�����д��� */
 #define FSFB_ERROR_NULL                          0x0000
-/* 输入 */
+/* ���� */
-#define FSFB_MSG_TYPE_ILLEGAL                    0x0010      /* 不是FSFB消息 */
+#define FSFB_MSG_TYPE_ILLEGAL                    0x0010      /* ����FSFB��Ϣ */
-#define FSFB_MSG_OLD_ERR                         0x0020      /* 非最新报文 */
+#define FSFB_MSG_OLD_ERR                         0x0020      /* �����±��� */
-#define FSFB_DEL_MSG_LNK_ERR                     0x0030      /* 临时报文删除失败 */
+#define FSFB_DEL_MSG_LNK_ERR                     0x0030      /* ��ʱ����ɾ��ʧ�� */
-#define FSFB_MSG_NOT_NODE_ERR                    0x0040      /* 报文信息与通信节点信息不一致 */
+#define FSFB_MSG_NOT_NODE_ERR                    0x0040      /* ������Ϣ��ͨ�Žڵ���Ϣ��һ�� */
-#define FSFB_MSG_LEN_ERR		                    0x0050      /* 报文长度不正 */
+#define FSFB_MSG_LEN_ERR		                    0x0050      /* ���ij��Ȳ��� */
-#define FSFB_MSG_FMT_ILLEGAL						0x0060		/* 报文格式不对 */
+#define FSFB_MSG_FMT_ILLEGAL						0x0060		/* ���ĸ�ʽ���� */
-#define FSFB_SSR_NOT_ILLEGAL						0x0070		/* 不是对应SSR报文信息 */
+#define FSFB_SSR_NOT_ILLEGAL						0x0070		/* ���Ƕ�ӦSSR������Ϣ */
-#define FSFB_MSG_REPLACE_ERR						0x0080		/* 覆盖节点失败 */
+#define FSFB_MSG_REPLACE_ERR						0x0080		/* ���ǽڵ�ʧ�� */
-#define FSFB_MSG_NO_REPLACENODE					0x0090		/* 不存在覆盖节点 */
+#define FSFB_MSG_NO_REPLACENODE					0x0090		/* �����ڸ��ǽڵ� */
-#define FSFB_MSG_NO_INVALID						0x00A0		/* BSD解码失败 */
+#define FSFB_MSG_NO_INVALID						0x00A0		/* BSD����ʧ�� */
 #define FSFB_MSG_CRC_ERR                        0x00B0
-/* 输出 */
+/* ��� */
-#define FSFB_DBGET_ERR							0x0050      /* 数据库查询错误 */
+#define FSFB_DBGET_ERR							0x0050      /* ���ݿ��ѯ���� */
-/* 函数出错处理，底层处理错误 */
+/* ���������������ײ㴦������ */
-#define FSFB_QUEUE_READ                          0x0001      /* 队列读有错 */
+#define FSFB_QUEUE_READ                          0x0001      /* ���ж��д� */
-#define FSFB_QUEUE_WRITE                         0x0002      /* 队列写有错 */
+#define FSFB_QUEUE_WRITE                         0x0002      /* ����д�д� */
-#define FSFB_QUEUE_INTEGRITY                     0x0003		/* 队列中数据不完整（包括scan有错，应用给出错误）*/
+#define FSFB_QUEUE_INTEGRITY                     0x0003		/* ���������ݲ�����������scan�д���Ӧ�ø�������*/
-#define FSFB_LNK_PUSH							0x0004		/* 链路管理表节点压栈错误 */
+#define FSFB_LNK_PUSH							0x0004		/* ��·�������ڵ�ѹջ���� */
-#define FSFB_LNK_POP								0x0005		/* 序列号缓存链表节点出栈错误 */
+#define FSFB_LNK_POP								0x0005		/* ���кŻ��������ڵ��ջ���� */
 
 
 

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

@@ -1,27 +1,27 @@
 
 /*******************************************************************************
-* �ļ���    ��  sfpConfig.h
+* 文件名    ：  sfpConfig.h
-* ��Ȩ˵��  ��  
+* 版权说明  ：  
-* �汾��    ��  1.0  
+* 版本号    ：  1.0  
-* ����ʱ��  ��  2010.05.04
+* 创建时间  ：  2010.05.04
-* ����      ��  ����
+* 作者      ：  李雁
-* ��������  ��  ���ļ�ΪSFPЭ�������ļ� 
+* 功能描述  ：  此文件为SFP协议配置文件 
-* ʹ��ע��  �� 
+* 使用注意  ： 
-                ��
+                无
-* �޸ļ�¼  ��  
+* 修改记录  ：  
 
 *******************************************************************************/
 
 #ifndef _SFPCONFIG_H
 #define _SFPCONFIG_H
 
-/**************************Э���¼�궨�忪��**********************************/
+/**************************协议记录宏定义开关**********************************/
-/*#define PRTCL_RECORD_DATA_ASC*/             /*���ݲ����ַ��ͼ�¼����*/
+/*#define PRTCL_RECORD_DATA_ASC*/             /*数据部分字符型记录开关*/
-/*#define PRTCL_RECORD_ERR_ASC*/              /*���󲿷��ַ��ͼ�¼����*/
+/*#define PRTCL_RECORD_ERR_ASC*/              /*错误部分字符型记录开关*/
 
-#define PRTCL_RECORD_SIMPLIFY_BIN	/*�����Ƽ�¼����*/
+#define PRTCL_RECORD_SIMPLIFY_BIN	/*二进制记录开关*/
-#define USE_DSU_SFP	/*ʹ��SFP��ѯ����*/
+#define USE_DSU_SFP	/*使用SFP查询函数*/
-#define SWAP_CRC		/*����CRC*/
+/*#define SWAP_CRC */		/*交换CRC*/
 
 #else
 #endif