增加外网数据长度，包数，耗时打印

TSCP/src/APP/PU13_integration_config/ci_integrate_config.h

@@ -22,14 +22,14 @@
 
 
 
-/*预编译指令，用于文件的条件编译*/
+/*Ԥ����ָ������ļ�����������*/
 #ifndef _CI_INTEGRATE_CONFIG_H
 #define _CI_INTEGRATE_CONFIG_H
 
-/*手写版集成内核版本号*/
+/*��д�漯���ں˰汾��*/
-#define VER_INTE_PROJECT            220  /*项目编号*/
+#define VER_INTE_PROJECT            220  /*��Ŀ���*/
-#define VER_INTE_PRODUCT            40   /*产品编号*/
+#define VER_INTE_PRODUCT            40   /*��Ʒ���*/
-#define VER_INTE_EXE                1   /*可执行编号*/
+#define VER_INTE_EXE                99   /*��ִ�б��*/
-#define VER_INTE_TIME               101   /*集成次数编号*/
+#define VER_INTE_TIME               102  /*���ɴ������*/
 
-#endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/
+#endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/

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

@@ -2082,7 +2082,7 @@ void elm_SafeProtectProcess(void)
 		else
 		{
 			/** CT/UCT车飞车防护--宕机防护*/
-			elm_FlyingProtect();
+			/*elm_FlyingProtect();*/
 		}
 
 		/** 本OC范围内的计轴映射表合法性校验 */

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, devState, 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, devState, 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, devState, 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, devState, sendLevel);
 			reResult = CI_ERROR;
 		}
 	}

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

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

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

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

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

@@ -6704,7 +6704,7 @@ static UINT8 PackCiToIvocCommTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 		ii = *wDataLength;
 		chRetVal = CI_SUCCESS;
 		
-		wEnvelopeSum = elm_GetCTEnvelope(szEnvelopeIdBuf);
+		wEnvelopeSum = 0u;
 		if (ENVELOPE_SUM_MAX > wEnvelopeSum)
 		{
 			wEnvelopeSendSumIndex = ii;
@@ -6922,7 +6922,7 @@ static UINT8 PackCiToIvocFaultTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 		ii = *wDataLength;
 		chRetVal = CI_SUCCESS;
 
-		wEnvelopeSum = elm_GetFaultEnvelope(szEnvelopeIdBuf);
+		wEnvelopeSum = 0u;
 		if (ENVELOPE_SUM_MAX > wEnvelopeSum)
 		{
 			wEnvelopeSendSumIndex = ii;
@@ -9391,7 +9391,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 +9403,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 +9422,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 +9493,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 +9517,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条进路之间方向变化点数目为偶数，则锁闭方向不一致则资源对顶*/

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

@@ -7370,6 +7370,32 @@ UINT8 TransmitRelationDataStructInit(CHAR* FSName)
 		}
 		(void)TransmitRelationDataStruFrmSZ(Data);
 	}
+
+	/*默认车辆段RC与120个OC通信*/
+	for (j = 0u; j < dquCICfgDtStr.TrsmtRlsDtStrLen; j++)
+	{
+		if ((0x0CU == dquCICfgDtStr.TrsmtRlsDtStr[j].CiId) && (CI_SYSTEM_TYPE_OC == dquCICfgDtStr.TrsmtRlsDtStr[j].SystemType))
+		{
+			/*车辆段RC，为其添加120个OC*/
+			for (i = 0U; i < (TRANSMIT_OBJECT_DEVICE_SUM_MAX - 1U); i++)
+			{
+				if (i < 6)
+				{
+					dquCICfgDtStr.TrsmtRlsDtStr[j].DeviceIdBuf[i] = i + 24U;
+				}
+				else
+				{
+					dquCICfgDtStr.TrsmtRlsDtStr[j].DeviceIdBuf[i] = i + 25U;
+				}
+			}
+			dquCICfgDtStr.TrsmtRlsDtStr[j].DeviceSum = TRANSMIT_OBJECT_DEVICE_SUM_MAX - 1U;
+			break;
+		}
+		else
+		{
+		}
+	}
+
 	rtnValue = 1u;
 	return rtnValue;
 }

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/System/CiSystemDefine.h

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

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

@@ -60,9 +60,9 @@
 /*联锁V13.0版本升级数据结构 2018.8.3*/
 /*版本号*/
 #define VER_MAIN_SUBCI_CI_CID            ((UINT8)22)   /*子系统主版本号*/
-#define VER_SUB_SUBCI_CI_CID			 ((UINT8)0)	/*子系统子版本号*/
+#define VER_SUB_SUBCI_CI_CID			 ((UINT8)88)	/*子系统子版本号*/
-#define VER_BRUNCH_CI_CID			     ((UINT8)2)	/*分支版本号..........主线填0....分支填1 调试填2 */
+#define VER_BRUNCH_CI_CID			     ((UINT8)3)	/*分支版本号..........主线填0....分支填1 调试填2 */
-#define VER_RETURN_SUBCI_CI_CID			 ((UINT8)1)	/*子系统回归版本号*/
+#define VER_RETURN_SUBCI_CI_CID			 ((UINT8)0)	/*子系统回归版本号*/
 
 #ifdef SCADE_MODE
 /*SCADE软件版本号*/
@@ -74,9 +74,9 @@
 #else
 /*手写软件版本号*/
 #define VER_SOFT_PRODUCT            ((UINT8)40) /*产品编号*/
-#define VER_SOFT_MODUAL_APP             ((UINT8)1)  /*模块编号*/
+#define VER_SOFT_MODUAL_APP             ((UINT8)88)  /*模块编号*/
 #define VER_SOFT_MIANVERSION        ((UINT8)22)  /*主版本号*/
-#define VER_SOFT_SUBVERSION         ((UINT8)8) /*子版本号*/
+#define VER_SOFT_SUBVERSION         ((UINT8)9) /*子版本号*/
 
 #endif
 

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

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

TSCP/src/MSCP/MSCP_main.c

@@ -657,7 +657,7 @@ static void SelfCheckInit(void)
 {
 #ifdef QNX
     /*- 文件自检初始化 */
-    PFM_FileInit();
+    //PFM_FileInit();
 	/*- 内存自检初始化*/
     PFM_MemCheck_Init();
 	/*- CPU自检初始化*/

TSCP/src/MSCP/PFM/PFM_Log.c

@@ -456,7 +456,7 @@ void MSCP_REBOOT_ASSERT(unsigned int x, unsigned int MaintenanceFlag,unsigned sh
 		if(AutoReboot_Flag == 0x55u)
 		{
 			(void)printf("See You Later!!!\n");
-			(void)system("shutdown");
+			//(void)system("shutdown");
 			/*- 休眠等待重启 */
 			CM_Sleep(CM_UINT32_MAX);
 		}

TSCP/src/MSCP/SFM/SFM_Prtcl.c

@@ -1695,6 +1695,8 @@ void SFM_TxOutnetSafe(IN CM_UINT8 buf[], IN CM_UINT32 Len)
     CM_UINT32 tx_sn = 0u;
     CM_RE_ASSERT((allLen + 4u) == Len, PRTCL_MODE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_1);
     i = 4u;
+	CM_UINT32 cnt1 = 0u, cnt2 = 1u, len1 = 0u, len2 = 0u;
+	CM_UINT64 tmpStartTick = 0, UsedTime1 = 0, UsedTime2 = 0;
     /*- 循环遍历输出队列 */
     while ((i + 7u) < Len)
     {
@@ -1784,16 +1786,24 @@ void SFM_TxOutnetSafe(IN CM_UINT8 buf[], IN CM_UINT32 Len)
 			if (ENUM_CM_SEB == isSendExtendBoard)
 			{
 				/*- 向红网SE发送SE外网帧 */
+				cnt1++;
+				len1 += ccLen;
+				tmpStartTick = CM_GetTick();
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_EXTEND_RED);
 				/*- 向红网SE发送SE外网帧 */
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_EXTEND_BLUE);
+				UsedTime1 = UsedTime1 + (CM_GetTick() - tmpStartTick);
 			}
 			else if((ENUM_CM_CC == isSendExtendBoard) || (ENUM_CM_CCSEB == isSendExtendBoard))
 			{
 				/*- 向红网CC发送CC外网帧 */
+				cnt2++;
+				len2 += ccLen;
+				tmpStartTick = CM_GetTick();
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_RED);
 				/*- 向蓝网CC发送CC外网帧 */
 				(void)CFM_OutnetSafe_Send(s_Prtcl_UDP_Cache, ccLen, ENUM_OUTNET_BLUE);
+				UsedTime2 = UsedTime2 + (CM_GetTick() - tmpStartTick);
 			}
 			else
 			{
@@ -1845,6 +1855,7 @@ void SFM_TxOutnetSafe(IN CM_UINT8 buf[], IN CM_UINT32 Len)
         /*- 索引偏移至下一输出报文 */
         i += (CM_UINT32)CM_UNSIGNED_SHORT_EXP(msgLen + 2u);
     }
+	printf("test:send all len=%d(%d), cnt1=%d, len1=%d, time1=%lluus-----cnt2=%d, len2=%d, time2=%lluus\n", len1+len2, Len, cnt1, len1, UsedTime1 / 1000u, cnt2, len2, UsedTime2 / 1000u);
 }
 
 void SFM_PrtclBufSwitch(void)

TSCP/src/dqu_common/dqu_emap_common/dsuEmapDefine.h

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

TSCP/src/dqu_common/dqu_idmap_common/dquIdmapQuery.h

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

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

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

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

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

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

@@ -1,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/fsfb/common_fsfb/fsfbProtclStruct.h

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

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

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

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

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

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

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

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

