调试日志修改

TSCP/src/APP/PU13_integration_config/ci_integrate_config.h

@@ -22,14 +22,14 @@
 
 
 
-/*Ԥ����ָ������ļ�����������*/
+/*预编译指令，用于文件的条件编译*/
 #ifndef _CI_INTEGRATE_CONFIG_H
 #define _CI_INTEGRATE_CONFIG_H
 
-/*��д�漯���ں˰汾��*/
+/*手写版集成内核版本号*/
-#define VER_INTE_PROJECT            220  /*��Ŀ���*/
+#define VER_INTE_PROJECT            220  /*项目编号*/
-#define VER_INTE_PRODUCT            40   /*��Ʒ���*/
+#define VER_INTE_PRODUCT            40   /*产品编号*/
-#define VER_INTE_EXE                99   /*��ִ�б��*/
+#define VER_INTE_EXE                1   /*可执行编号*/
-#define VER_INTE_TIME               102  /*���ɴ������*/
+#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();
@@ -357,15 +364,24 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 			ASSER_DEBUG(0u != errorCode, AAM_LOG(AAM_LOG_FATAL, "info:Clear AC%d RedunTime becasue pre/back error.\n", acID));
 		}
 		else
+		{
+			/*仅在待判断计轴当周期由空闲变占用时检查*/
+			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,9 +409,7 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 			{
 				; /*继续处理*/
 			}
-			/** 判断相邻范围内计轴坏车最近占用时间检查通过 */
+			
-			if ((CI_ERROR == chNearbyCheck))
-			{
 			/*有 坏车接近 或左右相邻计轴均无车接近 立即清除冗余计时*/
 			if ((AAM_BAD_NEAR == sameTrainType) || (AAM_BAD_NEAR == convertTrainType))
 			{
@@ -409,15 +423,14 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 				aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
 				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_SetAxisRedunCanArbFlag(acIndex, REDUN_OVER_ARB_NO);
 			}
-			}
 			else
 			{
 				/** 冗余计时位加1*/
@@ -435,18 +448,11 @@ 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
 					{
@@ -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,16 @@ 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);			
 					/*遍历计轴上最近坏车占用周期*/
@@ -1625,7 +1637,7 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 							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);
@@ -1638,6 +1650,12 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 						chKeepcheck = CI_ERROR;
 					}
 				}
+				else
+				{
+					;/*不处理*/
+					debug_infor_printf((const)"ACid: %d ,AdjacentSec Skip PhySec = %d\n", ACID, wCheckPhySec);
+				}
+			}
 		}
 		else
 		{
@@ -1649,10 +1667,28 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 	{
 		/*Step3 :当前物理区段间接相邻物理区段所有计轴无坏车*/
 		chNearSecNum = GetNearPhySecNum(wBasePhyid);
-		dwNearSecBuf = GetIndirectNearPhySecBuf(wBasePhyid);
+		pNearSecBuf = GetIndirectNearPhySecBuf(wBasePhyid);
 		for (ii = 0; ii < chNearSecNum; ii++)
 		{
-			wCheckPhySec = dwNearSecBuf[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);
 				/*遍历计轴上最近坏车占用周期*/
@@ -1677,6 +1713,16 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 					chKeepcheck = CI_ERROR;
 				}
 			}
+			else
+			{
+				;/*不可达状态 坏车占用不影响*/
+				debug_infor_printf((const)"ACid: %d ,NearSec Skip PhySec = %d\n", ACID, wCheckPhySec);
+			}
+			if (CI_SUCCESS != chKeepcheck)
+			{
+				break;
+			}
+		}
 	}
 	if (CI_SUCCESS == chKeepcheck)
 	{
@@ -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
@@ -2183,3 +2237,209 @@ 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,35 +667,74 @@ 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;
+		(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++)
+			{
+				chEnvelopeNum = elm_GetEnvelopeInAC(tmpAcIdBuf[chCfpAcIndex], szTmpEnvelope);
+				chFail = CI_SUCCESS;
 				if (SECTION_REL_ENVELOPE_SUM_MAX == chEnvelopeNum)
 				{
-			;
+					/*查找失败 添加坏车包络*/
+					chEnvelopeNum = 1U;
+					(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[0]);
 				}
-		else
+				/*将包络信息添加到分界点动态数据 */
-		{/* 将包络信息添加到分界点动态数据 */
+				g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum += chEnvelopeNum;
-			g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = chEnvelopeNum;
+				
-			for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
+				for (chEnvelopeIndex = 0U; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
 				{
+					chStepCheck = CutCfpOtherOcEData(tmpAcIdBuf[chCfpAcIndex], &szTmpEnvelope[chEnvelopeIndex], chDir);
+					if (CI_ERROR == chStepCheck)
+					{
+						/*截取失败设置坏车*/
+						(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[chEnvelopeIndex]);
+					}
 					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].envelopeType = szTmpEnvelope[chEnvelopeIndex].envelopeType;
 					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].headTrainID = szTmpEnvelope[chEnvelopeIndex].headTrainID;
 					g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].tailTrainID = szTmpEnvelope[chEnvelopeIndex].tailTrainID;
@@ -725,7 +764,108 @@ void SetCfpLocalOcEData(const UINT16 wCfpId)
 					(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[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,35 +1038,14 @@ 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);
-				chAxieIncLinkSum = GetAxisLinkSum(wLinkBelongAxieId);
-				szAxieIncLink = GetAxisLinkIdBuf(wLinkBelongAxieId);
-				chKeepFlag = elm_PrepareACLoc(wLinkBelongAxieId, ELM_DIR_SAME, &tmpAxieSecLoc);
 
 			if (CI_SUCCESS == chKeepFlag)
 			{
@@ -1012,11 +1125,6 @@ UINT8 CutCfpOtherOcEData(const UINT16 wCfpId, CfpEnvelopeStruct* strEnvelope)
 			}
 		}
 		else
-			{
-				;  /*返回失败*/
-			}
-		}
-		else
 		{
 			/*其他包络类型不截取，保留原数据*/
 			chReval = CI_SUCCESS;
@@ -1729,3 +1837,85 @@ void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpT
 		}
 	}
 }
+/**
+* @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);  /*获取区段数组下标*/
 	/**区段下标合法*/
@@ -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,6 +6527,29 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				reVal = CI_SUCCESS;
 			}
 		}
+
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔封锁状态检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwFLockCheck(logSectionId, &devId, &devState, &cYLockAlarmFlag);/*封锁检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 13U;
+			}
+		}
+
+		if (CI_SUCCESS == reVal)
+		{/*防护道岔位置检查*/
+			devId = 0u;                   /*设备ID*/
+			devState = 0u;                 /*设备状态*/
+			reVal = LogicSecRltvPrtctSwPosCheck(logSectionId, &devId, &devState);/*位置检查*/
+			if (CI_SUCCESS != reVal)
+			{
+				chFailStep = 14U;
+			}
+		}
+
 	}
 	else
 	{
@@ -6788,10 +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;
 	}
@@ -6820,6 +6890,32 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 			}
 		}
 
+		if (innerSwitchRetVal == CI_SUCCESS)
+		{
+			/* 单操相反位置取消驱动检查 */
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPosition = pProtectSwitchStru[ii].SwitchPosition;
+				switchDancaoPosition = GetSwitchDanCaoPostition(switchId);
+
+				if ((SWITCH_POSITION_INVALID == switchDancaoPosition)
+					||
+					(switchDancaoPosition == switchExpPosition))
+				{/*单操无效 或者 单操位置与动作位置一样*/
+					innerSwitchRetVal = CI_SUCCESS;
+				}
+				else
+				{
+					/*单操到相反位置取消道岔的驱动*/
+					innerSwitchRetVal = CI_ERROR;
+					break;
+				}
+			}
+		}
+
+
+
 		if (innerSwitchRetVal == CI_SUCCESS)
 		{
 			/*驱动计轴区段道岔*/
@@ -6838,7 +6934,7 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
 
 
 /*
-功能描述: 	驱动计轴区段内道岔处理
+功能描述: 	驱动计轴区段内道岔，计轴区段关联防护道岔处理
 输入参数:	const UINT16 axisSecId 计轴区段ID
 输出参数:	const UINT8 DrivFlag 道岔驱动标志
 返回值:		无
@@ -6850,12 +6946,18 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
 	UINT8 switchExpPos = 0u; 								/*道岔期望位置*/
 	AxisSwitchStruct* pAxisSecSwitchStru = NULL; 				/*道岔数据*/
 	UINT8 ii = 0u;											/*循环变量*/
-	UINT8 funRtn = CI_ERROR;
+
+	AxisSwitchStruct* pProtectSwitchStru = NULL;					/*防护道岔数据结构指针*/
+	UINT8 protectSwitchSum = 0u;
 
 	switchSum = GetAxisSwitchSum(axisSecId); /*获取计轴区段道岔数目*/
 	pAxisSecSwitchStru = GetAxisSwitchIdStru(axisSecId); /*获取计轴区段内道岔数据*/
 
+	protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
+	pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
 
+	if ((NULL != pAxisSecSwitchStru) && (NULL != pProtectSwitchStru))
+	{
 		if (SWITCH_NEED_DRIV_TRUE == DrivFlag)
 		{/*需要驱动计轴区段内道岔*/
 
@@ -6863,9 +6965,17 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
 			{
 				switchId = pAxisSecSwitchStru[ii].SwitchId;
 				switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
-			funRtn = SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
 			}
 
+			for (ii = 0u; ii < protectSwitchSum; ii++)
+			{
+				switchId = pProtectSwitchStru[ii].SwitchId;
+				switchExpPos = pProtectSwitchStru[ii].SwitchPosition;
+				(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段防护道岔的驱动状态为驱动中*/
+			}
+
+		}
 	}
 }
 
@@ -7319,7 +7429,7 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
 	UINT8 retValue = CI_ERROR;
 	UINT8 chLogSecLogLockState = 0U;  /*逻辑区段逻辑锁闭状态*/
 	UINT8 cLockBelongLogicRouteNum = 0U;  /*逻辑区段逻辑锁闭所属逻辑进路数量*/
-
+	UINT8 chLogSecJumpLockState = 0U;
 	/*获取道岔关联逻辑区段信息*/
 	logSecSum = GetSwitchLogSecSum(switchId);
 	logSecBuf = GetSwitchLogSecBuf(switchId);
@@ -7343,8 +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;
 				}
@@ -11367,3 +11478,84 @@ 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);
@@ -2082,7 +2082,7 @@ void elm_SafeProtectProcess(void)
 		else
 		{
 			/** CT/UCT车飞车防护--宕机防护*/
-			/*elm_FlyingProtect();*/
+			elm_FlyingProtect();
 		}
 
 		/** 本OC范围内的计轴映射表合法性校验 */

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
 							{
@@ -16443,3 +16443,46 @@ 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,7 +1674,16 @@ void RouteNearLockErrManage(const UINT16 routeId)
 		{/*之前驱动开放*/
 			if ((CI_SUCCESS == autoSignalValid) || (ROUTE_REPEATOPEN_SET_YES == routeRepeatStat))
 			{ /*自动信号或者重开*/
-
+				cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_REOPRN_SET_NEAR);
+				if(FUNC_SWITCH_ON == cFuncSwitch)
+				{
+					/*“重开信号是否记忆进路接近锁闭状态开关”配置为0xAA时，默认设置进路接近*/
+					SetRouteStateManage(routeId, ROUTE_STATE_NEAR_OPEN);   /*-->设置接近开放*/
+					RouteNearOpenManage(routeId); /*-->进路接近开放管理*/
+				}
+				else
+				{
+					/*“重开信号是否记忆进路接近锁闭状态开关”配置为0x55时，根据接近区段占用状态设置进路接近/未接近*/
 					if (CI_SUCCESS == routeTrainNear)
 					{/*进路有车接近*/
 						SetRouteStateManage(routeId, ROUTE_STATE_NEAR_OPEN);   /*-->设置接近开放*/
@@ -1687,6 +1697,7 @@ void RouteNearLockErrManage(const UINT16 routeId)
 						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();
@@ -11408,6 +11508,11 @@ void CheckLogSecJumpLockManage(void)
 					/** 检查本TIOC控区逻辑区段跳跃锁闭条件*/
 					checkResult = CheckLogJumpLockApply(logicSecId);
 					if (CI_SUCCESS == checkResult)
+					{
+						devId = 0u;
+						devState = 0u;
+						retVal = LogicSecRltvPrtctSwLockCheck(logicSecId, &devId, &devState);
+						if (CI_SUCCESS == retVal)
 						{
 							/** 检查条件满足，设置跳跃锁闭允许标志为允许 */
 							SetLogSecJumpLockPermFlag(logicSecId, LOGIC_JUMPUNLOCK_PERMISSIVE_YES);
@@ -11419,6 +11524,12 @@ void CheckLogSecJumpLockManage(void)
 						}
 					}
 					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);
+						SetAxisRelProSwitchLockSta(wAxisSectionId, SWITCH_LOCK_PROTECT_SET);
+
+						chTempcheck = AxisRelatedProSwitchLockCheck(wAxisSectionId, &devId, &devState);
+						if (CI_SUCCESS == chTempcheck)
+						{/*检查计轴区段锁闭状态*/
 							SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
 							SetAxisInCludeLogJumpLockState(wAxisSectionId, LOGIC_SECTION_JUMP_LOCK_YES);
+						}
+						else
+						{
+							/*无执行*/
+						}
+
+
+
 					}
 					else
 					{
@@ -14447,9 +14558,18 @@ void PhySecJumpLockLogicManage(void)
 				}
 				else
 				{  /*联锁内部锁闭，当持续检查锁闭条件满足时，再次给ZC发锁闭*/
-
+					devId = 0u;
+					devState = 0u;
+					chTempcheck = AxisRelatedProSwitchLockCheck(wAxisSectionId, &devId, &devState);
+					if (CI_SUCCESS == chTempcheck)
+					{
 						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_YES);
 					}
+					else
+					{
+						SetPhySecJumpLockStateToZC(wPhyId, PHYSICAL_SECTION_JUMP_LOCK_NO);
+					}
+				}
 			}
 		}
 		if ((AXIS_SECTION_JUMPLOCK_APPLY_NO == chApplyFlag) &&
@@ -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,13 +15588,43 @@ 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);
 	if ((0U != wLogSectionId) && (0U != wTrnId))
 	{
 		if (LOG_SECTION_LOGLOCK_NORMAL == chLogRouteLogicLockState)
+		{
+			wBelongPhySec = GetLgcSecRelativePhySecId(wLogSectionId);
+			chQcxFlag = GetPhySecQcxFlag(wBelongPhySec);
+			if (PHYSICAL_SECTION_QCX_YES == chQcxFlag)
+			{
+				/*牵出线区段RM列车检查区段外方进路*/
+				chTrainLevel = GetTrainLevel(wTrnId);
+				if (TRAIN_LEVEL_VBTC == chTrainLevel)
+				{
+					chKeepFlag = CI_SUCCESS;
+				}
+				else
+				{
+					/*检查牵出线外方信号机办理列车进路/折返进路*/
+					chKeepFlag = CheckQcxLiecheRoute(wBelongPhySec);
+				}
+			}
+			else if (PHYSICAL_SECTION_QCX_NO == chQcxFlag)
+			{
+				chKeepFlag = CI_SUCCESS;
+			}
+			else
+			{
+				/*异常防护*/
+				chKeepFlag = CI_ERROR;
+			}
+			if (CI_SUCCESS == chKeepFlag)
 			{
 				wLogSignalId = GetLogicalRouteRelateBeginSigId(wLogicRLockLogRouteId);
 				if (0U != wLogSignalId)
@@ -15534,6 +15685,11 @@ void SetLogRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrnId,
 				}
 			}
 			else
+			{
+				SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
+			}
+		}
+		else
 		{
 		/*无锁闭状态 或锁闭状态异常*/
 		SetLogSecTrainUseState(wLogSectionId, wTrnId, LOGIC_SECTION_RES_UNUSABLE);
@@ -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);                       /*获取进路状态*/
@@ -15571,6 +15730,33 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 
 	if ((LOG_SECTION_LOCK_NORMAL == chLogicLockState)
 		|| (LOG_SECTION_LOCK_DELAY == chLogicLockState))
