util.c

ZIGBEE 2006协议栈 BAT测试代码 RADIO PULSE MG2455

/*******************************************************************************
	- Chip		: MG24500/55
	- Author		: RadioPulse Inc, 2007.
	- Date		: 2007-07-02
	- Version		: VER 1.0	
*******************************************************************************/

#include "INCLUDE_TOP.h"

#include "C_HAL/UART.h"
#include "C_HAL/WDT.h"
#include "C_HAL/POWER.h"
#include "C_HAL/PHY.h"

#include "C_MAC/INCLUDE_MAC.h"
#include "C_NWK/INCLUDE_NWK.h"
#include "C_APS/INCLUDE_APS.h"


#define	KEYBOARD_BACK		0x08
#define	KEYBOARD_CarryRet	0x0D
#define	KEYBOARD_LineFeed	0x0A
#define	KEYBOARD_SPACE	0x20


//- Port	: 1=UART1, 0=UART0
void zPrintf(UINT8 Port, char *fmt, ...)
{
	va_list	arg_ptr;
	char		LocalText[64];
	UINT8	cnt;
	
	ZSYS_WDT_SET(10000);

	for(cnt=0 ; cnt<64 ; cnt++) 
	{
		LocalText[cnt] = 0x00;
	}

	va_start(arg_ptr, fmt);
	vsprintf(LocalText, fmt, arg_ptr);
	va_end(arg_ptr);

	if(Port & 0x01)		// SERIAL PORT1
	{
		for(cnt=0 ; cnt<64 ; cnt++) 
		{
			if(LocalText[cnt] != 0)
			{
				ZSYS_UART1_PUT(LocalText[cnt]);
				if(LocalText[cnt] == KEYBOARD_LineFeed)	
					ZSYS_UART1_PUT(KEYBOARD_CarryRet);			
			}
			else		break;
		}	
	}
	else 					// SERIAL PORT0
	{
		for(cnt=0 ; cnt<64 ; cnt++)
		{
			if(LocalText[cnt] != 0)
			{			
				ZSYS_UART0_PUT(LocalText[cnt]);
				if(LocalText[cnt] == KEYBOARD_LineFeed)	
					ZSYS_UART0_PUT(KEYBOARD_CarryRet);
			}
			else		break;
		}	
	}
}


//- Port	: 1=UART1, 0=UART0
void zScanf(UINT8 Port, UINT16 *pValue)
{
	char		integer;
	UINT8	ki;
	UINT8	cnt;

	cnt = 0;
	*pValue = 0;

	while(1) 
	{		
		ZSYS_WDT_SET(10000);

		if(Port & 0x01)
		{
			if(ZSYS_UART1_GET(&ki)) 
			{
				integer = toint(ki);

				if(integer != -1) 
				{
					if(cnt != 4)
					{
						ZSYS_UART1_PUT(ki);
						*pValue <<= 4;
						*pValue |= integer;
						cnt++;
					}
				}
				else 
				{
					if( (ki == KEYBOARD_BACK) && (cnt) ) 	// BackSpace
					{
						ZSYS_UART1_PUT(KEYBOARD_BACK);
						ZSYS_UART1_PUT(KEYBOARD_SPACE);
						ZSYS_UART1_PUT(KEYBOARD_BACK);
						*pValue = *pValue >> 4;
						cnt--;
					}
				
					if(ki == KEYBOARD_CarryRet)
					{
						break;
					}
				}
			}	
		
		}
		else
		{
			if(ZSYS_UART0_GET(&ki)) 
			{
				integer = toint(ki);

				if(integer != -1) 
				{
					if(cnt != 4)
					{
						ZSYS_UART0_PUT(ki);
						*pValue <<= 4;				
						*pValue |= integer;
						cnt++;
					}
				}
				else 
				{				
					if( (ki == KEYBOARD_BACK) && (cnt) ) 	// BackSpace
					{
						ZSYS_UART0_PUT(KEYBOARD_BACK);
						ZSYS_UART0_PUT(KEYBOARD_SPACE);
						ZSYS_UART0_PUT(KEYBOARD_BACK);
						*pValue = *pValue >> 4;
						cnt--;
					}

					if(ki == KEYBOARD_CarryRet) 	// Enter
					{
						break;
					}				
				}			
			}			
		}
	
	}

}


