解决STM8类型单片机空间太小，使用不了printf串口打印问题

概述：

在使用STM8L101F3这款单片机时，由于它只有8K的flash，空间非常小，只要调用C库函数printf编译后整个文件很大，直接程序溢出。这也就意味着我们实现printf串口打印调试就没办法进行。既然使用不了库函数，那么我们就可以自己动手封装类似printf的函数，这样我们就可以实现数据串口打印啦。这里就直接放上我的STM8L101F3的部分源码了，希望可以给你一些参考。

源码：

#include "stdarg.h"

#include "stm8l10x.h"

void USART_Config(void)

{

    /*Set the USART RX and USART TX at high level*/

    GPIO_ExternalPullUpConfig(GPIOC,GPIO_Pin_3|GPIO_Pin_4, ENABLE);

    /* Enable USART clock */

    CLK_PeripheralClockConfig(CLK_Peripheral_USART, ENABLE);

    USART_DeInit();

    USART_Init((uint32_t)9600, USART_WordLength_8D, USART_StopBits_1,

                USART_Parity_No, (USART_Mode_TypeDef)(USART_Mode_Rx | USART_Mode_Tx));

    USART_Cmd(DISABLE);

    enableInterrupts();

    USART_Cmd(ENABLE);    

}

/*发送串口数据*/

void send_uart_data(uint8_t data)

{

  while (USART_GetFlagStatus(USART_FLAG_TXE) == RESET);

  USART_SendData8(data);

}

/*

  功能：将int型数据转为2，8，10，16进制字符串

  参数：value --- 输入的int整型数

        str --- 存储转换的字符串

        radix --- 进制类型选择

  注意：8位单片机int字节只占2个字节

*/

char *sky_itoa(int value, char *str, unsigned int radix)

{

  char list[] = "0123456789ABCDEF";

  unsigned int tmp_value;

  int i = 0, j, k = 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] = '';

  //将逆序字符串转换为正序

  char tmp;

  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;

}

/*

  功能：将double型数据转为字符串

  参数：value --- 输入的double浮点数

        str --- 存储转换的字符串

        eps --- 保留小数位选择，至少保留一个小数位,至多保留4个小数位

  注意：8位单片机int字节只占2个字节

*/

void sky_ftoa(double value, char *str, unsigned int eps)

{

  unsigned int integer;

  double decimal;

  char list[] = "0123456789";

  int i = 0, j, k = 0;

  //将整数及小数部分提取出来

  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] = '';

  //将逆序字符串转换为正序

  char tmp;

  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等情况

  double pp = 0.1;

  for (j = 0; j <= eps; j++) {

    pp *= 0.1;

  }

  decimal += pp;

  while (eps) {

    decimal *= 10;

    eps --;

  }

  int tmp_decimal = (int)decimal;

  str[i ++] = '.';

  k = i;

  //整数部分数据转换为字符串，逆序存储

  do {

    str[i ++] = list[tmp_decimal%10];

    tmp_decimal /= 10;

  } while(tmp_decimal);

  str[i] = '';

  //将逆序字符串转换为正序

  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] = '';

}

void mprintf(char * Data, ...)

{

  const char *s;

  int d;   

  char buf[16];

  uint8_t txdata;

  va_list ap;

  va_start(ap, Data);

  while ( * Data != 0 ) {                          

    if ( * Data == 0x5c )  {  

      switch ( *++Data ) {

        case 'r':          

          txdata = 0x0d;

          send_uart_data(txdata);

          Data ++;

          break;

        case 'n':          

          txdata = 0x0a;

          send_uart_data(txdata);

          Data ++;

          break;

        default:

          Data ++;

          break;

      }  

    } else if ( * Data == '%') {  

      switch ( *++Data ) {

      case 's':  

        s = va_arg(ap, const char *);

        for ( ; *s; s++) {

          send_uart_data(*((uint8_t *)s));

        }

        Data++;

        break;

      case 'd':

        d = va_arg(ap, int);

        sky_itoa(d, buf, 10);

        for (s = buf; *s; s++) {

          send_uart_data(*((uint8_t *)s));

        }

        Data++;

        break;

      case 'x': {

        d = va_arg(ap, int);

        sky_itoa(d, buf, 16);

        for (s = buf; *s; s++) {

          send_uart_data(*((uint8_t *)s));

        }

        Data++;

        break;

      }

      case 'f': {

        double num = va_arg(ap, double);

        sky_ftoa(num, buf, 4);

        for (s = buf; *s; s++) {

          send_uart_data(*((uint8_t *)s));

        }

        Data++;

        break;

      }

      default:

        Data++;

        break;

      }  

    } else {

        send_uart_data(*((uint8_t *)Data));

        Data++;

    }

  }

}

void main(void)

{

    USART_Config();

    mprintf("STM8L start...rn");

    mprintf("%f %f %frn", 1.2, 12.36, -1.2364568);

    mprintf("%x %x %xrn", 0x1035, 0x0830, 0x2018);

    mprintf("%d %d %drn", 12, -12345, 2);

    mprintf("STM8L end...rn");

    while (1) {

    }

}

执行串口打印结果：

注意事项：

如果你不需要打印浮点数，那么就把浮点数打印部分代码注释掉。由于像这种8位单片机处理浮点数，是通过编译器来软实现，故对浮点数处理可能每增加一次浮点数处理，代码就会增加几十上百个字节，我这边的整型数和浮点数处理后的编译代码大小可以看看，浮点数处理和整型数处理代码空间的差异。