/*
*
* 文件名   ：  ProtclManage.c
* 版权说明 ：  北京北京交控科技有限公司
* 版本号   ：  1.0
* 创建时间 ：  2013.09.15
* 作者     ：  王佩佩
* 功能描述 ：  协议主处理类,主要实现了周期性调用协议。
* 使用注意 ：
* 修改记录 ：
*    时间			修改人		修改理由
*    2014.03.06     yw.lou      发送数据如果没有发送报文,对应的链路状态没有赋值,则导致最终在刷新链路时候链路不一致;
*                               无法区别开到底是哪个协议,因此修改,如果没有中间状态数据,则赋值0,以便能正常处理;
*    2014.03.20     yw.lou      只为ATS通信开辟了1个空间,而ATS最多可能发送2或3帧,导致数组越界;修改分配空间:
*                               最大可能链路数*各协议通信对象个数;
*    2014.04.13     yw.lou      为协议数据接收结构体分配空间后未初始化,接收各协议数据后调用ReceiveAppData函数,proType字段未初始化
*                               导致其它未收到数据未初始化的协议类型清空了已收到数据的协议类型;
*                               malloc申请空间失败后均返回失败,在初始化阶段完成检查,避免随机故障;
*
*---------------------------------------------
*/
#include <stdlib.h>
#include "CommonMemory.h"
#include "dsuProtclFun.h"
#include "protclMgeCfg.h"
#include "ProtclManage.h"
#include "Convert.h"
#include "dfsDataRead.h"
#include <string.h>

#ifdef USE_SFP
#include "sfpPrtclCommon.h"
#endif
#ifdef USE_RSR
#include "dsuRsrFunc.h"
#include "RsrCommon.h"
#endif
#ifdef USE_RSSPII
#include "Rssp2.h"
#include "PrtclParseManage.h"
#endif
#ifdef USE_RP
#include "RpInterface.h"
#endif
#ifdef USE_FSFB
#include "FsfbProtcl.h"
#endif

/***********协议初始化相关函数**************************************************************/
static UINT8 InitProtclInfoStru(ProtclConfigInfoStru* pUnifyInfo, UINT16 maxLnkNum);
static UINT8 InitSfpProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo);
static UINT8 InitRpProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo);
static UINT8 InitRsspProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo);
static UINT8 InitRsrProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo);
static UINT8 InitRssp2ProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo);
static UINT8 InitFsfbProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo);
static void GetSfpNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum);
static void GetRsspiNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum);
static void GetRsspiiNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum);
static void GetFsfbNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum);
static void TypeIdToDevName(UINT8 type, UINT8 id, UINT16* pDevName);
static PROTCL_APP_TO_STRU* NewProtclAppToStru(const UINT16 outputSize, const UINT16 inputSize);
static UINT8* NewAppData(UINT16* appDataMaxLen, const UINT16 outputSize, const UINT16 inputSize);
static UINT8 StPtclMgtSetOutnetQue(ProtclConfigInfoStru* pUnifyInfo, UINT16 locDevName, UINT8 queType);
static void StPtclMgtSetRecSize(ProtclConfigInfoStru* pUnifyInfo, UINT16 pProtclNumBuff[7], UINT32 curDevRecordLen[PROTCL_MGECFG_MAXCNT]);
static UINT8 StPtclMgtSetRecvDataBuff(ProtclConfigInfoStru* pUnifyInfo, UINT16 maxLinkNum, PROTCL_SND_CFG_STRU* protclSndCfgStru, PROTCL_RCV_DATA_TYPE* ptemProtclRcvDataStru, UINT8 ptclType, UINT8** pRcvDataBuff, UINT16* pRcvDataBuffLen);

/* 各协议函数指针配置表 */
static PROTCL_MGECFG_STRU protclCfgStruBuff[PROTCL_MGECFG_MAXCNT + 1] = {
	{protcl_nul_Init,protcl_nul_Snd,protcl_nul_Rcv,protcl_nul_Lnk,protcl_nul_NetsRecvPkgNum,protcl_nul_DelLnk,protcl_nul_ReFreshLnk,protcl_nul_End}

#ifdef USE_SFP
	,{InitSfpProtclStru,sfpSendData,SfpRcvData,GetSfpLnkStatus,GetSfpNetsRecvPkgNum, SfpDelLnk,SfpReFreshLnk,SfpFreeSpaceFunc}
#else
	,{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
#endif

#ifdef USE_RP
	,{InitRpProtclStru,RpSendData,RpRcvData,protcl_nul_Lnk,protcl_nul_NetsRecvPkgNum,RpDelLnk,RpReFreshLnk,RpFreeSpaceFunc}
#else
	,{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
#endif

#ifdef USE_RSR
	,{InitRsrProtclStru,RsrSendData,RsrRcvData,GetRsrLnkStatus,protcl_nul_NetsRecvPkgNum,RsrDelLnk,RsrReFreshLnk,RsrFreeSpaceFunc}
#else
	,{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
#endif

#ifdef USE_RSSPI
	,{InitRsspProtclStru,RsspSendData,RsspRcvData,GetRsspLnkStatus,GetRsspiNetsRecvPkgNum,RsspDelLnk,RsspReFreshLnk,RsspFreeSpaceFunc}
#else
	,{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
#endif

#ifdef USE_RSSPII
	,{InitRssp2ProtclStru,Rssp2SendData,Rssp2RcvData,GetRssp2LnkStatus,GetRsspiiNetsRecvPkgNum,Rssp2DelLnk,Rssp2ReFreshLnk,Rssp2FreeSpaceFunc}
#else
	,{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
#endif

#ifdef USE_FSFB
	,{InitFsfbProtclStru,FsfbSendData,FsfbRcvData,GetFsfbLnkStatus,GetFsfbNetsRecvPkgNum,FsfbDelLnk,FsfbReFreshLnk,FsfbFreeSpaceFunc}
#else
	,{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
#endif
};

/**
 * @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)
{
	/*- 定义局部变量*/
	UINT8 retVal = 0u; /*-< 设置函数返回值为0*/
	UINT8 tempProtclCnt = 0u;
	UINT8 tmpI = 0u;
	UINT8 flag = 0u;
	UINT8 rslt = 0u;
	F_INIT tmpInit;
	/* 临时变量*/
	PROTCL_RCV_DATA_TYPE* ptemProtclRcvDataStru = NULL;	/*临时存放协议数据的结构体*/
	PROTCL_SND_CFG_STRU* protclSndCfgStru = NULL;	/*发送结构*/
	UINT16* pProtclNumBuff = NULL; /*各协议最大链路数*/
	UINT32* curDevRecordLen = NULL;	/*本设备使用日志长度*/
	DSU_PROTCL_TYPE_STRU* protclTypeInfoStru = NULL;	/*各协议通信数量*/

	/* VOBC的记录数据大小 */
	if ((NULL == pUnifyInfo)) /*-< 参数是否非空*/
	{
		return retVal; /*-< 返回函数返回值*/
	}

	pUnifyInfo->GlobalVar = (GlobalVar*)malloc(sizeof(GlobalVar)); /*-< 分配全局变量空间*/
	if (NULL != pUnifyInfo->GlobalVar) /*-< 是否分配成功*/
	{
		/*初始化协议数据的结构体*/
		CommonMemSet(pUnifyInfo->GlobalVar, sizeof(GlobalVar), 0, sizeof(GlobalVar)); /*-< 清零分配全局变量空间*/

		protclSndCfgStru = pUnifyInfo->GlobalVar->protclSndCfgStru;	/*-< 得到发送结构变量*/
		pProtclNumBuff = pUnifyInfo->GlobalVar->pProtclNumBuff; /*-< 得到各协议最大链路数*/
		curDevRecordLen = pUnifyInfo->GlobalVar->curDevRecordLen; /*-< 得到本设备使用日志长度*/
	}
	else
	{
		return retVal; /*-< 返回函数返回值*/
	}

	tempProtclCnt = InitGetCfgInfo(fileName, inDataLen, inData, &pProtclNumBuff[1], pUnifyInfo); /*-< 调用初始从配置文件读取相对应的协议配置数据函数*/

	if (tempProtclCnt == 0u) /*-< 调用函数失败*/
	{
		retVal = 0u; /*-< 设置函数返回值为0*/
		return retVal; /*-< 返回函数返回值*/
	}
	protclTypeInfoStru = &pUnifyInfo->GlobalVar->protclTypeInfoStru; /*-< 得到协议类型信息*/

	StPtclMgtSetRecSize(pUnifyInfo, pProtclNumBuff, curDevRecordLen); /*-< 调用设置各协议日志大小函数*/

	/* 初始化各协议*/
	for (tmpI = 0u; tmpI < tempProtclCnt + 1; tmpI++) /*-< 协议数下标是否小于协议总数*/
	{
		if (0u < pProtclNumBuff[tmpI]) /*-< 此协议有通信*/
		{
			tmpInit = protclCfgStruBuff[tmpI].fInit; /*-< 得到此协议初始化函数*/
			if (NULL != tmpInit) /*-< 协议初始化函数是否非空*/
			{
				retVal = tmpInit(fileName, inDataLen, inData, pProtclNumBuff[tmpI], pUnifyInfo); /*-< 调用此协议初始化函数*/
			}
			else /*无此协议*/
			{
				retVal = 1u; /*-< 设置函数返回值为1*/
			}

			if (0u == retVal) /*-< 调用函数是否失败*/
			{
				/* 若有一个初始化失败，将不再继续。 */
				return retVal; /*-< 返回函数返回值*/
			}
		}
		else /*无需初始化*/
		{
			retVal = 1u; /*-< 设置函数返回值为1*/
		}
	}

	/*- 给临时存放协议数据的结构体分配空间 */
	pUnifyInfo->GlobalVar->RcvData = (PROTCL_RCV_DATA_TYPE*)malloc(sizeof(PROTCL_RCV_DATA_TYPE) * (PROTCL_MGECFG_MAXCNT + 1u));
	ptemProtclRcvDataStru = pUnifyInfo->GlobalVar->RcvData;

	/* 给接收数据的临时存档数据的结构体分配空间 */
	if (ptemProtclRcvDataStru != NULL) /*-< 是否分配成功*/
	{
		/*- 初始化协议数据的结构体*/
		CommonMemSet(ptemProtclRcvDataStru, sizeof(PROTCL_RCV_DATA_TYPE) * (PROTCL_MGECFG_MAXCNT + 1u), 0u, sizeof(PROTCL_RCV_DATA_TYPE) * (PROTCL_MGECFG_MAXCNT + 1u));

		/*- 申请并初始化协议数据结构体的接收数据缓冲区*/
		ptemProtclRcvDataStru[DSU_PROTCL_SFP].pData = (UINT8*)malloc(sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->sfpProtclNum);
		CommonMemSet(ptemProtclRcvDataStru[DSU_PROTCL_SFP].pData, sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->sfpProtclNum,
			0, pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->sfpProtclNum);

		/*- 规定协议数据结构体第2个空间存放SFP数据类型,第一个为ptemProtclRcvDataStru[0],默认不使用*/
		ptemProtclRcvDataStru[DSU_PROTCL_SFP].proType = DSU_PROTCL_SFP;

		/*- 申请并初始化协议数据结构体的接收数据缓冲区*/
		ptemProtclRcvDataStru[DSU_PROTCL_RP].pData = (UINT8*)malloc(sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->redunProtclNum);
		CommonMemSet(ptemProtclRcvDataStru[DSU_PROTCL_RP].pData, sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->redunProtclNum,
			0, pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->redunProtclNum);

		/*- 规定协议数据结构体第3个空间存放redun数据类型*/
		ptemProtclRcvDataStru[DSU_PROTCL_RP].proType = DSU_PROTCL_RP;

		/*- 申请并初始化协议数据结构体的接收数据缓冲区*/
		ptemProtclRcvDataStru[DSU_PROTCL_RSR].pData = (UINT8*)malloc(sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rsrProtclNum);
		CommonMemSet(ptemProtclRcvDataStru[DSU_PROTCL_RSR].pData, sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rsrProtclNum,
			0, pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rsrProtclNum);

		/*- 规定协议数据结构体第4个空间存放redun数据类型*/
		ptemProtclRcvDataStru[DSU_PROTCL_RSR].proType = DSU_PROTCL_RSR;

		/*- 申请并初始化协议数据结构体的接收数据缓冲区*/
		ptemProtclRcvDataStru[DSU_PROTCL_RSSP].pData = (UINT8*)malloc(sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rsspProtclNum);
		CommonMemSet(ptemProtclRcvDataStru[DSU_PROTCL_RSSP].pData, sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rsspProtclNum,
			0, pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rsspProtclNum);

		/*- 规定协议数据结构体第5个空间存放RSSP数据类型*/
		ptemProtclRcvDataStru[DSU_PROTCL_RSSP].proType = DSU_PROTCL_RSSP;

		/*- 申请并初始化协议数据结构体的接收数据缓冲区*/
		ptemProtclRcvDataStru[DSU_PROTCL_RSSP2].pData = (UINT8*)malloc(sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rssp2ProtclNum);
		CommonMemSet(ptemProtclRcvDataStru[DSU_PROTCL_RSSP2].pData, sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rssp2ProtclNum,
			0, pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->rssp2ProtclNum);

		/*- 规定协议数据结构体第5个空间存放RSSP数据类型*/
		ptemProtclRcvDataStru[DSU_PROTCL_RSSP2].proType = DSU_PROTCL_RSSP2;

		/*- 申请并初始化协议数据结构体的接收数据缓冲区*/
		ptemProtclRcvDataStru[DSU_PROTCL_FSFB].pData = (UINT8*)malloc(sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->fsfbProtclNum);
		CommonMemSet(ptemProtclRcvDataStru[DSU_PROTCL_FSFB].pData, sizeof(UINT8) * pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->fsfbProtclNum,
			0, pUnifyInfo->InputSize * pUnifyInfo->MaxNumPerCycle * protclTypeInfoStru->fsfbProtclNum);
		/*- 规定协议数据结构体第5个空间存放RSSP数据类型*/
		ptemProtclRcvDataStru[DSU_PROTCL_FSFB].proType = DSU_PROTCL_FSFB;
	}
	else
	{
		/* 不做处理 */
		retVal = 0u; /*-< 设置函数返回值为0*/
		return retVal; /*-< 返回函数返回值*/
	}


	/*- 初始化接收单帧应用数据*/
	pUnifyInfo->GlobalVar->pRcvProtclAppStru = NewProtclAppToStru(pUnifyInfo->OutputSize, pUnifyInfo->InputSize);
	if (NULL == pUnifyInfo->GlobalVar->pRcvProtclAppStru) /*-< 是否分配失败*/
	{
		retVal = 0u; /*-< 设置函数返回值为0*/
		return retVal; /*-< 返回函数返回值*/
	}

	/*- 初始化发送单帧应用数据*/
	pUnifyInfo->GlobalVar->pSndProtclAppStru = NewProtclAppToStru(pUnifyInfo->OutputSize, pUnifyInfo->InputSize);
	if (NULL == pUnifyInfo->GlobalVar->pSndProtclAppStru) /*-< 是否分配失败*/
	{
		retVal = 0u; /*-< 设置函数返回值为0*/
		return retVal; /*-< 返回函数返回值*/
	}


	for (tmpI = 0u; tmpI < PROTCL_MGECFG_MAXCNT + 1; tmpI++) /*-< 协议数下标是否小于协议数*/
	{
		/* 防止野指针 */
		protclSndCfgStru[tmpI].pProtclAppStru = (PROTCL_APP_TO_STRU*)malloc(sizeof(PROTCL_APP_TO_STRU) * 0u); /*-< 分配协议应用变量空间*/
		protclSndCfgStru[tmpI].DevDataCnt = 0u; /*-< 设置设备数量为0*/
	}

	/* 给发送数据的临时存档数据的结构体分配空间 */
	if (0u < protclTypeInfoStru->sfpProtclNum) /*-< SPF协议数是否大于0*/
	{
#ifdef USE_SFP
		flag |= StPtclMgtSetRecvDataBuff(pUnifyInfo, pUnifyInfo->GlobalVar->gpsfpUnitInfo->MaxNumLink, protclSndCfgStru, ptemProtclRcvDataStru, DSU_PROTCL_SFP, &pUnifyInfo->GlobalVar->gpSfpRcvDataBuff, &pUnifyInfo->GlobalVar->gSfpRcvDataBuffLen); /*-< 调用SFP设置收数据缓存函数*/
#endif
	}

	if (protclTypeInfoStru->redunProtclNum > 0u) /*-< RP协议数是否大于0*/
	{
#ifdef USE_RP
		flag |= StPtclMgtSetRecvDataBuff(pUnifyInfo, pUnifyInfo->GlobalVar->gpRedunUnitInfo->MaxNumLink, protclSndCfgStru, ptemProtclRcvDataStru, DSU_PROTCL_RP, &pUnifyInfo->GlobalVar->gpRpRcvDataBuff, &pUnifyInfo->GlobalVar->gRpRcvDataBuffLen); /*-< 调用RP设置收数据缓存函数*/
#endif
	}

	if (protclTypeInfoStru->rsrProtclNum > 0u) /*-< RSR协议数是否大于0*/
	{
#ifdef USE_RSR
		flag |= StPtclMgtSetRecvDataBuff(pUnifyInfo, pUnifyInfo->GlobalVar->gpRsrUnitInfo->MaxNumLink, protclSndCfgStru, ptemProtclRcvDataStru, DSU_PROTCL_RSR, &pUnifyInfo->GlobalVar->gpRsrRcvDataBuff, &pUnifyInfo->GlobalVar->gRsrRcvDataBuffLen); /*-< 调用RSR设置收数据缓存函数*/
#endif
	}

	if (protclTypeInfoStru->rsspProtclNum > 0u) /*-< RSSPI协议数是否大于0*/
	{
#ifdef USE_RSSPI
		flag |= StPtclMgtSetRecvDataBuff(pUnifyInfo, pUnifyInfo->GlobalVar->gpRsspUnitInfo->MaxNumLink, protclSndCfgStru, ptemProtclRcvDataStru, DSU_PROTCL_RSSP, &pUnifyInfo->GlobalVar->gpRsspRcvDataBuff, &pUnifyInfo->GlobalVar->gRsspRcvDataBuffLen); /*-< 调用RSSPI设置收数据缓存函数*/
#endif
	}

	if (protclTypeInfoStru->rssp2ProtclNum > 0u) /*-< RSSPII协议数是否大于0*/
	{
#ifdef USE_RSSPII
		Prtcl_RSSP2_CheckInit(&pUnifyInfo->GlobalVar->Rssp2PrtclHead); /*-< 调用RSSPII解析初始化函数*/
		/* add 20161017 xb */
		for (tmpI = 0u; tmpI < PRTCL_RQ_NUM; tmpI++) /*-< RSSPII解析队列数下标是否小于最大数*/
		{
			rslt = (UINT8)QUEUE_RING_Init(&Prtcl_RQ[tmpI].RingQue, PRTCL_RQ_SIZE); /*-< 调用RSSPII初始队列函数*/
			if (CM_TRUE != rslt) /*-< 调用函数是否失败*/
			{
				flag |= 1u; /*-< 设置退出标志为退出*/
				break; /*-< 退出*/
			}
			/*- 设置队列值*/
			Prtcl_RQ[tmpI].RingQue.m_bIsInited = CM_TRUE;
			Prtcl_RQ[tmpI].RingQue.m_IfCoverQueueFull = CM_TRUE;
			Prtcl_RQ[tmpI].RingQue.m_QueueState = QUEUE_RING_STATE_Empty;
		}

		flag |= StPtclMgtSetRecvDataBuff(pUnifyInfo, pUnifyInfo->GlobalVar->gpRssp2UnitInfo->MaxNumLink, protclSndCfgStru, ptemProtclRcvDataStru, DSU_PROTCL_RSSP2, &pUnifyInfo->GlobalVar->gpRssp2RcvDataBuff, &pUnifyInfo->GlobalVar->gRssp2RcvDataBuffLen); /*-< 调用RSSPII设置收数据缓存函数*/
#endif
	}

	if (protclTypeInfoStru->fsfbProtclNum > 0u) /*-< FSFB协议数是否大于0*/
	{
#ifdef USE_FSFB
		flag |= StPtclMgtSetRecvDataBuff(pUnifyInfo, pUnifyInfo->GlobalVar->gpFsfbUnitInfo->MaxNumLink, protclSndCfgStru, ptemProtclRcvDataStru, DSU_PROTCL_FSFB, &pUnifyInfo->GlobalVar->gpFsfbRcvDataBuff, &pUnifyInfo->GlobalVar->gFsfbRcvDataBuffLen); /*-< 调用FSFB设置收数据缓存函数*/
#endif
	}

	if (0u != flag) /*-< 退出标志是否退出*/
	{
		retVal = 0u; /*-< 设置函数返回值为0*/
	}
	return retVal; /*-< 返回函数返回值*/
}

/*
* 功能：协议发送数据
* 参数：
* 输入输出参数：  ProtclConfigInfoStru * pUnifyInfo   统一结构体
* 返回值：
*   1：接收数据成功
*   0：失败
*   2:非宕机错误码
*/
UINT8 SendAppData(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;
	UINT8 temLenbuf[2] = { 0 };
	PROTCL_APP_TO_STRU* tempProtclAppStru = NULL;
	UINT16 locDevName = 0;
	UINT16 destDevName = 0;
	UINT8 protclType = 0;
	UINT32 sendDataLen = 0;
	UINT32 tmpDataLen = 0;
	UINT16 temLnkDataLen = 0;
	UINT16 tempRecordLen = 0;
	UINT16 lnkDataLen = 0;
	UINT16 recordDataLen = 0;

	UINT32 tmpDevDataCnt = 0;
	UINT8 tmpI = 0;
	F_SND tmpSndF;
	UINT8 tmpSign = 0;
	PROTCL_SND_CFG_STRU* protclSndCfgStru = NULL;
	UINT16* pProtclNumBuff = NULL; /*各协议最大链路数*/

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->pSndProtclAppStru) && (NULL != pUnifyInfo->GlobalVar->protclSndCfgStru) && (NULL != pUnifyInfo->GlobalVar->pProtclNumBuff))
	{
		tempProtclAppStru = pUnifyInfo->GlobalVar->pSndProtclAppStru;
		protclSndCfgStru = pUnifyInfo->GlobalVar->protclSndCfgStru;
		pProtclNumBuff = pUnifyInfo->GlobalVar->pProtclNumBuff;

		/* 将应用需要发送的数据写入各协议的队列 */
		TypeIdToDevName(pUnifyInfo->LocalType, pUnifyInfo->LocalID, &locDevName);
		while (2 < QueueStatus(&pUnifyInfo->OutputDataQueue))
		{
			QueueScan(2, temLenbuf, &pUnifyInfo->OutputDataQueue);

			ret = AppSendInputDataAnalysis(&pUnifyInfo->OutputDataQueue, tempProtclAppStru);
			if (1 == ret)
			{
				/* 根据设备类型，决定协议的使用类型 */
				TypeIdToDevName(tempProtclAppStru->devType, tempProtclAppStru->devId, &destDevName);
				protclType = 0;
				DsuProtclGetProtclType(locDevName, destDevName, &protclType, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo);
			}
			else
			{
				break;
			}
			/* 防越界 */
			if ((PROTCL_MGECFG_MAXCNT >= protclType) && (0 != protclType))
			{
				if (0 < pProtclNumBuff[protclType]) /*有通信设备*/
				{
					/*按帧数填写*/
					tmpDevDataCnt = protclSndCfgStru[protclType].DevDataCnt;

					protclSndCfgStru[protclType].pProtclAppStru[tmpDevDataCnt].appDataMaxLen = tempProtclAppStru->appDataMaxLen;
					protclSndCfgStru[protclType].pProtclAppStru[tmpDevDataCnt].devType = tempProtclAppStru->devType;
					protclSndCfgStru[protclType].pProtclAppStru[tmpDevDataCnt].devId = tempProtclAppStru->devId;
					protclSndCfgStru[protclType].pProtclAppStru[tmpDevDataCnt].devLogId = tempProtclAppStru->devLogId;
					protclSndCfgStru[protclType].pProtclAppStru[tmpDevDataCnt].appDataLen = tempProtclAppStru->appDataLen;
					CommonMemCpy(protclSndCfgStru[protclType].pProtclAppStru[tmpDevDataCnt].pAppData, tempProtclAppStru->appDataLen, tempProtclAppStru->pAppData, tempProtclAppStru->appDataLen);

					protclSndCfgStru[protclType].DevDataCnt++;
				}
			}
			else
			{
				/* break;*/
			}
		}

		/* 执行各协议的发送函数 */
		for (tmpI = 1; tmpI < PROTCL_MGECFG_MAXCNT + 1; tmpI++)
		{
			tmpDataLen = 0;
			temLnkDataLen = 0;
			tempRecordLen = 0;
			if (0 < pProtclNumBuff[tmpI])
			{
				/* 调用发送函数 */
				tmpSndF = protclCfgStruBuff[tmpI].fSnd;
				if (NULL != tmpSndF)
				{
					ret = tmpSndF(pUnifyInfo, protclSndCfgStru[tmpI].DevDataCnt, pUnifyInfo->AppArray + 4 + sendDataLen, &tmpDataLen, pUnifyInfo->VarArray + 2 + lnkDataLen, &temLnkDataLen, pUnifyInfo->RecordArray
						+ 2 + recordDataLen, &tempRecordLen);
				}
				else /*无此协议*/
				{
					temLnkDataLen = 2;
					ShortToChar(0, pUnifyInfo->VarArray + 2 + lnkDataLen);
					ret = 1u;
				}
				/* 增加赋零*/
				protclSndCfgStru[tmpI].DevDataCnt = 0;

			}
			else
			{
				temLnkDataLen = 2;
				ShortToChar(0, pUnifyInfo->VarArray + 2 + lnkDataLen);
				ret = 1;
				/* 无此通信类型 */
			}
			if (1 == ret)
			{
				sendDataLen += tmpDataLen;
				lnkDataLen += temLnkDataLen;
				recordDataLen += tempRecordLen;
			}
			else
			{
				tmpSign = 1;
			}
		}
		/* 发送数据的长度 */
		LongToChar(sendDataLen, pUnifyInfo->AppArray);
		/* 中间变量的长度 */
		ShortToChar(lnkDataLen, pUnifyInfo->VarArray);
		/* 记录数据的长度 */
		ShortToChar(recordDataLen, pUnifyInfo->RecordArray);
	}
	else
	{
		ret = 0;
	}

	if (1 == tmpSign)
	{
		ret = 0;
	}
	return ret;
}

/**
 * @brief ReceiveAppData 协议接收数组
 * @param pUnifyInfo 统一结构体变量 取值范围:参考结构体ProtclConfigInfoStru
 * @return 0:失败 1:成功
 */
UINT8 ReceiveAppData(ProtclConfigInfoStru* pUnifyInfo)
{
	/*- 定义局部变量*/
	UINT8 ret = 0u; /*-< 设置函数返回值为0*/
	UINT8 flag = 0u;
	UINT8 lnkState = 0u;
	UINT8 i = 0u;  /* 循环使用 */
	UINT16 locDevName = 0u;
	UINT8 DevType = 0u;
	UINT8 DevId = 0u;
	UINT8 LogId = 0u;
	DSU_PROTCL_TYPE_STRU* protclTypeInfoStru = NULL;

#ifdef USE_SFP		
	struc_Unify_Info* gpsfpUnitInfo = NULL;	/*SFP协议结构体*/
#endif
#ifdef USE_RP
	RP_INFO_STRU* gpRedunUnitInfo = NULL;	/*冗余层协议结构体*/
#endif
#ifdef USE_RSR
	RSR_INFO_STRU* gpRsrUnitInfo = NULL;	/*RSR协议结构体*/
#endif
#ifdef USE_RSSPI
	RSSP_INFO_STRU* gpRsspUnitInfo = NULL;	/*RSSP协议结构体*/
#endif
#ifdef USE_RSSPII
	RSSP2_INFO_STRU* gpRssp2UnitInfo = NULL; /*RSSP2协议结构体*/
#endif
#ifdef USE_FSFB
	FSFB_INFO_STRU* gpFsfbUnitInfo = NULL; /*FSFB协议结构体*/
#endif

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar)) /*-< 参数是否非空*/
	{
		protclTypeInfoStru = &pUnifyInfo->GlobalVar->protclTypeInfoStru; /*-< 得到各协议通信数量*/

		/*- 得到协议结构体变量*/
#ifdef USE_SFP		
		gpsfpUnitInfo = pUnifyInfo->GlobalVar->gpsfpUnitInfo;	/*SFP协议结构体*/
#endif
#ifdef USE_RP
		gpRedunUnitInfo = pUnifyInfo->GlobalVar->gpRedunUnitInfo;	/*冗余层协议结构体*/
#endif
#ifdef USE_RSR
		gpRsrUnitInfo = pUnifyInfo->GlobalVar->gpRsrUnitInfo;	/*RSR协议结构体*/
#endif
#ifdef USE_RSSPI
		gpRsspUnitInfo = pUnifyInfo->GlobalVar->gpRsspUnitInfo;	/*RSSP协议结构体*/
#endif
#ifdef USE_RSSPII
		gpRssp2UnitInfo = pUnifyInfo->GlobalVar->gpRssp2UnitInfo; /*RSSP2协议结构体*/
#endif
#ifdef USE_FSFB
		gpFsfbUnitInfo = pUnifyInfo->GlobalVar->gpFsfbUnitInfo; /*FSFB协议结构体*/
#endif

		QueueClear(&pUnifyInfo->DataToApp); /*-< 清数据到应用队列*/
		if (protclTypeInfoStru->sfpProtclNum > 0u) /*-< SFP协议数量是否大于0*/
		{
#ifdef USE_SFP
			QueueClear(&gpsfpUnitInfo->OutnetQueueA); /*-< 清SFP协议输入红网队列*/
			QueueClear(&gpsfpUnitInfo->OutnetQueueB); /*-< 清SFP协议输入蓝网队列*/
#endif
		}

		if (protclTypeInfoStru->redunProtclNum > 0u) /*-< RP协议数量是否大于0*/
		{
#ifdef USE_RP
			QueueClear(&gpRedunUnitInfo->OutnetQueueA); /*-< 清RP协议输入红网队列*/
			QueueClear(&gpRedunUnitInfo->OutnetQueueB); /*-< 清SFP协议输入蓝网队列*/
#endif
		}

		if (protclTypeInfoStru->rsrProtclNum > 0u) /*-< RSR协议数量是否大于0*/
		{
#ifdef USE_RSR
			QueueClear(&gpRsrUnitInfo->OutnetQueueA); /*-< 清RSR协议输入红网队列*/
			QueueClear(&gpRsrUnitInfo->OutnetQueueB); /*-< 清SFP协议输入蓝网队列*/
#endif
		}

		if (protclTypeInfoStru->rsspProtclNum > 0u) /*-< RSSPI协议数量是否大于0*/
		{
#ifdef USE_RSSPI
			QueueClear(&gpRsspUnitInfo->OutnetQueueA); /*-< 清RSSPI协议输入红网队列*/
			QueueClear(&gpRsspUnitInfo->OutnetQueueB); /*-< 清SFP协议输入蓝网队列*/
#endif
		}

		if (protclTypeInfoStru->rssp2ProtclNum > 0u) /*-< RSSPII协议数量是否大于0*/
		{
#ifdef USE_RSSPII
			QueueClear(&gpRssp2UnitInfo->OutnetQueueA); /*-< 清RSSPII协议输入红网队列*/
			QueueClear(&gpRssp2UnitInfo->OutnetQueueB); /*-< 清SFP协议输入蓝网队列*/
#endif
		}

		TypeIdToDevName(pUnifyInfo->LocalType, pUnifyInfo->LocalID, &locDevName); /*-< 调用类型ID转设备名函数*/

		ret = StPtclMgtSetOutnetQue(pUnifyInfo, locDevName, 1u); /*-< 调用设置外红网队列函数*/
		if (0u == ret) /*-< 调用函数是否失败*/
		{
			return ret; /*-< 返回函数返回值*/
		}

		ret = StPtclMgtSetOutnetQue(pUnifyInfo, locDevName, 2u); /*-< 调用设置外蓝网队列函数*/
		if (0u == ret) /*-< 调用函数是否失败*/
		{
			return ret; /*-< 返回函数返回值*/
		}

		if (protclTypeInfoStru->sfpProtclNum > 0u) /*-< SFP协议数是否大于0*/
		{
#ifdef USE_SFP
			/* SFP协议接收数据 */
			gpsfpUnitInfo->RadamSN = *gpsfpUnitInfo->CycleNum; /*-< SFP得到周期数*/
#ifdef CI_TASKLOCK
			taskLock();
			ret = ProtclReceive(gpsfpUnitInfo); /*-< 调用SFP输入函数*/
			taskUnlock();
#else
			ret = ProtclReceive(gpsfpUnitInfo); /*-< 调用SFP输入函数*/
#endif
			if (ret == 1u) /*-< 调用函数是否成功*/
			{
				SfpRcvData(&pUnifyInfo->DataToApp, pUnifyInfo); /*-< 调用SFP输入数据函数*/
			}
			else
			{
				flag = 1u; /*-< 设置退出*/
			}
#endif
		}

		if (protclTypeInfoStru->redunProtclNum > 0u) /*-< RP协议数是否大于0*/
		{
#ifdef USE_RP
			/* RP协议接收数据 */
			ret = RpReceive(gpRedunUnitInfo); /*-< 调用RP输入函数*/
			if (ret == 1u) /*-< 调用函数是否成功*/
			{
				RpRcvData(&pUnifyInfo->DataToApp, pUnifyInfo); /*-< 调用RP输入数据函数*/
			}
			else
			{
				flag = 1u; /*-< 设置退出*/
			}
#endif
		}

		if (protclTypeInfoStru->rsrProtclNum > 0u) /*-< RSR协议数是否大于0*/
		{
#ifdef USE_RSR
			/* RSR协议接收数据 */
			ret = RsrReceive(gpRsrUnitInfo); /*-< 调用RSR输入函数*/
			if (ret == 1u) /*-< 调用函数是否成功*/
			{
				ret = RsrRcvData(&pUnifyInfo->DataToApp, pUnifyInfo); /*-< 调用RSR输入数据函数*/
			}
			else
			{
				flag = 1u; /*-< 设置退出*/
			}
#endif
		}

		if (protclTypeInfoStru->rsspProtclNum > 0u) /*-< RSSPI协议数是否大于0*/
		{
#ifdef USE_RSSPI
			/* RSSP协议接收数据 */
			ret = Rssp2Receive(gpRsspUnitInfo); /*-< 调用RSSPI输入函数*/
			if (ret == 1u) /*-< 调用函数是否成功*/
			{
				RsspRcvData(&pUnifyInfo->DataToApp, pUnifyInfo); /*-< 调用RSSPI输入数据函数*/
			}
			else
			{
				flag = 1u; /*-< 设置退出*/
			}
#endif
		}

		if (protclTypeInfoStru->rssp2ProtclNum > 0u) /*-< RSSPII协议数是否大于0*/
		{
#ifdef USE_RSSPII
			/* RSSP2协议接收数据 */
			ret = RsspIIReceive(gpRssp2UnitInfo); /*-< 调用RSSPII输入函数*/
			if (ret == 1u) /*-< 调用函数是否成功*/
			{
				Rssp2RcvData(&pUnifyInfo->DataToApp, pUnifyInfo); /*-< 调用RSSPII输入数据函数*/
			}
			else
			{
				flag = 1u; /*-< 设置退出*/
			}
#endif
		}

#ifdef USE_RSSPII
		/* 清理环形队列 */
		for (i = 0u; i < PRTCL_RQ_NUM; i++) /*-< RSSPII输入队列数下标是否小于总数*/
		{
			if (Prtcl_RQ[i].bIsInit == CM_TRUE) /*-< RSSPII输入队列是否初始化*/
			{
				/*- RSSPII输入队列设置参数*/
				DevType = (UINT8)(Prtcl_RQ[i].SourceID / 256 / 256 / 256);
				DevId = (UINT8)(Prtcl_RQ[i].SourceID / 256 / 256 % 256);
				LogId = (UINT8)(Prtcl_RQ[i].SourceID % 256);
				lnkState = GetLnkStatus(DevType, DevId, (UINT16)LogId, pUnifyInfo); /*-< RSSPII调用函数得到链路状态*/
				if (lnkState == 0u) /*-< RSSPII链路状态是否为0*/
				{
					Prtcl_Manage_DelRQ(Prtcl_RQ[i].SourceID); /*-< RSSPII调用删除输入队列函数*/
				}
			}
		}
#endif

		if (protclTypeInfoStru->fsfbProtclNum > 0u) /*-< FSFB协议数是否大于0*/
		{
#ifdef USE_FSFB

			if ((NULL != pUnifyInfo->CycleNum) && (0u == ((*pUnifyInfo->CycleNum) % 2u))) /*-< FSFB协议的周期为600ms*/
			{
				ret = FsfbProtclReceiveData(gpFsfbUnitInfo); /*-< 调用FSFB输入函数*/
				if (ret == 1u) /*-< 调用函数是否成功*/
				{
					FsfbRcvData(&pUnifyInfo->DataToApp, pUnifyInfo); /*-< 调用FSFB输入数据函数*/
				}
				else
				{
					flag = 1u; /*-< 设置退出*/
				}

				/*通信周期清队列*/
				QueueClear(&gpFsfbUnitInfo->OutnetQueueR); /*-< 清红网队列*/
				QueueClear(&gpFsfbUnitInfo->OutnetQueueB); /*-< 清篮网队列*/
			}
#endif
		}


		if (flag == 1u) /*-< 是否退出*/
		{
			ret = 0u; /*-< 设置函数返回值为0*/
		}
	}

	return ret; /*-< 返回函数返回值*/
}

/*
* 功能：查询链路状态
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
*             ProtclConfigInfoStru * pUnifyInfo   统一结构体
* 返回值：
*     0：不存在该条链路，返回错误
*     0x17：链路在数据传输正常状态
*     0x2b：链路在通信中断状态
*     0x33：链路在准备建立链接状态
*     0x4e：链路在等待建立链接状态
*     0x01: 表示刷新无用的链路
*/
UINT8 GetLnkStatus(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;
	UINT16 destDevName = 0;
	UINT16 locDevName = 0;
	UINT8   protclType = 0;
	F_LNK   tmpLnkF = NULL;
	if ((NULL!= pUnifyInfo)&&(NULL != pUnifyInfo->GlobalVar))
	{
		TypeIdToDevName(destType, destId, &destDevName);
		TypeIdToDevName(pUnifyInfo->LocalType, pUnifyInfo->LocalID, &locDevName);
		ret = DsuProtclGetProtclType(locDevName, destDevName, &protclType, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo);

		if (ret != 0)
		{
			/* 防越界 */
			if ((PROTCL_MGECFG_MAXCNT >= protclType) && (0 != protclType))
			{
				/* 调用具体协议的获取链路状态函数 */
				tmpLnkF = protclCfgStruBuff[protclType].fLnk;
				if (NULL != tmpLnkF)
				{
					ret = tmpLnkF(destType, destId, logId, pUnifyInfo);
				}
				else /*无此协议*/
				{
					ret = 0u;
				}
			}
			else
			{
				ret = 0;
			}

		}
	}
	return ret;
}




/*
* 功能：删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
*             ProtclConfigInfoStru * pUnifyInfo   统一结构体
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 DelLnkFunc(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;
	UINT16 destDevName = 0;
	UINT16 locDevName = 0;
	UINT8   protclType = 0;
	F_DELLNK tmpDelLnkF = NULL;

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar))
	{
		TypeIdToDevName(destType, destId, &destDevName);
		TypeIdToDevName(pUnifyInfo->LocalType, pUnifyInfo->LocalID, &locDevName);
		retVal = DsuProtclGetProtclType(locDevName, destDevName, &protclType, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo);

		if (retVal != 0)
		{
			/* 防越界 */
			if ((PROTCL_MGECFG_MAXCNT >= protclType) && (0 != protclType))
			{
				/* 调用具体协议的删除链路函数 */
				tmpDelLnkF = protclCfgStruBuff[protclType].fDelLnk;
				if (NULL != tmpDelLnkF)
				{
					retVal = tmpDelLnkF(destType, destId, logId, pUnifyInfo);
				}
				else /*无此协议*/
				{
					retVal = 0u;
				}
			}
			else
			{
				retVal = 0;
			}

		}
	}
	return retVal;
}