+	{
+		wBelongPhySec = GetLgcSecRelativePhySecId(wLogSectionId);
+		chQcxFlag = GetPhySecQcxFlag(wBelongPhySec);
+		if (PHYSICAL_SECTION_QCX_YES == chQcxFlag)
+		{
+			/*牵出线区段RM列车检查区段外方进路*/
+			chTrainLevel = GetTrainLevel(wTrainId);
+			if (TRAIN_LEVEL_VBTC == chTrainLevel)
+			{
+				chKeepFlag = CI_SUCCESS;
+			}
+			else
+			{
+				/*检查牵出线外方信号机办理列车进路/折返进路*/
+				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);
 
@@ -15665,6 +15851,11 @@ void SetNormalRouteLogicResUsable(const UINT16 wLogSectionId, const UINT16 wTrai
 			}
 		}
 		else
+		{
+			SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
+		}
+	}
+	else
 	{
 		/*无锁闭状态 或锁闭状态异常*/
 		SetLogSecTrainUseState(wLogSectionId, wTrainId, LOGIC_SECTION_RES_UNUSABLE);
@@ -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
 		{
@@ -16534,3 +16725,157 @@ 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]);  /*命令帧总长度*/
@@ -3093,3 +3091,217 @@ 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/ParsePackAxleData.c

@@ -167,7 +167,7 @@ UINT8 InitAxleToCiDataStru(void)
 					axisToCiDataStru[axleId].axisEtcsId = axieEtcsId;
 					axisToCiDataStru[axleId].ciEtcsId = ciEtcsId;
 
-					(void)memset(axisToCiDataStru[axleId].PhySecIdx, (INT32)AXISDATASTR_IDX, PHYSICAL_SECTION_SUM_MAX); /*默认设置下标为无效位置*/
+					(void)memset(axisToCiDataStru[axleId].PhySecIdx, (INT)AXISDATASTR_IDX, PHYSICAL_SECTION_SUM_MAX); /*默认设置下标为无效位置*/
 					for (j = 0u; j < phySecCurSum; j++) /*遍历物理区段*/
 					{
 						phySecId = GetPhySecId(j);

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,21 +2642,14 @@ 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);
-				}
-				else
-				{
-					reVal = CI_ERROR;
-				}
-
 					for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
 					{
-					tmpEnvelopeInfo.envelopeType = dataBuf[ii++];	/* 包络类型 */
+						tmpOtherEnvelope[chEnvelopeIndex].envelopeType = dataBuf[ii++];	/* 包络类型 */
-					if ((TYPE_UKT_ENVELOPE == tmpEnvelopeInfo.envelopeType)
+						if ((TYPE_UKT_ENVELOPE == tmpOtherEnvelope[chEnvelopeIndex].envelopeType)
-						|| (TYPE_UCT_ENVELOPE == tmpEnvelopeInfo.envelopeType)
+							|| (TYPE_UCT_ENVELOPE == tmpOtherEnvelope[chEnvelopeIndex].envelopeType)
-						|| (TYPE_CT_ENVELOPE == tmpEnvelopeInfo.envelopeType))
+							|| (TYPE_CT_ENVELOPE == tmpOtherEnvelope[chEnvelopeIndex].envelopeType))
 						{
 							;/*1:通信车 2：丢失通信车 3：隐藏车*/
 						}
@@ -2666,54 +2658,53 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 							reVal = CI_ERROR;
 						}
 
-					tmpEnvelopeInfo.headTrainID = ShortFromChar(&dataBuf[ii]);/* 前车ID */
+						tmpOtherEnvelope[chEnvelopeIndex].headTrainID = ShortFromChar(&dataBuf[ii]);/* 前车ID */
 						ii += 2u;
 
-					tmpEnvelopeInfo.tailTrainID = ShortFromChar(&dataBuf[ii]);/* 后车ID */
+						tmpOtherEnvelope[chEnvelopeIndex].tailTrainID = ShortFromChar(&dataBuf[ii]);/* 后车ID */
 						ii += 2u;
 
-					tmpEnvelopeInfo.startPos.Dir = dataBuf[ii++];/* 起点方向 */
+						tmpOtherEnvelope[chEnvelopeIndex].startPos.Dir = dataBuf[ii++];/* 起点方向 */
 
-					tmpEnvelopeInfo.startPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 起点link */
+						tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 起点link */
 						ii += 2u;
 
-					tmpEnvelopeInfo.startPos.Off = LongFromChar(&dataBuf[ii]);/* 起点offset */
+						tmpOtherEnvelope[chEnvelopeIndex].startPos.Off = LongFromChar(&dataBuf[ii]);/* 起点offset */
 						ii += 4u;
 
-					tmpEnvelopeInfo.endPos.Dir = dataBuf[ii++];/* 终点方向 */
+						tmpOtherEnvelope[chEnvelopeIndex].endPos.Dir = dataBuf[ii++];/* 终点方向 */
 
-					tmpEnvelopeInfo.endPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 终点link */
+						tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk = ShortFromChar(&dataBuf[ii]);/* 终点link */
 						ii += 2u;
 
-					tmpEnvelopeInfo.endPos.Off = LongFromChar(&dataBuf[ii]);/* 终点offset */
+						tmpOtherEnvelope[chEnvelopeIndex].endPos.Off = LongFromChar(&dataBuf[ii]);/* 终点offset */
 						ii += 4u;
 
-					wLinkTioc = GetLinkManageTiocById(tmpEnvelopeInfo.startPos.Lnk);
+						wLinkTioc = GetLinkManageTiocById(tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk);
 						if (wLinkTioc == localCiId)
 						{
-						(void)dsuCheckSameLoc(tmpEnvelopeInfo.startPos.Lnk, tmpEnvelopeInfo.startPos.Off, &tmpEnvelopeInfo.startPos.Lnk, &tmpEnvelopeInfo.startPos.Off);
+							(void)dsuCheckSameLoc(tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk, tmpOtherEnvelope[chEnvelopeIndex].startPos.Off, &tmpOtherEnvelope[chEnvelopeIndex].startPos.Lnk, &tmpOtherEnvelope[chEnvelopeIndex].startPos.Off);
 						}
 
-					wLinkTioc = GetLinkManageTiocById(tmpEnvelopeInfo.endPos.Lnk);
+						wLinkTioc = GetLinkManageTiocById(tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk);
 						if (wLinkTioc == localCiId)
 						{
-						(void)dsuCheckSameLoc(tmpEnvelopeInfo.endPos.Lnk, tmpEnvelopeInfo.endPos.Off, &tmpEnvelopeInfo.endPos.Lnk, &tmpEnvelopeInfo.endPos.Off);
+							(void)dsuCheckSameLoc(tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk, tmpOtherEnvelope[chEnvelopeIndex].endPos.Off, &tmpOtherEnvelope[chEnvelopeIndex].endPos.Lnk, &tmpOtherEnvelope[chEnvelopeIndex].endPos.Off);
 						}
 
-					/*截取分界点相邻OC发来的包络数据*/
+						/*分界点相邻OC发来的包络截取转移至发送联锁处理*/
-					reVal = CutCfpOtherOcEData(deviceId,&tmpEnvelopeInfo);
 
-					tmpEnvelopeInfo.ACCnt = elm_PrepareACBtwPoints(tmpEnvelopeInfo.startPos, tmpEnvelopeInfo.endPos, tmpEnvelopeInfo.ACID);
+						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 == tmpEnvelopeInfo.ACCnt) || (0u == tmpEnvelopeInfo.ACCnt))
+						if ((SECTION_IN_ENVELOPE_SUM_MAX == tmpOtherEnvelope[chEnvelopeIndex].ACCnt) || (0u == tmpOtherEnvelope[chEnvelopeIndex].ACCnt))
 						{
 							reVal = CI_ERROR;
 						}
 						else
 						{
-						for (chAcIndex = 0u; chAcIndex < tmpEnvelopeInfo.ACCnt; chAcIndex++)
+							for (chAcIndex = 0u; chAcIndex < tmpOtherEnvelope[chEnvelopeIndex].ACCnt; chAcIndex++)
 							{
-							wTiocId = GetAxisBelongTioc(tmpEnvelopeInfo.ACID[chAcIndex]);
+								wTiocId = GetAxisBelongTioc(tmpOtherEnvelope[chEnvelopeIndex].ACID[chAcIndex]);
 								if ((localCiId == wTiocId) || (0u == wTiocId))
 								{
 									reVal = CI_ERROR;
@@ -2727,27 +2718,40 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 						}
 
 
-					tmpEnvelopeInfo.trianCnt = dataBuf[ii++];/* 包含列车数量 */
+						tmpOtherEnvelope[chEnvelopeIndex].trianCnt = dataBuf[ii++];/* 包含列车数量 */
 
-					for (chTrainIndex = 0u; chTrainIndex < tmpEnvelopeInfo.trianCnt; chTrainIndex++)
+						for (chTrainIndex = 0u; chTrainIndex < tmpOtherEnvelope[chEnvelopeIndex].trianCnt; chTrainIndex++)
 						{
-						tmpEnvelopeInfo.trainID[chTrainIndex] = ShortFromChar(&dataBuf[ii]);/* 列车ID */
+							tmpOtherEnvelope[chEnvelopeIndex].trainID[chTrainIndex] = ShortFromChar(&dataBuf[ii]);/* 列车ID */
 							ii += 2u;
 
-						tmpEnvelopeInfo.ACTPort[chTrainIndex] = dataBuf[ii++];  /* 列车激活端——UCT跨分界点RRM用 */
+							tmpOtherEnvelope[chEnvelopeIndex].ACTPort[chTrainIndex] = dataBuf[ii++];  /* 列车激活端——UCT跨分界点RRM用 */
 						}
 
+						if (CI_SUCCESS != reVal)
+						{
+							break;
+						}
+					}
 					if (CI_SUCCESS == reVal)
 					{
-						/* 写入分界点接收到的包络数据 */
+						/*全部解析通过 写入分界点接收到的包络数据 */
-						SetCfpOtherOcEData(deviceId, chEnvelopeIndex, tmpEnvelopeInfo);
+						SetCfpOtherOcENum(deviceId, chEnvelopeNum);
+						for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
+						{
+							SetCfpOtherOcEData(deviceId, chEnvelopeIndex, tmpOtherEnvelope[chEnvelopeIndex]);
+						}
+						
+					}
 				}
 				else
 				{
-						;
+					reVal = CI_ERROR;
-					}
 				}
 
+				
+				if (CI_SUCCESS == reVal)
+				{
 					chCtNum = dataBuf[ii++];
 					for (chCtIndex = 0u; chCtIndex < chCtNum; chCtIndex++)
 					{
@@ -2853,6 +2857,11 @@ UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength)
 						/*非本控区信号机，不处理*/
 					}
 				}
+				else
+				{
+					break;
+				}
+			}
 		}
 	}
 
@@ -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/ParsePackOcData.c

@@ -1326,7 +1326,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 		ocName = (CI_SYSTEM_TYPE_OC) * 256U + systemId;
 		localCiId = GetSystemParaLocalCiId();	/*获取联锁ID*/
 
-#if 0
 		galOcDataVer = GetCiTranOcDataCheckVer(localCiId, ocName); /*获取OC系统数据版本号*/
 		if (hlhtGalHead.emapVerCrc == galOcDataVer)
 		{
@@ -1336,8 +1335,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 		{
 			headRet = HLHT_HEAD_ERROR;
 		}
-#endif
-		headRet = HLHT_HEAD_SUCCESS;  /*不对OC的数据版本进行校验*/
 #if 0
 		headRet = HLHTRecvCommonPacketHeadCheck(ocName, ciName, CI_OC_INTERFACE_INFOTYPE, CI_OC_PRTCL_VER, &hlhtGalHead, &errCode, 0, CI_SYSTEM_TYPE_OC);
 #endif

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))
 		{/*组注销请求回复帧*/
@@ -6704,7 +6715,7 @@ static UINT8 PackCiToIvocCommTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 		ii = *wDataLength;
 		chRetVal = CI_SUCCESS;
 		
-		wEnvelopeSum = 0u;
+		wEnvelopeSum = elm_GetCTEnvelope(szEnvelopeIdBuf);
 		if (ENVELOPE_SUM_MAX > wEnvelopeSum)
 		{
 			wEnvelopeSendSumIndex = ii;
@@ -6922,7 +6933,7 @@ static UINT8 PackCiToIvocFaultTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 		ii = *wDataLength;
 		chRetVal = CI_SUCCESS;
 
-		wEnvelopeSum = 0u;
+		wEnvelopeSum = elm_GetFaultEnvelope(szEnvelopeIdBuf);
 		if (ENVELOPE_SUM_MAX > wEnvelopeSum)
 		{
 			wEnvelopeSendSumIndex = ii;
@@ -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;
 					}
 					/*前筛*/
+					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);
 					}
 					/*后筛*/
+					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*/
@@ -11956,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;
 							}
@@ -12696,3 +12743,103 @@ 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*/
@@ -4862,17 +4868,6 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
 		{
 		}
 
-		/*设置进路入库属性*/
-		pRouteCfgDtStr->cRouteRukuProperty = ROUTE_RUKU_PROPERTY_NO;
-		if (0x0010U == (pDsuRouteStr->wRouteType & 0x0010U))
-		{
-			pRouteCfgDtStr->cRouteRukuProperty = ROUTE_RUKU_PROPERTY_YES;
-		}
-		else
-		{
-			/*非入库进路，不处理*/
-		}
-
 		/*自动信号属性*/
 		pRouteCfgDtStr->AutoSigProperty = ROUTE_AUTOSIG_PROPERTY_NO;
 		if(0xaau == pDsuRouteStr->wAttribute)
@@ -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;
 }
 
@@ -7370,32 +7393,6 @@ UINT8 TransmitRelationDataStructInit(CHAR* FSName)
 		}
 		(void)TransmitRelationDataStruFrmSZ(Data);
 	}
-
-	/*默认车辆段RC与120个OC通信*/
-	for (j = 0u; j < dquCICfgDtStr.TrsmtRlsDtStrLen; j++)
-	{
-		if ((0x0CU == dquCICfgDtStr.TrsmtRlsDtStr[j].CiId) && (CI_SYSTEM_TYPE_OC == dquCICfgDtStr.TrsmtRlsDtStr[j].SystemType))
-		{
-			/*车辆段RC，为其添加120个OC*/
-			for (i = 0U; i < (TRANSMIT_OBJECT_DEVICE_SUM_MAX - 1U); i++)
-			{
-				if (i < 6)
-				{
-					dquCICfgDtStr.TrsmtRlsDtStr[j].DeviceIdBuf[i] = i + 24U;
-				}
-				else
-				{
-					dquCICfgDtStr.TrsmtRlsDtStr[j].DeviceIdBuf[i] = i + 25U;
-				}
-			}
-			dquCICfgDtStr.TrsmtRlsDtStr[j].DeviceSum = TRANSMIT_OBJECT_DEVICE_SUM_MAX - 1U;
-			break;
-		}
-		else
-		{
-		}
-	}
-
 	rtnValue = 1u;
 	return rtnValue;
 }
