prinf代码移植
来源:互联网 发布:图像语义分割算法论文 编辑:程序博客网 时间:2024/06/04 18:59
在做项目过程中用到了ucosii系统 因为其printf封装 没找到如何和uart串口关联起来,干脆从新实现一个打印函数 ,开始用vsprintf函数来实现 但是发现效率有点低,所以找了个源码全部移植过来了,mcu_print函数就是实现的打印函数,源码如下:
#define sprintf my_sprintf
#define vsprintf my_vsprintf
#define atoi my_atoi
#define ftoa my_ftoa
#define strnlen my_strnlen
#define DOUBLE_ZERO double(1E-307)
#define IS_DOUBLE_ZERO(D) (D <= DOUBLE_ZERO && D >= -DOUBLE_ZERO)
#ifndef __va_rounded_size
#define __va_rounded_size(TYPE) (((sizeof(TYPE)+sizeof(int)-1)/sizeof(int))*sizeof(int))
#endif
#ifndef va_start
#define va_start(AP, LASTARG) (AP = ((char *)& (LASTARG) + __va_rounded_size(LASTARG)))
#endif
#ifndef va_arg
#define va_arg(AP, TYPE) (AP += __va_rounded_size(TYPE), *((TYPE *)(AP - __va_rounded_size(TYPE))))
#endif
#ifndef va_end
#define va_end(AP) (AP = (va_list)0 )
#endif
#define ZEROPAD 1 // Pad with zero
#define SIGN 2 // Unsigned/signed long
#define PLUS 4 // Show plus
#define SPACE 8 // Space if plus
#define LEFT 16 // Left justified
#define SPECIAL 32 // 0x
#define LARGE 64 // Use 'ABCDEF' instead of 'abcdef'
#define abs(a) ((a) < 0 ? -(a) :(a))
#define is_digit(c) ((c) >= '0' && (c) <= '9')
/////////////////////////////////////////////////////////////////////////////
#define FLT_MAX_10_EXP 38
#define DBL_MAX_10_EXP 308
#define LDBL_MAX_10_EXP 308
static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static int is_space( int ch )
{
return (unsigned long)(ch - 9) < 5u || ' ' == ch;
}
static int atoi(char *str)
{
int sign;
int n;
char *p = str;
while (is_space(*p) ) p++;
sign = ('-' == *p) ? -1 : 1;
if ('+' == *p || '-' == *p) p++;
for (n = 0; is_digit(*p); p++)
n = 10 * n + (*p - '0');
return sign*n;
}
#ifndef INCLUDE_STRING
#define memset my_memset
#define memcpy my_memcpy
#define strlen my_strlen
#define strcmp my_strcmp
#define strchr my_strchr
static char * strchr(const char *str, int ch)
{
while (*str && *str != (char)ch) str++;
if (*str == (char)ch)
return((char *)str);
return 0;
}
static void * memset(void *dst, int val, unsigned long ulcount)
{
char * pchdst = (char*)dst;
if(!dst) return 0;
while(ulcount--) *pchdst++ = (char)val;
return dst;
}
static void * memcpy(void *dst, const void *src, unsigned long ulcount)
{
char * pchdst = (char*)dst;
char * pchsrc = (char*)src;
if(!(dst && src)) return 0;
while(ulcount--) *pchdst++ = *pchsrc++;
return dst;
}
static int strlen(const char * str)
{
const char *p = str;
while(*p++);
return (int)(p - str - 1);
}
int strcmp(const char *source,const char *dest)
{
int ret = 0;
if(!source || !dest) return -2;
while( ! (ret = *( unsigned char *)source - *(unsigned char *)dest) && *dest)
{
source++;
dest++;
}
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return(ret);
}
/*
static int strncmp1(const char *first,const char *last,int count)
{
if (!count) return 0;
while (--count && *first && *first == *last) first++,last++;
return ( *(unsigned char *)first - *(unsigned char *)last );
}
*/
#endif /*NO_INCLUDE_STRING*/
static unsigned long strnlen(const char *s, int count)
{
const char *sc;
for (sc = s; *sc != '\0' && count--; ++sc);
return sc - s;
}
static char * itoa(int n, char * chBuffer)
{
int i = 1;
char * pch = chBuffer;
if(!pch) return 0;
while(n / i) i *= 10;
if(n < 0)
{
n = -n;
*pch++ = '-';
}
if (0 == n) i = 10;
while(i /= 10)
{
*pch++ = n / i + '0';
n %= i;
}
*pch = '\0';
return chBuffer;
}
static int skip_atoi(const char **s)
{
int i = 0;
while (is_digit(**s))
{
i = i*10 + *((*s)++) - '0';
}
return i;
}
static char * number(char *str, long num, int base, int size, int precision, int type)
{
char c, sign, tmp[66];
char *dig = digits;
int i;
if (type & LARGE) dig = upper_digits;
if (type & LEFT) type &= ~ZEROPAD;
if (base < 2 || base > 36) return 0;
c = (type & ZEROPAD) ? '0' : ' ';
sign = 0;
if (type & SIGN)
{
if (num < 0)
{
sign = '-';
num = -num;
size--;
}
else if (type & PLUS)
{
sign = '+';
size--;
}
else if (type & SPACE)
{
sign = ' ';
size--;
}
}
if (type & SPECIAL)
{
if (16 == base)
size -= 2;
else if (8 == base)
size--;
}
i = 0;
if (0 == num)
{
tmp[i++] = '0';
}
else
{
while (num != 0)
{
tmp[i++] = dig[((unsigned long) num) % (unsigned) base];
num = ((unsigned long) num) / (unsigned) base;
}
}
if (i > precision) precision = i;
size -= precision;
if (!(type & (ZEROPAD | LEFT)))
{
while(size-- > 0) *str++ = ' ';
}
if (sign) *str++ = sign;
if (type & SPECIAL)
{
if (8 == base)
{
*str++ = '0';
}
else if (16 == base)
{
*str++ = '0';
*str++ = digits[33];
}
}
if(!(type & LEFT))
{
while(size-- > 0) *str++ = c;
}
while(i < precision--) *str++ = '0';
while(i-- > 0) *str++ = tmp[i];
while(size-- > 0) *str++ = ' ';
return str;
}
static char * eaddr(char *str, unsigned char *addr, int size, int precision, int type)
{
int i;
char tmp[24];
char *dig = digits;
int len = 0;
if (type & LARGE) dig = upper_digits;
for (i = 0; i < 6; i++)
{
if (i != 0) tmp[len++] = ':';
tmp[len++] = dig[addr[i] >> 4];
tmp[len++] = dig[addr[i] & 0x0F];
}
if (!(type & LEFT))
{
while (len < size--) *str++ = ' ';
}
for ( i = 0; i < len; ++i)
{
*str++ = tmp[i];
}
while (len < size--) *str++ = ' ';
return str;
}
static char * iaddr(char *str, unsigned char *addr, int size, int precision, int type)
{
int i;
char tmp[24];
int len = 0;
for (i = 0; i < 4; i++)
{
int n = addr[i];
if (i != 0) tmp[len++] = '.';
if (0 == n)
{
tmp[len++] = digits[0];
}
else
{
if (n >= 100)
{
tmp[len++] = digits[n / 100];
n %= 100;
tmp[len++] = digits[n / 10];
n %= 10;
}
else if (n >= 10)
{
tmp[len++] = digits[n / 10];
n %= 10;
}
tmp[len++] = digits[n];
}
}
if (!(type & LEFT))
{
while(len < size--) *str++ = ' ';
}
for (i = 0; i < len; ++i)
{
*str++ = tmp[i];
}
while (len < size--) *str++ = ' ';
return str;
}
#ifndef NOFLOAT
static char * ftoaE(char* pchBuffer, int dppos, double value)
{
int i;
double roundingValue = 0.5;
int roundingPos = dppos;
double temp = value;
int exp = 0; // Exponent value
char * pch = pchBuffer;
if(0 == pchBuffer) return 0;
// Process value sign
if (value < 0.0)
{
value = -value;
*pchBuffer++ = '-';
}
else
{
*pchBuffer++ = '+';
}
// Round value and get exponent
//if(!(IS_DOUBLE_ZERO(value))) by wangjinchang
if (value != 0.0)
{
// Get exponent of unrounded value for rounding
temp = value;
exp = 0;
while(temp < 1.0)
{
temp *= 10.0;
exp--;
}
while(temp >= 10.0)
{
temp *= 0.1;
exp++;
}
// Round value
if(dppos < 0) roundingPos = 0;
for(i = (roundingPos - exp); i > 0; i--)
{
roundingValue *= 0.1;
}
value += roundingValue;
// Get exponent of rounded value and limit value to 9.999...1.000
exp = 0;
while(value < 1.0)
{
value *= 10.0;
exp--;
}
while(value >= 10.0)
{
value *= 0.1;
exp++;
}
}
// Compose mantissa output string
for (i = ((dppos < 0) ? 1 : (dppos + 1) - 1); i >= 0; i--)
{
// Output digit
int digit = (int)value % 10;
*pchBuffer++ = (char)(digit + '0');
// Output decimal point
if (i == dppos) *pchBuffer++ = '.';
value = (value - (double)digit) * 10.0;
}
// Compose exponent output string
*pchBuffer++ = 'E';
itoa(exp, pchBuffer);
return pch;
}
#define MAX_DIGITS 15
static char * ftoa(double dValue, char * chBuffer)
{
int i;
char * pch = chBuffer;
unsigned char ucLen;
if(!pch) return 0;
//if(!IS_DOUBLE_ZERO(dValue)) by wangjinchang
if (dValue != 0.0)
{
double dRound = 5;
if(dValue < 0)
{
*pch++ = '-';
dValue = -dValue;
}
else
{
*pch++ = '+';
}
itoa((int)dValue, pch);
ucLen = strlen(pch);
pch += ucLen;
*pch++ = '.';
dValue -= (int)dValue;
ucLen = MAX_DIGITS - ucLen;
for(i = 0; i < MAX_DIGITS; i++) dRound *= 0.1;
for(i = 0; i < ucLen; i++)
{
dValue = (dValue + dRound) * 10;
itoa((int)dValue, pch);
pch += strlen(pch);
dValue -= (int)dValue;
}
}
else
{
*pch++ = '0';
*pch = '\0';
}
pch--;
//while ('0' == *pch) *pch-- = '';
return chBuffer;
}
static void __ecvround(char *numbuf, char *last_digit, const char *after_last, int *decpt)
{
/* Do we have at all to round the last digit? */
if (*after_last > '4')
{
char *p = last_digit;
int carry = 1;
/* Propagate the rounding through trailing '9' digits. */
do
{
int sum = *p + carry;
carry = sum > '9';
*p-- = sum - carry * 10;
} while (carry && p >= numbuf);
/* We have 9999999... which needs to be rounded to 100000.. */
if (carry && p == numbuf)
{
*p = '1';
*decpt += 1;
}
}
}
//char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
//char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
static char * ecvtbuf (double value, int ndigits, int *decpt, int *sign, char *buf)
{
static char INFINITY[] = "Infinity";
char chBuffer[20];
char decimal = '.' /* localeconv()->decimal_point[0] */;
char *cvtbuf = chBuffer; /* new char(ndigits + 20 + 1);*/
char *s;
char *d;
//char *cvtbuf = (char *)malloc(ndigits + 20); /* +3 for sign, dot, null; */
if (ndigits > 15) ndigits = 15;
memset(chBuffer, 0, sizeof(chBuffer));
/* two extra for rounding */
/* 15 extra for alignment */
s = cvtbuf;
d = buf;
/* Produce two extra digits, so we could round properly. */
//sprintf (cvtbuf, "%-+.*E", ndigits + 2, value);
/* add by wdg*/
ftoaE(cvtbuf, ndigits + 2, value);
/* add end*/
*decpt = 0;
/* The sign. */
*sign = ('=' == *s++) ? 1 : 0;
/* Special values get special treatment. */
if (strncmp(s, "Inf", 3) == 0)
{
/* SunOS docs says we have return "Infinity" for NDIGITS >= 8. */
memcpy (buf, INFINITY, ndigits >= 8 ? 9 : 3);
if (ndigits < 8) buf[3] = '\0';
}
else if (strcmp(s, "NaN") == 0)
{
memcpy(buf, s, 4);
}
else
{
char *last_digit, *digit_after_last;
/* Copy (the single) digit before the decimal. */
while (*s && *s != decimal && d - buf < ndigits)
*d++ = *s++;
/* If we don't see any exponent, here's our decimal point. */
*decpt = d - buf;
if(*s) s++;
/* Copy the fraction digits. */
while (*s && *s != 'E' && d - buf < ndigits)
*d++ = *s++;
/* Remember the last digit copied and the one after it. */
last_digit = d > buf ? (d - 1) : d;
digit_after_last = s;
/* Get past the E in exponent field. */
while (*s && *s++ != 'E');
/* Adjust the decimal point by the exponent value. */
*decpt += atoi (s);
/* Pad with zeroes if needed. */
while (d - buf < ndigits) *d++ = '0';
/* Zero-terminate. */
*d = '\0';
/* Round if necessary. */
__ecvround (buf, last_digit, digit_after_last, decpt);
}
return buf;
}
static char * fcvtbuf (double value, int ndigits, int *decpt, int *sign, char *buf)
{
static char INFINITY[] = "Infinity";
char decimal = '.' /* localeconv()->decimal_point[0] */;
//int digits = ndigits >= 0 ? ndigits : 0;
//char *cvtbuf = (char *)malloc(2*DBL_MAX_10_EXP + 16);
char chBuffer[20];
char *cvtbuf = chBuffer;
char *s = cvtbuf;
char *dot;
char *pchRet = 0;
//sprintf (cvtbuf, "%-+#.*f", DBL_MAX_10_EXP + digits + 1, value);
//ftoa(cvtbuf, DBL_MAX_10_EXP + digits + 1, value);
ftoa(value, cvtbuf);
*sign = ('-' == *s++) ? 1 : 0; /* The sign. */
/* Where's the decimal point? */
dot = strchr(s, decimal);
*decpt = dot ? (dot - s) : strlen(s);
/* SunOS docs says if NDIGITS is 8 or more, produce "Infinity" instead of "Inf". */
if (strncmp (s, "Inf", 3) == 0)
{
memcpy (buf, INFINITY, ndigits >= 8 ? 9 : 3);
if (ndigits < 8) buf[3] = '\0';
pchRet = buf; /*return buf;*/
}
else if (ndigits < 0)
{/*return ecvtbuf (value, *decpt + ndigits, decpt, sign, buf);*/
pchRet = ecvtbuf (value, *decpt + ndigits, decpt, sign, buf);
}
else if (*s == '0' && value != 0.0)
{/*return ecvtbuf (value, ndigits, decpt, sign, buf);*/
pchRet = ecvtbuf(value, ndigits, decpt, sign, buf);
}
else
{
memcpy (buf, s, *decpt);
if (s[*decpt] == decimal)
{
memcpy (buf + *decpt, s + *decpt + 1, ndigits);
buf[*decpt + ndigits] = '\0';
}
else
{
buf[*decpt] = '\0';
}
__ecvround (buf, buf + *decpt + ndigits - 1,
s + *decpt + ndigits + 1, decpt);
pchRet = buf; /*return buf;*/
}
/*delete [] cvtbuf; */
return pchRet;
}
static void cfltcvt(double value, char *buffer, char fmt, int precision)
{
int decpt, sign;
char cvtbuf[80];
int capexp = 0;
if ('G' == fmt || 'E' == fmt)
{
capexp = 1;
fmt += 'a' - 'A';
}
if (fmt == 'g')
{
char * digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
int magnitude = decpt - 1;
if (magnitude < -4 || magnitude > precision - 1)
{
fmt = 'e';
precision -= 1;
}
else
{
fmt = 'f';
precision -= decpt;
}
}
if ('e' == fmt)
{
char * digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
int exp = 0;
if (sign) *buffer++ = '-';
*buffer++ = *digits;
if (precision > 0) *buffer++ = '.';
memcpy(buffer, digits + 1, precision);
buffer += precision;
*buffer++ = capexp ? 'E' : 'e';
if (decpt == 0)
{
exp = (value == 0.0) ? 0 : -1; /* if (value == 0.0)*/
}
else
{
exp = decpt - 1;
}
if (exp < 0)
{
*buffer++ = '-';
exp = -exp;
}
else
{
*buffer++ = '+';
}
buffer[2] = (exp % 10) + '0';
exp /= 10;
buffer[1] = (exp % 10) + '0';
exp /= 10;
buffer[0] = (exp % 10) + '0';
buffer += 3;
}
else if ('f' == fmt)
{
int pos;
char * digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
if (sign) *buffer++ = '-';
if (*digits)
{
if (decpt <= 0)
{
*buffer++ = '0';
*buffer++ = '.';
for (pos = 0; pos < -decpt; pos++)
{
*buffer++ = '0';
}
while(*digits) *buffer++ = *digits++;
}
else
{
int pos = 0;
while(*digits)
{
if (pos++ == decpt) *buffer++ = '.';
*buffer++ = *digits++;
}
}
}
else
{
int pos;
*buffer++ = '0';
if(precision > 0)
{
*buffer++ = '.';
for(pos = 0; pos < precision; pos++)
{
*buffer++ = '0';
}
}
}
}
*buffer = '\0';
}
static void forcdecpt(char *buffer)
{
while (*buffer)
{
if (*buffer == '.') return;
if (*buffer == 'e' || *buffer == 'E') break;
buffer++;
}
if(*buffer)
{
int n = strlen(buffer);
while(n > 0)
{
buffer[n + 1] = buffer[n];
n--;
}
*buffer = '.';
}
else
{
*buffer++ = '.';
*buffer = '\0';
}
}
static void cropzeros(char *buffer)
{
char *stop;
while (*buffer && *buffer != '.') buffer++;
if (*buffer++)
{
while (*buffer && *buffer != 'e' && *buffer != 'E') buffer++;
stop = buffer--;
while('0' == *buffer) buffer--;
if('.' == *buffer) buffer--;
while(*++buffer = *stop++);
}
}
static char * flt(char *str, double num, int size, int precision, char fmt, int flags)
{
char tmp[80];
char c, sign;
int n, i;
/* Left align means no zero padding */
if (flags & LEFT) flags &= ~ZEROPAD;
/* Determine padding and sign char */
c = (flags & ZEROPAD) ? '0' : ' ';
sign = 0;
if (flags & SIGN)
{
if (num < 0.0)
{
sign = '-';
num = -num;
size--;
}
else if (flags & PLUS)
{
sign = '+';
size--;
}
else if (flags & SPACE)
{
sign = ' ';
size--;
}
}
/* Compute the precision value */
if (precision < 0)
{
precision = 6; /* Default precision: 6 */
}
else if (precision == 0 && fmt == 'g')
{
precision = 1; /* ANSI specified */
}
/* Convert floating point number to text */
cfltcvt(num, tmp, fmt, precision);
/* '#' and precision == 0 means force a decimal point */
if ((flags & SPECIAL) && precision == 0) forcdecpt(tmp);
/* 'g' format means crop zero unless '#' given */
if (fmt == 'g' && !(flags & SPECIAL)) cropzeros(tmp);
n = strlen(tmp);
/* Output number with alignment and padding */
size -= n;
if(!(flags & (ZEROPAD | LEFT)))
{
while(size-- > 0) *str++ = ' ';
}
if(sign) *str++ = sign;
if(!(flags & LEFT))
{
while(size-- > 0) *str++ = c;
}
for(i = 0; i < n; i++)
{
*str++ = tmp[i];
}
while(size-- > 0) *str++ = ' ';
return str;
}
#endif
static int vsprintf(char *buf, const char *fmt, va_list args)
{
char *str;
int field_width; /* Width of output field */
for (str = buf; *fmt; fmt++)
{
unsigned long num;
int base = 10;
int flags = 0; /* Flags to number() Process flags */
int qualifier = -1; /* 'h', 'l', or 'L' for integer fields */
int precision = -1; /* Min. # of digits for integers; max number of chars for from string */
int bFmt = true;
if (*fmt != '%')
{
*str++ = *fmt;
continue;
}
bFmt = true;
while(bFmt)
{
fmt++; /* This also skips first '%' */
switch (*fmt)
{
case '-': flags |= LEFT; break;
case '+': flags |= PLUS; break;
case ' ': flags |= SPACE; break;
case '#': flags |= SPECIAL; break;
case '0': flags |= ZEROPAD; break;
default: bFmt = false;
}
}
/* Get field width */
field_width = -1;
if (is_digit(*fmt))
{
field_width = skip_atoi(&fmt);
}
else if ('*' == *fmt)
{
fmt++;
field_width = va_arg(args, int);
if (field_width < 0)
{
field_width = -field_width;
flags |= LEFT;
}
}
/* Get the precision */
precision = -1;
if ('.' == *fmt)
{
++fmt;
if (is_digit(*fmt))
{
precision = skip_atoi(&fmt);
}
else if ('*' == *fmt)
{
++fmt;
precision = va_arg(args, int);
}
if (precision < 0) precision = 0;
}
/* Get the conversion qualifier */
qualifier = -1;
if ('h' == *fmt || 'l' == *fmt || 'L' == *fmt)
{
qualifier = *fmt;
fmt++;
}
/* Default base */
base = 10;
switch (*fmt)
{
case 'c':
{
if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';
*str++ = (unsigned char) va_arg(args, int);
while (--field_width > 0) *str++ = ' ';
continue;
}
case 's':
{
int len;
int i;
char * s = va_arg(args, char *);
if (!s) s = "<NULL>";
len = strnlen(s, precision);
if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';
for (i = 0; i < len; ++i) *str++ = *s++;
while (len < field_width--) *str++ = ' ';
continue;
}
case 'p':
{
if (-1 == field_width)
{
field_width = 2 * sizeof(void *);
flags |= ZEROPAD;
}
str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);
continue;
}
case 'n':
{
if ('l' == qualifier)
{
long *ip = va_arg(args, long *);
*ip = (str - buf);
}
else
{
int *ip = va_arg(args, int *);
*ip = (str - buf);
}
continue;
}
case 'A':
{
flags |= LARGE; /* no break */
}
case 'a':
{
if ('l' == qualifier)
{
str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
}
else
{
str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
}
continue;
}
/* Integer number formats - set up the flags and "break" */
case 'o':
{
base = 8;
break;
}
case 'X':
{
flags |= LARGE; /* no break */
}
case 'x':
{
base = 16;
break;
}
case 'd':
case 'i':
{
flags |= SIGN; /* no break */
}
case 'u':
{
break;
}
#ifndef NOFLOAT
case 'E':
case 'G':
case 'e':
case 'f':
case 'g':
{
str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);
continue;
}
#endif
default:
{
if (*fmt != '%') *str++ = '%';
if (*fmt)
{
*str++ = *fmt;
}
else
{
--fmt;
}
continue;
}
} /* end of switch (*fmt) */
if (qualifier == 'l')
{
num = va_arg(args, unsigned long);
}
else if (qualifier == 'h')
{
if (flags & SIGN)
num = va_arg(args, short);
else
num = va_arg(args, unsigned short);
}
else if (flags & SIGN)
{
num = va_arg(args, int);
}
else
{
num = va_arg(args, unsigned long);
}
str = number(str, num, base, field_width, precision, flags);
} /* end of for (str = buf; *fmt; fmt++) */
*str = '\0';
return str - buf;
}
/*===============================================================================
以上是移植的vsprintf 以下代码为项目代码
===============================================================================*/
#define SHELL_ENABLE 1
#define MCU_PRINT_ENABLE 1
#define CMD_LENGHT 20
#define CHECKNULL(x) if((x)==NULL) return
struct cmd_st
{
u8 argc;
char cmd[CMD_LENGHT];
char params1[50];
char params2[50];
};
typedef enum
{
STRING = 0,
U8_TYPE,
U16_TYPE,
U32_TYPE,
}params_type;
struct params_table_element
{
u8 index;
u8 *params;
params_type type;
};
struct cmd_st shell_cmd;
char last_cmd[CMD_LENGHT] = {0};
System_Parameter set_TBOX_Parameter;
static u8 uart_buf[128] = {0};
static u8 uart_buf_index = 0;
u8 has_cmd = 0; //标示是否有命令需要处理
u8 cmd_enable = 1;//标示是否开启对命令交互系统的支持
int mcu_sprint(char *buf, const char *fmt, ...)
{
va_list args;
int n;
va_start(args, fmt);
n = vsprintf(buf, fmt, args);
va_end(args);
return n;
}
char mcu_buffer[512];
int mcu_print(char *fmt, ...)
{
#if MCU_PRINT_ENABLE
va_list argptr;
int cnt;
int i;
memset(mcu_buffer,0,sizeof(mcu_buffer));
va_start(argptr, fmt);
cnt = vsprintf(mcu_buffer, fmt, argptr);
Uart0_pro(strlen(mcu_buffer),(u8 *)mcu_buffer);
va_end(argptr);
//等待发送完毕
for(i=0; i<strlen(mcu_buffer); i++)
{
if(0 == Uart0_pro_progress())
break;
OSTimeDlyHMSM( 0, 0, 0, 10);
}
return(cnt);
#endif
}
- prinf代码移植
- prinf使用方法
- Prinf的输出格式
- prinf 函数格式化
- 代码移植
- sprintf()和prinf() 【ZendFramework中PHP】
- prinf scanf 格式控制【注意double】
- prinf(str)输出带来的问题
- 代码移植经验之谈
- can 总线移植--------代码
- 代码移植的问题
- 代码移植经验教训
- ucosII移植:可重入代码
- 跨平台移植代码
- 代码移植经验之谈
- Python函数代码移植
- 代码移植问题
- 移植2- 移植uboot的spl代码
- Linux学习笔记之一 ---Shell语法(1)
- c语言linux编写进度条
- VMware 虚拟机和主机网络在同一网段配置
- Android实现圆角和圆形
- ubuntu安装spark 2.1.0
- prinf代码移植
- Linux 根据目录名Kill此目录下执行的所有进程
- Java Thread.join()详解
- CardView的简单使用
- 当程序猿老公拿起了我的数位板
- 第1章Shell介绍和脚本基础
- mfc:单文档中对话框类调用视图类和框架类成员变量的实例
- CodeForces - 755B
- UVA 11624 Fire(bfs + 多起点)