/********************************************************
*                                                                                                            
* 文 件 名： 2oo2InterfaceDataManage.c   
* 版权说明： 北京交控科技有限公司 
* 创建时间： 2012-03-26
* 作    者： 联锁组
* 功能描述： 安全计算机接口数据管理
* 修改记录：   
*
********************************************************/ 

#include "../2oo2/2oo2InterfaceDataManage.h"
#include "MSCP_APP_API.h"
#include "stdarg.h"
#include "protclStruct.h"
#include "ParsePackCommon.h"
#include "dquCIInterFace.h"
#define PACK_LOG_ALARM_LENGTH ((UINT16)94)   /*每周期分包提醒的日志打印长度*/

/*2OO2*/ 
#ifdef PLATFORM_2OO2
extern FSFB_INFO_STRU  Fsfb_Info;                                         /*FSFB通信协议结构体*/
extern ProtclConfigInfoStru gCbtcData;                                    /*通用协议结构体*/
extern QueueStruct canQueueRecv;                                          /*IO到CI数据队列 */
extern QueueStruct canQueueSend;                                          /*CI到IO数据队列 */
extern UINT32 CycleNum;                                                   /*平台周期号*/
extern UINT8 Computer_Id_Local_File;			                          /*平台本机联锁ID*/
extern UINT8 processor_mode;					                          /*平台处理模式*/
extern UINT8 FSIOLinkStatusInfo;                                          /*联锁机与FSIO之间连接状态*/
extern UINT8 LEULinkStatusInfo;                                           /*联锁与LEU通信状态*/
extern UINT8 ZCLinkStatusInfo;                                            /*联锁与ZC通信状态*/
extern UINT8  gSheBeiType;                                                /*对外的设备类型*/
extern UINT8  gSheBeiID;                                                  /*对外的设备ID*/
extern UINT8 LocalCiId;                                                   /*系统配置文件中定义的联锁ID*/
extern QueueStruct logPrintfQue;                                          /*日志存储数据队列*/
UINT8  gSheBeiType; 
#endif

PlatComStatusStruct PlatComStatusStru[TRANSMIT_OBJECT_SUM_MAX] = {NULL}; /*定义平台通信关系数据结构体*/

QueueStruct* FsfbToCiDataQueue = NULL;		                             /*Fsfb到CI数据队列*/
QueueStruct* CiToFsfbDataQueue = NULL;		                             /*CI到Fsfb数据队列*/

QueueStruct* ProtocolToCiDataQueue = NULL;                               /*协议到应用的数据队列*/
QueueStruct* CiToProtocolDataQueue = NULL;                               /*CI到协议数据队列*/

QueueStruct* AtsToCiDataQueue = NULL;		                             /*ATS到CI数据队列*/
QueueStruct* CiToAtsDataQueue = NULL;		                             /*CI到ATS数据队列*/
QueueStruct* XianDiToCiDataQueue = NULL;		                         /*现地到CI数据队列*/
QueueStruct* CiToXianDiDataQueue = NULL;		                         /*CI到现地数据队列*/
QueueStruct* IoToCiDataQueue = NULL;		                             /*IO到CI数据队列*/
QueueStruct* CiToIoDataQueue = NULL;		                             /*CI到IO数据队列*/
QueueStruct* ZcToCiDataQueue = NULL;		                             /*ZC到CI数据队列*/
QueueStruct* CiToZcDataQueue = NULL;		                             /*CI到Zc数据队列*/
QueueStruct* LEUToCiDataQueue = NULL;		                             /*LEU到CI数据队列*/
QueueStruct* CiToLEUDataQueue = NULL;		                             /*CI到LEU数据队列*/
QueueStruct* VobcToCiDataQueue = NULL;		                             /*Vobc到CI数据队列*/
QueueStruct* CiToVobcDataQueue = NULL;		                             /*CI到Vobc数据队列*/
QueueStruct* PlatformToCiDataQueue = NULL;		                         /*Platform到CI数据队列*/
QueueStruct* CiToPlatformDataQueue = NULL;		                         /*CI到platform数据队列*/
QueueStruct* PscToCiDataQueue = NULL;		                             /*Psc到CI数据队列*/
QueueStruct* CiToPscDataQueue = NULL;		                             /*CI到Psc数据队列*/
QueueStruct* CiRecvFromCiDataQueue = NULL;	                             /*CI接受其他CI数据队列*/
QueueStruct* CiSendToCiDataQueue = NULL;	                             /*CI发送到其他CI数据队列*/

QueueStruct* AxisToCiDataQueue = NULL;		                             /*Axis到CI数据队列*/
QueueStruct* CiToAxisDataQueue = NULL;		                             /*CI到Axis数据队列*/
QueueStruct* OcToCiDataQueue = NULL;									 /*Oc到Ci的数据队列*/
QueueStruct* CiToOcDataQueue = NULL;									 /*Ci到Oc的数据队列*/

