[9.4.2] 9.4.2首版一回代码，基线版本

TSCP/src/APP/PU13_integration_config/ci_integrate_config.h

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

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,6 +319,8 @@ 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;  /*计轴区段包络数量*/
+	EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
 
 	chSwitch = aam_PrepareArbSwitch();
 	if (CI_SUCCESS == chSwitch)
@@ -450,27 +452,35 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 					}
 					else
 					{
-						/*ARB计轴区段同向相邻计轴区段连续占用*/
+						cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(acID, strEnvelopeInfo);
-						funRtn = aam_ArbContinuousOccCheck(acID, acSameCnt, acSameID);
+						if ((0U < cAcRelEnvelopeCnt) && (SECTION_REL_ENVELOPE_SUM_MAX > cAcRelEnvelopeCnt))
-
-						/*ARB计轴区段反向相邻计轴区段连续占用*/
-						funRtn &= aam_ArbContinuousOccCheck(acID, acConvertCnt, acConvertID);
-
-						if (CI_SUCCESS != funRtn)
 						{
-							/** 清除本计轴区段之前的冗余计时位 */
+							/*ARB区段存在包络，不进行ARB连续占用判断*/
-							funRtn = aam_ClearPassTrainFlag(acIndex);
-							ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00800000U);
-
-							funRtn = aam_ClearRedunTime(acIndex);
-							ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00400000U);
-
-							aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
-							AAM_LOG(AAM_LOG_FATAL, "info:AC%d  Keep ARB Fail Because Of Near Sec Continuous Occ\n", acID);
 						}
 						else
 						{
-							/*相邻区段占用检查通过，维持ARB状态*/
+							/*ARB计轴区段同向相邻计轴区段连续占用*/
+							funRtn = aam_ArbContinuousOccCheck(acID, acSameCnt, acSameID);
+
+							/*ARB计轴区段反向相邻计轴区段连续占用*/
+							funRtn &= aam_ArbContinuousOccCheck(acID, acConvertCnt, acConvertID);
+
+							if (CI_SUCCESS != funRtn)
+							{
+								/** 清除本计轴区段之前的冗余计时位 */
+								funRtn = aam_ClearPassTrainFlag(acIndex);
+								ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00800000U);
+
+								funRtn = aam_ClearRedunTime(acIndex);
+								ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00400000U);
+
+								aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
+								AAM_LOG(AAM_LOG_FATAL, "info:AC%d  Keep ARB Fail Because Of Near Sec Continuous Occ\n", acID);
+							}
+							else
+							{
+								/*相邻区段占用检查通过，维持ARB状态*/
+							}
 						}
 					}
 				}
@@ -1559,7 +1569,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; /*继续检查标志*/
@@ -1571,7 +1581,10 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
 	UINT8 chNearSecNum = 0U; /*间接相邻数量*/
 	UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
-
+	UINT8 chSwitchPosCheck = CI_ERROR;/*当前道岔检查结果*/
+	UINT16 wPreSecId = 0U;/*间接区段的跳转区段*/
+	UINT16 wSndPreSecId = 0U;/*间接区段最初跳转区段*/
+	UINT8 chPreSecNearCheck = 0U;/*间接区段的跳转区段是否直接相邻*/
 	cyCheckUtCyc = GetArbProtectCheckTime();
 	wBasePhyid = aam_PrepareACBelongPhyid(ACID);
 	
@@ -1614,28 +1627,38 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 			for (ii = 0; ii < chAdjacentPhyNum; ii++)
 			{
 				wCheckPhySec = wAdjacentPhyBuf[ii];
-				phyAcNum = GetPAxisSectionSum(wCheckPhySec);
+				chSwitchPosCheck = GetAdjacentPhySecAcCheck(wBasePhyid, wCheckPhySec);
-				pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
+				if (CI_SUCCESS == chSwitchPosCheck)
-				/*遍历计轴上最近坏车占用周期*/
-				if ((0U != phyAcNum) && (NULL != pACBuff))
 				{	
-					for (jj = 0; jj < phyAcNum; jj++)
+					/* 邻近区段有坏车曾占用再取消，认为坏车接近*/
+					phyAcNum = GetPAxisSectionSum(wCheckPhySec);
+					pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);			
+					/*遍历计轴上最近坏车占用周期*/
+					if ((0U != phyAcNum) && (NULL != pACBuff))
 					{
-						dwRecentUtCyc = GetAxisRecentUtOccupyCyc(pACBuff[jj]);
+						for (jj = 0; jj < phyAcNum; jj++)
-						chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);
-						if (CI_TIME_IN == chTimeFlag)
 						{
-							/*还在时间范围内 认为坏车接近*/
+							dwRecentUtCyc = GetAxisRecentUtOccupyCyc(pACBuff[jj]);
-							chKeepcheck = CI_ERROR;
+							chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);							
-							retVal = CI_ERROR;
+							if (CI_TIME_IN == chTimeFlag)
-							debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step2, PhySec = %d\n", ACID, wCheckPhySec);
+							{
-							break;
+								/*还在时间范围内*/
+								chKeepcheck = CI_ERROR;
+								retVal = CI_ERROR;
+								debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step2, PhySec = %d\n", ACID, wCheckPhySec);
+								break;
+							}
 						}
 					}
+					else
+					{
+						chKeepcheck = CI_ERROR;
+					}
 				}
 				else
 				{
-					chKeepcheck = CI_ERROR;
+					;/*不处理*/
+					debug_infor_printf((const)"ACid: %d ,AdjacentSec Skip PhySec = %d\n", ACID, wCheckPhySec);
 				}
 			}
 		}