/**
 * @brief ReFresh 使用链路数据数组刷新链路状态
 * @param pLnkStatusData 链路数据数组 取值范围:字节数组
 * @param pUnifyInfo 适配层结构体变量 取值范围:参考结构体:ProtclConfigInfoStru
 * @return 0:失败 1:成功
 */
UINT8 ReFresh(UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	/*- 定义局部变量*/
	UINT8 retVal = 0U; /*-< 设置函数返回值为失败*/
	UINT16 inLnkLen = 0U; /*链路总长度*/
	UINT16 evrLnkLen = 0U; /*链路长度*/
	UINT16 index = 0U; /*数组偏移量*/
	UINT8 flag = 0U; /*-< 设置链路长度是否错误标志为否*/
	UINT8 ftnRtn = 0U; /*调用函数返回值*/

	UINT8 i = 0U; /*循环使用*/
	F_REFRESHLNK tmpReFreshLnk = NULL; /*刷链函数指针*/
	UINT8 deepPro = 0u; /*-< 设置处理标志为不处理*/

	if ((NULL != pLnkStatusData) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->VarArray)) /*-< 入参是否非空*/
	{
		inLnkLen = ShortFromChar(&pLnkStatusData[0]); /*-< 得到链路长度*/

		ftnRtn = CommonMemCpy(&pUnifyInfo->VarArray[0], pUnifyInfo->VarArraySize, &pLnkStatusData[0], 2u + inLnkLen); /*-< 调用复制函数设置链路数据数组*/
		if (1u == ftnRtn) /*-< 调用函数是否成功*/
		{
			for (i = 1U; i < PROTCL_MGECFG_MAXCNT + 1U; i++) /*-< 协议数下标是否小于协议总数*/
			{
				deepPro = 0u; /*-< 设置处理标志为不处理*/

				evrLnkLen = ShortFromChar(&pLnkStatusData[2 + index]); /*-< 得到当前协议数下标协议链路数据长度*/
				index += 2U; /*-< 链路数据下标自增2*/
				if (evrLnkLen > 0U) /*-< 当前协议数下标协议是否有链路数据*/
				{
					if (evrLnkLen + 2U <= inLnkLen) /*-< 当前协议数下标协议链路数据长度是否正确*/
					{
						deepPro = 1u; /*-< 设置处理标志为处理*/
					}
					else
					{
						flag = 1U; /*-< 设置链路长度是否错误标志为是*/
						break; /*-< 退出遍历*/
					}
				}
				else
				{
					retVal = 1U; /*-< 设置函数返回值为成功*/
				}

				if (1u == deepPro) /*-< 处理标志是否为处理*/
				{
					/* 调用具体协议的刷新链路函数 */
					tmpReFreshLnk = protclCfgStruBuff[i].fReFreshLnk; /*-< 得到当前协议数下标协议刷链函数*/
					if (NULL != tmpReFreshLnk) /*-< 当前协议数下标协议刷链函数是否非空*/
					{
						if (DSU_PROTCL_FSFB == i) /*-< 当前协议数下标协议是否FSFB(刷链函数2个长度值)*/
						{
							retVal = tmpReFreshLnk(evrLnkLen, &pLnkStatusData[index], pUnifyInfo); /*-< 调用当前协议数下标协议刷链函数*/
						}
						else /*非FSFB*/
						{
							retVal = tmpReFreshLnk(evrLnkLen, &pLnkStatusData[2 + index], pUnifyInfo); /*-< 调用当前协议数下标协议刷链函数*/
						}
					}
					else /*无此协议*/
					{
						retVal = 1U; /*-< 设置函数返回值为成功*/
					}
					index += evrLnkLen; /*-< 链路数据下标自增当前协议数下标协议链路长度*/
				}

				inLnkLen = inLnkLen - evrLnkLen - 2U; /*-< 计算剩余链路数据长度*/
				if (retVal == 0U) /*-< 函数返回值是否为失败*/
				{
					flag = 1U; /*-< 设置链路长度是否错误标志为是*/
				}
			}

			if (flag == 1U) /*-< 链路长度是否错误标志是否为是*/
			{
				retVal = 0U; /*-< 设置函数返回值为成功*/
			}
		}
	}

	return retVal; /*-< 返回函数返回值*/
}