UINT32* CurCycleNum = NULL;					                             /*当前周期号*/
UINT32 StartCycleNum = 0u;                                                /*上电周期号*/
UINT8* PlatComputerId = NULL;                                            /*平台本机联锁ID*/
UINT8* PlatRunMode = NULL;	                                             /*平台处理模式*/
UINT8* CiAndIoComState = NULL;                                           /*联锁与IO通信状态*/
UINT8* CiAndLeuComState = NULL;                                          /*联锁与LEU通信状态*/
UINT8* CiAndZcComState = NULL;                                           /*联锁与ZC通信状态*/
UINT8* CiAndCiComDeviceNum = NULL;                                       /*相邻联锁数量*/
UINT8* CiAndCiComIdBuf = NULL;                                           /*联锁与联锁通信设备ID*/
UINT8* CiAndCiComState = NULL;                                           /*联锁与联锁通信状态*/
UINT8* PlatSheBeiType = NULL;                                            /*平台对外设备类型*/
extern TransmitRelationDataStruct TransmitRelaDataStru[TRANSMIT_OBJECT_SUM_MAX];
extern UINT16 TransmitRelaDataCurSum;

#if (kPLATFORM == kVXWORKS)
ProtclConfigInfoStru gCbtcData;
QueueStruct canQueueRecv;            /*IO到CI数据队列 */
QueueStruct canQueueSend;            /*CI到IO数据队列 */
UINT32 CycleNum;                     /*平台周期号*/
UINT8 Computer_Id_Local_File;			/*平台本机联锁ID*/
FSFB_INFO_STRU  Fsfb_Info;           /*FSFB通信协议结构体*/
UINT8 processor_mode;					/*平台处理模式*/
UINT8 FSIOLinkStatusInfo;            /*联锁机与FSIO之间连接状态*/
QueueStruct logPrintfQue;            /*日志数据队列 */
#endif

/*
* 功能描述： 平台初始化
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台ATS到CI接口队列
*/
UINT8 Initial2oo2Interface(void)
{
	UINT8 rtn = 0u;
	UINT16 locTypeId = 0;
	UINT8 result = 0u;
	
    /*定义平台数据队列指针*/
	
#ifdef PLATFORM_2OO2
    
	
	ProtocolToCiDataQueue = &gCbtcData.DataToApp;       /*初始化协议到CI数据队列*/
	CiToProtocolDataQueue = &gCbtcData.OutputDataQueue; /*初始化CI到协议数据队列*/
	
    FsfbToCiDataQueue = &Fsfb_Info.DataToApp;           /*初始化Fsfb到CI数据队列*/
    CiToFsfbDataQueue = &Fsfb_Info.OutputDataQueue;     /*初始化CI到Fsfb数据队列*/
	
	CurCycleNum = &CycleNum;                            /*初始化平台周期*/
	StartCycleNum = MSCP_GetSysCount(); /*上电周期号*/

    PlatComputerId = &Computer_Id_Local_File;
    PlatRunMode = &processor_mode;
	
	IoToCiDataQueue = &canQueueRecv;                   /*初始化IO到CI数据队列*/
	CiToIoDataQueue = &canQueueSend;                   /*初始化CI到IO数据队列*/
	
	AtsToCiDataQueue = NULL;					       /*初始化ATS到CI数据队列*/
    CiToAtsDataQueue = CiToProtocolDataQueue;          /*初始化CI到ATS数据队列*/
	
    XianDiToCiDataQueue = NULL;					       /*初始化ATS到CI数据队列*/
	CiToXianDiDataQueue = CiToProtocolDataQueue;       /*初始化CI到ATS数据队列*/

	
	ZcToCiDataQueue = NULL;							   /*初始化ZC到CI数据队列*/
    CiToZcDataQueue = CiToProtocolDataQueue;           /*初始化CI到ZC数据队列*/
	
	AxisToCiDataQueue = NULL;							 /*初始化Axis到CI数据队列*/
	CiToAxisDataQueue = CiToProtocolDataQueue;           /*初始化CI到Axis数据队列*/

	CiRecvFromCiDataQueue = NULL;					   /*初始化CI接受其他CI数据队列*/
	CiSendToCiDataQueue = CiToProtocolDataQueue;       /*初始化CI发送到其他CI数据队列*/
	
    VobcToCiDataQueue = NULL;						   /*初始化Vobc到CI数据队列*/
	CiToVobcDataQueue = CiToProtocolDataQueue;         /*初始化CI到Vobc数据队列*/

	PlatformToCiDataQueue = NULL;                           /*初始化Psd到CI数据队列*/
	CiToPlatformDataQueue = CiToProtocolDataQueue;          /*初始化CI到Psd数据队列*/

	PscToCiDataQueue = NULL;							/*初始化PSC到CI数据队列*/
	CiToPscDataQueue = CiToProtocolDataQueue;			/*初始化CI到PSC数据队列*/
	
    LEUToCiDataQueue = NULL;						   /*初始化Leu到CI数据队列*/
	CiToLEUDataQueue = CiToFsfbDataQueue;			   /*初始化CI到Leu数据队列*/
	
    CiAndIoComState = &FSIOLinkStatusInfo;             /*联锁与IO通信状态*/
	locTypeId = MSCP_GetOutnetID();
    /*LocalCiId = gSheBeiID;*/                             /*联锁设备ID*/
    PlatSheBeiType = &gSheBeiType;                     /*联锁设备类型*/
	LocalCiId = (UINT8)(locTypeId & 0xFFu);                             /*联锁设备ID*/
	gSheBeiType = (UINT8)((locTypeId >> 8u) & 0xFFu);
	
	OcToCiDataQueue = NULL;								/*初始化Oc到Ci的数据队列*/
	CiToOcDataQueue = CiToProtocolDataQueue;			/*初始化Ci到Oc的数据队列*/

	if (1U != QueueInitial(&logPrintfQue, 500000U))       /*初始化日志缓存队列*/
	{
		debug_infor_printf((const)"canQueueRecv init error \n");
	}

#if 0
    /*联锁与LEU、ZC、CI等的通信状态描述*/
    if (TransmitRelaDataCurSum < TRANSMIT_OBJECT_SUM_MAX)
    {
        for (ii = 0u; ii < TRANSMIT_OBJECT_SUM_MAX; ii++)
        {
            PlatComStatusStru[ii].SystemType = &(ComDevStatusInfo[ii].DeviceTypeOther);
            PlatComStatusStru[ii].SystemNum = &(ComDevStatusInfo[ii].ComDevSum);
            for (jj = 0u; jj < TRANSMIT_OBJECT_DEVICE_SUM_MAX; jj++)
            {
                PlatComStatusStru[ii].SystemIdBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdBuf[jj]);
                PlatComStatusStru[ii].CommunicationStatusBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdComStatusBuf[jj]);
            }
        }
        
    }
    else
    {
        
    }