//-- RETURN
//	0	: Not Valid
//	1	: Valid
UINT8 ZSYS_HIB_VALID()
{
	UINT8	i;
	UINT8	code *pCodeBuf;
	UINT8	SUM;

	pCodeBuf = HIB_ADDRESS;
	SUM = 0;
	for(i=0 ; i<HIB_LENGTH ; i++)
	{
		SUM += pCodeBuf[i];
	}

	if(SUM == 0)	return	1;
	else			return	0;
}

//-- RETURN
//	1	: ERROR. HIB is not valid
//	0	: SUCCESS. HIB is valid
UINT8 ZSYS_HIB_COPY(UINT8 *pBuf)
{
	UINT8	i;
	UINT8	code *pCodeBuf;
	UINT8	SUM;

	pCodeBuf = HIB_ADDRESS;
	SUM = 0;
	for(i=0 ; i<HIB_LENGTH ; i++)
	{
		SUM += pCodeBuf[i];
		pBuf[i] = pCodeBuf[i];
	}

	if(SUM == 0)	return	1;
	else			return	0;	
}





void Display_Buffer(UINT8 *pBuf, UINT8 Len, UINT8 Linefeed)
{
	UINT8	ib;

	for(ib=0 ; ib<Len ; ib++)
	{	
		if(Linefeed)
		{
			if( (ib % 16) == 0)		zPrintf(1, "\n");
		}
		zPrintf(1, " %02x",(short)pBuf[ib]);
	}
}


void Display_ZIGBEE_NET_ONE(S_ZIGBEE_NET *pZB)
{
	if(pZB->EnaZN)
	{
		zPrintf(1, "\n ZIG_NET :");
		zPrintf(1, " CH=%02x.",(short)pZB->Chan);
		zPrintf(1, " PAN=%04x.",(short)pZB->PanID);
		zPrintf(1, " Addr=%04x.",(short)pZB->ShortAddr);
		zPrintf(1, " Permit=%02x.",(short)pZB->SuperSpec_H);
		zPrintf(1, "\n BeaLen=%02x.",(short)pZB->BeaPayLen);
		zPrintf(1, " Ver_Sta=%02x.",(short)pZB->BeaPayload.Z2006.Ver_Stack);
		zPrintf(1, " B2=%02x.",(short)pZB->BeaPayload.Z2006.B2);
		zPrintf(1, " EPID=");
		Display_Buffer(pZB->BeaPayload.Z2006.EPID, 8, 0);
	}
}
			
void Swap_Buffer_4B(UINT8 *pBuf, UINT8 Idx)
{
	UINT8	Temp;
	
	Temp = pBuf[Idx+0];
	pBuf[Idx+0] = pBuf[Idx+3];
	pBuf[Idx+3] = Temp;

	Temp = pBuf[Idx+1];
	pBuf[Idx+1] = pBuf[Idx+2];
	pBuf[Idx+2] = Temp;
}

void Swap_Buffer_2B(UINT8 *pBuf, UINT8 Idx)
{
	UINT8	Temp;

	Temp = pBuf[Idx+0];
	pBuf[Idx+0] = pBuf[Idx+1];
	pBuf[Idx+1] = Temp;
}


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////



void p_Qword2ByteArray(UINT16 *pSrc16, UINT8 *pDst8)
{
	memcpy(pDst8, pSrc16, 8);
}

void p_ByteArray2Qword(UINT8 *pSrc8, UINT16 *pDst16)
{
	memcpy(pDst16, pSrc8, 8);
}


void ZSYS_RANDOM_GEN_SEED(UINT16 RandomSeed)
{
	srand(RandomSeed);
}

UINT16 ZSYS_RANDOM_GEN_GET(UINT16 MaskAnd)
{
	UINT16	random_return;

	random_return = rand() & MaskAnd;
	random_return = random_return + 0x08;
	
	return	random_return;		// Min=8, Max=8 + MaskAnd
}


INT8 ZSYS_LQI_TO_dBm(UINT8 LQI)
{
	UINT16	Tmp16;
	INT8		Tmp8;

	Tmp16 = 100 * (255 - LQI);
	Tmp16 = Tmp16 / 255;

	Tmp8 = 0 - Tmp16;
	
	return	Tmp8;
}


	API_SERIAL_PACKET	UartIn;
	API_SERIAL_PACKET	UartOut;