@@ -147,19 +147,6 @@ UINT8 ProtclReceiveTcpStateFunc(UINT16 TcpStateDataLen,UINT8* pTcpStateData, Pro
 ************************************************************************/
 UINT8 ProtclSendTcpCtrlFunc(UINT16 *pTcpCtrlDataLen,UINT8 *pTcpCtrlData, ProtclConfigInfoStru *pUnifyInfo);
 
-/*
-*函数名:	AdjustRsspiVarArray
-*功能描述:	调整RSSPI链路,只保留指定的对方地址链路
-*输入参数:	UINT8 oppIdsNum 对方类型ID逻辑ID数量
-*			const UINT16 oppTypeIds[] 对方类型ID数组
-*			const UINT16 oppLogicIds[] 对方逻辑ID数组
-*			ProtclConfigInfoStru *pUnifyInfo 适配结构体变量
-*输入出参:	无
-*输出参数:	无
-*返回值:	无
-*/
-void AdjustRsspiVarArray(UINT8 oppIdsNum, const UINT16 oppTypeIds[], const UINT16 oppLogicIds[], ProtclConfigInfoStru *pUnifyInfo);
-
 /*
 *功能描述:	获取各网收到包数
 *输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
@@ -196,14 +183,10 @@ void ProtclGetSwapData(UINT8 swapData[], const UINT16 swapDataMaxLen, ProtclConf
 */
 void ProtclSetSwapData(UINT8 swapData[], ProtclConfigInfoStru* protcl);
 
-/*
+/**
-*函数名:	ProtclDelAllLink
+ * @brief ProtclDelAllLink 适配层删除所有链路
-*功能描述:	适配层删除所有链路
+ * @param protcl 适配层协议结构体变量 取值范围:参考结构体ProtclConfigInfoStru
-*输入参数:	ProtclConfigInfoStru* protcl 协议结构体变量
+ */
-*输入出参:	无
-*输出参数:	无
-*返回值:	无
-*/
 void ProtclDelAllLink(ProtclConfigInfoStru* protcl);
 
 /*

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

@@ -29,8 +29,8 @@ extern "C" {
 
 /****#类型定义#*************************************************************/
 /* 函数指针 */
-typedef UINT8  (*F_INIT)(UINT8*, UINT32, UINT8*, UINT8, ProtclConfigInfoStru*);       /* ˇâ×°ÖŽINITŔŕĐÍ */
+typedef UINT8  (*F_INIT)(UINT8*, UINT32, UINT8*, UINT16, ProtclConfigInfoStru*);       /* ˇâ×°ÖŽINITŔŕĐÍ */
-typedef UINT8  (*F_SND)(ProtclConfigInfoStru*, UINT8, UINT8*, UINT32*, UINT8*, UINT16*, UINT8*, UINT16*);  /* ˇâ×°ÖŽSNDŔŕĐÍ */
+typedef UINT8  (*F_SND)(ProtclConfigInfoStru*, UINT32, UINT8*, UINT32*, UINT8*, UINT16*, UINT8*, UINT16*);  /* ˇâ×°ÖŽSNDŔŕĐÍ */
 typedef UINT8  (* F_RCV)(QueueStruct*, ProtclConfigInfoStru*);  /* 封装之RCV类型 */
 typedef UINT8  (* F_LNK)(UINT8,UINT8,UINT16, ProtclConfigInfoStru*);   /* 封装之GETLNK类型 */
 typedef void   (*F_NETPKGNUM)(ProtclConfigInfoStru*, const UINT8, const UINT8, const UINT16, UINT16*, UINT16*);   /* 封装之NetsRecvPkgNum类型 */

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

@@ -71,7 +71,7 @@ extern "C" {
 	typedef struct
 	{
 		PROTCL_APP_TO_STRU* pProtclAppStru;
-		UINT8 DevDataCnt;
+		UINT32 DevDataCnt;
 	}PROTCL_SND_CFG_STRU;
 
 
@@ -116,7 +116,7 @@ extern "C" {
 		PROTCL_RCV_DATA_TYPE *RcvData; /*临时存放协议数据的结构体*/
 		PROTCL_APP_TO_STRU* pSndProtclAppStru; /*发送单帧相关信息*/
 		PROTCL_SND_CFG_STRU protclSndCfgStru[PROTCL_MGECFG_MAXCNT + 1];	/*发送相关信息结构体*/
-		UINT8 pProtclNumBuff[PROTCL_MGECFG_MAXCNT + 1];	/*各协议最大链路数*/
+		UINT16 pProtclNumBuff[PROTCL_MGECFG_MAXCNT + 1];	/*各协议最大链路数*/
 		UINT32 curDevRecordLen[PROTCL_MGECFG_MAXCNT];	/*本设备使用日志长度*/
 		DSU_PROTCL_TYPE_STRU protclTypeInfoStru;	/*查询函数相关信息结构体*/
 		UINT8 oppTypePtl[UINT8_MAX + 1]; /*与通信的对方设备类型协议数组*/
@@ -147,6 +147,7 @@ typedef struct
 	UINT16 RecordArraySize;			/* 协议记录数组大小 */
 	GlobalVar *GlobalVar;			/*用到的全局变量*/
 	UINT8 MaxNumPerCycle;           /*一周期允许每个对象的最大有效数据，由应用按文档在初始化时填写*/
+	UINT8 rpInterfaceType;          /*RP协议接口类型0x55:发送/接收标识为4字节;其他(默认值):发送/接收标识为2字节,初始化时设置*/
 }ProtclConfigInfoStru;
 
 #ifdef __cplusplus

TSCP/src/protocol/protocol_cbtc/common_protocol_config/protocolConfig.h

@@ -4,7 +4,7 @@
 * 版权说明  ：
 * 版本号    ：  1.0
 * 创建时间  ：  2019.03.07
-* 作者      ：  
+* 作者      ：
 * 功能描述  ：  此文件为协议适配层配置文件
 * 使用注意  ：
 				无
@@ -19,10 +19,7 @@
 /*#define CI_TASKLOCK*/			/*CI加taskLock()支持多线程*/
 
 #define USE_SFP	/*使用SFP*/
-#define USE_RP	/*使用RP*/
-#define USE_RSR	/*使用RSR*/
 #define USE_RSSPI /*使用RSSPI*/
-#define USE_RSSPII /*使用RSSPII*/
 #define USE_FSFB /*使用FSFB*/
 
 #endif

TSCP/src/protocol/redun_record_cbtc/common_dqu_rp/dsuRpFunc.c

@@ -17,60 +17,91 @@
 #include "dquDataTypeDefine.h"
 
 #define DSU_COMM_PROTCL_STRU_SIZE 3
+#define DSU_IP_INFO_STRU_SIZE 30 /*设备IP地址表列占字节长度*/
 
 DSU_BOOK_IP_INFO_STRU DsuBookIpInfoStru;     /*初始化之后用于保存初始化之后的数据的变量*/
 
-/*
+/**
-*函数名:	dsuIpInit
+ * @brief dsuIpInit 初始化读取数据参数
-*功能描述:	RP查询函数初始化
+ * @param pFsName FS文件 取值范围：字节数组
-*输入参数:	UINT8 *pFsName	FS文件
+ * @param interfaceType 接口类型 取值范围:0x55:发送/接收标识为4字节;其他(默认值):发送/接收标识为2字节
-*输入出参:	无
+ * @return 0:失败 1:成功
-*输出参数:	无
+ */
-*返回值:	1:成功;0失败
+UINT8 dsuIpInit(UINT8* pFsName, UINT8 interfaceType)
-*/
-UINT8 dsuIpInit(UINT8 *pFsName)
 {
-	UINT8 rtn = 0;	/*返回值*/
+	UINT8 rtn = 0U; /*-< 设置函数返回值为失败*/
-	UINT8 readRtn = 0;	/*读取FS返回值*/
+	UINT8 readRtn = 0U; /*调用函数返回值*/
-	UINT8 *pData = NULL;	/*读出的数据*/
+	UINT8* pData = NULL; /*读出的数据*/
-	UINT32 dataLen = 0;	/*读出的数据长度*/
+	UINT32 dataLen = 0U; /*读出的数据长度*/
-	UINT32 mallocLen = 0;	/*分配空间大小*/
+	UINT32 mallocLen = 0U; /*分配空间大小*/
-	UINT32 offset = 0;	/*数据偏移量*/
+	UINT32 offset = 0U;	/*-< 设置数据下标为0*/
-	UINT32 i = 0;	/*用于循环*/
+	UINT32 i = 0U; /*用于循环*/
 
-	if (NULL != pFsName)	/*输入参非空*/
+	if (NULL != pFsName) /*-< 输入参是否非空*/
 	{
-		readRtn = dquGetConfigData((CHAR*)pFsName, DSU_DEVICE_IP_CONFIG_TYPE, DSU_DATA_IP_COMM_PROTCL_ID, &pData, &dataLen);	/*读取设备通信协议表*/
+		readRtn = dquGetConfigData((CHAR*)pFsName, DSU_DEVICE_IP_CONFIG_TYPE, DSU_DATA_IP_COMM_PROTCL_ID, &pData, &dataLen); /*-< 调用函数读取设备通信协议表*/
-		if ((1 == readRtn) && (DSU_COMM_PROTCL_STRU_SIZE <= dataLen))
+		if ((1U == readRtn) && (DSU_COMM_PROTCL_STRU_SIZE <= dataLen) && (0U == (dataLen % DSU_COMM_PROTCL_STRU_SIZE))) /*-< 调用函数是否成功 且有数据行 且数据长度是行整数倍*/
 		{
-			DsuBookIpInfoStru.CommProtclStruLen = (UINT16)(dataLen / DSU_COMM_PROTCL_STRU_SIZE);  /*行数*/
+			DsuBookIpInfoStru.CommProtclStruLen = (UINT16)(dataLen / DSU_COMM_PROTCL_STRU_SIZE); /*-< 计算得到行数*/
-			mallocLen = sizeof(DSU_COMM_PROTCL_STRU)*(DsuBookIpInfoStru.CommProtclStruLen);	/*需分配空间大小*/
+			mallocLen = sizeof(DSU_COMM_PROTCL_STRU) * (DsuBookIpInfoStru.CommProtclStruLen); /*-< 计算需分配空间大小*/
-			DsuBookIpInfoStru.pCommProtclStru = (DSU_COMM_PROTCL_STRU*)malloc(mallocLen); /*为结构体申请空间*/
+			DsuBookIpInfoStru.pCommProtclStru = (DSU_COMM_PROTCL_STRU*)malloc(mallocLen); /*-< 调用函数分配空间*/
-			if (NULL != DsuBookIpInfoStru.pCommProtclStru)
+			if (NULL != DsuBookIpInfoStru.pCommProtclStru) /*-< 调用函数是否成功*/
 			{
-				CommonMemSet(DsuBookIpInfoStru.pCommProtclStru, mallocLen, 0, mallocLen);
+				CommonMemSet(DsuBookIpInfoStru.pCommProtclStru, mallocLen, 0, mallocLen); /*-< 清零设备通信协议表*/
 
-				for (i = 0; i < DsuBookIpInfoStru.CommProtclStruLen; i++)
+				for (i = 0U; i < DsuBookIpInfoStru.CommProtclStruLen; i++) /*-< 行下标是否小于行数*/
 				{
-					/*1字节本方类型*/
+					DsuBookIpInfoStru.pCommProtclStru[i].EmitterType = pData[offset]; /*-< 设置本方设备类型*/
-					DsuBookIpInfoStru.pCommProtclStru[i].EmitterType = pData[offset];
+					offset++; /*-< 数据下标自增1*/
-					offset++;
+
-					/*1字节对方类型*/
+					DsuBookIpInfoStru.pCommProtclStru[i].ReceptorType = pData[offset]; /*-< 设置对方设备类型*/
-					DsuBookIpInfoStru.pCommProtclStru[i].ReceptorType = pData[offset];
+					offset++; /*-< 数据下标自增1*/
-					offset++;
+
-					/*1字节协议类型*/
+					DsuBookIpInfoStru.pCommProtclStru[i].CommuType = pData[offset]; /*-< 设置协议类型*/
-					DsuBookIpInfoStru.pCommProtclStru[i].CommuType = pData[offset];
+					offset++; /*-< 数据下标自增1*/
-					offset++;
 				}
-				if (offset == dataLen)	/*设备通信协议表赋值成功*/
+				if (offset == dataLen) /*-< 数据下标是否等于表数据长度*/
 				{
-					rtn = 1;
+					rtn = 1U; /*-< 设置函数返回值为成功*/
+				}
+			}
+		}
+
+		if ((1U == rtn) && (INTERFACE_TYPE_FOUR == interfaceType)) /*-< 函数返回值是否成功 且接口类型是否发送/接收标识为4字节*/
+		{
+			rtn = 0U; /*-< 设置函数返回值为失败*/
+			offset = 0U; /*-< 设置数据下标为0*/
+
+			readRtn = dquGetConfigData((CHAR*)pFsName, DSU_DEVICE_IP_CONFIG_TYPE, DSU_DATA_IP_IP_ID, &pData, &dataLen); /*-< 调用函数读取设备IP配置表*/
+			if ((1U == readRtn) && (DSU_IP_INFO_STRU_SIZE <= dataLen) && (0U == (dataLen % DSU_IP_INFO_STRU_SIZE))) /*-< 调用函数是否成功 且有数据行 且数据长度是行整数倍*/
+			{
+				DsuBookIpInfoStru.devTypeIdHlhtIdLen = (UINT16)(dataLen / DSU_IP_INFO_STRU_SIZE); /*-< 计算得到行数*/
+				mallocLen = sizeof(DEV_TYPE_ID_HLHT_ID) * (DsuBookIpInfoStru.devTypeIdHlhtIdLen); /*-< 计算需分配空间大小*/
+				DsuBookIpInfoStru.pDevTypeIdHlhtId = (DEV_TYPE_ID_HLHT_ID*)malloc(mallocLen); /*-< 调用函数分配空间*/
+				if (NULL != DsuBookIpInfoStru.pDevTypeIdHlhtId) /*-< 调用函数是否成功*/
+				{
+					CommonMemSet(DsuBookIpInfoStru.pDevTypeIdHlhtId, mallocLen, 0, mallocLen); /*-< 清零设备通信协议表*/
+
+					for (i = 0; i < DsuBookIpInfoStru.devTypeIdHlhtIdLen; i++) /*-< 行下标是否小于行数*/
+					{
+						DsuBookIpInfoStru.pDevTypeIdHlhtId[i].devTypeId = ShortFromChar(&pData[offset]); /*-< 设置设备类型ID*/
+						offset += 2u; /*-< 数据下标自增2*/
+
+						DsuBookIpInfoStru.pDevTypeIdHlhtId[i].hlhtId = LongFromChar(&pData[offset]); /*-< 设置互联互通ID*/
+						offset += 4u; /*-< 数据下标自增4*/
+
+						offset += (DSU_IP_INFO_STRU_SIZE - 6u); /*-< 数据下标自增其余行长度*/
+					}
+					if (offset == dataLen) /*-< 数据下标是否等于表数据长度*/
+					{
+						rtn = 1U; /*-< 设置函数返回值为成功*/
+					}
 				}
 			}
 		}
 	}
 
-	return rtn;
+	return rtn; /*-< 返回函数返回值*/
 }
 
 /*
@@ -149,3 +180,53 @@ UINT8 dsurRpGetProtclType(UINT16 LocalName, UINT16 DestName,UINT8* protclTye)
 	chReturnValue =1;
 	return chReturnValue;
 }
+
+/**
+ * @brief GetHlhtId 根据设备类型ID获取互联互通ID
+ * @param devTypeId 设备类型ID 取值范围:0x0000-0xFFFF
+ * @return 互联互通ID 取值范围:0x00000000-0xFFFFFFFF
+ */
+UINT32 GetHlhtId(UINT16 devTypeId)
+{
+	UINT32 rtnVal = 0U; /*-< 设置调用函数返回值为0*/
+	UINT16 i = 0U; /*-< 设置设备类型ID对应互联互通ID数组下标为0*/
+
+	if (NULL != DsuBookIpInfoStru.pDevTypeIdHlhtId) /*-< 设备类型ID对应互联互通ID数组是否非空*/
+	{
+		for (i = 0U; i < DsuBookIpInfoStru.devTypeIdHlhtIdLen; i++) /*-< 设备类型ID对应互联互通ID数组下标是否小于设备类型ID对应互联互通ID数组长度*/
+		{
+			if (DsuBookIpInfoStru.pDevTypeIdHlhtId[i].devTypeId == devTypeId) /*-< 设置设备类型ID对应互联互通ID数组下标的设备类型ID是否等于传入的设备类型ID*/
+			{
+				rtnVal = DsuBookIpInfoStru.pDevTypeIdHlhtId[i].hlhtId; /*-< 设备类型ID对应互联互通ID数组下标的互联互通ID赋值给函数返回值*/
+				break; /*-< 退出遍历*/
+			}
+		}
+	}
+
+	return rtnVal; /*-< 返回函数返回值*/
+}
+
+/**
+ * @brief GetDevTypeId 根据互联互通ID获取设备类型ID
+ * @param hlhtId 互联互通ID 取值范围:0x00000000-0xFFFFFFFF
+ * @return 设备类型ID 取值范围:0x0000-0xFFFF
+ */
+UINT16 GetDevTypeId(UINT32 hlhtId)
+{
+	UINT16 rtnVal = 0U; /*-< 设置调用函数返回值为0*/
+	UINT16 i = 0U; /*-< 设置设备类型ID对应互联互通ID数组下标为0*/
+
+	if (NULL != DsuBookIpInfoStru.pDevTypeIdHlhtId) /*-< 设备类型ID对应互联互通ID数组是否非空*/
+	{
+		for (i = 0U; i < DsuBookIpInfoStru.devTypeIdHlhtIdLen; i++) /*-< 设备类型ID对应互联互通ID数组下标是否小于设备类型ID对应互联互通ID数组长度*/
+		{
+			if (DsuBookIpInfoStru.pDevTypeIdHlhtId[i].hlhtId == hlhtId) /*-< 设置设备类型ID对应互联互通ID数组下标的互联互通ID是否等于传入的互联互通ID*/
+			{
+				rtnVal = DsuBookIpInfoStru.pDevTypeIdHlhtId[i].devTypeId; /*-< 设备类型ID对应互联互通ID数组下标的设备类型ID赋值给函数返回值*/
+				break; /*-< 退出遍历*/
+			}
+		}
+	}
+
+	return rtnVal; /*-< 返回函数返回值*/
+}

TSCP/src/protocol/redun_record_cbtc/common_dqu_rp/dsuRpFunc.h

@@ -20,6 +20,8 @@ extern "C" {
 
 #include "CommonTypes.h"
 
+#define INTERFACE_TYPE_FOUR (0x55) /*接口类型0x55:发送/接收标识为4字节*/
+
 	/*设备通信协议表0x4002*/
 	typedef struct
 	{
@@ -28,22 +30,30 @@ extern "C" {
 		UINT8 CommuType;	/*所使用的通信协议，1为Sfp，2为Rp，3为Rsr，4为RSSPI,5为RSSPII*/
 	}DSU_COMM_PROTCL_STRU;
 
+	/*设备类型ID对应互联互通ID*/
+	typedef struct
+	{
+		UINT16 devTypeId; /*设备类型ID*/
+		UINT32 hlhtId; /*互联互通ID*/
+	}DEV_TYPE_ID_HLHT_ID;
+
 	/*设备通信协议表信息*/
 	typedef struct
 	{
 		UINT16 CommProtclStruLen;	/*设备通信协议表行数*/
 		DSU_COMM_PROTCL_STRU *pCommProtclStru;	/*设备通信协议表*/
+
+		UINT16 devTypeIdHlhtIdLen; /*设备类型ID对应互联互通ID数组长度*/
+		DEV_TYPE_ID_HLHT_ID* pDevTypeIdHlhtId; /*设备类型ID对应互联互通ID数组*/
 	}DSU_BOOK_IP_INFO_STRU;
 
-	/*
+	/**
-	*函数名:	dsuIpInit
+	 * @brief dsuIpInit 初始化读取数据参数
-	*功能描述:	RP查询函数初始化
+	 * @param pFsName FS文件 取值范围：字节数组
-	*输入参数:	UINT8 *pFsName	FS文件
+	 * @param interfaceType 接口类型 取值范围:0x55:发送/接收标识为4字节;其他(默认值):发送/接收标识为2字节
-	*输入出参:	无
+	 * @return 0:失败 1:成功
-	*输出参数:	无
+	 */
-	*返回值:	1:成功;0失败
+	UINT8 dsuIpInit(UINT8* pFsName, UINT8 interfaceType);
-	*/
-	UINT8 dsuIpInit(UINT8 *pFsName);
 
 	/*
 	*函数名:	dsuRpGetDevType
@@ -77,6 +87,20 @@ extern "C" {
 	*/
 	UINT8 dsurRpGetProtclType(UINT16 LocalName, UINT16 DestName, UINT8* protclTye);
 
+	/**
+	 * @brief GetHlhtId 根据设备类型ID获取互联互通ID
+	 * @param devTypeId 设备类型ID 取值范围:0x0000-0xFFFF
+	 * @return 互联互通ID 取值范围:0x00000000-0xFFFFFFFF
+	 */
+	UINT32 GetHlhtId(UINT16 devTypeId);
+
+	/**
+	 * @brief GetDevTypeId 根据互联互通ID获取设备类型ID
+	 * @param hlhtId 互联互通ID 取值范围:0x00000000-0xFFFFFFFF
+	 * @return 设备类型ID 取值范围:0x0000-0xFFFF
+	 */
+	UINT16 GetDevTypeId(UINT32 hlhtId);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/protocol/redun_record_cbtc/common_redun/RpInterface.h

@@ -18,9 +18,6 @@
 #define OUTPUT_EDITION		(OUTPUT_RESERVED+2)          /**/
 #define OUTPUT_TEXT_LEN		(OUTPUT_EDITION+1)          /**/
 #define OUTPUT_LOC_TYPEID		(OUTPUT_TEXT_LEN+2)          /**/
-#define OUTPUT_DEST_TYPEID	(OUTPUT_LOC_TYPEID+2)          /**/
-#define OUTPUT_SN			(OUTPUT_DEST_TYPEID+2)          /**/
-#define OUTPUT_TEXT			(OUTPUT_SN+4)          /**/
 
 #ifdef __cplusplus
 extern "C" {

TSCP/src/protocol/redun_record_cbtc/common_redun/RpPlatform.h

@@ -12,7 +12,6 @@
 
 #include "CommonTypes.h"
 #include "CommonQueue.h"
-#include "CommonStack.h"
 #include "RpStruct.h"
 #include "RpConfig.h"
 
@@ -26,6 +25,17 @@
 extern "C" {
 #endif
 
+	typedef void* STACK_DATA_TYPE_RP;
+
+	/*堆栈结构体定义*/
+	typedef struct
+	{
+		STACK_DATA_TYPE_RP* pStackData;         /*空闲节点值，表示的是存储数据的空间*/
+		UINT16  Top;          /*目前栈的大小.同时这个值也可以描述当前堆栈中,再填写元素要存放的下标.
+								由于本堆栈是一个顺序栈,因此顺序栈中此值应当是初始为零,
+								之后逐步增大,即从0到STACK_MAXSIZE-1.*/
+		UINT16  TotalSize;     /*此堆栈能够存放节点的最大数*/
+	} CommonStackRp;
 
 /*冗余层统一结构*/
 typedef struct  Rp_Info
@@ -50,20 +60,18 @@ typedef struct  Rp_Info
 	QueueStruct OutnetQueueB; 		/*冗余层内网接收队列B(内网->冗余蓝网队列)*/
 	UINT32 OutnetQueueSize; 		/*内网接收队列长度，由协议初始化时填写*/
 	RpSNLINK_STRU *SnLinkhead;	/*序列号缓冲链表头指针*/
-	CommonStack SnLnkStack;		/*序列号缓冲链表堆栈*/
+	CommonStackRp SnLnkStack;		/*序列号缓冲链表堆栈*/
 	UINT32  *pSnStack;				/*指向堆栈空间，释放空间时使用*/
 	UINT8 *Buff_Rp;				/*临时数据缓冲区*/
+	UINT8 interfaceType; /*接口类型0x55:发送/接收标识为4字节;其他(默认值):发送/接收标识为2字节,初始化时设置*/
 } RP_INFO_STRU ;
 
-/*************************************************************************
+/**
-* 功能描述:
+ * @brief RpInit 初始化RP
-*	通过该函数，实现冗余层内存空间分配
+ * @param fileName FS文件 取值范围:字节数组
-* 参数说明:
+ * @param pRpStruct RP实例 取值范围:参考结构体RP_INFO_STRU
-* 	 [in]RP_INFO_STRU *pRpStruct     冗余层同一结构体;	
+ * @return 0:失败 1:成功
-* 返回值:
+ */
-* 	return 1；正常返回
-* 	return 0；异常返回
-**************************************************************************/
 UINT8 RpInit(UINT8* fileName,RP_INFO_STRU *pRpStruct);
 
 /***********************************************************************
@@ -89,24 +97,18 @@ UINT8 RpLnkDelete(UINT16 devName,RP_INFO_STRU *pdelDevSn);
  ***************************************************************************************/
 UINT8 RpFreeSpace(RP_INFO_STRU *pRpStruct);
 
-/*****************************************************************************************
+/**
-*功能描述:
+ * @brief RpReceive RP输入处理
-*    从红蓝网交替接收数据，处理后写入DataToApp数组
+ * @param pRpStruct RP实例 取值范围:参考结构体RP_INFO_STRU
-*参数说明:
+ * @return 0:失败 1:成功
-*    RP_INFO_STRU *pRpStruct    统一结构体
+ */
-*返回值:
-*   正确返回1；错误返回0;                                                     
-*****************************************************************************************/
 UINT8 RpReceive(RP_INFO_STRU *pRpStruct);
 
-/*****************************************************************************************
+/**
-*功能描述:
+ * @brief RpOutput RP输出处理
-*    将应用传来的数据OutputDataQueue组帧，并将数据写入AppArray和VarArray数组中
+ * @param pRpStruct RP实例 取值范围:参考结构体RP_INFO_STRU
-*参数说明:
+ * @return 0:失败 1:成功
-*    RP_INFO_STRU *pRpStruct    统一结构体
+ */
-*返回值:
-*   正确返回1；错误返回0;                                                     
-*****************************************************************************************/
 UINT8 RpOutput(RP_INFO_STRU *pRpStruct);
 
 /*****************************************************************************************
@@ -121,6 +123,12 @@ UINT8 RpOutput(RP_INFO_STRU *pRpStruct);
 *****************************************************************************************/
 UINT8 RpRefresh(UINT16 sLen_Input, UINT8 *Input_Data_LnkMes,RP_INFO_STRU *pRpStruct);
 
+/**
+ * @brief RpDelAllLink RP删除所有链路
+ * @param rp RP结构体变量 取值范围:参考结构体RP_INFO_STRU
+ */
+void RpDelAllLink(RP_INFO_STRU* rp);
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/protocol/redun_record_cbtc/common_redun/RpStruct.h

@@ -10,7 +10,6 @@
 
 #include "CommonTypes.h"
 #include "CommonQueue.h"
-#include "CommonStack.h"
 
 #ifdef __cplusplus
 extern "C" {

TSCP/src/protocol/rssp2_record_cbtc/dqu_rsspii_cbtc/dsuRssp2Func.c

@@ -330,6 +330,9 @@ UINT8 dquDevName2EtcsId(IN UINT16 DevName, IN UINT16 LogId, OUT UINT32 *pEtcsId)
 				}
 			}
 			break;
+		case DEVTYPE_RC:
+			ret = dquQueryOutDevId(QFUN_IDMAP_RC_ID, devId, &hlhtId);
+			break;
 		case DEVTYPE_VOBC:
 			ret = dquVobcName2OutDevId(DevName, (UINT8)LogId, &hlhtId);
 			break;

TSCP/src/protocol/rssp_record_cbtc1/common_dqu_rssp/dsuRsspDataStru.h

@@ -82,18 +82,27 @@ extern "C" {
 		UINT16	CiRowNum;	/*CI编号对照表行数*/
 		DSU_DEV_HLHTID *CiHlhtids;	/*CI编号对照表*/
 
+		UINT16	RcRowNum;	/*RC编号对照表行数*/
+		DSU_DEV_HLHTID* RcHlhtids;	/*RC编号对照表*/
+
 		UINT16	AtsRowNum;	/*ATS编号对照表行数*/
 		DSU_DEV_HLHTID *AtsHlhtids;	/*ATS编号对照表*/
 
 		UINT16	VobcRowNum;	/*VOBC编号对照表行数*/
 		DSU_DEV_HLHTID *VobcHlhtids;	/*VOBC编号对照表*/
 
+		UINT16	IvocRowNum;	/*IVOC编号对照表行数*/
+		DSU_DEV_HLHTID* IvocHlhtids;	/*IVOC编号对照表*/
+
 		UINT16	DsuRowNum;	/*DSU编号对照表行数*/
 		DSU_DEV_HLHTID *DsuHlhtids;	/*DSU编号对照表*/
 
 		UINT16	AomRowNum;	/*AOM编号对照表行数*/
 		DSU_DEV_HLHTID *AomHlhtids;	/*AOM编号对照表*/
 
+		UINT16	IvocAomRowNum;	/*IVOC-AOM编号对照表行数*/
+		DSU_DEV_HLHTID* IvocAomHlhtids;	/*IVOC-AOM编号对照表*/
+
 		UINT16	TdtRowNum;	/*TDT编号对照表行数*/
 		DSU_DEV_HLHTID *TdtHlhtids;	/*TDT编号对照表*/
 

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspCommonWl.c

@@ -803,21 +803,21 @@ UINT16 ComputeMsgCRC16_WL(const UINT8* pData, UINT16 size)
  *	参数名		类型		输入输出	描述
  *  --------------------------------------------------------------
  *	pDestAdd	UINT8 *		INOUT		内存空间开始地址
- *  Len			UINT16		IN			内存空间大小
+ *  Len			UINT32		IN			内存空间大小
  *	Val			UINT8		IN			指定值	
  * 
  * 返回值   : 1 正常
  ***********************************************************************/
-UINT8 RsspMemSet_WL(UINT8 *pDestAdd, UINT16 Len, UINT8 Val)
+UINT8 RsspMemSet_WL(UINT8* pDestAdd, UINT32 Len, UINT8 Val)
 {
-    UINT16 index = 0;
+	UINT32 index = 0u;
-	
-    for(index = 0; index < Len; index++)
-    {
-	    pDestAdd[index] = Val;
-    }
 
-	return (UINT8)1;
+	for (index = 0u; index < Len; index++)
+	{
+		pDestAdd[index] = Val;
+	}
+
+	return (UINT8)1u;
 }
 
 /***********************************************************************

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspCommonWl.h

@@ -30,7 +30,9 @@
 /* 类型 */
 #define RSSP_TYPE_VOBC_BACK_WL (0x13) /*VOBC-备用通道*/
 #define RSSP_TYPE_VOBC_WL	0x14	/*VOBC*/
+#define RSSP_TYPE_IVOC_WL	(0x10u)	/*IVOC*/
 #define RSSP_TYPE_AOM_WL	0x15	/*AOM*/
+#define RSSP_TYPE_IVOC_AOM_WL (0x11u)	/*IVOC-AOM*/
 #define RSSP_TYPE_ATS_WL	0x03	/*ATS*/
 #define RSSP_TYPE_TTIL_WL   0x17	/*列尾*/
 
@@ -98,9 +100,9 @@
 #define RP_LINK_LEN (14)	/*冗余层链路长度*/
 
 #ifdef RSSPI_SIMPLE_LINK_REFRESH
-#define RSSP_VAR_NODE_LEN_WL (58) /*简单链路刷新,中间变量数组一个节点的长度*/
+#define RSSP_VAR_NODE_LEN_WL (59) /*简单链路刷新,中间变量数组一个节点的长度*/
 #else
-#define RSSP_VAR_NODE_LEN_WL (87) /*中间变量数组一个节点的长度*/
+#define RSSP_VAR_NODE_LEN_WL (88) /*中间变量数组一个节点的长度*/
 #endif
 
 #ifdef __cplusplus
@@ -319,20 +321,19 @@ UINT32 CRC_Compute_Crc_WL(const UINT8* pData, UINT16 size, UINT8 chan);
  ***********************************************************************/
 UINT16 ComputeMsgCRC16_WL(const UINT8* pData, UINT16 size);
 
-
 /***********************************************************************
- * 方法名   : RsrMemSet
+ * 方法名   : RsspMemSet_WL
  * 功能描述 : 对指定内存设定指定的值
- * 输入参数 : 
+ * 输入参数 :
- *	参数名		类型				输入输出		描述
+ *	参数名		类型		输入输出	描述
  *  --------------------------------------------------------------
- *	pDestAdd	UINT8 *			INOUT		内存空间开始地址
+ *	pDestAdd	UINT8 *		INOUT		内存空间开始地址
- *  Len			UINT16			IN			内存空间大小
+ *  Len			UINT32		IN			内存空间大小
- *	Val			UINT8			IN			指定值													
+ *	Val			UINT8		IN			指定值
- * 
+ *
- * 返回值   : 无
+ * 返回值   : 1 正常
  ***********************************************************************/
-UINT8 RsspMemSet_WL(UINT8 *pDestAdd, UINT16 Len, UINT8 Val);
+UINT8 RsspMemSet_WL(UINT8* pDestAdd, UINT32 Len, UINT8 Val);
 
 /***********************************************************************
  * 方法名   : RsrMemSet

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspIFWl.h

@@ -43,16 +43,11 @@ UINT8 RsspReceive_WL(RSSP_INFO_STRU* rssp);
  */
 UINT8 RsspOutput_WL(QueueStruct *AppToRs,UINT8 *VarArray,RSSP_INFO_STRU *pRsspStru);
 
-/***********************************************************************
+/**
- * 方法名   : RsspInit_WL
+* @brief RsspInit_WL RSRSP初始化
- * 功能描述 : 通过该函数，实现对RSSP层的初始化函数。根据应用设定的基本值，计算各队列的大小。
+* @param pRsspStruct RSSPI实例 取值范围:参考结构体RSSP_INFO_STRU
- * 输入参数 : 
+* @return 0:失败 1:成功
- *	参数名				类型							输入输出		描述
+*/
- *  --------------------------------------------------------------
- *	pRsspStruct  RSSP_INFO_STRU*	INOUT			RSSP层统一结构体，需进行初始值设置。
- * 
- * 返回值   : UINT8  1：正常返回  0：错误返回
- ***********************************************************************/
 UINT8 RsspInit_WL(RSSP_INFO_STRU *pRsspStruct);
 
 /***********************************************************************

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspInitWl.c

@@ -27,107 +27,104 @@
 extern "C" {
 #endif
 
-/***********************************************************************
+ /**
- * 方法名   : RsspInit_WL
+* @brief RsspInit_WL RSRSP初始化
- * 功能描述 : 通过该函数，实现对RSRSP的初始化函数。根据应用设定的基本值，计算各队列的大小。
+* @param pRsspStruct RSSPI实例 取值范围:参考结构体RSSP_INFO_STRU
- * 输入参数 : 
+* @return 0:失败 1:成功
- *	参数名				类型							输入输出		描述
+*/
- *  --------------------------------------------------------------
- *	pRsspStruct  RSSP_INFO_STRU*	INOUT			RSSP层统一结构体，需进行初始值设置。
- * 
- * 返回值   : UINT8  1：正常返回  0：错误返回
- ***********************************************************************/
 	UINT8 RsspInit_WL(RSSP_INFO_STRU* pRsspStruct)
 	{
-		UINT8 rtn = 0; /*返回值*/
+		/*- 定义局部变量*/
+		UINT8 rtn = 0; /*-< 设置函数返回值为失败*/
 		UINT32 mallocLen = 0u; /*分配空间长度*/
 
-		if (NULL != pRsspStruct) /*参数非空判断*/
+		if (NULL != pRsspStruct) /*-< 参数是否非空*/
 		{
 			/*记录数组分配空间*/
-			pRsspStruct->RecordArray = (UINT8*)malloc(pRsspStruct->RecordArraySize + 2);
+			pRsspStruct->RecordArray = (UINT8*)malloc(pRsspStruct->RecordArraySize + 2); /*-< 分配日志数组*/
-			if (NULL != pRsspStruct->RecordArray)
+			if (NULL != pRsspStruct->RecordArray) /*-< 分配成功*/
 			{
-				CommonMemSet(pRsspStruct->RecordArray, sizeof(UINT8) * (pRsspStruct->RecordArraySize + 2), 0, sizeof(UINT8) * (pRsspStruct->RecordArraySize + 2));
+				CommonMemSet(pRsspStruct->RecordArray, sizeof(UINT8) * (pRsspStruct->RecordArraySize + 2), 0, sizeof(UINT8) * (pRsspStruct->RecordArraySize + 2)); /*-< 清零日志数组*/
 
 				/*输出协议给应用数组AppArray分配空间*/
-				pRsspStruct->AppArraySize = (pRsspStruct->OutputSize + RSSP_FIXED_LEN_WL + 14 + 26) * (pRsspStruct->MaxNumLink) + 2;
+				pRsspStruct->AppArraySize = (pRsspStruct->OutputSize + RSSP_FIXED_LEN_WL + 14 + 26) * (pRsspStruct->MaxNumLink) + 2; /*-< 得到应用数组长度*/
-				pRsspStruct->AppArray = (UINT8*)malloc(pRsspStruct->AppArraySize);
+				pRsspStruct->AppArray = (UINT8*)malloc(pRsspStruct->AppArraySize); /*-< 分配应用数组*/
-				if (NULL != pRsspStruct->AppArray)
+			}
+			if (NULL != pRsspStruct->AppArray) /*-< 分配成功*/
+			{
+				CommonMemSet(pRsspStruct->AppArray, sizeof(UINT8) * pRsspStruct->AppArraySize, 0, sizeof(UINT8) * pRsspStruct->AppArraySize); /*-< 清零应用数组*/
+
+				/*链路数组分配空间*/
+				pRsspStruct->VarArraySize = RSSP_VAR_NODE_LEN_WL * pRsspStruct->MaxNumLink + 32 + 14 * (pRsspStruct->MaxNumLink + 2) + 32; /*-< 得到链路数组长度*/
+				pRsspStruct->VarArray = (UINT8*)malloc(pRsspStruct->VarArraySize); /*-< 分配链路数组*/
+			}
+			if (NULL != pRsspStruct->VarArray) /*-< 分配成功*/
+			{
+				CommonMemSet(pRsspStruct->VarArray, sizeof(UINT8) * pRsspStruct->VarArraySize, 0, sizeof(UINT8) * pRsspStruct->VarArraySize); /*-< 清零链路数组*/
+
+				/*数据帧分配空间*/
+				pRsspStruct->FrameDataMaxLen = 2 + 8 + RSSP_FIXED_LEN_WL + 32 + (pRsspStruct->InputSize > pRsspStruct->OutputSize ? pRsspStruct->InputSize : pRsspStruct->OutputSize); /*-< 得到数据帧数组长度*/
+				pRsspStruct->FrameData = (UINT8*)malloc(pRsspStruct->FrameDataMaxLen); /*-< 分配数据帧数组*/
+			}
+			if (NULL != pRsspStruct->FrameData) /*-< 分配成功*/
+			{
+				CommonMemSet(pRsspStruct->FrameData, sizeof(UINT8) * pRsspStruct->FrameDataMaxLen, 0, sizeof(UINT8) * pRsspStruct->FrameDataMaxLen); /*-< 清零数组帧数组*/
+
+				/*数据堆栈链表分配空间*/
+				rtn = InitMsgNodeStack_WL(pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2) * 2, pRsspStruct->FrameDataMaxLen, &pRsspStruct->StackOfDataLink); /*-< 调用函数初始化链路堆栈链表*/
+				if (1 == rtn) /*-< 调用函数是否成功*/
 				{
-					CommonMemSet(pRsspStruct->AppArray, sizeof(UINT8) * pRsspStruct->AppArraySize, 0, sizeof(UINT8) * pRsspStruct->AppArraySize);
+					rtn = InitLnkNodeArr_WL(pRsspStruct->MaxNumLink, pRsspStruct); /*-< 调用函数初始化链路链路节点*/
-
+				}
-					/*链路数组分配空间*/
+				if (1 == rtn) /*-< 调用函数是否成功*/
-					pRsspStruct->VarArraySize = RSSP_VAR_NODE_LEN_WL * pRsspStruct->MaxNumLink + 32 + 14 * (pRsspStruct->MaxNumLink + 2) + 32;
+				{
-					pRsspStruct->VarArray = (UINT8*)malloc(pRsspStruct->VarArraySize);
+					rtn = 0; /*-< 设置函数返回值为失败*/
-					if (NULL != pRsspStruct->VarArray)
+					pRsspStruct->OutnetQueueSize = (pRsspStruct->OutputSize + 8) * pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2); /*-< 得到输入数据队列长度*/
+					rtn = QueueInitial(&pRsspStruct->OutnetQueueA, pRsspStruct->OutnetQueueSize); /*-< 初始化红网队列长度*/
+					if (1 == rtn) /*-< 调用函数是否成功*/
 					{
-						CommonMemSet(pRsspStruct->VarArray, sizeof(UINT8) * pRsspStruct->VarArraySize, 0, sizeof(UINT8) * pRsspStruct->VarArraySize);
+						rtn = QueueInitial(&pRsspStruct->OutnetQueueB, pRsspStruct->OutnetQueueSize); /*-< 初始化蓝网队列*/
-
-						/*数据帧分配空间*/
-						pRsspStruct->FrameDataMaxLen = 2 + 8 + RSSP_FIXED_LEN_WL + 32 + (pRsspStruct->InputSize > pRsspStruct->OutputSize ? pRsspStruct->InputSize : pRsspStruct->OutputSize);
-						pRsspStruct->FrameData = (UINT8*)malloc(pRsspStruct->FrameDataMaxLen);
-						if (NULL != pRsspStruct->FrameData)
-						{
-							CommonMemSet(pRsspStruct->FrameData, sizeof(UINT8) * pRsspStruct->FrameDataMaxLen, 0, sizeof(UINT8) * pRsspStruct->FrameDataMaxLen);
-
-							/*数据堆栈链表分配空间*/
-							rtn = InitMsgNodeStack_WL(pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2) * 2, pRsspStruct->FrameDataMaxLen, &pRsspStruct->StackOfDataLink);
-							if (1 == rtn) /*链路节点分配空间*/
-							{
-								rtn = InitLnkNodeArr_WL(pRsspStruct->MaxNumLink, pRsspStruct);
-							}
-							if (1 == rtn) /*输入应用给协议数据队列分配空间*/
-							{
-								rtn = 0; /*默认返回0*/
-								pRsspStruct->OutnetQueueSize = (pRsspStruct->OutputSize + 8) * pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2);
-								rtn = QueueInitial(&pRsspStruct->OutnetQueueA, pRsspStruct->OutnetQueueSize);
-								if (1 == rtn)
-								{
-									rtn = QueueInitial(&pRsspStruct->OutnetQueueB, pRsspStruct->OutnetQueueSize);
-								}
-							}
-							if (1 == rtn) /*输入协议给应用数据队列分配空间*/
-							{
-								pRsspStruct->DataToAppSize = (pRsspStruct->InputSize + 6) * pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2);
-								rtn = QueueInitial(&pRsspStruct->DataToApp, pRsspStruct->DataToAppSize);
-							}
-							if (1 == rtn) /*输出应用给协议数据队列分配空间*/
-							{
-								pRsspStruct->OutputDataQueueSize = (pRsspStruct->OutputSize + 8) * pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2);
-								rtn = QueueInitial(&pRsspStruct->OutputDataQueue, pRsspStruct->OutputDataQueueSize);
-							}
-							if (1 == rtn) /*输出应用给协议数据队列分配空间*/
-							{
-								rtn = 0; /*默认返回0*/
-								/*无应用发送数据个数默认值为3*/
-								pRsspStruct->NoSendAppData = NONE_SEND_APP_DATA_WL;
-
-								pRsspStruct->NetsRecvPkgNums = (RsppiNetsRecvPkgNum*)malloc(sizeof(RsppiNetsRecvPkgNum) * pRsspStruct->MaxNumLink);
-								if (NULL != pRsspStruct->NetsRecvPkgNums)
-								{
-									CommonMemSet(pRsspStruct->NetsRecvPkgNums, sizeof(RsppiNetsRecvPkgNum) * pRsspStruct->MaxNumLink, 0, sizeof(RsppiNetsRecvPkgNum) * pRsspStruct->MaxNumLink);
-
-									mallocLen = sizeof(UINT8) * ((pRsspStruct->OutputSize > pRsspStruct->InputSize) ? pRsspStruct->OutputSize : pRsspStruct->InputSize);
-									mallocLen += 32u;
-									pRsspStruct->gpSendSingleOutMsg = (UINT8*)malloc(mallocLen);
-									if (NULL != pRsspStruct->gpSendSingleOutMsg)
-									{
-										CommonMemSet(pRsspStruct->gpSendSingleOutMsg, mallocLen, 0u, mallocLen);
-
-										rtn = 1; /*初始化正常*/
-									}
-
-								}
-
-							}
-						}
 					}
 				}
+				if (1 == rtn) /*-< 调用函数是否成功*/
+				{
+					pRsspStruct->DataToAppSize = (pRsspStruct->InputSize + 6) * pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2); /*-< 得到到应用数据队列长度*/
+					rtn = QueueInitial(&pRsspStruct->DataToApp, pRsspStruct->DataToAppSize); /*-< 初始化到应用数据队列*/
+				}
+				if (1 == rtn) /*-< 调用函数是否成功*/
+				{
+					pRsspStruct->OutputDataQueueSize = (pRsspStruct->OutputSize + 8) * pRsspStruct->MaxNumLink * (pRsspStruct->MaxNumPerCycle + 2); /*-< 得到输出数据队列长度*/
+					rtn = QueueInitial(&pRsspStruct->OutputDataQueue, pRsspStruct->OutputDataQueueSize); /*-< 初始化输出数据队列*/
+				}
+				if (1 == rtn) /*-< 调用函数是否成功*/
+				{
+					rtn = 0; /*-< 设置函数返回值为失败*/
+					/*无应用发送数据个数默认值为3*/
+					pRsspStruct->NoSendAppData = NONE_SEND_APP_DATA_WL; /*-< 设置输出时无应用给协议应用数据周期数*/
+
+					pRsspStruct->NetsRecvPkgNumsLen = 0u; /*-< 设置各网收到包数数组长度为0*/
+					pRsspStruct->NetsRecvPkgNums = (RsppiNetsRecvPkgNum*)malloc(sizeof(RsppiNetsRecvPkgNum) * pRsspStruct->MaxNumLink); /*-< 分配各网收到包数数组*/
+					if (NULL != pRsspStruct->NetsRecvPkgNums) /*-< 分配成功*/
+					{
+						CommonMemSet(pRsspStruct->NetsRecvPkgNums, sizeof(RsppiNetsRecvPkgNum) * pRsspStruct->MaxNumLink, 0, sizeof(RsppiNetsRecvPkgNum) * pRsspStruct->MaxNumLink); /*-< 清零各网收到包数数组*/
+
+						mallocLen = sizeof(UINT8) * ((pRsspStruct->OutputSize > pRsspStruct->InputSize) ? pRsspStruct->OutputSize : pRsspStruct->InputSize); /*-< 得到应用长度*/
+						mallocLen += 32u; /*-< 得到应用加帧头长度*/
+						pRsspStruct->gpSendSingleOutMsg = (UINT8*)malloc(mallocLen); /*-< 分配应用加帧头数组*/
+						if (NULL != pRsspStruct->gpSendSingleOutMsg) /*-< 分配成功*/
+						{
+							CommonMemSet(pRsspStruct->gpSendSingleOutMsg, mallocLen, 0u, mallocLen); /*-< 清零应用加帧头数组*/
+
+							rtn = 1; /*-< 设置函数返回值为成功*/
+						}
+
+					}
+
+				}
 			}
 		}
 
