• cubeIDE开发， stm32调试信息串口通信输出显示

    目录

    一、stm32串口配置

    三、串口驱动功能调用及编译实现

    四、编译测试

            关于cubeIDE开发基本技巧及流程，本文不详细叙述，请参考：cubeIDE快速开发流程_py_free的博客-CSDN博客_cubeide汉化

    一、stm32串口配置

            本文采用的开发板是stm32L496VGT3,其有两个 USB 接口，一个为 USB ST-link 复用接口，作用为软件下载/调试/ 系统供电输入口。另一个为 USB OTG，用户可以外接 USB 设备，支持 1000mA,USB2.0 设备接入。本文就采用 USB ST-link口实现串口上下行通信及调试信息输出显示。

            USB ST-Link（USB1） 接口的串口通信及调试信息需要我们映射实现。

             打开cubeMX配置界面，配置串口映射，开启LPUART串口或其他USART*（1）的异步传输模式（2），配置串口参数（3），并将串口收发数据端口映射到PB10、PB11上（4），并开启中断功能（5），最后点击保存或生成代码按钮生成代码。

            开启外部中断：

            设置上拉输出：

      二、串口驱动设计及代码实现

            重新构建系统的printf函数，将其映射到LPUART串口。

            【1】首先禁用CubeIDE生成syscall.c文件

             【2】创建print.h和print.c两个驱动文件来取代syscall.c内的函数_read、_write等实现，本文是将这两个文件放置在ICore目录内

             print.h内容如下：

    1. /*
    2.  * print.h
    3.  *
    4.  *  Created on: 2021年11月16日
    5.  *      Author: Administrator
    6.  */
    7.  
    8. #ifndef INC_RETARGET_H_
    9. #define INC_RETARGET_H_
    10.  
    11. #include "stm32l4xx_hal.h"
    12. #include "stdio.h"//用于printf函数串口重映射
    13. #include 
    14.  
    15. void ResetPrintInit(UART_HandleTypeDef  *huart);//将printf()函数映射到指定串口上
    16.  
    17. int _isatty(int fd);
    18. int _write(int fd, char* ptr, int len);
    19. int _close(int fd);
    20. int _lseek(int fd, int ptr, int dir);
    21. int _read(int fd, char* ptr, int len);
    22. int _fstat(int fd, struct stat* st);
    23.  
    24. #endif /* INC_RETARGET_H_ */

            print.c内容如下，主要是将syscall.c内的空实现函数通过串口实现数据收发处理

    1. /*
    2.  * print.c
    3.  *
    4.  *  Created on: 2021年11月16日
    5.  *      Author: Administrator
    6.  */
    7.  
    8. #include <_ansi.h>
    9. #include <_syslist.h>
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17.  
    18. #include "print.h"
    19.  
    20. #if !defined(OS_USE_SEMIHOSTING)
    21. #define STDIN_FILENO  0
    22. #define STDOUT_FILENO 1
    23. #define STDERR_FILENO 2
    24.  
    25. UART_HandleTypeDef *gHuart;
    26.  
    27. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    28.   gHuart = huart;
    29.   /* Disable I/O buffering for STDOUT  stream, so that
    30.    * chars are sent out as soon as they are  printed. */
    31.   setvbuf(stdout, NULL, _IONBF, 0);
    32. }
    33. int _isatty(int fd) {
    34.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    35.     return 1;
    36.   errno = EBADF;
    37.   return 0;
    38. }
    39. int _write(int fd, char* ptr, int len) {
    40.   HAL_StatusTypeDef hstatus;
    41.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    42.     //串口发送数据实现，可以main.c等功能代码中直接调用HAL_UART_Transmit也能实现串口发送数据
    43.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    44.     if (hstatus == HAL_OK)
    45.       return len;
    46.     else
    47.       return EIO;
    48.   }
    49.   errno = EBADF;
    50.   return -1;
    51. }
    52. int _close(int fd) {
    53.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    54.     return 0;
    55.   errno = EBADF;
    56.   return -1;
    57. }
    58. int _lseek(int fd, int ptr, int dir) {
    59.   (void) fd;
    60.   (void) ptr;
    61.   (void) dir;
    62.   errno = EBADF;
    63.   return -1;
    64. }
    65. int _read(int fd, char* ptr, int len) {
    66.   HAL_StatusTypeDef hstatus;
    67.   if (fd == STDIN_FILENO) {
    68.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    69.     if (hstatus == HAL_OK)
    70.       return 1;
    71.     else
    72.       return EIO;
    73.   }
    74.   errno = EBADF;
    75.   return -1;
    76. }
    77. int _fstat(int fd, struct stat* st) {
    78.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    79.     st->st_mode = S_IFCHR;
    80.     return 0;
    81.   }
    82.   errno = EBADF;
    83.   return 0;
    84. }
    85.  
    86. #endif //#if !defined(OS_USE_SEMIHOSTING)

            【3】创建串口驱动接口，主要就是实现串口回调函数

            前面print.h/c实现串口输出能力，但其输入能力由于lpusart开启了外部中断功能，还需我们实现其回调函数，因为cubeMX生成的HAL库（stm32l4xx_hal_uart.c，文件名因芯片不同有所区别）的串口接收回调函数是个弱声明函数，其实现源码没有做什么事。

             现在创建usart.h、usart.c两个串口驱动文件，放置ICore目录下

            usart.h内容如下,HAL_UART_RxCpltCallback会覆盖stm32l4xx_hal_uart.c的同名回调函数：

    1. /*
    2.  * usart.h
    3.  *
    4.  *  Created on: Oct 20, 2022
    5.  *      Author: Administrator
    6.  */
    7.  
    8. #ifndef INC_USART_H_
    9. #define INC_USART_H_
    10.  
    11. #include "stm32l4xx_hal.h" //HAL库文件声明
    12. #include //用于字符串处理的库
    13. #include "print.h"//用于printf函数串口重映射
    14.  
    15. extern UART_HandleTypeDef hlpuart1;//声明USART1的HAL库结构体
    16.  
    17. #define HLPUSART_REC_LEN  256//定义USART1最大接收字节数
    18.  
    19. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    20. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    21. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    22.  
    23.  
    24. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    25.  
    26. #endif /* INC_USART_H_ */

            usart.c内容如下：

    1. /*
    2.  * usart.c
    3.  *
    4.  *  Created on: Oct 20, 2022
    5.  *      Author: Administrator
    6.  */
    7.  
    8. #include "usart.h"
    9.  
    10. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    11. /*
    12.  * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
    13.  * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
    14.  * bit13:预留
    15.  * bit12:预留
    16.  * bit11~0：接收到的有效字节数目(0~4095)
    17.  */
    18. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    19. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    20.  
    21. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    22. {
    23. 	if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    24.     {
    25. 		if(HLPUSART_RX_STA&0x4000){//溢出，重新开始
    26. 			HLPUSART_RX_STA=0;//接收错误,重新开始
    27. 		}
    28. 		if(HLPUSART_NewData==0x0d){//回车标记
    29.      	  printf("getdata:%.*s  \r\n", HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
    30.      	  HLPUSART_RX_STA|=0x8000;//标记接到回车
    31. 		}else{
    32. 			if((HLPUSART_RX_STA&0X0FFF)
    33. 				HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    34. 				HLPUSART_RX_STA++;  //数据长度计数加1
    35. 			}else{
    36. 				HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    37. 			}
    38.         }
    39.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    40.     }
    41. }

    三、串口驱动功能调用及编译实现

            在原来的key.h/key.c中添加按键按下识别函数，

            key.h:

    1. /*
    2.  * key.h
    3.  *
    4.  *  Created on: Sep 29, 2022
    5.  *      Author: py_hp
    6.  */
    7.  
    8. #ifndef KEY_H_
    9. #define KEY_H_
    10.  
    11. #include "main.h"
    12. #include "gpio.h"
    13.  
    14. GPIO_PinState get_key0_val();
    15. GPIO_PinState get_key1_val();
    16. GPIO_PinState get_key2_val();
    17.  
    18. uint8_t KEY_0(void);
    19. uint8_t KEY_1(void);
    20. uint8_t KEY_2(void);
    21.  
    22. #endif /* KEY_H_ */

            key.c内容如下：

    1. /*
    2.  * key.c
    3.  *
    4.  *  Created on: Sep 29, 2022
    5.  *      Author: py_hp
    6.  */
    7. #include "key.h"
    8.  
    9. GPIO_PinState get_key0_val()
    10. {
    11. 	return HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin);
    12. };
    13.  
    14. GPIO_PinState get_key1_val()
    15. {
    16. 	return HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin);
    17. };
    18.  
    19. GPIO_PinState get_key2_val()
    20. {
    21. 	return HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin);
    22. };
    23.  
    24. uint8_t KEY_0(void)
    25. {
    26. 	uint8_t a;
    27. 	a=0;//如果未进入按键处理，则返回0
    28. 	if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    29. 		HAL_Delay(20);//延时去抖动
    30. 		if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    31. 			a=1;//进入按键处理，返回1
    32. 		}
    33. 	}
    34. 	while(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET); //等待按键松开
    35. 	return a;
    36. }
    37.  
    38. uint8_t KEY_1(void)
    39. {
    40. 	uint8_t a;
    41. 	a=0;//如果未进入按键处理，则返回0
    42. 	if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    43. 		HAL_Delay(20);//延时去抖动
    44. 		if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    45. 			a=1;//进入按键处理，返回1
    46. 		}
    47. 	}
    48. 	while(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    49. 	return a;
    50. }
    51.  
    52. uint8_t KEY_2(void)
    53. {
    54. 	uint8_t a;
    55. 	a=0;//如果未进入按键处理，则返回0
    56. 	if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    57. 		HAL_Delay(20);//延时去抖动
    58. 		if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    59. 			a=1;//进入按键处理，返回1
    60. 		}
    61. 	}
    62. 	while(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    63. 	return a;
    64. }
    65.

            在main.c中调用串口驱动，其部分代码如下：

    1. /* USER CODE END Header */
    2. /* Includes ------------------------------------------------------------------*/
    3. #include "main.h"
    4. #include "usart.h"
    5. #include "gpio.h"
    6.  
    7. /* Private includes ----------------------------------------------------------*/
    8. /* USER CODE BEGIN Includes */
    9. //用户代码1
    10. #include "../../ICore/key.h"
    11. #include "../../ICore/led.h"
    12. #include "../../ICore/print.h"
    13. #include "../../ICore/usart.h"
    14. /* USER CODE END Includes */
    15.  
    16. /* Private typedef -----------------------------------------------------------*/
    17. /* USER CODE BEGIN PTD */
    18.  
    19. /* USER CODE END PTD */
    20.  
    21. /* Private define ------------------------------------------------------------*/
    22. /* USER CODE BEGIN PD */
    23. /* USER CODE END PD */
    24.  
    25. /* Private macro -------------------------------------------------------------*/
    26. /* USER CODE BEGIN PM */
    27.  
    28. /* USER CODE END PM */
    29.  
    30. /* Private variables ---------------------------------------------------------*/
    31.  
    32. /* USER CODE BEGIN PV */
    33.  
    34. /* USER CODE END PV */
    35.  
    36. /* Private function prototypes -----------------------------------------------*/
    37. void SystemClock_Config(void);
    38. /* USER CODE BEGIN PFP */
    39.  
    40. /* USER CODE END PFP */
    41.  
    42. /* Private user code ---------------------------------------------------------*/
    43. /* USER CODE BEGIN 0 */
    44.  
    45. /* USER CODE END 0 */
    46.  
    47. /**
    48.   * @brief  The application entry point.
    49.   * @retval int
    50.   */
    51. int main(void)
    52. {
    53.   /* USER CODE BEGIN 1 */
    54.  
    55.   /* USER CODE END 1 */
    56.  
    57.   /* MCU Configuration--------------------------------------------------------*/
    58.  
    59.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    60.   HAL_Init();
    61.  
    62.   /* USER CODE BEGIN Init */
    63.  
    64.   /* USER CODE END Init */
    65.  
    66.   /* Configure the system clock */
    67.   SystemClock_Config();
    68.  
    69.   /* USER CODE BEGIN SysInit */
    70.  
    71.   /* USER CODE END SysInit */
    72.  
    73.   /* Initialize all configured peripherals */
    74.   MX_GPIO_Init();
    75.   MX_LPUART1_UART_Init();
    76.   /* USER CODE BEGIN 2 */
    77.  //用户代码2
    78.   ResetPrintInit(&hlpuart1);
    79.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
    80.   HLPUSART_RX_STA = 0;
    81.   set_led0_val(0);
    82.   set_led1_val(get_key0_val());
    83.   /* USER CODE END 2 */
    84.  
    85.   /* Infinite loop */
    86.   /* USER CODE BEGIN WHILE */
    87.   while (1)
    88.   {
    89.       //用户代码3
    90. 	  if(KEY_1()) //按键KEY1判断为1时按键按下
    91. 	  {
    92. 		  set_led0_val(1);//LED1灯控制（1点亮，0熄灭）
    93. 		  set_led1_val(0);//LED2灯控制（1点亮，0熄灭）
    94. 	      printf("KEY1\r\n");//向USART1串口发送字符串
    95. 	  }
    96. 	  if(KEY_2()) //按键KEY2判断为1时按键按下
    97. 	  {
    98. 		  set_led0_val(0);//LED1灯控制（1点亮，0熄灭）
    99. 		  set_led1_val(1);//LED2灯控制（1点亮，0熄灭）
    100. 		  printf("KEY2\r\n");//向USART1串口发送字符串
    101. 	  }
    102. 	  if(HLPUSART_RX_STA&0xC000){//串口1判断中断接收标志位
    103. 		  printf("read flag HLPUSART_RX_STA&0XC000\r\n");//向USART1串口发送字符串
    104. 		  if(HLPUSART_RX_BUF[0]=='1'){
    105. 			  set_led0_val(1);//LED1灯控制（1点亮，0熄灭）
    106. 			  set_led1_val(1);//LED2灯控制（1点亮，0熄灭）
    107. 		  }
    108. 		  if(HLPUSART_RX_BUF[0]=='0'){
    109. 			  set_led0_val(0);//LED1灯控制（1点亮，0熄灭）
    110. 			  set_led1_val(0);//LED2灯控制（1点亮，0熄灭）
    111. 		  }
    112. 		  HLPUSART_RX_STA=0;//串口接收标志清0，即开启下一轮接收
    113. 	  }
    114.     /* USER CODE END WHILE */
    115.  
    116.     /* USER CODE BEGIN 3 */
    117.   }
    118.   /* USER CODE END 3 */
    119. }

    四、编译测试

            编译及加载程序到开发板：

             验证数据收发，按键1和按键2按下，顺利传输数据，输入“1”和“0”字段，可下行控制LED灯

  • 相关阅读:
    初识C++|类和对象（中）——类的默认成员函数
    PE文件解析（5）：重定位表详解
    分页列表缓存，你真的会吗
    Could not autowire field: protected tk.mybatis.mapper.common.Mapper
    Kotlin-高阶函数
    [需求管理-1]：IT需求管理总体流程+需求管理需要的技能
    第3章 初识SqlSugarCore之ConfigureOptions注入实现
    Vue首次使用Element
    艾美捷 DetergentOUT GB-S10去垢剂的特点和多种应用
    11 个 Flutter 最佳实践
  • 原文地址：https://blog.csdn.net/py8105/article/details/127893716