/*****************************************************************************
 *   uart.c:  UART API file for NXP LPC17xx Family Microprocessors
 *
 *   Copyright(C) 2009, NXP Semiconductor
 *   All rights reserved.
 *
 *   History
 *   2009.05.27  ver 1.00    Prelimnary version, first Release
 *
******************************************************************************/


#include "type.h"
#include "clib.h"
#include "../msp/uart0.h"
#include "../msp/time.h"


U8 Lc_strStartsWith(U8 *s1,U8 *s2)
{
	while(*s1 && *s2)
	{	
		if(*s1++ != *s2++)
		{
			return 0;
		}
	}
	return (*s2 == 0);
}


int Lc_strlen(const char *str)
{
	int i;
	i = 0;
	while((*str++)!='\0')
	{
		i++;
	}
	return i;
}

U8* Lc_strcpy(U8* dst,const char* str)
{
	U8 *p = dst;
	while(*dst++ = *str++);
	return p;
}

void Lc_delay_us(vU16 i)
{
	vU16 m;
	i=i/10;
	for(m=i;m>0;m--)
	{
		Lc_delay_1us();
	}
}

void Lc_delay_nop(U8 i)
{
	U8 m;
	for(m=i;m>0;m--)
	{
		NOP();
	}
}



//	D_1ms_delay_para
///22m 300
/// 22M   100ns 5个100ns  20ns 
void Lc_delay_ms(vU16 i)
{
	vU16 m,n;
	for(m=i;m>0;m--)
	{
		#ifdef D_debug_time
		; 
		#else
		//D_debug_time_using
		for(n= 85;n > 0;n--)
		{
			L0_delay_10us();//10us
		}
		#endif
	}
}

void Lc_buf_copy_uc(U8 *dst,U8 *src,U8 len)
{
	while(len--)
	{
		*dst++ = *src++;
	}
}

vU8 Lc_U8_media3(vU8 a,vU8 b,vU8 c)
{
	if(a > b)
	{
		if(b > c)
		{
			return b;
		}else
		{// b<a  b< c
			if(c > a)
			{/// a<c
				return a; 
			}else
			{// c<=a
				return c;
			}
		}
	}else
	{// a<=b
		if(b < c)
		{
			return b;
		}else
		{// a<=b   c <= b
			if(c > a)
			{// a<c   b
				return c; 
			}else
			{// c<=a   b
				return a; 
			}
		}
	}
}

vS32 Lc_S32_media3(vS32 a,vS32 b,vS32 c)
{
	if(a > b)
	{
		if(b > c)
		{
			return b;
		}
		else
		{// b<a  b< c
			if(c > a)
			{/// a<c
				return a; 
			}else
			{// c<=a
				return c;
			}
		}
	}else
	{// a<=b
		if(b < c)
		{
			return b;
		}else
		{// a<=b   c <= b
			if(c > a)
			{// a<c   b
				return c; 
			}else
			{// c<=a   b
				return a; 
			}
		}
	}
}