/*
* 协议销毁协议模块
* 参数：
*    ProtclConfigInfoStru *pUnifyInfo 协议结构体
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 FreeSpace(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;
	UINT8 flag = 0;

	UINT8 i = 0;/* 循环使用 */
	F_END tmpEndF = NULL;
	if (NULL != pUnifyInfo)
	{
		for (i = 0; i < PROTCL_MGECFG_MAXCNT + 1; i++)
		{
			/* 调用具体协议的释放空间函数 */
			tmpEndF = protclCfgStruBuff[i].fEnd;
			if (NULL != tmpEndF)
			{
				retVal = tmpEndF(pUnifyInfo);
			}
			else /*无此协议*/
			{
				retVal = 1u;
			}

			if (retVal == 0)
			{
				flag = 1;
			}
		}
		/* 释放适配层分配的结构体空间 */
		FreeSpaceFunc(pUnifyInfo);
		if (flag == 1)
		{
			retVal = 0;
		}
	}
	
	return retVal;
}

UINT8 ReceiveTcpState(UINT16 TcpStateDataLen, UINT8* pTcpStateData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RSSPII
	if ((NULL != pTcpStateData) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRssp2UnitInfo))
	{
		ret = RsspIIInputTcpState(TcpStateDataLen, pTcpStateData, pUnifyInfo->GlobalVar->gpRssp2UnitInfo);
	}
#endif

	return ret;
}

UINT8 SendTcpCtrl(UINT16* pTcpCtrlDataLen, UINT8* pTcpCtrlData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RSSPII
	if ((NULL != pTcpCtrlDataLen) && (NULL != pTcpCtrlData) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRssp2UnitInfo))
	{
		ret = RsspIIOutputTcpCtrl(pTcpCtrlDataLen, pTcpCtrlData, pUnifyInfo->GlobalVar->gpRssp2UnitInfo);
	}

#endif

	return ret;
}
/***********协议初始化相关函数**************************************************************/
/*
* 初始从配置文件读取相对应的协议配置数据
* 输入参数      :UINT8 *pFileName   协议配置数据文件名
*				 ProtclConfigInfoStru *pUnifyInfo
* 输出参数      :UINT8 *pEvenPrtclNumBuff 存放本方通信的相关协议个数
* 全局变量      :
* 返回值        : 成功,返回协议个数;失败返回0
*/
UINT8 InitGetCfgInfo(UINT8* pFileName, UINT32 inDataLen, UINT8 inData[], UINT16* pEvenPrtclNumBuff, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;
	UINT16 locDevName = 0;
	UINT8 tmpIndex = 0;
	UINT16 maxLnkNum = 0;
	DSU_PROTCL_TYPE_STRU tempProtclTypeNum = { 0 };
	if ((NULL!= pFileName)&&(NULL!= pEvenPrtclNumBuff)&&(NULL!= pUnifyInfo)&&(NULL!= pUnifyInfo->GlobalVar))
	{
		/* 本方的设备类型 */
		TypeIdToDevName(pUnifyInfo->LocalType, pUnifyInfo->LocalID, &locDevName);

		ret = DsuCommonInfoInit(pFileName, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo); /* 查询函数初始化,获取设备IP配置表中的设备IP地址及设备通信协议表数据 */
		if (ret == 0)
		{
			return ret;
		}

		DsuGetProtclTypeInfo(locDevName, &pUnifyInfo->GlobalVar->protclTypeInfoStru, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo, pUnifyInfo->GlobalVar->oppTypePtl, UINT8_MAX + 1, inDataLen, inData);
		CommonMemCpy(&tempProtclTypeNum, sizeof(DSU_PROTCL_TYPE_STRU), &pUnifyInfo->GlobalVar->protclTypeInfoStru, sizeof(DSU_PROTCL_TYPE_STRU));

		maxLnkNum = tempProtclTypeNum.rsspProtclNum + tempProtclTypeNum.rsrProtclNum + tempProtclTypeNum.redunProtclNum + tempProtclTypeNum.sfpProtclNum + tempProtclTypeNum.rssp2ProtclNum + tempProtclTypeNum.fsfbProtclNum;
		ret = InitProtclInfoStru(pUnifyInfo, maxLnkNum);
		if (ret == 0)
		{
			return ret;
		}

#ifdef USE_SFP
		pEvenPrtclNumBuff[tmpIndex] = tempProtclTypeNum.sfpProtclNum;
#endif
		tmpIndex++;

#ifdef USE_RP
		pEvenPrtclNumBuff[tmpIndex] = tempProtclTypeNum.redunProtclNum;
#endif
		tmpIndex++;

#ifdef USE_RSR
		pEvenPrtclNumBuff[tmpIndex] = tempProtclTypeNum.rsrProtclNum;
#endif
		tmpIndex++;

#ifdef USE_RSSPI
		pEvenPrtclNumBuff[tmpIndex] = tempProtclTypeNum.rsspProtclNum;
#endif
		tmpIndex++;

#ifdef USE_RSSPII
		pEvenPrtclNumBuff[tmpIndex] = tempProtclTypeNum.rssp2ProtclNum;
#endif
		tmpIndex++;

#ifdef USE_FSFB
		pEvenPrtclNumBuff[tmpIndex] = tempProtclTypeNum.fsfbProtclNum;
#endif
		tmpIndex++;


		ret = tmpIndex;
	}
	
	return ret;
}

/******************************************************************************************
* 功能描述      : 初始化统一结构体
1. 动态分配统一结构体空间，并对其进行初始化；
* 输入参数      :

* 输出参数      :
* 全局变量      :
* 返回值        : 成功返回1,失败返回0
*******************************************************************************************/
static UINT8 InitProtclInfoStru(ProtclConfigInfoStru* pUnifyInfo, UINT16 maxLnkNum)
{
	UINT8  retnVal = 0;
	UINT32 lTemp = 0;

	/* 协议输入给应用的数据队列长度 */
	lTemp = (pUnifyInfo->InputSize + 7) * maxLnkNum;
	pUnifyInfo->DataToAppSize = lTemp;
	retnVal = QueueInitial(&pUnifyInfo->DataToApp, pUnifyInfo->DataToAppSize);
	if (0 == retnVal)
	{
		return retnVal;
	}


	/* 应用给协议输出的数据队列长度 */
	lTemp = (pUnifyInfo->OutputSize + 6) * maxLnkNum;
	pUnifyInfo->OutputDataQueueSize = lTemp;
	retnVal = QueueInitial(&pUnifyInfo->OutputDataQueue, pUnifyInfo->OutputDataQueueSize);
	if (0 == retnVal)
	{
		return retnVal;
	}


	/*初始化红网接收队列*/
	pUnifyInfo->OutnetQueueSize = (pUnifyInfo->InputSize + 38 + 6) * maxLnkNum * pUnifyInfo->MaxNumPerCycle;
	retnVal = QueueInitial(&pUnifyInfo->OutnetQueueA, pUnifyInfo->OutnetQueueSize);
	if (0 == retnVal)
	{
		return retnVal;
	}


	/* 初始化蓝网接收队列 */
	retnVal = QueueInitial(&pUnifyInfo->OutnetQueueB, pUnifyInfo->OutnetQueueSize);
	if (0 == retnVal)
	{
		return retnVal;
	}

	/* 输出模块输出数组:指向冗余层的输出数组空间 */

	pUnifyInfo->AppArraySize = (pUnifyInfo->OutputSize + 38 + 7) * maxLnkNum + 4;
	pUnifyInfo->AppArray = NULL;
	pUnifyInfo->AppArray = (UINT8*)malloc(pUnifyInfo->AppArraySize);
	if (NULL != pUnifyInfo->AppArray)
	{
		/*初始化*/
		CommonMemSet(pUnifyInfo->AppArray, pUnifyInfo->AppArraySize, 0, pUnifyInfo->AppArraySize);
	}
	else
	{
		retnVal = 0;
		/* 记录 */
		return retnVal;
	}
	/* 输出模块输出中间变量数组大小 */
	pUnifyInfo->VarArraySize = VAR_NODE_LEN * maxLnkNum + 32;
	pUnifyInfo->VarArray = NULL;
	pUnifyInfo->VarArray = (UINT8*)malloc(pUnifyInfo->VarArraySize);
	if (NULL == pUnifyInfo->VarArray)
	{
		retnVal = 0;
		/* 记录 */
		return retnVal;
	}
	else
	{
		/* 初始化 */
		CommonMemSet(pUnifyInfo->VarArray, pUnifyInfo->VarArraySize, 0, pUnifyInfo->VarArraySize);
	}

	/*  记录数组  */
	pUnifyInfo->RecordArray = NULL;
	pUnifyInfo->RecordArray = (UINT8*)malloc(pUnifyInfo->RecordArraySize);
	if (NULL != pUnifyInfo->RecordArray)
	{
		/* 初始化 */
		CommonMemSet(pUnifyInfo->RecordArray, pUnifyInfo->RecordArraySize, 0, pUnifyInfo->RecordArraySize);
	}
	else
	{
		retnVal = 0;
		/* 记录 */
		return retnVal;
	}

	retnVal = 1;
	return retnVal;
}


/******************************************************************************************
* 功能描述      : 初始化SFP协议结构体
1. 动态分配SFP协议结构体空间，并对其进行初始化；
* 输入参数      :UINT8  typeNum   本设备通信使用SFP协议的个数

* 输出参数      :
* 全局变量      :
* 返回值        : 成功返回1,失败返回0
*******************************************************************************************/

static UINT8 InitSfpProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_SFP
	UINT32* curDevRecordLen = pUnifyInfo->GlobalVar->curDevRecordLen;
	struc_Unify_Info* gpsfpUnitInfo = NULL;	/*SFP协议结构体*/

	if (typeNum != 0)
	{
		if (gpsfpUnitInfo == NULL)
		{
			gpsfpUnitInfo = (struc_Unify_Info*)malloc(sizeof(struc_Unify_Info));
		}
		if (gpsfpUnitInfo != NULL)
		{
			pUnifyInfo->GlobalVar->gpsfpUnitInfo = gpsfpUnitInfo;	/*设置全局SFP结构*/
			CommonMemSet(gpsfpUnitInfo, sizeof(struc_Unify_Info), 0, sizeof(struc_Unify_Info));
			/* 协议初始化 */
			/* 初始化值设定 */
			gpsfpUnitInfo->CpuId = pUnifyInfo->cpuId;
			gpsfpUnitInfo->CycleNum = pUnifyInfo->CycleNum;
			gpsfpUnitInfo->TimeCounter = pUnifyInfo->CycleNum;
			gpsfpUnitInfo->LocalID = pUnifyInfo->LocalID;		/* 设备ID*/
			gpsfpUnitInfo->LocalType = pUnifyInfo->LocalType;		/* 设备type*/
			gpsfpUnitInfo->MaxNumLink = (UINT8)typeNum;		/* 通信的对象数*/
			gpsfpUnitInfo->MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle; /* 一周期允许每个对象的最大有效数据*/
			gpsfpUnitInfo->InputSize = pUnifyInfo->InputSize;	 /* 接受数据中最大一帧的应用数据长度*/
			gpsfpUnitInfo->OutputSize = pUnifyInfo->OutputSize;	 /* 发送数据中最大一帧的应用数据长度*/
			gpsfpUnitInfo->RecordArraySize = (UINT16)curDevRecordLen[0];	/* 记录数组大小*/
			gpsfpUnitInfo->OutnetQueueSize = typeNum * (pUnifyInfo->InputSize + 23) * 3 * 2 + 100;
			gpsfpUnitInfo->RedundTimeout = 0xffff;
			gpsfpUnitInfo->OutputTimeout = 0xffff;
			gpsfpUnitInfo->RadamSN = 0x1;

			ret = ProtclInit(fileName, inDataLen, inData, gpsfpUnitInfo);

			if (ret != 1)
			{
				return ret;
			}
		}
		else
		{
			ret = 0;
			return ret;
		}
	}
	else
	{
		/* 不做处理 */
	}
	ret = 1;
#endif

	return ret;
}

/**
 * @brief InitRpProtclStru 初始RP
 * @param fileName FS文件 取值范围:字节数组
 * @param inDataLen 内网FS数据长度 取值范围:0x00000000-0xFFFFFFFF
 * @param inData 内网FS数据 取值范围:字节数组
 * @param typeNum 链路数量 取值范围:0x00-0xFF
 * @param pUnifyInfo 链路数量 取值范围:参考结构体:ProtclConfigInfoStru
 * @return 0:失败 1:成功
 */
static UINT8 InitRpProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0U; /*-< 设置函数返回值为失败*/

#ifdef USE_RP /*是否定义使用RP宏开关*/
	UINT32* curDevRecordLen = pUnifyInfo->GlobalVar->curDevRecordLen; /*得到各协议日志长度数组*/
	RP_INFO_STRU* gpRedunUnitInfo = NULL; /*RP实例*/

	if (0U != typeNum) /*-< 输入链路数是否不等于0*/
	{
		if (gpRedunUnitInfo == NULL) /*-< RP实例是否为空*/
		{
			gpRedunUnitInfo = (RP_INFO_STRU*)malloc(sizeof(RP_INFO_STRU)); /*-< 分配RP实例空间*/

		}
		if (gpRedunUnitInfo != NULL) /*-< RP实例是否非空*/
		{
			pUnifyInfo->GlobalVar->gpRedunUnitInfo = gpRedunUnitInfo;	/*设置冗余层协议结构体*/

			(void)CommonMemSet(gpRedunUnitInfo, sizeof(RP_INFO_STRU), 0U, sizeof(RP_INFO_STRU));
			/* 协议初始化 */
			/* 初始化值设定 */
			gpRedunUnitInfo->LocalID = pUnifyInfo->LocalID; /*-< 适配层实例本方ID赋值给RP实例本方ID*/
			gpRedunUnitInfo->LocalType = pUnifyInfo->LocalType; /*-< 适配层实例本方类型赋值给RP实例本方类型*/
			gpRedunUnitInfo->MaxNumLink = (UINT8)typeNum; /*-< 适配层实例链路数赋值给RP实例链路数*/
			gpRedunUnitInfo->MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle; /*-< 适配层实例每周期收最大包数赋值给RP实例每周期收最大包数*/
			gpRedunUnitInfo->InputSize = pUnifyInfo->InputSize; /*-< 适配层实例输入应用长度赋值给RP实例输入应用长度*/
			gpRedunUnitInfo->OutputSize = pUnifyInfo->OutputSize; /*-< 适配层实例输出应用长度赋值给RP实例输出应用长度*/
			gpRedunUnitInfo->RecordArraySize = (UINT16)curDevRecordLen[1]; /*-< 适配层实例日志长度赋值给RP实例日志长度*/
			gpRedunUnitInfo->OutnetQueueSize = typeNum * (pUnifyInfo->InputSize + 23U) * 3U * 2U + 100U; /*-< 适配层实例应用给协议队列长度赋值给RP实例应用给协议队列长度*/
			gpRedunUnitInfo->interfaceType = pUnifyInfo->rpInterfaceType; /*-< 设置接口类型*/

			ret = RpInit(fileName, gpRedunUnitInfo); /*-< 调用初始化RP函数,结果赋值给函数返回值*/

			if (ret != 1U) /*-< 函数返回值是否非成功*/
			{
				return ret; /*-< 返回函数返回值*/
			}
		}
		else
		{
			ret = 0U; /*-< 设置函数返回值为失败*/
			return ret; /*-< 返回函数返回值*/
		}
	}
	else
	{
		/*-< 不做处理*/
	}
	ret = 1U; /*-< 设置函数返回值为成功*/
#endif

	return ret; /*-< 返回函数返回值*/
}

/******************************************************************************************
* 功能描述      : 初始化RSSP协议结构体
1. 动态分配RSSP协议结构体空间，并对其进行初始化；
* 输入参数      :UINT8  typeNum   本设备通信使用RSSP协议的个数

* 输出参数      :
* 全局变量      :
* 返回值        : 成功返回1,失败返回0
*******************************************************************************************/
static UINT8 InitRsspProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RSSPI
	UINT32* curDevRecordLen = pUnifyInfo->GlobalVar->curDevRecordLen;
	RSSP_INFO_STRU* gpRsspUnitInfo = NULL;

	if (0 != typeNum)
	{
		if (NULL == gpRsspUnitInfo)
		{
			gpRsspUnitInfo = (RSSP_INFO_STRU*)malloc(sizeof(RSSP_INFO_STRU));
		}
		if (NULL != gpRsspUnitInfo)
		{
			pUnifyInfo->GlobalVar->gpRsspUnitInfo = gpRsspUnitInfo;

			CommonMemSet(gpRsspUnitInfo, sizeof(RSSP_INFO_STRU), 0, sizeof(RSSP_INFO_STRU));
			/* 协议初始化,初始化值设定 */
			gpRsspUnitInfo->cpuId = pUnifyInfo->cpuId;
			gpRsspUnitInfo->CycleNum = pUnifyInfo->CycleNum;
			gpRsspUnitInfo->LocalID = pUnifyInfo->LocalID;		/* 设备ID*/
			gpRsspUnitInfo->LocalType = pUnifyInfo->LocalType;		/* 设备type*/
			gpRsspUnitInfo->LocalLogicId = pUnifyInfo->LocalLogicId;	/*本方逻辑ID*/
			gpRsspUnitInfo->MaxNumLink = typeNum;		/* 通信的对象数*/
			gpRsspUnitInfo->MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle; /* 一周期允许每个对象的最大有效数据*/
			gpRsspUnitInfo->InputSize = pUnifyInfo->InputSize;	 /* 接受数据中最大一帧的应用数据长度*/
			gpRsspUnitInfo->OutputSize = pUnifyInfo->OutputSize;	 /* 发送数据中最大一帧的应用数据长度*/
			gpRsspUnitInfo->RecordArraySize = (UINT16)curDevRecordLen[3]; /* 记录数组大小*/

			gpRsspUnitInfo->OutnetQueueSize = typeNum * (pUnifyInfo->InputSize + 25u) * gpRsspUnitInfo->MaxNumPerCycle * 2u;

			ret = Rssp2Init(fileName, inDataLen, inData, gpRsspUnitInfo);

			if (ret != 1)
			{
				return ret;
			}
		}
		else
		{
			ret = 0;
			return ret;
		}
	}
	else
	{
		/* 不做处理 */
	}
	ret = 1;
#endif

	return ret;
}

/******************************************************************************************
* 功能描述      : 初始化RSSP2协议结构体
1. 动态分配RSSP2协议结构体空间，并对其进行初始化；
* 输入参数      :UINT8  typeNum   本设备通信使用RSSP2协议的个数

* 输出参数      :
* 全局变量      :
* 返回值        : 成功返回1,失败返回0
*******************************************************************************************/
static UINT8 InitRssp2ProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;
#ifdef USE_RSSPII
	UINT32* curDevRecordLen = pUnifyInfo->GlobalVar->curDevRecordLen;
	RSSP2_INFO_STRU* gpRssp2UnitInfo = NULL;

	if (0 != typeNum)
	{
		if (200 < typeNum)
		{
			typeNum = 200;
		}
		if (NULL == gpRssp2UnitInfo)
		{
			gpRssp2UnitInfo = (RSSP2_INFO_STRU*)malloc(sizeof(RSSP2_INFO_STRU));
		}

		if (NULL != gpRssp2UnitInfo)
		{
			pUnifyInfo->GlobalVar->gpRssp2UnitInfo = gpRssp2UnitInfo;

			CommonMemSet(gpRssp2UnitInfo, sizeof(RSSP2_INFO_STRU), 0, sizeof(RSSP2_INFO_STRU));
			/* 协议初始化,初始化值设定 */
			gpRssp2UnitInfo->CycleNum = pUnifyInfo->CycleNum;
			gpRssp2UnitInfo->RandomNum = pUnifyInfo->CycleNum; /* add 20160819 xb 增加随机数功能 */
			gpRssp2UnitInfo->LocalID = pUnifyInfo->LocalID;		/* 设备ID*/
			gpRssp2UnitInfo->LocalType = pUnifyInfo->LocalType;	/* 设备type*/
			gpRssp2UnitInfo->MaxNumLink = (UINT8)typeNum;		        /* 通信的对象数*/
			gpRssp2UnitInfo->MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle; /* 一周期允许每个对象的最大有效数据*/
			if ((pUnifyInfo->InputSize > RSSP2_MAX_LEN) || (pUnifyInfo->OutputSize > RSSP2_MAX_LEN))
			{
				gpRssp2UnitInfo->InputSize = RSSP2_MAX_LEN;	 /* 接受数据中最大一帧的应用数据长度*/
				gpRssp2UnitInfo->OutputSize = RSSP2_MAX_LEN;	 /* 发送数据中最大一帧的应用数据长度*/
			}
			else
			{
				gpRssp2UnitInfo->InputSize = pUnifyInfo->InputSize;	 /* 接受数据中最大一帧的应用数据长度*/
				gpRssp2UnitInfo->OutputSize = pUnifyInfo->OutputSize;	 /* 发送数据中最大一帧的应用数据长度*/
			}
			gpRssp2UnitInfo->RecordArraySize = (UINT16)curDevRecordLen[4]; /* 记录数组大小*/

			gpRssp2UnitInfo->OutnetQueueSize = typeNum * (pUnifyInfo->InputSize + 23) * 3 * 2 + 100;

			ret = RsspIIInit(fileName, gpRssp2UnitInfo);

			if (ret != 1)
			{
				return ret;
			}
		}
		else
		{
			ret = 0;
			return ret;
		}
	}
	else
	{
		/* 不做处理 */
	}

	ret = 1;
#endif

	return ret;
}


