简单实现printf（）函数功能

bit f_tx_byte_over=0;



#if 0
//自定义串口 的printf 函数
char uart_buf[50];

void uart_printf( char* fmt, ... )  //无法列出传递函数的所有实参的类型和数目时,可以用省略号指定参数表
{
    unsigned int i, j;
    va_list ap;          //va_list 是一个字符指针，可以理解为指向当前参数的一个指针，取参必须通过这个指针进行。
    va_start( ap, fmt ); //va_start函数来获取参数列表中的参数，使用完毕后调用va_end()结束
    vsprintf( ( char* )uart_buf, fmt, ap );	// 把生成的格式化的字符串存放在这里
    va_end( ap );
    i = strlen( ( const char* )uart_buf );          //此次发送数据的长度
    for( j = 0; j < i; j++ )                                                  //循环发送数据
    {
        //while( ( UART0_TXD & 0x80 ) == 0x00 );       //发送数据寄存器空
        UART0_TXD = uart_buf[j];
    }
}
#endif

//阻塞式发送函数
void SendChar( unsigned char dat )
{
    f_tx_byte_over=0;
    UART0_TXD = dat;
	while(f_tx_byte_over==0);

}


/*
  功能：将int型数据转为2，8，10，16进制字符串
  参数：value --- 输入的int整型数
        str --- 存储转换的字符串
        radix --- 进制类型选择
  注意：8位单片机int字节只占2个字节
*/
char *int2char( int value, char *str, unsigned int radix )
{
    char list[] = "0123456789ABCDEF";
    unsigned int tmp_value=0;
    int i = 0, j=0, k = 0;
	char tmp=0;
    if ( NULL == str )
    {
        return NULL;
    }
    if ( 2 != radix && 8 != radix && 10 != radix && 16 != radix )
    {
        return NULL;
    }
    if ( radix == 10 && value < 0 )
    {
        //十进制且为负数
        tmp_value = ( unsigned int )( 0 - value );
        str[i++] = '-';
        k = 1;
    }
    else
    {
        tmp_value = ( unsigned int )value;
    }
    //数据转换为字符串，逆序存储
    do
    {
        str[i ++] = list[tmp_value % radix];
        tmp_value /= radix;
    }
    while( tmp_value );
    str[i] = '\0';
    //将逆序字符串转换为正序
    
    for ( j = k; j < ( i + k ) / 2; j++ )
    {
        tmp = str[j];
        str[j] = str[i - j - 1 + k];
        str[i - j - 1 + k] = tmp;
    }
    return str;
}

#if 0
/*
  功能：将double型数据转为字符串
  参数：value --- 输入的double浮点数
        str --- 存储转换的字符串
        eps --- 保留小数位选择，至少保留一个小数位,至多保留4个小数位
  注意：8位单片机int字节只占2个字节
*/
void flaot2char( double value, char *str, unsigned int eps )
{
    unsigned int integer;
    double decimal;
    char list[] = "0123456789";
    int i = 0, j, k = 0;
	char tmp=0;
	double pp = 0.1;
	int tmp_decimal;
    //将整数及小数部分提取出来
    if ( value < 0 )
    {
        decimal = ( double )( ( ( int )value ) - value );
        integer = ( unsigned int )( 0 - value );
        str[i ++] = '-';
        k = 1;
    }
    else
    {
        integer = ( unsigned int )( value );
        decimal = ( double )( value - integer );
    }
    //整数部分数据转换为字符串，逆序存储
    do
    {
        str[i ++] = list[integer % 10];
        integer /= 10;
    }
    while( integer );
    str[i] = '\0';
    //将逆序字符串转换为正序
    
    for ( j = k; j < ( i + k ) / 2; j++ )
    {
        tmp = str[j];
        str[j] = str[i - j - 1 + k];
        str[i - j - 1 + k] = tmp;
    }
    //处理小数部分
    if ( eps < 1 || eps > 4 )
    {
        eps = 4;
    }

    //精度问题，防止输入1.2输出1.19等情况
    
    for ( j = 0; j <= eps; j++ )
    {
        pp *= 0.1;
    }
    decimal += pp;
    while ( eps )
    {
        decimal *= 10;
        eps --;
    }
    tmp_decimal = ( int )decimal;
    str[i ++] = '.';
    k = i;
    //整数部分数据转换为字符串，逆序存储
    do
    {
        str[i ++] = list[tmp_decimal % 10];
        tmp_decimal /= 10;
    }
    while( tmp_decimal );
    str[i] = '\0';
    //将逆序字符串转换为正序
    for ( j = k; j < ( i + k ) / 2; j++ )
    {
        tmp = str[j];
        str[j] = str[i - j - 1 + k];
        str[i - j - 1 + k] = tmp;
    }
    str[i] = '\0';
}

#endif

void uart_printf( char * Data, ... )
{
    const char *s;
    int d=0;
    char buf[16];
    unsigned char txdata=0;
    va_list ap;
    va_start( ap, Data );
    while ( * Data != 0 )
    {
        if ( * Data == 0x5c )
        {
            switch ( *++Data )
            {
            case 'r':
                txdata = 0x0d;
                SendChar( txdata );
                Data ++;
                break;
            case 'n':
                txdata = 0x0a;
                SendChar( txdata );
                Data ++;
                break;
            default:
                Data ++;
                break;
            }
        }
        else if ( * Data == '%' )
        {
            switch ( *++Data )
            {
/*              
            case 's':
                s = va_arg( ap, const char * );
                for ( ; *s; s++ )
                {
                    SendChar( *( ( unsigned char * )s ) );
                }
                Data++;
                break;
*/
            case 'd':
                d = va_arg( ap, int );
                int2char( d, buf, 10 );
                for ( s = buf; *s; s++ )
                {
                    SendChar( *( ( unsigned char * )s ) );
                }
                Data++;
                break;
               
            case 'x':
            {
                d = va_arg( ap, int );
                int2char( d, buf, 16 );
                for ( s = buf; *s; s++ )
                {
                    SendChar( *( ( unsigned char * )s ) );
                }
                Data++;
                break;
            }
                
            
	/*        
            case 'f':
            {
				double num = va_arg(ap, double);
				flaot2char(num, buf, 4);
				for (s = buf; *s; s++)
				{
					SendChar(*((unsigned char *)s));
				}
				Data++;
                break;
            }
*/
            default:
                Data++;
                break;
            }
        }
        else
        {
            SendChar( *( ( unsigned char * )Data ) );
            Data++;
        }
    }
}