void Lc_array_sort(S32 arr[],int n)
{
	int i = 0, j=0, ok = 0;
	S32 tmp = 0;
	for(i=0; i<n-1; i++)
	{
		ok = 1;
		for(j=0; j<n-i-1; j++)
		{
			if(arr[j] > arr[j+1])
			{
				ok = 0;
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
		if(ok)
		{
			break;
		}
	}
}

vS32 Lc_S32_media(vS32 val[],S16 num)
{
	if(num <= 1)
	{
		return val[0];
	}
	else
	{
		Lc_array_sort(val,num);
		return val[num/2];
	}
}
U32 Lc_vS32_media(U32 *d, U8 n)
{
	U8 i = 0,j = 0;
	U32 h = 0;
	if(n == 1)
	{
		return d[0];
	}
	for(i=0;i<n-1;i++)
	{
		for(j=i+1;j<n;j++)
		{
			if(d[i] > d[j])
			{
				h = d[i];
				d[i] = d[j];
				d[j] = h;
			}
		}
	}
	if(n%2 !=  0) //奇数
	{
		return d[n/2];
	}
	else//偶数
	{
		return ((d[n/2] + d[n/2-1])/2);
	}
}


U32 Lc_vU32_avg(U32 *d, U8 n)
{
	U8 i = 0;
	U32 sum = 0;
	if(n == 1)
	{
		return d[0];
	}	
	for(i=0;i<n;i++)
	{
		sum += d[i]; 
	}
	return sum / n;
}


/////                0   1  (1-0)+1
//// 把buf中的数据从[usStart]到[usEnd] 共 usEnd-usStart+1  的数据转换成ascii
/// 0x11 0x22 ---> 0x31 0x31 0x32 0x32  '1' '1'  '2' '2'
void Lc_hex2ascii(U8 *buf,U16 len,U8 *ascii)
{
	vU16 t = 0,m = 0;
	for(t = 0;t < len;t ++)
	{

	#if 1
		ascii[m] = cguHex2Char[D_uc_high(buf[t])][1];
		m ++;
		ascii[m] = cguHex2Char[D_uc_low (buf[t])][1];
		m ++;
		ascii[m] =0x20; 
		m ++;
		#else
		
		ascii[m] = 0x30+m;
		m++;		
		ascii[m] = 0x30+m;
		m++;		
		ascii[m] = 0x30+m;
		m++;

		
		#endif
	}
}

///  cguHex2Char[0][0] = 0x00  cguHex2Char[0][1] = 0x30  
unsigned char code cguHex2Char[16][2]
={
	0x00,'0',
	0x01,'1',
	0x02,'2',
	0x03,'3',
	0x04,'4',
	0x05,'5',
	0x06,'6',
	0x07,'7',
	0x08,'8',
	0x09,'9',
	0x0A,'A',
	0x0B,'B',
	0x0C,'C',
	0x0D,'D',
	0x0E,'E',
	0x0F,'F'
};


void crc16(unsigned char *CRC,void *dat,unsigned int len) /*reentrant*/
{
	unsigned char *ptr = (unsigned char *)dat;
	unsigned long wcrc=0XFFFF;//预置16位crc寄存器，初值全部为1
	unsigned char temp;//定义中间变量
	int i=0,j=0;//定义计数
	for(i=0;i<len;i++)//循环计算每个数据
	{
		temp=*ptr&0X00FF;//将八位数据与crc寄存器亦或
		ptr++;//指针地址增加，指向下个数据
		wcrc^=temp;//将数据存入crc寄存器
		for(j=0;j<8;j++)//循环计算数据的
		{
			if(wcrc&0X0001)//判断右移出的是不是1，如果是1则与多项式进行异或。
			{
				wcrc>>=1;//先将数据右移一位
				wcrc^=0XA001;//与上面的多项式进行异或
			}
			else//如果不是1，则直接移出
			{
				wcrc>>=1;//直接移出
			}
		}
	}
	temp=wcrc;//crc的值
	CRC[0]=wcrc;//crc的低八位
	CRC[1]=wcrc>>8;//crc的高八位
}

#if 0
void crc16_irq(unsigned char *CRC,void *dat,unsigned int len)
{
	unsigned char *ptr = (unsigned char *)dat;
	unsigned long wcrc=0XFFFF;//预置16位crc寄存器，初值全部为1
	unsigned char temp;//定义中间变量
	int i=0,j=0;//定义计数
	for(i=0;i<len;i++)//循环计算每个数据
	{
		temp=*ptr&0X00FF;//将八位数据与crc寄存器亦或
		ptr++;//指针地址增加，指向下个数据
		wcrc^=temp;//将数据存入crc寄存器
		for(j=0;j<8;j++)//循环计算数据的
		{
			if(wcrc&0X0001)//判断右移出的是不是1，如果是1则与多项式进行异或。
			{
				wcrc>>=1;//先将数据右移一位
				wcrc^=0XA001;//与上面的多项式进行异或
			}
			else//如果不是1，则直接移出
			{
				wcrc>>=1;//直接移出
			}
		}
	}
	temp=wcrc;//crc的值
	CRC[0]=wcrc;//crc的低八位
	CRC[1]=wcrc>>8;//crc的高八位
}
#endif


U32 Lc_abs(vS32 a,vS32 b)
{
	if(a >= b)
	{
		return a - b;
	}
	return b - a;
}

void Lc_encrypt_id(U8 *enc_dst, U8 *enc_src, U32 enc_key, U8 src_len)
{
	U8 i = 0,key0,key1,key2,key3;
	key0 = enc_key >> 24 & 0xFF;
	key1 = enc_key >> 16 & 0xFF;
	key2 = enc_key >> 8 & 0xFF;
	key3 = enc_key >> 0 & 0xFF;

	for(i=0;i<src_len;i++)
	{
		enc_dst[i] = (((enc_src[i] << key0) + key1) ^ key2) + key3;
	}
}

void Lc_encrypt_id1(U8 *enc_dst, U8 *enc_src, U8 enc_key[], U8 src_len)
{
	U8 i;
	for(i=0;i<src_len;i++)
	{
		enc_dst[i] = (((enc_src[i] << enc_key[0]) + enc_key[1]) ^ enc_key[2]) + enc_key[3];
	}
}


//int Lc_strlen(char *str)
//{
//	char *tmp = str;
//	while(*tmp++)
//		;
//	return tmp - str - 1;
//}

int Lc_memset(U8 *buf,U8 c,U16 len)
{
	U16 i;
	for(i=0;i<len;i++)
	{
		buf[i] = c;
	}
	return 0;
}


#if 0
//判断是否大端字节序
int isBigEndianOrder(void)
{
    int iVal = 1;
    char *pChar = (char*)(&iVal);
    if(*pChar == 1) //低字节在低地址(小端)
        return 0;
    return 1; //(0x00000001) 低字节在高地址(大端)  Aix采用的是大端法
}

U32 ntohl(U32 dat)
{
    U32 res = 0;
    if(dat == 0 || isBigEndianOrder()){
        res = dat;
    }else{
        res = (((dat >> 0) & 0xFF) << 24) | (((dat >> 8) & 0xFF) << 16) | (((dat >> 16) & 0xFF) << 8) | (((dat >> 24) & 0xFF) << 0);
    }
    return res;
}

U32 htonl(U32 dat)
{
	U32 res = 0;
    if(dat == 0 || isBigEndianOrder()){
        res = dat;
    }else{
        res = (((dat >> 0) & 0xFF) << 24) | (((dat >> 8) & 0xFF) << 16) | (((dat >> 16) & 0xFF) << 8) | (((dat >> 24) & 0xFF) << 0);
    }
    return res;
}

U16 ntohs(U16 dat)
{
    U16 res = 0;
    if(dat == 0 || isBigEndianOrder()){
        res = dat;
    }else{
        res = (((dat >> 0) & 0xFF) << 8) | (((dat >> 8) & 0xFF) << 0) ;
    }
	return res;
}

U16 htons(U16 dat)
{
    U16 res = 0;
    if(dat == 0 || isBigEndianOrder()){
        res = dat;
    }else{
        res = (((dat >> 0) & 0xFF) << 8) | (((dat >> 8) & 0xFF) << 0) ;
    }
    return res;
}
#endif

#if 0///#ifdef D_flash_max


//  0--9   '0'
//      ABCEDF------0X41-- 87-6= 81
U8 Lc_Hex2Char(U8 CharStr)
{             
	U8  rd;	
	if (CharStr >9)//A   10-9+
	{
		rd = (CharStr - 10 + 'A') ; 
	}
	else
	{
		rd = (CharStr + '0') ; 
	}
	return rd;
}  
// 0x30'0'----'9'--> 0x0----0x09
//0x61--'a'---'f'--> 0x0a---0x0f 
//0x41 'A'--'F'--> 0x0a---0x0f
U8 Lc_Char2Hex(U8 CharStr)
{             
	U8  rd;	
	if (CharStr >= 'a')//0x61--'a'---'f'--> 0x0a---0x0f 
	{
		rd = (CharStr - 'a' + 0x0a) ; 
	}
	else if (CharStr >= 'A')//0x61--'a'---'f'--> 0x0a---0x0f 
	{
		rd = (CharStr - 'A' + 0x0a) ; 
	}
	else
	{
		rd = (CharStr - '0') ; 
	}
	return rd;
}  
//catch_protocol(s,d);
// 从 d中提取出协议,一般用于协议打包后的调试和透传,
// *s="iicsend:12 34 56 78 9a \r\n";
//  i:         012345678
// 返回协议字节数量
// extern int strpos (const char *s, char c);
unsigned char catch_protocol (const char *d_src,char d_protocol[]) 
{
	unsigned char n = 0,len = 0;//,i = 0;
	int i = 0;
	i = strpos(d_src, (char)':');
	i ++;
	len = strlen (d_src) - 2;
	while(i < len)
	{
		d_protocol[n] = Lc_Char2Hex(*(d_src+i))*16;
		i ++;
		d_protocol[n] += Lc_Char2Hex(*(d_src+i));
		i ++;i ++;
		n ++;
	}
	return n;
}

/*
 * 函数名：itoa  不同类型的cpu不一样 并且支持的最大数据取决于i = 1000000;D_value_max
 * 描述  ：将整形数据转换成字符串
 * 输入  ：-radix =10 表示10进制，其他结果为0
 *         -value 要转换的整形数
 *         -buf 转换后的字符串
 *         -radix = 10
 * 输出  ：无
 * 返回  ：无
 * 调用  ：被USART1_printf()调用

 Lc_int2a

 
 */
 #define D_value_max	100000
char *Lc_int2a(vS32 value, char *string, UN_TYPE radix)
{
	vS32     i, d;
	UN_TYPE     flag = 0;
	vU16    U16temp = 0;
	char    *ptr = string;
	
	/* This implementation only works for decimal numbers. */
	//value	
	if (!value)
	{
	    *ptr++ = 0x30;
	    *ptr = 0;
	    return string;
	}
	U16temp = value;
	switch(radix)
	{//%X2 %X4 %X6
		case '2':
			*ptr++ = Lc_Hex2Char((U16temp>>4)&0x0f);
			*ptr++ = Lc_Hex2Char((U16temp)&0x0f);
	    	*ptr = 0;
			return string;
			break;
		case '4':
			*ptr++ = Lc_Hex2Char((U16temp>>12)&0x0f);
			*ptr++ = Lc_Hex2Char((U16temp>>8)&0x0f);			
			*ptr++ = Lc_Hex2Char((U16temp>>12)&0x0f);
			*ptr++ = Lc_Hex2Char((U16temp>>8)&0x0f);			
			*ptr++ = Lc_Hex2Char((U16temp>>4)&0x0f);
			*ptr++ = Lc_Hex2Char((U16temp)&0x0f);
	    	*ptr = 0;	
			return string;		
			break;
			#if 0
		case '8':
			*ptr++ = Lc_HexToChar((value>>24)&0x0f);
			*ptr++ = Lc_HexToChar((value>>20)&0x0f);			
			*ptr++ = Lc_HexToChar((value>>16)&0x0f);
			*ptr++ = Lc_HexToChar((value>>12)&0x0f);
			*ptr++ = Lc_HexToChar((value>>8 )&0x0f);			
			*ptr++ = Lc_HexToChar((value>>4 )&0x0f);
			*ptr++ = Lc_HexToChar((value)&0x0f);
	    	*ptr = 0;	
			return string;
			break;
			#endif
		case 10:
			/* if this is a negative value insert the minus sign. */
			if (value < 0)
			{
					*ptr++ = '-';
			
					/* Make the value positive. */
					value *= -1;
			}
			i = D_value_max; 
			if (value > i)
			{
				value = i;
			}
			for (;i > 0; i /= 10)
			{
					d = value / i;
			
					if (d || flag)
					{
							*ptr++ = (char)(d + 0x30);
							value -= (d * i);
							flag = 1;
					}
			}
			
			/* Null terminate the string. */
			*ptr = 0;
			
			return string;			
			break;		
		default:
			*ptr++ = 0x30;
			*ptr = 0;
			return string;
			break;
	}


} /* NCL_Itoa */
///  bits:生成的字符共几位数据
void Lc_int2D(vS16 value, char *string,char bits)
{
	vS16     i, d;
	UN_TYPE     flag = 0;
//	vU16    U16temp = 0;
	char    *ptr = string;
	
	/* This implementation only works for decimal numbers. */
	//value	

//		U16temp = value;
		/* if this is a negative value insert the minus sign. */
		if (value < 0)
		{
			*ptr++ = '-';
			value *= -1;
		}else
		{
			*ptr++ = ' ';

		}
		
		
		
		i = us2fun2[bits-1];
		for (;i > 0; i /= 10)
		{
			d = value / i;
			if((0 == d)&&(0 == flag)&&(1 != i))
			{///
				*ptr++ = ' ';
				
			}else
			{
				flag = 1;///第一个非零的数据出现
				*ptr = (char)(d + 0x30);
				*ptr++;
				value -= (d * i);
			}
		}

} /* NCL_Itoa */

 
//void (*L0_uart0_uc)(U8 ww);

//  带buf的printf  fixme:  需要精简地方 
void Lc_print_buf(char *dat4,...)
{
	const char *s;
	vS32 d;   
	char buf[64];	///取决于cpu的内存大小，如果出现问题，请先定位到此处
//	char send[16];
	char n = 0;
	char *dat = 0;
	va_list ap;//va_list 是一个字符指针，可以理解为指向当前参数的一个指针，
	//取参必须通过这个指针进行。
//<Step 1> 在调用参数表之前，定义一个 va_list 类型的变量，
//(假设va_list 类型变量被定义为ap)；
	va_start(ap, dat);
//	然后应该对ap 进行初始化，让它指向可变参数表里面的第一个参数，
//这是通过 va_start 来实现的，第一个参数是 ap 本身，第二个参数是在
//变参表前面紧挨着的一个变量,即“...”之前的那个参数；

	dat = dat4;
//	<Step 3> 然后是获取参数，调用va_arg，它的第一个参数是ap，
//第二个参数是要获取的参数的指定类型，然后返回这个指定类型的值，
//并且把 ap 的位置指向变参表的下一个变量位置；
	//"e645654675y73\0"
	while ( *dat != 0)     // 判断是否到达字符串结束符
	{				                          
		if ( *dat == 0x5c )  //'\'
		{									  
			switch ( *++dat )
			{
				case 'r':							          //回车符
					ts_uart_send_depot.buf[n ++] = 0x0d;//L0pf_send_uc(0x0d);
					dat ++;
				break;
				
				case 'n':							          //换行符
					ts_uart_send_depot.buf[n ++] = 0x0a;//L0pf_send_uc(0x0a);	
					dat ++;
				break;

				case 't':							          // 
					ts_uart_send_depot.buf[n ++] = 0x09;//L0pf_send_uc(0x09);	
					dat ++;
				break;				
				default:
					dat ++;
				break;
			}			 
		}
		else if ( *dat == '%')
		{									  //
			switch ( *++dat )
			{			
				case 'C':
				case 'c':										  //字符
				//va_arg()里的任务就是根据指定的参数类型
				//取得本参数的值，并且把指针调到下一
				//个参数的起始地址
				//#define va_arg(ap,t) 
				//( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) 

				//char *ap;   %c  " , 0x30,
					s = va_arg(ap, const char *);			//	0x30
					ts_uart_send_depot.buf[n ++] = (char)s;//	L0pf_send_uc((char)s);		//	'0'
					dat++;
				break;		
				case 'd':										//十进制
					//" %d",0x30,
					//" %d",48,
					// int i = 48;
					//" %d",i,

					d = va_arg(ap, int);		// 0x30 =48d
					Lc_int2a(d, buf, 10);			//"buf="48"  buf[0]='4'  buf[1]='8'
					for (s = buf; *s; s++) 			// "48"----'4'--'8'   '\0'--*s
					{			//\0
						ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s);
						//printf("%c",*s);
					}
					dat++;
				break;
				case 'X':				
				case 'x':										  //字符串
					d = va_arg(ap, int);		// 0x30 =48d
					dat++;//%X2 %X4 %X8
					Lc_int2a(d, buf, *dat);			//"buf="48"  buf[0]='4'  buf[1]='8'
					for (s = buf; *s; s++) 			// "48"----'4'--'8'   '\0'--*s
					{			//\0
						ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s);
					}
					dat++;
				break;			
				case 'S':				
				case 's':										  //字符串
					s = va_arg(ap, const char *);
					for ( ; *s; s++) 
					{
						ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s);
					}
					dat++;
				break;
				case 'f':										//十进制
					d = va_arg(ap, int);
					Lc_int2a(d, buf, 10);
					for (s = buf; *s; s++) 
					{
						ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s);

					}
					dat++;
				break;
				default:
					dat++;
				break;
			}		 
		} /* end of else if */
		else 
		{
			ts_uart_send_depot.buf[n ++] = (*dat++);//L0pf_send_uc( *dat++);
		}
	}//end while....
	ts_uart_send_depot.max = n;
	ts_uart_send_depot.p = ts_uart_send_depot.buf;
	L0_uart0_sendbuf();
}//
#endif

