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.
1828 lines
31 KiB
1828 lines
31 KiB
/*****************************************************************************
|
|
* uart.c: UART API file for NXP LPC17xx Family Microprocessors
|
|
*
|
|
* Copyright (c) 2023 CCSENS
|
|
* All rights reserved.
|
|
*
|
|
* History
|
|
* 2009.05.27 ver 1.00 Prelimnary version, first Release
|
|
///cc 2023/04/08--11:25:5 Lc_buf_from_const_uc
|
|
*
|
|
******************************************************************************/
|
|
|
|
|
|
#include "c_type51.h"
|
|
#include "c_lib.h"
|
|
///#include "../msp/msp_uart0.h"
|
|
////#include "../msp/time.h"
|
|
#include <stdarg.h>
|
|
|
|
|
|
code vU16 us2fun2[5]
|
|
={
|
|
1, //0
|
|
10,// 1
|
|
100,// 2
|
|
1000,// 3
|
|
10000// 4
|
|
|
|
};
|
|
|
|
|
|
|
|
code vU32 ul2fun2[10]
|
|
={
|
|
1, //0
|
|
10,// 1
|
|
100,// 2
|
|
1000,// 3
|
|
10000,// 4
|
|
100000,
|
|
1000000,
|
|
10000000,
|
|
100000000,
|
|
1000000000,//9
|
|
};
|
|
|
|
#if 0
|
|
|
|
同样是转义字符，\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
|
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|
|
U32 Abs2(S32 a)
|
|
{
|
|
if(a < 0)
|
|
{
|
|
a = -a;
|
|
}
|
|
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
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
int libc_strlen(char *str)
|
|
{
|
|
char *tmp = str;
|
|
while(*tmp++)
|
|
;
|
|
return tmp - str - 1;
|
|
}
|
|
|
|
U8* Lc_strcpy(U8* dst,const char* str)
|
|
{
|
|
U8 *p = dst;
|
|
while(*dst++ = *str++);
|
|
return p;
|
|
}
|
|
|
|
|
|
U8 Lc_strStartsWith(U8 *s1,U8 *s2)
|
|
{
|
|
while(*s1 && *s2)
|
|
{
|
|
if(*s1++ != *s2++)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return (*s2 == 0);
|
|
}
|
|
|
|
|
|
int hexToDec(const char *source)
|
|
{
|
|
int sum = 0;
|
|
long t = 1;
|
|
int i,len;
|
|
|
|
len = Lc_strlen(source);
|
|
for(i=len-1; i>=0; i--)
|
|
{
|
|
sum += t * getIndexOfSigns(*(source + i));
|
|
t *= 16;
|
|
}
|
|
|
|
return sum;
|
|
|
|
}
|
|
unsigned char hex_to_char(unsigned char hex)
|
|
{
|
|
if((hex>=0x30)&&(hex<=0x39))
|
|
hex = hex-0x30;
|
|
else if((hex>=0x41)&&(hex<=0x5A)) // capital
|
|
hex = 'A' + (hex - 0x41);
|
|
else if((hex>=0x61)&&(hex<=0x7A)) // little case
|
|
hex = 'a' + (hex - 0x61);
|
|
else
|
|
hex = 0xff;
|
|
return hex;
|
|
}
|
|
|
|
int getIndexOfSigns(char ch)
|
|
{
|
|
if(ch >= '0' && ch <= '9')
|
|
{
|
|
return ch - '0';
|
|
}
|
|
if(ch >= 'A' && ch <='F')
|
|
{
|
|
return ch - 'A' + 10;
|
|
}
|
|
if(ch >= 'a' && ch <= 'f')
|
|
{
|
|
return ch - 'a' + 10;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void Lc_buf_copy_us(U16 *d,const U16 *s,U16 num)
|
|
{
|
|
U16 i;
|
|
for(i = 0; i < num; i ++)
|
|
{
|
|
*(d+i) = *(s+i);
|
|
}
|
|
|
|
}
|
|
void Lc_buf_from_const_uc(U8 *d,const U8 *s,U16 num)
|
|
{
|
|
U16 i;
|
|
for(i = 0; i < num; i ++)
|
|
{
|
|
*(d+i) = *(s+i);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
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];
|
|
}
|
|
}
|
|
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 Lc_for_int16(U16 i)
|
|
{
|
|
U16 m;
|
|
for(m=i;m>0;m--)
|
|
{
|
|
///L0_Delay_1ms();
|
|
}
|
|
}
|
|
|
|
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(const char *str)
|
|
{
|
|
int i;
|
|
i = 0;
|
|
while((*str++)!='\0')
|
|
{
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
u8 Lc_ocr8(const u8 *d,u8 len)
|
|
{
|
|
unsigned char i = 0;
|
|
u16 sum = 0;
|
|
for(i = 0;i < len;i ++)
|
|
{
|
|
sum += *d;
|
|
d ++;
|
|
}
|
|
return ((u8)(sum&0x00ff));
|
|
}
|
|
|
|
|
|
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
|
|
|
|
#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);
|
|
}
|
|
|
|
|
|
//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;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static U8 count_n(u8 n,u8 d)
|
|
{
|
|
if(n < d)
|
|
{
|
|
return MAX_OUT_NUM + n - d ;
|
|
}
|
|
else
|
|
{
|
|
return n-d;
|
|
}
|
|
}
|
|
|
|
U32 Abs(S32 a)
|
|
{
|
|
if(a < 0)
|
|
{
|
|
a = -a;
|
|
}
|
|
return a;
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif //#if 0 //5436345673456
|
|
|
|
|
|
|
|
//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);
|
|
|
|
m ++;
|
|
*(d+m) = 0;
|
|
|
|
}
|
|
|
|
/// 0-999
|
|
void Lc_int2str_3(U32 ui_in,char *d)
|
|
{
|
|
U8 m = 0;//,i;
|
|
if (ui_in >= ul2fun2[3])
|
|
{
|
|
ui_in = 999;
|
|
}
|
|
if (ui_in >= ul2fun2[2])// 100 12345
|
|
{
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10);
|
|
}
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
*(d+m) = ' ';
|
|
}
|
|
m ++;
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,0);
|
|
m ++;
|
|
*(d+m) = 0;
|
|
}
|
|
/// 0-99
|
|
void Lc_int2str_2(U32 ui_in,char *d)
|
|
{
|
|
U8 m = 0;//,i;
|
|
if (ui_in >= ul2fun2[2])
|
|
{
|
|
ui_in = 99;
|
|
}
|
|
|
|
if (ui_in >= ul2fun2[1])// 10 12345
|
|
{
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10);
|
|
}
|
|
else
|
|
{
|
|
*(d+m) = ' ';
|
|
}
|
|
m ++;
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,0);
|
|
m ++;
|
|
*(d+m) = 0;
|
|
}
|
|
void Lc_uc2str_2(U8 ui_in,char *d)
|
|
{
|
|
U8 m = 0;//,i;
|
|
if (ui_in >= ul2fun2[2])
|
|
{
|
|
ui_in = 99;
|
|
}
|
|
|
|
if (ui_in >= ul2fun2[1])// 10 12345
|
|
{
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10);
|
|
}
|
|
else
|
|
{
|
|
*(d+m) = ' ';
|
|
}
|
|
m ++;
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,0);
|
|
m ++;
|
|
*(d+m) = 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);
|
|
m ++;
|
|
*(d+m) = 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);
|
|
}
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
*(d+m) = ' ';
|
|
}
|
|
m ++;
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,0);
|
|
m ++;
|
|
*(d+m) = 0;
|
|
}
|
|
|
|
//-32.1
|
|
void Lc_sint2str_2_1(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[3])// 1000 12345
|
|
{
|
|
ui_in = 999;
|
|
}
|
|
|
|
if (ui_in >= ul2fun2[2])// 100 12345
|
|
{
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10);
|
|
}
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
*(d+m) = '0';
|
|
}
|
|
m ++;
|
|
*(d+m) = '.';
|
|
m ++;
|
|
*(d+m) = 0x30 + Lc_WEI(ui_in,0);
|
|
m ++;
|
|
*(d+m) = 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);
|
|
|
|
}
|
|
|
|
/******************************************************************************
|
|
** End Of File
|
|
******************************************************************************/
|
|
|
|
|