dvb_caemm.c

我国有线电视条件接受标准目前还没有统一

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <cyg/io/io.h>
#include <cyg/hal/types.h>
#include <cyg/infra/diag.h>
#include <cyg/kernel/kapi.h>

#include "custom.h"
#include "kinf.h"

#include "sp_demux.h"
#include "message_id.h"
#include "mbuf_ext_data.h"
#include "dvb_module.h"
#include "DVB_CADemux.h"
#include "dvb_ca.h"
#include "DVB_CAEmm.h"
#include "DVB_CADb.h"
#include "DVB_CAService.h"
#include "DVB_CALogo.h"

static ST_CA_DEMUX g_stCatDemux;
static ST_CA_DEMUX g_stEmmDemux;
static UINT8 g_ucEmmDemuxBuffer[MAX_EMM_BUFFER_SIZE];
static cyg_mutex_t g_CAEmmMutex;
static UINT8 g_ucEmmState = EMM_MAX_STATE;
static S_HLCAPack g_stEmmPack;
static ST_EMM_SECTION g_stEmmSec;
static UINT8 g_ucEmmSecBuffer[MAX_EMM_BUFFER_SIZE];
static UINT16 g_usEmmSecLen = 0;
static ST_EMM_MSGBUF g_stMessage[MAX_MESSAGE_BUFFER];
static S_leadinfo	*g_pstLeadInfo = NULL;
static BROADCAST_ADD_FREQ g_pAddFreq = NULL;
static BROADCAST_ADD_CHILD g_pAddChild = NULL;
static UINT8 g_ucMsgPos = (MAX_MESSAGE_BUFFER - 1);
static UINT32 g_ucLastMailTime = 0;
static UINT32 g_ucLastMsgTime = 0;
#if defined(SDT_CA_50)
static UINT8 aucMsgBgColor[MAX_MESSAGE_BUFFER];
static UINT8 aucMsgFontColor[MAX_MESSAGE_BUFFER];
static S_Frequ_Symbol g_stFreq[MAX_FREQ_NUM];
static UINT8 g_ucFreqNum = 0;
static UINT8 g_ucFreqNew = 0;
static UINT8 g_ucFreqVer = 0xFF;
#endif
static UINT8 g_ucNewMail = 0;
static UINT8 g_ucNewMsg = 0;
static UINT8 g_ucNewUpgradeInfo = 0;
void DVB_CAEmmDump(UINT8 *pBuffer);

static void DVB_CAEMM_ReadEmm(void);
static void DVB_CAEMM_ReadCat(void);
static void DVB_CAEMM_ParseEmm(UINT8 *pucBuffer);
static UINT16 DVB_CAEMM_ParseCat(UINT8 *pucBuffer);
static void DVB_CAEMM_UpgradeInfo(void);
static void DVB_CAEMM_Mail(void);
static void DVB_CAEMM_Message(void);
extern unsigned long crc32(char *data, int len);
extern int DVB_TimeYmdToMjd(UINT16 usYear, UINT8 ucMonth, UINT8 ucDay);
extern void DVB_TimeUpdateTime(UINT16 usMjd,UINT8 ucHour, UINT8 ucMin, UINT8 ucSec);
#if defined(SDT_CA_50)
static void DVB_CAEMM_MsgPolling(void);
#endif
static void DVB_CA_SendNewMail(void);
static void DVB_CA_SendNewMsg(void);

void DVB_CAEMM_RegisterCallBack(BROADCAST_ADD_FREQ pAddFreq, 
	BROADCAST_ADD_CHILD pAddChild)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	g_pAddFreq = pAddFreq;
	g_pAddChild = pAddChild;
	cyg_mutex_unlock(&g_CAEmmMutex);
}

void DVB_CAEMM_Init(void)
{
	memset(&g_stCatDemux, 0x0, sizeof(ST_CA_DEMUX));
	memset(&g_stEmmDemux, 0x0, sizeof(ST_CA_DEMUX));	
	memset(&g_stEmmSec, 0x0, sizeof(ST_EMM_SECTION));	
	memset(g_ucEmmDemuxBuffer, 0x0, MAX_EMM_BUFFER_SIZE);
	memset(g_ucEmmSecBuffer, 0x0, MAX_EMM_BUFFER_SIZE);
	memset(g_stMessage, 0x0, MAX_MESSAGE_BUFFER*sizeof(ST_EMM_MSGBUF));
	g_usEmmSecLen = 0;

	g_ucEmmState = EMM_MAX_STATE;
	g_stCatDemux.iChannelIndex = -1;
	g_stEmmDemux.iChannelIndex = -1;
	cyg_mutex_init(&g_CAEmmMutex);
}