@@ -11760,6 +11757,11 @@ UINT8 LogRelateProSwDataInit(RouteConfigDataStruct* RouteCfgDtStr, LogicSectionC
 	{
 		rtnvalue = 1U;
 	}
+
+	if (1U == rtnvalue)
+	{/*将逻辑区段所属保护区段的防护道岔存储入逻辑区段结构体*/
+		rtnvalue = LogRelateProSwDataByOverlapInit(pLgScCfgDtStr);
+	}
 	return rtnvalue;
 }
 
@@ -12779,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

@@ -1066,3 +1066,49 @@ UINT8 LS_TransZFSigFromChar(UINT8* pDataAddr, LS_TransRouteZFSigStruct* pTransRo
 	}
 	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

@@ -2360,3 +2360,91 @@ 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
@@ -3525,3 +3498,52 @@ 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

@@ -1151,3 +1151,55 @@ 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
 					{
-						;  /*不更新*/
+						;/*不更新最近坏车周期*/
 					}
 				}
 			}
@@ -787,3 +788,130 @@ 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
 		{

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,7 +1288,7 @@ 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)
@@ -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;
 
@@ -1611,3 +1665,372 @@ 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

@@ -27,6 +27,13 @@
 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道岔数据
 * 参数说明： 
@@ -407,6 +406,73 @@ void SetSwitchLockStatus(const UINT8 pLockType,const UINT16 pLockId,const UINT16
 			retVal = CI_SUCCESS;
 		}
 		break;
+		case SWITCH_PLOCKTYPE_AXISSEC:/*锁闭类型为被计轴区段防护锁闭*/
+		{
+			if (SWITCH_LOCK_PROTECT_SET == lockCommand)
+			{/*设置防护锁闭*/
+				findFlag = 0u;/*置未找到*/
+				emptyIndex = -1;/*空位索引*/
+				/*查找被防护计轴区段id是否存在，存在，退出；不存在，找一个存放位置，更新被锁闭的计轴区段数量*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (emptyIndex < 0)/*空位索引小于0，才查找空位索引*/
+					{
+						if (0u == SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii])
+						{
+							emptyIndex = (INT16)ii;/*空位值为0，表示为空位，记住索引*/
+						}
+					}
+
+					if (pLockId == SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii])
+					{/*找到被锁闭的id*/
+						findFlag = 1u;
+					}
+				}
+
+				if (0u == findFlag)
+				{/*没找到被锁闭id*/
+					if (emptyIndex >= 0)
+					{/*且空位存在*/
+						SwitchDataStru[bufIndex].PLockedAxisSecIdArr[emptyIndex] = pLockId;/*设置被锁闭id*/
+						SwitchDataStru[bufIndex].PLockedAxisSecNum++; /*被锁闭id数量增加1个*/
+					}
+					else
+					{/*超过软件支持的最大防护锁闭设备数目，输出打印信息*/
+						debug_infor_printf((const)"Set switch id %d PLOCK by axis %d fail,no empty space\n", bufIndex, pLockId);
+					}
+				}
+			}
+			else if (SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
+			{/*取消防护锁闭*/
+				targetIndex = -1;/*目标索引*/
+				/*如果没找到，返回*/
+				/*找到，设为0，且把数量-1*/
+				for (ii = 0u; ii < SWITCH_MAX_PROTECT_LOCKED_NUM; ii++)
+				{
+					if (SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii] == pLockId)
+					{
+						targetIndex = (INT16)ii;
+						SwitchDataStru[bufIndex].PLockedAxisSecIdArr[ii] = 0;/*设为0*/
+						break;
+					}
+				}
+
+				if (targetIndex >= 0)/*找到了*/
+				{
+					if (SwitchDataStru[bufIndex].PLockedAxisSecNum > 0U)
+					{
+						SwitchDataStru[bufIndex].PLockedAxisSecNum--;/*减1处理*/
+					}
+				}
+
+			}
+			else
+			{
+				/*非法命令，不处理*/
+			}
+			retVal = CI_SUCCESS;
+			break;
+		}
 		default:
 		{
 			/*类型非法，置返回标志错误*/
@@ -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/CiSystemDefine.h

@@ -275,7 +275,7 @@
 /*ZFWJ采集吸起之后报警计轴总复位继电器混线有效的周期数*/
 #define ZFWJ_REYLAY_VALID_CYCLE_NUM                   ((UINT32)3)        /*ZFWJ采集吸起之后认为有效的周期数*/
 
-#define OC_SUM_MAX ((UINT16)150) /*与CI通信的OC ID最大值*/
+#define OC_SUM_MAX ((UINT16)100) /*与CI通信的OC ID最大值*/
 #define AXLE_SUM_MAX ((UINT16)100) /*与CI通信的计轴系统 ID最大值*/
 
 #define  TIOCFS_VERSION_LENGTH      4U                /*版本号长度*/

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

@@ -60,9 +60,9 @@
 /*联锁V13.0版本升级数据结构 2018.8.3*/
 /*版本号*/
 #define VER_MAIN_SUBCI_CI_CID            ((UINT8)22)   /*子系统主版本号*/
-#define VER_SUB_SUBCI_CI_CID			 ((UINT8)88)	/*子系统子版本号*/
+#define VER_SUB_SUBCI_CI_CID			 ((UINT8)0)	/*子系统子版本号*/
-#define VER_BRUNCH_CI_CID			     ((UINT8)3)	/*分支版本号..........主线填0....分支填1 调试填2 */
+#define VER_BRUNCH_CI_CID			     ((UINT8)6)	/*分支版本号..........主线填0....分支填1 调试填2 */
-#define VER_RETURN_SUBCI_CI_CID			 ((UINT8)0)	/*子系统回归版本号*/
+#define VER_RETURN_SUBCI_CI_CID			 ((UINT8)1)	/*子系统回归版本号*/
 
 #ifdef SCADE_MODE
 /*SCADE软件版本号*/
@@ -74,9 +74,9 @@
 #else
 /*手写软件版本号*/
 #define VER_SOFT_PRODUCT            ((UINT8)40) /*产品编号*/
-#define VER_SOFT_MODUAL_APP             ((UINT8)88)  /*模块编号*/
+#define VER_SOFT_MODUAL_APP             ((UINT8)1)  /*模块编号*/
 #define VER_SOFT_MIANVERSION        ((UINT8)22)  /*主版本号*/
-#define VER_SOFT_SUBVERSION         ((UINT8)9) /*子版本号*/
+#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,8 +2521,13 @@ static void CalTrainSafePosition(void)
 	UINT8 chResult = CI_ERROR;
 	UINT32 dwTailDistance = 0U;/*退行距离*/
 	UINT8 chTrainIsSwTrackFlag = CI_ERROR;/*列车休眠唤醒轨标志*/
+	ELM_TrainSafeLocStruct strTrainSafeLoc = { 0U };    /*列车安全位置*/
+	UINT8 ii = 0U;
+	UINT8 cSafeLocRelAcNum = 0U;  /*安全位置覆盖的计轴区段数量*/
+	UINT16 szSafeLocRelAcId[SECTION_IN_ENVELOPE_SUM_MAX] = { 0U };      /*安全位置覆盖的计轴区段ID*/
 	
-	wTailDis = GetBackProtectMaxLen();
+	/*计算列车安全位置前，周期清除计轴区段列车安全位置覆盖标志为无效*/
+	ClearAxisTXSafeLocFlag();
 
 	/*遍历所有列车*/
 	for (trainCycle = 0u; trainCycle < TRAIN_SUM_MAX; 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,7 +152,7 @@
 
 #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列车查询范围内的道岔数量*/

TSCP/src/APP/ciapp/Transmit/TransmitDefine.h

@@ -1,13 +1,13 @@
 /********************************************************
 *                                                                                                            
-* �� �� ���� TransmitDefine.h   
+* 文 件 名： TransmitDefine.h   
-* ��Ȩ˵���� �������ؿƼ����޹�˾ 
+* 版权说明： 北京交控科技有限公司 
-* ����ʱ�䣺 2012-04-01
+* 创建时间： 2012-04-01
-* ��    �ߣ� ������
+* 作    者： 联锁组
-* ���������� ͨ�Ź������ö���ͷ�ļ�  
+* 功能描述： 通信管理配置定义头文件  
-* ����������
+* 函数包括：
-* ʹ��ע�⣺
+* 使用注意：
-* �޸ļ�¼��   
+* 修改记录：   
 *
 ********************************************************/ 
 
@@ -15,43 +15,43 @@
 #define _TRANSMIT_DEFINE_H_
 
 
-/*����ϵͳ����ͷ�ļ�*/
+/*包含系统配置头文件*/
 #include "../System/SystemConfigDefine.h"
 
 
 
 
-#define TRANSMIT_OBJECT_SUM_MAX              ((UINT16)16)          /*��������ͨ�Ŷ�������ֵ*/
+#define TRANSMIT_OBJECT_SUM_MAX              ((UINT16)16)          /*定义联锁通信对象的最大值*/
-#define TRANSMIT_OBJECT_DEVICE_SUM_MAX       ((UINT16)107)         /*��������ͬ��ͬ�豸����ͨ�ŵ��豸���ֵ*/
+#define TRANSMIT_OBJECT_DEVICE_SUM_MAX       ((UINT16)18)         /*定义联锁同相同设备类型通信的设备最大值*/
 
 
 
-/*ͨ��״̬*/
+/*通信状态*/
-#define TRANSMIT_STATE_BAD					((UINT8)0x55)      /*ͨ���ж�*/
+#define TRANSMIT_STATE_BAD					((UINT8)0x55)      /*通信中断*/
-#define TRANSMIT_STATE_GOOD					((UINT8)0xaa)      /*ͨ������*/
+#define TRANSMIT_STATE_GOOD					((UINT8)0xaa)      /*通信良好*/
-#define NOT_IN_TRAINSMIT_LIST				((UINT8)0x5a)		/*����ͨ���б���*/
+#define NOT_IN_TRAINSMIT_LIST				((UINT8)0x5a)		/*不在通信列表中*/
 
-/*ͨ��״̬*/
+/*通信状态*/
-#define TRANSMIT_2OO2_STATE_GOOD                  ((UINT8)0x01)      /*ͨ������*/
+#define TRANSMIT_2OO2_STATE_GOOD                  ((UINT8)0x01)      /*通信良好*/
-#define TRANSMIT_2OO2_STATE_LINK                  ((UINT8)0x02)      /*������*/
+#define TRANSMIT_2OO2_STATE_LINK                  ((UINT8)0x02)      /*维持连接*/
-#define TRANSMIT_2OO2_STATE_BAD                   ((UINT8)0x03)      /*ͨ���ж�*/
+#define TRANSMIT_2OO2_STATE_BAD                   ((UINT8)0x03)      /*通信中断*/
 
-/*ͨ��״̬(���ڷ�ATS�豸״̬֡��ͨ��������Ϣ)*/
+/*通信状态(用于发ATS设备状态帧的通信联锁信息)*/
-#define TRANSMIT_CI_STATE_GOOD					((UINT8)0x55)      /*ͨ������*/
+#define TRANSMIT_CI_STATE_GOOD					((UINT8)0x55)      /*通信良好*/
-#define TRANSMIT_CI_STATE_LINK					((UINT8)0xAA)      /*������*/
+#define TRANSMIT_CI_STATE_LINK					((UINT8)0xAA)      /*维持连接*/
-#define TRANSMIT_CI_STATE_BAD					((UINT8)0xFF)      /*ͨ���ж�*/
+#define TRANSMIT_CI_STATE_BAD					((UINT8)0xFF)      /*通信中断*/
 
-/*ͨ�Ź����ж�*/
+/*通信故障判断*/
-#define  COM_ERROR_FSIO_MAXCYCLENUM    ((UINT16)5)      /*IO������ͨ�Ź����ж����������*/
+#define  COM_ERROR_FSIO_MAXCYCLENUM    ((UINT16)5)      /*IO与联锁通信故障判断最大周期数*/
-#define  COM_ERROR_LEU_MAXCYCLENUM	   ((UINT32)100)	/*LEU������ͨ�Ź����ж����������*/
+#define  COM_ERROR_LEU_MAXCYCLENUM	   ((UINT32)100)	/*LEU与联锁通信故障判断最大周期数*/
 
 
-/*ͨ������*/
+/*通信周期*/
-#define  COM_CYCNUM_CI_TO_ATS      ((UINT8)1)        /*������ATSÿ�������ڷ���һ��*/
+#define  COM_CYCNUM_CI_TO_ATS      ((UINT8)1)        /*联锁到ATS每两个周期发送一次*/
-#define  COM_CYCNUM_CI_TO_XIANDI   ((UINT8)1)        /*�������ֵ�ÿ�������ڷ���һ��*/
+#define  COM_CYCNUM_CI_TO_XIANDI   ((UINT8)1)        /*联锁到现地每两个周期发送一次*/
 
-#define  TRANSMIT_NET_ATC_RED		((UINT8)0x55)	 /*ATC��������չ����*/
+#define  TRANSMIT_NET_ATC_RED		((UINT8)0x55)	 /*ATC红网，扩展红网*/
-#define  TRANSMIT_NET_ATC_BLUE		((UINT8)0xAA)	 /*ATC��������չ����*/
+#define  TRANSMIT_NET_ATC_BLUE		((UINT8)0xAA)	 /*ATC蓝网，扩展蓝网*/
 #endif
 
 

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);
@@ -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,11 +492,13 @@ 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");
-			//(void)system("shutdown");
+			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,18 +2175,12 @@ 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);
-	/*- 本系是否为主 */
-	if ((ENUM_2x2_MASTER == s_2x2_Ctrl.LocalState))
-	{
 	/*- 填写适配层(-1)跟随数据 */
 	len = SFM_GetPrtclFollowData(g_TxBaseFollow + 4, (CM_UINT32)(sizeof(g_TxBaseFollow)) - 4u);
 	CM_LongToChar(len, g_TxBaseFollow);
@@ -2212,12 +2195,10 @@ void SFM_2x2_InputProc(void)
 	CM_LongToChar(sysCyc, g_TxBaseFollow + g_TxBaseFollow_len + 4u);
 	CM_LongToChar(SFM_GetTxSn(), g_TxBaseFollow + g_TxBaseFollow_len + 8u);
 	g_TxBaseFollow_len += 12u;
-	   /*- 发送 */
+	/* 2取比较后,若为主系执行发送*/
-	   SFM_2x2_Send(g_TxBaseFollow, (CM_UINT32)g_TxBaseFollow_len, ENUM_2x2_MSG_BASE_FOLLOW);
+	if(0x55u == g_PFM_Cfg.M_2oo2_Enable)
-	}
-	else
 	{
-	  /*- 无处理 */
+		s_2x2_BaseFollow_2oo2Check_Send();
 	}
 	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);
@@ -1695,8 +1701,6 @@ void SFM_TxOutnetSafe(IN CM_UINT8 buf[], IN CM_UINT32 Len)
     CM_UINT32 tx_sn = 0u;
     CM_RE_ASSERT((allLen + 4u) == Len, PRTCL_MODE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_1);
     i = 4u;