#ifdef D_use_crc16
/*
CRC码的步骤为：

(1).预置16位寄存器为FFFFH。称此寄存器为CRC寄存器；

(2).把第一个8位数据与CRC寄存器的低位相异或，把结果放于CRC寄存器；

(3).把寄存器的内容右移一位(朝低位)，用0填补最高位，检查最低位；

(4).如果最低位为0：重复第3步(再次移位)如果最低位为1：CRC寄存器与多项式A001（1010 0000 0000 0001）进行异或；

(5).重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理；

(6).重复步骤2到步骤5，进行下一个8位数据的处理；

(7).最后得到的CRC寄存器即为CRC码。(CRC码 = CRC_L +CRC_H)

*/


/*****************crc校验**********************************************/

//crc生成函数，并将crc存储在预先定于的数组中

//调用方式crc16（指向数据的指针，需要校验的数据长度）

unsigned char CRC[2];//定义数组

void crc16(unsigned char *ptr,unsigned int len)
{
	unsigned long wcrc=0XFFFF;//预置16位crc寄存器，初值全部为1
	unsigned char temp;//定义中间变量
	int i=0,j=0;//定义计数
	for(i=0;i<len;i++)//循环计算每个数据
	{
		temp=*ptr&0X00FF;//将八位数据与crc寄存器亦或
		ptr++;//指针地址增加，指向下个数据
		wcrc^=temp;//将数据存入crc寄存器
		for(j=0;j<8;j++)//循环计算数据的
		{
			if(wcrc&0X0001)//判断右移出的是不是1，如果是1则与多项式进行异或。
			{
				wcrc>>=1;//先将数据右移一位
				wcrc^=0XA001;//与上面的多项式进行异或
			}
			else//如果不是1，则直接移出
			{
				wcrc>>=1;//直接移出
			}
		}
	}
	temp=wcrc;//crc的值
	CRC[0]=wcrc;//crc的低八位
	CRC[1]=wcrc>>8;//crc的高八位
}
code U8 auchCRCHi[]=  
{  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,  
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,  
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,  
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,  
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,  
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,  
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,  
0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,  
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,  
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,  
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40  
};  
  