void DVB_CAEMM_BroadcastStart(UINT16 usPid, UINT8 ucTableID)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	memset(&g_stEmmDemux, 0x0, sizeof(ST_CA_DEMUX));
	g_stEmmDemux.iChannelIndex = -1;
	g_stEmmDemux.pucDemuxBuffer = g_ucEmmDemuxBuffer;
	g_stEmmDemux.ucType = CHANNEL_TYPE_PSI;
	g_stEmmDemux.usMaxBufferLen = MAX_EMM_BUFFER_SIZE;
	g_stEmmDemux.usMaxSectionLen = MAX_EMM_BUFFER_SIZE;
	g_stEmmDemux.usPid = usPid;
	g_stEmmDemux.ucNoCrc = 0;
	#if defined(SDT_CA_50)
	g_stEmmDemux.ucMatch[0][0] = ucTableID;		
	g_stEmmDemux.ucMatch[0][5] = 0x08;	
	g_stEmmDemux.ucMask[0][0] = 0xFF;
	g_stEmmDemux.ucMask[0][5] = 0xFF;
	g_stEmmDemux.ucFilterLen[0] = 6;
	#elif defined(SDT_CA_40)
	g_stEmmDemux.ucMatch[0][0] = ucTableID;		
	g_stEmmDemux.ucMatch[0][3] = 0x08;	
	g_stEmmDemux.ucMask[0][0] = 0xFF;
	g_stEmmDemux.ucMask[0][3] = 0xFF;
	g_stEmmDemux.ucFilterLen[0] = 4;
	#endif
	g_stEmmDemux.ucFilterNum = 1;
	DVB_CAOpenChannel(&g_stEmmDemux);
	g_ucEmmState = EMM_GET_EMM;
	cyg_mutex_unlock(&g_CAEmmMutex);
}

void DVB_CAEMM_Start(void)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	g_ucEmmState = EMM_GET_CAT;
	if(g_stCatDemux.iChannelIndex >= 0)
		DVB_CACloseChannel(&g_stCatDemux);
	if(g_stEmmDemux.iChannelIndex >= 0)
		DVB_CACloseChannel(&g_stEmmDemux);
	cyg_mutex_unlock(&g_CAEmmMutex);
}

void DVB_CAEMM_Stop(void)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	g_ucEmmState = EMM_MAX_STATE;
	if(g_stCatDemux.iChannelIndex >= 0)
		DVB_CACloseChannel(&g_stCatDemux);
	if(g_stEmmDemux.iChannelIndex >= 0)
		DVB_CACloseChannel(&g_stEmmDemux);

	g_usEmmSecLen = 0;	
	memset(&g_stEmmSec, 0x0, sizeof(ST_EMM_SECTION));	
	memset(g_ucEmmSecBuffer, 0x0, MAX_EMM_BUFFER_SIZE);
	
	cyg_mutex_unlock(&g_CAEmmMutex);
}

void DVB_CAEMM_Polling(void)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	switch(g_ucEmmState)
	{
		case EMM_GET_CAT:
			DVB_CAEMM_ReadCat();
			break;
		case EMM_GET_EMM:
			DVB_CAEMM_ReadEmm();
			break;
		default:
			break;
	}
	cyg_mutex_unlock(&g_CAEmmMutex);
	
	#if defined(SDT_CA_50)
	DVB_CAEMM_MsgPolling();
	#endif

	if(g_ucNewMsg)
	{
		DVB_CA_SendNewMsg();
	}
	if(g_ucNewMail)
	{
		DVB_CA_SendNewMail();
	}
}
#if defined(SDT_CA_50)
void  DVB_CAEMM_CheckNewFreq(void)
{
	if(g_ucFreqNew)
	{
		main_prog_msg_t stMsg;
		UINT8 ucMessage = CA_NEW_FREQ;
		stMsg.u8MsgID   	= DVB_MODULE_ID;
		stMsg.u8SubModID = CA_UI_ID;
		stMsg.u16FuncID  	= CA_MESSAGE;
		stMsg.pData = (void *)&ucMessage;
		DVB_SendBackMsg(&stMsg, 1);
	}
}