-		return rtn;
+		return rtn; /*-< 返回函数返回值*/
 	}
 
 /***********************************************************************

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspLnkNodeMgrWl.c

@@ -38,7 +38,7 @@ extern "C" {
  *--------------------------------------------------------------------*/
 static UINT8 InitRsspLnkInfoWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf, const DSU_RSSP_LINK_SINFO_STRU_WL* pOutputDsuLnkInf, RsspLinkInfoStru_WL* pRsspLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi);
 static UINT8 SetNodeParamWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf, const DSU_RSSP_LINK_SINFO_STRU_WL* pOutputDsuLnkInf, NodeParamInfoStru_WL *pNodeParam);
-static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UINT8 lnkNodeIdx, UINT8* VarArray);
+static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UINT16 lnkNodeIdx, UINT8* VarArray);
 static void VarArray2LnkNodeInfo_WL(const UINT8* VarArray, Lnk_Info_Node_Stru_WL* pNode);
 static UINT8 CheckRecvDsuLnkInfoWl(UINT16 LocalDevName, const DataNode_WL *pNode, const DSU_RSSP_LINK_RINFO_STRU_WL *pRecvLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi);
 static UINT8 CheckOutputDsuLnkInfoWl(UINT16 LocalDevName, const DataNode_WL *pNode, const DSU_RSSP_LINK_SINFO_STRU_WL *pOutputLnkInfo, DSU_RSSP_INFO_STRU_WL *pDsuRsspi);