@@ -1653,28 +1676,57 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
 		for (ii = 0; ii < chNearSecNum; ii++)
 		{
 			wCheckPhySec = dwNearSecBuf[ii];
-			phyAcNum = GetPAxisSectionSum(wCheckPhySec);
+			wPreSecId = GetNearSecPreSecId(wBasePhyid, wCheckPhySec);
-			pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
+			chPreSecNearCheck = CheckPhySecIfAdjacent(wBasePhyid, wPreSecId);
-			/*遍历计轴上最近坏车占用周期*/
+			if (CI_SUCCESS == chPreSecNearCheck)
-			if ((0U != phyAcNum) && (NULL != pACBuff))
 			{
-				for (jj = 0; jj < phyAcNum; jj++)
+				/*直接区段可达、本区段与直接相邻区段可达*/
+				chSwitchPosCheck = GetAdjacentPhySecAcCheck(wBasePhyid, wPreSecId);
+				chSwitchPosCheck &= GetAdjacentPhySecAcCheck(wPreSecId, wCheckPhySec);
+			}
+			else
+			{
+				/*间隔两步相邻区段，要求每步可达*/
+				wSndPreSecId = GetNearSecPreSecId(wBasePhyid, wPreSecId);
+				chSwitchPosCheck = GetAdjacentPhySecAcCheck(wBasePhyid, wSndPreSecId);
+				chSwitchPosCheck &= GetAdjacentPhySecAcCheck(wSndPreSecId, wPreSecId);
+				chSwitchPosCheck &= GetAdjacentPhySecAcCheck(wPreSecId, wCheckPhySec);
+			}
+			if (CI_SUCCESS == chSwitchPosCheck) 
+			{
+				/* 邻近可达区段有坏车曾占用再取消，认为坏车接近*/
+				phyAcNum = GetPAxisSectionSum(wCheckPhySec);
+				pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
+				/*遍历计轴上最近坏车占用周期*/
+				if ((0U != phyAcNum) && (NULL != pACBuff))
 				{
-					dwRecentUtCyc = GetAxisRecentUtOccupyCyc(pACBuff[jj]);
+					for (jj = 0; jj < phyAcNum; jj++)
-					chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);
-					if (CI_TIME_IN == chTimeFlag)
 					{
-						/*还在时间范围内 认为坏车接近*/
+						dwRecentUtCyc = GetAxisRecentUtOccupyCyc(pACBuff[jj]);
-						chKeepcheck = CI_ERROR;
+						chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);
-						retVal = CI_ERROR;
+						if (CI_TIME_IN == chTimeFlag)
-						debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step3, PhySec = %d\n", ACID, wCheckPhySec);
+						{
-						break;
+							/*还在时间范围内 认为坏车接近*/
+							chKeepcheck = CI_ERROR;
+							retVal = CI_ERROR;
+							debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step3, PhySec = %d\n", ACID, wCheckPhySec);
+							break;
+						}
 					}
 				}
+				else
+				{
+					chKeepcheck = CI_ERROR;
+				}
 			}
 			else
 			{
-				chKeepcheck = CI_ERROR;
+				;/*不可达状态 坏车占用不影响*/
+				debug_infor_printf((const)"ACid: %d ,NearSec Skip PhySec = %d\n", ACID, wCheckPhySec);
+			}
+			if (CI_SUCCESS != chKeepcheck)
+			{
+				break;
 			}
 		}
 	}
@@ -2115,12 +2167,14 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
 	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 +2191,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 +2222,7 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
 					}
 					else
 					{
-						/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
+						/*继续检查*/
 					}
 				}
 				else

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/IO/DeviceRelayDataProcess.c