void DVB_CAEMM_ResetNewFreq(void)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	g_ucFreqNew = 0;
	cyg_mutex_unlock(&g_CAEmmMutex);
}

void DVB_CAEMM_SetFreq(void)
{
	if(g_ucFreqVer != 0xFF)
	{
	//	diag_printf("\n\n\nDVB_CAEMM_SetFreq\n\n\n");
		DVB_CAService_SetFreqVer(g_ucFreqVer);
	}
}

UINT8  DVB_CAEMM_GetFreq(S_Frequ_Symbol *pstFreq)
{
	if(pstFreq == NULL)
		return 0 ;
	cyg_mutex_lock(&g_CAEmmMutex);
	memcpy(pstFreq, g_stFreq, g_ucFreqNum * sizeof(S_Frequ_Symbol));
	g_ucFreqNew = 0;
	cyg_mutex_unlock(&g_CAEmmMutex);
	return g_ucFreqNum;
}
#endif
#if defined(SDT_CA_50)
UINT8 * DVB_CAEMM_GetMsg( UINT8 *ucBgColor, UINT8 *ucFontColor)
{
	int i = 0;
	int iBufferPos = 0;
	UINT8 *pucBuffer = NULL;
	cyg_mutex_lock(&g_CAEmmMutex);
	iBufferPos = g_ucMsgPos;
	for(i = 0; i <MAX_MESSAGE_BUFFER; i++)
	{		
		iBufferPos = (iBufferPos + 1) % MAX_MESSAGE_BUFFER;
		if(g_stMessage[iBufferPos].ucEnable && g_stMessage[iBufferPos].ucGetTimes < 3)
		{			
			pucBuffer = (UINT8 *)malloc(MAIL_CONTEXT_SIZE + 1);
			if(pucBuffer != NULL)
			{
				memset(pucBuffer, 0x0, MAIL_CONTEXT_SIZE + 1);
				memcpy(pucBuffer, g_stMessage[iBufferPos].ucMsgBuffer,MAIL_CONTEXT_SIZE);
				*ucBgColor = aucMsgBgColor[iBufferPos];
				*ucFontColor = aucMsgFontColor[iBufferPos];
				g_stMessage[iBufferPos].ucGetTimes++;
				
				if(g_stMessage[iBufferPos].ucGetTimes >= 3)
					memset(&(g_stMessage[iBufferPos]), 0x0, sizeof(ST_EMM_MSGBUF));
			}
			else 
				ecos_printf("buffer is null!\n");
			break;
		}
	}

	if(pucBuffer != NULL)
	{
		g_ucMsgPos = iBufferPos;
	}
	cyg_mutex_unlock(&g_CAEmmMutex);

	return pucBuffer;
}
#elif defined(SDT_CA_40)
UINT8 * DVB_CAEMM_GetMsg(void)
{
	int i = 0;
	int iBufferPos = 0;
	UINT8 *pucBuffer = NULL;
	cyg_mutex_lock(&g_CAEmmMutex);
	iBufferPos = g_ucMsgPos;
	for(i = 0; i <MAX_MESSAGE_BUFFER; i++)
	{		
		iBufferPos = (iBufferPos + 1) % MAX_MESSAGE_BUFFER;
		if(g_stMessage[iBufferPos].ucEnable && g_stMessage[iBufferPos].ucGetTimes < 3)
		{			
			pucBuffer = (UINT8 *)malloc(MAIL_CONTEXT_SIZE + 1);
			if(pucBuffer != NULL)
			{
				memset(pucBuffer, 0x0, MAIL_CONTEXT_SIZE + 1);
				memcpy(pucBuffer, g_stMessage[iBufferPos].ucMsgBuffer,MAIL_CONTEXT_SIZE);
				g_stMessage[iBufferPos].ucGetTimes++;
				
				if(g_stMessage[iBufferPos].ucGetTimes >= 3)
					memset(&(g_stMessage[iBufferPos]), 0x0, sizeof(ST_EMM_MSGBUF));
			}
			else 
				ecos_printf("buffer is null!\n");
			break;
		}
	}

	if(pucBuffer != NULL)
	{
		g_ucMsgPos = iBufferPos;
	}
	cyg_mutex_unlock(&g_CAEmmMutex);

	return pucBuffer;
}
#endif
void DVB_CAEMM_UpdateTime(S_Time *pstTime)
{
	//static int ucUpdateTime = 0;
	UINT16 uiValue = 0;
	UINT32 uiCurMjd;
	
	uiValue = TransYMD(pstTime->YY, pstTime->MM, pstTime->DD);
	//if(ucUpdateTime == 0)
	{
		uiCurMjd = DVB_TimeYmdToMjd(2000 + pstTime->YY, pstTime->MM, pstTime->DD);
		DVB_TimeUpdateTime(uiCurMjd, pstTime->HH, pstTime->MINUTE, pstTime->SS);
		//ucUpdateTime = 1;
	}
	DVB_CADB_Set(CA_DB_CMD_DATE, uiValue);
	uiValue = (pstTime->HH << 8) | pstTime->MINUTE;
	DVB_CADB_Set(CA_DB_CMD_TIME, uiValue);
}