/******************************************************************************************
* 功能描述      : 初始化RSR协议结构体
1. 动态分配RSR协议结构体空间，并对其进行初始化；
* 输入参数      :UINT8  typeNum   本设备通信使用RSR协议的个数

* 输出参数      :
* 全局变量      :
* 返回值        : 成功返回1,失败返回0
*******************************************************************************************/
static UINT8 InitRsrProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RSR
	UINT32* curDevRecordLen = pUnifyInfo->GlobalVar->curDevRecordLen;
	RSR_INFO_STRU* gpRsrUnitInfo = NULL;

	if (0 != typeNum)
	{
		if (NULL == gpRsrUnitInfo)
		{
			gpRsrUnitInfo = (RSR_INFO_STRU*)malloc(sizeof(RSR_INFO_STRU));
		}
		if (NULL != gpRsrUnitInfo)
		{
			pUnifyInfo->GlobalVar->gpRsrUnitInfo = gpRsrUnitInfo;

			CommonMemSet(gpRsrUnitInfo, sizeof(RSR_INFO_STRU), 0, sizeof(RSR_INFO_STRU));
			/* 协议初始化,初始化值设定 */
			gpRsrUnitInfo->CycleNum = pUnifyInfo->CycleNum;
			gpRsrUnitInfo->LocalID = pUnifyInfo->LocalID;		/* 设备ID*/
			gpRsrUnitInfo->LocalType = pUnifyInfo->LocalType;		/* 设备type*/
			gpRsrUnitInfo->MaxNumLink = (UINT8)typeNum;		/* 通信的对象数*/
			gpRsrUnitInfo->MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle; /* 一周期允许每个对象的最大有效数据*/
			if ((pUnifyInfo->InputSize > RSR_RSSP_MAX_LEN) || (pUnifyInfo->OutputSize > RSR_RSSP_MAX_LEN))
			{
				gpRsrUnitInfo->InputSize = RSR_RSSP_MAX_LEN;	 /* 接受数据中最大一帧的应用数据长度*/
				gpRsrUnitInfo->OutputSize = RSR_RSSP_MAX_LEN;	 /* 发送数据中最大一帧的应用数据长度*/
			}
			else
			{
				gpRsrUnitInfo->InputSize = pUnifyInfo->InputSize;	 /* 接受数据中最大一帧的应用数据长度*/
				gpRsrUnitInfo->OutputSize = pUnifyInfo->OutputSize;	 /* 发送数据中最大一帧的应用数据长度*/
			}
			gpRsrUnitInfo->RecordArraySize = (UINT16)curDevRecordLen[2]; /* 记录数组大小*/

			gpRsrUnitInfo->OutnetQueueSize = typeNum * (pUnifyInfo->InputSize + 23) * 3 * 2 + 100;

			ret = RsrInit(fileName, gpRsrUnitInfo);

			if (ret != 1)
			{
				return ret;
			}
		}
		else
		{
			ret = 0;
			return ret;
		}
	}
	else
	{
		/* 不做处理 */
	}
	ret = 1;

#endif

	return ret;
}

/******************************************************************************************
* 功能描述      : 初始化FSFB协议结构体
1. 动态分配RSR协议结构体空间，并对其进行初始化；
* 输入参数      :UINT8  typeNum   本设备通信使用RSR协议的个数

* 输出参数      :
* 全局变量      :
* 返回值        : 成功返回1,失败返回0
*******************************************************************************************/
static UINT8 InitFsfbProtclStru(UINT8* fileName, UINT32 inDataLen, UINT8 inData[], UINT16 typeNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 rtn = 0;

#ifdef USE_FSFB

	FSFB_INFO_STRU* fsfbUnitInfo = NULL;

	if (0 < typeNum) /*有通信设备数量*/
	{
		fsfbUnitInfo = (FSFB_INFO_STRU*)malloc(sizeof(FSFB_INFO_STRU));
		if (NULL != fsfbUnitInfo) /*分配内存成功*/
		{
			pUnifyInfo->GlobalVar->gpFsfbUnitInfo = fsfbUnitInfo;
			CommonMemSet(fsfbUnitInfo, sizeof(FSFB_INFO_STRU), 0, sizeof(FSFB_INFO_STRU));

			fsfbUnitInfo->CycleNum = pUnifyInfo->CycleNum;
			fsfbUnitInfo->LocalType = pUnifyInfo->LocalType;
			fsfbUnitInfo->LocalID = pUnifyInfo->LocalID;
			fsfbUnitInfo->MaxNumLink = (UINT8)typeNum;
			fsfbUnitInfo->MaxNumPerCycle = pUnifyInfo->MaxNumPerCycle;
			if ((pUnifyInfo->InputSize > FSFB_MAX_LEN) || (pUnifyInfo->OutputSize > FSFB_MAX_LEN)) /*超出每帧应用最大长度*/
			{
				fsfbUnitInfo->InputSize = FSFB_MAX_LEN;
				fsfbUnitInfo->OutputSize = FSFB_MAX_LEN;
			}
			else
			{
				fsfbUnitInfo->InputSize = pUnifyInfo->InputSize;
				fsfbUnitInfo->OutputSize = pUnifyInfo->OutputSize;
			}
			fsfbUnitInfo->RecordArraySize = (UINT16)pUnifyInfo->GlobalVar->curDevRecordLen[5]; /* 记录数组大小*/

			rtn = FsfbProtclInit(fileName, fsfbUnitInfo);
		}
		else /*分配内存失败*/
		{
			rtn = 0;
		}
	}
	else /*无通信设备数量*/
	{
		rtn = 1;
	}

#endif

	return rtn;
}

/***********协议发送相关函数**************************************************************/
/*
* 功能：应用发送的数据解析
*
* 参数：
* 输入参数：  const QueueStruct *pAppQueueData    应用输入到协议的数据队列
* 输出参数：  PROTCL_APP_TO_STRU *protclAppStru   解析后的数据
* 返回值：
*    UINT8 1 收到完整数据帧，0 无数据
*/
UINT8 AppSendInputDataAnalysis(QueueStruct* pAppQueueData, PROTCL_APP_TO_STRU* pProtclAppStru)
{
	UINT8 retVal = 0;
	UINT8 tempBuff[2] = { 0 };
	UINT16 tempDatalen = 0;

	QueueScan(2, tempBuff, pAppQueueData);	/* 肯定存在两个字节 */
	tempDatalen = ShortFromChar(tempBuff);
	if (((tempDatalen + 2) <= QueueStatus(pAppQueueData)) && (4 <= tempDatalen))
	{
		pProtclAppStru->appDataLen = tempDatalen - 4;
		QueueRead(2, tempBuff, pAppQueueData);/* 长度 */
		QueueRead(1, &pProtclAppStru->devType, pAppQueueData);/* 类型 */
		QueueRead(1, &pProtclAppStru->devId, pAppQueueData);/* ID */
		QueueRead(2, tempBuff, pAppQueueData);/* LogicID */
		pProtclAppStru->devLogId = ShortFromChar(tempBuff);
		QueueRead((tempDatalen - 4), pProtclAppStru->pAppData, pAppQueueData);/* 应用数据 */

		retVal = 1;
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}

/*
* 功能：SFP协议入口组帧
*
* 参数：
* 输入参数：  const PROTCL_APP_TO_STRU *protclAppStru   需要组的数据
* 输出参数：  QueueStruct *pAppQueueData    协议入口数据队列
* 返回值：
*    UINT8 1 正常，0 不正常
*/
UINT8 sfpInputPackFms(const PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData)
{
	UINT8 retVal = 0;
	UINT8 tmpHeadBuf[6] = { 0 };

	if (protclAppStru.appDataLen > 0)
	{
		/* 长度 */
		ShortToChar(protclAppStru.appDataLen + 4, tmpHeadBuf);
		/* 2个字节的预留 */
		tmpHeadBuf[2] = 0;
		tmpHeadBuf[3] = 0;
		/* 设备ID */
		tmpHeadBuf[4] = protclAppStru.devId;
		/* 设备类型 */
		tmpHeadBuf[5] = protclAppStru.devType;
		QueueWrite(6, tmpHeadBuf, pAppQueueData);
		QueueWrite(protclAppStru.appDataLen, protclAppStru.pAppData, pAppQueueData);

		retVal = 1;
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}


/*
* 功能：SFP协议发送数据
*
* 参数：
* 输入参数：  devDataCount	设备数据个数	UINT8
* 输出参数：
*             sendDataLen	发送数据长度	UINT32*
*             pSndData	    发送数据	    UINT8*
*             pLnkStatusData	协议状态数据	UINT8*
*             lnkDataLen	协议状态数据长度	UINT16*
*             recordArray 	协议记录数据	UINT8*
*             recordDataLen	协议记录数据长度	UINT16*

* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 sfpSendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	UINT8 ret = 0;

#ifdef USE_SFP
	UINT32 i = 0;/* 循环使用 */
	UINT32 len = 0;
	UINT32 dataLen = 0;
	UINT16 lenInput = 0;
	UINT16 tempRecordSize = 0;
	PROTCL_APP_TO_STRU* pAppDataStru = pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_SFP].pProtclAppStru;
	struc_Unify_Info* gpsfpUnitInfo = pUnifyInfo->GlobalVar->gpsfpUnitInfo;	/*SFP协议结构体*/

	QueueClear(&gpsfpUnitInfo->OutputDataQueue);

	if (pAppDataStru != NULL)
	{
		for (i = 0; i < devDataCount; i++)
		{
			sfpInputPackFms(pAppDataStru[i], &gpsfpUnitInfo->OutputDataQueue);
		}
#ifdef CI_TASKLOCK
		taskLock();
		ret = ProtclOutput(gpsfpUnitInfo);
		taskUnlock();
#else
		ret = ProtclOutput(gpsfpUnitInfo);
#endif
		if (ret == 1)
		{
			/* 该长度包含中间变量和报文数据 丢弃该长度 */
			/* 从数据长度0到通信链路管理表的数据长度 4字节 */
			len = LongFromChar(gpsfpUnitInfo->PrtclSndBuff);
			/* 报文的总长度*/
			if (len > 4)
			{
				dataLen = LongFromChar(gpsfpUnitInfo->PrtclSndBuff + 4);

				*sendDataLen = dataLen;
				CommonMemCpy(pSndData, dataLen, gpsfpUnitInfo->PrtclSndBuff + 8, dataLen);
				if (len - dataLen - 4 > 0)
				{

					lenInput = (UINT16)(len - dataLen - 4);
					(*lnkDataLen) = lenInput + 2;
					ShortToChar(lenInput, pLnkStatusData);
					CommonMemCpy(&pLnkStatusData[2], lenInput, gpsfpUnitInfo->PrtclSndBuff + 8 + dataLen, lenInput);
				}
				else
				{
					/* 不做任何处理 */
					*sendDataLen = 0;
					ShortToChar(0, pLnkStatusData);
					*lnkDataLen = 2;
				}
			}
			else
			{
				/* 不做处理 */
				*sendDataLen = 0;
				ShortToChar(0, pLnkStatusData);
				*lnkDataLen = 2;
			}
		}
		else
		{
			pSndData = NULL;
			pLnkStatusData = NULL;

			*sendDataLen = 0;
			*lnkDataLen = 0;
		}

		tempRecordSize = ShortFromChar(gpsfpUnitInfo->RecordArray) + 1;
		if (gpsfpUnitInfo->RecordArraySize > 3)
		{
			if (gpsfpUnitInfo->RecordArraySize >= (tempRecordSize + 2))
			{
				ShortToChar(0, gpsfpUnitInfo->RecordArray);
				ShortToChar(tempRecordSize, recordArray);
				CommonMemCpy(&recordArray[2], tempRecordSize - 1, &gpsfpUnitInfo->RecordArray[2], tempRecordSize - 1);
				recordArray[2 + tempRecordSize - 1] = '\0';
				*recordDataLen = tempRecordSize + 2;
			}
			else
			{
				ShortToChar(0, gpsfpUnitInfo->RecordArray);
				ShortToChar(gpsfpUnitInfo->RecordArraySize - 2, recordArray);
				CommonMemCpy(&recordArray[2], gpsfpUnitInfo->RecordArraySize - 3, &gpsfpUnitInfo->RecordArray[2], gpsfpUnitInfo->RecordArraySize - 3);
				recordArray[gpsfpUnitInfo->RecordArraySize - 1] = '\0';
				*recordDataLen = gpsfpUnitInfo->RecordArraySize;
			}
		}

	}
	else
	{
		ret = 0;
		pSndData = NULL;
		pLnkStatusData = NULL;
		ShortToChar(0, recordArray);
		*sendDataLen = 0;
		*lnkDataLen = 0;
		*recordDataLen = 0;
	}
#endif

	return ret;
}


/*
* 功能：RSSP协议入口组帧
*
* 参数：
* 输入参数：  const PROTCL_APP_TO_STRU *protclAppStru   需要组的数据
* 输出参数：  QueueStruct *pAppQueueData    协议入口数据队列
* 返回值：
*    UINT8 1 正常，0 不正常
*/
UINT8 RsspInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData)
{
	UINT8 retVal = 0;
	UINT8 tmpHeadBuf[6] = { 0 };

	if (protclAppStru.appDataLen > 0)
	{
		/* 两个字节的长度 */
		ShortToChar(protclAppStru.appDataLen + 4, tmpHeadBuf);
		/*一个字节的设备ID */
		tmpHeadBuf[3] = protclAppStru.devId;
		/*一个字节的设备类型 */
		tmpHeadBuf[2] = protclAppStru.devType;
		/*2个字节逻辑ID*/
		ShortToChar(protclAppStru.devLogId, &tmpHeadBuf[4]);
		QueueWrite(6, tmpHeadBuf, pAppQueueData);
		QueueWrite(protclAppStru.appDataLen, protclAppStru.pAppData, pAppQueueData);

		retVal = 1;
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}


/*
* 功能：RSSP协议发送数据
*
* 参数：
* 输入参数：  devDataCount	设备数据个数	UINT8
* 输出参数：  sendDataLen	发送数据长度	UINT32*
*             pSndData	    发送数据	    UINT8*
*             pLnkStatusData	协议状态数据	UINT8*
*             lnkDataLen	协议状态数据长度	UINT16*
*             recordArray 	协议记录数据	UINT8*
*             recordDataLen	协议记录数据长度	UINT16*
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RsspSendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	UINT8 ret = 0;

#ifdef USE_RSSPI
	UINT32 i = 0;/* 循环使用 */
	UINT32 len = 0;
	UINT16 varlen = 0;
	UINT16 tempRecordSize = 0;
	PROTCL_APP_TO_STRU* pAppDataStru = NULL;
	RSSP_INFO_STRU* gpRsspUnitInfo = NULL;

	if ((NULL != pUnifyInfo) && (NULL != sendDataLen) && (NULL != lnkDataLen) && (NULL != recordArray) && (NULL != recordDataLen) && (NULL != pUnifyInfo->GlobalVar))
	{
		pAppDataStru = pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_RSSP].pProtclAppStru;
		gpRsspUnitInfo = pUnifyInfo->GlobalVar->gpRsspUnitInfo;

		if ((pAppDataStru != NULL) && (pSndData != NULL) && (pLnkStatusData != NULL))
		{
			QueueClear(&gpRsspUnitInfo->OutputDataQueue);

			for (i = 0; i < devDataCount; i++)
			{
				RsspInputPackFms(pAppDataStru[i], &gpRsspUnitInfo->OutputDataQueue);
			}


			ret = Rssp2Output(gpRsspUnitInfo);
			if (ret == 1)
			{
				/* 整个数组长度 4字节 */
				len = LongFromChar(gpRsspUnitInfo->AppArray);
				*sendDataLen = len;

				/* 中间变量整个数组长度 2字节 */
				varlen = ShortFromChar(gpRsspUnitInfo->VarArray);
				*lnkDataLen = varlen + 2;
				/* 报文的总长度*/
				if (len > 2)
				{
					CommonMemCpy(pSndData, len, gpRsspUnitInfo->AppArray + 4, len);
				}
				else
				{
					/* 不做处理 */
					*sendDataLen = 0;
					/**lnkDataLen = 0;*/
				}
				if (varlen > 2)
				{
					CommonMemCpy(pLnkStatusData, varlen + 2, gpRsspUnitInfo->VarArray, varlen + 2);

				}
				else
				{
					/* 不做处理 */
					ShortToChar(0, pLnkStatusData);
					*lnkDataLen = 2;
				}
			}
			else
			{
				pSndData = NULL;
				pLnkStatusData = NULL;
				*sendDataLen = 0;
				*lnkDataLen = 0;
				ret = 0;
			}

			tempRecordSize = ShortFromChar(gpRsspUnitInfo->RecordArray) + 1;
			if (gpRsspUnitInfo->RecordArraySize > 3)
			{
				if (gpRsspUnitInfo->RecordArraySize >= (tempRecordSize + 2))
				{
					ShortToChar(0, gpRsspUnitInfo->RecordArray);
					ShortToChar(tempRecordSize, recordArray);
					CommonMemCpy(&recordArray[2], tempRecordSize - 1, &gpRsspUnitInfo->RecordArray[2], tempRecordSize - 1);
					recordArray[2 + tempRecordSize - 1] = '\0';
					*recordDataLen = tempRecordSize + 2;
				}
				else
				{
					ShortToChar(0, gpRsspUnitInfo->RecordArray);
					ShortToChar(gpRsspUnitInfo->RecordArraySize - 2, recordArray);
					CommonMemCpy(&recordArray[2], gpRsspUnitInfo->RecordArraySize - 3, &gpRsspUnitInfo->RecordArray[2], gpRsspUnitInfo->RecordArraySize - 3);
					recordArray[gpRsspUnitInfo->RecordArraySize - 1] = '\0';
					*recordDataLen = gpRsspUnitInfo->RecordArraySize;
				}
			}
		}
		else
		{
			pSndData = NULL;
			pLnkStatusData = NULL;
			ShortToChar(0, recordArray);
			*sendDataLen = 0;
			*lnkDataLen = 0;
			*recordDataLen = 0;
			ret = 0;
		}
	}


#endif

	return ret;
}


/*
* 功能：RSSP2协议入口组帧
*
* 参数：
* 输入参数：  const PROTCL_APP_TO_STRU *protclAppStru   需要组的数据
* 输出参数：  QueueStruct *pAppQueueData    协议入口数据队列
* 返回值：
*    UINT8 1 正常，0 不正常
*/
UINT8 Rssp2InputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData)
{
	UINT8 retVal = 0;
	UINT8 tmpHeadBuf[6] = { 0 };

	if (protclAppStru.appDataLen > 0)
	{
		/* 两个字节的长度 */
		ShortToChar(protclAppStru.appDataLen + 4, tmpHeadBuf);
		/*一个字节的设备ID */
		tmpHeadBuf[3] = protclAppStru.devId;
		/*一个字节的设备类型 */
		tmpHeadBuf[2] = protclAppStru.devType;
		/*2个字节的逻辑ID*/
		ShortToChar(protclAppStru.devLogId, &tmpHeadBuf[4]);
		QueueWrite(6, tmpHeadBuf, pAppQueueData);
		QueueWrite(protclAppStru.appDataLen, protclAppStru.pAppData, pAppQueueData);

		retVal = 1;
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}

/*
* 功能：RSSP2协议发送数据
*
* 参数：
* 输入参数：  devDataCount	设备数据个数	UINT8
* 输出参数：  sendDataLen	发送数据长度	UINT32*
*             pSndData	    发送数据	    UINT8*
*             pLnkStatusData	协议状态数据	UINT8*
*             lnkDataLen	协议状态数据长度	UINT16*
*             recordArray 	协议记录数据	UINT8*
*             recordDataLen	协议记录数据长度	UINT16*
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 Rssp2SendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	UINT8 ret = 0;
#ifdef USE_RSSPII
	UINT32 i = 0;/* 循环使用 */
	UINT32 len = 0;
	UINT16 varlen = 0;
	UINT16 recordLen = 0;
	PROTCL_APP_TO_STRU* pAppDataStru = pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_RSSP2].pProtclAppStru;
	RSSP2_INFO_STRU* gpRssp2UnitInfo = pUnifyInfo->GlobalVar->gpRssp2UnitInfo;

	if ((pAppDataStru != NULL) && (pSndData != NULL) && (pLnkStatusData != NULL))
	{
		QueueClear(&gpRssp2UnitInfo->OutputDataQueue);

		for (i = 0; i < devDataCount; i++)
		{
			Rssp2InputPackFms(pAppDataStru[i], &gpRssp2UnitInfo->OutputDataQueue);
		}


		ret = RsspIIOutput(gpRssp2UnitInfo);

		if (ret == 1)
		{

			/* 报文的总长度*/
			len = (UINT32)(gpRssp2UnitInfo->AppArraySize);
			if (len > 2)
			{
				CommonMemCpy(pSndData, len, gpRssp2UnitInfo->AppArray, len);
				*sendDataLen = len;
			}
			else
			{
				/* 不做处理 */
				*sendDataLen = 0;
			}
			/* 中间变量整个数组长度 2字节 */
			varlen = ShortFromChar(gpRssp2UnitInfo->VarArray);
			if (varlen > 2)
			{
				CommonMemCpy(pLnkStatusData, varlen + 2, gpRssp2UnitInfo->VarArray, varlen + 2);
				*lnkDataLen = varlen + 2;
			}
			else
			{
				/* 不做处理 */
				ShortToChar(0, pLnkStatusData);
				*lnkDataLen = 2;
			}

			recordLen = ShortFromChar(gpRssp2UnitInfo->RecordArray);
			if (recordLen > 2)
			{
				CommonMemCpy(recordArray, recordLen + 2, gpRssp2UnitInfo->RecordArray, recordLen + 2);
				*recordDataLen = recordLen + 2;
			}
			else
			{
				ShortToChar(0, recordArray);
				*recordDataLen = 2;
			}
		}
		else
		{
			pSndData = NULL;
			pLnkStatusData = NULL;
			*sendDataLen = 0;
			*lnkDataLen = 0;
			*recordDataLen = 0;
			ret = 0;
		}
	}
	else
	{
		pSndData = NULL;
		pLnkStatusData = NULL;
		ShortToChar(0, recordArray);
		*sendDataLen = 0;
		*lnkDataLen = 0;
		*recordDataLen = 0;
		ret = 0;
	}
#endif

	return ret;
}