@@ -6161,7 +6161,7 @@ void PhySecResetToRelayStateProc(void)
 		{/*采集到ZFWJ落下，不执行计轴复位逻辑处理*/
 			retValid = CI_ERROR;
 			tmpRet = SetRelayStateUpdateCycNum(relayZFWId, 0u);	/*清除ZFW总复位继电器有效起始周期号*/
-
+			CleanPhySecResetStartCycNum();/*清除复位起始周期号*/
 			if (CI_ERROR == tmpRet)
 			{
 				/*错误处理*/
@@ -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/OutputDataProcess.c

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

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

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

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

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

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

@@ -1646,6 +1646,7 @@ void RouteNearLockErrManage(const UINT16 routeId)
 	UINT8 routeRepeatStat = 0U;
 	UINT8 routeTrainNear = 0U;
 	UINT8 cFuncRetVal = CI_ERROR;
+	UINT8 cFuncSwitch = 0U;
 
 	/*获取进路始端信号机ID*/
 	startSignalId = GetRouteStartSignalId(routeId);
@@ -1673,18 +1674,28 @@ void RouteNearLockErrManage(const UINT16 routeId)
 		{/*之前驱动开放*/
 			if ((CI_SUCCESS == autoSignalValid) || (ROUTE_REPEATOPEN_SET_YES == routeRepeatStat))
 			{ /*自动信号或者重开*/
-
+				cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_REOPRN_SET_NEAR);
-				if (CI_SUCCESS == routeTrainNear)
+				if(FUNC_SWITCH_ON == cFuncSwitch)
-				{/*进路有车接近*/
+				{
+					/*“重开信号是否记忆进路接近锁闭状态开关”配置为0xAA时，默认设置进路接近*/
 					SetRouteStateManage(routeId, ROUTE_STATE_NEAR_OPEN);   /*-->设置接近开放*/
-
 					RouteNearOpenManage(routeId); /*-->进路接近开放管理*/
 				}
 				else
-				{/*进路无车接近*/
+				{
-					SetRouteStateManage(routeId, ROUTE_STATE_YUXIAN_OPEN);  /*-->设置预先开放*/
+					/*“重开信号是否记忆进路接近锁闭状态开关”配置为0x55时，根据接近区段占用状态设置进路接近/未接近*/
+					if (CI_SUCCESS == routeTrainNear)
+					{/*进路有车接近*/
+						SetRouteStateManage(routeId, ROUTE_STATE_NEAR_OPEN);   /*-->设置接近开放*/
 
-					RouteYuXianOpenManage(routeId);  /*进路预先开放管理*/
+						RouteNearOpenManage(routeId); /*-->进路接近开放管理*/
+					}
+					else
+					{/*进路无车接近*/
+						SetRouteStateManage(routeId, ROUTE_STATE_YUXIAN_OPEN);  /*-->设置预先开放*/
+
+						RouteYuXianOpenManage(routeId);  /*进路预先开放管理*/
+					}
 				}
 			}
 			else
@@ -13033,7 +13044,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 +13150,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 +13213,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 +13231,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 +13429,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 +13453,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属性*/
 				}
 			}
@@ -15751,7 +15762,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 +15782,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
 		{

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

@@ -8375,7 +8375,8 @@ UINT8 KeepBlocRouteOtherSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLe
     /*进路开放信号机需检查相关折返进路*/
     UINT8 const zheFanRouteSum = GetRtnEndSigAsStartSigRouteSum(routeId);
     UINT16 * const zheFanRouteIdBuf = GetReturnEndSigAsStartSigRoute(routeId); 
-
+	/* 始端信号机Id */
+	UINT16 const startSignalId = GetRouteStartSignalId(routeId);
 
     /* 联锁逻辑检查 */  
 
@@ -8453,7 +8454,8 @@ UINT8 KeepBlocRouteOtherSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLe
         else
         {
             /* 记录故障码 */
-            SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,devId,ETYPE_SIG_RETURN_OPENED_STATE,devState,sendLevel); 
+			/*原报警ETYPE_SIG_RETURN_OPENED_STATE，出现因进路id顺序出现报警不一致*/
+			SetErrorData(functionId, CI_DEVICE_TYPE_SIGNAL, startSignalId, ETYPE_SIG_START_OPEN_STATE, SIGNAL_CLOSE, sendLevel);
             reResult = CI_ERROR;
         }
     }
@@ -8624,6 +8626,7 @@ UINT8 OpenBlocRouteOtherSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLe
 
 	UINT8 signalVirtualAttr = SIGNAL_VIRTUAL_NO;/*虚拟信号机属性*/
 	UINT8 repeatOpenFlag = ROUTE_REPEATOPEN_SET_NO;/*重开标志*/
+	UINT16 const startSignalId = GetRouteStartSignalId(routeId);/*始端信号机id*/
 	
     /* 联锁逻辑检查 */	
 	cRouteLeadProperty = GetRouteLeadProperty(routeId);
@@ -8760,7 +8763,8 @@ UINT8 OpenBlocRouteOtherSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLe
 		else
 		{
 			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,devId,ETYPE_SIG_RETURN_OPENED_STATE,devState,sendLevel); 
+			/*原报警ETYPE_SIG_RETURN_OPENED_STATE 出现因进路id顺序出现报警不一致 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SIGNAL, startSignalId, ETYPE_SIG_START_OPEN_STATE, SIGNAL_CLOSE, sendLevel);
 			reResult = CI_ERROR;
 		}
 	}
@@ -8810,6 +8814,7 @@ UINT8 OpenCbtcRouteOtherSignalCheck(UINT16 routeId, UINT8 functionId, UINT8 send
 	UINT8 signalVirtualAttr = SIGNAL_VIRTUAL_NO;/*虚拟信号机属性*/
 	UINT8 repeatOpenFlag = ROUTE_REPEATOPEN_SET_NO;/*重开标志*/
 	UINT8 needOpenNotTrueRepeatFlag = ROUTE_NEEDOPEN_REOPEN_NO;/*需开放不满足重开标志*/
+	UINT16 const startSignalId = GetRouteStartSignalId(routeId);/*始端信号机id*/
 
 	routeState = GetRouteState(routeId);/*获取进路状态*/
 										/* 联锁逻辑检查 */
@@ -8936,7 +8941,8 @@ UINT8 OpenCbtcRouteOtherSignalCheck(UINT16 routeId, UINT8 functionId, UINT8 send
 		else
 		{
 			/* 记录故障码 */
-			SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, devId, ETYPE_SIG_RETURN_OPENED_STATE, devState, sendLevel);
+			/*原报警ETYPE_SIG_RETURN_OPENED_STATE 出现因进路id顺序出现报警不一致 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SIGNAL, startSignalId, ETYPE_SIG_START_OPEN_STATE, SIGNAL_CLOSE, sendLevel);
 			reResult = CI_ERROR;
 		}
 	}
@@ -19227,7 +19233,7 @@ UINT8 KeepCBTCRouteOtherSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLe
 	UINT16* pNeedCloseBuf = NULL;
 	UINT8 zheFanRouteSum = 0U;
 	UINT16 * zheFanRouteIdBuf = NULL;
-
+	UINT16  startSignalId = GetRouteStartSignalId(routeId);/*始端信号机id*/
 	/* 进路内设备数据 */            
 	/*进路相关需开放信号机*/
 	needOpenSigSum = GetRouteCbtcNeedOpenSigSum(routeId);
@@ -19320,7 +19326,8 @@ UINT8 KeepCBTCRouteOtherSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLe
 		else
 		{
 			/* 记录故障码 */
-			SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE,devId,ETYPE_SIG_RETURN_OPENED_STATE,devState,sendLevel); 
+			/*原报警ETYPE_SIG_RETURN_OPENED_STATE 出现因进路id顺序出现报警不一致 */
+			SetErrorData(functionId, CI_DEVICE_TYPE_SIGNAL, startSignalId, ETYPE_SIG_START_OPEN_STATE, SIGNAL_CLOSE, sendLevel);
 			reResult = CI_ERROR;
 		}
 	}