void DVB_CAEMM_GetUpgradeInfo(STUpdateInfo *pstUpgradeInfo)
{
	if(pstUpgradeInfo == NULL)
		return;
	cyg_mutex_lock(&g_CAEmmMutex);
	pstUpgradeInfo->uiFreq = g_pstLeadInfo->frequ;
	pstUpgradeInfo->uiSymRate = g_pstLeadInfo->symbol_rate;
	pstUpgradeInfo->ucModunation = g_pstLeadInfo->modunation;
	pstUpgradeInfo->uiFactory = g_pstLeadInfo->maufactory_code;
	pstUpgradeInfo->ucTableID = g_pstLeadInfo->TID;
	pstUpgradeInfo->usPID = g_pstLeadInfo->PID;
	memcpy(pstUpgradeInfo->aucHwVer, g_pstLeadInfo->hardware_version, 4);
	memcpy(pstUpgradeInfo->aucSwVer, g_pstLeadInfo->software_version, 4);
	memcpy(pstUpgradeInfo->aucStartSTBID, g_pstLeadInfo->start_STB_ID, 12);
	memcpy(pstUpgradeInfo->aucEndSTBID, g_pstLeadInfo->end_STB_ID, 12);
	pstUpgradeInfo->aucTime[0] = g_pstLeadInfo->S_shift_time.YY;
	pstUpgradeInfo->aucTime[1] = g_pstLeadInfo->S_shift_time.MM;
	pstUpgradeInfo->aucTime[2] = g_pstLeadInfo->S_shift_time.DD;
	pstUpgradeInfo->aucTime[3] = g_pstLeadInfo->S_shift_time.HH;
	pstUpgradeInfo->aucTime[4] = g_pstLeadInfo->S_shift_time.MINUTE;
	pstUpgradeInfo->aucTime[5] = g_pstLeadInfo->S_shift_time.SS;
	cyg_mutex_unlock(&g_CAEmmMutex);
}

UINT8 DVB_CAEMM_CheckNewUpgradeInfo(void)
{
	if(g_ucNewUpgradeInfo)
	{
		main_prog_msg_t stMsg;
		UINT8 ucMessage = CA_UPGRADE_INFO;
		stMsg.u8MsgID   	= DVB_MODULE_ID;
		stMsg.u8SubModID = CA_UI_ID;
		stMsg.u16FuncID  	= CA_MESSAGE;
		stMsg.pData = (void *)&ucMessage;
		DVB_SendBackMsg(&stMsg, 1);
	}
	return 0;
}