code U8 auchCRCLo[] =  
{  
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,  
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,  
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,  
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,  
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,  
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,  
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,  
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,  
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,  
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,  
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,  
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,  
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,  
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,  
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,  
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,  
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,  
0x40  
};  
  
U16 N_CRC16(U8 *updata,U8 len)  
{  
  U8 uchCRCHi=0xff;  
  U8 uchCRCLo=0xff;  
  U8  uindex;  
  while(len--)  
  {  
  uindex = uchCRCHi^*updata++;  
  uchCRCHi = uchCRCLo^auchCRCHi[uindex];  
  uchCRCLo = auchCRCLo[uindex];  
  }  
  return (uchCRCHi<<8 | uchCRCLo);  
}  

#endif
#if 0 //5436345673456
/******************************************************************** 
*
* 名称: L0_Usend_uc_hex
* 说明: 例如:L0_Usend_uc_hex(0x0c); output " 0c  " 
* 功能: 发送数据
* 调用: SendHUc（）Lc_HexToChar（）
* 输入:
* 返回值: 无
***********************************************************************/
void Lc_uc_hex(char ww)
{
	L0_uart0_uc(Lc_Hex2Char((ww>>4)&0x0f));
	L0_uart0_uc(Lc_Hex2Char(ww&0x0f));		
}