#ifdef USE_RSR
/*
* 功能：RSR协议入口组帧
*
* 参数：
* 输入参数：  const PROTCL_APP_TO_STRU *protclAppStru   需要组的数据
* 输出参数：  QueueStruct *pAppQueueData    协议入口数据队列
* 返回值：
*    UINT8 1 正常，0 不正常
*/
UINT8 RsrInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData, RSR_INFO_STRU* gpRsrUnitInfo)
{
	UINT8 retVal = 0;
	UINT8 tmpHeadBuf[8] = { 0 };
	UINT16 destDevName = 0;
	UINT16 locDevName = 0;
	UINT8 index = 0;

	UINT16 rsspSrcAdd = 0;
	INT16 bsdAdd = 0;
	UINT16 destRsspAdd = 0;

	if (protclAppStru.appDataLen > 0)
	{
		TypeIdToDevName(protclAppStru.devType, protclAppStru.devId, &destDevName);
		TypeIdToDevName(gpRsrUnitInfo->LocalType, gpRsrUnitInfo->LocalID, &locDevName);
		if (protclAppStru.devType == VOBC_TYPE)
		{
			retVal = dsuVOBCvsCIOutInfo(protclAppStru.devLogId, 0, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
		}
		else if (gpRsrUnitInfo->LocalType == VOBC_TYPE)
		{
			retVal = dsuVOBCvsCIOutInfo(protclAppStru.devLogId, 1, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
		}
		else
		{
			retVal = dsuZCvsCIOutInfo(locDevName, destDevName, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
		}
		if (retVal != 0)
		{
			/* 两个字节的长度 */
			ShortToChar(protclAppStru.appDataLen + 6, tmpHeadBuf);
			index += 2;
			/* 两个字节的源地址 */
			ShortToChar(rsspSrcAdd, tmpHeadBuf + index);
			index += 2;
			/* 两个字节的BSD地址 */
			ShortToChar(bsdAdd, tmpHeadBuf + index);
			index += 2;
			/* 两个字节的目标地址 */
			ShortToChar(destRsspAdd, tmpHeadBuf + index);
			QueueWrite(8, tmpHeadBuf, pAppQueueData);
			QueueWrite(protclAppStru.appDataLen, protclAppStru.pAppData, pAppQueueData);
		}
		else
		{
			retVal = 0;
		}
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}
#endif


/*
* 功能：RSR协议发送数据
*
* 参数：
* 输入参数：  devDataCount	设备数据个数	UINT8
* 输出参数：  sendDataLen	发送数据长度	UINT32*
*             pSndData	    发送数据	    UINT8*
*             pLnkStatusData	协议状态数据	UINT8*
*             lnkDataLen	协议状态数据长度	UINT16*
*             recordArray 	协议记录数据	UINT8*
*             recordDataLen	协议记录数据长度	UINT16*
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RsrSendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	UINT8 ret = 0;

#ifdef USE_RSR
	UINT32 i = 0;
	UINT16 len = 0;
	UINT16 varlen = 0;
	UINT16 tempRecordSize = 0;
	PROTCL_APP_TO_STRU* pAppDataStru = pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_RSR].pProtclAppStru;
	RSR_INFO_STRU* gpRsrUnitInfo = pUnifyInfo->GlobalVar->gpRsrUnitInfo;

	UINT8 protclType = GetCbtcSysType();

	if ((pAppDataStru != NULL) && (pSndData != NULL) && (pLnkStatusData != NULL))
	{
		QueueClear(&gpRsrUnitInfo->OutputDataQueue);
		for (i = 0; i < devDataCount; i++)
		{
			RsrInputPackFms(pAppDataStru[i], &gpRsrUnitInfo->OutputDataQueue, gpRsrUnitInfo);
		}

		ret = RsrOutput(gpRsrUnitInfo);
		if (ret == 1)
		{
			/* 整个数组长度 2字节 */
			len = ShortFromChar(gpRsrUnitInfo->AppArray);
			if (DQU_CBTC_HLT != protclType)
			{
				*sendDataLen = len;
			}
			/* 中间变量整个数组长度 2字节 */
			varlen = ShortFromChar(gpRsrUnitInfo->VarArray);
			/* yw.lou 和RP一样也需要处理不同的情况*/
			/* 报文的总长度*/
			if (len > 2)
			{
				if (DQU_CBTC_HLT == protclType)
				{
					RsrAndRpAppArrayPage(gpRsrUnitInfo->AppArray + 2, len, pSndData, sendDataLen);
				}
				else
				{
					CommonMemCpy(pSndData, len, gpRsrUnitInfo->AppArray + 2, len);
				}
			}
			else
			{
				/* 不做处理 */
				*sendDataLen = 0;
			}
			if (varlen > 2)
			{
				*lnkDataLen = varlen + 2;
				CommonMemCpy(pLnkStatusData, varlen + 2, gpRsrUnitInfo->VarArray, varlen + 2);

			}
			else
			{
				/* 不做处理 */
				ShortToChar(0, pLnkStatusData);

				*lnkDataLen = 2;
			}
		}
		else
		{
			pSndData = NULL;
			pLnkStatusData = NULL;
			*lnkDataLen = 0;
			*sendDataLen = 0;
			ret = 0;
		}

		tempRecordSize = ShortFromChar(gpRsrUnitInfo->RecordArray) + 1;
		if (gpRsrUnitInfo->RecordArraySize > 3)
		{
			if (gpRsrUnitInfo->RecordArraySize >= (tempRecordSize + 2))
			{
				ShortToChar(0, gpRsrUnitInfo->RecordArray);
				ShortToChar(tempRecordSize, recordArray);
				CommonMemCpy(&recordArray[2], tempRecordSize - 1, &gpRsrUnitInfo->RecordArray[2], tempRecordSize - 1);
				recordArray[2 + tempRecordSize - 1] = '\0';
				*recordDataLen = tempRecordSize + 2;
			}
			else
			{
				ShortToChar(0, gpRsrUnitInfo->RecordArray);
				ShortToChar(gpRsrUnitInfo->RecordArraySize - 2, recordArray);
				CommonMemCpy(&recordArray[2], gpRsrUnitInfo->RecordArraySize - 3, &gpRsrUnitInfo->RecordArray[2], gpRsrUnitInfo->RecordArraySize - 3);
				recordArray[gpRsrUnitInfo->RecordArraySize - 1] = '\0';
				*recordDataLen = gpRsrUnitInfo->RecordArraySize;
			}
		}

	}
	else
	{
		pSndData = NULL;
		pLnkStatusData = NULL;
		ShortToChar(0, recordArray);
		*sendDataLen = 0;
		*lnkDataLen = 0;
		*recordDataLen = 0;
		ret = 0;
	}
#endif

	return ret;
}

/*
* 功能：RP协议入口组帧
*
* 参数：
* 输入参数：  const PROTCL_APP_TO_STRU *protclAppStru   需要组的数据
* 输出参数：  QueueStruct *pAppQueueData    协议入口数据队列
* 返回值：
*    UINT8 1 正常，0 不正常
*/
UINT8 RpInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData)
{
	UINT8 retVal = 0;
	UINT8 tmpHeadBuf[4] = { 0 };

	if (protclAppStru.appDataLen > 0)
	{
		/* 两个字节的长度 */
		ShortToChar(protclAppStru.appDataLen + 2, tmpHeadBuf);
		/* 1个字节的设备类型 */
		tmpHeadBuf[2] = protclAppStru.devType;
		/* 1个字节的设备ID */
		tmpHeadBuf[3] = protclAppStru.devId;
		QueueWrite(4, tmpHeadBuf, pAppQueueData);
		QueueWrite(protclAppStru.appDataLen, protclAppStru.pAppData, pAppQueueData);

		retVal = 1;
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}


/*
* 功能：RP协议发送数据
*
* 参数：
* 输入参数：  devDataCount	设备数据个数	UINT8
* 输出参数：  sendDataLen	发送数据长度	UINT32*
*             pSndData	    发送数据	    UINT8*
*             pLnkStatusData	协议状态数据	UINT8*
*             lnkDataLen	协议状态数据长度	UINT16*
*             recordArray 	协议记录数据	UINT8*
*             recordDataLen	协议记录数据长度	UINT16*
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RpSendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	UINT8 ret = 0;

#ifdef USE_RP
	UINT32 i = 0;
	UINT16 len = 0;
	UINT16 varlen = 0;
	UINT16 tempRecordSize = 0;
	PROTCL_APP_TO_STRU* pAppDataStru = pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_RP].pProtclAppStru;
	RP_INFO_STRU* gpRedunUnitInfo = pUnifyInfo->GlobalVar->gpRedunUnitInfo;	/*冗余层协议结构体*/

	if ((pAppDataStru != NULL) && (pSndData != NULL) && (pLnkStatusData != NULL))
	{
		QueueClear(&gpRedunUnitInfo->OutputDataQueue);
		for (i = 0; i < devDataCount; i++)
		{
			RpInputPackFms(pAppDataStru[i], &gpRedunUnitInfo->OutputDataQueue);
		}


		ret = RpOutput(gpRedunUnitInfo);
		if (ret == 1)
		{
			/* 整个数组长度 2字节 */
			len = ShortFromChar(gpRedunUnitInfo->AppArray);
			/* 中间变量整个数组长度 2字节 */
			varlen = ShortFromChar(gpRedunUnitInfo->VarArray);

			/*yw.lou 修改: 由于发送应用数据可能存在为空的情况，而此时有状态数据，则就存在问题*/
			/* 报文的总长度*/
			if ((len > 2))
			{
				CommonMemCpy(pSndData, len, gpRedunUnitInfo->AppArray + 2, len);
				*sendDataLen = len;
			}
			else
			{
				/* 不做处理 */
				*sendDataLen = 0;
			}
			if (varlen > 2)
			{
				*lnkDataLen = varlen + 2;
				CommonMemCpy(pLnkStatusData, varlen + 2, gpRedunUnitInfo->VarArray, varlen + 2);

			}
			else
			{
				/* 不做处理 */
				ShortToChar(0, pLnkStatusData);
				*lnkDataLen = 2;
			}
		}
		else
		{
			pSndData = NULL;
			pLnkStatusData = NULL;
			*sendDataLen = 0;
			*lnkDataLen = 0;
			ret = 0;
		}

		tempRecordSize = ShortFromChar(gpRedunUnitInfo->RecordArray) + 1;
		if (gpRedunUnitInfo->RecordArraySize > 3)
		{
			if (gpRedunUnitInfo->RecordArraySize >= (tempRecordSize + 2))
			{
				ShortToChar(0, gpRedunUnitInfo->RecordArray);
				ShortToChar(tempRecordSize, recordArray);
				CommonMemCpy(&recordArray[2], tempRecordSize - 1, &gpRedunUnitInfo->RecordArray[2], tempRecordSize - 1);
				recordArray[2 + tempRecordSize - 1] = '\0';
				*recordDataLen = tempRecordSize + 2;
			}
			else
			{
				ShortToChar(0, gpRedunUnitInfo->RecordArray);
				ShortToChar(gpRedunUnitInfo->RecordArraySize - 2, recordArray);
				CommonMemCpy(&recordArray[2], gpRedunUnitInfo->RecordArraySize - 3, &gpRedunUnitInfo->RecordArray[2], gpRedunUnitInfo->RecordArraySize - 3);
				recordArray[gpRedunUnitInfo->RecordArraySize - 1] = '\0';
				*recordDataLen = gpRedunUnitInfo->RecordArraySize;
			}
		}
	}
	else
	{
		pSndData = NULL;
		pLnkStatusData = NULL;
		ShortToChar(0, recordArray);
		recordArray = NULL;
		*sendDataLen = 0;
		*lnkDataLen = 0;
		recordDataLen = 0;
		ret = 0;
	}
#endif

	return ret;
}


/*
* 功能：FSFB协议入口组帧
*
* 参数：
* 输入参数：  const PROTCL_APP_TO_STRU *protclAppStru   需要组的数据
* 输出参数：  QueueStruct *pAppQueueData    协议入口数据队列
* 返回值：
*    UINT8 1 正常，0 不正常
*/
UINT8 FsfbInputPackFms(PROTCL_APP_TO_STRU protclAppStru, QueueStruct* pAppQueueData)
{
	UINT8 retVal = 0u; /*返回值*/
	UINT8 headBuf[5] = { 0 }; /*帧头数组*/

	if (protclAppStru.appDataLen > 0)
	{
		ShortToChar(protclAppStru.appDataLen + 3, headBuf); /*2字节长度*/
		headBuf[2] = protclAppStru.devType; /*1字节设备类型*/
		headBuf[3] = protclAppStru.devId; /*1字节设备ID*/
		headBuf[4] = 0x01; /*1字节帧类型*/

		QueueWrite(5, headBuf, pAppQueueData);
		QueueWrite(protclAppStru.appDataLen, protclAppStru.pAppData, pAppQueueData);

		retVal = 1u;
	}

	return retVal;
}

/**
 * @brief FsfbSendData FSFB协议发送数据
 * @param pUnifyInfo FSFB实例 取值范围:参考结构体ProtclConfigInfoStru
 * @param devDataCount 设备数据个数 取值范围:0x00000000-0xFFFFFFFF
 * @param pSndData 发送数据 取值范围:字节数组
 * @param sendDataLen 发送数据长度 取值范围:0x00000000-0xFFFFFFFF
 * @param pLnkStatusData 协议状态数据 取值范围:字节数组
 * @param lnkDataLen 发送数据长度 协议状态数据长度:0x00000000-0xFFFFFFFF
 * @param recordArray 协议记录数据 取值范围:字节数组
 * @param recordDataLen 协议记录数据长度 协议状态数据长度:0x0000-0xFFFF
 * @return 0:失败 1:成功
 */
UINT8 FsfbSendData(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	/*- 定义局部变量*/
	UINT8 retVal = 0u; /*-< 设置函数返回值为失败*/

#ifdef USE_FSFB

	UINT32* curCycleNum = NULL; /*当前周期*/
	PROTCL_APP_TO_STRU* appToStru = NULL; /*应用到协议的数据结构体*/
	FSFB_INFO_STRU* fsfbInfo = NULL; /*FSFB协议结构体*/
	UINT32 i = 0u;/*用于循环*/
	UINT32 outQueDataLen = 0u; /*FSFB输出队列数据长度*/
	UINT8 outQueData[FSFB_MAX_LEN * 16] = { 0 }; /*FSFB输出队列数据*/
	UINT32 outQueIdx = 0u; /*FSFB输出队列位置*/
	UINT16 outQueFramLen = 0u; /*FSFB输出队列帧长度*/
	UINT8 btmHead[5] = { 0 }; /*FSFB BTM帧头*/
	UINT8 queWriteRtn = 0u; /*队列写返回值*/
	UINT32 dataLen = 0u; /*FSFB输出处理后总数据长度*/
	UINT32 dataIdx = 0u; /*FSFB输出处理后总数据当前位置*/
	UINT16 frameLen = 0u; /*FSFB输出处理后帧长度*/
	UINT16 dstTypeId = 0u; /*目的类型ID*/
	UINT16 recordLen = 0u; /*记录长度*/

	if ((NULL != pUnifyInfo) && (NULL != pSndData) && (NULL != sendDataLen) && (NULL != pLnkStatusData) && (NULL != lnkDataLen) && (NULL != recordArray) && (NULL != recordDataLen)
		&& (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo) && (NULL != pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_FSFB].pProtclAppStru)
		&& (NULL != pUnifyInfo->CycleNum)) /*-< 参数是否合法*/
	{
		curCycleNum = pUnifyInfo->CycleNum; /*-< 得到周期号*/
		appToStru = pUnifyInfo->GlobalVar->protclSndCfgStru[DSU_PROTCL_FSFB].pProtclAppStru; /*-< 得到应用给数据*/
		fsfbInfo = pUnifyInfo->GlobalVar->gpFsfbUnitInfo; /*-< 得到FSFB*/

		QueueClear(&fsfbInfo->OutputDataQueue); /*-< 清输出队列*/
		LongToChar(0u, fsfbInfo->AppArray); /*-< 清输出给应用数组*/

		if (0u == ((*curCycleNum) % 2)) /*-< 周期号是否2倍数*/
		{
			for (i = 0; i < devDataCount; i++) /*-< 组各目的设备数据到队列*/
			{
				FsfbInputPackFms(appToStru[i], &fsfbInfo->OutputDataQueue); /*-< 调用输入包函数*/
			}

			if (0 == ((*curCycleNum) % 50)) /*-< 周期号是否50倍数*/
			{
				outQueDataLen = QueueStatus(&fsfbInfo->OutputDataQueue); /*-< 得到队列长度*/
				if (outQueDataLen <= FSFB_MAX_LEN * 16) /*-< 未超出最大长度*/
				{
					QueueScan(outQueDataLen, outQueData, &fsfbInfo->OutputDataQueue); /*-< 扫队列长度数据*/
					while ((outQueIdx + 4) < outQueDataLen) /*-< 遍历队列长度数据*/
					{
						outQueFramLen = ShortFromChar(&outQueData[outQueIdx]); /*-< 得到2字节长度*/
						outQueIdx += 2; /*-< 增数据下标*/
						ShortToChar((UINT16)3, &btmHead[0]); /*-< 设置2字节BTM帧头长度*/
						memcpy(&btmHead[2], &outQueData[outQueIdx], 2); /*-< 设置2字节目的LEU类型ID*/
						btmHead[4] = 0x10; /*-< 设置BTM帧类型*/

						queWriteRtn = QueueWrite(5, btmHead, &fsfbInfo->OutputDataQueue); /*-< 写入队列5字节头*/
						if (1u == queWriteRtn) /*-< 写入队列成功*/
						{
							outQueIdx += outQueFramLen; /*-< 增数据下标*/
						}
						else
						{
							break; /*-< 退出遍历*/
						}
					}
				}
				else /*超出最大长度*/
				{
					QueueClear(&fsfbInfo->OutputDataQueue); /*-< 清队列*/
				}
			}

			retVal = FsfbProtclOutPut(fsfbInfo); /*-< 调输出函数*/

			if (1u == retVal) /*-< 调用函数成功*/
			{
				dataLen = 4 + LongFromChar(&fsfbInfo->AppArray[dataIdx]); /*-< 得到数据长度*/
				dataIdx += 4; /*-< 数据下标自增4*/
				while ((dataIdx + 4) < dataLen) /*-< 遍历数据*/
				{
					/*2字节长度*/
					frameLen = ShortFromChar(&fsfbInfo->AppArray[dataIdx]); /*-< 得到2字节长度*/
					dataIdx += 2; /*-< 数据下标自增2*/
					ShortToChar(frameLen + 3, &pSndData[*sendDataLen]); /*-< 设置长度到输出数据*/
					*sendDataLen += 2; /*-< 输出数据下标自增2*/

					/*1字节协议类型*/
					pSndData[*sendDataLen] = DSU_PROTCL_FSFB; /*-< 设置FSFB类型到输出数据*/
					*sendDataLen += 1; /*-< 输出数据下标自增1*/

					/*2字节目的类型ID*/
					dstTypeId = ShortFromChar(&fsfbInfo->AppArray[dataIdx]); /*-< 得到类型ID*/
					dataIdx += 2; /*-< 数据下标自增2*/
					ShortToChar(dstTypeId, &pSndData[*sendDataLen]); /*-< 设置FSFB类型到输出数据*/
					*sendDataLen += 2; /*-< 输出数据下标自增2*/

					/*2字节目的逻辑ID*/
					ShortToChar(0u, &pSndData[*sendDataLen]); /*-< 设置逻辑ID到输出数据*/
					*sendDataLen += 2; /*-< 输出数据下标自增2*/

					if ((2 <= frameLen) && ((dataIdx + frameLen - 2) <= dataLen)) /*-< 帧长度是否正常*/
					{
						frameLen -= 2; /*-< 帧长度自减2*/
						CommonMemCpy(&pSndData[*sendDataLen], frameLen, &fsfbInfo->AppArray[dataIdx], frameLen); /*-< 复制应用数据到输出数据*/

						dataIdx += frameLen; /*-< 数据下标自增帧长度*/
						*sendDataLen += frameLen; /*-< 输出数据下标自增帧长度*/
					}
					else
					{
						break; /*-< 退出遍历*/
					}
				}

				/*中间变量*/
				*lnkDataLen = 2 + ShortFromChar(fsfbInfo->VarArray); /*-< 得到中间变量长度*/
				CommonMemCpy(pLnkStatusData, *lnkDataLen, fsfbInfo->VarArray, *lnkDataLen); /*-< 复制中间变量长度到输出中间变量数组*/
			}

			if (fsfbInfo->RecordArraySize > 3) /*-< 有记录空间*/
			{
				recordLen = ShortFromChar(fsfbInfo->RecordArray); /*-< 得到日志长度*/
				if ((2 + recordLen + 1) <= fsfbInfo->RecordArraySize) /*-< 可存所有日志,1字节为结束字符*/
				{
					ShortToChar(recordLen + 1, &recordArray[0]); /*-< 设置记录长度到记录数组*/
					CommonMemCpy(&recordArray[2], recordLen, &fsfbInfo->RecordArray[2], recordLen); /*-< 复制记录到记录数组*/
					recordArray[2 + recordLen] = '\0'; /*-< 添加字符串结束符*/

					*recordDataLen = 2 + recordLen + 1; /*-< 设置记录长度*/
				}
				else /*不可存所有日志*/
				{
					ShortToChar(fsfbInfo->RecordArraySize - 2, &recordArray[0]); /*-< 设置总记录长度*/
					CommonMemCpy(&recordArray[2], fsfbInfo->RecordArraySize - 3, &fsfbInfo->RecordArray[2], fsfbInfo->RecordArraySize - 3); /*-< 复制总记录*/
					recordArray[fsfbInfo->RecordArraySize - 1] = '\0'; /*-< 添加字符串结束符*/

					*recordDataLen = fsfbInfo->RecordArraySize; /*-< 设置记录长度*/
				}
			}
		}
		else
		{
			retVal = 1u; /*-< 设置函数返回值为成功*/
		}
	}

#endif

	return retVal; /*-< 返回函数返回值*/
}



/*
* 功能：RP和RSR协议发送输出数据组帧
*
* 参数：
* 输入参数：  UINT8* pInAppArray         输入应用数据
*             UINT32 appDtaLen           输入数据长度
* 输出参数：  UINT32* outAppLen          组包后的应用数据长度
*             UINT8* pOutAppArray        组包后的应用数据
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RsrAndRpAppArrayPage(UINT8* pInAppArray, UINT32 appDtaLen, UINT8* pOutAppArray, UINT32* outAppLen)
{
	UINT8 retnVal = 0;
	UINT32 index = 0;
	UINT32 outIndex = 0;
	UINT16 dataLen = 0;

	if ((pInAppArray != NULL) && (pOutAppArray != NULL) && (outAppLen != NULL))
	{
		while (appDtaLen > 0)
		{
			/*两个子节点的长度长度等于源长度+2(目标设备个数和源设备个数)*/
			dataLen = ShortFromChar(&pInAppArray[index]);
			if (appDtaLen >= (dataLen + 2))
			{
				ShortToChar(dataLen + 2, &pOutAppArray[outIndex]);
				/*1个字节的目标设备个数*/
				index += 2;
				outIndex += 2;
				pOutAppArray[outIndex++] = 1;
				/*蓝网的IP地址和端口号  总共12个字节*/
				CommonMemCpy(&pOutAppArray[outIndex], 12, &pInAppArray[index], 12);

				index += 12;
				outIndex += 12;
				/*1个字节的源设备个数*/
				pOutAppArray[outIndex++] = 1;
				/*红网的IP地址和端口号  总共12个字节*/
				CommonMemCpy(&pOutAppArray[outIndex], 12, &pInAppArray[index], 12);
				index += 12;
				outIndex += 12;
				/*应用数据*/
				CommonMemCpy(&pOutAppArray[outIndex], dataLen - 24, &pInAppArray[index], dataLen - 24);
				appDtaLen = appDtaLen - dataLen - 2;
				outIndex += (dataLen - 24);
				index += (dataLen - 24);
			}
			else
			{
				break;
			}
		}
		*outAppLen = outIndex;

		retnVal = 1;
	}
	else
	{
		retnVal = 0;
	}
	return retnVal;
}