-	CM_UINT32 cnt1 = 0u, cnt2 = 1u, len1 = 0u, len2 = 0u;
-	CM_UINT64 tmpStartTick = 0, UsedTime1 = 0, UsedTime2 = 0;
     /*- 循环遍历输出队列 */
     while ((i + 7u) < Len)
     {
@@ -1786,24 +1790,16 @@ void SFM_TxOutnetSafe(IN CM_UINT8 buf[], IN CM_UINT32 Len)
 			if (ENUM_CM_SEB == isSendExtendBoard)
 			{
 				/*- 向红网SE发送SE外网帧 */
-				cnt1++;
-				len1 += ccLen;
-				tmpStartTick = CM_GetTick();
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_EXTEND_RED);
 				/*- 向红网SE发送SE外网帧 */
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_EXTEND_BLUE);
-				UsedTime1 = UsedTime1 + (CM_GetTick() - tmpStartTick);
 			}
 			else if((ENUM_CM_CC == isSendExtendBoard) || (ENUM_CM_CCSEB == isSendExtendBoard))
 			{
 				/*- 向红网CC发送CC外网帧 */
-				cnt2++;
-				len2 += ccLen;
-				tmpStartTick = CM_GetTick();
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_RED);
 				/*- 向蓝网CC发送CC外网帧 */
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_BLUE);
-				UsedTime2 = UsedTime2 + (CM_GetTick() - tmpStartTick);
 			}
 			else
 			{
@@ -1855,7 +1851,6 @@ void SFM_TxOutnetSafe(IN CM_UINT8 buf[], IN CM_UINT32 Len)
         /*- 索引偏移至下一输出报文 */
         i += (CM_UINT32)CM_UNSIGNED_SHORT_EXP(msgLen + 2u);
     }
-	printf("test:send all len=%d(%d), cnt1=%d, len1=%d, time1=%lluus-----cnt2=%d, len2=%d, time2=%lluus\n", len1+len2, Len, cnt1, len1, UsedTime1 / 1000u, cnt2, len2, UsedTime2 / 1000u);
 }
 
 void SFM_PrtclBufSwitch(void)

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/dsuEmapDefine.h

@@ -297,7 +297,6 @@
 #define	MA_OTHER_END				3			/*其他类型终点*/
 
 #define	DEVTYPE_CI	    0x3c  /*CI数据类型恒比码*/	
-#define	DEVTYPE_RC	    0x3d  /*CI数据类型恒比码*/
 #define	DEVTYPE_ZC	    0x1e  /*相邻ZC数据恒比码*/	
 #define	DEVTYPE_ATS	    0x03  /*ATS数据恒比码*/	
 #define	DEVTYPE_VOBC    0x14U  /*VOBC数据恒比码*/

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/dqu_common/dqu_idmap_common/dquIdmapQuery.h

@@ -45,7 +45,6 @@
 #define QFUN_IDMAP_PHY_ID		 19  /*物理区段编号数据ID*/
 #define QFUN_IDMAP_AXLE_ID		 21  /*计轴系统编号数据ID*/
 #define QFUN_IDMAP_ITE_ID		 22  /*ITE编号数据ID*/
-#define QFUN_IDMAP_RC_ID		 23  /*RC编号数据ID*/
 
 #define IDMAP_TYPE_MIN 1   /*查询结构类型最小值 add by qxt 20170509*/
 #define IDMAP_TYPE_MAX 21  /*查询结构类型最大值，用于防护查询类型struType的范围*/

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

@@ -60,7 +60,7 @@ static UINT8 FsfbSetNodeParam(const DSU_FSFB_LINK_RINFO_STRU* pRecvDsuLnkInf,
 							  FsfbNodeParamInfoStru *pNodeParam);
 static UINT8 FsfbCheckRecvDsuLnkInfo(UINT16 srcAddr,UINT16 destAddr,
 									 const DSU_FSFB_LINK_RINFO_STRU *pRecvLnkInfo);
-static UINT8 FsfbCheckInputAddr(UINT16 locTypeId, UINT16 oppTypeId, const DSU_FSFB_LINK_RINFO_STRU* pRecvLnkInfo);
+static UINT8 FsfbCheckInputAddr(UINT16 LocalDevName,UINT16 destName,const DSU_FSFB_LINK_RINFO_STRU *pRecvLnkInfo);
 static void FsfbLnkNodeInfo2VarArray(const Fsfb_Lnk_Info_Node_Stru* pNode, UINT8* VarArray, UINT8* recordArray, UINT16 recordArraySize);
 /*--------------------------------------------------------------------
  * 链路管理模块内部函数申明 End
@@ -132,8 +132,8 @@ UINT8 FsfbOutputReplaceLnkNode(UINT16 locName,UINT16 destName,UINT8 applyCat,Fsf
 						   FSFB_INFO_STRU *pFsfbStruct)
 {
 	UINT8 ret = 0,chcRet = 0;
-	DSU_FSFB_LINK_RINFO_STRU rcvLnkInfo = { 0 };  /* 本方作为接受节点的信息 */
+	DSU_FSFB_LINK_RINFO_STRU rcvLnkInfo;  /* 本方作为接受节点的信息 */
-	DSU_FSFB_LINK_SINFO_STRU outLnkInfo = { 0 };  /* 本方作为发送节点的信息*/
+	DSU_FSFB_LINK_SINFO_STRU outLnkInfo;  /* 本方作为发送节点的信息*/
 	Fsfb_Lnk_Info_Node_Stru *pLnkNodeInfo = NULL;
 	/* 
 	*  根据本方设备名称和对方的设备名称获取本方作为接受节点的信息
@@ -547,10 +547,10 @@ UINT8 FsfbUptLnkNodeInfoByAbt(UINT8* pAppData, FSFB_INFO_STRU* pFsfbStrut, Fsfb_
 			pLnkNode->IsSendFlag = 1u;
 			rtnVal = 1u; /*-< 设置函数返回值为成功*/
 		}
-	}
 
 		return rtnVal; /*-< 返回函数返回值*/
 	}
+}
 
 
 
@@ -1180,34 +1180,52 @@ static UINT8 FsfbCheckRecvDsuLnkInfo(UINT16 srcAddr,UINT16 destAddr,
 	return retVal;
 }
 