void Lc_us_hex(U16 ww)
{//
	U8 t;	
	t = (U8)(((ww >> 8)&0x00ff));
	Lcp_uc_hex(t);
	t = (U8)(((ww )&0x00ff));
	Lcp_uc_hex(t);		
}

void Lc_print_NC(char *dat,...)
{

}
// 非缓存模式的打印 fixme: 发送16进制数据时有bug
void Lc_print33333(char *dat4,...)
{
	const char *s;
	vS32 d;   
	char buf[16];//char t;
		char *dat = NULL;
	va_list ap;//va_list 是一个字符指针，可以理解为指向当前参数的一个指针，
	//取参必须通过这个指针进行。
//<Step 1> 在调用参数表之前，定义一个 va_list 类型的变量，
//(假设va_list 类型变量被定义为ap)；
	va_start(ap, dat4);
//	然后应该对ap 进行初始化，让它指向可变参数表里面的第一个参数，
//这是通过 va_start 来实现的，第一个参数是 ap 本身，第二个参数是在
//变参表前面紧挨着的一个变量,即“...”之前的那个参数；
dat =dat4;
//	<Step 3> 然后是获取参数，调用va_arg，它的第一个参数是ap，
//第二个参数是要获取的参数的指定类型，然后返回这个指定类型的值，
//并且把 ap 的位置指向变参表的下一个变量位置；
	//"e645654675y73\0"
	while ( *dat != 0)     // 判断是否到达字符串结束符
	{				                          
		if ( *dat == 0x5c )  //'\'
		{									  
			switch ( *++dat )
			{
				case 'r':							          //回车符
					L0_uart0_uc(0x0d);
					dat ++;
				break;
				
				case 'n':							          //换行符
					L0_uart0_uc(0x0a);	
					dat ++;
				break;

				case 't':							          // 
					L0_uart0_uc(0x09);	
					dat ++;
				break;				
				default:
					dat ++;
				break;
			}			 
		}
		else if ( *dat == '%')
		{									  //
			switch ( *++dat )
			{			
				case 'C':
				case 'c':										  //字符
				//va_arg()里的任务就是根据指定的参数类型
				//取得本参数的值，并且把指针调到下一
				//个参数的起始地址
				//#define va_arg(ap,t) 
				//( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) 

				//char *ap;   %c  " , 0x30,
					s = va_arg(ap, const char *);			//	0x30
						L0_uart0_uc((char)s);		//	'0'
					dat++;
				break;		
				case 'd':										//十进制
					//" %d",0x30,
					//" %d",48,
					// int i = 48;
					//" %d",i,  //#define va_arg(ap,t) (((t *)ap)++[0])  //(((int *)ap)++[0])

					d = va_arg(ap, int);		// 0x30 =48d
					d >>= 8;
					Lc_int2a(d, buf, 10);			//"buf="48"  buf[0]='4'  buf[1]='8'
					for (s = buf; *s; s++) 			// "48"----'4'--'8'   '\0'--*s
					{			//\0
						L0_uart0_uc(*s);
						//printf("%c",*s);
					}
					dat++;
				break;
				case 'X':				
				case 'x':										  //字符串
					d = va_arg(ap, int);		// 0x30 =48d
					d >>= 8;
					dat++;//%X2 %X4 %X8
					Lc_int2a(d, buf, *dat);			//"buf="48"  buf[0]='4'  buf[1]='8'
					for (s = buf; *s; s++) 			// "48"----'4'--'8'   '\0'--*s
					{			//\0
						L0_uart0_uc(*s);
					}
					dat++;
				break;			
				case 'S':				
				case 's':										  //字符串
					s = va_arg(ap, const char *);
					for ( ; *s; s++) 
					{
						L0_uart0_uc(*s);
					}
					dat++;
				break;
				case 'f':										//十进制
					d = va_arg(ap, int);
					Lc_int2a(d, buf, 10);
					for (s = buf; *s; s++) 
					{
						L0_uart0_uc(*s);

					}
					dat++;
				break;
				default:
					dat++;
				break;
			}		 
		} /* end of else if */
		else 
		{
			L0_uart0_uc(*dat ++);
			//t = *dat;
			//L0pf_send_uc = L0_uart0_uc;
			//L0pf_send_uc(t);
			//L0_uart0_uc(t);
			//dat++;
		}
	}//end while....斯蒂芬
}//