@@ -139,15 +139,16 @@ UINT8 RsspLnkDelete_WL(UINT32 destDevName,RSSP_INFO_STRU *pRsspStruct)
   */
 UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRsspStruct)
 {
+	/*- 定义局部变量*/
 	UINT8 ret = 1u; /*-< 设置函数返回值为成功*/
 
 	UINT8 NodeLen = 0u; /*设置节点长度为0*/
-	UINT8 NodeNum = 0u; /*设置节点数量为0*/
+	UINT16 NodeNum = 0u; /*设置节点数量为0*/
-	UINT8 index = 0u; /*设置数量下标为0*/
+	UINT16 index = 0u; /*设置数量下标为0*/
 	UINT16 offset = 0u; /*设置数据下标为0*/
 	DSU_RSSP_LINK_RINFO_STRU_WL recvLnkInfo; /*本方作为接收方时候的节点基本信息*/
 	DSU_RSSP_LINK_SINFO_STRU_WL outputLnkInfo; /*本方作为发送方时候的节点基本信息*/
-	UINT8 lnkNodeIdx = 0u; /*设置链路节点下标为0*/
+	UINT16 lnkNodeIdx = 0u; /*设置链路节点下标为0*/
 
 	NodeLen = RSSP_VAR_NODE_LEN_WL; /*-< 设置函数返回值为成功*/
 	if ((0u == (VarLen % NodeLen)) && (UINT8_MAX >= (VarLen / NodeLen))) /*-< 链路数据长度是否单节点链路长度整数倍 且小于UINT8_MAX值*/
@@ -177,7 +178,7 @@ UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRssp
 	{
 		for (index = 0; index < NodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
 		{
-			lnkNodeIdx = VarArray[offset]; /*-< 设置链路节点下标为要刷链路节点下标*/
+			lnkNodeIdx = ShortFromChar(&VarArray[offset]); /*-< 设置链路节点下标为要刷链路节点下标*/
 			if (lnkNodeIdx < pRsspStruct->LnkNodeNum) /*-< 要刷当前链路节点下标是否小于最大链路数*/
 			{
 				VarArray2LnkNodeInfo_WL(&VarArray[offset], &pRsspStruct->LnkNodeArr[lnkNodeIdx]); /*-< 调用设置链路节点数据函数*/
@@ -221,8 +222,8 @@ UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRssp
 			else
 			{
 				PrintRecArray2ByteB(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, 0x8801u); /*-< 记录刷新链路下标错误日志*/
-				PrintRecArrayByte(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, lnkNodeIdx); /*-< 记录刷新链路标志日志*/
+				PrintRecArray2ByteB(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, lnkNodeIdx); /*-< 记录刷新链路标志日志*/
-				PrintRecArrayByte(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, pRsspStruct->LnkNodeNum); /*-< 记录刷新链路标志日志*/
+				PrintRecArray2ByteB(pRsspStruct->RecordArray, pRsspStruct->RecordArraySize, pRsspStruct->LnkNodeNum); /*-< 记录刷新链路标志日志*/
 
 				return 0u; /*-< 返回函数失败*/
 			}
@@ -251,7 +252,7 @@ UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRssp
  * 
  * 返回值   : 无
  ***********************************************************************/
- void GetLnkNodeArr_WL(Lnk_Info_Node_Stru_WL** pLnkInfoNodeArr,UINT8 *OutLen,RSSP_INFO_STRU *pRsspStruct)
+ void GetLnkNodeArr_WL(Lnk_Info_Node_Stru_WL** pLnkInfoNodeArr,UINT16 *OutLen,RSSP_INFO_STRU *pRsspStruct)
 {
 	*pLnkInfoNodeArr = pRsspStruct->LnkNodeArr;	
 	*OutLen = pRsspStruct->LnkNodeNum;
@@ -263,10 +264,11 @@ UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRssp
  * @param pRsspStruct RSSPI实例 取值范围:参考结构体:RSSP_INFO_STRU
  * @return 0:失败 1:成功
  */
- UINT8 InitLnkNodeArr_WL(UINT8 num, RSSP_INFO_STRU* pRsspStruct)
+ UINT8 InitLnkNodeArr_WL(UINT16 num, RSSP_INFO_STRU* pRsspStruct)
  {
+	 /*- 定义局部变量*/
 	 UINT8 ret = 1u; /*-< 设置函数返回值为成功*/
-	 UINT8 index = 0u; /*链路数下标*/
+	 UINT16 index = 0u; /*链路数下标*/
 	 UINT32 lnkNodeArrSize = 0u; /*链路数组长度*/
 	 pRsspStruct->LnkNodeNum = num; /*-< 设置链路数给RSSPI实例链路数*/
 	 lnkNodeArrSize = sizeof(Lnk_Info_Node_Stru_WL) * pRsspStruct->LnkNodeNum; /*-< 计算链路数组长度*/
@@ -278,13 +280,14 @@ UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRssp
 	 else
 	 {
 		 RsspMemSet_WL((UINT8*)pRsspStruct->LnkNodeArr, lnkNodeArrSize, 0); /*-< 清零链路数据数组*/
-	 }
-	 for (index = 0u; index < pRsspStruct->LnkNodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
-	 {
-		 pRsspStruct->LnkNodeArr[index].NodeStatus = Replace_WL; /*-< 设置当前链路节点为不可用*/
 
-		 pRsspStruct->LnkNodeArr[index].RecvKeepHaltCycleNum = 0u; /*-< 清零接收保持Halt_WL状态周期数*/
+		 for (index = 0u; index < pRsspStruct->LnkNodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
-		 pRsspStruct->LnkNodeArr[index].RecvKeepSendSseCycleNum = 0u; /*-< 清零接收保持SendSSE_WL状态周期数*/
+		 {
+			 pRsspStruct->LnkNodeArr[index].NodeStatus = Replace_WL; /*-< 设置当前链路节点为不可用*/
+
+			 pRsspStruct->LnkNodeArr[index].RecvKeepHaltCycleNum = 0u; /*-< 清零接收保持Halt_WL状态周期数*/
+			 pRsspStruct->LnkNodeArr[index].RecvKeepSendSseCycleNum = 0u; /*-< 清零接收保持SendSSE_WL状态周期数*/
+		 }
 	 }
 
 	 return ret; /*-< 返回函数返回值*/
@@ -305,7 +308,7 @@ UINT8 RsspRefresh_WL(UINT16 VarLen, const UINT8* VarArray, RSSP_INFO_STRU* pRssp
  ***********************************************************************/
 Lnk_Info_Node_Stru_WL* SearchLnkBsdNode_WL(UINT16 RsspSrcAddr,UINT16 DestBsdAdd,RSSP_INFO_STRU *pRsspStruct)
 {
-	UINT8 index = 0;
+	UINT16 index = 0;
 	Lnk_Info_Node_Stru_WL* retNodePtr = NULL;
 
 	for(index = 0; index < pRsspStruct->LnkNodeNum; index++)
@@ -342,7 +345,7 @@ Lnk_Info_Node_Stru_WL* SearchLnkBsdNode_WL(UINT16 RsspSrcAddr,UINT16 DestBsdAdd,
  ***********************************************************************/
 Lnk_Info_Node_Stru_WL* SearchLnkSse_SsrNode_WL(UINT16 RsspSrcAddr,UINT16 RsspDestAddr,RSSP_INFO_STRU *pRsspStruct)
 {
-	UINT8 index = 0;
+	UINT16 index = 0;
 	Lnk_Info_Node_Stru_WL* retNodePtr = NULL;
 
 	for(index = 0; index < pRsspStruct->LnkNodeNum; index++)
@@ -380,7 +383,7 @@ Lnk_Info_Node_Stru_WL* SearchLnkSse_SsrNode_WL(UINT16 RsspSrcAddr,UINT16 RsspDes
 Lnk_Info_Node_Stru_WL* GetReplaceNode_WL(RSSP_INFO_STRU *pRsspStruct)
 /* wangpeipei 20111202 Add S */
 {
-	UINT8 index = 0;
+	UINT16 index = 0;
 	Lnk_Info_Node_Stru_WL* retNodePtr = NULL;
 
     for(index = 0; index < pRsspStruct->LnkNodeNum; index++)
@@ -514,8 +517,8 @@ UINT8 outputReplaceLnkNode_WL(UINT16 SrcAddr,UINT16 BsdAddr,UINT16 DestAddr,
 						   RSSP_INFO_STRU *pRsspStruct)
 {
 	UINT8 ret = 0,chcRet = 0;
-	DSU_RSSP_LINK_RINFO_STRU_WL recvLnkInfo;		/* 本方作为接收方时候的节点基本信息 */
+	DSU_RSSP_LINK_RINFO_STRU_WL recvLnkInfo = { 0 };		/* 本方作为接收方时候的节点基本信息 */
-	DSU_RSSP_LINK_SINFO_STRU_WL outputLnkInfo;		/* 本方作为发送方时候的节点基本信息 */
+	DSU_RSSP_LINK_SINFO_STRU_WL outputLnkInfo = { 0 };		/* 本方作为发送方时候的节点基本信息 */
 	Lnk_Info_Node_Stru_WL *pLnkNodeInfo = NULL;
 
 	/* 根据参数目标地址以及BSD地址取得本方作为接受节点的信息 */
@@ -579,7 +582,7 @@ UINT8 outputReplaceLnkNode_WL(UINT16 SrcAddr,UINT16 BsdAddr,UINT16 DestAddr,
  ***********************************************************************/
 Lnk_Info_Node_Stru_WL* SearchNodeByAddr_WL(UINT32 destName,RSSP_INFO_STRU *pRsspStruct)
 {
-	UINT8 index = 0;
+	UINT16 index = 0;
 	Lnk_Info_Node_Stru_WL* retLnkNodePtr = NULL;	/* 返回指针 */
 	for( index = 0; index < pRsspStruct->LnkNodeNum; index++)
 	{
@@ -677,7 +680,8 @@ static UINT8 InitRsspLnkInfoWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf
   */
 UINT8 WriteToVarArray_WL(UINT8* VarArray, RSSP_INFO_STRU* pRsspStruct)
 {
-	UINT8 ret = 0u, index = 0u; /*-< 设置函数返回值为失败*/
+	UINT8 ret = 0u;
+	UINT16 index = 0u; /*-< 设置函数返回值为失败*/
 	UINT8* pTmp = NULL; /*链路数据*/
 	UINT8 NodeLen = 0u; /*节点长度*/
 	UINT8 count = 0u; /*可用节点数*/
@@ -707,16 +711,18 @@ UINT8 WriteToVarArray_WL(UINT8* VarArray, RSSP_INFO_STRU* pRsspStruct)
 /**
  * @brief LnkNodeInfo2VarArray_WL 链路节点写入链路数据
  * @param pNode 链路节点 取值范围:参考结构体:Lnk_Info_Node_Stru_WL
- * @param lnkNodeIdx 链路节点下标 取值范围:0x00-0xFF
+ * @param lnkNodeIdx 链路节点下标 取值范围:0x0000-0xFFFF
  * @param VarArray 链路数据 取值范围:字节数组
  */
-static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UINT8 lnkNodeIdx, UINT8* VarArray)
+static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UINT16 lnkNodeIdx, UINT8* VarArray)
 {
+	/*- 定义局部变量*/
 	UINT16 index = 0; /*链路数据下标*/
 	const RsspLinkInfoStru_WL* pRsspLnkInfo = &pNode->RsspLinInfo; /*当前链路信息*/
 	const TimeStampStru_WL* pTmStmp = &pNode->RsspLinInfo.TimeStmp; /*当前链路时间戳*/
 
-	VarArray[index++] = lnkNodeIdx; /*-< 设置链路节点下标给链路数据,下标自增1*/
+	ShortToChar(lnkNodeIdx, &VarArray[index]); /*-< 设置链路节点下标给链路数据*/
+	index += 2; /*-< 链路数据下标自增2*/
 
 	LongToChar(pNode->CycleNum, &VarArray[index]); /*-< 设置周期号给链路数据*/
 	index += 4; /*-< 链路数据下标自增4*/
@@ -816,11 +822,12 @@ static void LnkNodeInfo2VarArray_WL(const Lnk_Info_Node_Stru_WL* pNode, const UI
  */
 static void VarArray2LnkNodeInfo_WL(const UINT8* VarArray, Lnk_Info_Node_Stru_WL* pNode)
 {
+	/*- 定义局部变量*/
 	UINT16 index = 0; /*链路数据下标*/
 	RsspLinkInfoStru_WL* pRsspLnkInfo = &pNode->RsspLinInfo; /*当前链路信息*/
 	TimeStampStru_WL* pTmStmp = &pNode->RsspLinInfo.TimeStmp; /*当前链路时间戳*/
 
-	index += 1; /*-< 跳过所在链路中下标*/
+	index += 2u; /*-< 链路数据下标自增2*/
 
 	pNode->CycleNum = LongFromChar(&VarArray[index]); /*-< 链路数据赋值给周期号*/
 	index += 4; /*-< 链路数据下标自增4*/
@@ -1082,47 +1089,41 @@ static UINT8 SetNodeParamWl(const DSU_RSSP_LINK_RINFO_STRU_WL* pRecvDsuLnkInf,
 	return (UINT8)1;
 }
 
-/***********************************************************************
+ /**
- * 方法名   :   AdjustLnkCycle
+  * @brief AdjustLnkCycle 根据指定本方类型,周期号,当前链路,调整当前链路周期号并设置是否为执行周期
- * 功能描述 :	根据指定本方类型、周期号、当前链路，调整当前链路周期号并设置是否为执行周期。
+  * @param localType 本方类型 取值范围:0x00-0xFF
- * 输入参数 :
+  * @param cycleNum 周期号 取值范围:0x00000000-0xFFFFFFFF
- *	参数名		类型					输入输出	描述
+  * @param lnkNode 链路节点 取值范围:参考结构体Lnk_Info_Node_Stru_WL
- *  -----------------------------------------------------------
+  */
- *	localType	UINT8					IN			本方类型
- *	cycleNum	UINT32					IN			周期号
- *	lnkNode		Lnk_Info_Node_Stru_WL*	IN			链路节点
- *
- * 返回值   :	无
- ***********************************************************************/
 void AdjustLnkCycle(UINT8 localType, UINT32 cycleNum, Lnk_Info_Node_Stru_WL* lnkNode)
 {
-	if (lnkNode != NULL)
+	if (lnkNode != NULL) /*-< 参数是否非空*/
 	{
-		if (((RSSP_TYPE_VOBC_WL == localType) || (RSSP_TYPE_VOBC_BACK_WL == localType)) && (RSSP_TYPE_ATS_WL == (lnkNode->DestTypeId / 256)))	/*VOBC发往ATS*/
+		if (((RSSP_TYPE_VOBC_WL == localType) || (RSSP_TYPE_IVOC_WL == localType) || (RSSP_TYPE_VOBC_BACK_WL == localType)) && (RSSP_TYPE_ATS_WL == (lnkNode->DestTypeId / 256))) /*-< 本方类型为VOBC或IVOC或车备 且对方类型为ATS*/
 		{
-			if (0 == (cycleNum % VOBC_ATS_CYCLENUM_MULTIPLE))	/*周期号倍数,调整链路周期号并可执行*/
+			if (0 == (cycleNum % VOBC_ATS_CYCLENUM_MULTIPLE)) /*-< 周期号倍数为车发到ATS本方周期号倍数*/
 			{
-				lnkNode->ExeCycle = 1;
+				lnkNode->ExeCycle = 1; /*-< 设置为执行*/
 			}
 			else  /*非周期号倍数,不执行*/
 			{
-				lnkNode->ExeCycle = 0;
+				lnkNode->ExeCycle = 0; /*-< 设置为不执行*/
 			}
 		}
-		else if ((RSSP_TYPE_AOM_WL == localType) && (RSSP_TYPE_ATS_WL == (lnkNode->DestTypeId / 256)))	/*AOM发往ATS*/
+		else if (((RSSP_TYPE_AOM_WL == localType) || (RSSP_TYPE_IVOC_AOM_WL == localType)) && (RSSP_TYPE_ATS_WL == (lnkNode->DestTypeId / 256))) /*-< 本方类型为AOM或IVOC的AOM 且对方类型为ATS*/
 		{
-			if (0 == (cycleNum % AOM_ATS_CYCLENUM_MULTIPLE))	/*周期号倍数,调整链路周期号并可执行*/
+			if (0 == (cycleNum % AOM_ATS_CYCLENUM_MULTIPLE)) /*-< 周期号倍数为AOM发到ATS本方周期号倍数*/
 			{
-				lnkNode->ExeCycle = 1;
+				lnkNode->ExeCycle = 1; /*-< 设置为执行*/
 			}
 			else  /*非周期号倍数,不执行*/
 			{
-				lnkNode->ExeCycle = 0;
+				lnkNode->ExeCycle = 0; /*-< 设置为不执行*/
 			}
 		}
 		else /*否则,不用调整链路周期可执行*/
 		{
-			lnkNode->ExeCycle = 1;
+			lnkNode->ExeCycle = 1; /*-< 设置为执行*/
 		}
 	}
 }

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspLnkNodeMgrWl.h

@@ -33,7 +33,7 @@ extern "C" {
   * @param pRsspStruct RSSPI实例 取值范围:参考结构体:RSSP_INFO_STRU
   * @return 0:失败 1:成功
   */
-UINT8 InitLnkNodeArr_WL(UINT8 num,RSSP_INFO_STRU *pRsspStruct);
+UINT8 InitLnkNodeArr_WL(UINT16 num,RSSP_INFO_STRU *pRsspStruct);
 
 /***********************************************************************
  * 方法名   : SearchLnkBsdNode_WL
@@ -160,20 +160,14 @@ UINT8 WriteToVarArray_WL(UINT8 *VarArray,RSSP_INFO_STRU *pRsspStruct);
  * 
  * 返回值   : 无
  ***********************************************************************/
-void GetLnkNodeArr_WL(Lnk_Info_Node_Stru_WL** pLnkInfoNodeArr,UINT8 *OutLen,RSSP_INFO_STRU *pRsspStruct);
+void GetLnkNodeArr_WL(Lnk_Info_Node_Stru_WL** pLnkInfoNodeArr,UINT16 *OutLen,RSSP_INFO_STRU *pRsspStruct);
 
-/***********************************************************************
+/**
- * 方法名   :   AdjustLnkCycle
+ * @brief AdjustLnkCycle 根据指定本方类型,周期号,当前链路,调整当前链路周期号并设置是否为执行周期
- * 功能描述 :	根据指定本方类型、周期号、当前链路，调整当前链路周期号并设置是否为执行周期。
+ * @param localType 本方类型 取值范围:0x00-0xFF
- * 输入参数 :
+ * @param cycleNum 周期号 取值范围:0x00000000-0xFFFFFFFF
- *	参数名		类型					输入输出	描述
+ * @param lnkNode 链路节点 取值范围:参考结构体Lnk_Info_Node_Stru_WL
- *  -----------------------------------------------------------
+ */
- *	localType	UINT8					IN			本方类型
- *	cycleNum	UINT32					IN			周期号
- *	lnkNode		Lnk_Info_Node_Stru_WL*	IN			链路节点
- *
- * 返回值   :	无
- ***********************************************************************/
 void AdjustLnkCycle(UINT8 localType, UINT32 cycleNum, Lnk_Info_Node_Stru_WL *lnkNode);
 
 /*--------------------------------------------------------------------

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspOutputWl.c

@@ -27,6 +27,7 @@
 #include "RsspLnkNodeMgrWl.h"
 #include "RsspRecordDelareWl.h"
 #include "CommonRecord.h"
+#include "CommonMemory.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -63,15 +64,16 @@ static void RecvLnkStatusMng_WL(RSSP_INFO_STRU* pRsspStru);
 UINT8 RsspOutput_WL(QueueStruct* AppToRs, UINT8* VarArray, RSSP_INFO_STRU* pRsspStru)
 {
 	/** 定义局部变量*/
-	UINT8 ret = 0, index = 0; /*-< 设置返回值为失败*/
+	UINT8 ret = 0;
+	UINT16 index = 0; /*-< 设置返回值为失败*/
 	UINT8 QueErrFlag = 0; /*-< 设置队列错误标识为否*/
-	UINT8 LnkNodeNum = 0;						/* 通信节点数 */
+	UINT16 LnkNodeNum = 0;						/* 通信节点数 */
 	UINT16 MaxMsgLen = 0;						/* 一个队列节点的最大数据长度 */
 	UINT16 MsgLen = 0;							/* 消息长度 */
 	UINT8* TmpOutMsg = NULL;		/* 作成报文数据缓存区 */
 	Lnk_Info_Node_Stru_WL* LnkNodeArr = NULL;		/* 通信节点数组 */
 	Lnk_Info_Node_Stru_WL* pNode = NULL;			/* 通信节点指针 */
-		/* ywlou20101118 Add S */
+	/* ywlou20101118 Add S */
 	UINT8 appDataFlg = 0; /*-< 设置是否有应用给数据标识为否*/
 	/* ywlou20101118 Add E */
 	UINT32 destDevName = 0;		/* 对方设备标识 */
@@ -97,15 +99,13 @@ UINT8 RsspOutput_WL(QueueStruct* AppToRs, UINT8* VarArray, RSSP_INFO_STRU* pRssp
 		PrintRecArrayByte(RecordArray, RecordSize, RSSP_OUTPUT); /*-< 记录输出标识日志*/
 		PrintRecArray2ByteB(RecordArray, RecordSize, (UINT16)QueueStatus(AppToRs));	/*-< 记录输入队列总长度日志*/
 #endif
-		RsspMemSet_WL(&pRsspStru->AppArray[0], pRsspStru->AppArraySize, 0); /*-< 调用清空给应用数据存放的数组函数*/
+		CommonMemSet(&pRsspStru->AppArray[0], pRsspStru->AppArraySize, 0u, pRsspStru->AppArraySize); /*-< 调用清空给应用数据存放的数组函数*/
 		/* 取得全局的通信节点数组 */
 		GetLnkNodeArr_WL(&LnkNodeArr, &LnkNodeNum, pRsspStru); /*-< 调用取得通信节点数组函数*/
 
 		/* 无发送数据周期数累加 */
 		for (index = 0; index < LnkNodeNum; index++) /*-< 当前链路数下标是否小于链路总数*/
 		{
-			LnkNodeArr[index].CycleNum++; /*-< 协议周期累加1*/
-			AdjustLnkCycle(pRsspStru->LocalType, LnkNodeArr[index].CycleNum, &LnkNodeArr[index]); /*-< 调用根据指定本方类型、周期号、当前链路，调整当前链路周期号并设置是否为执行周期函数*/
 			if (1 == LnkNodeArr[index].ExeCycle) /*-< 此链路是否执行周期*/
 			{
 				LnkNodeArr[index].HasRsdBeforeSseOrSsr = 0;	/*-< 设置未生成过RSD标识为否*/
@@ -148,7 +148,7 @@ UINT8 RsspOutput_WL(QueueStruct* AppToRs, UINT8* VarArray, RSSP_INFO_STRU* pRssp
 				{
 					/* RSD 报文作成 */
 					ret = CreateRsdMsg_WL(pRsspStru->FrameData, (UINT16)(MsgLen + 2), TmpOutMsg, &pNode, pRsspStru); /*-< 调用生成RSD帧函数*/
-					RsspMemSet_WL(pRsspStru->FrameData, (UINT16)(MsgLen + 2), 0); /*-< 清零应用给帧数据*/
+					CommonMemSet(pRsspStru->FrameData, (UINT32)(MsgLen + 2u), 0u, (UINT32)(MsgLen + 2u)); /*-< 清零应用给帧数据*/
 					/* RSD报文作成成功	*/
 					if (1 == ret) /*-< 调用函数是否成功*/
 					{
@@ -224,7 +224,7 @@ UINT8 RsspOutput_WL(QueueStruct* AppToRs, UINT8* VarArray, RSSP_INFO_STRU* pRssp
 					/*-< 什么不做*/
 				}
 
-				if ((RSSP_TYPE_VOBC_WL == pRsspStru->LocalType) || (RSSP_TYPE_VOBC_BACK_WL == pRsspStru->LocalType) || (RSSP_TYPE_AOM_WL == pRsspStru->LocalType)) /*-< 本方类型是否车或车后备或AOM*/
+				if ((RSSP_TYPE_VOBC_WL == pRsspStru->LocalType) || (RSSP_TYPE_IVOC_WL == pRsspStru->LocalType) || (RSSP_TYPE_VOBC_BACK_WL == pRsspStru->LocalType) || (RSSP_TYPE_AOM_WL == pRsspStru->LocalType) || (RSSP_TYPE_IVOC_AOM_WL == pRsspStru->LocalType)) /*-< 本方类型是否CBTC车或车车或车后备或CBTC AOM或车车AOM*/
 				{
 					if (DisbaledReplace_WL == LnkNodeArr[index].NodeStatus) /*-< 当前链路可用性是否可用*/
 					{
@@ -235,7 +235,7 @@ UINT8 RsspOutput_WL(QueueStruct* AppToRs, UINT8* VarArray, RSSP_INFO_STRU* pRssp
 						dstType = DquToDevType(LnkNodeArr[index].DestDevName, pRsspStru->pDsuRsspInfoStruWL); /*-< 调用根据HLHTID转成设备类型函数设置目的类型ID*/
 #endif
 					}
-					if ((RSSP_TYPE_VOBC_WL == dstType) || (RSSP_TYPE_VOBC_BACK_WL == dstType) || (RSSP_TYPE_TTIL_WL == dstType)) /*-< 对方类型是否车或车后备或列尾通信*/
+					if ((RSSP_TYPE_VOBC_WL == dstType) || (RSSP_TYPE_IVOC_WL == dstType) || (RSSP_TYPE_VOBC_BACK_WL == dstType) || (RSSP_TYPE_TTIL_WL == dstType)) /*-< 对方类型是否车或车车或车后备或列尾通信*/
 					{
 						appDataFlg = 1; /*-< 设置是否有应用给数据标识为是*/
 					}
@@ -378,7 +378,7 @@ UINT8 RsspOutput_WL(QueueStruct* AppToRs, UINT8* VarArray, RSSP_INFO_STRU* pRssp
 				PrintFiles(RecordArray, RecordSize, "\n");
 #endif 
 #ifdef RSSP_RECORD_SIMPLIFY_BIN	/*是否定义二进制宏开关*/
-				PrintRecArrayByte(RecordArray, RecordSize, index); /*-< 记录当前链路下标日志*/
+				PrintRecArray2ByteB(RecordArray, RecordSize, index); /*-< 记录当前链路下标日志*/
 				PrintRecArray2ByteB(RecordArray, RecordSize, LnkNodeArr[index].RsspLinInfo.RsspDestAddr); /*-< 记录RSSPI目的地址日志*/
 				PrintRecArray2ByteB(RecordArray, RecordSize, LnkNodeArr[index].DestTypeId); /*-< 记录目的类型ID日志*/
 				PrintRecArray2ByteB(RecordArray, RecordSize, LnkNodeArr[index].DestLogicId); /*-< 记录目的逻辑ID日志*/
@@ -839,22 +839,15 @@ static UINT8 WriteToAppArray(const UINT8* appData, const UINT16 appDataLen, Lnk_
 	return rtn;
 }
 
-/***********************************************************************
+/**
- * 方法名   : RecvLnkStatusMng_WL
+* @brief RecvLnkStatusMng_WL 根据通信节点的信息进行状态变化
- * 功能描述 : 根据通信节点的信息进行状态变化。
+* @param pRsspStru RSSPI结构体 取值范围:参考结构体RSSP_INFO_STRU
- * 输入参数 :
+*/
- *	参数名		类型				输入输出	描述
- *  --------------------------------------------------------------
- *	pBsdMsg		const DataNod_WLe*		IN			Bsd报文
- *  pLnkNode	Lnk_Info_Node_Stru_WL 	INOUT		RSSP到应用的输出队列
- *
-
- * 返回值   : UINT8  1：正常返回
- ***********************************************************************/
 static void RecvLnkStatusMng_WL(RSSP_INFO_STRU* pRsspStru)
 {
-	UINT8 index = 0u; /*下标*/
+	/*- 定义局部变量*/
-	UINT8 LnkNodeNum = 0u; /*链路节点数*/
+	UINT16 index = 0u; /*下标*/
+	UINT16 LnkNodeNum = 0u; /*链路节点数*/
 	UINT8 RecvStatus = 0u; /*收状态*/
 	UINT32 LastLocalRecTC = 0u; /*上次收到报文本地周期号*/
 	UINT32 NoRecDataTc = 0u; /*无收数据周期数*/
@@ -869,64 +862,59 @@ static void RecvLnkStatusMng_WL(RSSP_INFO_STRU* pRsspStru)
 	GetLnkNodeArr_WL(&LnkNodeArr, &LnkNodeNum, pRsspStru); /*-< 调用函数获取链接节点列表和列表数量*/
 	for (index = 0u; index < LnkNodeNum; index++) /*-< 当前节点下标是否小于节点总数*/
 	{
+		LnkNodeArr[index].CycleNum++; /*-< 协议周期累加1*/
+		AdjustLnkCycle(pRsspStru->LocalType, LnkNodeArr[index].CycleNum, &LnkNodeArr[index]); /*-< 调用根据指定本方类型、周期号、当前链路，调整当前链路周期号并设置是否为执行周期函数*/
 		if (1u == LnkNodeArr[index].ExeCycle) /*-< 此链路是否执行周期*/
 		{
 			RecvStatus = LnkNodeArr[index].RsspLinInfo.RecvLinkStatus; /*-< 设置当前节点收状态给收状态*/
-			if ((WaitSSR_WL == RecvStatus) || (RecvData_WL == RecvStatus)) /*-< 收状态是否等SSR或收数据状态*/
+			LastLocalRecTC = LnkNodeArr[index].RsspLinInfo.TimeStmp.LastLocalRecTC; /*-< 设置当前节点上次收到有效数据时周期号给上次收到有效数据时周期号*/
+			if (((WaitSSR_WL == RecvStatus) || (RecvData_WL == RecvStatus)) && (LnkNodeArr[index].RsspLinInfo.TimeStmp.TC != LastLocalRecTC)) /*-< 收状态是否等SSR或收数据状态 且当前周期号是否不等于上次收到有效数据时周期号*/
 			{
-				LastLocalRecTC = LnkNodeArr[index].RsspLinInfo.TimeStmp.LastLocalRecTC; /*-< 设置当前节点上次收到有效数据时周期号给上次收到有效数据时周期号*/
+				LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum += 1u; /*-< 设置当前节点无收数据周期数自增1*/
-				if (LnkNodeArr[index].RsspLinInfo.TimeStmp.TC != LastLocalRecTC) /*-< 当前周期号是否不等于上次收到有效数据时周期号*/
+				NoRecDataTc = LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum; /*-< 设置当前节点无收数据周期数给无收数据周期数*/
+				if (WaitSSR_WL == RecvStatus) /*-< 收状态是否等SSR状态*/
 				{
-					LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum += 1u; /*-< 设置当前节点无收数据周期数自增1*/
+					if (LnkNodeArr[index].RsspLinInfo.LocalNode.SSDelay < NoRecDataTc) /*-< 无收数据周期数是否大于当前节点容忍的等SSR周期数*/
-					NoRecDataTc = LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum; /*-< 设置当前节点无收数据周期数给无收数据周期数*/
-					if (WaitSSR_WL == RecvStatus) /*-< 收状态是否等SSR状态*/
 					{
-						if (LnkNodeArr[index].RsspLinInfo.LocalNode.SSDelay < NoRecDataTc) /*-< 无收数据周期数是否大于当前节点容忍的等SSR周期数*/
+						if (LnkNodeArr[index].RsspLinInfo.TimeStmp.NumSendSse >= SEND_SSE_NUM_WL) /*-< 当前节点发SSE次数是否大于等于最大发SSE次数*/
 						{
-							if (LnkNodeArr[index].RsspLinInfo.TimeStmp.NumSendSse >= SEND_SSE_NUM_WL) /*-< 当前节点发SSE次数是否大于等于最大发SSE次数*/
+							LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = Halt_WL; /*-< 设置当前节点收状态为中断*/
-							{
+							LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum = 0; /*-< 清零当前节点收无数据周期数*/
-								LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = Halt_WL; /*-< 设置当前节点收状态为中断*/
+							LnkNodeArr[index].RsspLinInfo.TimeStmp.NumSendSse = 0; /*-< 清零当前节点发SSE次数*/
-								LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum = 0; /*-< 清零当前节点收无数据周期数*/
-								LnkNodeArr[index].RsspLinInfo.TimeStmp.NumSendSse = 0; /*-< 清零当前节点发SSE次数*/
-							}
-							else
-							{
-								LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = SendSSE_WL; /*-< 设置当前节点收状态为发SSE状态*/
-								LnkNodeArr[index].RsspLinInfo.TimeStmp.NumSendSse++; /*-< 设置当前节点发SSE次数自增1*/
-							}
 						}
 						else
 						{
-							/*-< 什么不做 */
+							LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = SendSSE_WL; /*-< 设置当前节点收状态为发SSE状态*/
+							LnkNodeArr[index].RsspLinInfo.TimeStmp.NumSendSse++; /*-< 设置当前节点发SSE次数自增1*/
 						}
 					}
 					else
 					{
-#ifdef TIMED_SSE /*是否定义定时发SSE时序校正宏开关*/
+						/*-< 什么不做 */
-						AntiDelayTC = CheckTimeStamp_WL(LnkNodeArr[index].RsspLinInfo.TimeStmp.TC, LnkNodeArr[index].RsspLinInfo.TimeStmp.SsrTc, LnkNodeArr[index].RsspLinInfo.LocalNode.AntiDelayCount); /*-< 调用函数得到当前周期与收SSR周期差是否超配置*/
-						if (AntiDelayTC < 0) /*-< 当前周期与收SSR周期差是否超配置*/
-						{
-							LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = SendSSE_WL; /*-< 设置当前节点收状态为发SSE状态*/
-						}
-						else
-						{
-							/*-< 什么不做*/
-						}
-#endif
-						if (NoRecDataTc > LnkNodeArr[index].RsspLinInfo.LocalNode.DLost) /*-< 无收数据周期数是否大于当前节点容忍的连续无数据周期数*/
-						{
-							LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = Halt_WL; /*-< 设置当前节点收状态为中断*/
-							LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum = 0u; /*-< 清零当前节点收无数据周期数*/
-						}
-						else
-						{
-							/*-< 什么不做*/
-						}
 					}
 				}
 				else
 				{
-					/*-< 什么不做*/
+#ifdef TIMED_SSE /*是否定义定时发SSE时序校正宏开关*/
+					AntiDelayTC = CheckTimeStamp_WL(LnkNodeArr[index].RsspLinInfo.TimeStmp.TC, LnkNodeArr[index].RsspLinInfo.TimeStmp.SsrTc, LnkNodeArr[index].RsspLinInfo.LocalNode.AntiDelayCount); /*-< 调用函数得到当前周期与收SSR周期差是否超配置*/
+					if (AntiDelayTC < 0) /*-< 当前周期与收SSR周期差是否超配置*/
+					{
+						LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = SendSSE_WL; /*-< 设置当前节点收状态为发SSE状态*/
+					}
+					else
+					{
+						/*-< 什么不做*/
+					}
+#endif
+					if (NoRecDataTc > LnkNodeArr[index].RsspLinInfo.LocalNode.DLost) /*-< 无收数据周期数是否大于当前节点容忍的连续无数据周期数*/
+					{
+						LnkNodeArr[index].RsspLinInfo.RecvLinkStatus = Halt_WL; /*-< 设置当前节点收状态为中断*/
+						LnkNodeArr[index].RsspLinInfo.NoRecvDataCycleNum = 0u; /*-< 清零当前节点收无数据周期数*/
+					}
+					else
+					{
+						/*-< 什么不做*/
+					}
 				}
 			}
 			else

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspReciveWl.c

@@ -937,6 +937,7 @@ static void ReadNetData(QueueStruct* pInputQue, DataNode_WL** pHeadNode, RSSP_IN
 	UINT16 dstTypeId = 0u; /*目的类型ID*/
 	UINT32 dstId = 0u; /*传入的对方唯一ID*/
 	UINT32 recvDstId = 0u; /*收到数据中协议唯一ID对应唯一类型ID*/
+	UINT8 deepPro = 0u; /*-< 设置处理标志为不处理*/
 
 	if ((NULL != pInputQue) && (NULL != pHeadNode) && (NULL != rssp) && (NULL != rssp->StackOfDataLink) && (NULL != rssp->pDsuRsspInfoStruWL) && (NULL != rssp->FrameData) && (NULL != rssp->RecordArray)) /*-< 参数是否非空*/
 	{
@@ -945,9 +946,11 @@ static void ReadNetData(QueueStruct* pInputQue, DataNode_WL** pHeadNode, RSSP_IN
 		/*输入队列数据中有数据,进行处理*/
 		while (queLen > twoLen)	/*-< 队列中是否有数据*/
 		{
+			deepPro = 0u; /*-< 设置处理标志为不处理*/
+
 			QueueScan(twoLen, rssp->FrameData, pInputQue); /*-< 扫长度字节到数组中*/
 			pkgDataLen = ShortFromChar(rssp->FrameData); /*-< 表示的此单包数据长度*/
-			if ((twoLen + pkgDataLen) <= queLen) /*-< 表示的此单包数据长度是否正常*/
+			if (((UINT32)twoLen + (UINT32)pkgDataLen) <= queLen) /*-< 表示的此单包数据长度是否正常*/
 			{
 				if ((twoLen + twoLen + RSSP_HEAD_LEN_WL + TC_LEN_WL + CRC_16_LEN_WL) < pkgDataLen) /*-< 2字节类型ID+2字节逻辑ID+RSSPI帧长度,小于包长度,表示帧长度是否正常*/
 				{
@@ -977,113 +980,7 @@ static void ReadNetData(QueueStruct* pInputQue, DataNode_WL** pHeadNode, RSSP_IN
 
 						if (dstAddr == rssp->pDsuRsspInfoStruWL->LocRsspiAddr)	/*-< 是否是发给本方的数据*/
 						{
-#ifdef RSSP_NO_HLHT
+							deepPro = 1u; /*-< 设置处理标志为处理*/
-							dstId = dstTypeId; /*-< 设置对方唯一ID*/
-#else
-							dstId = DquTypeIdToHlhtId(dstTypeId, dstLogicId, rssp->pDsuRsspInfoStruWL); /*-< 设置对方唯一ID*/
-#endif
-							dsuRsspRGetName_WL(srcAddr, dstAddr, &recvDstId, rssp->pDsuRsspInfoStruWL); /*-< 调用设置收到对方唯一ID函数*/
-							if (recvDstId == dstId) /*-< 传入唯一ID与收数据中唯一ID是否一致*/
-							{
-								crcValid = IsRedunRcvMsg(pkgDataLen - twoLen - twoLen, &rssp->FrameData[twoLen + twoLen + twoLen], rssp->RecordArray, rssp->RecordArraySize); /*-< 调用检查单包数据报文函数*/
-								if (1u == crcValid) /*-< 调用函数是否成功*/
-								{
-									pLastNode = NULL; /*-< 清空上一节点*/
-									pCurNode = (*pHeadNode); /*-< 当前节点从头节点开始*/
-									isCover = 0u; /*-< 不覆盖节点*/
-									isPop = 0u; /*-< 未弹出节点*/
-									isAddFull = 0u; /*-< 设置是否添加标志为不添加*/
-
-									isInBreak = 0u; /*-< 设置退出遍历标志为不退出*/
-									while (NULL != pCurNode) /*-< 当前节点是否非空*/
-									{
-										if ((srcAddr == pCurNode->SrcAddr) && (sn == pCurNode->TCr) && (frameType == pCurNode->FrameType)) /*-< 是否相同值节点*/
-										{
-											isCover = 1u; /*-< 设置覆盖标志为覆盖*/
-											isInBreak = 1u; /*-< 设置退出遍历标志为退出*/
-										}
-										else /*按源地址,序号,帧类型 从小到大排序*/
-										{
-											if ((srcAddr < pCurNode->SrcAddr)	/*-< 按源地址,序号,帧类型排序*/
-												|| ((srcAddr == pCurNode->SrcAddr) && (sn < pCurNode->TCr))	/*再比较序号*/
-												|| ((srcAddr == pCurNode->SrcAddr) && (sn == pCurNode->TCr) && (frameType < pCurNode->FrameType)) /*再比较帧类型*/
-												)
-											{
-												isInBreak = 1u; /*-< 设置退出遍历标志为退出*/
-											}
-										}
-
-										if (0 == isInBreak) /*-< 退出遍历标志为是否为不退出*/
-										{
-											pLastNode = pCurNode; /*-< 设置上一节点为当节点*/
-											pCurNode = pCurNode->pNextNode;/*-< 设置当前节点为下一节点*/
-
-										}
-										else /*退出遍历*/
-										{
-											break;/*-< 退出遍历*/
-										}
-									}
-
-									if (1u == isCover)	/*-< 覆盖节点标志是否为覆盖*/
-									{
-										pNewNode = pCurNode; /*-< 设置新节点为当前节点*/
-									}
-									else /*插入节点*/
-									{
-										isPop = StackPopWl(&rssp->StackOfDataLink->stack, (STACK_DATA_TYPE_WL*)&pNewNode); /*-< 调用弹出新节点函数*/
-										if (1u == isPop) /*-< 调用函数是否成功*/
-										{
-											if (NULL != pCurNode)	/*-< 当前节点是否非空*/
-											{
-												pNewNode->pNextNode = pCurNode; /*-< 设置下一节点为当前节点*/
-											}
-											if (NULL == pLastNode)	/*-< 上一节点是否为空*/
-											{
-												*pHeadNode = pNewNode; /*-< 设置头节点为新节点*/
-											}
-											else /*上一节点指向新节点*/
-											{
-												pLastNode->pNextNode = pNewNode; /*-< 设置下一节点为新节点*/
-											}
-										}
-										else /*堆栈已满*/
-										{
-											if ((NULL != (*pHeadNode)) && (NULL != pLastNode)) /*-< 头节点非空且上一节点非空*/
-											{
-												pNewNode = (*pHeadNode); /*-< 设置新节点为头节点*/
-												(*pHeadNode) = (*pHeadNode)->pNextNode; /*-< 设置头节点为下一节点*/
-												pLastNode->pNextNode = pNewNode; /*-< 设置下一节点为新节点*/
-												pNewNode->pNextNode = pCurNode; /*-< 设置下一节点为当前节点*/
-												isAddFull = 1u; /*-< 设置是否添加标志为添加*/
-											}
-
-											PrintRecArrayByte(rssp->RecordArray, rssp->RecordArraySize, RP_INPUT_STACK_NO);	/*-< 记录日志-堆栈无空间日志*/
-											PrintRecArray4ByteB(rssp->RecordArray, rssp->RecordArraySize, queLen);	/*-< 记录数据长度日志*/
-										}
-									}
-									if ((1u == isCover) || (1u == isPop) || (1u == isAddFull))	/*-< 覆盖标志为覆盖 且弹出函数成功 且是否添加为添加*/
-									{
-										pNewNode->FrameType = frameType; /*-< 设置帧类型*/
-										pNewNode->SrcAddr = srcAddr; /*-< 设置RSSPI的源地址*/
-										dsuRsspRGetName_WL(srcAddr, dstAddr, &pNewNode->DevName, rssp->pDsuRsspInfoStruWL); /*-< 调用设置对方唯一ID函数*/
-#ifdef RSSP_NO_HLHT
-										pNewNode->DestLogId = pNewNode->DevName & 0xff; /*-< 设置目的逻辑ID*/
-#else
-										pNewNode->DestLogId = DquToDevId(pNewNode->DevName, rssp->pDsuRsspInfoStruWL); /*-< 设置目的逻辑ID*/
-#endif
-										pNewNode->LocalLogId = rssp->LocalID; /*-< 设置本方逻辑ID*/
-										pNewNode->DestLogicId = dstLogicId; /*-< 设置对方逻辑ID*/
-										pNewNode->DataLen = pkgDataLen - twoLen - twoLen - twoLen; /*-< 去掉最后2字节CRC长度,pkgDataLen里包含2字节类型ID,2字节逻辑ID*/
-										pNewNode->TCr = sn; /*-< 设置序号*/
-										RsspMemCopy_WL(&rssp->FrameData[twoLen + twoLen + twoLen], pNewNode->Data, pkgDataLen - twoLen); /*-< 复制帧数据*/
-									}
-								}
-							}
-							else /*不是发给本方的数据*/
-							{
-								PrintRecArrayByte(rssp->RecordArray, rssp->RecordArraySize, RP_INPUT_FRAME_ID_ERR);	/*-< 记录唯一ID错误日志*/
-							}
 						}
 						else /*不是发给本方的数据*/
 						{
@@ -1107,8 +1004,128 @@ static void ReadNetData(QueueStruct* pInputQue, DataNode_WL** pHeadNode, RSSP_IN
 				QueueElementDiscard(queLen, pInputQue); /*-< 清空队列*/
 				PrintRecArrayByte(rssp->RecordArray, rssp->RecordArraySize, RP_INPUT_LEN_ERR);	/*-< 记录输入长度错误日志*/
 			}
-			queLen = QueueStatus(pInputQue); /*-< 获取队列中剩余数据长度*/
 
+			if (1u == deepPro) /*-< 处理标志是否为处理*/
+			{
+				deepPro = 0u; /*-< 设置处理标志为不处理*/
+
+#ifdef RSSP_NO_HLHT
+				dstId = dstTypeId; /*-< 设置对方唯一ID*/
+#else
+				dstId = DquTypeIdToHlhtId(dstTypeId, dstLogicId, rssp->pDsuRsspInfoStruWL); /*-< 设置对方唯一ID*/
+#endif
+				dsuRsspRGetName_WL(srcAddr, dstAddr, &recvDstId, rssp->pDsuRsspInfoStruWL); /*-< 调用设置收到对方唯一ID函数*/
+				if (recvDstId == dstId) /*-< 传入唯一ID与收数据中唯一ID是否一致*/
+				{
+					crcValid = IsRedunRcvMsg(pkgDataLen - twoLen - twoLen, &rssp->FrameData[twoLen + twoLen + twoLen], rssp->RecordArray, rssp->RecordArraySize); /*-< 调用检查单包数据报文函数*/
+					if (1u == crcValid) /*-< 调用函数是否成功*/
+					{
+						pLastNode = NULL; /*-< 清空上一节点*/
+						pCurNode = (*pHeadNode); /*-< 当前节点从头节点开始*/
+						isCover = 0u; /*-< 不覆盖节点*/
+						isPop = 0u; /*-< 未弹出节点*/
+						isAddFull = 0u; /*-< 设置是否添加标志为不添加*/
+
+						deepPro = 1u; /*-< 设置处理标志为处理*/
+					}
+				}
+				else /*不是发给本方的数据*/
+				{
+					PrintRecArrayByte(rssp->RecordArray, rssp->RecordArraySize, RP_INPUT_FRAME_ID_ERR);	/*-< 记录唯一ID错误日志*/
+				}
+			}
+
+			if (1u == deepPro) /*-< 处理标志是否为处理*/
+			{
+				deepPro = 0u; /*-< 设置处理标志为不处理*/
+
+				isInBreak = 0u; /*-< 设置退出遍历标志为不退出*/
+				while (NULL != pCurNode) /*-< 当前节点是否非空*/
+				{
+					if ((srcAddr == pCurNode->SrcAddr) && (sn == pCurNode->TCr) && (frameType == pCurNode->FrameType)) /*-< 是否相同值节点*/
+					{
+						isCover = 1u; /*-< 设置覆盖标志为覆盖*/
+						isInBreak = 1u; /*-< 设置退出遍历标志为退出*/
+					}
+					else /*按源地址,序号,帧类型 从小到大排序*/
+					{
+						if ((srcAddr < pCurNode->SrcAddr)	/*-< 按源地址,序号,帧类型排序*/
+							|| ((srcAddr == pCurNode->SrcAddr) && (sn < pCurNode->TCr))	/*再比较序号*/
+							|| ((srcAddr == pCurNode->SrcAddr) && (sn == pCurNode->TCr) && (frameType < pCurNode->FrameType)) /*再比较帧类型*/
+							)
+						{
+							isInBreak = 1u; /*-< 设置退出遍历标志为退出*/
+						}
+					}
+
+					if (0 == isInBreak) /*-< 退出遍历标志为是否为不退出*/
+					{
+						pLastNode = pCurNode; /*-< 设置上一节点为当节点*/
+						pCurNode = pCurNode->pNextNode;/*-< 设置当前节点为下一节点*/
+
+					}
+					else /*退出遍历*/
+					{
+						break;/*-< 退出遍历*/
+					}
+				}
+
+				if (1u == isCover)	/*-< 覆盖节点标志是否为覆盖*/
+				{
+					pNewNode = pCurNode; /*-< 设置新节点为当前节点*/
+				}
+				else /*插入节点*/
+				{
+					isPop = StackPopWl(&rssp->StackOfDataLink->stack, (STACK_DATA_TYPE_WL*)&pNewNode); /*-< 调用弹出新节点函数*/
+					if (1u == isPop) /*-< 调用函数是否成功*/
+					{
+						if (NULL != pCurNode)	/*-< 当前节点是否非空*/
+						{
+							pNewNode->pNextNode = pCurNode; /*-< 设置下一节点为当前节点*/
+						}
+						if (NULL == pLastNode)	/*-< 上一节点是否为空*/
+						{
+							*pHeadNode = pNewNode; /*-< 设置头节点为新节点*/
+						}
+						else /*上一节点指向新节点*/
+						{
+							pLastNode->pNextNode = pNewNode; /*-< 设置下一节点为新节点*/
+						}
+					}
+					else /*堆栈已满*/
+					{
+						if ((NULL != (*pHeadNode)) && (NULL != pLastNode)) /*-< 头节点非空且上一节点非空*/
+						{
+							pNewNode = (*pHeadNode); /*-< 设置新节点为头节点*/
+							(*pHeadNode) = (*pHeadNode)->pNextNode; /*-< 设置头节点为下一节点*/
+							pLastNode->pNextNode = pNewNode; /*-< 设置下一节点为新节点*/
+							pNewNode->pNextNode = pCurNode; /*-< 设置下一节点为当前节点*/
+							isAddFull = 1u; /*-< 设置是否添加标志为添加*/
+						}
+
+						PrintRecArrayByte(rssp->RecordArray, rssp->RecordArraySize, RP_INPUT_STACK_NO);	/*-< 记录日志-堆栈无空间日志*/
+						PrintRecArray4ByteB(rssp->RecordArray, rssp->RecordArraySize, queLen);	/*-< 记录数据长度日志*/
+					}
+				}
+				if ((1u == isCover) || (1u == isPop) || (1u == isAddFull))	/*-< 覆盖标志为覆盖 且弹出函数成功 且是否添加为添加*/
+				{
+					pNewNode->FrameType = frameType; /*-< 设置帧类型*/
+					pNewNode->SrcAddr = srcAddr; /*-< 设置RSSPI的源地址*/
+					dsuRsspRGetName_WL(srcAddr, dstAddr, &pNewNode->DevName, rssp->pDsuRsspInfoStruWL); /*-< 调用设置对方唯一ID函数*/
+#ifdef RSSP_NO_HLHT
+					pNewNode->DestLogId = pNewNode->DevName & 0xff; /*-< 设置目的逻辑ID*/
+#else
+					pNewNode->DestLogId = DquToDevId(pNewNode->DevName, rssp->pDsuRsspInfoStruWL); /*-< 设置目的逻辑ID*/
+#endif
+					pNewNode->LocalLogId = rssp->LocalID; /*-< 设置本方逻辑ID*/
+					pNewNode->DestLogicId = dstLogicId; /*-< 设置对方逻辑ID*/
+					pNewNode->DataLen = pkgDataLen - twoLen - twoLen - twoLen; /*-< 去掉最后2字节CRC长度,pkgDataLen里包含2字节类型ID,2字节逻辑ID*/
+					pNewNode->TCr = sn; /*-< 设置序号*/
+					RsspMemCopy_WL(&rssp->FrameData[twoLen + twoLen + twoLen], pNewNode->Data, pkgDataLen - twoLen); /*-< 复制帧数据*/
+				}
+			}
+
+			queLen = QueueStatus(pInputQue); /*-< 获取队列中剩余数据长度*/
 		}
 	}
 }

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspStructWl.h

@@ -121,7 +121,7 @@ typedef struct
 	UINT8 LocalType;				/* 设备type，由应用按文档在初始化时填写 */
 	UINT16 LocalLogicId;			/*本方逻辑ID*/
 	UINT32 *CycleNum;				/* 周期号，由应用按文档在每周期开始时填写 */
-	UINT8 MaxNumLink;				/* RSSP层同时通信的最大对象数，由应用按文档在初始化时填写 */
+	UINT16 MaxNumLink;				/* RSSP层同时通信的最大对象数，由应用按文档在初始化时填写 */
 	UINT8 MaxNumPerCycle;			/* RSSP层一周期允许每个对象的最大有效数据，由应用按文档在初始化时填写 */
 	UINT16 InputSize;				/* RSSP层接受数据中最大一帧的应用数据长度，由应用按文档在初始化时填写 */
 	UINT16 OutputSize;				/* RSSP层发送数据中最大一帧的应用数据长度，由应用按文档在初始化时填写 */
@@ -144,7 +144,7 @@ typedef struct
 	UINT8* FrameData; /*帧数据*/
 	RsspStackElement_WL* StackOfDataLink;
 	Lnk_Info_Node_Stru_WL* LnkNodeArr;			/* 通信节点数组 */
-	UINT8 LnkNodeNum;							/* 通信节点数组长度 */
+	UINT16 LnkNodeNum;							/* 通信节点数组长度 */
 	DSU_RSSP_INFO_STRU_WL *pDsuRsspInfoStruWL;	/*RSSP配置信息*/
 	UINT8 NoSendAppData;						/*输出时无应用给协议应用数据周期数*/
 	UINT16 NetsRecvPkgNumsLen; /*各网收到包数数组长度*/

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspWl.c

@@ -658,29 +658,26 @@ void RsspiSetSwapDataForOut(UINT8 swapData[], UINT8 outData[], RSSP_INFO_STRU* r
     }
 }
 
-/*
+/**
-*函数名:	RsspiDelAllLink
+ * @brief RsspiDelAllLink RSSPI删除所有链路
-*功能描述:	RSSPI删除所有链路
+ * @param rsspi RSSPI结构体变量 取值范围:参考结构体RSSP_INFO_STRU
-*输入参数:	RSSP_INFO_STRU* rsspi RSSPI结构体变量
+ */
-*输入出参:	无
-*输出参数:	无
-*返回值:	无
-*/
 void RsspiDelAllLink(RSSP_INFO_STRU* rsspi)
 {
-    UINT8 i = 0u; /*用于循环*/
+    /*- 定义局部变量*/
+    UINT16 i = 0u; /*用于循环*/
 
-    if ((NULL != rsspi) && (NULL != rsspi->LnkNodeArr)) /*参数检查*/
+    if ((NULL != rsspi) && (NULL != rsspi->LnkNodeArr)) /*-< 参数是否非空*/
     {
-        for (i = 0; i < rsspi->LnkNodeNum; i++) /*遍历所有链路*/
+        for (i = 0; i < rsspi->LnkNodeNum; i++) /*-< 遍历所有链路*/
         {
-            RsspMemSet_WL((UINT8*)&rsspi->LnkNodeArr[i], sizeof(Lnk_Info_Node_Stru_WL), 0u); /*链路信息清零*/
+            RsspMemSet_WL((UINT8*)&rsspi->LnkNodeArr[i], sizeof(Lnk_Info_Node_Stru_WL), 0u); /*-< 链路信息清零*/
-            rsspi->LnkNodeArr[i].NodeStatus = Replace_WL; /*节点状态设置可覆盖*/
+            rsspi->LnkNodeArr[i].NodeStatus = Replace_WL; /*-< 节点状态设置可覆盖*/
         }
 
-        if (NULL != rsspi->RecordArray) /*记录日志*/
+        if (NULL != rsspi->RecordArray) /*-< 记录日志非空*/
         {
-            PrintRecArray2ByteB(rsspi->RecordArray, rsspi->RecordArraySize, (UINT16)0xF0F0u);
+            PrintRecArray2ByteB(rsspi->RecordArray, rsspi->RecordArraySize, (UINT16)0xF0F0u); /*-< 记录删所有链日志*/
         }
     }
 }

TSCP/src/protocol/rssp_record_cbtc1/common_rssp/RsspWl.h

@@ -179,14 +179,10 @@ void RsspiSetSwapData(UINT8 swapData[], RSSP_INFO_STRU* rsspi);
 */
 void RsspiSetSwapDataForOut(UINT8 swapData[], UINT8 outData[], RSSP_INFO_STRU* rsspi);
 
-/*
+/**
-*函数名:	RsspiDelAllLink
+ * @brief RsspiDelAllLink RSSPI删除所有链路
-*功能描述:	RSSPI删除所有链路
+ * @param rsspi RSSPI结构体变量 取值范围:参考结构体RSSP_INFO_STRU
-*输入参数:	RSSP_INFO_STRU* rsspi RSSPI结构体变量
+ */
-*输入出参:	无
-*输出参数:	无
-*返回值:	无
-*/
 void RsspiDelAllLink(RSSP_INFO_STRU* rsspi);
 
 /*--------------------------------------------------------------------

TSCP/src/protocol/sfp_record_cbtc1/common_dqu_sfp/dsuRelatedDeal.c

@@ -61,17 +61,19 @@
 #define DSU_DATA_PROTCL_SAME_RELATION     0x05   /*DSU相同设备类型通信关系tableId*/
 
 
-/*FS的sheet页信息*/
+/*FS的sheet页信息结构体*/
 typedef struct
 {
-	UINT32 Id; /*序号*/
+	UINT32 Id; /*序号 取值范围:0x00000000-0xFFFFFFFF*/
-	UINT32 Len; /*长度*/
+	UINT32 Len; /*长度 取值范围:0x00000000-0xFFFFFFFF*/
-	UINT16 RowCount; /*行总数*/
+	UINT16 RowCount; /*行总数 取值范围:0x0000-0xFFFF*/
-	UINT32 ColLen; /*列字节长度*/
+	UINT32 ColLen; /*列字节长度 取值范围:0x00000000-0xFFFFFFFF*/
-	UINT8* Data; /*数据*/
+	UINT8* Data; /*数据 取值范围:字节数组*/
 } SheetInfo;
 
 static void InitSheet(SheetInfo* sheetInfo, UINT8 data[], const UINT32 dataLen, const UINT32 excelId, const UINT32 sheetId);
+static void StDsuSfpFindExcel(SheetInfo* sheetInfo, UINT8 data[], const UINT32 dataLen, UINT32 idx, UINT32 excelCount, const UINT32 excelId, const UINT32 sheetId);
+static UINT8 StDsuSfpFindSheet(SheetInfo* sheetInfo, UINT8 data[], const UINT32 dataLen, UINT32 curExcelStartPos, UINT32* curExcelPos, UINT32 sheetCount, const UINT32 sheetId);
 static void MergeParam(SheetInfo* sheetInfo, UINT8 outData[], UINT32* outDataIdx, UINT16 outDataLen, UINT8 mergeData[], UINT32* mergeDataIdx);
 
 /***************************************************************************************************************
@@ -791,213 +793,270 @@ UINT8 dsuSfpInit(UINT8* fileName,UINT8** pDataBase)
 
 #endif
 
-/*
+/**
-*功能描述:	初始化sheet页信息
+ * @brief InitSheet 初始化sheet页信息
-*输入参数:	UINT8 data[] 数据
+ * @param sheetInfo sheet页信息 取值范围:参考结构体SheetInfo
-*			const UINT32 dataLen 数据长度
+ * @param data 数据数组 取值范围:字节数组
-*			const UINT32 excelId excel序号
+ * @param dataLen 数据长度 取值范围:0x00000000-0xFFFFFFFF
-*			const UINT32 sheetId sheet页序号
+ * @param excelId excle的ID 取值范围:0x00000000-0xFFFFFFFF
-*输入出参:	SheetInfo* sheetInfo sheet页信息
+ * @param sheetId sheet页ID 取值范围:0x00000000-0xFFFFFFFF
-*输出参数:	无
+ */
-*返回值:	无
-*/
 static void InitSheet(SheetInfo* sheetInfo, UINT8 data[], const UINT32 dataLen, const UINT32 excelId, const UINT32 sheetId)
 {
+	/*- 定义局部变量*/
 	UINT32 idx = 0u; /*数据下标*/
 	UINT32 crcVal = 0u; /*crc值*/
 	UINT32 crc = 0u; /*计算的crc*/
 	UINT32 curLen = 0u; /*当前长度*/
 	UINT32 excelCount = 0u; /*excel数量*/
-	UINT32 excelIdx = 0u; /*excel下标*/
-	UINT32 curExcelId = 0u; /*当前excel序号*/
-	UINT32 curExcelPos = 0u; /*当前在excel位置*/
-	UINT32 curExcelStartPos = 0u; /*当前excel开始位置*/
-	UINT32 sheetCount = 0u; /*sheet数量*/
-	UINT32 sheetIdx = 0u; /*sheet下标*/
-	UINT32 curSheetId = 0u; /*当前sheet序号*/
-	UINT32 curSheetStartPos = 0u; /*当前sheet开始位置*/
-	UINT8 isBreak = 0u; /*是否退出*/
 
-	if ((NULL != sheetInfo) && (NULL != data) && (0u < dataLen)) /*参数检查*/
+	if ((NULL != sheetInfo) && (0u < dataLen) && (NULL != data)) /*-< 参数是否非空*/
 	{
-		/*设置默认值*/
+		sheetInfo->Id = 0u; /*-< 设置sheet页信息序号为0*/
-		sheetInfo->Id = 0u;
+		sheetInfo->Len = 0u; /*-< 设置sheet页信息长度为0*/
-		sheetInfo->Len = 0u;
+		sheetInfo->RowCount = 0u; /*-< 设置sheet页信息行总数为0*/
-		sheetInfo->RowCount = 0u;
+		sheetInfo->ColLen = 0u; /*-< 设置sheet页信息列字节长度为0*/
-		sheetInfo->ColLen = 0u;
+		sheetInfo->Data = NULL; /*-< 设置sheet页信息数据为NULL*/
-		sheetInfo->Data = NULL;
 
-		if ((idx + 40u) <= dataLen) /*DH下标检查*/
+		if ((idx + 40u) <= dataLen) /*-< 需使用数据长度是否合法*/
 		{
-			/*4字节CRC*/
+			crcVal = LongFromChar(&data[idx]); /*-< 得到CRC值*/
-			crcVal = LongFromChar(&data[idx]);
+			idx += 4u; /*-< 当前数据下标自增4*/
-			idx += 4u;
+
 			/*4字节版本*/
-			idx += 4u;
+			idx += 4u; /*-< 当前数据下标自增4*/
-			/*4字节长度*/
-			curLen = LongFromChar(&data[idx]);
-			idx += 4u;
 
-			if ((curLen == dataLen) && (4u < curLen))
+			curLen = LongFromChar(&data[idx]); /*-< 得到数据中长度*/
+			idx += 4u; /*-< 当前数据下标自增4*/
+
+			if ((curLen == dataLen) && (4u < curLen)) /*-< 数据中长度是否合法*/
 			{
-				crc = Crc32(&data[4], curLen - 4u);
+				crc = Crc32(&data[4u], curLen - 4u); /*-< 计算数据CRC值*/
-				if (crc == crcVal)
+				if (crc == crcVal) /*-< 计算数据CRC值是否与数据中CRC相等*/
 				{
-					/*4字节excel数量*/
+					excelCount = LongFromChar(&data[idx]); /*-< 得到excel数量*/
-					excelCount = LongFromChar(&data[idx]);
+					idx += 4u; /*-< 当前数据下标自增4*/
-					idx += 4u;
+
 					/*24字节预留*/
-					idx += 24u;
+					idx += 24u; /*-< 当前数据下标自增24*/
 
-					for (excelIdx = 0u; excelIdx < excelCount; excelIdx++)
+					StDsuSfpFindExcel(sheetInfo, data, dataLen, idx, excelCount, excelId, sheetId); /*-< 调用找对应excle数据函数*/
-					{
-						if ((idx + 24u) <= dataLen) /*DI下标检查*/
-						{
-							/*4字节excel索引*/
-							curExcelId = LongFromChar(&data[idx]);
-							idx += 4u;
-							if (curExcelId == excelId)
-							{
-								/*4字节长度*/
-								idx += 4u;
-								/*4字节excel位置*/
-								curExcelPos = LongFromChar(&data[idx]);
-								curExcelStartPos = curExcelPos;
-								idx += 4u;
-								/*12字节预留*/
-								idx += 12u;
-
-								if ((curExcelPos + 40u) <= dataLen) /*DH下标检查*/
-								{
-									/*4字节excel CRC*/
-									crcVal = LongFromChar(&data[curExcelPos]);
-									curExcelPos += 4u;
-									/*4字节excel版本*/
-									curExcelPos += 4u;
-									/*4字节excel长度*/
-									curLen = LongFromChar(&data[curExcelPos]);
-									curExcelPos += 4u;
-
-									if (4u < curLen)
-									{
-										crc = Crc32(&data[curExcelStartPos + 4u], curLen - 4u);
-										if (crc == crcVal)
-										{
-											/*4字节sheet数量*/
-											sheetCount = LongFromChar(&data[curExcelPos]);
-											curExcelPos += 4u;
-											/*24字节预留*/
-											curExcelPos += 24u;
-
-											for (sheetIdx = 0u; sheetIdx < sheetCount; sheetIdx++)
-											{
-												if ((curExcelPos + 24u) <= dataLen) /*DH下标检查*/
-												{
-													/*4字节sheet索引*/
-													curSheetId = LongFromChar(&data[curExcelPos]);
-													curExcelPos += 4u;
-													if (curSheetId == sheetId)
-													{
-														sheetInfo->Id = curSheetId;
-														/*4字节长度*/
-														sheetInfo->Len = LongFromChar(&data[curExcelPos]);
-														curExcelPos += 4u;
-														/*4字节sheet相对excel位置*/
-														curSheetStartPos = LongFromChar(&data[curExcelPos]);
-														curExcelPos += 4u;
-														/*2字节行数*/
-														sheetInfo->RowCount = ShortFromChar(&data[curExcelPos]);
-														curExcelPos += 2u;
-														/*2字节列数-无用*/
-														curExcelPos += 2u;
-														/*8字节预留*/
-														curExcelPos += 8u;
-														/*Len字节数据*/
-														sheetInfo->Data = &data[curExcelStartPos + curSheetStartPos];
-
-														if (0u < sheetInfo->RowCount) /*有行数*/
-														{
-															if ((0u < sheetInfo->Len) && (0u == (sheetInfo->Len % sheetInfo->RowCount))) /*有数据且数据长度行数可整除*/
-															{
-																sheetInfo->ColLen = sheetInfo->Len / sheetInfo->RowCount;
-															}
-															else /*数据错误*/
-															{
-																sheetInfo->Len = 0u;
-																sheetInfo->RowCount = 0u;
-																sheetInfo->Data = NULL;
-															}
-														}
-														else /*无行数*/
-														{
-															sheetInfo->Len = 0u;
-															sheetInfo->Data = NULL;
-														}
-
-														isBreak = 1u;
-													}
-													else
-													{
-														curExcelPos += 20u; /*偏移一个DI*/
-													}
-												}
-												else /*长度错误*/
-												{
-													isBreak = 1u;
-												}
-												if (1u == isBreak)
-												{
-													break;
-												}
-											}
-										}
-										else /*crc错误*/
-										{
-											isBreak = 1u;
-										}
-									}
-									else /*长度错误*/
-									{
-										isBreak = 1u;
-									}
-								}
-								else /*长度错误*/
-								{
-									isBreak = 1u;
-								}
-							}
-							else /*继续找*/
-							{
-								idx += 20u; /*偏移一个DI*/
-							}
-						}
-						else /*长度错误*/
-						{
-							isBreak = 1u;
-						}
-						if (1u == isBreak)
-						{
-							break;
-						}
-					}
 				}
 			}
 		}
 	}
 }
 
-/*
+/**
-*功能描述:	合并参数
+ * @brief StDsuSfpFindExcel 找对应excle数据
-*输入参数:	SheetInfo* sheetInfo sheet页信息
+ * @param sheetInfo sheet页信息 取值范围:参考结构体SheetInfo
-*			UINT8 outData[] 外部数据
+ * @param data 数据数组 取值范围:字节数组
-*			UINT32* outDataIdx 外部数据位置
+ * @param dataLen 数据长度 取值范围:0x00000000-0xFFFFFFFF
-*输入出参:	UINT8 mergeData[] 合并后数据
+ * @param idx 数据数组 取值范围:0x00000000-0xFFFFFFFF
-*			UINT32* mergeDataIdx 合并位置
+ * @param excelCount excle数量 取值范围:0x00000000-0xFFFFFFFF
-*输出参数:	无
+ * @param excelId excle的ID 取值范围:0x00000000-0xFFFFFFFF
-*返回值:	无
+ * @param sheetId sheet页ID 取值范围:0x00000000-0xFFFFFFFF
-*/
+ */
+static void StDsuSfpFindExcel(SheetInfo* sheetInfo, UINT8 data[], const UINT32 dataLen, UINT32 idx, UINT32 excelCount, const UINT32 excelId, const UINT32 sheetId)
+{
+	/*- 定义局部变量*/
+	UINT32 excelIdx = 0u; /*excel下标*/
+	UINT8 deepPro = 0u; /*-< 设置处理标志为不处理*/
+	UINT32 curExcelId = 0u; /*当前excel序号*/
+	UINT32 curExcelPos = 0u; /*当前在excel位置*/
+	UINT32 curExcelStartPos = 0u; /*当前excel开始位置*/
+	UINT32 crcVal = 0u; /*crc值*/
+	UINT32 crc = 0u; /*计算的crc*/
+	UINT32 curLen = 0u; /*当前长度*/
+	UINT8 isBreak = 0u; /*-< 设置是否退出遍历标识为否*/
+	UINT32 sheetCount = 0u; /*sheet数量*/
+
+	if ((NULL != sheetInfo) && (NULL != data)) /*-< 参数是否非空*/
+	{
+		for (excelIdx = 0u; excelIdx < excelCount; excelIdx++) /*-< excel下标是否小于excel数量*/
+		{
+			deepPro = 0u; /*-< 设置处理标志为不处理*/
+
+			if ((idx + 24u) <= dataLen) /*-< 需使用数据长度是否合法*/
+			{
+				curExcelId = LongFromChar(&data[idx]); /*-< 得到当前excle的ID*/
+				idx += 4u; /*-< 当前数据下标自增4*/
+
+				if (curExcelId == excelId) /*-< 得到当前excle的ID是否为要找的*/
+				{
+					/*4字节长度*/
+					idx += 4u; /*-< 当前数据下标自增4*/
+
+					/*4字节excel位置*/
+					curExcelPos = LongFromChar(&data[idx]); /*-< 得到当前excel位置*/
+					curExcelStartPos = curExcelPos; /*-< 记录当前excel位置为excel开始位置*/
+					idx += 4u; /*-< 当前数据下标自增4*/
+
+					/*12字节预留*/
+					idx += 12u; /*-< 当前数据下标自增12*/
+
+					if ((curExcelPos + 40u) <= dataLen) /*-< 需使用数据长度是否合法*/
+					{
+						crcVal = LongFromChar(&data[curExcelPos]); /*-< 得到CRC值*/
+						curExcelPos += 4u; /*-< 当前excel位置自增4*/
+
+						/*4字节excel版本*/
+						curExcelPos += 4u; /*-< 当前excel位置自增4*/
+
+						curLen = LongFromChar(&data[curExcelPos]); /*-< 得到excel长度*/
+						curExcelPos += 4u; /*-< 当前excel位置自增4*/
+
+						if ((4u < curLen) && ((curExcelStartPos + curLen) <= dataLen)) /*-< excel长度大于4 且excel开始位置加长度小于等于数据长度*/
+						{
+							deepPro = 1u; /*-< 设置处理标志为处理*/
+						}
+						else /*长度错误*/
+						{
+							isBreak = 1u; /*-< 设置是否退出遍历标识为是*/
+						}
+					}
+					else /*长度错误*/
+					{
+						isBreak = 1u; /*-< 设置是否退出遍历标识为是*/
+					}
+				}
+				else /*继续找*/
+				{
+					idx += 20u; /*-< 当前数据下标自增20*/
+				}
+			}
+			else /*长度错误*/
+			{
+				isBreak = 1u; /*-< 设置是否退出遍历标识为是*/
+			}
+
+			if (1u == deepPro) /*-< 处理标志是否为处理*/
+			{
+				crc = Crc32(&data[curExcelStartPos + 4u], curLen - 4u); /*-< 计算excel数据CRC值*/
+				if (crc == crcVal) /*-< 计算CRC值是否与数据中相等*/
+				{
+					sheetCount = LongFromChar(&data[curExcelPos]); /*-< 得到sheet页数量*/
+					curExcelPos += 4u; /*-< 当前excel位置自增4*/
+
+					/*24字节预留*/
+					curExcelPos += 24u; /*-< 当前excel位置自增24*/
+
+					isBreak = StDsuSfpFindSheet(sheetInfo, data, dataLen, curExcelStartPos, &curExcelPos, sheetCount, sheetId); /*-< 调用找对应sheet页数据函数*/
+				}
+				else /*crc错误*/
+				{
+					isBreak = 1u; /*-< 设置是否退出遍历标识为是*/
+				}
+			}
+
+			if (1u == isBreak) /*-< 退出遍历标识为是否为是*/
+			{
+				break; /*-< 退出遍历*/
+			}
+		}
+	}
+}
+
+/**
+ * @brief StDsuSfpFindSheet 找对应sheet页数据
+ * @param sheetInfo sheet页信息 取值范围:参考结构体SheetInfo
+ * @param data 数据数组 取值范围:字节数组
+ * @param dataLen 数据长度 取值范围:0x00000000-0xFFFFFFFF
+ * @param curExcelStartPos excel开始位置 取值范围:0x00000000-0xFFFFFFFF
+ * @param curExcelPos 当前excel位置 取值范围:0x00000000-0xFFFFFFFF
+ * @param sheetCount sheet页数量 取值范围:0x00000000-0xFFFFFFFF
+ * @param sheetId sheet页ID 取值范围:0x00000000-0xFFFFFFFF
+ * @return 0:不退出遍历 1:退出遍历
+ */
+static UINT8 StDsuSfpFindSheet(SheetInfo* sheetInfo, UINT8 data[], const UINT32 dataLen, UINT32 curExcelStartPos, UINT32* curExcelPos, UINT32 sheetCount, const UINT32 sheetId)
+{
+	/*- 定义局部变量*/
+	UINT8 rtnVal = 0u; /*-< 设置函数返回值为不退出遍历*/
+	UINT32 sheetIdx = 0u; /*sheet下标*/
+	UINT32 curSheetId = 0u; /*当前sheet序号*/
+	UINT32 curSheetStartPos = 0u; /*当前sheet开始位置*/
+
+	if ((NULL != sheetInfo) && (NULL != data) && (NULL != curExcelPos)) /*-< 参数是否非空*/
+	{
+		for (sheetIdx = 0u; sheetIdx < sheetCount; sheetIdx++) /*-< sheet页下标是否sheet页数量*/
+		{
+			if (((*curExcelPos) + 24u) <= dataLen) /*-< 需使用数据长度是否合法*/
+			{
+				curSheetId = LongFromChar(&data[*curExcelPos]); /*-< 得到当前sheet页ID*/
+				(*curExcelPos) += 4u; /*-< 当前excel位置自增4*/
+				if (curSheetId == sheetId) /*-< 得到当前sheet页ID是否为要找的*/
+				{
+					sheetInfo->Id = curSheetId; /*-< 设置当前sheet页ID到sheet页信息*/
+
+					sheetInfo->Len = LongFromChar(&data[*curExcelPos]); /*-< 设置长度到sheet页信息*/
+					(*curExcelPos) += 4u; /*-< 当前excel位置自增4*/
+
+					curSheetStartPos = LongFromChar(&data[*curExcelPos]); /*-< 设置sheet相对excel位置到sheet页信息*/
+					(*curExcelPos) += 4u; /*-< 当前excel位置自增4*/
+
+					sheetInfo->RowCount = ShortFromChar(&data[*curExcelPos]); /*-< 设置行数到sheet页信息*/
+					(*curExcelPos) += 2u; /*-< 当前excel位置自增2*/
+
+					/*2字节列数-无用*/
+					(*curExcelPos) += 2u; /*-< 当前excel位置自增2*/
+					/*8字节预留*/
+					(*curExcelPos) += 8u; /*-< 当前excel位置自增8*/
+
+					sheetInfo->Data = &data[curExcelStartPos + curSheetStartPos]; /*-< 设置sheet页开始数据到sheet页信息*/
+
+					if (0u < sheetInfo->RowCount) /*-< 是否有行数*/
+					{
+						if ((0u < sheetInfo->Len) && (0u == (sheetInfo->Len % sheetInfo->RowCount))) /*-< 是否有数据且数据长度行数可整除*/
+						{
+							sheetInfo->ColLen = sheetInfo->Len / sheetInfo->RowCount; /*-< 得到列数据长度*/
+						}
+						else /*数据错误*/
+						{
+							sheetInfo->Len = 0u; /*-< 设置数据长度为0*/
+							sheetInfo->RowCount = 0u; /*-< 设置行数为0*/
+							sheetInfo->Data = NULL; /*-< 设置数据为NULL*/
+						}
+					}
+					else /*无行数*/
+					{
+						sheetInfo->Len = 0u; /*-< 设置数据长度为0*/
+						sheetInfo->Data = NULL; /*-< 设置数据为NULL*/
+					}
+
+					rtnVal = 1u; /*-< 设置函数返回值为退出遍历*/
+				}
+				else
+				{
+					(*curExcelPos) += 20u; /*-< 当前excel位置自增20*/
+				}
+			}
+			else /*长度错误*/
+			{
+				rtnVal = 1u; /*-< 设置函数返回值为退出遍历*/
+			}
+
+			if (1u == rtnVal) /*-< 函数返回值是否为退出遍历*/
+			{
+				break; /*-< 退出遍历*/
+			}
+		}
+	}
+
+	return rtnVal; /*-< 返回函数返回值*/
+}
+
+/**
+ * @brief MergeParam 合并参数
+ * @param sheetInfo sheet页信息 取值范围:参考结构体SheetInfo
+ * @param outData 外部数据 取值范围:字节数组
+ * @param outDataIdx 外部数据位置 取值范围:0x00000000--0xFFFFFFFF
+ * @param outDataLen 外部数据长度 取值范围:0x0000-0xFFFF
+ * @param mergeData 合并后数据 取值范围:字节数组
+ * @param mergeDataIdx 合并位置 取值范围:0x00000000--0xFFFFFFFF
+ */
 static void MergeParam(SheetInfo* sheetInfo, UINT8 outData[], UINT32* outDataIdx, UINT16 outDataLen, UINT8 mergeData[], UINT32* mergeDataIdx)
 {
+	/*- 定义局部变量*/
 	UINT8* proOutData = NULL; /*处理的外部数据*/
 	UINT16 outRowCount = 0u; /*外部数据行数量*/
 	UINT16 mergeRowCount = 0u; /*合并后数据行数量*/
@@ -1013,91 +1072,87 @@ static void MergeParam(SheetInfo* sheetInfo, UINT8 outData[], UINT32* outDataIdx
 	UINT16 inOppDev = 0u; /*内部对方设备*/
 	UINT16 outOppDev = 0u; /*外部对方设备*/
 
-	if ((NULL != sheetInfo) && (NULL != mergeData) && (NULL != mergeDataIdx)) /*检查参数*/
+	if ((NULL != sheetInfo) && (NULL != outData) && (NULL != outDataIdx) && (NULL != mergeData) && (NULL != mergeDataIdx)) /*-< 参数是否非空*/
 	{
-		proOutData = &outData[*outDataIdx];
+		proOutData = &outData[*outDataIdx]; /*-< 得到外部数据开始位置*/
-		CommonMemCpy(&mergeData[*mergeDataIdx], outDataLen, &proOutData[0], outDataLen); /*复制不同设备类型数组*/
+		CommonMemCpy(&mergeData[*mergeDataIdx], outDataLen, &proOutData[0], outDataLen); /*-< 复制外部数据到合并数据*/
-		outRowCount = ShortFromChar(&proOutData[0]); /*当前数量*/
+		outRowCount = ShortFromChar(&proOutData[0]); /*-< 得到数量*/
-		mergeRowCount = outRowCount;
+		mergeRowCount = outRowCount; /*-< 赋值外部数量到合并数量*/
-		(*outDataIdx) += outDataLen; /*更新位置*/
+		(*outDataIdx) += outDataLen; /*-< 更新外部数据位置*/
 
-		rowCountIdx = (*mergeDataIdx); /*记下长度位置*/
+		rowCountIdx = (*mergeDataIdx); /*-< 记下合并数量位置*/
-		(*mergeDataIdx) += outDataLen;
+		(*mergeDataIdx) += outDataLen; /*-< 更新合并数据位置*/
-		if (NULL != sheetInfo->Data) /*有数据,合并*/
+		if ((NULL != sheetInfo->Data) && ((DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) || (DSU_DATA_PROTCL_SAME_RELATION == sheetInfo->Id))) /*-< 是否有数据合并 且表是不同类型表或相同类型表*/
 		{
-			if ((DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) || (DSU_DATA_PROTCL_SAME_RELATION == sheetInfo->Id)) /*sheet页*/
+			if (DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) /*-< 当前是否是不同类型表*/
 			{
-				if (DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) /*不同类型表*/
+				rowShouldLen = DSU_DIFF_RELATION_LENGTH; /*-< 设置不同类型表列长度给检查列长度*/
+				oppDevIdx = 8u; /*-< 得到对方设备下标*/
+			}
+			else
+			{
+				rowShouldLen = DSU_SAME_RELATION_LENGTH; /*-< 设置相同类型表列长度给检查列长度*/
+				oppDevIdx = 9u; /*-< 得到对方设备下标*/
+			}
+			colLen = sheetInfo->ColLen; /*-< 得到内部数据列长度*/
+			if ((colLen == rowShouldLen)) /*-< 检查内部数据列长度是否与列长度相等*/
+			{
+				for (i = 0u; i < sheetInfo->RowCount; i++) /*-< 当前行下标是否小于内部数据行数量*/
 				{
-					rowShouldLen = DSU_DIFF_RELATION_LENGTH;
+					hasSame = 0u; /*-< 设置是否有相同标志为否*/
-					oppDevIdx = 8u;
+					if (DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) /*-< 当前是否是不同类型表*/
-				}
-				else
-				{
-					rowShouldLen = DSU_SAME_RELATION_LENGTH;
-					oppDevIdx = 9u;
-				}
-				colLen = sheetInfo->ColLen;
-				if ((colLen == rowShouldLen)) /*检查行长度*/
-				{
-					for (i = 0; i < sheetInfo->RowCount; i++) /*遍历行*/
 					{
-						hasSame = 0u;
+						inLocDev = sheetInfo->Data[i * colLen]; /*-< 得到内部数据本方类型*/
-						if (DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) /*不同类型表*/
+						inOppDev = sheetInfo->Data[(i * colLen) + oppDevIdx]; /*-< 得到内部数据对方类型*/
+					}
+					else
+					{
+						inLocDev = ShortFromChar(&sheetInfo->Data[i * colLen]); /*-< 得到内部数据本方类型ID*/
+						inOppDev = ShortFromChar(&sheetInfo->Data[(i * colLen) + oppDevIdx]); /*-< 得到内部数据对方类型ID*/
+					}
+					for (j = 0u; j < outRowCount; j++) /*-< 当前行下标是否小于外部数据行数量*/
+					{
+						if (DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) /*-< 当前是否是不同类型表*/
 						{
-							inLocDev = sheetInfo->Data[i * colLen];
+							outLocDev = proOutData[2u + (j * colLen)]; /*-< 得到外部数据本方类型*/
-							inOppDev = sheetInfo->Data[(i * colLen) + oppDevIdx];
+							outOppDev = proOutData[2u + (j * colLen) + oppDevIdx]; /*-< 得到外部数据对方类型*/
 						}
 						else
 						{
-							inLocDev = ShortFromChar(&sheetInfo->Data[i * colLen]);
+							outLocDev = ShortFromChar(&proOutData[2u + (j * colLen)]); /*-< 得到外部数据本方类型ID*/
-							inOppDev = ShortFromChar(&sheetInfo->Data[(i * colLen) + oppDevIdx]);
+							outOppDev = ShortFromChar(&proOutData[(2u + (j * colLen)) + oppDevIdx]); /*-< 得到外部数据对方类型ID*/
 						}
-						for (j = 0; j < outRowCount; j++)
+						if ((inLocDev == outLocDev) && (inOppDev == outOppDev)) /*-< 内外数据本方对方是否都相同*/
 						{
-							if (DSU_DATA_PROTCL_DIFF_RELATION == sheetInfo->Id) /*不同类型表*/
+							hasSame = 1u; /*-< 设置是否有相同标志为是*/
-							{
+							break; /*-< 退出遍历*/
-								outLocDev = proOutData[2u + (j * colLen)];
-								outOppDev = proOutData[2u + (j * colLen) + oppDevIdx];
-							}
-							else
-							{
-								outLocDev = ShortFromChar(&proOutData[2u + (j * colLen)]);
-								outOppDev = ShortFromChar(&proOutData[(2u + (j * colLen)) + oppDevIdx]);
-							}
-							if ((inLocDev == outLocDev) && (inOppDev == outOppDev)) /*内外数据本方对方都相同*/
-							{
-								hasSame = 1u;
-								break;
-							}
-						}
-						if (0u == hasSame) /*无不同参,添加*/
-						{
-							CommonMemCpy(&mergeData[*mergeDataIdx], colLen, &sheetInfo->Data[i * colLen], colLen);
-							(*mergeDataIdx) += colLen;
-							mergeRowCount++;
 						}
 					}
-
+					if (0u == hasSame) /*-< 是否有相同标志是否为否*/
-					ShortToChar(mergeRowCount, &mergeData[rowCountIdx]);
+					{
+						CommonMemCpy(&mergeData[*mergeDataIdx], colLen, &sheetInfo->Data[i * colLen], colLen); /*-< 复制此行内部数据到合并数据*/
+						(*mergeDataIdx) += colLen; /*-< 合并数据位置自加列长度*/
+						mergeRowCount++; /*-< 合并数量自加1*/
+					}
 				}
+
+				ShortToChar(mergeRowCount, &mergeData[rowCountIdx]); /*-< 设置合并数量到合并数据*/
 			}
 		}
 	}
 }
 
-/*
+/**
-*功能描述:	合并参数
+ * @brief MergeDataBaseInParam 合并数据库参数
-*输入参数:	const UINT32 inDataLen 内部参数长度
+ * @param inDataLen 内部参数长度 取值范围:0x00000000-0xFFFFFFFF
-*			UINT8 inData[] 内部参数
+ * @param inData 内部参数 取值范围:字节数组
-*			struc_Unify_Info* sfp sfp结构体变量
+  * @param sfp sfp结构体变量 取值范围:参考结构体struc_Unify_Info
-*输入出参:	无
+ * @return 0:失败 1:成功
-*输出参数:	无
+ */
-*返回值:	是否成功.1:成功;0:失败
-*/
 UINT8 MergeDataBaseInParam(const UINT32 inDataLen, UINT8 inData[], struc_Unify_Info* sfp)
 {
-	UINT8 rtnVal = 0u; /*返回值*/
+	/*- 定义局部变量*/
+	UINT8 rtnVal = 0u; /*-< 设置函数返回值为失败*/
 	SheetInfo diffSheet = { 0u }; /*不同设备类型sheet页*/
 	SheetInfo sameSheet = { 0u }; /*相同设备类型sheet页*/
 	UINT8* dataBase = NULL; /*数据参数*/
@@ -1110,49 +1165,49 @@ UINT8 MergeDataBaseInParam(const UINT32 inDataLen, UINT8 inData[], struc_Unify_I
 	UINT16 diffRowNum = 0u; /*不同设备类型行数量*/
 	UINT16 sameRowNum = 0u; /*相同设备类型行数量*/
 
-	if ((NULL != sfp) && (NULL != sfp->DataBase)) /*参数检查*/
+	if ((NULL != sfp) && (NULL != sfp->DataBase)) /*-< 参数是否非空*/
 	{
-		if ((0u < inDataLen) && (NULL != inData)) /*有内网参数*/
+		if ((0u < inDataLen) && (NULL != inData)) /*-< 有内网参数*/
 		{
-			InitSheet(&diffSheet, inData, inDataLen, DSU_DATA_PROTCL_TYPE, DSU_DATA_PROTCL_DIFF_RELATION);
+			InitSheet(&diffSheet, inData, inDataLen, DSU_DATA_PROTCL_TYPE, DSU_DATA_PROTCL_DIFF_RELATION); /*-< 得到不同设备类型通信关系表*/
-			InitSheet(&sameSheet, inData, inDataLen, DSU_DATA_PROTCL_TYPE, DSU_DATA_PROTCL_SAME_RELATION);
+			InitSheet(&sameSheet, inData, inDataLen, DSU_DATA_PROTCL_TYPE, DSU_DATA_PROTCL_SAME_RELATION); /*-< 得到相同设备类型通信关系表*/
-			dataBase = sfp->DataBase;
+			dataBase = sfp->DataBase; /*-< 得到数据库*/
 
 #ifdef SFP_CKECK_DSU_IP 
-			relationNum = ShortFromChar(&dataBase[curDataBaseIdx]); /*IP个数*/
+			relationNum = ShortFromChar(&dataBase[curDataBaseIdx]); /*-< 得到IP个数*/
 			curDataBaseIdx += 2u;
-			curDataBaseIdx = curDataBaseIdx + relationNum * DSU_OBJ_INFO_LENGTH; /*IP长度*/
+			curDataBaseIdx = curDataBaseIdx + relationNum * DSU_OBJ_INFO_LENGTH; /*-< 得到IP长度*/
 #endif
-			diffRowNum = ShortFromChar(&dataBase[curDataBaseIdx]); /*不同设备类型通信关系行数*/
+			diffRowNum = ShortFromChar(&dataBase[curDataBaseIdx]); /*-< 得到不同设备类型通信关系行数*/
-			diffDataLen = 2u + diffRowNum * DSU_DIFF_RELATION_LENGTH; /*不同设备类型数据长度*/
+			diffDataLen = 2u + diffRowNum * DSU_DIFF_RELATION_LENGTH; /*-< 得到不同设备类型数据长度*/
-			sameRowNum = ShortFromChar(&dataBase[curDataBaseIdx + +diffDataLen]); /*相同设备类型数据长度*/
+			sameRowNum = ShortFromChar(&dataBase[curDataBaseIdx + diffDataLen]); /*-< 得到相同设备类型数据长度*/
-			sameDataLen = 2u + sameRowNum * DSU_SAME_RELATION_LENGTH; /*相同设备类型通信关系行数*/
+			sameDataLen = 2u + sameRowNum * DSU_SAME_RELATION_LENGTH; /*-< 得到相同设备类型通信关系行数*/
 
-			mergeDataLen = curDataBaseIdx + diffDataLen + diffSheet.Len + sameDataLen + sameSheet.Len; /*总长度*/
+			mergeDataLen = curDataBaseIdx + diffDataLen + diffSheet.Len + sameDataLen + sameSheet.Len; /*-< 计算总长度*/
-			mergeData = (UINT8*)malloc(sizeof(UINT8) * mergeDataLen);
+			mergeData = (UINT8*)malloc(sizeof(UINT8) * mergeDataLen); /*-< 分配合并数组*/
-			if (NULL != mergeData)
+			if (NULL != mergeData) /*-< 分配成功*/
 			{
-				CommonMemSet(&mergeData[0], mergeDataLen, 0u, mergeDataLen); /*清零数据*/
+				CommonMemSet(&mergeData[0], mergeDataLen, 0u, mergeDataLen); /*-< 清零合并数组*/
 
 #ifdef SFP_CKECK_DSU_IP 
-				CommonMemCpy(&mergeData[0], curDataBaseIdx, &dataBase[0], curDataBaseIdx);
+				CommonMemCpy(&mergeData[0], curDataBaseIdx, &dataBase[0], curDataBaseIdx); /*-< 复制当前数据*/
-				curMergeDataIdx += curDataBaseIdx;
+				curMergeDataIdx += curDataBaseIdx; /*-< 累加当前数据长度*/
 #endif
 
-				MergeParam(&diffSheet, &dataBase[0], &curDataBaseIdx, diffDataLen, &mergeData[0], &curMergeDataIdx);
+				MergeParam(&diffSheet, &dataBase[0], &curDataBaseIdx, diffDataLen, &mergeData[0], &curMergeDataIdx); /*-< 调用函数合并不同设备类型参数*/
-				MergeParam(&sameSheet, &dataBase[0], &curDataBaseIdx, sameDataLen, &mergeData[0], &curMergeDataIdx);
+				MergeParam(&sameSheet, &dataBase[0], &curDataBaseIdx, sameDataLen, &mergeData[0], &curMergeDataIdx); /*-< 调用函数合并相同设备类型参数*/
 
-				sfp->DataBase = mergeData;
+				sfp->DataBase = mergeData; /*-< 更新数据库*/
 
-				rtnVal = 1u;
+				rtnVal = 1u; /*-< 设置函数返回值为成功*/
 			}
 		}
 		else /*无内网参数*/
 		{
-			rtnVal = 1u;
+			rtnVal = 1u; /*-< 设置函数返回值为成功*/
 		}
 	}
 
-	return rtnVal;
+	return rtnVal; /*-< 返回函数返回值*/
 }
 

TSCP/src/protocol/sfp_record_cbtc1/common_dqu_sfp/dsuRelatedDeal.h

@@ -28,29 +28,31 @@
 extern "C" {
 #endif
 
+	/*IP端口结构体*/
 	typedef struct
 	{
-		UINT8 RedIp[4]; /*红网IP地址*/
+		UINT8 RedIp[4]; /*红网IP地址 取值范围:字节数组*/
-		UINT16 PortRed;   /*红网端口号*/
+		UINT16 PortRed;   /*红网端口号 取值范围:0x0000-0xFFFF*/
-		UINT8 BlueIp[4]; /*蓝网IP地址*/
+		UINT8 BlueIp[4]; /*蓝网IP地址 取值范围:字节数组*/
-		UINT16 PortBlue;  /*蓝网端口号*/
+		UINT16 PortBlue;  /*蓝网端口号 取值范围:0x0000-0xFFFF*/
 	} IP_PORT_STRU;
 
+	/*链路结构体*/
 	typedef struct {
-		UINT8  Role;            /*本机角色*/
+		UINT8  Role;            /*本机角色 取值范围:0x00-0xFF*/
-		UINT8  NCyclesPerPack;  /*此通信关系中允许的最大合法丢包数*/
+		UINT8  NCyclesPerPack;  /*此通信关系中允许的最大合法丢包数 取值范围:0x00-0xFF*/
-		UINT16 LocalCycle;      /*本方运行周期长度(报文发送周期长度)*/
+		UINT16 LocalCycle;      /*本方运行周期长度(报文发送周期长度) 取值范围:0x0000-0xFFFF*/
-		UINT16 LocalMaxDelay;   /*本方报文最大延时差*/
+		UINT16 LocalMaxDelay;   /*本方报文最大延时差 取值范围:0x0000-0xFFFF*/
-		UINT8  LocalCommType;   /*本方发送数据通信类型（也是对方接收数据的通信类型）*/
+		UINT8  LocalCommType;   /*本方发送数据通信类型（也是对方接收数据的通信类型） 取值范围:0x00-0xFF*/
-		UINT16 DestCycle;       /* 对方报文发送周期*/
+		UINT16 DestCycle;       /* 对方报文发送周期 取值范围:0x0000-0xFFFF*/
-		UINT16 DestMaxDelay;    /*本方报文最大延时差*/
+		UINT16 DestMaxDelay;    /*本方报文最大延时差 取值范围:0x0000-0xFFFF*/
-		UINT16 AckMaxDelay;     /*接收方ACK传输最大延迟*/
+		UINT16 AckMaxDelay;     /*接收方ACK传输最大延迟 取值范围:0x0000-0xFFFF*/
-		UINT8  DestCommType;    /*对方发送数据通信类型（也是本方接收数据的通信类型）*/       
+		UINT8  DestCommType;    /*对方发送数据通信类型（也是本方接收数据的通信类型） 取值范围:0x00-0xFF*/       
 
 		#ifdef SFP_CKECK_DSU_IP 
 		/*IPÅäÖÃ*/
-		UINT8 dstNum;
+		UINT8 dstNum; /*取值范围 : 0x00 - 0xFF*/
-		IP_PORT_STRU DstIpInfo[2];
+		IP_PORT_STRU DstIpInfo[2]; /*取值范围:字节数组*/
     #endif
 	} struc_LnkBasicInfo; 
 
@@ -112,18 +114,6 @@ UINT32 dsuIsDevExist(struc_Unify_Info * LocalInfo , UINT32 DevName);
 */
 UINT16 dsuGetObjNum(struc_Unify_Info * LocalInfo);
 
-/*
-* 功能描述:相同建链时得到跟随方的信息
-* 参数说明:
-*   [out]INT8 *FollowDevInfo:记录跟随方信息的数组的头指针 (数组应该定义一个1*9的数组)
-*       内部格式为
-*       Byte0         Byte1          Byte2          Byte3   Byte4         Byte5        Byte6......
-*       跟随方个数    跟随方1Type    跟随方1ID      0       0             跟随方2Type  跟随方2ID  ...
-*   [in] struc_Unify_Info * LocalInfo 当前运行的对象统一结构体内容
-* 返回值:获得正确返回1否则返回0	
-*/
-UINT8 dsuSameTypeLnk(struc_Unify_Info * LocalInfo, UINT8 *FollowDevInfo);
-
 
 #ifdef USE_DSU_SFP
 /*
@@ -136,15 +126,13 @@ UINT8** pDataBase
 UINT8 dsuSfpInit(UINT8* fileName,UINT8** pDataBase);
 #endif
 
-/*
+/**
-*功能描述:	合并参数
+ * @brief MergeDataBaseInParam 合并数据库参数
-*输入参数:	const UINT32 inDataLen 内部参数长度
+ * @param inDataLen 内部参数长度 取值范围:0x00000000-0xFFFFFFFF
-*			UINT8 inData[] 内部参数
+ * @param inData 内部参数 取值范围:字节数组
-*			struc_Unify_Info* sfp sfp结构体变量
+  * @param sfp sfp结构体变量 取值范围:参考结构体struc_Unify_Info
-*输入出参:	无
+ * @return 0:失败 1:成功
-*输出参数:	无
+ */
-*返回值:	是否成功.1:成功;0:失败
-*/
 UINT8 MergeDataBaseInParam(const UINT32 inDataLen, UINT8 inData[], struc_Unify_Info* sfp);
 
 #ifdef __cplusplus

TSCP/src/protocol/sfp_record_cbtc1/common_sfp/sfpPrtclInit.c

@@ -43,305 +43,310 @@
 #include "dsuRelatedDeal.h"
 
 
-/******************************************************************************************
+/**
-* 功能描述      : 协议初始化函数
+ * @brief ProtclInit 协议初始化函数
-                   1. 在调用此函数之前，应用要将统一结构体中InputSize，OutputSize,MaxNumLink,
+ * @param fileName FS文件名 取值范围:字节数组
-                      MaxNumPerCycle,OutnetQueueSize等变量赋值
+ * @param inDataLen 内部数据长度 取值范围:0x00000000-0xFFFFFFFF
-* 输入参数      : UINT8 *   fileName            存放数据的文件名或地址
+ * @param inData 内部数据 取值范围:字节数组
-*				: UINT32 inDataLen 内部参数长度
+ * @param pUnifyInfo SFP实例 取值范围:参考结构体struc_Unify_Info
-*				: UINT8 inData[] 内部参数
+ * @return 0:失败 1:成功
-* 输入输出参数  : struc_Unify_Info* pUnifyInfo  协议统一结构体指针
+ */
-* 输出参数      :   
+UINT8 ProtclInit(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], struc_Unify_Info* pUnifyInfo)/* %RELAX<MISRA_8_10> */
-* 全局变量      :
-* 返回值        : 正常初始化返回1，否则返回0        
-*******************************************************************************************/
-UINT8 ProtclInit(UINT8 *fileName, UINT32 inDataLen, UINT8 inData[], struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
 {
+    /*- 定义局部变量*/
     UINT16 InputSize;     /*作为对结构体中的一些变量访问的临时变量*/
     UINT16 OutputSize;
     UINT16 MaxNumLink;
     UINT16 MaxNumPerCycle;
     UINT32 lTemp;
-    UINT8  ret = 0;
+    UINT8  ret = 0; /*-< 设置函数返回值为失败*/
 
-    if(pUnifyInfo == NULL)
+    if (pUnifyInfo == NULL) /*-< 参数是否非空*/
     {
-		ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
-    {}
-    
-    /* wangpeipei 20120103 Mod S */
-	if((fileName != NULL) && (pUnifyInfo->DataBase == NULL))
-	{
-#ifdef USE_DSU_SFP
-        ret = dsuSfpInit(fileName, &pUnifyInfo->DataBase);
-		if (ret == 0)
-		{
-			return ret;
-		}
-		else
-		{
-			/* 不作处理 */
-		}
-#else
-		ret = 1;
-#endif
-	}
-	else if((fileName == NULL) && (pUnifyInfo->DataBase != NULL))
-	{
-		/* 不作处理 */
-	}
-	else
-	{
-		return ret;
-	}
-
-    ret = MergeDataBaseInParam(inDataLen, inData, pUnifyInfo);
-    if (0u == ret)
     {
-        return ret;
     }
 
-	/* wangpeipei 20120103 Mod End */
+    /* wangpeipei 20120103 Mod S */
-    /*把统一结构体中的4个基本参数倒到临时变量中*/
+    if ((fileName != NULL) && (pUnifyInfo->DataBase == NULL)) /*-< FS文件名是否非空 且数据库是否空*/
+    {
+#ifdef USE_DSU_SFP
+        ret = dsuSfpInit(fileName, &pUnifyInfo->DataBase); /*-< 调用初始化查询函数*/
+        if (ret == 0) /*-< 调用函数是否失败*/
+        {
+            return ret; /*-< 返回函数返回值*/
+        }
+        else
+        {
+            /* 不作处理 */
+        }
+#else
+        ret = 1; /*-< 返回函数返回值*/
+#endif
+    }
+    else if ((fileName == NULL) && (pUnifyInfo->DataBase != NULL)) /*-< FS文件名是否空 且数据库是否非空*/
+    {
+        /* 不作处理 */
+    }
+    else
+    {
+        return ret; /*-< 返回函数返回值*/
+    }
+
+    ret = MergeDataBaseInParam(inDataLen, inData, pUnifyInfo); /*-< 调用合并参数函数*/
+    if (0u == ret) /*-< 调用函数是否失败*/
+    {
+        return ret; /*-< 返回函数返回值*/
+    }
+
+    /* wangpeipei 20120103 Mod End */
+    /*- 把统一结构体中的4个基本参数倒到临时变量中*/
     InputSize = pUnifyInfo->InputSize;
     OutputSize = pUnifyInfo->OutputSize;
     MaxNumLink = pUnifyInfo->MaxNumLink + 1;
     MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle;
-    
+
     /*首先根据应用给出的四个基本参数计算并给统一结构体中的队列、数组参数赋值*/
     /* DataToApp接口队列大小
      * 根据如下公式由协议计算，并对其初始化：
-     * [InputSize （每帧输入数据的最大字节数）+协议占用字节数（值为7）]* 
+     * [InputSize （每帧输入数据的最大字节数）+协议占用字节数（值为7）]*
      * MaxNumLink（最大链路数）*/
-    /*分配给应用队列空间*/
+     /*- 分配给应用队列空间*/
     lTemp = (InputSize + 7) * MaxNumLink;
-    pUnifyInfo->DataToAppSize =  lTemp;
+    pUnifyInfo->DataToAppSize = lTemp;
-  
+
-  
+
     /* OutputDataQueue的大小
      * 由如下公式计算出来对该值进行初始化：
-     * [OutputSize (每帧输出数据的最大字节数)+协议字节数（值为6）]* 
+     * [OutputSize (每帧输出数据的最大字节数)+协议字节数（值为6）]*
      * MaxNumLink（最大链路数）
      */
+     /*- 分配给输出队列空间*/
     lTemp = (OutputSize + 6) * MaxNumLink;
-    pUnifyInfo->OutputDataQueueSize =  lTemp;
+    pUnifyInfo->OutputDataQueueSize = lTemp;
-  
+
     /* 协议输入单元的入口数组与协议冗余单元的出口数组大小
-     * 总空间 = [InputSize （每帧输入数据的最大字节数）+协议占用字节数（值为15）]* 
+     * 总空间 = [InputSize （每帧输入数据的最大字节数）+协议占用字节数（值为15）]*
-     * MaxNumLink（最大链路数）*每个周期每个对象收到报文数的最大值（参考值为5）+ 
+     * MaxNumLink（最大链路数）*每个周期每个对象收到报文数的最大值（参考值为5）+
      * 富余字节数（该值为2）
      */
-    lTemp = (InputSize + 15) * MaxNumLink* MaxNumPerCycle + 2;
+     /*- 分配给输入队列空间*/
+    lTemp = (InputSize + 15) * MaxNumLink * MaxNumPerCycle + 2;
     pUnifyInfo->PrtclRcvSize = lTemp;
-  
+
     /* PrtclSndBuff所指数组的大小
      *总空间 = [OutputSize （每帧输出数据的最大字节数）+协议占用字节数（该为49）+
      * 链路管理表节点占用字节数(参考值为48)]* MaxNumLink（最大链路数）+
-     * 数组头占用字节数（即4.7部分表格中所列的：整个数组长度+数组长度0 = 8）	
+     * 数组头占用字节数（即4.7部分表格中所列的：整个数组长度+数组长度0 = 8）
      */
+     /*- 分配给输出队列空间*/
     lTemp = (OutputSize + 49 + 4 + LNKFRAMELEN) * MaxNumLink + 8;
-    pUnifyInfo->PrtclSndBuffSize =  lTemp;
+    pUnifyInfo->PrtclSndBuffSize = lTemp;
-  
+
-    
+
     /*分配冗余出口数组*/
-    pUnifyInfo->DataAfterReduntancy = NULL; 
+    /*- 分配给冗余数组空间*/
-    pUnifyInfo->DataAfterReduntancy =(UINT8*) malloc(pUnifyInfo->PrtclRcvSize);
+    pUnifyInfo->DataAfterReduntancy = NULL;
-    if(pUnifyInfo->DataAfterReduntancy == NULL)
+    pUnifyInfo->DataAfterReduntancy = (UINT8*)malloc(pUnifyInfo->PrtclRcvSize);
+    if (pUnifyInfo->DataAfterReduntancy == NULL) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
         /*无操作*/
-		CommonMemSet(pUnifyInfo->DataAfterReduntancy,pUnifyInfo->PrtclRcvSize,0,pUnifyInfo->PrtclRcvSize);
+        CommonMemSet(pUnifyInfo->DataAfterReduntancy, pUnifyInfo->PrtclRcvSize, 0, pUnifyInfo->PrtclRcvSize); /*-< 清零冗余数组*/
     }
-  
+
     /*分配协议内部使用临时变量空间*/
+     /*- 分配给内部使用临时变量空间*/
     lTemp = InputSize + 20;
     pUnifyInfo->CommBuffer = (UINT8*)malloc(lTemp);
-	if (pUnifyInfo->CommBuffer ==NULL)
+    if (pUnifyInfo->CommBuffer == NULL) /*-< 分配空间失败*/
-	{
-		ret =0;
-		return ret;
-	}
-	else
-	{
-		CommonMemSet(pUnifyInfo->CommBuffer,lTemp,0,lTemp);
-	}
-
-    /*分配输出出口数组*/
-    pUnifyInfo->PrtclSndBuff = NULL; 
-    pUnifyInfo->PrtclSndBuff = (UINT8*)malloc(pUnifyInfo->PrtclSndBuffSize);
-    if(pUnifyInfo->PrtclSndBuff == NULL)
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/ 
+        CommonMemSet(pUnifyInfo->CommBuffer, lTemp, 0, lTemp); /*-< 清零临时变量*/
-		CommonMemSet(pUnifyInfo->PrtclSndBuff,sizeof(UINT8)*pUnifyInfo->PrtclSndBuffSize,0,sizeof(UINT8)*pUnifyInfo->PrtclSndBuffSize);		
+    }
+
+    /*- 分配输出出口数组*/
+    pUnifyInfo->PrtclSndBuff = NULL;
+    pUnifyInfo->PrtclSndBuff = (UINT8*)malloc(pUnifyInfo->PrtclSndBuffSize);
+    if (pUnifyInfo->PrtclSndBuff == NULL) /*-< 分配空间失败*/
+    {
+        ret = 0; /*-< 设置函数返回值为失败*/
+        return ret; /*-< 返回函数返回值*/
+    }
+    else
+    {
+        /*无操作*/
+        CommonMemSet(pUnifyInfo->PrtclSndBuff, sizeof(UINT8) * pUnifyInfo->PrtclSndBuffSize, 0, sizeof(UINT8) * pUnifyInfo->PrtclSndBuffSize); /*-< 清零输出出口数组*/
     }
 
 #ifdef SWAP_CRC
+    /*- 分配交互CRC数组*/
     lTemp = 2u + 4u * (pUnifyInfo->MaxNumLink + 2u); /*2字节长度+链路个(4字节目的类型ID+4字节CRC)*/
     pUnifyInfo->SwapCrcs = (UINT8*)malloc(lTemp);
-    if (pUnifyInfo->SwapCrcs == NULL)
+    if (pUnifyInfo->SwapCrcs == NULL) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
         /*无操作*/
-        CommonMemSet(pUnifyInfo->SwapCrcs, sizeof(UINT8) * lTemp, 0, sizeof(UINT8) * lTemp);
+        CommonMemSet(pUnifyInfo->SwapCrcs, sizeof(UINT8) * lTemp, 0, sizeof(UINT8) * lTemp); /*-< 清零交互CRC数组*/
     }
 #endif
-  
+
-    /*记录数组的空间分配*/
+    /*- 记录数组的空间分配*/
     pUnifyInfo->RecordArray = NULL;
-    pUnifyInfo->RecordArray = (UINT8*)malloc(pUnifyInfo->RecordArraySize+2);
+    pUnifyInfo->RecordArray = (UINT8*)malloc(pUnifyInfo->RecordArraySize + 2);
-    if(pUnifyInfo->RecordArray == NULL)
+    if (pUnifyInfo->RecordArray == NULL) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
-    }
-    else
-    {
-        /*无操作*/ 
-		CommonMemSet(pUnifyInfo->RecordArray,sizeof(UINT8)*(pUnifyInfo->RecordArraySize+2),0,sizeof(UINT8)*(pUnifyInfo->RecordArraySize+2));	
-    }
-  
-  
-    /*分配链路管理表堆栈空间*/
-    pUnifyInfo->LnkStack.pNode = NULL;
-    pUnifyInfo->LnkStack.pNode = (void**)malloc(MaxNumLink * sizeof(void*));
-    pUnifyInfo->LnkStack.totalsize = (UINT16) MaxNumLink;
-    if(pUnifyInfo->LnkStack.pNode == NULL)
-    {
-        ret = 0;
-        return ret;
     }
     else
     {
         /*无操作*/
-		CommonMemSet(pUnifyInfo->LnkStack.pNode,MaxNumLink * sizeof(void*),0,MaxNumLink * sizeof(void*));
+        CommonMemSet(pUnifyInfo->RecordArray, sizeof(UINT8) * (pUnifyInfo->RecordArraySize + 2), 0, sizeof(UINT8) * (pUnifyInfo->RecordArraySize + 2)); /*-< 清零记录数组*/
     }
-  
+
-    /*分配输出链表堆栈空间*/
+
+    /*- 分配链路管理表堆栈空间*/
+    pUnifyInfo->LnkStack.pNode = NULL;
+    pUnifyInfo->LnkStack.pNode = (void**)malloc(MaxNumLink * sizeof(void*));
+    pUnifyInfo->LnkStack.totalsize = (UINT16)MaxNumLink;
+    if (pUnifyInfo->LnkStack.pNode == NULL) /*-< 分配空间失败*/
+    {
+        ret = 0; /*-< 设置函数返回值为失败*/
+        return ret; /*-< 返回函数返回值*/
+    }
+    else
+    {
+        /*无操作*/
+        CommonMemSet(pUnifyInfo->LnkStack.pNode, MaxNumLink * sizeof(void*), 0, MaxNumLink * sizeof(void*)); /*-< 清零链路管理表堆栈*/
+    }
+
+    /*- 分配输出链表堆栈空间*/
     pUnifyInfo->OutputStack.pNode = NULL;
     pUnifyInfo->OutputStack.pNode = (void**)malloc(MaxNumLink * sizeof(void*));
-    pUnifyInfo->OutputStack.totalsize = (UINT16) MaxNumLink;
+    pUnifyInfo->OutputStack.totalsize = (UINT16)MaxNumLink;
-    if(pUnifyInfo->OutputStack.pNode == NULL)
+    if (pUnifyInfo->OutputStack.pNode == NULL) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/ 
+        /*无操作*/
-		CommonMemSet(pUnifyInfo->OutputStack.pNode,MaxNumLink * sizeof(void*),0,MaxNumLink * sizeof(void*));
+        CommonMemSet(pUnifyInfo->OutputStack.pNode, MaxNumLink * sizeof(void*), 0, MaxNumLink * sizeof(void*)); /*-< 清零输出链表堆栈*/
-    } 
+    }
-     
+
-    /*分配冗余链表堆栈空间*/
+    /*- 分配冗余链表堆栈空间*/
     pUnifyInfo->InputStack.pNode = NULL;
     pUnifyInfo->InputStack.pNode = (void**)malloc((UINT16)MaxNumLink * MaxNumPerCycle * sizeof(void*));
-    pUnifyInfo->InputStack.totalsize = (UINT16) MaxNumLink * MaxNumPerCycle;
+    pUnifyInfo->InputStack.totalsize = (UINT16)MaxNumLink * MaxNumPerCycle;
-    if(pUnifyInfo->InputStack.pNode == NULL)
+    if (pUnifyInfo->InputStack.pNode == NULL) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/   
+        /*无操作*/
-		CommonMemSet(pUnifyInfo->InputStack.pNode,MaxNumLink * MaxNumPerCycle* sizeof(void*),0,MaxNumLink * MaxNumPerCycle* sizeof(void*));
+        CommonMemSet(pUnifyInfo->InputStack.pNode, MaxNumLink * MaxNumPerCycle * sizeof(void*), 0, MaxNumLink * MaxNumPerCycle * sizeof(void*)); /*-< 清零冗余链表堆栈*/
     }
 
-    pUnifyInfo->NetsRecvPkgNums = (SfpNetsRecvPkgNum*)malloc(sizeof(SfpNetsRecvPkgNum) * pUnifyInfo->MaxNumLink);
+    pUnifyInfo->NetsRecvPkgNumsLen = 0u; /*-< 设置各网收到包数数组长度为0*/
-    if (NULL == pUnifyInfo->NetsRecvPkgNums)
+    pUnifyInfo->NetsRecvPkgNums = (SfpNetsRecvPkgNum*)malloc(sizeof(SfpNetsRecvPkgNum) * pUnifyInfo->MaxNumLink); /*-< 分配各网收到包数数组*/
+    if (NULL == pUnifyInfo->NetsRecvPkgNums) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        CommonMemSet(pUnifyInfo->NetsRecvPkgNums, sizeof(SfpNetsRecvPkgNum) * pUnifyInfo->MaxNumLink, 0, sizeof(SfpNetsRecvPkgNum) * pUnifyInfo->MaxNumLink);
+        CommonMemSet(pUnifyInfo->NetsRecvPkgNums, sizeof(SfpNetsRecvPkgNum) * pUnifyInfo->MaxNumLink, 0, sizeof(SfpNetsRecvPkgNum) * pUnifyInfo->MaxNumLink); /*-< 清零各网收到包数数组*/
     }
 
-    /*分配断链信息结构体空间*/
+    /*- 分配断链信息结构体空间*/
     lTemp = dsuGetObjNum(pUnifyInfo);    /*数据库中节点数*/
     pUnifyInfo->NumBuildLink = NULL;
-    pUnifyInfo->NumBuildLink = (DuanLianInfo*) malloc(lTemp * sizeof(DuanLianInfo));
+    pUnifyInfo->NumBuildLink = (DuanLianInfo*)malloc(lTemp * sizeof(DuanLianInfo));
-    if(pUnifyInfo->NumBuildLink == NULL)
+    if (pUnifyInfo->NumBuildLink == NULL) /*-< 分配空间失败*/
     {
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/ 
+        /*无操作*/
-		CommonMemSet(pUnifyInfo->NumBuildLink,lTemp * sizeof(DuanLianInfo),0,lTemp * sizeof(DuanLianInfo));		
+        CommonMemSet(pUnifyInfo->NumBuildLink, lTemp * sizeof(DuanLianInfo), 0, lTemp * sizeof(DuanLianInfo)); /*-< 清零断链信息*/
     }
- 
+
-    if(!InitLnkMngr(pUnifyInfo))                   /*通信链路管理表初始化*/
+    if (!InitLnkMngr(pUnifyInfo)) /*-< 调用通信链路管理表初始化函数,调用失败*/
     {
 #ifdef _DEBUG_
         printf("InitLnkMngr error\n");
 #endif
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/    
+        /*无操作*/
     }
-     
+
-    if(!RedundancyInitial(pUnifyInfo))            /*通信冗余处理初始化*/
+    if (!RedundancyInitial(pUnifyInfo)) /*-< 调用通信冗余处理初始化函数,调用失败*/
     {
 #ifdef _DEBUG_
         printf("RedundancyInitial error\n");
 #endif
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/    
+        /*无操作*/
     }
-     
+
-    if(!Prtcl_RecInitial(pUnifyInfo))            /*通信协议输入初始化*/
+    if (!Prtcl_RecInitial(pUnifyInfo)) /*-< 调用通信协议输入初始化函数,调用失败*/
     {
 #ifdef _DEBUG_
         printf("Prtcl_RecInitial error\n");
 #endif
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/    
+        /*无操作*/
     }
-     
+
-    if(!Prtcl_OutputInitial(pUnifyInfo))            /*通信协议输出初始化*/
+    if (!Prtcl_OutputInitial(pUnifyInfo)) /*-< 通信协议输出初始化,调用失败*/
     {
 #ifdef _DEBUG_
         printf("Prtcl_OutputInitial error\n");
 #endif
-        ret = 0;
+        ret = 0; /*-< 设置函数返回值为失败*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
-        /*无操作*/    
+        /*无操作*/
     }
-    
+
-    ret = 1;
+    ret = 1; /*-< 设置函数返回值为成功*/
-    return ret;
+    return ret; /*-< 返回函数返回值*/
 }
 
 

TSCP/src/protocol/sfp_record_cbtc1/common_sfp/sfpPrtclReceive.h

@@ -56,21 +56,6 @@ static UINT8 Redundancy(struc_Unify_Info *pUnifyInfo);
 *******************************************************************************************/
 UINT8 RedundancyInitial(struc_Unify_Info *pUnifyInfo);
 
-/*
-*函数名:	RedundancyReceive
-*功能描述:	接收数据，并进行冗余处理
-*				1、从队列中读出每一帧数据
-*				2、判断本方与对方的逻辑地址是否合法
-*				3、判断CRC是否正确
-*				4、判断报方类型。
-*				5、收到RFC帧，查链路管理表，如果存在，根据链路管理表判断该RFC是否合法，如果不存在，插入一维链表。
-*				6、收到ACK帧，通过链路管理表判断该ACK是否合法，如果合法，通过一维链表判断是否是冗余帧
-*				7、收到DATA帧，通过链路管理表判断该DATA是否合法，如果合法，通过一维链表判断是否是冗余帧
-*输入参数:	struc_Unify_Info *pUnifyInfoForRedun	SFP结构体
-*输入出参:	无
-*输出参数:	无
-*返回值:	1:成功;0失败
-*/
 static UINT16 RedundancyReceive(struc_Unify_Info *pUnifyInfoForRedun);
 
 /*

TSCP/src/protocol/sfp_record_cbtc1/common_sfp/sfpPrtcl_Output.c

@@ -32,6 +32,9 @@
 #include "dsuRelatedDeal.h"
 #include "CommonMemory.h"
 
+static UINT8 StSfpOutProData(struc_Unify_Info* pUnifyInfoForOutput, struc_OutputDataBuff** pCurDataBuffItem, struc_OutputDataBuff* pLastDataBuffItem, struc_Lnk_Mngr** pCurProc_Lnk, UINT32* nNumsPrtclSnd);
+static UINT8 StSfpOutProDataLink(struc_Unify_Info* pUnifyInfoForOutput, struc_OutputDataBuff* pCurDataBuffItem, struc_Lnk_Mngr* pCurProc_Lnk, UINT32* nNumsPrtclSnd);
+
 /*
 *函数名:	Insert_OutputDataBuff
 *功能描述:	在输入两节点之间插入一个节点,从堆栈中推出一个单元用来存储数据
@@ -1156,31 +1159,20 @@ static INT8 FillLnkMngr_into_PrtclSnd(struc_Lnk_Mngr *CurLnk, UINT32 *nNumsPrtcl
     return ret;
 }
 
-
+/**
-/******************************************************************************************
+ * @brief ProtclOutput 协议输出单元的主函数,根据协议的规则,将应用传来的数据组帧
-* 功能描述      : 协议输出单元的主函数,根据协议的规则,将应用传来的数据组帧,
+ * @param pUnifyInfo sfp变量 取值范围:参考结构体struc_Unify_Info
-                  并为数据比较单元准备好必需的数据,同时维护链路管理表
+ * @return 0:失败 1:成功
-* 输入参数      : 
+ */
-* 输入输出参数  : struc_Unify_Info* pUnifyInfo  协议统一结构体指针
-* 输出参数      :
-* 全局变量      : UINT32 nNumsPrtclSnd                       协议输出的数据的个数(字节为单位)
-                  struc_Lnk_Mngr *pCurProc_Lnk               链路管理表中当前处理的的链路指针,这里是指针，不是实体*
-                  UINT8 chCurProcItemSrc                     当前要处理的元素的来源 ITEMSRC_BOTH (数据队列和链路管理表) 0x17;ITEMSRC_DATAQUEUE (数据队列) 0x33;ITEMSRC_LNKMNGR(链路管理表) 0x55
-                  struc_OutputDataBuff *pLastDataBuffItem    表示当前处理的数据存储单元的指针
-                  struc_OutputDataBuff *pCurDataBuffItem     表示上一次处理的数据存储单元的指针
-                  struc_Unify_Info *pUnifyInfoForOutput      输出用平台变量结构体指针
-* 返回值        : 正确返回1，错误返回0        
-*******************************************************************************************/
 UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
 {
+    /*- 定义局部变量*/
     UINT8 blNeedToInit;
     UINT8 temp_char[4];
     struc_Lnk_Mngr *CurFillLnk;/*定义当前指针;*/
-    UINT8 Role;
 	/*UINT8 index;*/
     INT8  ResultofGet;/*GetNextItem2Proc的处理结果*/
     INT32 i;
-    UINT16 DSUNumNodes;  /*数据库中节点数*/
 
     /*struc_LnkBasicInfo BasicInfoForLocal;*/
     /* peipei.wang20111011  mod S */
@@ -1190,38 +1182,38 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
     /* peipei.wang20111011  mod E */
 
     UINT32 LocalDevName;
-    UINT8 ret = 0;
+    UINT8 ret = 0; /*-< 设置函数返回值为0*/
 	UINT8 chCurProcItemSrc = 0;	/*当前要处理的元素的来源 ITEMSRC_BOTH (数据队列和链路管理表) 0x17;ITEMSRC_DATAQUEUE (数据队列) 0x33;ITEMSRC_LNKMNGR(链路管理表) 0x55*/
 	struc_Lnk_Mngr *pCurProc_Lnk = NULL;	/*链路管理表中当前处理的的链路指针,这里是指针，不是实体*/
 	struc_OutputDataBuff *pLastDataBuffItem = NULL;	/*表示上一次处理的数据存储单元的指针*/
 	struc_OutputDataBuff *pCurDataBuffItem = NULL;	/*表示当前处理的数据存储单元的指针*/
 	UINT32 nNumsPrtclSnd = 0;	/*协议输出的数据的个数(字节为单位)*/
 	struc_Unify_Info *pUnifyInfoForOutput = pUnifyInfo;	/*SFP结构体*/
+    UINT8 funRtn = 0u;
     
-    if(pUnifyInfo == NULL)
+    if(pUnifyInfo == NULL) /*-< 参数是否非空*/
     {
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {}
     
 #ifdef SWAP_CRC
-    ShortToChar(0u, &pUnifyInfoForOutput->SwapCrcs[0]); /*清空*/
+    ShortToChar(0u, &pUnifyInfoForOutput->SwapCrcs[0]); /*-< 清空交互CRC值*/
 #endif
 
-    blNeedToInit = 1;/*需要初始化置真*/
+    blNeedToInit = 1;/*-< 设置需要初始化置真*/
     /*给本地设备名赋值*/
-    LocalDevName = TypeIdToName(pUnifyInfoForOutput->LocalType,pUnifyInfoForOutput->LocalID);
+    LocalDevName = TypeIdToName(pUnifyInfoForOutput->LocalType,pUnifyInfoForOutput->LocalID); /*-< 调用根据类型与ID得到设备名函数*/
-    nNumsPrtclSnd = 8;/*协议输出帧长度初始化,从第五位开始写*/
+    nNumsPrtclSnd = 8; /*-< 设置协议输出帧长度初为8*/
 
 	/* peipei.wang20111011  mod S */
     /*删除输出模块绝对超时时间，追加获取输出开始时间*/
     /*AbsTimeoutForOutput = GetTick(pUnifyInfoForOutput) + pUnifyInfoForOutput->OutputTimeout;*/
     /*获取输出开始时间*/
-    startTimeoutForOutput = GetTick(pUnifyInfoForOutput);
+    startTimeoutForOutput = GetTick(pUnifyInfoForOutput); /*-< 得到开始时间*/
     /* peipei.wang20111011  mod E */
-     
+        
-    DSUNumNodes = dsuGetObjNum(pUnifyInfoForOutput);   /*数据库中节点数*/     
 #ifdef PRTCL_RECORD_ERR_ASC
     /*当前的Tick，和冗余开始标记*/
     PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"Output: ");
@@ -1239,6 +1231,7 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
     PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"\n");
 #endif
 #ifdef PRTCL_RECORD_SIMPLIFY_BIN
+    /*- 记录本方类型ID日志*/
     PrintRecArrayByte(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,0x03);
     PrintRecArrayByte(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, 
         pUnifyInfoForOutput->LocalType); 
@@ -1247,315 +1240,82 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
    
 #endif
 
-    
+       
-    /*将出口数组的数组长度和数组长度0清零*/
+    for(i = 0;i < 8; i++) /*-< 输出数据下标是否小于8*/
-    for(i = 0;i < 8; i++)
     {
-        pUnifyInfoForOutput->PrtclSndBuff[i] = 0;    
+        pUnifyInfoForOutput->PrtclSndBuff[i] = 0; /*-< 将出口数组的数组长度和数组长度0清零*/
     }
 
 	/*将数据从数据队列读取填充到数据缓冲链表中去*/
-    if( Queue2Buff(pUnifyInfoForOutput) == -1)/*填充失败，返回错误*/
+    if( Queue2Buff(pUnifyInfoForOutput) == -1) /*-< 是否填充失败*/
     {
-        ret = 1;
+        ret = 1; /*-< 设置函数返回值为1*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
         /*填充成功*/    
     }
-	ResultofGet = GetNextItem2Proc(blNeedToInit, &chCurProcItemSrc, &pCurProc_Lnk, &pLastDataBuffItem, &pCurDataBuffItem, pUnifyInfoForOutput);
+	ResultofGet = GetNextItem2Proc(blNeedToInit, &chCurProcItemSrc, &pCurProc_Lnk, &pLastDataBuffItem, &pCurDataBuffItem, pUnifyInfoForOutput); /*-< 调用下个元素函数*/
-    if(ResultofGet < 0)/*错误处理*/
+    if(ResultofGet < 0) /*-< 调用函数是否失败*/
     {
-        ret = 1;
+        ret = 1; /*-< 设置函数返回值为1*/
-        return ret;
+        return ret; /*-< 返回函数返回值*/
     }
     else
     {
         /*得到下一个处理对象正确*/    
     }
 	
-    while(1)/*如果当前的处理元素不为空,说明还有要处理的数据,否则说明处理完毕*/
+    while(1) /*-< 遍历*//*如果当前的处理元素不为空,说明还有要处理的数据,否则说明处理完毕*/
     {
 		/* peipei.wang20111011  mod S */
         /*删除超时判断，追加为当前时间 - 输出开始时间与输出模块执行时限的判断*/
         /*if(GetTick(pUnifyInfoForOutput) < AbsTimeoutForOutput)*/
-        if(IsTimeOut(GetTick(pUnifyInfoForOutput),startTimeoutForOutput,pUnifyInfoForOutput->OutputTimeout) == 0)
+        if(IsTimeOut(GetTick(pUnifyInfoForOutput),startTimeoutForOutput,pUnifyInfoForOutput->OutputTimeout) == 0) /*-< 判断当前是否超时*/
         /* peipei.wang20111011  mod E */	
         { 
 			/*根据本地name（type＋id）导出数据库中基本信息*/
 			
-            if(ResultofGet != 0)
+            if(ResultofGet != 0) /*-< 是否有下一元素处理*/
             {  
-                blNeedToInit = 0;/*需要初始化置假*/
+                blNeedToInit = 0;/*-< 设置需要初始化置假*/
 				/* wangpeipei 20120306 Add S */
 				
 				/* wangpeipei 20120306 Add E */
-                switch(chCurProcItemSrc)/*根据当前要处理的通信对象的来源进行分类操作*/
+                switch(chCurProcItemSrc)/*-< 根据当前要处理的通信对象的来源进行分类操作*/
                 {
 					
-                case ITEMSRC_DATABUFF:/*只在数据缓冲链表出现，在链路管理表中无此对象*/
+                case ITEMSRC_DATABUFF: /*-< 是否数据*//*只在数据缓冲链表出现，在链路管理表中无此对象*/
-                    if(pCurDataBuffItem->DataCycleNum == *pUnifyInfoForOutput->CycleNum)/*如果数据是最新的数据,说明是要申请建链*/
+                    /*数据*/
+                    funRtn = StSfpOutProData(pUnifyInfoForOutput, &pCurDataBuffItem, pLastDataBuffItem, &pCurProc_Lnk, &nNumsPrtclSnd); /*-< 调用处理输出数据函数*/
+                    if (1u == funRtn) /*-< 调用函数是否成功*/
                     {
-						 
+                        ret = 1u; /*-< 设置函数返回值为1*/
-                        if(dsuIsLnkLegal(pUnifyInfoForOutput,pCurDataBuffItem->DevName,&Role))
+                        return ret; /*-< 返回函数返回值*/
-                        {/*如果建链合法*/      				  
-                            if(Role == ROLE_SPON)/*本方为发起方*/
-                            {
-                                /*在链路管理表中添加此条链路，相当于在原来处理的链路之前添加了这一条链路。pCurProc_Lnk是当前要处理的通信对象对应的链路管理表的节点*/
-                                /*如果弹不出链路管理表节点，不返回，继续处理下一帧数据*/
-                                pCurProc_Lnk = InsertLnk(pCurDataBuffItem->DevName,pUnifyInfoForOutput);
-                                if(pCurProc_Lnk == NULL)
-                                {
-                                    /*记录记录*/
-#ifdef PRTCL_RECORD_ERR_ASC
-                                    PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"E:");
-                                    PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
-                                        ERR|OUTPUT|ERROR_NULL|LNKMANAGE_POP);
-                                    PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"\n");
-
-#endif
-#ifdef PRTCL_RECORD_SIMPLIFY_BIN
-                                    PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, 
-                                        ERR|OUTPUT|ERROR_NULL|LNKMANAGE_POP);
-
-#endif
-
-                                }
-                                else 
-                                {                  
-                                    /*更新链路管理表的状态为wConAck，记录本方序列号；*/
-                                    pCurProc_Lnk->Lnk_Info.lLocalSN =  pUnifyInfoForOutput->RadamSN;
-                                    pCurProc_Lnk->Lnk_Info.chStatus = STATUS_WCONACK;
-                                    /*记录RFC的起始序列号*/
-                                    pCurProc_Lnk->Lnk_Info.RfcSN = pUnifyInfoForOutput->RadamSN;
-									BuildFrame(FRAME_RFC, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd, pUnifyInfoForOutput);/*组织RFC帧*/
-                                    /*还原当前要处理的链路，使处理后的结果同删链一样,以便GetNextItem2Proc的统一处理*/
-                                    pCurProc_Lnk = pCurProc_Lnk->NextNode;
-                                }
-                            }
-                            else
-                            {}
-                        }/*建链不合法，不做任何操作*/
-                        else
-                        {
-                                /*记录记录*/
-#ifdef PRTCL_RECORD_ERR_ASC
-                                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"W:");
-                                PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
-                                    WARN|OUTPUT|OBJ_ILLEAGL|ERROR_NULL);
-                                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"\n");                                        
-#endif
-#ifdef PRTCL_RECORD_SIMPLIFY_BIN
-                                PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray,pUnifyInfoForOutput->RecordArraySize,
-                                    WARN|OUTPUT|OBJ_ILLEAGL|ERROR_NULL);
-#endif               
-
-                        }
                     }
-                    else/*不是最新数据,删除这个节点*/
+                    break; /*-< 退出循环*/
-                    {
+                case ITEMSRC_LNKMNGR: /*-< 是否链路*//*只在链路管理表中存在，在数据缓冲链表中不存在:因为在数据缓冲链表中插入节点的操作已经在GetNextItem2Proc完成了,
-                        /*删除节点数据缓冲链表自动跳至此节点的前节点*/
-						pCurDataBuffItem = Delete_OutputDataBuff(pLastDataBuffItem, pCurDataBuffItem, pUnifyInfoForOutput);
-                        if(pCurDataBuffItem == NULL_ITEM)
-                        {
-                            /*记录记录*/
-#ifdef PRTCL_RECORD_ERR_ASC
-                            PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"E:");
-                            PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
-                                ERR|OUTPUT|ERROR_NULL|OUTPUT_LNK_PUSH);
-                            PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"\n");
-
-#endif
-#ifdef PRTCL_RECORD_SIMPLIFY_BIN
-                            PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, 
-                                ERR|OUTPUT|ERROR_NULL|OUTPUT_LNK_PUSH);
-
-#endif    
-
-                            
-                            ret = 1;
-                            return ret;
-                        }
-                        else
-                        {}
-                    }
-                    break;
-                case ITEMSRC_LNKMNGR: /*只在链路管理表中存在，在数据缓冲链表中不存在:因为在数据缓冲链表中插入节点的操作已经在GetNextItem2Proc完成了,
       													故这里应当根据链路管理表的状态进行操作,因此可以采用与两者都有采用一致的处理方法。*/
-                case ITEMSRC_BOTH:		/*当两者都有时,需要根据链路状况和数据状态综合考虑*/
+                case ITEMSRC_BOTH: /*-< 是否数据链路*//*当两者都有时,需要根据链路状况和数据状态综合考虑*/
-                    switch(pCurProc_Lnk->Lnk_Info.chStatus)/*链路状态*/
+                    /*是否数据链路*/
+                    funRtn = StSfpOutProDataLink(pUnifyInfoForOutput, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd); /*-< 调用处理输出数据链路函数*/
+                    if (1u == funRtn) /*-< 调用函数是否成功*/
                     {
-                    case STATUS_DATA:/*数据状态*/
+                        ret = 1u; /*-< 设置函数返回值为1*/
-                        /*本方序列号要有过0处理*/
+                        return ret; /*-< 返回函数返回值*/
-                        if( (pCurProc_Lnk->Lnk_Info.lLocalSN + 1) == 0 )
-                        {
-                            pCurProc_Lnk->Lnk_Info.lLocalSN = 1;
-                        }
-                        else
-                        {
-                            pCurProc_Lnk->Lnk_Info.lLocalSN = (pCurProc_Lnk->Lnk_Info.lLocalSN + 1);
-                        }
-                        switch(pCurDataBuffItem->DataStatus)/*数据存储空间中数据状态*/
-                        {
-                        case SENT:/*已经发送*/
-                            /*组织IDLE帧*/
-							BuildFrame(FRAME_IDLE, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd, pUnifyInfoForOutput);
-                            break;
-                        case NEED2SEND:
-                            /*根据当前数据存储空间中数据组建DATA帧；*/
-							BuildFrame(FRAME_DATA, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd, pUnifyInfoForOutput);
-                            pCurDataBuffItem->DataStatus = SENT;
-                            break;
-                        default:
-                            break;
-                        }
-                        break;
-                    case STATUS_HALT:/*通信中断状态*/
-                        if(pCurProc_Lnk->Lnk_Info.chRole == ROLE_SPON)/*本方为发起方*/
-                        {                
-                            /*说明这种情况下断链过一次这是检测发起方断链的状况*/
-                            for( i = 0;i < DSUNumNodes;i++)/*遍历查找对应的锻炼记录信息*/
-                            {/*我们的原则是先从空的位置开始写,如果已经有过不重新分配单元,否则重新分配单元*/
-                                if (pUnifyInfoForOutput->NumBuildLink[i].DevName == 0x00)/*说明这是空白单元*/
-                                {
-                                    pUnifyInfoForOutput->NumBuildLink[i].DevName = pCurDataBuffItem->DevName;
-                                    pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++;/*累积断链数+1*/
-                                    break;/*跳出*/
-                                }
-                                else
-                                {
-                                    /**/
-                                }
-                                if (pUnifyInfoForOutput->NumBuildLink[i].DevName == pCurDataBuffItem->DevName)/*找到相等的计数*/
-                                {
-                                    pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++;/*累积断链数+1*/
-                                    break;
-                                }
-                                else
-                                {
-                                    /*没有找到，继续查找*/    
-                                }
-                            }
-                            /*更新链路管理表的状态为wConAck，记录本方序列号,更新接收超时*/
-                            pCurProc_Lnk->Lnk_Info.lLocalSN = pUnifyInfoForOutput->RadamSN;
-                            pCurProc_Lnk->Lnk_Info.chStatus = STATUS_WCONACK;
-                            pCurProc_Lnk->Lnk_Info.chNoDataRcvCycle = 0;
-                            /*记录RFC的起始序列号*/
-                            pCurProc_Lnk->Lnk_Info.RfcSN = pUnifyInfoForOutput->RadamSN;
-                            /*组织RFC帧*/
-							BuildFrame(FRAME_RFC, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd, pUnifyInfoForOutput);
-                        }
-                        else
-                        {}
-      				    break;
-                    case STATUS_PRECON:/*收到RFC准备回ACK的状态*/
-                        if(pCurProc_Lnk->Lnk_Info.chRole == ROLE_FLW)/*本方为跟随方*/
-                        {
-                            /*这是检测跟随方断链的状况*/
-                            /*说明这种情况下断链过一次或者是第一次建链,因此在第一次分配单元时没有必要++*/			
-                            for(i = 0;i < DSUNumNodes;i++)/*遍历查找对应的断链记录信息*/
-                            {/*我们的原则是先从空的位置开始写,如果已经有过不重新分配单元,否则重新分配单元*/
-                                if (pUnifyInfoForOutput->NumBuildLink[i].DevName == 0x00)/*说明这是空白单元*/
-                                {
-                                    pUnifyInfoForOutput->NumBuildLink[i].DevName = pCurDataBuffItem->DevName;
-                                    pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++;/*累积断链数+1*/
-                                    break;/*跳出*/
-                                }
-                                else
-                                {
-                                    /**/    
-                                }
-                                if (pUnifyInfoForOutput->NumBuildLink[i].DevName == pCurDataBuffItem->DevName)/*找到相等的计数*/
-                                {
-                                    pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++;/*累积断链数+1*/
-                                    break;
-                                }
-                                else
-                                {
-                                    /*没有找到，继续查找*/ 
-                                }
-                            }
-                            /*更新链路管理表的状态为DATA，记录本方序列号；*/
-                            pCurProc_Lnk->Lnk_Info.lLocalSN = pUnifyInfoForOutput->RadamSN;
-                            pCurProc_Lnk->Lnk_Info.chStatus = STATUS_DATA;
-                            /*记录ACK帧的起始序列号*/
-                            pCurProc_Lnk->Lnk_Info.AckSN = pUnifyInfoForOutput->RadamSN;
-                            /*根据RFC组建ACK帧；*/
-							BuildFrame(FRAME_ACK, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd, pUnifyInfoForOutput);
-                        }
-                        else
-                        {
-                            /*本方为发起方，不做处理*/   
-#ifdef PRTCL_RECORD_ERR_ASC
-                                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"E:");
-                                PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
-                                    ERR|OUTPUT|ROLE_STATUS_CONFLICT|ERROR_NULL);
-                                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"\n");
-
-#endif
-#ifdef PRTCL_RECORD_SIMPLIFY_BIN
-                                PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, 
-                                    ERR|OUTPUT|ROLE_STATUS_CONFLICT|ERROR_NULL);
-
-#endif				
-
-                        }
-                        break;
-                    case STATUS_WCONACK: /*等待ACK状态*/
-                        /*需要根据ACK是否超时来判断是否需要重建链*/
-                        if( pCurProc_Lnk->Lnk_Info.chNoDataRcvCycle  >= pCurProc_Lnk->Lnk_Info.nACKTOut )
-                        {/*重新建链*/
-                            if(pCurProc_Lnk->Lnk_Info.chRole != ROLE_SPON)/*如果不是发起方则报未知错误*/
-                            {
-                                /*记录记录*/
-#ifdef PRTCL_RECORD_ERR_ASC
-                                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"E:");
-                                PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
-                                    ERR|OUTPUT|ROLE_STATUS_CONFLICT|ERROR_NULL);
-                                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"\n");
-
-#endif
-#ifdef PRTCL_RECORD_SIMPLIFY_BIN
-                                PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, 
-                                    ERR|OUTPUT|ROLE_STATUS_CONFLICT|ERROR_NULL);
-
-#endif
-
-                                ret = 1;
-                                return ret;/*报错*/
-                            }
-                            else
-                            {
-                                /*本方是发起方，执行下面的操作*/    
-                            }					
-                            /*更新链路管理表的状态为wConAck，记录本方序列号,更新接收超时*/
-                            pCurProc_Lnk->Lnk_Info.lLocalSN =  pUnifyInfoForOutput->RadamSN;
-                            pCurProc_Lnk->Lnk_Info.chStatus = STATUS_WCONACK;
-                            pCurProc_Lnk->Lnk_Info.chNoDataRcvCycle = 0;
-                            /*记录RFC的起始序列号*/
-                            pCurProc_Lnk->Lnk_Info.RfcSN = pUnifyInfoForOutput->RadamSN;
-                            /*组织RFC帧*/
-							BuildFrame(FRAME_RFC, pCurDataBuffItem, pCurProc_Lnk, &nNumsPrtclSnd, pUnifyInfoForOutput);
-                        }
-                        else
-                        {
-                            /*没有超时，不处理*/    
-                        }
-                        break;
-                    default:
-                        break;              
                     }
-                    break;
+                    break; /*-< 退出循环*/
-                default:
+                default: /*-< 其他*/
-                    break;
+                    /*是否数据链路*/
+                    break; /*-< 退出循环*/
                 }
                 
-				ResultofGet = GetNextItem2Proc(blNeedToInit, &chCurProcItemSrc, &pCurProc_Lnk, &pLastDataBuffItem, &pCurDataBuffItem, pUnifyInfoForOutput);
+				ResultofGet = GetNextItem2Proc(blNeedToInit, &chCurProcItemSrc, &pCurProc_Lnk, &pLastDataBuffItem, &pCurDataBuffItem, pUnifyInfoForOutput); /*-< 调用下个元素函数*/
-                if(ResultofGet < 0) /*为下一次的循环准备好数据*/
+                if(ResultofGet < 0) /*-< 调用函数是否失败*/
                 {
-                    ret = 1;
+                    ret = 1; /*-< 设置函数返回值为1*/
-                    return ret;
+                    return ret; /*-< 返回函数返回值*/
                 }
                 else
                 {
@@ -1564,7 +1324,7 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
     		}	
             else
             {  
-                break;/*读取完毕，跳出循环*/
+                break; /*-< 退出循环*/
             }
         }	
         else
@@ -1578,31 +1338,32 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
 
 #endif
 #ifdef PRTCL_RECORD_SIMPLIFY_BIN
+            /*- 记录超时日志*/
             PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, 
                 ERR|OUTPUT|ERROR_NULL|TIMEOUT);
 
 #endif
 
-            break;
+            break; /*-< 退出循环*/
         } 
 	}
-    /*添加相关数据长度,不包含逐位比较*/
+    /*- 添加单帧数据长度*/
     LongToChar( (UINT32)(nNumsPrtclSnd - 8),temp_char);
-    /*数据长度0*/
+    /*设置数据长度0*/
     pUnifyInfoForOutput->PrtclSndBuff[4] = temp_char[0];
     pUnifyInfoForOutput->PrtclSndBuff[5] = temp_char[1];
     pUnifyInfoForOutput->PrtclSndBuff[6] = temp_char[2];
     pUnifyInfoForOutput->PrtclSndBuff[7] = temp_char[3];
 
-    /*添加链路管理表信息*/
+    /*- 添加链路管理表信息*/
     CurFillLnk =  pUnifyInfoForOutput->LnkHead;/*定位到链路管理表头指针*/
     /*记录记录*/
 #ifdef PRTCL_RECORD_DATA_ASC
     PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,"Links:\n");
 #endif
-    while (CurFillLnk != NULL)
+    while (CurFillLnk != NULL) /*-< 当前链路是否非空*/
     {
-        if((pUnifyInfoForOutput->PrtclSndBuffSize - nNumsPrtclSnd) < LNKFRAMELEN)
+        if((pUnifyInfoForOutput->PrtclSndBuffSize - nNumsPrtclSnd) < LNKFRAMELEN) /*-< 长度是否小于链路数据长度*/
         {
             /*记录记录*/
 #ifdef PRTCL_RECORD_ERR_ASC
@@ -1618,27 +1379,27 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
 
 #endif
 
-	        /*添加帧长度*/
+	        /*- 添加帧长度*/
             LongToChar( (UINT32)(nNumsPrtclSnd - 4),temp_char);/*不包含数据长度的四个字节*/
-	        /*输出数组长度不够，记录已填入的长度*/
+	        /*- 输出数组长度不够，记录已填入的长度*/
   	        pUnifyInfoForOutput->PrtclSndBuff[0] = temp_char[0];
   	        pUnifyInfoForOutput->PrtclSndBuff[1] = temp_char[1];
   	        pUnifyInfoForOutput->PrtclSndBuff[2] = temp_char[2];
   	        pUnifyInfoForOutput->PrtclSndBuff[3] = temp_char[3];
-            ret = 1;
+            ret = 1; /*-< 设置函数返回值为1*/
-            return ret;
+            return ret; /*-< 返回函数返回值*/
         }
         else
         {
             /*字节数正确*/    
         }
-        /*添加特定链路到数组中*/		
+        /*- 添加特定链路到数组中*/		
 		FillLnkMngr_into_PrtclSnd(CurFillLnk, &nNumsPrtclSnd, pUnifyInfoForOutput);
         /*记录记录,链路状态信息*/	
         /*当前处理的链路管理表的节点后移一个节点*/
         CurFillLnk = CurFillLnk->NextNode;
     }	
-    /*添加帧长度*/
+    /*- 添加总数据长度*/
     LongToChar( (UINT32)(nNumsPrtclSnd - 4),temp_char);/*不包含数据长度的两个字节*/
     pUnifyInfoForOutput->PrtclSndBuff[0] = temp_char[0];
     pUnifyInfoForOutput->PrtclSndBuff[1] = temp_char[1];
@@ -1655,6 +1416,7 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
 #endif
 
 #ifdef PRTCL_RECORD_SIMPLIFY_BIN
+    /*- 记录输出结束日志*/
     PrintRecArrayByte(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
         0xE0);
     /*整个输出数组长度*/
@@ -1673,8 +1435,8 @@ UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo)/* %RELAX<MISRA_8_10> */
     PrintFilec(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,'\n');
 #endif
     
-    ret = 1;
+    ret = 1; /*-< 设置函数返回值为1*/
-    return ret;
+    return ret; /*-< 返回函数返回值*/
 }
 
 /*
@@ -1883,4 +1645,312 @@ void SfpSetSwapDataForOut(UINT8 swapData[], UINT8 outData[], struc_Unify_Info* s
             PrintRecArray2ByteB(record, recordSize, swapDataLen);
         }
     }
+}
+
+/**
+ * @brief StSfpOutProData 处理输出数据
+ * @param pUnifyInfoForOutput sfp变量 取值范围:参考结构体struc_Unify_Info
+ * @param pCurDataBuffItem 当前元素 取值范围:参考枚举struc_OutputDataBuff
+ * @param pLastDataBuffItem 之前元素 取值范围:参考枚举struc_OutputDataBuff
+ * @param pCurProc_Lnk 当前链路 取值范围:参考枚举struc_Lnk_Mngr
+ * @param nNumsPrtclSnd 输出数据下标 取值范围:0x00000000-0xFFFFFFFF
+ * @return 0:不退出 1:退出
+ */
+static UINT8 StSfpOutProData(struc_Unify_Info* pUnifyInfoForOutput, struc_OutputDataBuff** pCurDataBuffItem, struc_OutputDataBuff* pLastDataBuffItem, struc_Lnk_Mngr** pCurProc_Lnk, UINT32* nNumsPrtclSnd)
+{
+    /*- 定义局部变量*/
+    UINT8 rtnVal = 0u; /*-< 设置函数返回值为0*/
+    UINT8 Role = 0u;
+
+    if ((NULL != pUnifyInfoForOutput) && (NULL != pCurDataBuffItem) && (NULL != (*pCurDataBuffItem)) && (NULL != pCurProc_Lnk) && (NULL != nNumsPrtclSnd)) /*-< 参数是否非空*/
+    {
+        if ((*pCurDataBuffItem)->DataCycleNum == (*(pUnifyInfoForOutput->CycleNum))) /*-< 数据是否新数据*//*如果数据是最新的数据,说明是要申请建链*/
+        {
+            if (dsuIsLnkLegal(pUnifyInfoForOutput, (*pCurDataBuffItem)->DevName, &Role)) /*-< 调用函数得本方类型*/
+            {/*如果建链合法*/
+                if (Role == ROLE_SPON) /*-< 本方是否为发起方*/
+                {
+                    /*在链路管理表中添加此条链路，相当于在原来处理的链路之前添加了这一条链路。pCurProc_Lnk是当前要处理的通信对象对应的链路管理表的节点*/
+                    /*如果弹不出链路管理表节点，不返回，继续处理下一帧数据*/
+                    (*pCurProc_Lnk) = InsertLnk((*pCurDataBuffItem)->DevName, pUnifyInfoForOutput); /*-< 调用插入链路函数*/
+                    if ((*pCurProc_Lnk) == NULL) /*-< 新链路是否为空*/
+                    {
+                        /*记录记录*/
+#ifdef PRTCL_RECORD_ERR_ASC
+                        PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "E:");
+                        PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                            ERR | OUTPUT | ERROR_NULL | LNKMANAGE_POP);
+                        PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "\n");
+
+#endif
+#ifdef PRTCL_RECORD_SIMPLIFY_BIN
+                        /*- 记录新链路为空日志*/
+                        PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                            ERR | OUTPUT | ERROR_NULL | LNKMANAGE_POP);
+
+#endif
+
+                    }
+                    else
+                    {
+                        /*- 更新链路管理表的状态为wConAck，记录本方序列号*/
+                        (*pCurProc_Lnk)->Lnk_Info.lLocalSN = pUnifyInfoForOutput->RadamSN;
+                        (*pCurProc_Lnk)->Lnk_Info.chStatus = STATUS_WCONACK;
+                        /*- 记录RFC的起始序列号*/
+                        (*pCurProc_Lnk)->Lnk_Info.RfcSN = pUnifyInfoForOutput->RadamSN;
+                        BuildFrame(FRAME_RFC, (*pCurDataBuffItem), (*pCurProc_Lnk), nNumsPrtclSnd, pUnifyInfoForOutput); /*-< 组织RFC帧*/
+                        /*- 还原当前要处理的链路，使处理后的结果同删链一样,以便GetNextItem2Proc的统一处理*/
+                        (*pCurProc_Lnk) = (*pCurProc_Lnk)->NextNode;
+                    }
+                }
+                else
+                {
+                }
+            }/*建链不合法，不做任何操作*/
+            else
+            {
+                /*记录记录*/
+#ifdef PRTCL_RECORD_ERR_ASC
+                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "W:");
+                PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                    WARN | OUTPUT | OBJ_ILLEAGL | ERROR_NULL);
+                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "\n");
+#endif
+#ifdef PRTCL_RECORD_SIMPLIFY_BIN
+                /*- 记录得到本方类型错误日志*/
+                PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                    WARN | OUTPUT | OBJ_ILLEAGL | ERROR_NULL);
+#endif               
+
+            }
+        }
+        else/*不是最新数据,删除这个节点*/
+        {
+            /*删除节点数据缓冲链表自动跳至此节点的前节点*/
+            (*pCurDataBuffItem) = Delete_OutputDataBuff(pLastDataBuffItem, (*pCurDataBuffItem), pUnifyInfoForOutput); /*-< 调用删除节点函数*/
+            if ((*pCurDataBuffItem) == NULL_ITEM) /*-< 调用函数是否失败*/
+            {
+                /*记录记录*/
+#ifdef PRTCL_RECORD_ERR_ASC
+                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "E:");
+                PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                    ERR | OUTPUT | ERROR_NULL | OUTPUT_LNK_PUSH);
+                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "\n");
+
+#endif
+#ifdef PRTCL_RECORD_SIMPLIFY_BIN
+                /*- 记录删除节点错误日志*/
+                PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                    ERR | OUTPUT | ERROR_NULL | OUTPUT_LNK_PUSH);
+
+#endif    
+
+
+                rtnVal = 1u; /*-< 设置函数返回值为1*/
+            }
+            else
+            {
+            }
+        }
+    }
+    else
+    {
+        rtnVal = 1u; /*-< 设置函数返回值为1*/
+    }
+
+    return rtnVal; /*-< 返回函数返回值*/
+}
+
+/**
+ * @brief StSfpOutProDataLink 处理输出数据链路
+ * @param pUnifyInfoForOutput sfp变量 取值范围:参考结构体struc_Unify_Info
+ * @param pCurDataBuffItem 当前元素 取值范围:参考枚举struc_OutputDataBuff
+ * @param pCurProc_Lnk 当前链路 取值范围:参考枚举struc_Lnk_Mngr
+ * @param nNumsPrtclSnd 输出数据下标 取值范围:0x00000000-0xFFFFFFFF
+ * @return 0:不退出 1:退出
+ */
+static UINT8 StSfpOutProDataLink(struc_Unify_Info* pUnifyInfoForOutput, struc_OutputDataBuff* pCurDataBuffItem, struc_Lnk_Mngr* pCurProc_Lnk, UINT32* nNumsPrtclSnd)
+{
+    /*- 定义局部变量*/
+    UINT8 rtnVal = 0u; /*-< 设置函数返回值为0*/
+    UINT16 i = 0u;
+    UINT16 DSUNumNodes = 0u;  /*数据库中节点数*/
+
+    if ((NULL != pUnifyInfoForOutput) && (NULL != pCurDataBuffItem) && (NULL != pCurProc_Lnk) ) /*-< 参数是否非空*/
+    {
+        DSUNumNodes = dsuGetObjNum(pUnifyInfoForOutput); /*-< 得到数据库中节点数*/
+
+        switch (pCurProc_Lnk->Lnk_Info.chStatus) /*-< 判断链路状态*/
+        {
+        case STATUS_DATA: /*-< 是否数据状态*/
+            /*本方序列号要有过0处理*/            
+            if ((pCurProc_Lnk->Lnk_Info.lLocalSN + 1) == 0) /*-< 本方序号+1是否为0*/
+            {
+                pCurProc_Lnk->Lnk_Info.lLocalSN = 1; /*-< 设置本方序号1*/
+            }
+            else
+            {
+                pCurProc_Lnk->Lnk_Info.lLocalSN = (pCurProc_Lnk->Lnk_Info.lLocalSN + 1); /*-< 设置本方序号加1*/
+            }
+            switch (pCurDataBuffItem->DataStatus) /*-< 是否数据存储空间中数据状态*/
+            {
+            case SENT: /*-< 是否发空闲*/
+                /*组织IDLE帧*/
+                BuildFrame(FRAME_IDLE, pCurDataBuffItem, pCurProc_Lnk, nNumsPrtclSnd, pUnifyInfoForOutput); /*-< 调用构建帧函数构建空闲帧*/
+                break; /*-< 退出*/
+            case NEED2SEND: /*-< 是否发数据*/
+                /*根据当前数据存储空间中数据组建DATA帧；*/
+                BuildFrame(FRAME_DATA, pCurDataBuffItem, pCurProc_Lnk, nNumsPrtclSnd, pUnifyInfoForOutput); /*-< 调用构建帧函数构建数据帧*/
+                pCurDataBuffItem->DataStatus = SENT; /*-< 设置数据状态为发送*/
+                break; /*-< 退出*/
+            default: /*-< 其他*/
+                /*其他*/
+                break; /*-< 退出*/
+            }
+            break; /*-< 退出*/
+        case STATUS_HALT: /*-< 是否通信中断状态*/
+            if (pCurProc_Lnk->Lnk_Info.chRole == ROLE_SPON) /*-< 是否本方为发起方*/
+            {
+                /*说明这种情况下断链过一次这是检测发起方断链的状况*/
+                for (i = 0; i < DSUNumNodes; i++) /*-< 遍历查找对应的锻炼记录信息*/
+                {/*我们的原则是先从空的位置开始写,如果已经有过不重新分配单元,否则重新分配单元*/
+                    if (pUnifyInfoForOutput->NumBuildLink[i].DevName == 0x00) /*-< 是否链路设备名为0*/
+                    {
+                        pUnifyInfoForOutput->NumBuildLink[i].DevName = pCurDataBuffItem->DevName; /*-< 设置设备名为元素中设备名*/
+                        pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++; /*-< 累积断链数自增1*/
+                        break; /*-< 退出遍历*/
+                    }
+                    else
+                    {
+                        /**/
+                    }
+                    if (pUnifyInfoForOutput->NumBuildLink[i].DevName == pCurDataBuffItem->DevName) /*-< 是否链路设备名为元素中设备名*/
+                    {
+                        pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++; /*-< 累积断链数自增1*/
+                        break; /*-< 退出遍历*/
+                    }
+                    else
+                    {
+                        /*没有找到，继续查找*/
+                    }
+                }
+                /*- 更新链路管理表的状态为wConAck，记录本方序列号,更新接收超时*/
+                pCurProc_Lnk->Lnk_Info.lLocalSN = pUnifyInfoForOutput->RadamSN;
+                pCurProc_Lnk->Lnk_Info.chStatus = STATUS_WCONACK;
+                pCurProc_Lnk->Lnk_Info.chNoDataRcvCycle = 0;
+                /*- 记录RFC的起始序列号*/
+                pCurProc_Lnk->Lnk_Info.RfcSN = pUnifyInfoForOutput->RadamSN;
+                /*- 组织RFC帧*/
+                BuildFrame(FRAME_RFC, pCurDataBuffItem, pCurProc_Lnk, nNumsPrtclSnd, pUnifyInfoForOutput);
+            }
+            else
+            {
+            }
+            break; /*-< 退出*/
+        case STATUS_PRECON: /*-< 是否收到RFC准备回ACK的状态*/
+            if (pCurProc_Lnk->Lnk_Info.chRole == ROLE_FLW) /*-< 本方为跟随方*/
+            {
+                /*这是检测跟随方断链的状况*/
+                /*说明这种情况下断链过一次或者是第一次建链,因此在第一次分配单元时没有必要++*/
+                for (i = 0; i < DSUNumNodes; i++) /*-< 遍历查找对应的锻炼记录信息*/
+                {/*我们的原则是先从空的位置开始写,如果已经有过不重新分配单元,否则重新分配单元*/
+                    if (pUnifyInfoForOutput->NumBuildLink[i].DevName == 0x00) /*-< 是否链路设备名为0*/
+                    {
+                        pUnifyInfoForOutput->NumBuildLink[i].DevName = pCurDataBuffItem->DevName; /*-< 设置设备名为元素中设备名*/
+                        pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++; /*-< 累积断链数自增1*/
+                        break; /*-< 退出遍历*/
+                    }
+                    else
+                    {
+                        /**/
+                    }
+                    if (pUnifyInfoForOutput->NumBuildLink[i].DevName == pCurDataBuffItem->DevName) /*-< 是否链路设备名为元素中设备名*/
+                    {
+                        pUnifyInfoForOutput->NumBuildLink[i].nTotalNums_DuanLian++; /*-< 累积断链数自增1*/
+                        break; /*-< 退出遍历*/
+                    }
+                    else
+                    {
+                        /*没有找到，继续查找*/
+                    }
+                }
+                /*- 更新链路管理表的状态为DATA,记录本方序列号*/
+                pCurProc_Lnk->Lnk_Info.lLocalSN = pUnifyInfoForOutput->RadamSN;
+                pCurProc_Lnk->Lnk_Info.chStatus = STATUS_DATA;
+                /*- 记录ACK帧的起始序列号*/
+                pCurProc_Lnk->Lnk_Info.AckSN = pUnifyInfoForOutput->RadamSN;
+                /*- 根据RFC组建ACK帧*/
+                BuildFrame(FRAME_ACK, pCurDataBuffItem, pCurProc_Lnk, nNumsPrtclSnd, pUnifyInfoForOutput);
+            }
+            else
+            {
+                /*本方为发起方，不做处理*/
+#ifdef PRTCL_RECORD_ERR_ASC
+                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "E:");
+                PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                    ERR | OUTPUT | ROLE_STATUS_CONFLICT | ERROR_NULL);
+                PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "\n");
+
+#endif
+#ifdef PRTCL_RECORD_SIMPLIFY_BIN
+                /*- 记录状态错误日志*/
+                PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                    ERR | OUTPUT | ROLE_STATUS_CONFLICT | ERROR_NULL);
+
+#endif				
+
+            }
+            break;
+        case STATUS_WCONACK: /*-< 是否等待ACK状态*/
+            /*需要根据ACK是否超时来判断是否需要重建链*/
+            if (pCurProc_Lnk->Lnk_Info.chNoDataRcvCycle >= pCurProc_Lnk->Lnk_Info.nACKTOut) /*-< 无数据周期是否超等ACK容忍*/
+            {/*重新建链*/
+                if (pCurProc_Lnk->Lnk_Info.chRole != ROLE_SPON) /*-< 是否不是发起方*/
+                {
+                    /*记录记录*/
+#ifdef PRTCL_RECORD_ERR_ASC
+                    PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "E:");
+                    PrintFileU16Hex(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                        ERR | OUTPUT | ROLE_STATUS_CONFLICT | ERROR_NULL);
+                    PrintFiles(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize, "\n");
+
+#endif
+#ifdef PRTCL_RECORD_SIMPLIFY_BIN
+                    /*- 记录角色错误日志*/
+                    PrintRecArray2ByteB(pUnifyInfoForOutput->RecordArray, pUnifyInfoForOutput->RecordArraySize,
+                        ERR | OUTPUT | ROLE_STATUS_CONFLICT | ERROR_NULL);
+
+#endif
+
+                    rtnVal = 1u; /*-< 设置函数返回值为1*/
+                }
+                else
+                {
+                    /*本方是发起方，执行下面的操作*/
+                }
+                /*- 更新链路管理表的状态为wConAck,记录本方序列号,更新接收超时*/
+                pCurProc_Lnk->Lnk_Info.lLocalSN = pUnifyInfoForOutput->RadamSN;
+                pCurProc_Lnk->Lnk_Info.chStatus = STATUS_WCONACK;
+                pCurProc_Lnk->Lnk_Info.chNoDataRcvCycle = 0;
+                /*- 记录RFC的起始序列号*/
+                pCurProc_Lnk->Lnk_Info.RfcSN = pUnifyInfoForOutput->RadamSN;
+                /*- 组织RFC帧*/
+                BuildFrame(FRAME_RFC, pCurDataBuffItem, pCurProc_Lnk, nNumsPrtclSnd, pUnifyInfoForOutput);
+            }
+            else
+            {
+                /*没有超时，不处理*/
+            }
+            break; /*-< 退出*/
+        default: /*-< 其他*/
+            /*其他*/
+            break; /*-< 退出*/
+        }
+    }
+    else
+    {
+        rtnVal = 1u; /*-< 设置函数返回值为1*/
+    }
+
+    return rtnVal; /*-< 返回函数返回值*/
 }