/***********协议接收相关函数**************************************************************/
/*
* 功能：SFP协议接收数据
*
* 参数：
* 输入参数：	struc_Unify_Info *gpsfpUnitInfo	SFP结构体
* 输出参数：	QueueStruct* pOutToApp 输出给应用的数据帧格式
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 SfpRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_SFP
	UINT8 tempDatabuff[2] = { 0 };
	UINT16 tempDataLen = 0;
	UINT8* sfpRcvDataBuff = NULL;
	UINT16 tmpLogid = 0;
	struc_Unify_Info* gpsfpUnitInfo = NULL;

	if ((NULL != pOutToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpSfpRcvDataBuff) && (NULL != pUnifyInfo->GlobalVar->gpsfpUnitInfo))
	{
		sfpRcvDataBuff = pUnifyInfo->GlobalVar->gpSfpRcvDataBuff;
		gpsfpUnitInfo = pUnifyInfo->GlobalVar->gpsfpUnitInfo;

		CommonMemSet(sfpRcvDataBuff, sizeof(UINT8) * pUnifyInfo->GlobalVar->gSfpRcvDataBuffLen, 0u, sizeof(UINT8) * pUnifyInfo->GlobalVar->gSfpRcvDataBuffLen);
		while (QueueStatus(&gpsfpUnitInfo->DataToApp) > 2)
		{
			QueueRead(2, tempDatabuff, &gpsfpUnitInfo->DataToApp);/* 两个字节长度 */

			tempDataLen = ShortFromChar(tempDatabuff);
			QueueRead(tempDataLen, sfpRcvDataBuff, &gpsfpUnitInfo->DataToApp);
			tempDataLen = tempDataLen - 5 + PROTCL_OUT_FONT_LEN;
			/*ShortToChar(tempDataLen,tempDatabuff);*/
			RcvDataToAppQueue(sfpRcvDataBuff[3], sfpRcvDataBuff[2], tmpLogid, sfpRcvDataBuff[4], tempDataLen, sfpRcvDataBuff + 5, pOutToApp);
		}

	}
#endif

	ret = 1;

	return ret;
}




/*
* 功能：RSR协议接收数据
*
* 参数：
* 输入参数：
* 输出参数：  QueueStruct* pOutToApp 输出给应用的数据帧格式
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RsrRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RSR
	UINT8 tempDatabuff[2] = { 0 };
	UINT16 tempDataLen = 0;
	UINT8* rsrRcvDataBuff = NULL;
	UINT16 tmpLogid = 0;
	UINT16 srcAddr = 0;
	UINT16 destAddr = 0;
	UINT16 destDevName = 0;
	UINT8 destDevType = 0;
	UINT8 destDevId = 0;
	RSR_INFO_STRU* gpRsrUnitInfo = NULL;

	if ((NULL != pOutToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsrRcvDataBuff) && (NULL != pUnifyInfo->GlobalVar->gpRsrUnitInfo))
	{
		rsrRcvDataBuff = pUnifyInfo->GlobalVar->gpRsrRcvDataBuff;
		gpRsrUnitInfo = pUnifyInfo->GlobalVar->gpRsrUnitInfo;

		CommonMemSet(rsrRcvDataBuff, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRsrRcvDataBuffLen, 0u, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRsrRcvDataBuffLen);
		while (QueueStatus(&gpRsrUnitInfo->DataToApp) > 2)
		{
			QueueRead(2, tempDatabuff, &gpRsrUnitInfo->DataToApp);/* 两个字节长度 */

			tempDataLen = ShortFromChar(tempDatabuff);
			QueueRead(tempDataLen, rsrRcvDataBuff, &gpRsrUnitInfo->DataToApp);
			tempDataLen = tempDataLen - 4 + PROTCL_OUT_FONT_LEN;
			srcAddr = ShortFromChar(rsrRcvDataBuff);
			destAddr = ShortFromChar(rsrRcvDataBuff + 2);

			if (gpRsrUnitInfo->LocalType == VOBC_TYPE)
			{

				dsuVOBCvsCIInInfo(srcAddr, destAddr, &tmpLogid);
				destDevType = CI_TYPE;
			}
			else if (gpRsrUnitInfo->LocalType == ZC_TYPE)
			{
				dsuZCvsCIInInfo(srcAddr, destAddr, &destDevName);
				DevName2TypeId(destDevName, &destDevType, &destDevId);
				tmpLogid = 0;
			}
			else if (gpRsrUnitInfo->LocalType == CI_TYPE)
			{
				if (dsuVOBCvsCIInInfo(srcAddr, destAddr, &tmpLogid) == 0)
				{
					dsuZCvsCIInInfo(srcAddr, destAddr, &destDevName);
					DevName2TypeId(destDevName, &destDevType, &destDevId);
					tmpLogid = 0;
				}
				else
				{
					/*dsuVOBCvsCIInInfo(srcAddr,destAddr,&tmpLogid);*/
					destDevType = VOBC_TYPE;
				}
			}
			else
			{
				ret = 0;
				return ret;
			}
			RcvDataToAppQueue(destDevType, destDevId, tmpLogid, 0, tempDataLen, rsrRcvDataBuff + 4, pOutToApp);

		}

	}
#endif

	ret = 1;

	return ret;
}

/*将接收到的数据写入到输出队列中 */
UINT8 RcvDataToAppQueue(UINT8 devType, UINT8 devId, UINT16 logId, UINT8 lifeTime, UINT16 appDatalen, UINT8* pAppData, QueueStruct* pDataToApp)
{
	UINT8 ret = 0;
	UINT8 tempDataBuff[2] = { 0 };
	ShortToChar(appDatalen, tempDataBuff);
	QueueWrite(2, tempDataBuff, pDataToApp);
	QueueWrite(1, &devType, pDataToApp);
	QueueWrite(1, &devId, pDataToApp);
	ShortToChar(logId, tempDataBuff);
	QueueWrite(2, tempDataBuff, pDataToApp);
	QueueWrite(1, &lifeTime, pDataToApp);
	QueueWrite(appDatalen - PROTCL_OUT_FONT_LEN, pAppData, pDataToApp);
	ret = 1;
	return ret;
}


/*
* 功能：RSSP协议接收数据
*
* 参数：
* 输入参数：
* 输出参数：  QueueStruct* pOutToApp 输出给应用的数据帧格式
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RsspRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RSSPI
	UINT8 tempDatabuff[2] = { 0 };
	UINT16 tempDataLen = 0;
	UINT8* rsspRcvDataBuff = NULL;
	UINT16 tmpLogid = 0;
	UINT16 logid = 0U;
	RSSP_INFO_STRU* gpRsspUnitInfo = NULL;

	if ((NULL != pOutToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsspRcvDataBuff) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo))
	{
		rsspRcvDataBuff = pUnifyInfo->GlobalVar->gpRsspRcvDataBuff;
		gpRsspUnitInfo = pUnifyInfo->GlobalVar->gpRsspUnitInfo;

		CommonMemSet(rsspRcvDataBuff, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRsspRcvDataBuffLen, 0u, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRsspRcvDataBuffLen);
		while (QueueStatus(&gpRsspUnitInfo->DataToApp) > 2)
		{
			QueueRead(2, tempDatabuff, &gpRsspUnitInfo->DataToApp);
			tempDataLen = ShortFromChar(tempDatabuff);
			QueueRead(tempDataLen, rsspRcvDataBuff, &gpRsspUnitInfo->DataToApp);
			if (4 <= tempDataLen)
			{
				logid = rsspRcvDataBuff[2];
				tmpLogid = (UINT16)(((logid << 8) & 0xFF00) | (rsspRcvDataBuff[3] & 0x00FF));
				tempDataLen = tempDataLen - 4 + PROTCL_OUT_FONT_LEN;
				RcvDataToAppQueue(rsspRcvDataBuff[0], rsspRcvDataBuff[1], tmpLogid, 0, tempDataLen, rsspRcvDataBuff + 4, pOutToApp);
			}
		}

	}
#endif

	ret = 1;

	return ret;
}

/*
* 功能：RSSP2协议接收数据
*
* 参数：
* 输入参数：
* 输出参数：  QueueStruct* pOutToApp 输出给应用的数据帧格式
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 Rssp2RcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;
#ifdef USE_RSSPII
	UINT8 tempDatabuff[2] = { 0 };
	UINT16 tempDataLen = 0;
	UINT8* rssp2RcvDataBuff = NULL;
	UINT16 logId = 0;
	UINT8 devType = 0;
	UINT8 devId = 0;
	RSSP2_INFO_STRU* gpRssp2UnitInfo = NULL;

	if ((NULL != pOutToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRssp2RcvDataBuff) && (NULL != pUnifyInfo->GlobalVar->gpRssp2UnitInfo))
	{
		rssp2RcvDataBuff = pUnifyInfo->GlobalVar->gpRssp2RcvDataBuff;
		gpRssp2UnitInfo = pUnifyInfo->GlobalVar->gpRssp2UnitInfo;

		CommonMemSet(rssp2RcvDataBuff, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRssp2RcvDataBuffLen, 0u, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRssp2RcvDataBuffLen);
		while (QueueStatus(&gpRssp2UnitInfo->DataToApp) > 2)
		{
			QueueRead(2, tempDatabuff, &gpRssp2UnitInfo->DataToApp);
			tempDataLen = ShortFromChar(tempDatabuff);/* 获取长度 */
			tempDataLen -= 4;
			QueueRead(1, &devType, &gpRssp2UnitInfo->DataToApp);
			QueueRead(1, &devId, &gpRssp2UnitInfo->DataToApp);
			QueueRead(2, tempDatabuff, &gpRssp2UnitInfo->DataToApp);
			logId = ShortFromChar(tempDatabuff);
			QueueRead(tempDataLen, rssp2RcvDataBuff, &gpRssp2UnitInfo->DataToApp);/* 获取组包后的数据 */

			tempDataLen = tempDataLen + PROTCL_OUT_FONT_LEN;/* 应用数据的长度,加上5个 */

			RcvDataToAppQueue(devType, devId, logId, 0, tempDataLen, rssp2RcvDataBuff, pOutToApp);
		}

	}
#endif

	ret = 1;

	return ret;
}


/*
* 功能：RP协议接收数据
*
* 参数：
* 输入参数：
* 输出参数：  QueueStruct* pOutToApp 输出给应用的数据帧格式
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 RpRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_RP
	UINT8 tempDatabuff[2] = { 0 };
	UINT16 tempDataLen = 0;
	UINT8* rpRcvDataBuff = NULL;
	UINT8 tempType = 0;
	UINT8 tempId = 0;
	UINT16 tmpLogid = 0;
	RP_INFO_STRU* gpRedunUnitInfo = NULL; /*冗余层协议结构体*/

	if ((NULL != pOutToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRpRcvDataBuff) && (NULL != pUnifyInfo->GlobalVar->gpRedunUnitInfo))
	{
		rpRcvDataBuff = pUnifyInfo->GlobalVar->gpRpRcvDataBuff;
		gpRedunUnitInfo = pUnifyInfo->GlobalVar->gpRedunUnitInfo;

		CommonMemSet(rpRcvDataBuff, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRpRcvDataBuffLen, 0u, sizeof(UINT8) * pUnifyInfo->GlobalVar->gRpRcvDataBuffLen);
		while (QueueStatus(&gpRedunUnitInfo->DataToApp) > 2)
		{
			QueueRead(2, tempDatabuff, &gpRedunUnitInfo->DataToApp);
			QueueRead(1, &tempType, &gpRedunUnitInfo->DataToApp);
			QueueRead(1, &tempId, &gpRedunUnitInfo->DataToApp);

			tempDataLen = ShortFromChar(tempDatabuff);
			QueueRead(tempDataLen - 2, rpRcvDataBuff, &gpRedunUnitInfo->DataToApp);
			tempDataLen = tempDataLen - 2 + PROTCL_OUT_FONT_LEN;
			RcvDataToAppQueue(tempType, tempId, tmpLogid, 0, tempDataLen, rpRcvDataBuff, pOutToApp);
		}

	}
#endif

	ret = 1;

	return ret;
}

/*
* 功能：FSFB协议接收数据
*
* 参数：
* 输入参数：
* 输出参数：  QueueStruct* pOutToApp 输出给应用的数据帧格式
* 返回值：
*    UINT8 1 正常，其他不正常
*/
UINT8 FsfbRcvData(QueueStruct* pOutToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0;

#ifdef USE_FSFB
	UINT8 dataLenBuf[2] = { 0 };
	UINT16 dataLen = 0u;
	UINT8* rcvBuf = NULL;
	FSFB_INFO_STRU* gpFsfbUnitInfo = NULL;

	if ((NULL != pOutToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbRcvDataBuff) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo))
	{
		rcvBuf = pUnifyInfo->GlobalVar->gpFsfbRcvDataBuff;
		gpFsfbUnitInfo = pUnifyInfo->GlobalVar->gpFsfbUnitInfo;

		CommonMemSet(rcvBuf, sizeof(UINT8) * pUnifyInfo->GlobalVar->gFsfbRcvDataBuffLen, 0u, sizeof(UINT8) * pUnifyInfo->GlobalVar->gFsfbRcvDataBuffLen);
		while (QueueStatus(&gpFsfbUnitInfo->DataToApp) > 2)
		{
			QueueRead(2, dataLenBuf, &gpFsfbUnitInfo->DataToApp);
			dataLen = ShortFromChar(dataLenBuf);
			QueueRead(dataLen, rcvBuf, &gpFsfbUnitInfo->DataToApp);

			dataLen = dataLen - 4 + PROTCL_OUT_FONT_LEN;
			RcvDataToAppQueue(rcvBuf[0], rcvBuf[1], 0, 0, dataLen, &rcvBuf[4], pOutToApp);
		}

	}
#endif

	ret = 1;

	return ret;
}


/**
 * @brief readQueueDataToApp 输入时平台给适配协议数据
 * @param rcvQueueData 输入平台数据队列 取值范围:参考结构体QueueStruct
 * @param OutNetFlag 红蓝网标志 取值范围:1:红网;2:篮网
 * @param locDevName 本方类型ID 取值范围:0x0000-0xFFFF
 * @param pDataToApp 用于各协议输入数据 取值范围:参考结构体PROTCL_RCV_DATA_TYPE
 * @param pUnifyInfo 适配层结构体变量 取值范围:参考结构体ProtclConfigInfoStru
 * @return 0:失败;1:成功
 */
UINT8 readQueueDataToApp(QueueStruct* rcvQueueData, UINT8 OutNetFlag, UINT16 locDevName, PROTCL_RCV_DATA_TYPE* pDataToApp, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 0; /*-< 设置函数返回值为0*/
	UINT8 retFun = 0;
	UINT8 i = 0;                               /*  循环使用 */
	UINT16 destDevName = 0;
	UINT8 protclType = 0;
	PROTCL_APP_TO_STRU* tempProtclAppStru = NULL;

#ifdef USE_RSSPII
	QueueRingID pRingQue = NULL;
	CM_BOOL mbRet = CM_FALSE; /*-< 设置解析结果为假*/
	UINT32 len = 0;
#endif

	if ((NULL != rcvQueueData) && (NULL != pDataToApp) && (NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->pRcvProtclAppStru)) /*-< 参数是否非空*/
	{
		tempProtclAppStru = pUnifyInfo->GlobalVar->pRcvProtclAppStru; /*-< 设置收协议应用数据结构变量*/

		for (i = 0; i < PROTCL_MGECFG_MAXCNT + 1; i++) /*-< 协议数下标是否小于协议数量*/
		{
			/*清除长度信息,避免后续拷贝出错;*/
			pDataToApp[i].rcvDataLen = 0; /*-< 设置到收数据长度为0*/
		}

		while (2 < QueueStatus(rcvQueueData)) /*-< 收数据队列长度是否大于2*/
		{
			retFun = 0; /*-< 设置调用函数返回值为0*/
			ret = AppReceiveDataAnalysis(rcvQueueData, tempProtclAppStru); /*-< 调用接收应用层的数据解析函数,返回值赋值给函数返回值*/
			if (ret == 1) /*-< 函数返回值是否为1*/
			{
				TypeIdToDevName(tempProtclAppStru->devType, tempProtclAppStru->devId, &destDevName); /*-< 调用类型ID转设备名函数*/
				retFun = DsuProtclGetProtclType(locDevName, destDevName, &protclType, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo); /*-< 调用根据本方类型ID与对方类型ID查找所使用的协议类型函数,返回值赋值给调用函数返回值*/
			}
			else
			{
				break; /*-< 退出遍历*/
			}

			if (1 == retFun) /*-< 调用函数是否成功*/
			{
				if (DSU_PROTCL_RSSP2 == protclType) /*-< 协议类型是否RSSPII*/
				{
#ifdef USE_RSSPII
					pRingQue = NULL;
					Prtcl_Manage_GetRQ(tempProtclAppStru->devType * 256 * 256 * 256 + tempProtclAppStru->devId * 256 * 256 + OutNetFlag * 256 + tempProtclAppStru->devLogId, &pRingQue); /*-< 调用获取环形队列索引函数*/
					QUEUE_RING_Write(pRingQue, tempProtclAppStru->pAppData, tempProtclAppStru->appDataLen); /*-< 调用将数据写入列队的尾部函数*/
					mbRet = CM_TRUE; /*-< 设置解析结果为真*/
					while (CM_TRUE == mbRet) /*-< 解析结果是否为真*/
					{
						mbRet = Prtcl_Base_Check(pRingQue, &pUnifyInfo->GlobalVar->Rssp2PrtclHead, tempProtclAppStru->pAppData, pUnifyInfo->GlobalVar->gRssp2RcvDataBuffLen, &len); /*-< 调用从环形缓冲区获得一包完整信息函数,结果赋值给解析结果*/
						if (CM_TRUE == mbRet) /*-< 解析结果是否为真*/
						{
							tempProtclAppStru->appDataLen = (UINT16)len; /*-< 设置应用数据长度*/
							/*将新一帧数据往缓冲区尾部填写*/
							ShortToChar(tempProtclAppStru->appDataLen + 4, pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen); /*-< 写应用数据长度到对应协议缓存数据中*/
							/*修改缓冲区总长度*/
							pDataToApp[protclType].rcvDataLen += 2; /*-< 对应协议收数据长度自加2*/

							/* 增加发送方的设备类型 */
							*(pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen) = tempProtclAppStru->devType; /*-< 设置设备类型到应用数据长度到对应协议缓存数据中*/
							pDataToApp[protclType].rcvDataLen++; /*-< 对应协议收数据长度自加1*/

							/* 增加发送方的设备ID */
							*(pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen) = tempProtclAppStru->devId; /*-< 设置设备ID到应用数据长度到对应协议缓存数据中*/
							pDataToApp[protclType].rcvDataLen++; /*-< 对应协议收数据长度自加1*/

							/* 增加逻辑ID */
							ShortToChar(tempProtclAppStru->devLogId, pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen); /*-< 设置设备逻辑ID到应用数据长度到对应协议缓存数据中*/
							pDataToApp[protclType].rcvDataLen += 2; /*-< 对应协议收数据长度自加2*/

							/*拷贝接收数据至缓冲区尾部*/
							CommonMemCpy(pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen, tempProtclAppStru->appDataLen, tempProtclAppStru->pAppData, tempProtclAppStru->appDataLen); /*-< 复制应用数据到应用数据长度到对应协议缓存数据中*/
							/*更新缓冲区总长度*/
							pDataToApp[protclType].rcvDataLen += tempProtclAppStru->appDataLen; /*-< 对应协议收数据长度自加应用数据长度*/
						}
					}
#endif
				}
				else
				{
					if ((DSU_PROTCL_RSSP == protclType) || (DSU_PROTCL_FSFB == protclType)) /*-< 协议类型是否RSSPI或FSFB2*/
					{
						/*2字节总长度*/
						ShortToChar(tempProtclAppStru->appDataLen + 4, &pDataToApp[protclType].pData[pDataToApp[protclType].rcvDataLen]); /*-< 写应用数据长度到对应协议缓存数据中*/
						pDataToApp[protclType].rcvDataLen += 2; /*-< 对应协议收数据长度自加2*/

						/*1字节类型*/
						pDataToApp[protclType].pData[pDataToApp[protclType].rcvDataLen] = tempProtclAppStru->devType; /*-< 设置设备类型到应用数据长度到对应协议缓存数据中*/
						pDataToApp[protclType].rcvDataLen++; /*-< 对应协议收数据长度自加1*/

						/*1字节ID*/
						pDataToApp[protclType].pData[pDataToApp[protclType].rcvDataLen] = tempProtclAppStru->devId; /*-< 设置设备ID到应用数据长度到对应协议缓存数据中*/
						pDataToApp[protclType].rcvDataLen++; /*-< 对应协议收数据长度自加1*/

						/*2字节逻辑ID*/
						ShortToChar(tempProtclAppStru->devLogId, &pDataToApp[protclType].pData[pDataToApp[protclType].rcvDataLen]); /*-< 设置设备逻辑ID到应用数据长度到对应协议缓存数据中*/
						pDataToApp[protclType].rcvDataLen += 2; /*-< 对应协议收数据长度自加2*/
					}
					else /*其他协议*/
					{
						/*协议类型不再填写,使用全局规定的各协议类型*/
						/*pDataToApp[protclType].proType = protclType;*/
						/*将新一帧数据往缓冲区尾部填写*/
						ShortToChar(tempProtclAppStru->appDataLen, pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen); /*-< 写应用数据长度到对应协议缓存数据中*/
						/*修改缓冲区总长度*/
						pDataToApp[protclType].rcvDataLen += 2; /*-< 对应协议收数据长度自加2*/
					}
					/*拷贝接收数据至缓冲区尾部*/
					CommonMemCpy(pDataToApp[protclType].pData + pDataToApp[protclType].rcvDataLen, tempProtclAppStru->appDataLen, tempProtclAppStru->pAppData, tempProtclAppStru->appDataLen); /*-< 复制应用数据到应用数据长度到对应协议缓存数据中*/
					/*更新缓冲区总长度*/
					pDataToApp[protclType].rcvDataLen += tempProtclAppStru->appDataLen; /*-< 对应协议收数据长度自加应用数据长度*/
				}
			}
			else
			{
				break; /*-< 退出遍历*/
			}
		}

		ret = 1; /*-< 设置函数返回值为0*/
	}

	return ret; /*-< 返回函数返回值*/
}


