ccsens_hardware
/
stc_ttss_encryption
2
0
Fork 3
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
2 Branches
0 Tags
263 KiB
Tree: 138768dd65
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '138768dd65'
${ noResults }
stc_ttss_encryption/source/clib/clib.c

1687 lines
33 KiB
Raw Normal View History

v1.0
5 years ago
/*****************************************************************************
* 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"
#if 0
vU16 us2fun2[5]
={
1, //0
10,// 1
100,// 2
1000,// 3
10000// 4
};
vU32 ul2fun2[10]
={
1, //0
10,// 1
100,// 2
1000,// 3
10000,// 4
100000,
1000000,
10000000,
100000000,
1000000000,//9
};
同样是转义字符，\n 的作用相当于“Enter”键，而想退回去就可以用“Backspace”键，也就是\b
这里还有一个可能用到的转义字符是\r ：使光标回退到本行开头
\b 退格
\n 换行 0x0A
\f 走纸
\t 水平制表
\v 垂直制表
\r 0x0d
//如果追求内存紧张加上const INT32U ul2fun2[10]
void Lc_float2str(float f,U8 *str,U8 point_num);
{
S32 i = 0; U32 u32i = 0;
U8 n = 0;U8 m = 0;U8 d = 0;
switch(point_num)
{
case 0:
break;
case 1:
f *= 10.;
break;
case 2:
f *= 100.;
break;
case 3:
f *= 1000.;
break;
default:
break;
};
i = (S32)f;
// Lc_float2str(1.23,&d,2)
// Lc_float2str(0.23,&d,2)
// Lc_float2str(23.4,&d,1)
// Lc_float2str(-12345.236,&d,2)
// 1,1.2 12.3 240 0.12
if(i < 0)
{
str[n] = '-';
n ++;
i *= -1;
}
u32i = (U32)i;
m = 4;
if(u32i >= ul2fun2[m]) u32i = ul2fun2[m] - 1;
for(m = 0;m > 4;m ++)
{// 43210
d = (u32i /ul2fun2[m])%10;
if (d > 0)
str[n] = d;
n ++;
}
if (n == point_num)
{
str[n] ='.';
n ++;
}
str[n] = i%10
}
void L0_Delay_ms(unsigned int time)
{
unsigned int j;
for(;time > 0;time --)
{
j = D_l0_delay_ms;
while(j--)
;
}
}
//22m 50ms --delay ms 100 j=150
void L1_delay_test(void)
{
while(9)
{
L0_Delay_ms(100);
P2 = !P2;
}
}void Lc_delay_us(unsigned int n)
{
// unsigned char j;
for(;n > 0;n --)
{
//j = 2;
// while(j--)
// ;
}65 300
}
#endif
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 *d,const U8 *s,U16 num)
{
U16 i;
for(i = 0; i < num; i ++)
{
*(d+i) = *(s+i);
}
}
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];
}
}
///// 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)
{
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的高八位
}
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;
}
}
#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
v1.2
4 years ago
int Lc_memset(U8 *buf,U8 c,U16 len)
{
U16 i;
for(i=0;i<len;i++)
{
buf[i] = c;
}
return 0;
}
v1.0
5 years ago
/******************************************************************************
** End Of File
******************************************************************************/