///计算CRC校验码	
unsigned int CRC16(unsigned char *ptr, unsigned char len)
{
   unsigned int crc=0xffff;
   unsigned char i;
   while(len--)
   {
       crc ^=*ptr++;
       for(i=0;i<8;i++)
	   {
	       if(crc & 0x1)
		   {
		      crc>>=1;
			  crc^=0xa001;
		   }
		   else
		   {
		      crc>>=1;
		   }
	   }
   }
   return crc;
}



///检测CRC校验码是否正确
unsigned char CheckCRC(unsigned char *ptr,unsigned char len)
{
	unsigned int crc;
	crc = (unsigned int)CRC16(ptr,(len-2));
	if(ptr[len-1]==(crc>>8) && ptr[len-2]==(crc & 0x00ff))
	{
		return 0xff;
	}
	else
	{
		return 0x0;
	}
}


char *strstr(const char *str1, const char *str2)
{
    char *cp = (char*)str1;
    char *s1, *s2;
 
    if (!*str2)
        return((char *)str1);
 
    while (*cp)
    {
        s1 = cp;
        s2 = (char *)str2;
 
        while (*s1 && *s2 && !(*s1 - *s2))
            s1++, s2++;
 
        if (!*s2)
            return(cp);
 
        cp++;
    }
    return(NULL);
}