void ZSYS_UART_API_SEND()
{
	UINT8	i;
	UINT8	*pSrc;
	
	ZSYS_UART1_PUT(0xAA);
	ZSYS_UART1_PUT(UartOut.LEN);
	
	UartOut.SUM = 0;

	pSrc = (UINT8 *)&UartOut.PKT;

	for(i=0 ; i<UartOut.LEN ; i++)
	{
		ZSYS_UART1_PUT(*pSrc);
		UartOut.SUM += *pSrc;
		pSrc++;		
	}

	ZSYS_UART1_PUT(UartOut.SUM);
	ZSYS_UART1_PUT(0x55);
}


void ZSYS_UART_API_DEBUG(UINT16 ErrorCode, UINT16 Value)
{
	UINT8	Chk;
	UINT8	Tmp;

	ZSYS_UART1_PUT(0xAA);				
	ZSYS_UART1_PUT(0x06);	Chk = 0;
	ZSYS_UART1_PUT(0xEE);	Chk += 0xEE;
	Tmp = ErrorCode >> 8;	
	ZSYS_UART1_PUT(Tmp);	Chk += Tmp;
	Tmp = ErrorCode;
	ZSYS_UART1_PUT(Tmp);	Chk += Tmp;
	ZSYS_UART1_PUT(0x02);	Chk += 2;
	Tmp = Value >> 8;
	ZSYS_UART1_PUT(Tmp);	Chk += Tmp;
	Tmp = Value;
	ZSYS_UART1_PUT(Tmp);	Chk += Tmp;
	ZSYS_UART1_PUT(Chk);
	ZSYS_UART1_PUT(0x55);	
}



void ZSYS_UART_API_COMMON_NOTIFY(UINT8 Status)
{
	UINT8 Chk = 0;

	ZSYS_UART1_PUT(0xAA);
	ZSYS_UART1_PUT(0x05);
	ZSYS_UART1_PUT(COMM_LAYER);
	Chk += COMM_LAYER;
	ZSYS_UART1_PUT(COMM_OPCODE);
	Chk += COMM_OPCODE;                          	/*	Opcode	*/
	ZSYS_UART1_PUT(COMM_TYPE);
	Chk += COMM_TYPE;                               	/*	Type	*/
	ZSYS_UART1_PUT(0x1);
	Chk += 0x1;                                            	/*	Size		*/
	ZSYS_UART1_PUT(Status);
	Chk += Status;                                       /* 	Packet	*/
	ZSYS_UART1_PUT(Chk);                  	/*	CRC		*/
	ZSYS_UART1_PUT(0x55);                		/* 	ETX		*/

}



UINT8 ZSYS_UART_API_PARSER()
{
	static	UINT8	State = 0;
	static	UINT8	*pDst;
	static	UINT8	BufCnt;
	
	UINT8	KeyIn;
	UINT8	ParseOK;

	if(ZSYS_UART1_GET(&KeyIn) == 0)		return	0;

	ParseOK = 0;
	
	switch(State)
	{
		case 0 :		
			if(KeyIn == 0xAA)	State = 1;
			break;
		case 1 :
			UartIn.LEN = KeyIn & 0x7F;
			
			pDst = (UINT8 *)&UartIn.PKT;
			UartIn.SUM = 0;
			BufCnt = 0;
			State = 2;
			break;
		case 2 :
			*pDst = KeyIn;
			pDst++;
			UartIn.SUM += KeyIn;			
			BufCnt++;

			if(BufCnt == UartIn.LEN)
			{
				State = 3;
			}		
			break;
		case 3 :		
			if( (KeyIn==0) || (KeyIn==UartIn.SUM) )
			{
				ParseOK = 1;				
			}
			else	
			{
				ZSYS_UART_API_COMMON_NOTIFY(cCOMMON_CRC_ERROR);
			}
			State = 0;
			break;
		default	: 
			State = 0;
			break;	
	}

	return	ParseOK;
	
}


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////





void ZSYS_RemoveWarning_UTIL_Function()
{
	UINT8	Call;

	Call = 0;
	
	if(Call)
	{
		zPrintf(0, 0);
		zScanf(0, 0);
		ZSYS_HIB_VALID();
		ZSYS_HIB_COPY(0);
		Display_Buffer(0, 0, 0);
		Display_ZIGBEE_NET_ONE(0);
		Swap_Buffer_2B(0,0);
		Swap_Buffer_4B(0,0);
		ZSYS_UART_API_DEBUG(0,0);
		ZSYS_UART_API_PARSER();
		ZSYS_UART_API_COMMON_NOTIFY(0);
		ZSYS_UART_API_SEND();
	}
}