/*
* 功能：接收应用层的数据解析
*
* 参数：
* 输入参数：  const QueueStruct *pAppQueueData    应用输入到协议的数据队列
* 输出参数：  PROTCL_APP_TO_STRU *protclAppStru   解析后的数据
* 返回值：
*    UINT8 1 收到完整数据帧，0 无数据
*/
UINT8 AppReceiveDataAnalysis(QueueStruct* pAppQueueData, PROTCL_APP_TO_STRU* pProtclAppStru)
{
	UINT8 retVal = 0;
	UINT8 tempBuff[2] = { 0 };
	UINT16 tempDatalen = 0;

	UINT8 protclType = GetCbtcSysType();

	QueueScan(2, tempBuff, pAppQueueData);	/* 肯定存在两个字节 */
	tempDatalen = ShortFromChar(tempBuff);

	if ((tempDatalen + 2) <= QueueStatus(pAppQueueData))
	{

		QueueRead(2, tempBuff, pAppQueueData);/* 长度 */
		QueueRead(1, &pProtclAppStru->devType, pAppQueueData);/* 类型 */
		QueueRead(1, &pProtclAppStru->devId, pAppQueueData);/* ID */

		if ((DQU_CBTC_CPK == protclType) || (DQU_CBTC_FAO == protclType))	/*合库或FAO*/
		{
			pProtclAppStru->appDataLen = tempDatalen - 2;
			QueueRead((tempDatalen - 2), pProtclAppStru->pAppData, pAppQueueData);/* 应用数据 */
			retVal = 1;
		}
		else /*其他*/
		{
			if (4 <= tempDatalen)
			{
				pProtclAppStru->appDataLen = tempDatalen - 4;
				QueueRead(2, tempBuff, pAppQueueData);
				pProtclAppStru->devLogId = ShortFromChar(tempBuff);
				QueueRead((tempDatalen - 4), pProtclAppStru->pAppData, pAppQueueData);/* 应用数据 */

				retVal = 1;
			}
			else
			{
				retVal = 0;
			}
		}
	}
	else
	{
		retVal = 0;
	}

	return retVal;
}


/*
*	将Buff的格式的数据压入队列
*/
UINT8 SetDataToQue(UINT32 dataLen, UINT8* buff, QueueStruct* q)
{
	UINT8 ret = 0;
	QueueClear(q);
	ret = QueueWrite(dataLen, buff, q);
	return ret;
}



/************************************链路状态查询******************************************/
/*
* 功能：SFP协议查询链路状态
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
*			  struc_Unify_Info *pSfpUnitInfo SFP统一结构体
* 返回值：
*     0：不存在该条链路，返回错误
*     0x17：链路在数据传输正常状态
*     0x2b：链路在通信中断状态
*     0x33：链路在准备建立链接状态
*     0x4e：链路在等待建立链接状态
*/
UINT8 GetSfpLnkStatus(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_SFP
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpsfpUnitInfo))
	{
		retVal = ProtclCheckLnkStatus(destType, destId, pUnifyInfo->GlobalVar->gpsfpUnitInfo);
	}

#endif

	return retVal;
}

/*
* 功能：RSR协议查询链路状态
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     0：不存在该条链路，返回错误
*     0x17：链路在数据传输正常状态
*     0x2b：链路在通信中断状态
*/
UINT8 GetRsrLnkStatus(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSR
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsrUnitInfo))
	{

		UINT16 locDevName = 0;
		UINT16 DestDevName = 0;
		UINT16 rsspSrcAdd = 0;
		INT16   bsdAdd = 0;
		UINT16	destRsspAdd = 0;
		RSR_INFO_STRU* gpRsrUnitInfo = pUnifyInfo->GlobalVar->gpRsrUnitInfo;

		TypeIdToDevName(gpRsrUnitInfo->LocalType, gpRsrUnitInfo->LocalID, &locDevName);
		TypeIdToDevName(destType, destId, &DestDevName);

		if (destType == VOBC_TYPE)
		{
			retVal = dsuVOBCvsCIOutInfo(logId, 0, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
		}
		else if (gpRsrUnitInfo->LocalType == VOBC_TYPE)
		{
			retVal = dsuVOBCvsCIOutInfo(logId, 1, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
		}
		else
		{
			retVal = dsuZCvsCIOutInfo(locDevName, DestDevName, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
		}
		if (1 == retVal)
		{
			retVal = RsrLnkStatus(rsspSrcAdd, bsdAdd, destRsspAdd, gpRsrUnitInfo);
		}
	}
#endif

	return retVal;
}

/*
* 功能：RSSP协议查询链路状态
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     0：不存在该条链路，返回错误
*     0x17：链路在数据传输正常状态
*     0x2b：链路在通信中断状态
*/
UINT8 GetRsspLnkStatus(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPI
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo))
	{
		retVal = Rssp2LnkStatus(destType, destId, logId, pUnifyInfo->GlobalVar->gpRsspUnitInfo);
	}

#endif

	return retVal;
}

/*
* 功能：RSSP2协议查询链路状态
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     0：不存在该条链路，返回错误
*     0x17：链路在数据传输正常状态
*     0x2b：链路在通信中断状态
*/
UINT8 GetRssp2LnkStatus(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPII
	retVal = RsspIILnkStatus(destType, destId, logId, pUnifyInfo->GlobalVar->gpRssp2UnitInfo);
#endif

	return retVal;
}

/*
* 功能：FSFB协议查询链路状态
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     0：不存在该条链路，返回错误
*     0x17：链路在数据传输正常状态
*     0x2b：链路在通信中断状态
*/
UINT8 GetFsfbLnkStatus(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_FSFB

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo))
	{
		retVal = FsfbProtclGetLnkStatus(destType, destId, pUnifyInfo->GlobalVar->gpFsfbUnitInfo);
	}

#endif

	return retVal;
}

/*******************************************删除链路子函数开始 **********************************************/

/*
* 功能：SFP协议删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
*			  struc_Unify_Info *pSfpUnitInfo  SFP统一结构体
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 SfpDelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_SFP
	retVal = ProtclDeleteLnk(destType, destId, pUnifyInfo->GlobalVar->gpsfpUnitInfo);
#endif

	return retVal;
}

/*
* 功能：Rp协议删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 RpDelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RP
	UINT16 destDevName = 0;
	TypeIdToDevName(destType, destId, &destDevName);
	retVal = RpLnkDelete(destDevName, pUnifyInfo->GlobalVar->gpRedunUnitInfo);
#endif

	return retVal;
}

/*
* 功能：RSR协议删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 RsrDelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSR
	UINT16 locDevName = 0;
	UINT16 DestDevName = 0;
	UINT16 rsspSrcAdd = 0;
	INT16   bsdAdd = 0;
	UINT16	destRsspAdd = 0;
	RSR_INFO_STRU* gpRsrUnitInfo = pUnifyInfo->GlobalVar->gpRsrUnitInfo;

	TypeIdToDevName(gpRsrUnitInfo->LocalType, gpRsrUnitInfo->LocalID, &locDevName);
	TypeIdToDevName(destType, destId, &DestDevName);

	if (destType == VOBC_TYPE)
	{
		retVal = dsuVOBCvsCIOutInfo(logId, 0, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
	}
	else if (gpRsrUnitInfo->LocalType == VOBC_TYPE)
	{
		retVal = dsuVOBCvsCIOutInfo(logId, 1, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
	}
	else
	{
		retVal = dsuZCvsCIOutInfo(locDevName, DestDevName, &rsspSrcAdd, &bsdAdd, &destRsspAdd);
	}
	if (1 == retVal)
	{
		retVal = RsrLnkDelete(rsspSrcAdd, bsdAdd, destRsspAdd, gpRsrUnitInfo);
	}
#endif

	return retVal;
}

/*
* 功能：RSSP协议删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 RsspDelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPI
	retVal = Rssp2LnkDelete(destType, destId, logId, pUnifyInfo->GlobalVar->gpRsspUnitInfo);
#endif

	return retVal;
}

/*
* 功能：RSSP2协议删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 Rssp2DelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPII
	retVal = RsspIILnkDelete(destType, destId, logId, pUnifyInfo->GlobalVar->gpRssp2UnitInfo);
#endif

	return retVal;
}

/*
* 功能：FSFB协议删除链路
*
* 参数：
* 输入参数：  UINT8 DestType    对方设备类型
* 			  UINT8 DestID      对方设备ID
*             UINT16 logId      若卡斯柯的CI与VOBC通信，需要填写VOBC的站台号。其他的系统填0。
* 返回值：
*     1：删除链路成功
*     0：删除链路失败
*/
UINT8 FsfbDelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_FSFB

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo))
	{
		retVal = FsfbProtclDeleteLnk(destType, destId, pUnifyInfo->GlobalVar->gpFsfbUnitInfo);
	}

#endif

	return retVal;
}

/********************************************刷新链路相关函数*********************************************/
/*
* 功能：SFP刷新链路状态
*
* 参数：
* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
*				 struc_Unify_Info *pSfpUnitInfo SFP统一结构体
* 返回值：
*     0：刷新链路失败
*     1：刷新链路成功
*/
UINT8 SfpReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_SFP
	if (NULL != pUnifyInfo->GlobalVar->gpsfpUnitInfo)
	{
		retVal = ProtclFreshLnkMngr(slen_input, pLnkStatusData, pUnifyInfo->GlobalVar->gpsfpUnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}

/*
* 功能：RP刷新链路状态
*
* 参数：
* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
* 返回值：
*     0：刷新链路失败
*     1：刷新链路成功
*/
UINT8 RpReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RP
	if (NULL != pUnifyInfo->GlobalVar->gpRedunUnitInfo)
	{
		retVal = RpRefresh(slen_input, pLnkStatusData, pUnifyInfo->GlobalVar->gpRedunUnitInfo);
	}
	else
	{
		retVal = 1;

	}
#endif

	return retVal;
}

/*
* 功能：RSR刷新链路状态
*
* 参数：
* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
* 返回值：
*     0：刷新链路失败
*     1：刷新链路成功
*/
UINT8 RsrReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSR
	if (NULL != pUnifyInfo->GlobalVar->gpRsrUnitInfo)
	{
		retVal = RsrRefresh(slen_input, pLnkStatusData, pUnifyInfo->GlobalVar->gpRsrUnitInfo);
	}
	else
	{
		retVal = 1;

	}
#endif

	return retVal;
}

/*
* 功能：RSSP刷新链路状态
*
* 参数：
* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
* 返回值：
*     0：刷新链路失败
*     1：刷新链路成功
*/
UINT8 RsspReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPI
	if (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo)
	{
		retVal = Rssp2Refresh(slen_input, pLnkStatusData, pUnifyInfo->GlobalVar->gpRsspUnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}

/*
* 功能：RSSP2刷新链路状态
*
* 参数：
* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
* 返回值：
*     0：刷新链路失败
*     1：刷新链路成功
*/
UINT8 Rssp2ReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPII
	if (NULL != pUnifyInfo->GlobalVar->gpRssp2UnitInfo)
	{
		retVal = RsspIIRefresh(slen_input, pLnkStatusData, pUnifyInfo->GlobalVar->gpRssp2UnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}


/*
* 功能：FSFB刷新链路状态
*
* 参数：
* 输入参数： 	 UINT8* pLnkStatusData     协议状态数据
* 返回值：
*     0：刷新链路失败
*     1：刷新链路成功
*/
UINT8 FsfbReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_FSFB

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo))
	{
		retVal = FsfbProtclRefreshLnk(pLnkStatusData, pUnifyInfo->GlobalVar->gpFsfbUnitInfo);
	}

#endif

	return retVal;
}

/********************************************销毁空间相关函数*********************************************/
/*
* SFP协议销毁协议模块
* 参数：struc_Unify_Info *pSfpUnitInfo SFP统一结构体
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 SfpFreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_SFP
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpsfpUnitInfo))
	{
		retVal = ProtclFreeSpace(pUnifyInfo->GlobalVar->gpsfpUnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}

/*
* RP协议销毁协议模块
* 参数：
*    无
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 RpFreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RP
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRedunUnitInfo))
	{
		retVal = RpFreeSpace(pUnifyInfo->GlobalVar->gpRedunUnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}

/*
* RSR协议销毁协议模块
* 参数：
*    无
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 RsrFreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSR
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsrUnitInfo))
	{
		retVal = RsrFreeSpace(pUnifyInfo->GlobalVar->gpRsrUnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}


/*
* RSSP协议销毁协议模块
* 参数：
*    无
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 RsspFreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPI

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo))
	{
		retVal = Rssp2FreeSpace(pUnifyInfo->GlobalVar->gpRsspUnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}
/*
* RSSP2协议销毁协议模块
* 参数：
*    无
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 Rssp2FreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_RSSPII

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRssp2UnitInfo))
	{
		retVal = RsspIIFreeSpace(pUnifyInfo->GlobalVar->gpRssp2UnitInfo);
	}
	else
	{
		retVal = 1;
	}
#endif

	return retVal;
}

/*
* FSFB协议销毁协议模块
* 参数：
*    无
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 FsfbFreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 0;

#ifdef USE_FSFB

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo))
	{
		retVal = FsfbProtclFreeSpace(pUnifyInfo->GlobalVar->gpFsfbUnitInfo);
	}

#endif

	return retVal;
}


/*
* 销毁全局变量的空间
* 参数：
*    ProtclConfigInfoStru* pUnifyInfo 适配层结构体
* 返回值：
*    1 ：销毁成功
*    0 ：销毁失败
*/
UINT8 FreeSpaceFunc(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 retVal = 1;
	UINT8 i = 0;/* 循环使用 */

	if ((NULL!= pUnifyInfo)&&(NULL != pUnifyInfo->GlobalVar)&&(NULL != pUnifyInfo->GlobalVar->RcvData))
	{
		for (i = 1; i < (PROTCL_MGECFG_MAXCNT + 1); i++)
		{
			if ((NULL != pUnifyInfo->GlobalVar->RcvData[i].pData))
			{
				free((void*)pUnifyInfo->GlobalVar->RcvData[i].pData);
				pUnifyInfo->GlobalVar->RcvData[i].pData = NULL;
			}
		}
		free((void*)pUnifyInfo->GlobalVar->RcvData);
		pUnifyInfo->GlobalVar->RcvData = NULL;


		for (i = 0; i < (PROTCL_MGECFG_MAXCNT + 1); i++)
		{
			if (NULL != pUnifyInfo->GlobalVar->protclSndCfgStru[i].pProtclAppStru)
			{
				free((void*)pUnifyInfo->GlobalVar->protclSndCfgStru[i].pProtclAppStru);
				pUnifyInfo->GlobalVar->protclSndCfgStru[i].pProtclAppStru = NULL;
			}
		}
		free(pUnifyInfo->GlobalVar->RcvData);
		pUnifyInfo->GlobalVar->RcvData = NULL;
		free(pUnifyInfo->GlobalVar);
	}


	return retVal;
}



/***********Getting**&**Setting****封装******************************************************/

/***********异常防护函数**************************************************************/
/** 零函数
* 主要用于函数指针清零。
* 防止异常情况使用空的函数指针而导致的不良后果。
**************************************************/
UINT8  protcl_nul_Init(UINT8* nul_FileName, UINT32 inDataLen, UINT8 inData[], UINT16 nul_Num, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8  retval = 1;

	return retval;
}

UINT8  protcl_nul_Snd(ProtclConfigInfoStru* pUnifyInfo, UINT32 devDataCount, UINT8* pSndData, UINT32* sendDataLen, UINT8* pLnkStatusData, UINT16* lnkDataLen, UINT8* recordArray, UINT16* recordDataLen)
{
	UINT8  retval = 1;

	return retval;
}

UINT8  protcl_nul_Rcv(QueueStruct* PQueueStru, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8  retval = 1;

	return retval;
}


UINT8  protcl_nul_Lnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8  retval = 1;

	return retval;
}

void protcl_nul_NetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum)
{
	if ((NULL != pUnifyInfo) && (NULL != redRecvPkgNum) && (NULL != blueRecvPkgNum))
	{
		(*redRecvPkgNum) = 0u;
		(*blueRecvPkgNum) = 0u;
	}
}

UINT8  protcl_nul_DelLnk(UINT8 destType, UINT8 destId, UINT16 logId, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8  retval = 1;

	return retval;
}


UINT8  protcl_nul_ReFreshLnk(UINT16 slen_input, UINT8* pLnkStatusData, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8  retval = 1;

	return retval;
}


UINT8  protcl_nul_End(ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8  retval = 1;

	return retval;
}

/*******************************************************************************************************
* 功能描述: 	   返回所有协议及协议适配层丢包或非宕机错误码信息
* 输入参数: 		应用获取错误编码的数组vProtclErrorInfo
* 输入输出参数: 	vProtclErrorInfo
* 输出参数: 		返回vProtclErrorInfo错误信息码
* 全局变量: 	  无
* 返回值:			无
*******************************************************************************************************/

UINT8 GetProtclErrorInfo(UINT32 vProtclErrorInfo[])
{
	UINT8 index = 0, retval = 0;

#ifdef USE_RP
	vProtclErrorInfo[index++] = GetRpErrorInfo();
#endif
#ifdef USE_RSR
	vProtclErrorInfo[index++] = GetRsrErrorInfo();
#endif

	retval = 1;
	return retval;
}


/*******************************************************************************************************
* 功能描述: 	   所有协议及协议适配层丢包和非宕机错误码复位
* 输入参数: 		应用获取错误编码的数组vProtclErrorInfo
* 输入输出参数: 	vProtclErrorInfo
* 输出参数: 		vProtclErrorInfo
* 全局变量: 	  无
* 返回值:			无
*******************************************************************************************************/

UINT8 ReSetProtclErrorInfo(UINT32 vProtclErrorInfo[])
{
	UINT8 ret = 1;
#ifdef USE_RP
	ReSetRpErrorInfo();
#endif
#ifdef USE_RSR
	ReSetRsrErrorInfo();
#endif
	CommonMemSet(vProtclErrorInfo, sizeof(UINT32) * PRTCL_ERR_INFO_LEN, 0, sizeof(UINT32) * PRTCL_ERR_INFO_LEN);
	return ret;
}
/*******************************************************************************************************
* 功能描述: 	   设置RSSP协议无发送应用数据周期数接口函数
* 输入参数: 		无
* 输入输出参数: 	无
* 输出参数: 		gRsspErrorInfo
* 全局变量: 	  gRsspErrorInfo
* 返回值:			1:成功
*******************************************************************************************************/

UINT8 SetRsspConfigData(UINT8 vNoSendDataNum, ProtclConfigInfoStru* pUnifyInfo)
{
	UINT8 ret = 1;

#ifdef USE_RSSPI
	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo))
	{
		SetRsspNoSendAppData(vNoSendDataNum, pUnifyInfo->GlobalVar->gpRsspUnitInfo);
	}

#endif

	return ret;
}

/*
*函数名:	TypeIdToDevName
*功能描述:	类型ID转成设备名称
*输入参数:	UINT8 type	类型
*			UINT8 id	ID
*输入出参:	无
*输出参数:	UINT16 *pDevName	设备名称
*返回值:	无
*/
static void TypeIdToDevName(UINT8 type, UINT8 id, UINT16* pDevName)
{
	UINT16 devName = 0U;
	devName = type;
	*pDevName = ((UINT16)(devName << 8) & 0xFF00) | (id & 0x00FF);
}

/*
*功能描述:	获取各网收到包数
*输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
*			const UINT8 dstType	目的设备类型
*			const UINT8 dstId 目的设备ID
*			const UINT16 dstLogicId 目的逻辑ID
*输入出参:	UINT16* redRecvPkgNum 红网收到包数
*			UINT16* blueRecvPkgNum 篮网收到包数
*输出参数:	无
*返回值:	无
*/
void GetNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum)
{
	UINT16 locTypeId = 0u; /*本方类型ID*/
	UINT16 oppTypeId = 0u; /*对方类型ID*/
	UINT8 protclType = 0u; /*协议类型*/
	UINT8 isGetProtclType = 0u; /*是否获取到协议类型*/
	F_NETPKGNUM fNetsPkgNum = NULL; /*各网收包数量函数*/

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != redRecvPkgNum) && (NULL != blueRecvPkgNum)) /*参数检查*/
	{
		(*redRecvPkgNum) = 0u;
		(*blueRecvPkgNum) = 0u;
		TypeIdToDevName(pUnifyInfo->LocalType, pUnifyInfo->LocalID, &locTypeId);
		TypeIdToDevName(dstType, dstId, &oppTypeId);
		isGetProtclType = DsuProtclGetProtclType(locTypeId, oppTypeId, &protclType, &pUnifyInfo->GlobalVar->DsuProtclBookIpInfo);

		if ((1u == isGetProtclType) && (PROTCL_MGECFG_MAXCNT >= protclType) && (0u != protclType)) /*获取到协议类型*/
		{
			fNetsPkgNum = protclCfgStruBuff[protclType].fNetsRecvPkgNum;
			if (NULL != fNetsPkgNum)
			{
				fNetsPkgNum(pUnifyInfo, dstType, dstId, dstLogicId, redRecvPkgNum, blueRecvPkgNum);
			}
		}
	}
}

/*
*功能描述:	获取SFP各网收到包数
*输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
*			const UINT8 dstType	目的设备类型
*			const UINT8 dstId 目的设备ID
*			const UINT16 dstLogicId 目的逻辑ID
*输入出参:	UINT16* redRecvPkgNum 红网收到包数
*			UINT16* blueRecvPkgNum 篮网收到包数
*输出参数:	无
*返回值:	无
*/
static void GetSfpNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum)
{
#ifdef USE_SFP
	if ((NULL != pUnifyInfo) && (NULL != redRecvPkgNum) && (NULL != blueRecvPkgNum) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpsfpUnitInfo)) /*参数检查*/
	{		
		ProtclGetNetsRecvPkgNum(pUnifyInfo->GlobalVar->gpsfpUnitInfo, dstType, dstId, redRecvPkgNum, blueRecvPkgNum);
	}
#endif
}

/*
*功能描述:	获取RSSPI各网收到包数
*输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
*			const UINT8 dstType	目的设备类型
*			const UINT8 dstId 目的设备ID
*			const UINT16 dstLogicId 目的逻辑ID
*输入出参:	UINT16* redRecvPkgNum 红网收到包数
*			UINT16* blueRecvPkgNum 篮网收到包数
*输出参数:	无
*返回值:	无
*/
static void GetRsspiNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum)
{
#ifdef USE_RSSPI
	if ((NULL != pUnifyInfo) && (NULL != redRecvPkgNum) && (NULL != blueRecvPkgNum) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRsspUnitInfo)) /*参数检查*/
	{
		RsspiGetNetsRecvPkgNum(pUnifyInfo->GlobalVar->gpRsspUnitInfo, dstType, dstId, dstLogicId, redRecvPkgNum, blueRecvPkgNum);
	}