-/**
+/***********************************************************************
- * @brief FsfbCheckInputAddr 检查本方类型ID作为接收信息是否正确
+* 方法名   :   FsfbCheckInputAddr
- * @param locTypeId 本方类型ID 取值范围:0x0000-0xFFFF
+* 功能描述 : 检查根据本方设备名称以及对方设备标识 取得的本方作为接受信息是否正确。
- * @param oppTypeId 对方类型ID 取值范围:0x0000-0xFFFF
+* 输入参数 : 
- * @param pRecvLnkInfo 接收方链路信息 取值范围:参考结构体DSU_FSFB_LINK_RINFO_STRU
+*	参数名			类型							输入输出		描述
- * @return 0:失败 1:成功
+*  ------------------------------------------------------------------------
+*  LocalDevName	UINT16							IN				本方标识符
+*  destName			UINT16							IN		    对方标识符
+*  pRecvLnkInfo	const DSU_FSFB_LINK_RINFO_STRU*	IN				接受信息
+*
+* 返回值   : UINT8  1：正常返回  0：错误返回
+***********************************************************************/
+static UINT8 FsfbCheckInputAddr(UINT16 LocalDevName,UINT16 destName,const DSU_FSFB_LINK_RINFO_STRU *pRecvLnkInfo)
+{
+	UINT8 ret = 0;
+	UINT8 locType =0;
+	UINT8 destType = 0;
+	UINT8 id =0;
+
+	if (pRecvLnkInfo== NULL)
+	{
+		return ret;
+	}
+
+	if (pRecvLnkInfo->DestName != LocalDevName)
+	{
+		return ret;
+	}
+	ComDevName2TypeId(LocalDevName,&locType,&id);
+	ComDevName2TypeId(destName,&destType,&id);
+	/* 
+	* 对方标识符和本方的标识符不相等 则应用给出地址有误
 	*/
-static UINT8 FsfbCheckInputAddr(UINT16 locTypeId, UINT16 oppTypeId, const DSU_FSFB_LINK_RINFO_STRU* pRecvLnkInfo)
+	if(((locType ==FSFB_CI_DEV)&&(destType==FSFB_LEU_DEV))||((locType ==FSFB_LEU_DEV)&&(destType==FSFB_CI_DEV)))
 	{
-	/*- 定义局部变量*/
+		ret = 1;
-	UINT8 rtnVal = 0u; /*-< 设置函数返回值为失败*/
-	UINT8 locType = 0u; /*本方类型*/
-	UINT8 oppType = 0u; /*对方类型*/
-	UINT8 id = 0u; /*设备ID*/
-
-	if ((NULL != pRecvLnkInfo) && (pRecvLnkInfo->DestName == locTypeId)) /*-< 参数非空 且收链路的目的设备名等于本方类型ID*/
-	{
-		ComDevName2TypeId(locTypeId, &locType, &id); /*-< 调用函数根据本方类型ID取得相对应的类型和ID*/
-		ComDevName2TypeId(oppTypeId, &oppType, &id); /*-< 调用函数根据对方类型ID取得相对应的类型和ID*/
-
-		if ((((FSFB_CI_DEV == locType) || (FSFB_RC_DEV == locType)) && (FSFB_LEU_DEV == oppType)) || ((FSFB_LEU_DEV == locType) && ((FSFB_CI_DEV == oppType) || (FSFB_RC_DEV == oppType)))) /*-< 本方类型为CI或RC 且对方类型为LEU  或者 本方类型为LEU 且对方类型为CI或RC*/
-		{
-			rtnVal = 1u; /*-< 设置函数返回值为成功*/
 	}
+	else
+	{
+		ret=0;
+	}
+	return ret;
 }
 
-	return rtnVal; /*-< 返回函数返回值*/
+
-}
+
 
 /***********************************************************************
  * 方法名   : FsfbLnkNodeInfo2VarArray

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

@@ -59,7 +59,8 @@
 /*--------------------------------------------------------------------
  * ���Ĵ���ģ���ڲ��������� Start
  *--------------------------------------------------------------------*/
-static UINT8 CreateTsdOrSbtMsg(const UINT8* pAppData, UINT16 DataLen, UINT8 applyCat, UINT8* OutTsdOrSbtMsg, UINT16* outPutDataLen, Fsfb_Lnk_Info_Node_Stru* pPNode);
+static UINT8 CreateTsdOrSbtMsg(const UINT8 *pAppData,UINT16 DataLen,UINT8 applyCat,
+							   UINT8 *OutTsdOrSbtMsg,UINT16* outPutDataLen, Fsfb_Lnk_Info_Node_Stru* pPNode);
 static UINT8 CreateSseMsg(UINT8 applyCate,Fsfb_Lnk_Info_Node_Stru *pLnkNodeInfo,UINT8* outSseMsg);
 static UINT8 CreateSsrMsg(UINT8 applyCate,Fsfb_Lnk_Info_Node_Stru *pLnkNodeInfo,UINT8* outSsrMsg);
 static UINT8 CreateBtmMsg(const UINT8 *pAppData,UINT16 DataLen,UINT16 userDataLen,UINT8 messType,
@@ -944,66 +945,58 @@ UINT8 FsfbAnalysisBtdMsg(UINT16 devName,UINT8 applyCat,UINT8* pAppData,FSFB_INFO
 /*--------------------------------------------------------------------
  * ���Ĵ���ģ���ڲ��ӿں��� Start
  *--------------------------------------------------------------------*/
+/***********************************************************************
+* ������   : CreateTsdOrSbtMsg
+* �������� : ����Ӧ������ ���� TSD��SBT���ġ�
+* ������� : 
+*	������		����					�������		����
+*  -------------------------------------------------------------------------------
+*	pAppData   	const UINT8*			IN			Ӧ�ò㵽Rssp���������ж��нڵ�
+*	DataLen	   	UINT8					IN			����pAppData�����ݳ���
+*  OutTsdOrSbtMsg  	UINT8*					OUT			FSFD��Ϣ֡
+*   outPutDataLen   UINT16*   OUT     ������ij���
+*  pPNode 	Lnk_Info_Node_Stru_WL**		OUT			���¶�Ӧ�ڵ����������������ڷ��� -1 
 
-/**
+* ����ֵ   : UINT8  1����������  0�����󷵻�
- * @brief CreateTsdOrSbtMsg ����TSD��SBT����
+***********************************************************************/
- * @param pAppData Ӧ���������� ȡֵ��Χ:�ֽ�����
+static UINT8 CreateTsdOrSbtMsg(const UINT8 *pAppData,UINT16 DataLen,UINT8 applyCat,
- * @param DataLen Ӧ���������鳤�� ȡֵ��Χ:0x0000-0xFFFF
+							 UINT8 *OutTsdOrSbtMsg,UINT16* outPutDataLen, Fsfb_Lnk_Info_Node_Stru* pPNode)
- * @param applyCat Ӧ������ ȡֵ��Χ:0x00-0xFF
- * @param OutTsdOrSbtMsg ����������� ȡֵ��Χ:�ֽ�����
- * @param outPutDataLen ����������鳤�� ȡֵ��Χ:0x0000-0xFFFF
-  * @param pPNode ��· ȡֵ��Χ:�ο��ṹ��Fsfb_Lnk_Info_Node_Stru
- * @return 0:ʧ�� 1:�ɹ�
- */
-static UINT8 CreateTsdOrSbtMsg(const UINT8* pAppData, UINT16 DataLen, UINT8 applyCat, UINT8* OutTsdOrSbtMsg, UINT16* outPutDataLen, Fsfb_Lnk_Info_Node_Stru* pPNode)
 {
-	/*- ����ֲ�����*/
+	UINT8 ret = 0;
-	UINT8 ret = 0u; /*-< ���ú�������ֵΪʧ��*/
-	UINT16 CRC16 = 0u; /*CRCֵ*/
-	UINT32 CRCM[2] = { 0u }; /*SVCֵ*/
 
-	if ((NULL != pAppData) && (NULL != OutTsdOrSbtMsg) && (NULL != outPutDataLen) && (NULL != pPNode)) /*-< �����ǿ�*/
+	UINT16 CRC16 = 0;											/* FSFB��ϢCRC */
+	UINT32 CRCM[2] ={0};										/* CRCM���� */
+	pPNode->Applcat = applyCat;
+	switch(applyCat)
 	{
-		pPNode->Applcat = applyCat; /*-< ��������*/
+		case APPLCAT_BTM:
-		switch (applyCat) /*-< �жϱ�������*/
+			*outPutDataLen = SBT_SIZE;
-		{
-		case APPLCAT_BTM: /*-< BTM����*/
-			*outPutDataLen = SBT_SIZE; /*-< ����������ݳ���*/
 			/* ��·״̬���� */
-			pPNode->FsfbLinInfo.RecvLinkStatus = Fsfb_WaitBtm_SbtAbt; /*-< ���ý�����·״̬Ϊ��SBT��ABT*/
+			pPNode->FsfbLinInfo.RecvLinkStatus = Fsfb_WaitBtm_SbtAbt;
-			pPNode->FsfbLinInfo.NoRecvDataCycleNum = 0u; /*-< ������������������Ϊ0*/
 			/* �趨SBT֡ͷ */
-			SetFsfbMsgHead(applyCat, FSFB_SBT_MSG, pPNode->FsfbLinInfo.sendSrcAdd, pPNode->FsfbLinInfo.sendDestAdd, OutTsdOrSbtMsg); /*-< ���ú�������SBT֡ͷ*/
+			SetFsfbMsgHead(applyCat,FSFB_SBT_MSG, pPNode->FsfbLinInfo.sendSrcAdd,pPNode->FsfbLinInfo.sendDestAdd,OutTsdOrSbtMsg);
-			ret = 1u; /*-< ���ú�������ֵΪ�ɹ�*/
+			ret=1;
-			break; /*-< �˳�*/
+			break;
-		case APPLCAT_TDM: /*-< TD����*/
+		case APPLCAT_TDM:
+			*outPutDataLen = TSD_SIZE;
 			/*��·״̬����*/
-			pPNode->FsfbLinInfo.RecvLinkStatus = Fsfb_WaitSse; /*-< ���ý�����·״̬Ϊ��SSE*/
+			pPNode->FsfbLinInfo.RecvLinkStatus = Fsfb_WaitSse;
 			/* ����TSD֡ͷ */
-			SetFsfbMsgHead(applyCat, FSFB_TSD_MSG, pPNode->FsfbLinInfo.sendSrcAdd, pPNode->FsfbLinInfo.sendDestAdd, OutTsdOrSbtMsg); /*-< ���ú�������TSD֡ͷ*/
+			SetFsfbMsgHead(applyCat,FSFB_TSD_MSG, pPNode->FsfbLinInfo.sendSrcAdd,pPNode->FsfbLinInfo.sendDestAdd,OutTsdOrSbtMsg);
 			/*�ж����ݳ����Ƿ�ΪTSD �����ݳ��� */
-			if ((TSD_DF_SIZE != DataLen) && (TSD_DF_TWO_SIZE != DataLen)) /*-< ���ݳ��ȴ���*/
+			if(DataLen != TSD_DF_SIZE)
 			{
-				ret = 0u; /*-< ���ú�������ֵΪʧ��*/
+				ret =0;
 			}
 			else
 			{
-				if ((TSD_DF_SIZE == DataLen))
+				ret =1;
-				{
-					(*outPutDataLen) = TSD_SIZE; /*-< ����������ݳ���*/
 			}
-				else
+			break;
-				{
-					(*outPutDataLen) = TSD_TWO_SIZE; /*-< ����������ݳ���*/
-				}
-
-				ret = 1u; /*-< ���ú�������ֵΪ�ɹ�*/
-			}
-			break; /*-< �˳�*/
 		default:
-			*outPutDataLen = 0u; /*-< ����������ݳ���*/
+			*outPutDataLen =0;
-			ret = 0u; /*-< ���ú�������ֵΪʧ��*/
+			ret = 0;
-			break; /*-< �˳�*/
+			break;
 	}
 	/* Body �趨 
 	*  ------------------------------------------------------------------
@@ -1013,44 +1006,47 @@ static UINT8 CreateTsdOrSbtMsg(const UINT8* pAppData, UINT16 DataLen, UINT8 appl
 	*/
 	/* Ӧ������ */
 	/* ��pAppData��ʼ���� MsgLen��Ӧ�����ݵ� ������ */
-		if (ret != 0) /*-< ��������ֵ��ʧ��*/
+	if(ret != 0)
 	{
-			if (DataLen == 0) /*-< ���ݳ���Ϊ0*/
+		if(DataLen ==0)
 		{
 			/* �齨SBT֡��body */
-				DataLen = SBT_DF_SIZE; /*-< �������ݳ���*/
+			DataLen = SBT_DF_SIZE;
-				BuildSbtFrameDf(pPNode, &OutTsdOrSbtMsg[FSFB_DATA_POS]); /*-< ���ú�������SBT֡*/
+			BuildSbtFrameDf(pPNode,&OutTsdOrSbtMsg[FSFB_DATA_POS]);
 		}
 		else
 		{
-				ComMemCopy(pAppData, &OutTsdOrSbtMsg[FSFB_DATA_POS], DataLen); /*-< ���ú�����������*/
+			ComMemCopy(pAppData, &
+				OutTsdOrSbtMsg[FSFB_DATA_POS],DataLen);
 		}
 		/* ����CRCMֵ,(�϶�����1 ) */
 
 		
-			ret = ComCalcCRCM(&OutTsdOrSbtMsg[FSFB_DATA_POS], DataLen, pPNode->FsfbLinInfo.LocalNode.SIDr, pPNode->FsfbLinInfo.TimeStmp.NowTn, CRCM); /*-< ���ú�������SVC*/
+		ret = ComCalcCRCM(&OutTsdOrSbtMsg[FSFB_DATA_POS],DataLen,
+			pPNode->FsfbLinInfo.LocalNode.SIDr,
+			pPNode->FsfbLinInfo.TimeStmp.NowTn,
+			CRCM);
 
 		/* ������ �趨 4�ֽ� */
-			LongToCharLE(pPNode->FsfbLinInfo.TimeStmp.TC, &OutTsdOrSbtMsg[FSFB_TC_POS]); /*-< ������Ÿ��������*/
+		LongToCharLE(pPNode->FsfbLinInfo.TimeStmp.TC, &OutTsdOrSbtMsg[FSFB_TC_POS]);
 
 		/* ��ȫ���ݳ��� Ӧ������+ 2��CRCM����  2�ֽ� */
-			ShortToCharLE((UINT16)(DataLen + 2 * FSFB_CRCM_LEN), &OutTsdOrSbtMsg[FSFB_DATA_SIZE_POS]); /*-< �������ݳ��ȸ��������*/
+		ShortToCharLE((UINT16)(DataLen+2*FSFB_CRCM_LEN), &OutTsdOrSbtMsg[FSFB_DATA_SIZE_POS]);
 
-			/*- ����SVC���������*/
+		/* CRCM[0] CRCM[1] �趨  4 �ֽ� */
 		LongToCharLE(CRCM[0],&OutTsdOrSbtMsg[FSFB_CRCM_1_POS]);
 		LongToCharLE(CRCM[1],&OutTsdOrSbtMsg[FSFB_CRCM_2_POS]);
 
-			/*- ����CRC���������*/
+		/* 16λ CRC �趨 2 �ֽ� */
 		CRC16 = ComComputeMsgCRC16(OutTsdOrSbtMsg,(UINT16)((*outPutDataLen)-FSFB_CRC_16_LEN));
 		ShortToCharLE(CRC16,&OutTsdOrSbtMsg[(UINT16)((*outPutDataLen)-FSFB_CRC_16_LEN)]);
 
 		/* �޷���Ӧ��������Ϊ 0 */
-			pPNode->FsfbLinInfo.NoAppDataCycleNum = 0u; /*-< �����޷�����������Ϊ0*/
+		pPNode->FsfbLinInfo.NoAppDataCycleNum = 0;
-			ret = 1u; /*-< ���ú�������ֵΪ�ɹ�*/
+		ret = 1;
-		}
 	}
 
-	return ret; /*-< ���غ�������ֵ*/
+	return ret;
 }
 
 /*Test todo */

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

@@ -671,160 +671,166 @@ UINT8 FsfbProtclFreeSpace(FSFB_INFO_STRU* pFsfbStruct)
 	return retVal;
 }
 
-/**
+/*--------------------------------------------------------------------
-* @brief FsfbStructInit ����ABT������Ϣ����ͨ�Žڵ���Ϣ
+ * FSFBЭ���ⲿ�ӿں��� End
-* @param pLnkNode ��·�ڵ� ȡֵ��Χ:�ο��ṹ��Fsfb_Lnk_Info_Node_Stru
+ *--------------------------------------------------------------------*/
-* @return 0:ʧ��;1�ɹ�
+/*--------------------------------------------------------------------
-*/
+ * FSFBЭ���ڲ��ӿں��� Start
+ *--------------------------------------------------------------------*/
+/***********************************************************************
+ * ������   : FsfbStructInit
+ * �������� : ͨ���ú�����ʵ�ֶ�RSR��ij�ʼ������������Ӧ���趨�Ļ���ֵ����������еĴ�С��
+ * ������� : 
+ *	������				����							�������		����
+ *  --------------------------------------------------------------
+ *	pFsfbStruct  FSFB_INFO_STRU*	INOUT			FSFB��ͳһ�ṹ�壬����г�ʼֵ���á�
+ * ����ֵ   : UINT8  1����������  0�����󷵻�
+ ***********************************************************************/
 static UINT8 FsfbStructInit(FSFB_INFO_STRU *pFsfbStruct)
 {
-	/*- ����ֲ�����*/
+	UINT8 retVal = 0;
-	UINT8 retVal = 0u; /*-< ���ú�������ֵΪ0*/
+	UINT16 inputSize = 0;     
-	UINT16 inputSize = 0u;
+	UINT16 outputSize = 0;
-	UINT16 outputSize = 0u;
+	UINT16 maxMsgNum=0;
-	UINT16 maxMsgNum = 0u;
+	UINT16 maxMsg = 0;
-	UINT16 maxMsg = 0u;
 
 	inputSize = pFsfbStruct->InputSize;
 	outputSize = pFsfbStruct->OutputSize;
 
-	/*- �õ���������� */
+	/* ��������� */
 	maxMsg = pFsfbStruct->InputSize > pFsfbStruct->OutputSize?
 			pFsfbStruct->InputSize:pFsfbStruct->OutputSize;
-	maxMsg += 2u + 4u + FSFB_FIXED_LEN + 32u; /*-< �źŲ���й̶�����(2+4) + RSSP��̶����� + 32���� */
+	maxMsg += 2 + 4 + FSFB_FIXED_LEN +32;		/* �źŲ���й̶�����(2+4) + RSSP��̶����� + 32���� */
 
-	/*- ���������ʼ�� */
+	/* ���������ʼ�� */
-	maxMsgNum = pFsfbStruct->MaxNumLink * (pFsfbStruct->MaxNumPerCycle + 2u);		/* ������� */
+	maxMsgNum = pFsfbStruct->MaxNumLink *(pFsfbStruct->MaxNumPerCycle + 2);		/* ������� */
 
-	/*- FSFB�����ģ������������*/
+	/* FSFB�����ģ��������� */
 	pFsfbStruct->AppArraySize = (pFsfbStruct->OutputSize+11+26)*(pFsfbStruct->MaxNumPerCycle)*(pFsfbStruct->MaxNumLink)+2;
 	pFsfbStruct->AppArray = (UINT8 *)malloc(pFsfbStruct->AppArraySize);
-	if (pFsfbStruct->AppArray == NULL) /*-< ����ʧ��*/
+	if(pFsfbStruct->AppArray == NULL)
 	{
-		retVal = 0u; /*-< ���ú�������ֵΪ0*/
+		retVal = 0;
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
-		ComMemSet(pFsfbStruct->AppArray, sizeof(UINT8) * pFsfbStruct->AppArraySize, 0U); /*-< ���������*/
+		LongToChar(0, pFsfbStruct->AppArray);
-		LongToChar(0, pFsfbStruct->AppArray); /*-< ����������鳤��Ϊ0*/
 	}
 
-	/*- ����FSFB���ģ������м���������С */
+	/* FSFB���ģ������м���������С */
-	pFsfbStruct->VarArraySize = FSFB_VAR_NODE_LEN * pFsfbStruct->MaxNumLink + 32u;
+	pFsfbStruct->VarArraySize = FSFB_VAR_NODE_LEN * pFsfbStruct->MaxNumLink+32; 
 	pFsfbStruct->VarArray = (UINT8*)malloc(pFsfbStruct->VarArraySize);
-	if (NULL == pFsfbStruct->VarArray) /*-< ����ʧ��*/
+	if( NULL == pFsfbStruct->VarArray)
 	{
 		/* ��¼ */
-		retVal = 0u; /*-< ���ú�������ֵΪ0*/
+		retVal =0;
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
-		ComMemSet(pFsfbStruct->VarArray, sizeof(UINT8) * pFsfbStruct->VarArraySize, 0U); /*-< ������������*/
+		ShortToChar(0, pFsfbStruct->VarArray);
-		ShortToChar(0u, pFsfbStruct->VarArray); /*-< �����м�������鳤��Ϊ0*/
 	}
 
-	/*- ��ʼ��Э�������Ӧ�õ����ݶ���*/
+	/* Э�������Ӧ�õ����ݶ��г��� */
-	pFsfbStruct->DataToAppSize = (inputSize + 6u) * maxMsgNum;		/* Э�������Ӧ�õ����ݶ��г��� */
+	pFsfbStruct->DataToAppSize = (inputSize + 6) * maxMsgNum;		/* Э�������Ӧ�õ����ݶ��г��� */
 	retVal = QueueInitial(&pFsfbStruct->DataToApp,pFsfbStruct->DataToAppSize);
-	if (0u == retVal) /*-< ��������ֵ�Ƿ�Ϊʧ��*/
+	if(0 == retVal)
 	{
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
 		/* ʲô���� */
 	}
 
-	/*- ��ʼ��Ӧ�ø�Э����������ݶ���*/
+	/* Ӧ�ø�Э����������ݶ��г��� */
-	pFsfbStruct->OutputDataQueueSize = (outputSize + 8u) * maxMsgNum;
+	pFsfbStruct->OutputDataQueueSize= (outputSize + 8 )*maxMsgNum;
 	retVal = QueueInitial(&pFsfbStruct->OutputDataQueue,pFsfbStruct->OutputDataQueueSize);
-	if (0u == retVal) /*-< ��������ֵ�Ƿ�Ϊʧ��*/
+	if(0 == retVal)
 	{
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
 		/* ʲô���� */
 	}
 
-	/*- ��ʼ���������ܶ���*/
+	/* �������ܶ��г��� */
-	pFsfbStruct->OutnetQueueSize = (pFsfbStruct->InputSize + 2u + 11u) * pFsfbStruct->MaxNumPerCycle * pFsfbStruct->MaxNumLink;
+	pFsfbStruct->OutnetQueueSize = (pFsfbStruct->InputSize + 2 + 11)*pFsfbStruct->MaxNumPerCycle*pFsfbStruct->MaxNumLink;
-	/*- ��ʼ���������� */
+	/* �������� */
 	retVal = QueueInitial(&pFsfbStruct->OutnetQueueR,pFsfbStruct->OutnetQueueSize);
-	if (0u == retVal) /*-< ��������ֵ�Ƿ�Ϊʧ��*/
+	if(0 == retVal)
 	{
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
 		/* ʲô���� */
 	}
 
-	/*- ��ʼ���������� */
+	/* �������� */
 	retVal = QueueInitial(&pFsfbStruct->OutnetQueueB,pFsfbStruct->OutnetQueueSize);
-	if (0u == retVal) /*-< ��������ֵ�Ƿ�Ϊʧ��*/
+	if(0 == retVal)
 	{
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
 		/* ʲô���� */
 	}
 
-	/*- �����¼����*/
+	/*  ��¼����  */
 	pFsfbStruct->RecordArray = (UINT8*)malloc(pFsfbStruct->RecordArraySize);
-	if (NULL == pFsfbStruct->RecordArray) /*-< ����ʧ��*/
+	if( NULL == pFsfbStruct->RecordArray)
 	{
 		/* ��¼ */
-		retVal = 0u; /*-< ���ú�������ֵΪ0*/
+		retVal =0;
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
-		ComMemSet(pFsfbStruct->RecordArray, pFsfbStruct->RecordArraySize, 0x0); /*-< �����¼����*/
+		ComMemSet(pFsfbStruct->RecordArray ,pFsfbStruct->RecordArraySize,0x0);
 	}
 
-	/*- ��ʼ����·��������ջ*/
+	/* ������·��������ջ�ռ� */
 	pFsfbStruct->LnkStack.maxNodeNum = pFsfbStruct->MaxNumLink;
 	retVal = StackInitial(&pFsfbStruct->LnkStack.stack,pFsfbStruct->LnkStack.maxNodeNum);
 	
-	if (0u == retVal) /*-< ��������ֵ�Ƿ�Ϊʧ��*/
+	if (0 == retVal)
 	{
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
 		/* �������� */
 	}
 
-	/*- ������ʱ���Ļ�����*/
+	/* ��ʱ���Ļ����� */
 	pFsfbStruct->TmpDataBuff = (UINT8 *)malloc(maxMsg);
-	if (NULL == pFsfbStruct->TmpDataBuff) /*-< ����ʧ��*/
+	if( NULL == pFsfbStruct->TmpDataBuff)
 	{
-		retVal = 0u; /*-< ���ú�������ֵΪ0*/
+		retVal =0;
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
-		ComMemSet(pFsfbStruct->TmpDataBuff, maxMsg, 0x0u); /*-< ������ʱ���Ļ�����*/
+		ComMemSet(pFsfbStruct->TmpDataBuff ,maxMsg,0x0);
 	}
 
-	pFsfbStruct->NetsRecvPkgNumsLen = 0u; /*-< ���ø����յ��������鳤��Ϊ0*/
+	pFsfbStruct->NetsRecvPkgNums = (FsfbNetsRecvPkgNum*)malloc(sizeof(FsfbNetsRecvPkgNum) * pFsfbStruct->MaxNumLink);
-	pFsfbStruct->NetsRecvPkgNums = (FsfbNetsRecvPkgNum*)malloc(sizeof(FsfbNetsRecvPkgNum) * pFsfbStruct->MaxNumLink); /*-< ��������յ���������*/
+	if (NULL == pFsfbStruct->NetsRecvPkgNums)
-	if (NULL == pFsfbStruct->NetsRecvPkgNums) /*-< ����ʧ��*/
 	{
-		retVal = 0u; /*-< ���ú�������ֵΪ0*/
+		retVal = 0;
-		return retVal; /*-< ���غ�������ֵ*/
+		return retVal;
 	}
 	else
 	{
-		ComMemSet((UINT8*)pFsfbStruct->NetsRecvPkgNums, sizeof(FsfbNetsRecvPkgNum) * pFsfbStruct->MaxNumLink, 0u); /*-< ��������յ���������*/
+		ComMemSet((UINT8*)pFsfbStruct->NetsRecvPkgNums, sizeof(FsfbNetsRecvPkgNum)* pFsfbStruct->MaxNumLink, 0u);
 	}
 
-	retVal = 1; /*-< ���ú�������ֵΪ1*/
+	retVal = 1;
-	return retVal; /*-< ���غ�������ֵ*/
+	return retVal;
 }
 
 

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

@@ -21,7 +21,6 @@
 
 #define FSFB_CI_DEV 60      /*连锁设备*/
 #define FSFB_LEU_DEV 94      /*连锁设备*/
-#define FSFB_RC_DEV (0x3Du) /*RCÀàÐÍ*/
 
 /* 消息类型 */
 #define FSFB_SSE_MSG	((UINT8)0x90)						/* SSE 消息 */
@@ -35,7 +34,6 @@
 
 /* 消息帧长度 */
 #define TSD_SIZE     58 
-#define TSD_TWO_SIZE (74U) /*À©³äºóTSD³¤¶È*/
 #define SSE_SIZE     20
 #define SSR_SIZE     25
 #define SBT_SIZE    138
@@ -46,7 +44,6 @@
 
 /* 报文data feild Size */
 #define TSD_DF_SIZE  36
-#define TSD_DF_TWO_SIZE  (52U) /*À©³äºóTSD_DF³¤¶È*/
 #define BTC_DF_SIZE   8
 #define SBT_DF_SIZE 116
 #define ABT_DF_SIZE   0

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

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

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

@@ -37,17 +37,12 @@ extern "C" {
 #define PROTCL_MGECFG_MAXCNT	((UINT8)0x06)	/*协议数量*/
 
 #define	VOBC_TYPE	((UINT8)0x14)	/*VOBC设备类型*/
-#define	IVOC_TYPE	((UINT8)0x10)	/*IVOC设备类型*/
 #define	AOM_TYPE	((UINT8)0x15)	/*AOM设备类型*/
-#define	IVOC_AOM_TYPE ((UINT8)0x11)	/*IVOC-AOM设备类型*/
 #define	CI_TYPE		((UINT8)0x3C)	/*CI设备类型*/
-#define	RC_TYPE		((UINT8)0x3D)	/*RC设备类型*/
 #define	ZC_TYPE		((UINT8)0x1E)	/*ZC设备类型*/
 #define	ATS_TYPE	((UINT8)0x03)	/*ATS设备类型*/
 #define PSC_TYPE	((UINT8)0x61)	/*PSC设备类型*/
 #define ITE_TYPE	((UINT8)0x18)	/*ITE设备类型*/
-#define OC_TYPE	    ((UINT8)0x64)	/*OCC设备类型*/
-#define LEU_TYPE	((UINT8)0x5E)	/*LEU设备类型*/
 
 	/*设备通信协议表0x4002*/
 	typedef struct
@@ -76,17 +71,19 @@ extern "C" {
 	{
 		UINT8 sfpProtclNum;	/*SFP通信设备数量*/
 		UINT8 rsrProtclNum;	/*RSR通信设备数量*/
-		UINT16 rsspProtclNum;	/*RSSPI通信设备数量*/
+		UINT8 rsspProtclNum;	/*RSSPI通信设备数量*/
 		UINT8 redunProtclNum;	/*RP通信设备数量*/
 		UINT8 rssp2ProtclNum;	/*RSSPII通信设备数量*/
 		UINT8 fsfbProtclNum;	/*FSFB通信设备数量*/
 	}DSU_PROTCL_TYPE_STRU;
 
-	/**
+	/*
-	 * @brief DsuCommonInfoInit 适配层查询函数初始化
+	*函数名:	DsuCommonInfoInit
-	 * @param pFsName FS文件路径 取值范围:字节数组
+	*功能描述:	适配层查询函数初始化
-	 * @param pDsuProtclBookIpInfo 查询表信息 取值范围:参考结构体DSU_PROTCL_BOOK_IP_INFO_STRU
+	*输入参数:	UINT8 *pFsName	FS文件
-	 * @param 0:失败;1:成功
+	*输入出参:	DSU_PROTCL_BOOK_IP_INFO_STRU *pDsuProtclBookIpInfo	适配层使用表
+	*输出参数:	无
+	*返回值:	1:成功;0失败
 	*/
 	UINT8 DsuCommonInfoInit(UINT8 *pFsName, DSU_PROTCL_BOOK_IP_INFO_STRU *pDsuProtclBookIpInfo);
 
@@ -102,16 +99,17 @@ extern "C" {
 	*/
 	UINT8 DsuProtclGetProtclType(UINT16 locTypeId, UINT16 oppTypeId, UINT8 *pProtclType, DSU_PROTCL_BOOK_IP_INFO_STRU *pDsuProtclBookIpInfo);
 
-	/**
+	/*
-	 * @brief DsuGetProtclTypeInfo 根据本方类型ID查找与对方通信时使用协议的最大通信设备数量(最大链路数)
+	*函数名:	DsuGetProtclTypeInfo
-	 * @param locTypeId 本方类型ID 取值范围:0x0000-0xFFFF
+	*功能描述:	根据本方类型ID查找与对方通信时使用协议的最大通信设备数量(最大链路数)
-	 * @param dsuProtclTypeInfo 各协议数量 取值范围:参考结构体DSU_PROTCL_TYPE_STRU
+	*输入参数:	UINT16 locTypeId	本方类型ID
-	 * @param pDsuProtclBookIpInfo 适配层使用表 取值范围:参考结构体DSU_PROTCL_BOOK_IP_INFO_STRU
+	*			DSU_PROTCL_BOOK_IP_INFO_STRU *pDsuProtclBookIpInfo 适配层使用表
-	 * @param globalVarOppTypePtl 对方协议类型数组 取值范围:字节数组
+	*			UINT32 inDataLen 内网数据长度
-	 * @param globalVarOppTypePtlLen 对方协议类型数组长度 取值范围:0x0000-0xFFFF
+	*			UINT8 inData[] 内网数据
-	 * @param inDataLen 内部数据长度 取值范围:0x00000000-0xFFFFFFFF
+	*			UINT16 globalVarOppTypePtlLen 与通信的对方设备类型协议数组长度
-	 * @param inData 内部数据 取值范围:字节数组
+	*输入出参:	UINT8 globalVarOppTypePtl[UINT8_MAX] 与通信的对方设备类型协议数组
-	 * @return 0:失败 1:成功
+	*输出参数:	DSU_PROTCL_TYPE_STRU *dsuProtclTypeInfo	各协议通信设备数量
+	*返回值:	1:成功;0失败
 	*/
 	UINT8 DsuGetProtclTypeInfo(UINT16 locTypeId, DSU_PROTCL_TYPE_STRU* dsuProtclTypeInfo, DSU_PROTCL_BOOK_IP_INFO_STRU* pDsuProtclBookIpInfo, UINT8 globalVarOppTypePtl[], UINT16 globalVarOppTypePtlLen, UINT32 inDataLen, UINT8 inData[]);
 

TSCP/src/protocol/protocol_cbtc/common_protocol/ProtclManage.h

@@ -55,13 +55,9 @@ extern "C" {
 #define	ERR_PRTCL_MANAGE_TYPE_ERR  				0x00000001	
 #define	ERR_PRTCL_MANAGE_DATA_ANALYSIS_ERR		0x00000002	
 	   
-/**
+/*
- * @brief Init 从配置文件读取相对应的协议配置数据
+ * 协议初始化
- * @param fileName 配置文件路径 取值范围:字节数组
+ *
- * @param inDataLen 内部数据长度 取值范围:0x00000000-0xFFFFFFFF
- * @param inData 内部数据 取值范围:字节数组
- * @param pUnifyInfo 同样结构体变量 取值范围:参考结构体ProtclConfigInfoStru
- * @return 0:失败 1:成功
  */
 UINT8 Init(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], ProtclConfigInfoStru* pUnifyInfo);
 
@@ -75,11 +71,15 @@ UINT8 Init(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], ProtclConfigInfoSt
 */
 UINT8 SendAppData(ProtclConfigInfoStru *pUnifyInfo);
 
-/**
+/*
- * @brief ReceiveAppData 协议接收数组
+* 功能：协议接收数组
- * @param pUnifyInfo 统一结构体变量 取值范围:参考结构体ProtclConfigInfoStru
+* 参数：
- * @return 0:失败 1:成功
+* 输入输出参数：ProtclConfigInfoStru * pUnifyInfo   统一结构体
+* 返回值：
+*    1：接收数据成功
+0：失败
 */
+
 UINT8 ReceiveAppData(ProtclConfigInfoStru* pUnifyInfo);
 
 /*
@@ -113,11 +113,14 @@ UINT8 GetLnkStatus (UINT8 destType,UINT8 destId,UINT16 logId,ProtclConfigInfoStr
 */
 UINT8 DelLnkFunc(UINT8 destType,UINT8 destId,UINT16 logId,ProtclConfigInfoStru *pUnifyInfo);
 
-/**
+/*
- * @brief ReFresh 使用链路数据数组刷新链路状态
+* 功能：刷新链路状态
- * @param pLnkStatusData 链路数据数组 取值范围:字节数组
+*
- * @param pUnifyInfo 适配层结构体变量 取值范围:参考结构体:ProtclConfigInfoStru
+* 参数： 
- * @return 0:失败 1:成功
+* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
+* 返回值： 
+*     0：刷新链路失败
+*     1：刷新链路成功 
 */
 UINT8 ReFresh(UINT8 *pLnkStatusData, ProtclConfigInfoStru *pUnifyInfo);
 
@@ -134,26 +137,26 @@ UINT8 FreeSpace(ProtclConfigInfoStru *pUnifyInfo);
 UINT8 ReceiveTcpState(UINT16 TcpStateDataLen,UINT8* pTcpStateData, ProtclConfigInfoStru *pUnifyInfo);
 UINT8 SendTcpCtrl(UINT16 *pTcpCtrlDataLen,UINT8 *pTcpCtrlData, ProtclConfigInfoStru *pUnifyInfo);
 
-UINT8 InitGetCfgInfo(UINT8* pFileName, UINT32 inDataLen, UINT8 inData[], UINT16* pEvenPrtclNumBuff, ProtclConfigInfoStru* pUnifyInfo);
+UINT8 InitGetCfgInfo(UINT8* pFileName, UINT32 inDataLen, UINT8 inData[], UINT8* pEvenPrtclNumBuff, ProtclConfigInfoStru* pUnifyInfo);
 /***********协议发送相关函数**************************************************************/
 UINT8 AppSendInputDataAnalysis(QueueStruct *pAppQueueData,PROTCL_APP_TO_STRU *pProtclAppStru);
 UINT8 sfpInputPackFms(const PROTCL_APP_TO_STRU protclAppStru, QueueStruct *pAppQueueData);
-UINT8 sfpSendData(ProtclConfigInfoStru *pUnifyInfo, UINT32 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8 * pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
+UINT8 sfpSendData(ProtclConfigInfoStru *pUnifyInfo, UINT8 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8 * pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
 UINT8 RsspInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct *pAppQueueData);
-UINT8 RsspSendData(ProtclConfigInfoStru *pUnifyInfo, UINT32 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
+UINT8 RsspSendData(ProtclConfigInfoStru *pUnifyInfo, UINT8 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
 
 #ifdef USE_RSR
 UINT8 RsrInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct *pAppQueueData, RSR_INFO_STRU *gpRsrUnitInfo);
 #endif
 
-UINT8 RsrSendData(ProtclConfigInfoStru *pUnifyInfo, UINT32 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
+UINT8 RsrSendData(ProtclConfigInfoStru *pUnifyInfo, UINT8 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
 UINT8 RpInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct *pAppQueueData);
-UINT8 RpSendData(ProtclConfigInfoStru *pUnifyInfo, UINT32 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
+UINT8 RpSendData(ProtclConfigInfoStru *pUnifyInfo, UINT8 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
 UINT8 RsrAndRpAppArrayPage(UINT8* pInAppArray,UINT32 appDtaLen,UINT8* pOutAppArray,UINT32* outAppLen);
 UINT8 Rssp2InputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct *pAppQueueData);
-UINT8 Rssp2SendData(ProtclConfigInfoStru *pUnifyInfo, UINT32 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
+UINT8 Rssp2SendData(ProtclConfigInfoStru *pUnifyInfo, UINT8 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8* pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
 UINT8 FsfbInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData);
-UINT8 FsfbSendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen);
+UINT8 FsfbSendData(ProtclConfigInfoStru* pUnifyInfo, UINT8 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen);
 /***********协议接收相关函数**************************************************************/
 UINT8 SfpRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru *pUnifyInfo);
 UINT8 RpRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru *pUnifyInfo);
@@ -210,8 +213,8 @@ UINT8 FsfbFreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo);
 /***********Getting**&**Setting****封装***********************************************/
 
 /***********异常防护函数**************************************************************/
-UINT8  protcl_nul_Init(UINT8* nul_FileName, UINT32 inDataLen, UINT8 inData[], UINT16 nul_Num, ProtclConfigInfoStru* pUnifyInfo);
+UINT8  protcl_nul_Init(UINT8* nul_FileName, UINT32 inDataLen, UINT8 inData[], UINT8 nul_Num, ProtclConfigInfoStru* pUnifyInfo);
-UINT8  protcl_nul_Snd(ProtclConfigInfoStru *pUnifyInfo, UINT32 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8 * pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
+UINT8  protcl_nul_Snd(ProtclConfigInfoStru *pUnifyInfo, UINT8 devDataCount,UINT8* pSndData,UINT32* sendDataLen,UINT8 * pLnkStatusData,UINT16* lnkDataLen,UINT8* recordArray,UINT16* recordDataLen);
 UINT8  protcl_nul_Rcv(QueueStruct* PQueueStru, ProtclConfigInfoStru *pUnifyInfo);
 UINT8  protcl_nul_Lnk(UINT8 destType,UINT8 destId,UINT16 logId, ProtclConfigInfoStru *pUnifyInfo);
 void   protcl_nul_NetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum);

TSCP/src/protocol/protocol_cbtc/common_protocol/protclInterFun.c

@@ -5,7 +5,6 @@
 #include "dsuRsspFunc.h"
 #include "CommonMemory.h"
 #include "CommonRecord.h"
-#include <string.h>
 
 #define RSSPI_OPP_IDS_NUM (255) /*RSSPI的对方唯一ID数量*/
 
@@ -29,6 +28,8 @@
 #define DATA2_STAGING_NO (19u) /*TwoDevRepeat二份数据暂存数组无空间*/
 #define NO_DATA_NET1_LEN_ILLEGAL (20u) /*TwoDevRepeat网1无数据时数据长度非法*/
 
+static UINT16 DelRsspiNotOppId(UINT16 linkDataLen, UINT8 linkData[], UINT16 singleLinkLen, UINT16 oppIdIdx, UINT8 oppIdsNum, const UINT32 oppIds[]);
+
 static UINT8 ProtclTwoRepeatParam(ProtclConfigInfoStru* protcl, UINT8* data1, UINT8* data2, UINT32* data2Len, UINT8* data2Staging);
 static UINT8 RepeatDataFormatCheck(UINT8* data, const UINT32 dataLen);
 static UINT8 DevDataFormatCheck(UINT8* data, const UINT32 dataLen, UINT32* dataIdx, UINT32* netLen);
@@ -261,6 +262,180 @@ UINT8 ProtclSendTcpCtrlFunc(UINT16 *pTcpCtrlDataLen,UINT8 *pTcpCtrlData, ProtclC
 	return ret;
 }
 
+/*
+*函数名:	DelRsspiNotOppId
+*功能描述:	删除RSSPI链路中非指定的对方地址链路
+*输入参数:	UINT16 linkDataLen 链路数据长度
+*			UINT8 linkData[] 链路数据
+*			UINT16 singleLinkLen 单个链路长度
+*			UINT16 oppIdIdx 对方唯一ID在链路中位置
+*			UINT8 oppIdsNum 对方唯一ID数量
+*			const UINT32 oppIds[] 对方唯一ID数组
+*输入出参:	无
+*输出参数:	无
+*返回值:	UINT16 aftLinkDataLen 处理后的链路数据长度
+*/
+static UINT16 DelRsspiNotOppId(UINT16 linkDataLen, UINT8 linkData[], UINT16 singleLinkLen, UINT16 oppIdIdx, UINT8 oppIdsNum, const UINT32 oppIds[])
+{
+	UINT16 aftLinkDataLen = linkDataLen; /*处理后链路数据长度*/
+	UINT16 i = 0; /*用于循环*/
+	UINT16 j = 0; /*用于循环*/
+	UINT16 linkNum = linkDataLen / singleLinkLen; /*包含的单个链路数量*/
+	UINT32 oppIdLink = 0; /*链路信息中对方唯一ID*/
+	UINT16 curIdx = 0; /*当前链路下标位置*/
+
+	if (( NULL != linkData)&&( NULL != oppIds))
+	{
+		for (i = 0; i < linkNum; i++) /*遍历链路信息*/
+		{
+			oppIdLink = LongFromChar(&linkData[curIdx + oppIdIdx]); /*链路中对方唯一ID*/
+			for (j = 0; j < oppIdsNum; j++)
+			{
+				if (oppIds[j] == oppIdLink) /*找到退出循环*/
+				{
+					break;
+				}
+			}
+			if (j == oppIdsNum) /*未找到,删除此对方唯一ID的链路*/
+			{
+				if (i < (linkNum - 1)) /*非最后一个,移动链路信息*/
+				{
+					CommonMemCpy(&linkData[curIdx], linkDataLen - (singleLinkLen * (i + 1)), &linkData[curIdx + singleLinkLen], linkDataLen - (singleLinkLen * (i + 1)));
+				}
+				aftLinkDataLen -= singleLinkLen; /*调整处理后长度*/
+			}
+			else
+			{
+				curIdx += singleLinkLen; /*下标偏移一个链路长度*/
+			}
+		}
+
+	}
+	
+	return aftLinkDataLen;
+}
+
+/*
+*函数名:	AdjustRsspiVarArray
+*功能描述:	调整RSSPI链路,只保留指定的对方地址链路
+*输入参数:	UINT8 oppIdsNum 对方类型ID逻辑ID数量
+*			const UINT16 oppTypeIds[] 对方类型ID数组
+*			const UINT16 oppLogicIds[] 对方逻辑ID数组
+*			ProtclConfigInfoStru *pUnifyInfo 适配结构体变量
+*输入出参:	无
+*输出参数:	无
+*返回值:	无
+*/
+void AdjustRsspiVarArray(UINT8 oppIdsNum, const UINT16 oppTypeIds[], const UINT16 oppLogicIds[], ProtclConfigInfoStru *pUnifyInfo)
+{
+	const UINT16 oppIdSafeIdx = 7; /*对方唯一ID在安全层中位置*/
+	const UINT16 oppIdRedundIdx = 0; /*对方唯一ID在冗余层中位置*/
+
+	UINT32 oppIds[RSSPI_OPP_IDS_NUM] = { 0 }; /*对方唯一ID*/
+	UINT32 i = 0; /*用于循环*/
+	UINT8 *linkData = NULL; /*链路信息*/
+	UINT16 totalLen = 0; /*链路总长度*/
+	UINT16 curIdx = 0; /*当前链路下标位置*/
+	UINT32 curProtcl = 1; /*当前协议标识*/
+	UINT16 curLen = 0; /*当前协议链路长度*/
+	UINT16 curLenIdx = 0; /*当前协议链路长度位置*/
+	UINT16 safeLen = 0; /*RSSPI安全层链路长度*/
+	UINT16 safeLenIdx = 0; /*RSSPI安全层链路长度位置*/
+	UINT16 aftSafeLen = 0; /*处理后的RSSPI安全层链路长度*/
+	UINT16 redundLen = 0; /*RSSPI冗余层链路长度*/
+	UINT16 redundLenIdx = 0; /*RSSPI冗余层链路长度位置*/
+	UINT16 aftRedundLen = 0; /*处理后的RSSPI冗余层链路长度*/
+	UINT8 isAdjustRear = 0; /*是否调整尾部数据*/
+
+#ifdef USE_RSSPI
+	if ((0 < oppIdsNum) && (RSSPI_OPP_IDS_NUM > oppIdsNum) && (NULL != oppTypeIds) && (NULL != oppLogicIds) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->VarArray)
+		&& (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo->pDsuRsspInfoStruWL)) /*参数检查*/
+	{
+		for (i = 0; i < oppIdsNum; i++) /*获取到RSSPI对方唯一ID*/
+		{
+#ifdef RSSP_NO_HLHT
+			oppIds[i] = oppTypeIds[i];
+#else
+			oppIds[i] = DquTypeIdToHlhtId(oppTypeIds[i], oppLogicIds[i], pUnifyInfo->GlobalVar->gpRsspUnitInfo->pDsuRsspInfoStruWL); /*对方唯一ID*/
+#endif
+		}
+
+		linkData = pUnifyInfo->VarArray; /*链路信息*/
+		/*链路总长度*/
+		totalLen = 2 + ShortFromChar(linkData);
+		curIdx += 2;
+
+		for (curProtcl = 1; curProtcl <= PROTCL_MGECFG_MAXCNT; curProtcl++) /*遍历协议*/
+		{
+			/*当前链路下标位置*/
+			curLen = ShortFromChar(&linkData[curIdx]);
+			curLenIdx = curIdx;
+			curIdx += 2;
+
+			if ((curIdx + curLen) <= totalLen) /*协议链路长度有效*/
+			{
+				if ((DSU_PROTCL_RSSP == curProtcl) && (2 < curLen)) /*当前是RSSPI协议,有链路信息*/
+				{
+					safeLen = ShortFromChar(&linkData[curIdx]); /*安全层链路长度*/
+					if (((2 + safeLen) <= curLen) && (0 == (safeLen%RSSP_VAR_NODE_LEN_WL))) /*安全层链路长度有效*/
+					{
+						safeLenIdx = curIdx; /*安全层链路长度位置*/
+						curIdx += 2;
+
+						if (0 < safeLen) /*有安全层链路信息*/
+						{
+							aftSafeLen = DelRsspiNotOppId(safeLen, &linkData[curIdx], RSSP_VAR_NODE_LEN_WL, oppIdSafeIdx, oppIdsNum, oppIds);
+						}
+
+						redundLenIdx = curIdx + safeLen;
+						redundLen = curLen - 2 - safeLen;
+						if ((0 < redundLen) && (0 == (redundLen % RP_LINK_LEN)))
+						{
+							aftRedundLen = DelRsspiNotOppId(redundLen, &linkData[redundLenIdx], RP_LINK_LEN, oppIdRedundIdx, oppIdsNum, oppIds);
+						}
+
+						if ((aftSafeLen <= safeLen) && (aftRedundLen <= redundLen)) /*处理后长度有效*/
+						{
+							curIdx += aftSafeLen; /*处理后冗余层开始位置*/
+							if (aftSafeLen < safeLen) /*安全层调整过*/
+							{
+								CommonMemCpy(&linkData[curIdx], aftRedundLen, &linkData[redundLenIdx], aftRedundLen); /*调整冗余层数据*/
+								ShortToChar(aftSafeLen, &linkData[safeLenIdx]); /*设置处理后的安全层长度*/
+								isAdjustRear = 1;
+							}
+							else
+							{
+								if (aftRedundLen < redundLen) /*冗余层调整过*/
+								{
+									isAdjustRear = 1;
+								}
+							}
+							curIdx += aftRedundLen; /*尾部数据开始位置*/
+							if (1 == isAdjustRear) /*需调整尾部数据*/
+							{
+								CommonMemCpy(&linkData[curIdx], totalLen - curLenIdx - 2 - curLen, &linkData[curLenIdx + 2 + curLen], totalLen - curLenIdx - 2 - curLen); /*调整尾部数据*/
+								ShortToChar(2 + aftSafeLen + aftRedundLen, &linkData[curLenIdx]); /*设置处理后的RSSPI链路长度*/
+								ShortToChar(totalLen - 2 - (safeLen - aftSafeLen) - (redundLen - aftRedundLen), linkData); /*设置适配层链路总长度*/
+							}
+						}
+					}
+
+					break; /*找到RSSPI处理完链路退出循环*/
+				}
+				else /*非RSSPI协议继续循环处理*/
+				{
+					curIdx += curLen;
+				}
+			}
+			else /*协议链路长度无效,退出循环*/
+			{
+				break;
+			}
+		}
+	}
+#endif
+}
+
 /*
 *功能描述:	获取各网收到包数
 *输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
@@ -330,14 +505,17 @@ void ProtclGetSwapData(UINT8 swapData[], const UINT16 swapDataMaxLen, ProtclConf
 	}
 }
 
-/**
+/*
- * @brief ProtclSetSwapData 设置输出数据中双CPU交互数据
+*函数名:	ProtclSetSwapData
- * @param swapData 交互数据2字节总长度+SFP(2字节长度+N个[4字节CRC])+RSSPI(2字节长度+N个[4字节SVC]) 取值范围:字节数组
+*功能描述:	设置输出数据中双CPU交互数据
- * @param protcl 协议结构体变量 取值范围:参考结构体ProtclConfigInfoStru
+*输入参数:	UINT8 swapData[] 交互数据 2字节总长度+SFP(2字节长度+N个[4字节CRC])+RSSPI(2字节长度+N个[4字节SVC])
+*			ProtclConfigInfoStru* protcl 协议结构体变量
+*输入出参:	无
+*输出参数:	无
+*返回值:	无
 */
 void ProtclSetSwapData(UINT8 swapData[], ProtclConfigInfoStru* protcl)
 {
-	/*- 定义局部变量*/
 	UINT16 swapDataLen = 0u; /*交互数据长度*/
 	UINT32 allLen = 0u; /*总长度*/
 	UINT32 outAppIdx = 0u; /*输出应用数据位置*/
@@ -348,88 +526,64 @@ void ProtclSetSwapData(UINT8 swapData[], ProtclConfigInfoStru* protcl)
 	UINT16 rsspiLen = 0u; /*RSSPI长度*/
 	UINT16 sfpStartIdx = 0u; /*SFP开始位置*/
 	UINT16 rsspiStartIdx = 0u; /*RSSPI开始位置*/
-	UINT8 isProSfp = 0u; /*-< 设置是否处理过SFP为否*/
+	UINT8 isProSfp = 0u; /*是否处理过SFP*/
-	UINT8 isProRsspi = 0u; /*-< 设置是否处理过RSSPI为否*/
+	UINT8 isProRsspi = 0u; /*是否处理过RSSPI*/
 	UINT8* record = NULL; /*日志数组*/
 	UINT16 recordSize = 0u; /*日志数组长度*/
-	UINT8 deepPro = 0u; /*-< 设置处理标志为不处理*/
 
-	if ((NULL != swapData) && (NULL != protcl) && (NULL != protcl->GlobalVar)) /*-< 参数是否非空*/
+	if ((NULL != swapData) && (NULL != protcl) && (NULL != protcl->GlobalVar))
 	{
-		/*- 记录调用函数日志*/
 		record = protcl->RecordArray;
 		recordSize = protcl->RecordArraySize;
 		PrintRecArrayByte(record, recordSize, 0xD2u);
 
-		swapDataLen = ShortFromChar(&swapData[0]); /*-< 得到总长度*/
+		swapDataLen = ShortFromChar(&swapData[0]); /*总长度*/
 
-		sfpStartIdx = 2u; /*-< 设置RSSPI开始位置为2*/
+		sfpStartIdx = 2u; /*RSSPI开始位置*/
-		sfpLen = ShortFromChar(&swapData[2]); /*-< 得到长度*/
+		sfpLen = ShortFromChar(&swapData[2]);
-		rsspiStartIdx = 2u + sfpStartIdx + sfpLen; /*-< 更新RSSPI开始位置*/
+		rsspiStartIdx = 2u + sfpStartIdx + sfpLen; /*RSSPI开始位置*/
-		rsspiLen = ShortFromChar(&swapData[rsspiStartIdx]); /*-< 更新RSSPI开始位置*/
+		rsspiLen = ShortFromChar(&swapData[rsspiStartIdx]);
-		if (((2u + sfpLen + 2u + rsspiLen) == swapDataLen) && (0u == (sfpLen % 4u)) && (0u == (rsspiLen % 4u))) /*-< 长度检查*/
+		if (((2u + sfpLen + 2u + rsspiLen) == swapDataLen) && (0u == (sfpLen % 4u)) && (0u == (rsspiLen % 4u))) /*长度检查*/
 		{
 			/*AppArray:4字节总长度+|&2字节长度+1字节协议类型+1字节目的类型+1字节目的ID+2字节预留+网络上发送数据(协议包)*/
-			allLen = LongFromChar(&protcl->AppArray[0]); /*-< 得到应用长度*/
+			allLen = LongFromChar(&protcl->AppArray[0]);
-			if (0u < allLen) /*-< 是否有输出*/
+			if (0u < allLen) /*有输出*/
 			{
-				deepPro = 1u; /*-< 设置处理标志为处理*/
+				outAppData = &protcl->AppArray[4];
-			}
+				while (outAppIdx < allLen) /*遍历输出应用数据*/
-			else /*无输出*/
 				{
-				/*- 记录应用长度错误日志*/
+					pkgLen = 2u + ShortFromChar(&outAppData[outAppIdx]);
-				PrintRecArrayByte(record, recordSize, 2u);
+					if ((outAppIdx + pkgLen) <= allLen) /*当前输出应用位置加长度小于等于输出应用长度,合法*/
-				PrintRecArrayByte(record, recordSize, 0u);
-			}
-		}
-		else /*长度检查错误*/
 					{
-			/*- 记录长度检查错误日志*/
+						protclType = outAppData[outAppIdx + 2u]; /*协议类型*/
-			PrintRecArrayByte(record, recordSize, 1u);
+						if ((DSU_PROTCL_SFP == protclType) || (DSU_PROTCL_RSSP == protclType)) /*SFP或RSSPI*/
-			PrintRecArray2ByteB(record, recordSize, swapDataLen);
-			PrintRecArray2ByteB(record, recordSize, sfpLen);
-			PrintRecArray2ByteB(record, recordSize, rsspiLen);
-		}
-	}
-
-	if (1u == deepPro) /*-< 处理标志是否为处理*/
 						{
-		outAppData = &protcl->AppArray[4]; /*-< 得到输出数据*/
+							if (DSU_PROTCL_SFP == protclType) /*SFP*/
-		while (outAppIdx < allLen) /*-< 遍历输出应用数据*/
 							{
-			pkgLen = 2u + ShortFromChar(&outAppData[outAppIdx]); /*-< 得到包长度*/
+								if (0u == isProSfp) /*只处理一次,适配层输出数据中,SFP数据一份*/
-			if ((outAppIdx + pkgLen) <= allLen) /*-< 当前输出应用位置加长度小于等于输出应用长度,合法*/
-			{
-				protclType = outAppData[outAppIdx + 2u]; /*-< 得到协议类型*/
-				if ((DSU_PROTCL_SFP == protclType) || (DSU_PROTCL_RSSP == protclType)) /*-< 协议类型是否SFP或RSSPI*/
-				{
-					if (DSU_PROTCL_SFP == protclType) /*-< 协议类型是SFP*/
-					{
-						if (0u == isProSfp) /*-< 处理过SFP是否为否*//*只处理一次,适配层输出数据中,SFP数据一份*/
 								{
 #ifdef USE_SFP
-							SfpSetSwapDataForOut(&swapData[sfpStartIdx], &outAppData[outAppIdx], protcl->GlobalVar->gpsfpUnitInfo); /*-< 调用设置指定输出数据中双CPU交互数据函数*/
+									SfpSetSwapDataForOut(&swapData[sfpStartIdx], &outAppData[outAppIdx], protcl->GlobalVar->gpsfpUnitInfo);
 #endif
-							isProSfp = 1u; /*-< 设置是否处理过SFP为是*/
+									isProSfp = 1u;
 								}
 							}
 							else /*RSSPI*/
 							{
-						if (0u == isProRsspi)  /*-< 处理过RSSPI是否为否*//*只处理一次,适配层输出数据中,RSSPI数据一份*/
+								if (0u == isProRsspi) /*只处理一次,适配层输出数据中,RSSPI数据一份*/
 								{
 #ifdef USE_RSSPI
-							RsspiSetSwapDataForOut(&swapData[rsspiStartIdx], &outAppData[outAppIdx], protcl->GlobalVar->gpRsspUnitInfo); /*-< 调用设置输出数据中双CPU交互数据函数*/
+									RsspiSetSwapDataForOut(&swapData[rsspiStartIdx], &outAppData[outAppIdx], protcl->GlobalVar->gpRsspUnitInfo);
 #endif
-							isProRsspi = 1u; /*-< 设置是否处理过RSSPI为是*/
+									isProRsspi = 1u;
 								}
 							}
 						}
 
-				outAppIdx += pkgLen; /*-< 输出数据下标自增包长度*/
+						outAppIdx += pkgLen;
 					}
 					else /*包长度非法*/
 					{
-				/*- 记录包长度检查错误日志*/
 						PrintRecArrayByte(record, recordSize, 3u);
 						PrintRecArray2ByteB(record, recordSize, pkgLen);
 						PrintRecArray4ByteB(record, recordSize, outAppIdx);
@@ -439,24 +593,39 @@ void ProtclSetSwapData(UINT8 swapData[], ProtclConfigInfoStru* protcl)
 					}
 				}
 			}
+			else /*无输出*/
+			{
+				PrintRecArrayByte(record, recordSize, 2u);
+				PrintRecArrayByte(record, recordSize, 0u);
+			}
+		}
+		else /*长度检查错误*/
+		{
+			PrintRecArrayByte(record, recordSize, 1u);
+			PrintRecArray2ByteB(record, recordSize, swapDataLen);
+			PrintRecArray2ByteB(record, recordSize, sfpLen);
+			PrintRecArray2ByteB(record, recordSize, rsspiLen);
+		}
+	}
 }
 
-/**
+/*
- * @brief ProtclDelAllLink 适配层删除所有链路
+*函数名:	ProtclDelAllLink
- * @param protcl 适配层协议结构体变量 取值范围:参考结构体ProtclConfigInfoStru
+*功能描述:	适配层删除所有链路
+*输入参数:	ProtclConfigInfoStru* protcl 协议结构体变量
+*输入出参:	无
+*输出参数:	无
+*返回值:	无
 */
 void ProtclDelAllLink(ProtclConfigInfoStru* protcl)
 {
-	if ((NULL != protcl) && (NULL != protcl->GlobalVar)) /*-< 参数是否非空*/
+	if ((NULL != protcl) && (NULL != protcl->GlobalVar)) /*参数检查*/
 	{
 #ifdef USE_SFP
-		SfpDelAllLink(protcl->GlobalVar->gpsfpUnitInfo); /*-< 调用SFP删除所有链路函数*/
+		SfpDelAllLink(protcl->GlobalVar->gpsfpUnitInfo);
 #endif
 #ifdef USE_RSSPI
-		RsspiDelAllLink(protcl->GlobalVar->gpRsspUnitInfo); /*-< 调用RSSPI删除所有链路函数*/
+		RsspiDelAllLink(protcl->GlobalVar->gpRsspUnitInfo);
-#endif
-#ifdef USE_RP
-		RpDelAllLink(protcl->GlobalVar->gpRedunUnitInfo); /*-< 调用RP删除所有链路函数*/
 #endif
 	}
 }
@@ -878,27 +1047,30 @@ static UINT8 TwoNetRepeatParam(ProtclConfigInfoStru* protcl, UINT8* data1, UINT3
 	return rtnVal;
 }
 
-/**
+/*
- * @brief TwoDevRepeat 两份设备数据比较去除重复数据(只地面平台使用)
+*函数名:	TwoDevRepeat
- * @param protcl 协议结构体变量 取值范围:参考结构体ProtclConfigInfoStru
+*功能描述:	两份设备数据比较去除重复数据
- * @param data1 一份数据(格式:网络数据{4字节长度+{2字节长度+2字节设备类型ID+2字节逻辑ID+网络数据包}+{N个}}+{N个}) 取值范围:字节数组
+*输入参数:
- * @param data1IdxNet 网1当前下标 取值范围:0x00000000-0xFFFFFFFF
+*			ProtclConfigInfoStru* protcl 协议结构体变量
- * @param data1Idx 数据1下标 取值范围:0x00000000-0xFFFFFFFF
+*			UINT8* data1 一份数据(格式:网络数据{4字节长度+{2字节长度+2字节设备类型ID+2字节逻辑ID+网络数据包}+{N个}}+{N个})
- * @param data1Len 一份数据长度 取值范围:0x00000000-0xFFFFFFFF
+*			const UINT32 data1IdxNet 网1当前下标
- * @param data2 二份数据(格式:同一份数据) 取值范围:字节数组
+*			const UINT32 data1Len 一份数据长度
- * @param data2Idx 数据2下标 取值范围:0x00000000-0xFFFFFFFF
+*			UINT8* data2 二份数据(格式:同上)
- * @param data2Len 二份数据长度 取值范围:0x00000000-0xFFFFFFFF
+*			const UINT32 data2Len 二份数据长度
- * @param net2Idx 网2下标 取值范围:0x00000000-0xFFFFFFFF
+*			const UINT32 net2Len 网2长度
- * @param net2Len 网2长度 取值范围:0x00000000-0xFFFFFFFF
+*			const UINT32 data2StagingMaxLen 二份数据暂存数组最大长度
- * @param data2Staging 二份数据暂存数组 取值范围:字节数组
+*输入出参:
- * @param data2StagingIdx 二份数据暂存数组下标 取值范围:0x00000000-0xFFFFFFFF
+*			UINT32* data1Idx 数据1下标
- * @param data2StagingMaxLen 二份数据暂存数组最大长度 取值范围:0x00000000-0xFFFFFFFF
+*			UINT32* data2Idx 数据2下标
- * @return 1:成功 其他:失败
+*			UINT32* net2Idx 网2下标
+*			UINT8* data2Staging 二份数据暂存数组
+*			UINT32* data2StagingIdx 二份数据暂存数组下标
+*输出参数:	无
+*返回值:	成功:1 失败:非1
 */
 static UINT8 TwoDevRepeat(ProtclConfigInfoStru* protcl, UINT8* data1, const UINT32 data1IdxNet, UINT32* data1Idx, const UINT32 data1Len, UINT8* data2, UINT32* data2Idx, const UINT32 data2Len, UINT32* net2Idx, const UINT32 net2Len, UINT8* data2Staging, UINT32* data2StagingIdx, const UINT32 data2StagingMaxLen)
 {
-	/*- 定义局部变量*/
+	UINT8 rtnVal = 0u; /*返回值*/
-	UINT8 rtnVal = 0u; /*-< 设置函数返回值为0*/
 	UINT16 dev2Len = 0u; /*设备包数据长度*/
 	UINT32 dev2UniqueId = 0u; /*设备唯一ID(类型ID+逻辑ID)*/
 	UINT8 dev2oppTypePtl = 0u; /*对方设备协议类型*/
@@ -906,66 +1078,40 @@ static UINT8 TwoDevRepeat(ProtclConfigInfoStru* protcl, UINT8* data1, const UINT
 	UINT32 net1Idx = 0u; /*网1下标*/
 	UINT8 funRtn = 0u; /*调用函数返回值*/
 	UINT8 isErr = 0u; /*是否错误*/
-	UINT8 deepPro = 0u; /*-< 设置处理标志为不处理*/
 
-	funRtn = TwoDevRepeatParam(protcl, data1, data1Idx, data2, data2Idx, net2Idx, data2Staging, data2StagingIdx); /*-< 调用两份设备数据比较去除重复数据函数参数检查函数*/
+	funRtn = TwoDevRepeatParam(protcl, data1, data1Idx, data2, data2Idx, net2Idx, data2Staging, data2StagingIdx);
-	if (1u == funRtn) /*-< 调用函数是否返回正常*/
+	if (1u == funRtn) /*调用函数返回正常*/
 	{
-		if (*data2Idx + 6u < data2Len) /*-< 数据下标合法.6为2字节设备数据长度+4字节设备唯一ID*/
+		if (*data2Idx + 6u < data2Len) /*数据下标合法.6为2字节设备数据长度+4字节设备唯一ID*/
 		{
-			dev2Len = 2u + ShortFromChar(&data2[*data2Idx]); /*-< 得到设备2数据长度*/
+			dev2Len = 2u + ShortFromChar(&data2[*data2Idx]); /*设备数据长度*/
-			if ((6u < (UINT32)dev2Len) && (4u + (UINT32)dev2Len <= net2Len)) /*-< 设备2数据长度合法*/
+			if ((6u < (UINT32)dev2Len) && (4u + (UINT32)dev2Len <= net2Len)) /*设备数据长度合法*/
 			{
-				dev2oppTypePtl = protcl->GlobalVar->oppTypePtl[data2[*data2Idx + 2u]]; /*-< 得到设备2对方协议类型*/
+				dev2oppTypePtl = protcl->GlobalVar->oppTypePtl[data2[*data2Idx + 2u]];
-				dev2UniqueId = LongFromChar(&data2[*data2Idx + 2u]); /*-< 得到设备2唯一ID*/
+				dev2UniqueId = LongFromChar(&data2[*data2Idx + 2u]); /*设备唯一ID*/
-				if ((data1IdxNet + 4u) <= data1Len) /*-< 数据1位置是否合法*/
+				if ((data1IdxNet + 4u) <= data1Len) /*数据位置合法*/
 				{
-					net1Len = 4u + LongFromChar(&data1[data1IdxNet]); /*-< 得到网1包长度*/
+					net1Len = 4u + LongFromChar(&data1[data1IdxNet]); /*网包长度*/
-					if (net1Len <= data1Len) /*-< 网1包长度合法*/
+					if (net1Len <= data1Len) /*网包长度合法*/
 					{
-						deepPro = 1u; /*-< 设置处理标志为处理*/
+						net1Idx += 4u;
-					}
+						if (4u < net1Len) /*有设备数据*/
-					else /*网包长度非法*/
 						{
-						rtnVal = NET1_LEN_ILLEGAL; /*-< 设置函数返回值为18*/
+							funRtn = RepeatCheck(dev2oppTypePtl, dev2UniqueId, &data2[*data2Idx], dev2Len, data1, data1Idx, data1Len, data1IdxNet, &net1Idx, net1Len, data2Staging, data2StagingIdx, data2StagingMaxLen);
-					}
+							if (1u == funRtn) /*调用函数返回值正常*/
-				}
-				else /*数据位置非法*/
 							{
-					rtnVal = DATA1_IDX_ILLEGAL; /*-< 设置函数返回值为12*/
+								*net2Idx += dev2Len;
-				}
+								*data2Idx += dev2Len;
-			}
+								rtnVal = 1u;
-			else /*设备数据长度非法*/
-			{
-				rtnVal = DATA2_DEV_LEN_ILLEGAL; /*-< 设置函数返回值为11*/
-			}
-		}
-		else /*数据下标非法*/
-		{
-			rtnVal = DATA2_IDX_ILLEGAL; /*-< 设置函数返回值为10*/
-		}
-	}
-
-	if (1u == deepPro) /*-< 处理标志是否为处理*/
-	{
-		net1Idx += 4u; /*-< 网1下标自增4*/
-		if (4u < net1Len) /*-< 网1有设备数据*/
-		{
-			funRtn = RepeatCheck(dev2oppTypePtl, dev2UniqueId, &data2[*data2Idx], dev2Len, data1, data1Idx, data1Len, data1IdxNet, &net1Idx, net1Len, data2Staging, data2StagingIdx, data2StagingMaxLen); /*-< 调用重复检查函数*/
-			if (1u == funRtn) /*-< 调用函数返回值是否正常*/
-			{
-				*net2Idx += dev2Len; /*-< 网2长度自增设备2长度*/
-				*data2Idx += dev2Len; /*-< 数据2长度自增设备2长度*/
-				rtnVal = 1u; /*-< 设置函数返回值为1*/
 							}
 							else /*调用函数返回值错误*/
 							{
-				rtnVal = funRtn; /*-< 设置函数返回值为调用函数返回值*/
+								rtnVal = funRtn;
 							}
 						}
 						else /*无设备数据*/
 						{
-			if (data1IdxNet == *data1Idx) /*-< 是否第一次*/
+							if (data1IdxNet == *data1Idx) /*第一次*/
 							{
 								if (net1Idx == net1Len) /*-< 检查网包长度是否合法*/
 								{
@@ -999,8 +1145,28 @@ static UINT8 TwoDevRepeat(ProtclConfigInfoStru* protcl, UINT8* data1, const UINT
 							}
 						}
 					}
+					else /*网包长度非法*/
+					{
+						rtnVal = NET1_LEN_ILLEGAL;
+					}
+				}
+				else /*数据位置非法*/
+				{
+					rtnVal = DATA1_IDX_ILLEGAL;
+				}
+			}
+			else /*设备数据长度非法*/
+			{
+				rtnVal = DATA2_DEV_LEN_ILLEGAL;
+			}
+		}
+		else /*数据下标非法*/
+		{
+			rtnVal = DATA2_IDX_ILLEGAL;
+		}
+	}
 
-	return rtnVal; /*-< 返回函数返回值*/
+	return rtnVal;
 }
 
 /*