//12,34
void Lc_int2str_2_2(U32 ui_in,char *d)
{
	U8  m = 0;//,i; 

	if (ui_in >= ul2fun2[4])//  1000    123456  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(4));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}	
	if (ui_in >= ul2fun2[3])//  1000    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[2])//  100    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = '0';
		m  ++;
	}

	*(d+m) = '.';
	m  ++;
	if (ui_in >= ul2fun2[1])//  10    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = '0';
		m  ++;
	}
	*(d+m) = 0x30 + Lc_WEI(ui_in,0);

} 



// 123.4

void Lc_int2str_3_1(U32 ui_in,char *d)
{
	U8  m = 0;//,i; 
	if (ui_in >= ul2fun2[4])//  1000    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(4));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	
	if (ui_in >= ul2fun2[3])//  1000    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[2])//  100    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[1])//  10    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = '0';
		m  ++;
	}
	*(d+m) = '.';
	m  ++;
	*(d+m) = 0x30 + Lc_WEI(ui_in,0);

} 


//-123
void Lc_sint2str_3(int i_in,char *d)
{
	U8  m = 0;//,i; 
	U32 ui_in;
	if(i_in < 0)
	{
		ui_in = (U32)(0-i_in);
		*(d+m) = '-';
	}else
	{
		ui_in = (U32)(i_in);
		*(d+m) = ' ';
	}
	m  ++;
	
	if (ui_in >= ul2fun2[2])//  100    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[1])//  10    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}
	*(d+m) = 0x30 + Lc_WEI(ui_in,0);
} 


// 12345

void Lc_int2str_5(U32 ui_in,char *d)
{
	U8  m = 1;//,i; 
	*(d+0) = ' ';
	if (ui_in >= ul2fun2[4])//  10,000    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(4));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}


	if (ui_in >= ul2fun2[3])//  1,000    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[2])//  100    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[1])//  10    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	*(d+m) = 0x30 + Lc_WEI(ui_in,0);

} 
//40 
void Lc_int2str_4(U32 ui_in,char *d)
{
	U8  m = 0;//,i; 

	if (ui_in >= ul2fun2[3])//  1,000    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[2])//  100    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[1])//  10    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}
	*(d+m) = 0x30 + Lc_WEI(ui_in,0);
} 


//  123
void Lc_int2str_3(U32 ui_in,char *d)
{
	U8  m = 0;//,i; 

	if (ui_in >= ul2fun2[2])//  100    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}

	if (ui_in >= ul2fun2[1])//  10    12345  
	{
		*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
		m  ++;
	}
	else			
	{
		*(d+m) = ' ';
		m  ++;
	}
	*(d+m) = 0x30 + Lc_WEI(ui_in,0);
} 


//Lc_int2str(123456,	5,3,&str[0]');
/*


blank 填充字符  ' '或者其他unsigned char *blank)//保留以后使用


*/



void Lc_int2str(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d)
{
	U8  m = 0,i; 
	for(i = 0;i < len;i++)
	{
		if(point != 0)
		{
			if(point == (len-i+1))
			{
				*(d+m) = '.';
				m  ++;
			}
		}	
		if (ui_in>=ul2fun2[len-i])
		{
			*(d+m) = 0x30 + Lc_WEI(ui_in,(len-i));// (unsigned char)((ui_in/ul2fun2[len-i])%10); 
			m  ++;
		}
		else			
		{
			*(d+m) = ' ';
			m  ++;
		}
	}
	*(d+m) = 0x30 + Lc_WEI(ui_in,1);
	m++;
	*(d+m) = 0x00;
	//*(d+m) = 'e';
} 


// input:  123456d
// output: '1' '2'  '3'.... 
//对应的点阵 为 0123456789. ，最后为空格，专为显示点阵类的数值使用
void Lc_int2number(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d)
{
	U8  i,m = 0; //uc_temp,
	for(i = len+1;i != 0;i--)// len + 1 point 占用一位
	{
		if(point == (len-i))
		{
			d[len-m] = '.';//'.'
			m ++;
		}
		{
			if (ui_in>=ul2fun2[i-1])
			{
				d[len-m] = (U8)((ui_in/ul2fun2[i-1])%10); 
				
			}
			else			
			{
				d[len-m] = ' ';//' '
			}
			m ++;
		}
	}	
	d[len-m] = (U8)(ui_in%10);
} 