#endif

#endif
	result = HLHTCiIdMapInitial();
	if (CI_SUCCESS == result)
	{
		rtn = 1;
	}

	return rtn;

}

/*
* 功能描述： 获取Axis到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: Axis到CI接口队列
*/
QueueStruct* Get2oo2AxisToCiDataQueue(void)
{
	return AxisToCiDataQueue;
}

/*
* 功能描述： 获取平台通用协议到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台通用协议到CI接口队列
*/
QueueStruct* Get2oo2ProtocolToCiDataQueue(void)
{

    return ProtocolToCiDataQueue;
}

/*
* 功能描述： 获取平台CI到通用协议接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI到通用协议接口队列
*/
QueueStruct* Get2oo2CiToProtocolDataQueue(void)
{

    return CiToProtocolDataQueue;
}

/*
* 功能描述： 获取平台Fsfb到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI到Fsfb接口队列
*/
QueueStruct* Get2oo2FsfbToCiDataQueue(void)
{

    return FsfbToCiDataQueue;
}

/*
* 功能描述： 获取平台CI到FsfbP接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI到Fsfb接口队列
*/
QueueStruct* Get2oo2CiToFsfbDataQueue(void)
{

    return CiToFsfbDataQueue;
}



/*
* 功能描述： 获取平台ATS到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台ATS到CI接口队列
*/
QueueStruct* Get2oo2AtsToCiDataQueue(void)
{

    return AtsToCiDataQueue;
}


/*
* 功能描述： 获取平台CI到现地接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI到现地接口队列
*/
QueueStruct* Get2oo2CiToXianDiDataQueue(void)
{
    return CiToXianDiDataQueue;
}

/*
* 功能描述： 获取平台现地到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台现地到CI接口队列
*/
QueueStruct* Get2oo2XianDiToCiDataQueue(void)
{

    return XianDiToCiDataQueue;
}


/*
* 功能描述： 获取平台CI到ATS接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI到ATS接口队列
*/
QueueStruct* Get2oo2CiToAtsDataQueue(void)
{
    return CiToAtsDataQueue;
}


/*
* 功能描述： 获取ZC到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: ZC到CI接口队列
*/
QueueStruct* Get2oo2ZcToCiDataQueue(void)
{
	return ZcToCiDataQueue;
}


/*
* 功能描述： 获取CI到ZC接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到ZC接口队列
*/
QueueStruct* Get2oo2CiToZcDataQueue(void)
{
	return CiToZcDataQueue;
}



/*
* 功能描述： 获取平台CI从其他CI接收接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI接收CI接口队列
*/
QueueStruct* Get2oo2CiRecvCiDataQueue(void)
{
	return CiRecvFromCiDataQueue;
}


/*
* 功能描述： 获取CI发送到其他CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI发送CI接口队列
*/
QueueStruct* Get2oo2CiSendCiDataQueue(void)
{
	return CiSendToCiDataQueue;
}

/*
* 功能描述： 获取平台IO到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台IO到CI接口队列
*/
QueueStruct* Get2oo2IoToCiDataQueue(void)
{
	return IoToCiDataQueue;
}


/*
* 功能描述： 获取平台CI到IO接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: 平台CI到IO接口队列
*/
QueueStruct* Get2oo2CiToIoDataQueue(void)
{
    return CiToIoDataQueue;
}

/*
* 功能描述： 获取Leu到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: Leu到CI接口队列
*/
QueueStruct* Get2oo2LEUToCiDataQueue(void)
{
	return LEUToCiDataQueue;
}

/*
* 功能描述： 获取CI到Leu接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Leu接口队列
*/
QueueStruct* Get2oo2CiToLEUDataQueue(void)
{
	return CiToLEUDataQueue;
}

/*
* 功能描述： 获取CI到Vobc接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Vobc接口队列
*/
QueueStruct* Get2oo2VobcToCiDataQueue(void)
{
    return VobcToCiDataQueue;
}

/*
* 功能描述： 获取CI到Vobc接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Vobc接口队列
*/
QueueStruct* Get2oo2CiToVobcDataQueue(void)
{
    return CiToVobcDataQueue;
}


/*
* 功能描述： 获取CI到Axis接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Axis接口队列
*/
QueueStruct* Get2oo2CiToAxisDataQueue(void)
{
	return CiToAxisDataQueue;
}