@@ -24766,7 +24773,7 @@ UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSec
 
 						if (CI_SUCCESS != cRetVal)
 						{
-							SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_TRAIN_POS, 0U, cSendLevel);
+							SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_TRAIN_POS, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 							debug_infor_printf((const)"LogSecSeqAndTrainPosCheckCLD: Train Check Error: Train[%d] Position Is Error\n", wTrainId); 
 						}
 						else
@@ -24777,19 +24784,19 @@ UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSec
 					}
 					else
 					{
-						SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_TRAIN_COMM, 0U, cSendLevel);
+						SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_TRAIN_COMM, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 						debug_infor_printf((const)"LogSecSeqAndTrainPosCheckCLD: Train Check Error: Train[%d] CommState Is Error\n", wTrainId);  /*列车通信异常，返回失败*/
 					}
 				}
 				else
 				{
-					SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SEC_ATTR, 0U, cSendLevel);
+					SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_SEC_ATTR, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 					debug_infor_printf((const)"LogSecSeqAndTrainPosCheckCLD: LogSec Check Error: LogSec[%d] Attr Is Error\n", pLogSecIdBuff[0]);  /*部分进路的逻辑区段非休眠唤醒轨/道岔区段，返回失败*/
 				}
 			}
 			else
 			{
-				SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SEC_ATTR, 0U, cSendLevel);
+				SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_SEC_ATTR, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 				/*获取逻辑区段包含的link失败，返回失败*/
 			}
 		}
@@ -24801,7 +24808,7 @@ UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSec
 	}
 	else
 	{
-		SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SEC_ATTR, 0U, cSendLevel);
+		SetCiSendCmdBackInfoWithTrainId(CI_BACK_DYM_ROUTE_SEC_ATTR, CI_SYSTEM_TYPE_VOBC, wTrainId, 0U, 0U, wTrainId);
 		/*入参检查失败，返回失败*/
 	}
 