void Lc_Byte_cp(BYTE *src,BYTE *dis, int len)
{
	int i;
	for(i = 0; i < len ;i ++)
	{
		*dis = *src;
		dis ++;
		src ++;
	}
	//return 0;
}
/*
void Lc_Byte_print(BYTE *src,int len)
{
	int     i, d;
	for(i = 0; i < len ;i ++)
	{
		*dis = *src;
		dis ++;
		src ++;
	}
	//return 0;
}
*/


//  -10........+10

U32 L2_fun_number_show(int i,char str[4])
{
	U8 c;
	int cint;

	if(i >= 0)
	{
		cint = i;
		str[0] =' ';

	}
	else
	{
		cint = 0 - i;
		str[0] ='-';

		
	}
	c = Lc_WEI(cint,1);
	if(0 == c)
	{
		str[1] =' ';
	}
	else
	{
		str[1] = 0x30+ c;

	}
	str[2] = 0x30+ Lc_WEI(cint,0);
	return 0;
}

//L1_lkt_write(s_room_val.ui_t3,s_room_val.ui_t3,s_task_lkt.din);
//U_uluiuc

void Lc_2ui2buf(vU32 ui_t2,vU32 ui_t3,volatile BYTE out[])
{
#if 0
	volatile U_uluiuc t;
	//s_temp[]
	t.uiv[0] = ui_t2;
	t.uiv[1] = ui_t3;
 
	
	Lc_Byte_cp(t.dv,out,8);

	out[3] = D_ul2uc_0( ui_t2);
	ui_t2 >>= 8;
	out[2] = D_ul2uc_0( ui_t2);
	ui_t2 >>= 8;
	out[1] = D_ul2uc_0( ui_t2);
	ui_t2 >>= 8;
	out[0] = D_ul2uc_0( ui_t2);
	
	
	out[7] = D_ul2uc_0( ui_t3);
	ui_t2 >>= 8;
	out[6] = D_ul2uc_0( ui_t3);
	ui_t2 >>= 8;
	out[5] = D_ul2uc_0( ui_t3);
	ui_t2 >>= 8;
	out[4] = D_ul2uc_0( ui_t3);

	
	#else
	out[0] = D_ul2uc_0( ui_t2);
	ui_t2 >>= 8;
	out[1] = D_ul2uc_0( ui_t2);
	ui_t2 >>= 8;
	out[2] = D_ul2uc_0( ui_t2);
	ui_t2 >>= 8;
	out[3] = D_ul2uc_0( ui_t2);
	
/*	
	out[4] = D_ul2uc_0( ui_t3);
	ui_t2 >>= 8;
	out[5] = D_ul2uc_0( ui_t3);
	ui_t2 >>= 8;
	out[6] = D_ul2uc_0( ui_t3);
	ui_t2 >>= 8;
	out[7] = D_ul2uc_0( ui_t3);
*/
#endif
	
}

void L1_buf22ui(volatile BYTE in[],vU32 *ui_t2,vU32 *ui_t3)
{
	#if 0
	volatile U_uluiuc t;
	Lc_Byte_cp(in,t.dv,8);
	*ui_t2 = t.uiv[0];
	*ui_t3 = t.uiv[1];
	*ui_t2 = 0;
	*ui_t2|= (U32)in[3];
	*ui_t2|= (U32)(in[2]<<8);
	*ui_t2|= (U32)(in[1]<<16);
	*ui_t2|= (U32)(in[0]<<24);
	
	*ui_t3 = 0;
	*ui_t3|= (U32)in[7];
	*ui_t3|= (U32)(in[6]<<8);
	*ui_t3|= (U32)(in[5]<<16);
	*ui_t3|= (U32)(in[4]<<24);

	#else


	*ui_t2 = 0;
	*ui_t2|= (U32)in[0];
	*ui_t2|= (U32)(in[1]<<8);
	*ui_t2|= (U32)(in[2]<<16);
	*ui_t2|= (U32)(in[3]<<24);
	/*
	*ui_t3 = 0;
	*ui_t3|= (INT32U)in[4];
	*ui_t3|= (INT32U)(in[5]<<8);
	*ui_t3|= (INT32U)(in[6]<<16);
	*ui_t3|= (INT32U)(in[7]<<24);
	*/
	#endif
}
 
U32 Lc_abs(vU32 a,vU32 b,vU32 *diff)
{
	if(a >= b)
	{
		*diff = a-b;
		return 1;
	}else
	{
		*diff = b-a;
		return 0;
	}
}





#endif //#if 0 //5436345673456

/******************************************************************************
**                            End Of File
******************************************************************************/