/*
* 功能描述： 获取CI到Oc接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Oc接口队列
*/
QueueStruct* Get2oo2CiToOcDataQueue(void)
{
	return CiToOcDataQueue;
}


/*
* 功能描述： 获取PSD到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: PSD到CI接口队列
*/
QueueStruct* Get2oo2PlatformToCiDataQueue(void)
{
    return PlatformToCiDataQueue;
}

/*
* 功能描述： 获取CI到Psd接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Psd接口队列
*/
QueueStruct* Get2oo2CiToPlatformDataQueue(void)
{
    return CiToPlatformDataQueue;
}

/*
* 功能描述： 获取Psc到CI接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: Psc到CI接口队列
*/
QueueStruct* Get2oo2PscToCiDataQueue(void)
{
	return PscToCiDataQueue;
}

/*
* 功能描述： 获取CI到Psc接口队列
* 参数说明： void
* 返回值  ： NULL: 获取数据失败
*           !NULL: CI到Psc接口队列
*/
QueueStruct* Get2oo2CiToPscDataQueue(void)
{
	return CiToPscDataQueue;
}

/*
* 功能描述： 获取平台周期号
* 参数说明： void
* 返回值  ： 0: 获取数据失败
*           >0: 平台周期号
*/
UINT32 Get2oo2CurCycleNum(void)
{
#if (kPLATFORM==kVXWORKS)
	return MSCP_GetSysCount();
#else
	return *CurCycleNum;
#endif
	
}


/*
* 功能描述： 获取平台本机ID
* 参数说明： void
* 返回值  ： 0: 获取数据失败
*           >0: 平台本机ID
*/
UINT8 Get2oo2ComputerId(void)
{
#if (kPLATFORM==kVXWORKS)
	return MSCP_GetBoardID();
#else
	return *PlatComputerId;
#endif

	
}


/*
* 功能描述： 获取平台本机处理模式
* 参数说明： void
* 返回值  ： 0: 获取数据失败
*           >0: 平台本机处理模式
*/
UINT8 Get2oo2ProcessMode(void)
{
#if (kPLATFORM==kVXWORKS)
	UINT8 rtn = 0u;
	UINT8 cutSysState = 0U;
	ENUM_2x2_STATE_T state = ENUM_2x2_SHUTDOWN;
	state = MSCP_GetLastLocal2x2State();
	cutSysState = MSCP_2x2_GetSwitchFlag();
	if (ENUM_2x2_MASTER == state)
	{
		rtn = 0xA0;
	}
	else if ((ENUM_2x2_SLAVE == state)||(1==cutSysState))
	{
		rtn = 0x50;
	}
	else
	{
		rtn = 0U;
	}

	debug_infor_printf((const)"MSCP_GetLastLocal2x2State %x", state);
	return rtn;
#else

	return *PlatRunMode;
#endif
}

/*
* 功能描述： 获取平台其他主机处理模式
* 参数说明： void
* 返回值  ： 0: 获取数据失败
*           >0: 平台本机处理模式
*/
UINT8 Get2oo2OhterProcessMode(void)
{
	UINT8 rtn = 0u;
#if (kPLATFORM==kVXWORKS)
	
	UINT8 cutSysState = 0U;
	ENUM_2x2_STATE_T state = ENUM_2x2_SHUTDOWN;
	state = MSCP_GetLastPartner2x2State();
	cutSysState = MSCP_2x2_GetSwitchFlag();
	if (ENUM_2x2_MASTER == state)
	{
		rtn = 0x0A;
	}
	else if ((ENUM_2x2_SLAVE == state) || (1 == cutSysState))
	{
		rtn = 0x05;
	}
	else
	{
		rtn = 0U;
	}
	debug_infor_printf((const)"MSCP_GetLastPartner2x2State %x", state);
	return rtn;
#else

	return rtn;
#endif
}
/*
* 功能描述： 获取CI与其他设备通信的该设备数量
* 参数说明： const UINT8 systemType, 系统类型
* 返回值  ： 通信设备数目
*/
UINT8 Get2oo2CiAndOtherSysCommNum(const UINT8 systemType)
{
    UINT8 ii = 0u;
    UINT8 returnValue = 0u;

    for (ii = 0u; ii < TRANSMIT_OBJECT_SUM_MAX; ii++)
    {
        if (TransmitRelaDataStru[ii].SystemType == systemType)
        {
            returnValue = TransmitRelaDataStru[ii].DeviceSum;
            
            break;
        }
    }

	return returnValue;
}



/*
* 功能描述： 获取CI与IO通信状态
* 参数说明： void
* 返回值  ： 
*/
UINT8 Get2oo2CiAndIoCommState(void)
{
	return *CiAndIoComState;
}

/*
* 功能描述： 获取起始周期号
* 参数说明： void
* 返回值  ： 
*/
UINT32 Get2oo2StartCycleNum(void)
{
	return StartCycleNum;
}

/*
* 功能描述： 获取平台设备类型
* 参数说明： void
* 返回值  ： 
*/
UINT8 Get2oo2SheBeiType(void)
{
#ifdef PLATFORM_2OO2

    return gSheBeiType;

#endif

	
}


