21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 解决STM8类型单片机空间太小，使用不了printf串口打印问 ...
返回列表 发新帖我要提问

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

[复制链接]
1328|2
 楼主| 花间一壶酒sd 发表于 2024-3-30 11:10 | 显示全部楼层 |阅读模式
printf, print, STM8, STM, ST
概述：
     在使用STM8L101F3这款单片机时，由于它只有8K的flash，空间非常小，只要调用C库函数printf编译后整个文件很大，直接程序溢出。这也就意味着我们实现printf串口打印调试就没办法进行。既然使用不了库函数，那么我们就可以自己动手封装类似printf的函数，这样我们就可以实现数据串口打印啦。这里就直接放上我的STM8L101F3的部分源码了，希望可以给你一些参考。

源码：

复制
  1. #include "stdarg.h"
    

  2. #include "stm8l10x.h"
    

  3.  
    

  4. void USART_Config(void)
    

  5. {
    

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

  7.     GPIO_ExternalPullUpConfig(GPIOC,GPIO_Pin_3|GPIO_Pin_4, ENABLE);
    

  8.     /* Enable USART clock */
    

  9.     CLK_PeripheralClockConfig(CLK_Peripheral_USART, ENABLE);
    

  10.     USART_DeInit();
    

  11.     USART_Init((uint32_t)9600, USART_WordLength_8D, USART_StopBits_1,
    

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

  13.     USART_Cmd(DISABLE);
    

  14.     enableInterrupts();
    

  15.     USART_Cmd(ENABLE);    
    

  16. }
    

  17.  
    

  18. /*发送串口数据*/
    

  19. void send_uart_data(uint8_t data)
    

  20. {
    

  21.   while (USART_GetFlagStatus(USART_FLAG_TXE) == RESET);
    

  22.   USART_SendData8(data);
    

  23. }
    

  24.  
    

  25. /*
    

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

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

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

  29.         radix --- 进制类型选择
    

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

  31. */
    

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

  33. {
    

  34.   char list[] = "0123456789ABCDEF";
    

  35.   unsigned int tmp_value;
    

  36.   int i = 0, j, k = 0;
    

  37.   if (NULL == str) {
    

  38.     return NULL;
    

  39.   }
    

  40.   if (2 != radix && 8 != radix && 10 != radix && 16 != radix) {
    

  41.     return NULL;
    

  42.   }
    

  43.   if (radix == 10 && value < 0) {
    

  44.     //十进制且为负数
    

  45.     tmp_value = (unsigned int)(0 - value);
    

  46.     str[i++] = '-';
    

  47.     k = 1;
    

  48.   } else {
    

  49.     tmp_value = (unsigned int)value;
    

  50.   }
    

  51.   //数据转换为字符串，逆序存储
    

  52.   do {
    

  53.     str[i ++] = list[tmp_value%radix];
    

  54.     tmp_value /= radix;
    

  55.   } while(tmp_value);
    

  56.   str[i] = '\0';
    

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

  58.   char tmp;
    

  59.   for (j = k; j < (i+k)/2; j++) {
    

  60.     tmp = str[j];
    

  61.     str[j] = str[i-j-1+k];
    

  62.     str[i-j-1+k] = tmp;
    

  63.   }
    

  64.   return str;
    

  65. }
    

  66.  
    

  67. /*
    

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

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

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

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

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

  73. */
    

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

  75. {
    

  76.   unsigned int integer;
    

  77.   double decimal;
    

  78.   char list[] = "0123456789";
    

  79.   int i = 0, j, k = 0;
    

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

  81.   if (value < 0) {
    

  82.     decimal = (double)(((int)value) - value);
    

  83.     integer = (unsigned int)(0 - value);
    

  84.     str[i ++] = '-';
    

  85.     k = 1;
    

  86.   } else {
    

  87.     integer = (unsigned int)(value);
    

  88.     decimal = (double)(value - integer);
    

  89.   }
    

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

  91.   do {
    

  92.     str[i ++] = list[integer%10];
    

  93.     integer /= 10;
    

  94.   } while(integer);
    

  95.   str[i] = '\0';
    

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

  97.   char tmp;
    

  98.   for (j = k; j < (i+k)/2; j++) {
    

  99.     tmp = str[j];
    

  100.     str[j] = str[i-j-1+k];
    

  101.     str[i-j-1+k] = tmp;
    

  102.   }
    

  103.   //处理小数部分
    

  104.   if (eps < 1 || eps > 4) {
    

  105.     eps = 4;
    

  106.   }
    

  107.   
    

  108.   //精度问题，防止输入1.2输出1.19等情况
    

  109.   double pp = 0.1;
    

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

  111.     pp *= 0.1;
    

  112.   }
    

  113.   decimal += pp;
    

  114.   while (eps) {
    

  115.     decimal *= 10;
    

  116.     eps --;
    

  117.   }
    

  118.   int tmp_decimal = (int)decimal;
    

  119.   str[i ++] = '.';
    

  120.   k = i;
    

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

  122.   do {
    

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

  124.     tmp_decimal /= 10;
    

  125.   } while(tmp_decimal);
    

  126.   str[i] = '\0';
    

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

  128.   for (j = k; j < (i+k)/2; j++) {
    

  129.     tmp = str[j];
    

  130.     str[j] = str[i-j-1+k];
    

  131.     str[i-j-1+k] = tmp;
    

  132.   }
    

  133.   str[i] = '\0';
    

  134. }
    

  135.  
    

  136.  
    

  137. void mprintf(char * Data, ...)
    

  138. {
    

  139.   const char *s;
    

  140.   int d;   
    

  141.   char buf[16];
    

  142.   uint8_t txdata;
    

  143.   va_list ap;
    

  144.   va_start(ap, Data);
    

  145.   while ( * Data != 0 ) {                                                          
    

  146.     if ( * Data == 0x5c )  {                                                                          
    

  147.       switch ( *++Data ) {
    

  148.         case 'r':                                                                  
    

  149.           txdata = 0x0d;
    

  150.           send_uart_data(txdata);
    

  151.           Data ++;
    

  152.           break;
    

  153.         case 'n':                                                                  
    

  154.           txdata = 0x0a;
    

  155.           send_uart_data(txdata);
    

  156.           Data ++;
    

  157.           break;
    

  158.         default:
    

  159.           Data ++;
    

  160.           break;
    

  161.       }                         
    

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

  163.       switch ( *++Data ) {                                
    

  164.       case 's':                                                                                 
    

  165.         s = va_arg(ap, const char *);
    

  166.         for ( ; *s; s++) {
    

  167.           send_uart_data(*((uint8_t *)s));
    

  168.         }                                
    

  169.         Data++;                                
    

  170.         break;
    

  171.       case 'd':                        
    

  172.         d = va_arg(ap, int);                                        
    

  173.         sky_itoa(d, buf, 10);                                        
    

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

  175.           send_uart_data(*((uint8_t *)s));
    

  176.         }                                        
    

  177.         Data++;                                
    

  178.         break;
    

  179.       case 'x': {
    

  180.         d = va_arg(ap, int);                                        
    

  181.         sky_itoa(d, buf, 16);                                        
    

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

  183.           send_uart_data(*((uint8_t *)s));
    

  184.         }                                        
    

  185.         Data++;                        
    

  186.         break;
    

  187.       }
    

  188.       case 'f': {
    

  189.         double num = va_arg(ap, double);                                        
    

  190.         sky_ftoa(num, buf, 4);
    

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

  192.           send_uart_data(*((uint8_t *)s));
    

  193.         }                                        
    

  194.         Data++;                        
    

  195.         break;
    

  196.       }
    

  197.       default:
    

  198.         Data++;                                
    

  199.         break;                                
    

  200.       }                 
    

  201.     } else {
    

  202.         send_uart_data(*((uint8_t *)Data));
    

  203.         Data++;
    

  204.     }
    

  205.   }
    

  206. }
    

  207.  
    

  208. void main(void)
    

  209. {
    

  210.     USART_Config();
    

  211.     mprintf("STM8L start...\r\n");
    

  212.     mprintf("%f %f %f\r\n", 1.2, 12.36, -1.2364568);
    

  213.     mprintf("%x %x %x\r\n", 0x1035, 0x0830, 0x2018);
    

  214.     mprintf("%d %d %d\r\n", 12, -12345, 2);
    

  215.     mprintf("STM8L end...\r\n");
    

  216.     while (1) {
    

  217.         
    

  218.     }
    

  219. }


回复

收藏 举报

相关帖子
 楼主| 花间一壶酒sd 发表于 2024-3-30 11:10 | 显示全部楼层
执行串口打印结果：

47004660782a051056.png
回复

收藏 举报

 楼主| 花间一壶酒sd 发表于 2024-3-30 11:10 | 显示全部楼层
注意事项：
      如果你不需要打印浮点数，那么就把浮点数打印部分代码注释掉。由于像这种8位单片机处理浮点数，是通过编译器来软实现，故对浮点数处理可能每增加一次浮点数处理，代码就会增加几十上百个字节，我这边的整型数和浮点数处理后的编译代码大小可以看看，浮点数处理和整型数处理代码空间的差异。

27480660782ad9fa32.png
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

花间一壶酒sd

101

主题

1219

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部