TSCP/src/protocol/sfp_record_cbtc1/common_sfp/sfpplatform.h

@@ -129,22 +129,12 @@ extern "C" {
 *******************************************************************************************/
 UINT8 ProtclReceive(struc_Unify_Info *pUnifyInfo);
 
-
+/**
-/******************************************************************************************
+ * @brief ProtclOutput 协议输出单元的主函数,根据协议的规则,将应用传来的数据组帧
-* 功能描述      : 协议输出单元的主函数,根据协议的规则,将应用传来的数据组帧,
+ * @param pUnifyInfo sfp变量 取值范围:参考结构体struc_Unify_Info
-                  并为数据比较单元准备好必需的数据,同时维护链路管理表
+ * @return 0:失败 1:成功
-* 输入参数      : 
+ */
-* 输入输出参数  : struc_Unify_Info* pUnifyInfo  协议统一结构体指针
+UINT8 ProtclOutput(struc_Unify_Info* pUnifyInfo);
-* 输出参数      :
-* 全局变量      : UINT32 nNumsPrtclSnd                       协议输出的数据的个数(字节为单位)
-                  struc_Lnk_Mngr *pCurProc_Lnk               链路管理表中当前处理的的链路指针,这里是指针，不是实体*
-                  UINT8 chCurProcItemSrc                     当前要处理的元素的来源 ITEMSRC_BOTH (数据队列和链路管理表) 0x17;ITEMSRC_DATAQUEUE (数据队列) 0x33;ITEMSRC_LNKMNGR(链路管理表) 0x55
-                  struc_OutputDataBuff *pLastDataBuffItem    表示当前处理的数据存储单元的指针
-                  struc_OutputDataBuff *pCurDataBuffItem     表示上一次处理的数据存储单元的指针
-                  struc_Unify_Info *pUnifyInfoForOutput      输出用平台变量结构体指针
-* 返回值        : 正确返回1，错误返回0        
-*******************************************************************************************/
-UINT8 ProtclOutput(struc_Unify_Info *pUnifyInfo);
 
 
 /******************************************************************************************

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

@@ -1,27 +1,26 @@
 
 /*******************************************************************************
-* �ļ���    ��  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*/
 
 #else
 #endif