#if (kPLATFORM==kVXWORKS)
/*向维护机传输日志打印-字符串输入*/
void debug_infor_printf(char* debug_string, ...)
{
	UINT32 wdataLength = 0U;
	va_list argList;
	CM_CHAR msgBuf[1024 + 256];
	va_start(argList, debug_string);
	(void)vsnprintf(msgBuf, sizeof(msgBuf), debug_string, argList);
	va_end(argList);

	wdataLength = (UINT32)strlen(msgBuf);
	msgBuf[wdataLength] = '\n';
	/*日志传输到队列中*/
	(void)QueueWrite((wdataLength+ (UINT32)1u), (UINT8*)msgBuf, &logPrintfQue);
}

/*向维护机传输日志打印-字节数组输入*/
void debug_out_array(UINT8 mode, UINT8* debug_array, UINT16 len)
{
	UINT16 i = 0U;
	UINT16 indexChar = 0U;
	CM_CHAR msgBuf[UDPSEND_BUF_MAX * 3U] = { '\0' };
	CM_CHAR byteTochar[6] = { '\0' };
	UINT16 wdataLength = 0U;
	/*一个8进制字节转化为2个字符，输入字节数组不能超过长度最大值*/
	if ((NULL != debug_array) && (UDPSEND_BUF_MAX > len))
	{
		if (0xAA == mode)
		{
#if 0
			for (i = 0U; i < len; i++)
			{
				/*把字节数组(16进制)转化为字符数组，再存入队列*/
				/*单字节不够两位，补'0'*/
				if (i == len - 1)
				{
					indexChar += sprintf(msgBuf + indexChar, "%02x", debug_array[i]);
				}
				else
				{
					indexChar += sprintf(msgBuf + indexChar, "%02x-", debug_array[i]);
				}
			}
			wdataLength = (UINT16)strlen(msgBuf);

#endif 
			/*增加####+2字节长度，解析工具识别####然后解析*/
			byteTochar[0] = '#';
			byteTochar[1] = '#';
			byteTochar[2] = '#';
			byteTochar[3] = '#';
			ShortToChar(len, &byteTochar[4]);
			(void)QueueWrite(6, (UINT8*)byteTochar, &logPrintfQue);
			(void)QueueWrite(len, (UINT8*)debug_array, &logPrintfQue);
		}
		else
		{
			; /*不处理*/
		}

	}
	else
	{
		; /*不处理*/
	}
}

void DarkInfoPack(UINT16 mode, UINT8* debug_array, UINT16 len)
{
	if (NULL != debug_array)
	{
		MSCP_PFM_LOG_DARK(0x55, mode, len, debug_array);
	}
	else
	{
		; /*不处理*/
	}
}
#endif

/*单机版需重新*/
UINT8 OutnetSafeRecv(UINT16* srcTypeId, UINT16* srcLogicId, UINT8* data, UINT32* dataLen, UINT32 dataMaxLen)
{
	UINT8 rtn = 0u; /*返回值*/
	
	UINT8 lifeTime = 0u; /*生存时间*/

	rtn = MSCP_AppRecvMsg(ENUM_MSG_OUTNET_SAFE, srcTypeId, srcLogicId, &lifeTime, data, dataLen, dataMaxLen);

	return rtn;
}

/*内网安全输入*/
UINT8 InnetSafeRecv(UINT16* srcTypeId, UINT16* srcLogicId, UINT8* data, UINT32* dataLen, UINT32 dataMaxLen)
{
	UINT8 rtn = 0u; /*返回值*/

	UINT8 lifeTime = 0u; /*生存时间*/

	rtn = MSCP_AppRecvMsg(ENUM_MSG_INNET_MAINTENANCE, srcTypeId, srcLogicId, &lifeTime, data, dataLen, dataMaxLen);

	return rtn;
}


/*单机版需重新*/
UINT8 OutnetSafeSend(UINT16 dstTypeId, UINT16 dstLogicId, UINT8* data, UINT32 dataLen)
{
	UINT8 rtn = 0u; /*返回值*/

	/*真实联锁*/
	rtn = MSCP_AppSendMsg(ENUM_MSG_OUTNET_SAFE, dstTypeId, dstLogicId, data, dataLen);

	return rtn;
}

/*内网维护网输出*/
UINT8 InnetSafeSend(UINT16 dstTypeId, UINT16 dstLogicId, UINT8* data, UINT32 dataLen)
{
	UINT8 rtn = 0u; /*返回值*/

	/*真实联锁*/
	rtn = MSCP_AppSendMsg(ENUM_MSG_INNET_MAINTENANCE, dstTypeId, dstLogicId, data, dataLen);

	return rtn;
}