@@ -24957,8 +24964,6 @@ UINT8 MatchLieCheRouteCLD(const UINT8 cRouteSum, const UINT16 szRouteId[MAX_ROUT
 	UINT8 cRouteType = 0U;  /*进路类型*/
 	UINT8 cLieCheIndex = UINT8_MAX;  /*目标列车进路索引*/
 	UINT8 cReturnIndex = UINT8_MAX;  /*目标折返进路索引*/
-	UINT16 wMatchedRouteId = 0U;
-	UINT8 cRouteRukuProperty = ROUTE_AUTOSIG_PROPERTY_NO;  /*进路入库属性*/
 
 	/*入参检查*/
 	if ((MAX_ROUTE_IN_LT_NUM >= cRouteSum) && (NULL != szRouteId) && (NULL != pMatchedRouteId))
@@ -24984,27 +24989,17 @@ UINT8 MatchLieCheRouteCLD(const UINT8 cRouteSum, const UINT16 szRouteId[MAX_ROUT
 
 		if (UINT8_MAX != cLieCheIndex)
 		{
-			wMatchedRouteId = szRouteId[cLieCheIndex];  /*存在列车进路，以列车进路优先*/
+			*pMatchedRouteId = szRouteId[cLieCheIndex];  /*存在列车进路，以列车进路优先*/
+			cRetVal = CI_SUCCESS;
 		}
 		else if(UINT8_MAX != cReturnIndex)
 		{
-			wMatchedRouteId = szRouteId[cReturnIndex];  /*不存在列车进路，使用非主折返进路*/
+			*pMatchedRouteId = szRouteId[cReturnIndex];  /*不存在列车进路，使用非主折返进路*/
-		}
-		else
-		{
-			debug_infor_printf((const)"MatchLieCheRouteCLD: No Train Route And Return Route\n");  /*只有调车进路，返回失败*/
-		}
-
-		/*判断匹配到的进路是否为入库进路*/
-		cRouteRukuProperty = GetRouteRukuProperty(wMatchedRouteId);
-		if (ROUTE_RUKU_PROPERTY_YES == cRouteRukuProperty)
-		{
-			*pMatchedRouteId = wMatchedRouteId;  /*入库进路，返回成功*/
 			cRetVal = CI_SUCCESS;
 		}
 		else
 		{
-			debug_infor_printf((const)"MatchLieCheRouteCLD: Route Id[%d] Is Not Ruku Route\n", wMatchedRouteId);  /*非入库进路，表明ATS发送的逻辑区段序列方向非入库方向，返回失败*/
+			debug_infor_printf((const)"MatchLieCheRouteCLD: No Train Route And Return Route\n");  /*只有调车进路，返回失败*/
 		}		
 	}
 	else
@@ -26207,3 +26202,120 @@ UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId
 
 	return chRetVal;
 }
+
+
+
+/*
+* 功能描述： 进路风井区段状态检查
+* 参数说明： 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)
+{
+	/* 进路区段*/
+	UINT8 const checkSum = GetRouteAiaShaftSecNum(routeId);
+	UINT16* const dataIdBuf = GetRouteAiaShaftSecIdBuf(routeId);
+
+	/* 局部变量定义初始化 */
+    UINT8 i = 0u;           /* 循环变量 */
+    UINT16 devId = 0u;
+    UINT8  devState = 0u;
+	UINT8 reVal = CI_ERROR;
+
+    if ((AIR_SHAFT_ROUTE_SECTION_NUM_MAX < checkSum) || (NULL == dataIdBuf))
+    {
+        /*风井区段数据错误*/
+        reVal = CI_ERROR;
+    }
+    else
+    {
+		/* 风井区段占用检查 */
+		reVal = CI_SUCCESS;
+        /*开始检查*/
+		for (i = 0u; i < checkSum; i++)
+		{
+			devId = dataIdBuf[i];
+			devState = GetPhySecCurMergeState(devId);
+
+			if (SECTION_OCCUPY_NO == devState)
+			{
+				/* 通过检查*/
+			}
+			else
+			{
+				/*状态不一致返回故障状态*/
+				*pDevId = devId;
+				*pDevState = devState;
+				reVal = CI_ERROR;
+				break;
+			}
+		}		
+    }
+
+    /*全部通过检查*/
+    return reVal;
+}
+
+
+/*
+* 功能描述： 进路风井区段锁闭检查
+* 参数说明： 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)
+{
+	/* 进路区段*/
+	UINT8 const checkSum = GetRouteAiaShaftSecNum(routeId);
+	UINT16* const dataIdBuf = GetRouteAiaShaftSecIdBuf(routeId);
+
+	/* 局部变量定义初始化 */
+	UINT8 i = 0u;           /* 循环变量 */
+	UINT16 devId = 0u;
+	UINT8  devState = 0u;
+	UINT8 reVal = CI_ERROR;
+
+	if ((AIR_SHAFT_ROUTE_SECTION_NUM_MAX < checkSum)  || (NULL == dataIdBuf))
+	{
+		/*风井区段数据错误*/
+		reVal = CI_ERROR;
+	}
+	else
+	{
+		/* 风井区段占用检查 */
+		reVal = CI_SUCCESS;
+		/*开始检查*/
+		/*风井区段锁闭检查*/
+		for (i = 0u; i < checkSum; i++)
+		{
+			devId = dataIdBuf[i];
+			devState = GetPhySecLockState(devId);
+
+			/*未锁闭或防护锁闭，不检查防护锁闭方向（之前已检查方向）*/
+			if ((PHYSICAL_SECTION_LOCK_NO == devState) || (PHYSICAL_SECTION_LOCK_PROTECT == devState))
+			{
+				/* 通过检查*/
+
+			}
+			else
+			{
+				/*状态不一致返回故障状态*/
+				*pDevId = devId;
+				*pDevState = devState;
+				reVal = CI_ERROR;
+				break;
+			}
+			
+		}
+	}
+
+	/*全部通过检查*/
+	return reVal;
+}

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

@@ -2784,5 +2784,25 @@ 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);
 #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

@@ -503,7 +503,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;
 
@@ -767,11 +766,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,7 +778,6 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 				}
 				else
 				{
-					cLogId = 0u;
 					dwTrainId = 0u;
 				}
 				LongToChar(dwTrainId, &ciToXianDiDataBuffer[ii]);

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

@@ -1563,6 +1563,8 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 	UINT8 CiTypeOfRoute = 0u;		/*当前进路所属联锁类型*/
 	UINT8 ciTrainTestState = 0u;	/*试车线联锁状态*/
 	UINT8 routeAutoTriggerFlag = GetRouteAutoTriggerFlag(DeviceId);     /*获取进路自动触发标志*/
+
+	UINT32 xuanpaiStartCycNum = GetRouteXuanPaiStartCycNum(DeviceId);/*进路选排开始周期数*/
 	switch (MaskType)
 	{
 	case MASK_TYPE_ROUTE_IDLE:/*进路空闲码位*/
@@ -1576,7 +1578,8 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
 		}
 		break;
 	case MASK_TYPE_ROUTE_XUANPAI:/*进路选排码位*/
-		if (ROUTE_STATE_XUANPAI == routeState)
+		/* 处于选排周期号有效即可发送码位*/
+		if (xuanpaiStartCycNum > 0u)
 		{
 			SetMaskValue(MaskId, dataBuf);
 		}

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

@@ -5131,9 +5131,10 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocPosMonitorInfo Error \n", pstVobcToCiDataStru->VobcId);
 			}
 
+			/*给IVOC组未接近开放进路信息（预先开放）*/
 			if (CI_SUCCESS == chRetVal)
 			{
-				/*组包成功*/
+				chRetVal = PackCiToIvocOpenRouteNotNearInfo(cszCiToIvocDataBuf, &ii, pstVobcToCiDataStru->VobcId);
 			}
 			else
 			{
@@ -5141,8 +5142,18 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocJumpBackReply Error \n", pstVobcToCiDataStru->VobcId);
 			}
 