void DVB_CAEMM_ResetNewUpgradeInfo(void)
{
	cyg_mutex_lock(&g_CAEmmMutex);
	g_ucNewUpgradeInfo = 0;
	cyg_mutex_unlock(&g_CAEmmMutex);
}
static void DVB_CAEMM_ReadEmm(void)
{
	int iResult = 0;
	
	if(g_stEmmDemux.iChannelIndex < 0)
		DVB_CAOpenChannel(&g_stEmmDemux);
	else
	{
		iResult = DVB_CADemuxReadSection(&g_stEmmDemux);
		if(iResult == 0)
		{
			DVB_CAEMM_ParseEmm(g_stEmmDemux.pucDemuxBuffer);
		}
		else if(iResult < 0)
		{
			DVB_CACloseChannel(&g_stEmmDemux);
			DVB_CAOpenChannel(&g_stEmmDemux);
		}
	}
}
static void DVB_CAEMM_ReadCat(void)
{
	int iResult = 0;
	UINT16 usEmmPid = 0x1FFF;
	
	if(g_stCatDemux.iChannelIndex < 0)
	{
		g_stCatDemux.iChannelIndex = -1;
		g_stCatDemux.pucDemuxBuffer = g_ucEmmDemuxBuffer;
		g_stCatDemux.ucType = CHANNEL_TYPE_PSI;
		g_stCatDemux.usMaxBufferLen = MAX_EMM_BUFFER_SIZE;
		g_stCatDemux.usMaxSectionLen = MAX_EMM_BUFFER_SIZE;
		g_stCatDemux.usPid = CAT_PID;
		g_stCatDemux.ucNoCrc = 0;
		g_stCatDemux.ucMatch[0][0] = CAT_TABLED_ID;					
		g_stCatDemux.ucMask[0][0] = 0xFF;
		g_stCatDemux.ucFilterLen[0] = 1;
		g_stCatDemux.ucFilterNum = 1;
		DVB_CAOpenChannel(&g_stCatDemux);
	}
	else
	{
		iResult = DVB_CADemuxReadSection(&g_stCatDemux);
		if(iResult == 0)
		{
			usEmmPid = DVB_CAEMM_ParseCat(g_stCatDemux.pucDemuxBuffer);
			if(usEmmPid != 0x1FFF)
			{
				UINT32 uiCardID = 0;
				DVB_CACloseChannel(&g_stCatDemux);
				memset(&g_stEmmDemux, 0x0, sizeof(ST_CA_DEMUX));
				g_stEmmDemux.iChannelIndex = -1;
				g_stEmmDemux.pucDemuxBuffer = g_ucEmmDemuxBuffer;
				g_stEmmDemux.ucType = CHANNEL_TYPE_PSI;
				g_stEmmDemux.usMaxBufferLen = MAX_EMM_BUFFER_SIZE;
				g_stEmmDemux.usMaxSectionLen = MAX_EMM_BUFFER_SIZE;
				g_stEmmDemux.usPid = usEmmPid;
				g_stEmmDemux.ucNoCrc = 0;
				DVB_CADB_Get(CA_DB_CMD_SMART_ID, &uiCardID);	
				#if 0
				g_stEmmDemux.ucMatch[0][0] = 0x80;	
				g_stEmmDemux.ucMask[0][0] = 0xF0;
				g_stEmmDemux.ucFilterLen[0] = 1;
				g_stEmmDemux.ucFilterNum = 1;
				#else
				#if defined(SDT_CA_50)
				g_stEmmDemux.ucMatch[0][0] = 0x80;	
				g_stEmmDemux.ucMatch[0][3] = 0x00;
				g_stEmmDemux.ucMatch[0][6] = 0x00;	
				g_stEmmDemux.ucMatch[0][7] = 0x00;	
				g_stEmmDemux.ucMatch[0][8] = 0x00;	
				g_stEmmDemux.ucMatch[0][9] = 0x00;	
				
				g_stEmmDemux.ucMask[0][0] = 0xF0;
				g_stEmmDemux.ucMask[0][3] = 0xFF;
				g_stEmmDemux.ucMask[0][6] = 0xFF;
				g_stEmmDemux.ucMask[0][7] = 0xFF;
				g_stEmmDemux.ucMask[0][8] = 0xFF;
				g_stEmmDemux.ucMask[0][9] = 0xFF;
				g_stEmmDemux.ucFilterLen[0] = 10;

				g_stEmmDemux.ucMatch[1][0] = 0x80;	
				g_stEmmDemux.ucMatch[1][3] = 0x00;
				g_stEmmDemux.ucMatch[1][6] = (uiCardID >> 24) & 0xFF;	
				g_stEmmDemux.ucMatch[1][7] = (uiCardID >> 16) & 0xFF;	
				g_stEmmDemux.ucMatch[1][8] = (uiCardID >> 8) & 0xFF;	
				g_stEmmDemux.ucMatch[1][9] = (uiCardID) & 0xFF;	
				
				g_stEmmDemux.ucMask[1][0] = 0xF0;
				g_stEmmDemux.ucMask[1][3] = 0xFF;
				g_stEmmDemux.ucMask[1][6] = 0xFF;
				g_stEmmDemux.ucMask[1][7] = 0xFF;
				g_stEmmDemux.ucMask[1][8] = 0xFF;
				g_stEmmDemux.ucMask[1][9] = 0xFF;
				g_stEmmDemux.ucFilterLen[1] = 10;

				g_stEmmDemux.ucMatch[2][0] = 0x80;	
				g_stEmmDemux.ucMatch[2][3] = 0x00;	
				
				g_stEmmDemux.ucMask[2][0] = 0xF0;
				g_stEmmDemux.ucMask[2][3] = 0xFF;

				g_stEmmDemux.ucNegate[2][0] = 0x00;
				g_stEmmDemux.ucNegate[2][3] = 0xFF;
				g_stEmmDemux.ucFilterLen[2] = 4;
				g_stEmmDemux.ucFilterNum = 3;
				#elif defined(SDT_CA_40)
				g_stEmmDemux.ucMatch[0][0] = 0x80;	
				g_stEmmDemux.ucMatch[0][4] = 0x00;	
				g_stEmmDemux.ucMatch[0][5] = 0x00;	
				g_stEmmDemux.ucMatch[0][6] = 0x00;	
				g_stEmmDemux.ucMatch[0][7] = 0x00;	
				
				g_stEmmDemux.ucMask[0][0] = 0xF0;
				g_stEmmDemux.ucMask[0][4] = 0xFF;
				g_stEmmDemux.ucMask[0][5] = 0xFF;
				g_stEmmDemux.ucMask[0][6] = 0xFF;
				g_stEmmDemux.ucMask[0][7] = 0xFF;
				g_stEmmDemux.ucFilterLen[0] = 8;

				g_stEmmDemux.ucMatch[1][0] = 0x80;	
				g_stEmmDemux.ucMatch[1][4] = (uiCardID >> 24) & 0xFF;	
				g_stEmmDemux.ucMatch[1][5] = (uiCardID >> 16) & 0xFF;	
				g_stEmmDemux.ucMatch[1][6] = (uiCardID >> 8) & 0xFF;	
				g_stEmmDemux.ucMatch[1][7] = (uiCardID) & 0xFF;	
				
				g_stEmmDemux.ucMask[1][0] = 0xF0;
				g_stEmmDemux.ucMask[1][4] = 0xFF;
				g_stEmmDemux.ucMask[1][5] = 0xFF;
				g_stEmmDemux.ucMask[1][6] = 0xFF;
				g_stEmmDemux.ucMask[1][7] = 0xFF;
				g_stEmmDemux.ucFilterLen[1] = 8;
				g_stEmmDemux.ucFilterNum = 2;
				#endif
				#endif
				DVB_CAOpenChannel(&g_stEmmDemux);
				g_ucEmmState = EMM_GET_EMM;
			}
		}
		else if(iResult < 0)
		{
			DVB_CACloseChannel(&g_stCatDemux);
			DVB_CAOpenChannel(&g_stCatDemux);
		}
	}
}

static void DVB_CAEMM_ParseEmm(UINT8 *pucBuffer)
{
	main_prog_msg_t stMsg;
	UINT8 ucMessage;
	#if defined(SDT_CA_50)
	int i, j;
	UINT16 usSectionLen;
	UINT32 uiCrcValue;


	if(pucBuffer[3] > pucBuffer[4] )
	{
		return;
	}

	/*if(pucBuffer[5] == 0x00
		//|| pucBuffer[5] == 0x01
		|| pucBuffer[5] == 0x02
		|| pucBuffer[5] == 0x03
		|| pucBuffer[5] == 0x04
		|| pucBuffer[5] == 0x05
		|| pucBuffer[5] == 0x06
		|| pucBuffer[5] == 0x07
		|| pucBuffer[5] == 0x08
		|| pucBuffer[5] == 0x09)
	{
		return;
	}*/
	if(pucBuffer[4] != 0)