UINT32 InnetRawIoRecv(UINT8* data, UINT32 dataMaxLen)
{
	UINT32 dataLen = 0u; /*返回值*/

#if (kPLATFORM==kVXWORKS)
	
	UINT16 srcTypeId = 0u; /*源类型ID*/

	dataLen = MSCP_InnetRaw_AppRecv(1, &srcTypeId, data, dataMaxLen);
#else
	QueueStruct* rawDataQueue = Get2oo2IoToCiDataQueue();

	UINT32 dataQueueTotalLen = 0;											/*队列数据总长度*/
	
	if (rawDataQueue != NULL)
	{
		/*获取队列数据总长度*/
		dataQueueTotalLen = QueueStatus(rawDataQueue);
		
        if (dataQueueTotalLen >= dataMaxLen)
        {/*IO接收数据 >= IO数据最大有效长度时:读取IO数据最大有效长度*/
            
			/*从队列中读出数据*/
			dataQueueTotalLen = dataMaxLen;
			(void)QueueRead(dataQueueTotalLen, data, rawDataQueue);

		}
        else if(0U < dataQueueTotalLen)
        {/*0 < dataQueueTotalLen < maxIoDataLen*/
            
			/*从队列中读出数据*/
			(void)QueueRead((UINT16)dataQueueTotalLen, data, rawDataQueue);
        }
		else
		{/*dataQueueTotalLen == 0*/
		}
#if 0
		/*解析IO到CI数据帧*/
        ParseIoToCiDataFrame(tempDataBuf, (UINT16)dataQueueTotalLen);
#endif
        /*获取队列数据总长度*/
        dataQueueTotalLen = QueueStatus(rawDataQueue);

		if (0U < dataQueueTotalLen)
		{
			(void)QueueClear(rawDataQueue);	/*清队列*/

			dataLen = CI_ERROR;
		}
		else
		{
			dataLen = CI_SUCCESS;
		}
	}
#endif
	return dataLen;
}

UINT8 InnetRawIoSend(UINT8* data, UINT32 dataLen)
{
	UINT8 rtn = 0u; /*返回值*/
#if (kPLATFORM==kVXWORKS)
	rtn = MSCP_InnetRaw_AppSend(1, 0x0901, data, dataLen);
#else
	QueueStruct* rawDataQueueToSend = Get2oo2CiToIoDataQueue();/*发送数据的队列*/
	if (rawDataQueueToSend != NULL)
	{
		(void)QueueClear(rawDataQueueToSend);					/*清队列*/

		if (0U == QueueWrite(dataLen, data, rawDataQueueToSend))
		{ /*写队列失败*/

			(void)QueueClear(rawDataQueueToSend);   /*清队列*/

			debug_infor_printf((const)"Error: write rawDataQueueToSend fail, QueueWrite = 0");

			rtn = CI_ERROR;	                    
		}
		else
		{
			;
		}
	}
	else
	{
		; /*不处理*/
	}
#endif
	return rtn;
}

UINT32 InnetRawLeuRecv(UINT16* srcTypeId, UINT8* data, UINT32 dataMaxLen)
{
	UINT32 dataLen = 0u; /*返回值*/
#if (kPLATFORM==kVXWORKS)
	dataLen = MSCP_InnetRaw_AppRecv(2, srcTypeId, data, dataMaxLen);
#else

#endif
	return dataLen;
}

UINT8 InnetRawLeuSend(UINT16 dstTypeId, UINT8* data, UINT32 dataLen)
{
	UINT8 rtn = 0u; /*返回值*/
#if (kPLATFORM==kVXWORKS)
	rtn = MSCP_InnetRaw_AppSend(2, dstTypeId, data, dataLen);
#else

#endif
	return rtn;
}