-			/*预留10字节*/
+			if (CI_SUCCESS == chRetVal)
-			ii += 5U;
+			{
+				/*组包成功*/
+			}
+			else
+			{
+				/*发生组包错误*/
+				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocOpenRouteNotNearInfo Error \n", pstVobcToCiDataStru->VobcId);
+			}
+
+			/*预留4字节*/
+			ii += 4U;
 		}
 		else if ((IVOC_CI_INFO_TYPE_LOGOUT_ASK == pstVobcToCiDataStru->appInfoType) && (curCycleNum == pstVobcToCiDataStru->ComStartCycle))
 		{/*组注销请求回复帧*/
@@ -9391,7 +9402,9 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 				chTempBreakFlag = 0U;
 				chTempRemoveFlag = 0U;
 				chTempAddFlag = 0U;
+				pRouteLogSecId = NULL;
 				wLogicSecId = GetLogicSecId(wLogicSecIndex);
+
 				if ((0U < wLogicSecId) && (UINT16_MAX > wLogicSecId))
 				{
 					chLogSecHaveResOpp = GetLogSecHaveResOpp(wLogicSecId);
@@ -9401,6 +9414,8 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 						wRLockRouteId = GetLogSecLockBelongRoute(wLogicSecId);
 						wPLockRouteId = GetLogSecPLockRouteId(wLogicSecId);
 						chLogLockDir = GetLogSecLockDir(wLogicSecId);
+						pAPoint.Lnk = 0U;
+						pAPoint.Off = 0U;
 						
 						if (0U < wRLockRouteId)
 						{
@@ -9418,8 +9433,15 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 							; /*继续下一个*/
 						}
 
-						pAPoint.Lnk = GetLgcSecOrgnLink(pRouteLogSecId[0]);
+						if (NULL != pRouteLogSecId)
-						pAPoint.Off = 0U;
+						{
+							pAPoint.Lnk = GetLgcSecOrgnLink(pRouteLogSecId[0]);
+							pAPoint.Off = 0U;
+						}
+						else
+						{
+							;
+						}
 						
 						if ((CI_SYSTEM_DIRECTION_UP == chLogLockDir) || (CI_SYSTEM_DIRECTION_DOWN == chLogLockDir))
 						{
@@ -9482,6 +9504,9 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 								chLogRelateLogLockDir = GetLogSecLockDir(wRelateLogSecId[jj]);
 								wRLockRouteId = GetLogSecLockBelongRoute(wRelateLogSecId[jj]);
 								wPLockRouteId = GetLogSecPLockRouteId(wRelateLogSecId[jj]);
+								pBPoint.Lnk = 0U;
+								pBPoint.Off = 0U;
+
 								if (0U < wRLockRouteId)
 								{
 									wRouteLogSecSum = GetRouteLogSectionSum(wRLockRouteId);
@@ -9503,13 +9528,17 @@ static UINT8 PackCiToIvocReqAlignmentInfo(UINT8* pDataBuf, UINT16* wDataLength,
 								{
 									; /*继续查找*/
 								}
-								if (NULL != pRouteLogSecId)
+
+								if ((NULL != pRouteLogSecId) && (0U < pAPoint.Lnk) && (0U < pBPoint.Lnk))
 								{
 									/*可能涉及到相邻联锁，如果数据没做，指针可能为空，此时需要防一下*/
-									chDirChangedNum = GetDirChangeNumBtwPoints(&pAPoint, &pBPoint);
+									/*两个比较的区段均有锁闭才去检查方向变化点数目和锁闭方向*/
+
 									if ((CI_SYSTEM_DIRECTION_UP == chLogRelateLogLockDir) || (CI_SYSTEM_DIRECTION_DOWN == chLogRelateLogLockDir))
 									{
 										/*当前逻辑区段锁闭方向和关联逻辑区段锁闭方向必须有效*/
+										chDirChangedNum = GetDirChangeNumBtwPoints(&pAPoint, &pBPoint);
+										
 										if (0U == (chDirChangedNum % 2U))
 										{
 											/*2条进路之间方向变化点数目为偶数，则锁闭方向不一致则资源对顶*/
@@ -11938,29 +11967,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;
 							}
@@ -12678,3 +12726,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

@@ -722,9 +722,6 @@ UINT8 SystemParameterStructInit(CHAR* FSName)
 					/*对向行驶双车间隔最小安全距离(cm)*/
 					dquCICfgDtStr.SystemParaStrNew.OppositeTrackDistance = pCbtcConfigDataStru.OppositeTrackDistance;
 
-					/*站台追踪时，列车间隔距离（cm）*/
-					dquCICfgDtStr.SystemParaStrNew.StationTrackDistance = pCbtcConfigDataStru.StationTrackDistance;
-
 					/*线路最差情况下紧急制动距离（单位m）*/
 					dquCICfgDtStr.SystemParaStrNew.MaxMALength = pCbtcConfigDataStru.MaxMALength;
 
@@ -4862,17 +4859,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 +6951,7 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
 	callFun *= InitRelay_DCAgreeStru(FSName);/*初始化调车同意继电器表*/
 	callFun *= InitLS_SGBJStru(FSName);  /*初始化声光报警表*/
 	callFun *= InitLS_TransRouteRtnDataStruct(FSName);  /*初始化转换轨折返信号机表*/
+	callFun *= InitLS_AirShaftRouteStru(FSName);	/*初始化风井进路检查表*/
 
 	/*电子地图初始化失败，函数失败退出*/
 	if(0u == callFun)
@@ -7210,6 +7197,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;
 }
 
@@ -12753,3 +12765,55 @@ 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;
+}

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

@@ -937,5 +937,13 @@ 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);
 #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)      /*接近区段无故障车*/
 

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,89 @@ 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非法，不处理*/
+		}
+	}
+}

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,31 @@ 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);
 
 #ifdef __cplusplus
 }

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

