printf

这是完整的ucos在51上移植的资料

                                     printf在uCOS51上的移植和浮点数显示
                                      [e-mail]   2003/10/20
                                      

    printf函数是C语言里应用最为广泛的函数之一，我们初学C语言时实现的第一个程序《Hello the world》，就包含printf语句。它的应用十分灵活，可以打印各种类型数据，可变数量的变量，表达式，是非常理想的输出函数，广泛用于结果输出，中间变量显示，调试等。然而，编译器将其作为标准库函数，不提供源代码，其本身代码量也偏大，无法实现嵌入式系统按需裁减的要求，并且有些printf库代码不支持重入。
    解决方法是把Linux里的相关源码简化后移植到C51里。关键点在于理解变参函数、参数传递规则、浮点数存储格式。
    C编译器一般将函数参数按从右至左的顺序依次压入堆栈(C51在使用reentrant关键字后也这么处理)，函数内部处理参数变量时直接在堆栈上寻址，局部变量紧跟在参数后面存放，函数返回时出栈，参数和局部变量所占用空间自动释放。例如：
    fun(char *fmt,char a,int b long c,float d) reentrant
    的堆栈结构如图1所示：
    
        ------------------
        |float d 4 bytes |
    +10 ------------------
        |long c 4 bytes  |
    +6  ------------------
        |int b 2 bytes   |
    +4  ------------------
        |char a 1 bytes  |
    +3  ------------------
        |char *fmt 3bytes|
 SP+0-->------------------
        |     局部变量    |
        ------------------
        图1.fun函数参数和局部变量在堆栈里的结构
    
    C51编译器从右向左依次将float/long/int/char/char *压入仿真堆栈，各种数据类型所占空间大小如图1，例如char占1字节，float占4字节等。值得一提的是，常数压栈的格式：0-255按1字节压栈，256-32767压成2字节，32768(8000H)或以上压成4字节，带有l/L结尾的常数占4字节。
    上面的函数fun内部可以通过函数名称访问各个变量，C编译器自动把函数名转换成地址，如：访问long c转换成访问SP+6，访问char a转换成访问SP+3等。写成表达式为：
    c=0x12345678;======>(SP+6)=0x12345678
    a='y';=============>(SP+3)='y'
    总之，上面的函数通过显式地指定函数名和数据类型完成参数的传递和访问，内部细节由C编译器完成，对用户透明。
    这种方式的好处是表达清晰，结构严谨，屏蔽底层细节；坏处是不够灵活，参数必须在处理前显式确定并固定不变，这给我们用同一函数处理不同情况带来了困难，C的解决方案是引入“变参函数”(详见C语言大全)，如下：
    fun(char *fmt,...) reentrant
    ...表示有0到N个可变数量参数，C编译器此时不检查参数匹配，传递参数规律与一般函数相同。如果我们用这个函数取代前一个函数，但仍按前一函数的调用方式调用，那么，参数在堆栈里的位置仍如图1所示。此时，函数形参只有“...”没有具体变量名，如何引用形参变量呢？观察图1堆栈结构可知，如果知道堆栈内第一个参数的起址和每个参数的数据类型及他们的排列顺序，就可以通过指针访问指定的变量。例如：
    知道堆栈内第一个参数的起址SP和每个参数的数据类型及排列顺序(char*/char/int/long/float)，就可以通过SP,SP+3,SP+4,SP+6,SP+10访问原来必须通过参数名访问的fmt,a,b,c,d变量。写成C语言就是：
    
    fun("yy",'y',(int)2,5L,-12.5);
    
    fun(char *fmt,...) reentrant
    {
    void *p;
    
    p=&fmt;
    //此时*p指向字符串"yy"首址，**p是字符串第一个字符'y'。
    p=(char **)p+1;
    //此时*((char *)p)为字符'y'。
    p=(char *)p+1;
    //此时*((int *)p)为0x0002。
    p=(int *)p+1;
    //此时*((long *)p)为0xC1480000，即-12.5的IEEE-754标准格式。
    p=(float *)p+1;
    }
    测试代码：