/*
* 功能描述： 内网平台心跳帧接收
* 参数说明： OUT UINT8* CC1_data  CC1返回数据
*          OUT UINT8* CC2_data  CC2返回数据
*          OUT UINT8* SEB1_data  SEB1返回数据
*          OUT UINT8* SEB2_data  SEB2返回数据
*           OUT UINT8* CC1_commFFlag  CC1接收数据标志
*           OUT UINT8* CC2_commFFlag  CC2接收数据标志
*           OUT UINT8* SEB1_commFFlag  SEB1接收数据标志
*           OUT UINT8* SEB2_commFFlag  SEB2接收数据标志
* 返回值  ：无
* BY LC
*/
void InnetHeartFrameRecv(OUT UINT8* CC1_data, OUT UINT8* CC2_data, OUT UINT8* SEB1_data, OUT UINT8* SEB2_data, OUT UINT8* CC1_commFFlag, OUT UINT8* CC2_commFFlag, OUT UINT8* SEB1_commFFlag, OUT UINT8* SEB2_commFFlag)
{
	UINT32  remainCount = UINT32_MAX;
	UINT8 count = 0U;
	UINT8 tmpDataBuff[HEART_FRAME_MAX_LENGTH] = { 0U };
	UINT8 rtnDataBuff_CCA[HEART_FRAME_MAX_LENGTH] = { 0U };
	UINT8 rtnDataBuff_CCB[HEART_FRAME_MAX_LENGTH] = { 0U };
	UINT8 rtnDataBuff_SEBA[HEART_FRAME_MAX_LENGTH] = { 0U };
	UINT8 rtnDataBuff_SEBB[HEART_FRAME_MAX_LENGTH] = { 0U };
	UINT32 cycNew_CCA = 0U;
	UINT32 cycNew_CCB = 0U;
	UINT32 cycNew_SEBA = 0U;
	UINT32 cycNew_SEBB = 0U;
	UINT32 tmpCyc = 0U;

	while (0U != remainCount)
	{
		/*清空数组*/
		(void)CommonMemSet(&tmpDataBuff, HEART_FRAME_MAX_LENGTH, 0U, HEART_FRAME_MAX_LENGTH);
		
#if (kPLATFORM == kVXWORKS)

		remainCount = MSCP_OutNetHeart_AppRecv(OUT &tmpDataBuff, HEART_FRAME_MAX_LENGTH);
		debug_infor_printf((const)"\nBoard ID: %d, Printf Heart DataBuff from [MSCP_OutNetHeart_AppRecv], remainCount = %d", tmpDataBuff[2], remainCount);
		debug_out_array(0xAA, tmpDataBuff, HEART_FRAME_REAL_LENGTH);
#endif
		
		
		if (0U != tmpDataBuff[2])
		{
			count++;

			/*接收CC1数据*/
			if (BOARD_TYPE_CCUA == tmpDataBuff[2])
			{
				tmpCyc = LongFromChar(&tmpDataBuff[3]);	/*获取本帧周期号*/
				if (tmpCyc > cycNew_CCA)
				{
					cycNew_CCA = tmpCyc;
					(void)CommonMemCpy((void*)&rtnDataBuff_CCA, HEART_FRAME_MAX_LENGTH, (const void*)&tmpDataBuff, HEART_FRAME_MAX_LENGTH);

				}
				*CC1_commFFlag = CI_SUCCESS;
			}
			/*接收CC2数据*/
			else if (BOARD_TYPE_CCUB == tmpDataBuff[2])
			{
				tmpCyc = LongFromChar(&tmpDataBuff[3]);	/*获取本帧周期号*/
				if (tmpCyc > cycNew_CCB)
				{
					cycNew_CCB = tmpCyc;
					(void)CommonMemCpy((void*)&rtnDataBuff_CCB, HEART_FRAME_MAX_LENGTH, (const void*)&tmpDataBuff, HEART_FRAME_MAX_LENGTH);
				}
				*CC2_commFFlag = CI_SUCCESS;
			}
			/*接收SEB1数据*/
			else if (BOARD_TYPE_SEBA == tmpDataBuff[2])
			{
				tmpCyc = LongFromChar(&tmpDataBuff[3]);	/*获取本帧周期号*/
				if (tmpCyc > cycNew_SEBA)
				{
					cycNew_SEBA = tmpCyc;
					(void)CommonMemCpy((void*)&rtnDataBuff_SEBA, HEART_FRAME_MAX_LENGTH, (const void*)&tmpDataBuff, HEART_FRAME_MAX_LENGTH);
				}
				*SEB1_commFFlag = CI_SUCCESS;
			}
			/*接收SEB2数据*/
			else if (BOARD_TYPE_SEBB == tmpDataBuff[2])
			{
				tmpCyc = LongFromChar(&tmpDataBuff[3]);	/*获取本帧周期号*/
				if (tmpCyc > cycNew_SEBB)
				{
					cycNew_SEBB = tmpCyc;
					(void)CommonMemCpy((void*)&rtnDataBuff_SEBB, HEART_FRAME_MAX_LENGTH, (const void*)&tmpDataBuff, HEART_FRAME_MAX_LENGTH);
				}
				*SEB2_commFFlag = CI_SUCCESS;
			}
			else
			{
				/*数据来源板卡非法，不处理*/
			}
			
			/*已接受到最大接收值， 退出循环*/
			if (HEART_FRAME_MAX_SUM == count)
			{
				remainCount = 0U;
			}
		}
		else
		{
			remainCount = 0U;
		}
	}

	(void)CommonMemCpy((void*)CC1_data, HEART_FRAME_MAX_LENGTH, (const void*)&rtnDataBuff_CCA, HEART_FRAME_MAX_LENGTH);
	(void)CommonMemCpy((void*)CC2_data, HEART_FRAME_MAX_LENGTH, (const void*)&rtnDataBuff_CCB, HEART_FRAME_MAX_LENGTH);
	(void)CommonMemCpy((void*)SEB1_data, HEART_FRAME_MAX_LENGTH, (const void*)&rtnDataBuff_SEBA, HEART_FRAME_MAX_LENGTH);
	(void)CommonMemCpy((void*)SEB2_data, HEART_FRAME_MAX_LENGTH, (const void*)&rtnDataBuff_SEBB, HEART_FRAME_MAX_LENGTH);

}


/*
* 功能描述： 获取本系收到的两系IO输入状态
* 参数说明：UINT8* ioData 获取的IO数据
* 返回值  ： CI_SUCCESS 获取成功
*           CI_ERROR  获取失败
* BY LC
*/
UINT8 InnetChannelIODataRecv(UINT8* ioData)
{
	UINT8 retVal = CI_ERROR;
	UINT8 ioRecvFlag = 0U;
	UINT8 recvIOData[IO_DATA_LENGTH] = { 0U };/*收到的40字节GPIO数据，留50字节储存*/
	UINT8 paraseIOData[IO_DATA_DATA_LENGTH] = { 0U };/*实际内容为4个PU4个状态 16字节*/

#if (kPLATFORM == kVXWORKS)
	if (NULL != ioData)
	{
		/*获取本系PU收到的IO数据*/
		ioRecvFlag = MSCP_2x2_GetLastIoInput(recvIOData, (UINT16)IO_DATA_LENGTH);
		if (0x55U == ioRecvFlag)
		{
			debug_infor_printf((const)"\nRECV IOData:");
			debug_out_array(0xAA, recvIOData, (UINT16)IO_DATA_LENGTH);
			(void)CommonMemCpy(&paraseIOData[0], 4U, &recvIOData[0], 4U);/*PU1数据*/
			(void)CommonMemCpy(&paraseIOData[4], 4U, &recvIOData[10], 4U);/*PU2数据*/
			(void)CommonMemCpy(&paraseIOData[8], 4U, &recvIOData[20], 4U);/*PU3数据*/
			(void)CommonMemCpy(&paraseIOData[12], 4U, &recvIOData[30], 4U);/*PU4数据*/
			debug_infor_printf((const)"\nPUA IOData:%d-%d-%d-%d  %d-%d-%d-%d", paraseIOData[0], paraseIOData[1], paraseIOData[2], paraseIOData[3], paraseIOData[4], paraseIOData[5], paraseIOData[6], paraseIOData[7]);
			debug_infor_printf((const)"\nPUB IOData:%d-%d-%d-%d  %d-%d-%d-%d", paraseIOData[8], paraseIOData[9], paraseIOData[10], paraseIOData[11], paraseIOData[12], paraseIOData[13], paraseIOData[14], paraseIOData[15]);
			retVal = CI_SUCCESS;
		}
		else
		{
			/*返回失败*/
		}
	}

	if (CI_SUCCESS == retVal)
	{
		(void)CommonMemCpy(ioData, IO_DATA_DATA_LENGTH, paraseIOData, IO_DATA_DATA_LENGTH);
	}
	else
	{
		/*返回失败*/
	}
#endif

	return retVal;
}