#endif
}

/*
*功能描述:	获取RSSPII各网收到包数
*输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
*			const UINT8 dstType	目的设备类型
*			const UINT8 dstId 目的设备ID
*			const UINT16 dstLogicId 目的逻辑ID
*输入出参:	UINT16* redRecvPkgNum 红网收到包数
*			UINT16* blueRecvPkgNum 篮网收到包数
*输出参数:	无
*返回值:	无
*/
static void GetRsspiiNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum)
{
#ifdef USE_RSSPII
	if ((NULL != pUnifyInfo) && (NULL != redRecvPkgNum) && (NULL != blueRecvPkgNum) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpRssp2UnitInfo)) /*参数检查*/
	{
		RsspiiGetNetsRecvPkgNum(pUnifyInfo->GlobalVar->gpRssp2UnitInfo, dstType, dstId, dstLogicId, redRecvPkgNum, blueRecvPkgNum);
	}
#endif
}

/*
*功能描述:	获取FSFB各网收到包数
*输入参数:	ProtclConfigInfoStru* pUnifyInfo 适配层变量
*			const UINT8 dstType	目的设备类型
*			const UINT8 dstId 目的设备ID
*			const UINT16 dstLogicId 目的逻辑ID
*输入出参:	UINT16* redRecvPkgNum 红网收到包数
*			UINT16* blueRecvPkgNum 篮网收到包数
*输出参数:	无
*返回值:	无
*/
static void GetFsfbNetsRecvPkgNum(ProtclConfigInfoStru* pUnifyInfo, const UINT8 dstType, const UINT8 dstId, const  UINT16 dstLogicId, UINT16* redRecvPkgNum, UINT16* blueRecvPkgNum)
{
#ifdef USE_FSFB
	if ((NULL != pUnifyInfo) && (NULL != redRecvPkgNum) && (NULL != blueRecvPkgNum) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->gpFsfbUnitInfo)) /*参数检查*/
	{
		FsfbProtclGetNetsRecvPkgNum(pUnifyInfo->GlobalVar->gpFsfbUnitInfo, dstType, dstId, redRecvPkgNum, blueRecvPkgNum);
	}
#endif
}

/*
*功能描述:	初始化单帧应用到协议的数据结构体变量--只能初始化时使用
*输入参数:	const UINT16 outputSize 输出应用数长度
*			const UINT16 inputSize 输入应用数长度
*输入出参:	无
*输出参数:	无
*返回值:	PROTCL_APP_TO_STRU* protclAppToStru 应用到协议的数据结构体
*/
static PROTCL_APP_TO_STRU* NewProtclAppToStru(const UINT16 outputSize, const UINT16 inputSize)
{
	PROTCL_APP_TO_STRU* protclAppToStru = NULL; /*返回值*/

	protclAppToStru = (PROTCL_APP_TO_STRU*)malloc(sizeof(PROTCL_APP_TO_STRU));
	if (NULL != protclAppToStru)
	{
		CommonMemSet(protclAppToStru, sizeof(PROTCL_APP_TO_STRU), 0u, sizeof(PROTCL_APP_TO_STRU));

		protclAppToStru->pAppData = NewAppData(&protclAppToStru->appDataMaxLen, outputSize, inputSize);
		if (NULL == protclAppToStru->pAppData)
		{
			protclAppToStru = NULL;
		}
	}

	return protclAppToStru;
}


/*
*功能描述:	生成单帧应用到协议的数据数组--只能初始化时使用
*输入参数:	const UINT16 outputSize 输出应用数长度
*			constUINT16 inputSize 输入应用数长度
*输入出参:	UINT16* appDataMaxLen 应用到协议的数据最大长度
*输出参数:	无
*返回值:	UINT8* appData 应用到协议的数据数组
*/
static UINT8* NewAppData(UINT16* appDataMaxLen, const UINT16 outputSize, const UINT16 inputSize)
{
	UINT8* appData = NULL; /*返回值*/
	UINT32 mallocLen = 0u; /*分配空间长度*/

	if (NULL != appDataMaxLen)
	{
		*appDataMaxLen = (outputSize > inputSize) ? outputSize : inputSize;
		*appDataMaxLen += 44u; /*做输入时再加各协议里最长包头*/
		mallocLen = sizeof(UINT8) * (*appDataMaxLen);
		appData = (UINT8*)malloc(mallocLen);
		if (NULL != appData)
		{
			CommonMemSet(appData, mallocLen, 0u, mallocLen);
		}
		else
		{
			appData = NULL;
		}
	}

	return appData;
}

/**
 * @brief StPtclMgtSetOutnetQue 设置外网队列
 * @param pUnifyInfo 适配层信息 取值范围:参考结构体ProtclConfigInfoStru
 * @param locDevName 本方设备类型 取值范围:0x0000-0xFFFF
 * @param queType 队列类型 取值范围:0:红网;1:篮网
 * @return 0:失败 1:成功
 */
static UINT8 StPtclMgtSetOutnetQue(ProtclConfigInfoStru* pUnifyInfo, UINT16 locDevName, UINT8 queType)
{
	/*- 定义局部变量*/
	UINT8 rtnVal = 0u; /*-< 设置函数返回值为0*/
	UINT8 funRtn = 0u;
	UINT8 i = 0u;  /* 循环使用 */
	QueueStruct* pQue = NULL;
	PROTCL_RCV_DATA_TYPE* pRcvData = NULL;

#ifdef USE_SFP		
	struc_Unify_Info* gpsfpUnitInfo = NULL;	/*SFP协议结构体*/
#endif
#ifdef USE_RP
	RP_INFO_STRU* gpRedunUnitInfo = NULL;	/*冗余层协议结构体*/
#endif
#ifdef USE_RSR
	RSR_INFO_STRU* gpRsrUnitInfo = NULL;	/*RSR协议结构体*/
#endif
#ifdef USE_RSSPI
	RSSP_INFO_STRU* gpRsspUnitInfo = NULL;	/*RSSP协议结构体*/
#endif
#ifdef USE_RSSPII
	RSSP2_INFO_STRU* gpRssp2UnitInfo = NULL; /*RSSP2协议结构体*/
#endif
#ifdef USE_FSFB
	FSFB_INFO_STRU* gpFsfbUnitInfo = NULL; /*FSFB协议结构体*/
#endif

	if ((NULL != pUnifyInfo) && (NULL != pUnifyInfo->GlobalVar) && (NULL != pUnifyInfo->GlobalVar->RcvData) && ((1u == queType) || (2u == queType))) /*-< 参数是否合法*/
	{
		/*- 得到各协议变量*/
#ifdef USE_SFP		
		gpsfpUnitInfo = pUnifyInfo->GlobalVar->gpsfpUnitInfo;	/*SFP协议结构体*/
#endif
#ifdef USE_RP
		gpRedunUnitInfo = pUnifyInfo->GlobalVar->gpRedunUnitInfo;	/*冗余层协议结构体*/
#endif
#ifdef USE_RSR
		gpRsrUnitInfo = pUnifyInfo->GlobalVar->gpRsrUnitInfo;	/*RSR协议结构体*/
#endif
#ifdef USE_RSSPI
		gpRsspUnitInfo = pUnifyInfo->GlobalVar->gpRsspUnitInfo;	/*RSSP协议结构体*/
#endif
#ifdef USE_RSSPII
		gpRssp2UnitInfo = pUnifyInfo->GlobalVar->gpRssp2UnitInfo; /*RSSP2协议结构体*/
#endif
#ifdef USE_FSFB
		gpFsfbUnitInfo = pUnifyInfo->GlobalVar->gpFsfbUnitInfo; /*FSFB协议结构体*/
#endif

		pRcvData = pUnifyInfo->GlobalVar->RcvData; /*-< 临时存放协议数据的结构体*/
		if (1u == queType) /*-< 队列类型是否红网*/
		{
			pQue = &pUnifyInfo->OutnetQueueA; /*-< 得到红网队列*/
		}
		else
		{
			pQue = &pUnifyInfo->OutnetQueueB; /*-< 得到蓝网队列*/
		}
		funRtn = readQueueDataToApp(pQue, queType, locDevName, pRcvData, pUnifyInfo); /*-< 调用输入时平台给适配协议数据函数*/
	}

	if (1u == funRtn) /*-< 调用函数是否成功*/
	{
		for (i = 1u; i < PROTCL_MGECFG_MAXCNT + 1u; i++) /*-< 协议数下标是否小于协议数*/
		{
			if (0u < pRcvData[i].rcvDataLen) /*-< 收数据长度是否大于0*/
			{
				pQue = NULL; /*-< 设置队列为空*/

				switch (pRcvData[i].proType) /*-< 判断协议类型*/
				{
				case DSU_PROTCL_SFP: /*-< 协议类型是否SFP*/
#ifdef USE_SFP
					if (1u == queType) /*-< 队列类型是否红网*/
					{
						pQue = &gpsfpUnitInfo->OutnetQueueA; /*-< 设置队列为红网队列*/
					}
					else
					{
						pQue = &gpsfpUnitInfo->OutnetQueueB; /*-< 设置队列为蓝网队列*/
					}
#endif
					break; /*-< 退出*/
				case DSU_PROTCL_RP: /*-< 协议类型是否RP*/
#ifdef USE_RP
					if (1u == queType) /*-< 队列类型是否红网*/
					{
						pQue = &gpRedunUnitInfo->OutnetQueueA; /*-< 设置队列为红网队列*/
					}
					else
					{
						pQue = &gpRedunUnitInfo->OutnetQueueB; /*-< 设置队列为蓝网队列*/
					}
#endif
					break; /*-< 退出*/
				case DSU_PROTCL_RSR: /*-< 协议类型是否RSR*/
#ifdef USE_RSR
					if (1u == queType) /*-< 队列类型是否红网*/
					{
						pQue = &gpRsrUnitInfo->OutnetQueueA; /*-< 设置队列为红网队列*/
					}
					else
					{
						pQue = &gpRsrUnitInfo->OutnetQueueB; /*-< 设置队列为蓝网队列*/
					}
#endif
					break; /*-< 退出*/
				case DSU_PROTCL_RSSP: /*-< 协议类型是否RSSPI*/
#ifdef USE_RSSPI
					if (1u == queType) /*-< 队列类型是否红网*/
					{
						pQue = &gpRsspUnitInfo->OutnetQueueA; /*-< 设置队列为红网队列*/
					}
					else
					{
						pQue = &gpRsspUnitInfo->OutnetQueueB; /*-< 设置队列为蓝网队列*/
					}
#endif
					break; /*-< 退出*/
				case DSU_PROTCL_RSSP2: /*-< 协议类型是否RSSPII*/
#ifdef USE_RSSPII
					if (1u == queType) /*-< 队列类型是否红网*/
					{
						pQue = &gpRssp2UnitInfo->OutnetQueueA; /*-< 设置队列为红网队列*/
					}
					else
					{
						pQue = &gpRssp2UnitInfo->OutnetQueueB; /*-< 设置队列为蓝网队列*/
					}
#endif
					break; /*-< 退出*/
				case DSU_PROTCL_FSFB: /*-< 协议类型是否FSFB*/
#ifdef USE_FSFB
					if (1u == queType) /*-< 队列类型是否红网*/
					{
						pQue = &gpFsfbUnitInfo->OutnetQueueR; /*-< 设置队列为红网队列*/
					}
					else
					{
						pQue = &gpFsfbUnitInfo->OutnetQueueB; /*-< 设置队列为蓝网队列*/
					}
#endif
					break; /*-< 退出*/
				default: /*-< 其他*/
					break; /*-< 退出*/
				}

				if (NULL != pQue) /*-< 队列是否非空*/
				{
					SetDataToQue(pRcvData[i].rcvDataLen, pRcvData[i].pData, pQue); /*-< 设置数据到队列*/
				}
			}
		}

		rtnVal = 1u; /*-< 设置函数返回值为1*/
	}

	return rtnVal; /*-< 返回函数返回值*/
}

/**
 * @brief StPtclMgtSetRecSize 设置各协议日志大小
 * @param pUnifyInfo 统一结构体变量 取值范围:参考结构体ProtclConfigInfoStru
 * @param pProtclNumBuff 各协议数量 取值范围:UINT16数组
 * @param curDevRecordLen 本设备使用日志长度 取值范围:0x00000000-0xFFFFFFFF
 */
static void StPtclMgtSetRecSize(ProtclConfigInfoStru* pUnifyInfo, UINT16 pProtclNumBuff[7], UINT32 curDevRecordLen[PROTCL_MGECFG_MAXCNT])
{
	/*- 定义局部变量*/
	/* 本设备使用日志长度比率*/
	UINT32 curDevRecordLenRatio[PROTCL_MGECFG_MAXCNT] = { 0u };
	/* 本设备使用日志总长度*/
	UINT32 curDevRecordTotalLen = 0u;
	/* 设备一个链路长度*/
	UINT32 devRecFitLen[PROTCL_MGECFG_MAXCNT] = { 0u };
	/* 临时变量*/
	UINT32 tmpVal = 0u;
	UINT8 tmpI = 0u;
	UINT32 allDevRecordLen = 0u; /*总协议日志大小*/
	UINT8 borrowIdxNum = 0u; /*借设备下标数*/
	UINT8 borrowIdx[PROTCL_MGECFG_MAXCNT] = { 0u }; /*借设备下标*/
	UINT32 borrowLen[PROTCL_MGECFG_MAXCNT] = { 0u }; /*借各设备长度*/
	UINT32 curBorrowNeedLen = 0u; /*当前需借长度*/
	UINT8 i = 0u; /*用于循环*/
	UINT8 isBreak = 0u; /*-< 设置是否退出遍历标识为否*/
	UINT8 deepPro = 0u; /*-< 设置处理标志为不处理*/

	if ((NULL != pUnifyInfo) && (NULL != pProtclNumBuff) && (NULL != curDevRecordLen) && (2u < pUnifyInfo->RecordArraySize)) /*-< 长度大于2,才做日志空间分配处理*/
	{
		/*- 按比率分配日志空间*/
		devRecFitLen[0] = SFP_PER_LNK_RECORD_MAX_LEN;
		devRecFitLen[1] = RP_PER_LNK_RECORD_MAX_LEN;
		devRecFitLen[2] = RSR_PER_LNK_RECORD_MAX_LEN;
		devRecFitLen[3] = RSSPI_PER_LNK_RECORD_MAX_LEN;
		devRecFitLen[4] = RSSPII_PER_LNK_RECORD_MAX_LEN;
		devRecFitLen[5] = FSFB_PER_LNK_RECORD_MAX_LEN;
		for (tmpI = 0u; tmpI < PROTCL_MGECFG_MAXCNT; tmpI++) /*-< 协议数下标是否小于总数*/
		{
			if (pProtclNumBuff[tmpI + 1] > 0u) /*-< 是否有此协议*/
			{
				curDevRecordLenRatio[tmpI] = devRecFitLen[tmpI] * pProtclNumBuff[tmpI + 1u]; /*-< 此协议日志大小*/
				curDevRecordTotalLen += curDevRecordLenRatio[tmpI]; /*-< 总日志大小累加此协议日志大小*/
			}
		}
		for (tmpI = 0u; tmpI < PROTCL_MGECFG_MAXCNT; tmpI++) /*-< 协议数下标是否小于总数*/
		{
			if (pProtclNumBuff[tmpI + 1] > 0u) /*-< 是否有此协议*/
			{
				curDevRecordLen[tmpI] = (pUnifyInfo->RecordArraySize - 2u) * curDevRecordLenRatio[tmpI] / curDevRecordTotalLen; /*-< 此协议日志大小*/
				allDevRecordLen += curDevRecordLen[tmpI]; /*-< 总协议日志大小*/
				tmpVal += devRecFitLen[tmpI]; /*-< 最小日志长度累加此协议日志最小长度*/
			}
		}
		/*调整日志空间.总分配日志长度小于最小日志长度:按比率分配; 否则:在按比率分配基础上,调整使任一可用协议日志长度不小于一个链路长度*/
		if (allDevRecordLen >= tmpVal) /*-< 总协议日志大小是否大于等于最小日志长度*/
		{
			deepPro = 1u; /*-< 设置处理标志为处理*/
		}
	}

	if (1u == deepPro) /*-< 处理标志是否为处理*/
	{
		for (tmpI = 0u; tmpI < PROTCL_MGECFG_MAXCNT; tmpI++) /*-< 协议数下标是否小于总数*/
		{
			/*只处理可用协议日志长度*/
			if ((pProtclNumBuff[tmpI + 1] > 0u) && (curDevRecordLen[tmpI] < devRecFitLen[tmpI])) /*-< 是否有此协议 且长度小于一个链路长度*/
			{
				curBorrowNeedLen = devRecFitLen[tmpI] - curDevRecordLen[tmpI]; /*-< 得到需借长度*/
				borrowIdxNum = 0u; /*-< 清零借设备下标数*/
				isBreak = 0u; /*-< 设置是否退出遍历标识为否*/
				for (i = 0u; i < PROTCL_MGECFG_MAXCNT; i++) /*-< 协议数下标是否小于总数*/
				{
					if ((i != tmpI) && (curDevRecordLen[i] > devRecFitLen[i])) /*-< 非当前协议 且可借日志*/
					{
						if ((curDevRecordLen[i] - devRecFitLen[i]) >= curBorrowNeedLen) /*-< 可借长度大于等于需借长度*/
						{
							borrowLen[borrowIdxNum] = curBorrowNeedLen; /*-< 设置需借长度给借此设备长度*/

							isBreak = 1u; /*-< 设置是否退出遍历标识为是*/
						}
						else
						{
							borrowLen[borrowIdxNum] = curDevRecordLen[i] - devRecFitLen[i]; /*-< 设置可借长度给借此设备长度*/
						}
						curBorrowNeedLen -= borrowLen[borrowIdxNum]; /*-< 更新需借长度*/

						borrowIdx[borrowIdxNum] = i; /*-< 设置借设备下标给借此设备下标*/
						borrowIdxNum++; /*-< 设置借设备下标数自增1*/
					}
					if (1u == isBreak) /*-< 设置是否退出遍历标识为是*/
					{
						break; /*-< 退出遍历*/
					}
				}
				if (1u == isBreak) /*-< 借够日志*/
				{
					for (i = 0u; i < borrowIdxNum; i++) /*-< 借设备下标数下标小于总数*/
					{
						curDevRecordLen[borrowIdx[i]] -= borrowLen[i]; /*-< 借设备日志长度*/
					}
					curDevRecordLen[tmpI] = devRecFitLen[tmpI]; /*-< 调整本设备为一个链路长度*/
				}
			}
		}
	}
}

/**
 * @brief StPtclMgtSetRecvDataBuff 设置收数据缓存
 * @param pUnifyInfo 统一结构体变量 取值范围:参考结构体ProtclConfigInfoStru
 * @param maxLinkNum 最大链路数 取值范围:0x0000-0xFFFF
 * @param protclSndCfgStru 配置变量 取值范围:参考结构体PROTCL_SND_CFG_STRU
 * @param ptemProtclRcvDataStru 收数据类型 取值范围:参考结构体PROTCL_RCV_DATA_TYPE
 * @param ptclType 协议类型 取值范围:0x00-0xFF
 * @param pRcvDataBuff 收数据 取值范围:字节数组
 * @param pRcvDataBuffLen 收数据长度 取值范围:0x0000-0xFFFF
 * @return 0:不退出 1:退出
 */
static UINT8 StPtclMgtSetRecvDataBuff(ProtclConfigInfoStru* pUnifyInfo, UINT16 maxLinkNum, PROTCL_SND_CFG_STRU* protclSndCfgStru, PROTCL_RCV_DATA_TYPE* ptemProtclRcvDataStru, UINT8 ptclType, UINT8** pRcvDataBuff, UINT16* pRcvDataBuffLen)
{
	/*- 定义局部变量*/
	UINT8 rtnVal = 1u; /*-< 设置函数返回值为退出*/
	UINT32 i = 0u; /*用于循环*/
	UINT32 tmpVal = 0u;

	tmpVal = maxLinkNum * pUnifyInfo->MaxNumPerCycle; /*-< 得到输入收最大周期数*/
	protclSndCfgStru[ptclType].pProtclAppStru = (PROTCL_APP_TO_STRU*)malloc(sizeof(PROTCL_APP_TO_STRU) * tmpVal); /*-< 分配输入收数据空间*/
	if ((NULL == protclSndCfgStru[ptclType].pProtclAppStru) || (NULL == ptemProtclRcvDataStru[ptclType].pData)) /*-< 分配失败*/
	{
		rtnVal = 1u; /*-< 设置函数返回值为退出*/
	}
	else
	{
		/*为声明的发送数据临时存储区初始化*/
		CommonMemSet(protclSndCfgStru[ptclType].pProtclAppStru, sizeof(PROTCL_APP_TO_STRU) * tmpVal, 0u, sizeof(PROTCL_APP_TO_STRU) * tmpVal); /*-< 清零输入收数据空间*/

		/*初始化单帧应用数据*/
		for (i = 0u; i < tmpVal; i++) /*-< 输入收周期数是否小于最大周期数*/
		{
			protclSndCfgStru[ptclType].pProtclAppStru[i].pAppData = NewAppData(&protclSndCfgStru[ptclType].pProtclAppStru[i].appDataMaxLen, pUnifyInfo->OutputSize, pUnifyInfo->InputSize); /*-< 分配单个输入收数据空间*/
			if (NULL == protclSndCfgStru[ptclType].pProtclAppStru[i].pAppData) /*-< 分配失败*/
			{
				break; /*-< 退出遍历*/
			}
		}
		if (i == tmpVal) /*-< 都分配成功*/
		{
			(*pRcvDataBuff) = NewAppData(pRcvDataBuffLen, pUnifyInfo->OutputSize, pUnifyInfo->InputSize); /*-< 分配收应用数据空间*/
			if (NULL == (*pRcvDataBuff)) /*-< 分配失败*/
			{
				rtnVal = 1u; /*-< 设置函数返回值为退出*/
			}
			else
			{
				rtnVal = 0u; /*-< 设置函数返回值为不退出*/
			}
		}
		else
		{
			rtnVal = 1u; /*-< 设置函数返回值为退出*/
		}

	}

	return rtnVal; /*-< 返回函数返回值*/
}