@@ -4578,11 +4578,24 @@ UINT8 GetLogSecHaveResOpp(const UINT16 wLogicSecId)
 		/*뎠품쭉서혐뙈야구쏵쨌傑균샀淪쏵쨌傑균쇗렝빱傑균*/
 		wRouteLogSecSum = GetRouteLogSectionSum(wRLockRouteId);
 		pRouteLogSecId = GetRouteLogSectionIdBuf(wRLockRouteId);
-		if ((pRouteLogSecId[wRouteLogSecSum - 1U] == wLogicSecId) && (LOG_SECTION_LOCK_NORMAL == chLogSecLockState))
+
+		if (NULL != pRouteLogSecId)
 		{
-			/*当前待查询逻辑区段为进路最后一个区段并且是正常锁闭，满足条件*/
+			if ((pRouteLogSecId[wRouteLogSecSum - 1U] == wLogicSecId) && (LOG_SECTION_LOCK_NORMAL == chLogSecLockState))
-			retVal = CI_SUCCESS;
+			{
+				/*当前待查询逻辑区段为进路最后一个区段并且是正常锁闭，满足条件*/
+				retVal = CI_SUCCESS;
+			}
+			else
+			{
+				; /*不满足条件*/
+			}
 		}
+		else
+		{
+			; /*可能相邻联锁进路，为空初始化失败*/
+		}
+		
 	}
 	else if (0U < wPLockRouteId)
 	{
@@ -4593,11 +4606,22 @@ UINT8 GetLogSecHaveResOpp(const UINT16 wLogicSecId)
 		chLogSecLockDir = GetLogSecLockDir(wLogicSecId);
 		chLogSecLockSysDir = ConvertDirectionToLogic(chLogSecLockDir);
 
-		if (((pLogicSectionIdBuf[chLogicSectionSum - 1U] == wLogicSecId) && (DIR_SAME == chLogSecLockSysDir))
+		if (NULL != pLogicSectionIdBuf)
-			|| ((pLogicSectionIdBuf[0] == wLogicSecId) && (DIR_CONVERT == chLogSecLockSysDir)))
 		{
-			/*当前待查询逻辑区段锁闭方向与逻辑方向相同，则保护区段最后一个区段满足条件；与逻辑方向相反，保护区段第一个逻辑区段满足条件*/
+			if (((pLogicSectionIdBuf[chLogicSectionSum - 1U] == wLogicSecId) && (DIR_SAME == chLogSecLockSysDir))
-			retVal = CI_SUCCESS;
+				|| ((pLogicSectionIdBuf[0] == wLogicSecId) && (DIR_CONVERT == chLogSecLockSysDir)))
+			{
+				/*当前待查询逻辑区段锁闭方向与逻辑方向相同，则保护区段最后一个区段满足条件；与逻辑方向相反，保护区段第一个逻辑区段满足条件*/
+				retVal = CI_SUCCESS;
+			}
+			else
+			{
+				; /*可能相邻联锁数据，为空初始化失败*/
+			}
+		}
+		else
+		{
+			; /*可能相邻联锁进路，为空初始化失败*/
 		}
 	}
 	else

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

@@ -1104,9 +1104,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 +1156,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 +1171,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 +1183,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
@@ -1258,7 +1263,7 @@ void AddNearPhySec(const UINT16 wPhySecId)
 				else
 				{
 					/*待检查区域仍在本联锁和相邻RC发送范围*/
-					chAddCheck = CheckNearPhySec(dwNearSecBuf[jj], wPhySecId);
+					chAddCheck = CheckNearPhySec(dwNearSecBuf[jj], wPhySecId, wAdjacentPhySec);
 					chBelongCi = GetPhySecBelongCiId(dwNearSecBuf[jj]);
 					chCiType = GetCiType(chBelongCi);
 					if (CI_SUCCESS == chAddCheck)
@@ -1287,7 +1292,7 @@ void AddNearPhySec(const UINT16 wPhySecId)
 								}
 								else
 								{
-									chAddCheck = CheckNearPhySec(dwTwoStepNearSecBuf[kk], wPhySecId);
+									chAddCheck = CheckNearPhySec(dwTwoStepNearSecBuf[kk], wPhySecId, dwNearSecBuf[jj]);
 									/*暂不再查*/
 								}
 							}
@@ -1344,11 +1349,11 @@ UINT16* GetAdjacentPhySecBuf(const UINT16 wPhySecId)
 }
 /*
 * 功能描述：检查物理区段已有邻近范围内有无该区段 无则添加
-* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec，wPrePhySecId 间接区段的跳转区段
 * 返回值  ：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)
 {
 	UINT8 retValue = CI_SUCCESS;
 	UINT8 ii = 0U;
@@ -1356,10 +1361,7 @@ UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec)
 	UINT16* wAdjacentPhyBuf = NULL; /*直接相连区段数组*/
 	UINT16 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
 	UINT8 chNearSecNum = 0U; /*间接相邻数量*/
-	UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
 	UINT16 bufIndex = 0U;
-	UINT8 chCiType = 0U;
-	UINT8 chBelongCi = 0U;
 
 	bufIndex = GetPhySecConfigBufIndex(basePhysec);  /*获取区段数组下标*/
 	chAdjacentPhyNum = GetAdjacentPhySecNum(basePhysec);