/*
* 功能描述： 将队列中的数据传输出去
* 参数说明： UINT8* thisString, 本周期数据
* 返回值  ： 0: 打印失败
*			 1: 打印成功
*/
void SendOut_LogBuff()
{
#if (kPLATFORM==kVXWORKS)

	UINT16 ii = 0U;
	UINT16 subPackLength = 0U;  /*每个分包的数据长度*/
	UINT8 pData[UDPSEND_BUF_MAX + 1] = { 0U };
	UINT16 wCount = 0U;   /*整数包数*/
	UINT16 wTotalNum = 0U;  /*总包数*/
	UINT16 wLastLength = 0U;
	UINT16 wNowNum = 1U;   /*当前组包的数量*/
	UINT32 dataLength = 0U;  /*队列中日志总长度*/
	UINT8 retval = CI_ERROR;
	UINT32 wCycleNum = 0U;
	UINT32  wCRCCheck = 0U;
	UINT32 curCycNum = 0U;

	curCycNum = Get2oo2CurCycleNum();
	subPackLength = GetLogSubPackDataLength();

	/****计算最终需传输的日志大小******/
	wCycleNum = Get2oo2CurCycleNum();
	dataLength = QueueStatus(&logPrintfQue) + PACK_LOG_ALARM_LENGTH; /*日志队列长度+需打印的分包记录长度*/
	wCount = (UINT16)(dataLength / (subPackLength - 13U));  /* 每包留出13字节组 包头与CRC  9+4*/
	wLastLength = (UINT16)(dataLength % (subPackLength - 13U));  /* 余数长度*/
	if (0U == wLastLength)
	{
		wTotalNum = wCount;
	}
	else
	{
		wTotalNum = wCount + 1U;
	}
	
	debug_infor_printf((const)"\nSystemCycleNum:%10d,Pack %2d Frame Log,Full Pack Length Is %4d,Last Pack Length Is %4d", wCycleNum, wTotalNum, subPackLength, wLastLength);

	/*日志分成规定长度一包发送*/
	for (ii = 0U; ii < wCount; ii++)
	{
		(void)CommonMemSet(pData, (UINT32)sizeof(pData), 0u, (UINT32)sizeof(pData));  /*清空pData*/

		LongToChar(wCycleNum, &pData[0]);  /*周期号 4字节*/

		pData[4] = 0x10;  /*包类型*/

		pData[5] = (UINT8)wTotalNum;  /*总包数*/

		pData[6] = (UINT8)wNowNum++;  /*本包索引*/

		ShortToChar(subPackLength - 13U, &pData[7]);  /*本包数据长度 2字节*/

		retval = QueueRead(subPackLength - 13U, &pData[9], &logPrintfQue); /*组数据内容*/
		
		wCRCCheck = Tioc_CommonCrc32(&pData[0], (UINT32)((UINT32)subPackLength - 4U));

		LongToChar(wCRCCheck, &pData[subPackLength - 4U]);  /*CRC 4字节*/

		if (CI_SUCCESS == retval)
		{
			/*发送分包*/
			MSCP_LogBin(pData, subPackLength);
		}
	}
	/*发送余下数据*/
	wLastLength = (UINT16)QueueStatus(&logPrintfQue);
	(void)CommonMemSet(pData, (UINT32)sizeof(pData), 0u, (UINT32)sizeof(pData));  /*清空pData*/

	LongToChar(wCycleNum, &pData[0]);  /*周期号 4字节*/

	pData[4] = 0x10;  /*包类型*/

	pData[5] = (UINT8)wTotalNum;  /*总包数*/

	pData[6] = (UINT8)wNowNum++;  /*本包索引*/

	ShortToChar((UINT16)dataLength, &pData[7]);  /*本包数据长度 2字节*/

	retval = QueueRead(wLastLength, &pData[9], &logPrintfQue); /*组数据内容*/

	wCRCCheck = Tioc_CommonCrc32(&pData[0], (UINT32)((UINT32)wLastLength + 9U));/*组CRC校验码*/

	LongToChar(wCRCCheck, &pData[wLastLength +9U]);  /*CRC 4字节*/

	if (CI_SUCCESS == retval)
	{
		/*发送分包*/
		MSCP_LogBin(pData, wLastLength+13U);

	}

#endif
	/*发送完成后，清空队列*/
	(void)QueueClear(&logPrintfQue);
}