void fun(char *fmt,...) reentrant
{
  void *p;

  p=&fmt;
  PrintChar(**((char **)p));
  p=((char **)p) +1;
  PrintChar(*((char *)p));
  p=((char *)p) +1;
  PrintLong(*((int *)p));
  p=((int *)p) +1;
  PrintLong(*((long *)p));
  p=((long *)p) +1;
  PrintLong(*((long *)p));
  p=((float *)p) +1;
}
    显示结果：yy0000000200000005C1480000
    由上面知，在C里不用显式使用SP等堆栈指针，而是使用void指针指向各种类型数据。变参函数的参数传递和获取就是这样运做的，知道了它的原理，就不难理解printf的实现了。
    我所移植的printf支持标准或长二进制/八进制/十进制/十六进制/无符号整数，支持字符、字符串、浮点数、百分号%显示。其中，浮点数在整个范围内被完全支持，统一采用科学记数法显示。对应的指示符如下：
    c 字符    f 浮点数    s 字符串    % 百分号显示
    d/ld 2字节/4字节有符号整数    u/lu 2字节/4字节无符号整数
    x/lx 2字节/4字节十六进制数    o/lo 2字节/4字节八进制数
    b/lb 2字节/4字节二进制数
    
    printf的功能是字符串化数据，它的第一个参数是格式化字符串fmt，用其指示第一个参数在堆栈里的起址和其后各个参数的数据类型。知道了参数堆栈起址和各个参数的类型和排放次序，就可以依次取出各个参数并字符串化。详细过程参见yyprintf源代码。同时，注意到参数是依靠起址和数据长度信息依次读出来的，那么，yyprintf的参数必须与格式化参数的指示相同，否则参数数据会乱掉。对于不能肯定的转化数据类型建议加上强制类型定义，如(int) 2。特别是常数的转换类型容易搞错。
    printf大部分代码与硬件无关，只有参数堆栈结构和打印一个字符putchar()函数是硬件相关的。移植printf时只要修改putchar()函数和堆栈结构即可。putchar()函数的功能一般是向串口输出一个字符，也可以向其他显示设备输出一个字符，取决于你的驱动程序。我已经在uCOS51里实现了PrintChar函数，直接调用就可以了。其实，在X86、POWERPC、ARM等32位CPU上移植printf更加有效和方便。
    
    测试举例：
    float r=1.9835671E-10,pi=3.1415926;
    yyprintf("R=%f  Circle area=%f\n",r,pi*r*r);
    结果：
    R=1.983567E-10  Circle area=1.236071E-19
        
    源代码：
//============================================================================================
//
//============================================================================================
void yyprintf(char *fmt,...) reentrant  //自编简单printf等效函数
{
    void *p;  //任意指针，可以指向任何类型，C语法不对其严格要求。
    char ch;
    unsigned char j;

    p=&fmt;
    p=(char **)p+1;  //此处p是指向指针的指针，fmt是字符串指针，p是指向fmt的指针

    while(1){
        while((ch=*fmt++)!='%'){
            if(ch=='\0') return;
            else if(ch=='\n'){PrintChar(10);PrintChar(13);}
            else if(ch=='\t'){
                for(j=0;j<TABNum;j++)
                    PrintChar(' ');
            }
            else PrintChar(ch);
        }
        ch=*fmt++;
        switch(ch){
            case 'c':
                PrintChar(*((char *)p));
                p=(char *)p+1;
                break;
            case 'd':
                PrintN(*((int *)p),10);
                p=(int *)p+1;
                break;
            case 'x':
                PrintN(*((int *)p),16);
                p=(int *)p+1;
                break;
            case 'o':
                PrintUN(*((int *)p),8);
                p=(int *)p+1;
                break;
            case 'b':
                PrintUN(*((int *)p),2);
                p=(int *)p+1;
                break;
            case 'l':
                ch=*fmt++;
                switch(ch){
                    case 'd':
                        PrintLN(*((long *)p),10);
                        p=(long *)p+1;
                        break;
                    case 'o':
                        PrintLUN(*((long *)p),8);
                        p=(long *)p+1;
                        break;
                    case 'u':
                        PrintLUN(*((unsigned long *)p),10);
                        p=(unsigned long *)p+1;
                        break;
                    case 'b':
                        PrintLUN(*((long *)p),2);
                        p=(long *)p+1;
                        break;
                    case 'x':
                        PrintLN(*((long *)p),16);
                        p=(long *)p+1;
                        break;
                    default:
                        return;
                }
                break;
            case 'f':
                DispF(*((float *)p));
                p=(float *)p+1;
                break;
            case 'u':
                PrintUN(*((unsigned int *)p),10);
                p=(unsigned int *)p+1;
                break;
            case 's':
                PrintStr(*((char **)p));
                p=(char **)p+1;
                break;
            case '%':
                PrintChar('%');
                p=(char *)p+1;
                break;
            default:
                return;
        }
    }
}

void PrintN(int n,int b) reentrant  //十进制显示整形数
{
    if(b==16){PrintWord(n);return;}
	if(n<0){PrintChar('-');n=-n;}
	if(n/b)
	    PrintN(n/b,b);
	PrintChar(n%b+'0');
}

void PrintUN(unsigned int n,unsigned int b) reentrant  //十进制显示无符号整形数
{
    if(b==16){PrintWord(n);return;}
	if(n/b)
	    PrintUN(n/b,b);
	PrintChar(n%b+'0');
}


void PrintLN(long n,long b) reentrant  //十进制显示长整形数
{
    if(b==16){PrintLong(n);return;}
	if(n<0){PrintChar('-');n=-n;}
	if(n/b)
	    PrintLN(n/b,b);
	PrintChar(n%b+'0');
}

void PrintLUN(unsigned long n,unsigned long b) reentrant  //十进制显示无符号长整形数
{
    if(b==16){PrintLong(n);return;}
	if(n/b)
	    PrintLUN(n/b,b);
	PrintChar(n%b+'0');
}

参考文献：

1。《ROM版本下系统调试信息的一种显示方法》合肥工业大学 彭良清 《单片机与嵌入式系统应用》p22页2002(1-6)


TO BE CONTINUED...


                                浮点数显示