@@ -1401,6 +1403,7 @@ UINT8 CheckNearPhySec(const UINT16 wPhySecId, const UINT16 basePhysec)
 	if ((CI_SUCCESS == retValue) &&(PHYSEC_INDIRECTNEAR_SEC_SUM_MAX>chNearSecNum))
 	{
 		PhysicalSectionConfigDataStru[bufIndex].IndirectNearPhySecBuf[chNearSecNum] = wPhySecId;
+		PhysicalSectionConfigDataStru[bufIndex].IndirectNearSecPreSec[chNearSecNum] = wPrePhySecId;
 		PhysicalSectionConfigDataStru[bufIndex].chNearPhySecNum++;
 	}
 	else
@@ -1464,7 +1467,6 @@ UINT8 PhySectionNearConfigDataManage(void)
 	UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
 	UINT8 chNearSecNum = 0U; /*间接相邻数量*/
 	UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
-	UINT8 chLocalCiType = GetLocalCiType();
 	UINT8 chLocal = GetSystemParaLocalCiId();
 	UINT8 chBelongCi = 0U;
 
@@ -1611,3 +1613,178 @@ 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
+	{
+		;/*不处理*/
+	}
+}
+
+/*
+* 功能描述：获取间接相邻区段检查的跳转区段
+* 参数说明： const UINT16 wPhySecId 物理区段 UINT16 wNearSecId
+* 返回值  ：无
+*Create fan 20260303
+*/
+UINT16 GetNearSecPreSecId(const UINT16 wPhySecId, UINT16 wNearSecId)
+{
+	UINT16 bufIndex = 0U;
+	UINT8 ii = 0U;
+	UINT16 retVal = 0U;
+	bufIndex = GetPhySecConfigBufIndex(wPhySecId);  /*获取区段数组下标*/
+	if (PHYSICAL_SECTION_SUM_MAX > bufIndex)
+	{
+		for (ii = 0U; ii < PhysicalSectionConfigDataStru[bufIndex].chNearPhySecNum; ii++)
+		{
+			if (wNearSecId == PhysicalSectionConfigDataStru[bufIndex].IndirectNearPhySecBuf[ii])
+			{
+				retVal = PhysicalSectionConfigDataStru[bufIndex].IndirectNearSecPreSec[ii];
+				break;
+			}
+			else
+			{
+				;/*继续*/
+			}
+		}
+	}
+	else
+	{
+		;/*不处理*/
+	}
+	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;
+}

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 (配置字段)*/
@@ -70,13 +77,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];  /*单位距离内内间接邻近物理区段数组*/
+	UINT16 IndirectNearSecPreSec[PHYSEC_INDIRECTNEAR_SEC_SUM_MAX];/*间接相邻区段的跳转路径*/
 	UINT8 chArbPossibleTag; /*是否能判Arb*/
 	UINT16 wIndexInAxle; /*在计轴系统中的索引*/
 } PhysicalSectionConfigDataStruct;
 
 
 
+
 typedef struct S_OC_PhysicalSectionConfigDataStruct
 {
 	UINT16 PhysicalSectionId;				/*物理区段ID(配置字段)*/
@@ -457,11 +467,11 @@ UINT8 GetAdjacentPhySecNum(const UINT16 wPhySecId);
 UINT16* GetAdjacentPhySecBuf(const UINT16 wPhySecId);
 /*
 * 功能描述：检查物理区段已有邻近范围内有无该区段 无则添加
-* 参数说明： const UINT16 wPhySecId，UINT16 basePhysec
+* 参数说明： const UINT16 wPhySecId 待检查区段，UINT16 basePhysec，wPrePhySecId 间接区段的跳转区段
 * 返回值  ：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);
 
 /*
 * 功能描述：获取物理区段范围内间接相邻区段数量
@@ -511,6 +521,37 @@ 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);
+
+/*
+* 功能描述：获取间接相邻区段检查的跳转区段
+* 参数说明： const UINT16 wPhySecId 物理区段 UINT16 wNearSecId
+* 返回值  ：无
+*Create fan 20260303
+*/
+UINT16 GetNearSecPreSecId(const UINT16 wPhySecId, 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);
 
 #ifdef __cplusplus
 }

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

@@ -364,4 +364,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/System/SystemConfigDefine.h

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

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

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

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

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

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

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

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

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

TSCP/src/DRV/imx8_drv_gpio.c

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

TSCP/src/DRV/imx8_drv_gpio.h

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

TSCP/src/MSCP/CFM/CFM_Net.c

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

TSCP/src/MSCP/DFM/DFM_DRV.h

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

TSCP/src/MSCP/DFM/DFM_DRV_QNX.c

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

TSCP/src/MSCP/MSCP_APP_API.c

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

TSCP/src/MSCP/MSCP_main.c

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

TSCP/src/MSCP/PFM/PFM_Cfg.c

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

TSCP/src/MSCP/PFM/PFM_Cfg.h

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

TSCP/src/MSCP/PFM/PFM_InputOutput.c

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

TSCP/src/MSCP/PFM/PFM_Log.c

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

TSCP/src/MSCP/PFM/PFM_Log.h

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

TSCP/src/MSCP/PFM/PFM_RemoteUpdate.c

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

TSCP/src/MSCP/SFM/SFM_2oo2.c

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

TSCP/src/MSCP/SFM/SFM_2x2.c

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

TSCP/src/MSCP/SFM/SFM_2x2.h

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

TSCP/src/MSCP/SFM/SFM_Prtcl.c

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

TSCP/src/dqu_common/dqu_cbtc_common/dquCbtcConfigData.c

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

TSCP/src/dqu_common/dqu_cbtc_common/dquCbtcConfigData.h

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

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

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

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

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