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.
1851 lines
36 KiB
1851 lines
36 KiB
/*****************************************************************************
|
|
* 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
///despiking 削峰
|
|
void Lc_despiking_shift3_U16(vU16 *m)
|
|
{///只要中间的数据同时大于或小于两边的数据，则去掉
|
|
if(m[1] >= m[0])
|
|
{
|
|
if(m[1] > m[2])
|
|
{
|
|
m[1] = m[0];
|
|
}
|
|
}else if(m[1] < m[0])
|
|
{
|
|
if(m[1] < m[2])
|
|
{
|
|
m[1] = m[0];
|
|
}
|
|
}else
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
#if 0 ///保留 不要删除
|
|
void Lc_U16_shift_media3(vU16 *m);//,vU16 m[1],vU16 m[2])
|
|
{
|
|
if(m[0] > m[1])
|
|
{
|
|
if(m[1] > m[2])
|
|
{
|
|
m[1] = m[0];
|
|
}else
|
|
{// m[1]<m[0] m[1]< m[2]
|
|
if(m[2] > m[0])
|
|
{/// m[0]<m[2]
|
|
m[0] = m[1];
|
|
}else
|
|
{// m[2]<=m[0]
|
|
m[2] = m[1];
|
|
}
|
|
}
|
|
}else
|
|
{// m[0]<=m[1]
|
|
if(m[1] < m[2])
|
|
{
|
|
m[1] = m[0];
|
|
}else
|
|
{// m[0]<=m[1] m[2] <= m[1]
|
|
if(m[2] > m[0])
|
|
{// m[0]<m[2] m[1]
|
|
m[2] = m[1];
|
|
}else
|
|
{// m[2]<=m[0] m[1]
|
|
m[0] = m[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
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];
|
|
}
|
|
}
|
|
vS32 Lc_vS32_media(vS32 *d, U8 n)
|
|
{
|
|
U8 i = 0,j = 0;
|
|
vS32 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);
|
|
}
|
|
}
|
|
|
|
|
|
S32 Lc_vS32_avg(vS32 *d, U8 n)
|
|
{
|
|
U8 i = 0;
|
|
S32 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 crc16qq(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的高八位
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
int libc_strlen(char *str)
|
|
{
|
|
char *tmp = str;
|
|
while(*tmp++)
|
|
;
|
|
return tmp - str - 1;
|
|
}
|
|
|
|
|
|
#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
|
|
******************************************************************************/
|
|
|
|
|