• STM32F103单片机C语言模块化编程实战：按键控制LED灯并串口打印详解与示例

    一、开发环境

    硬件：正点原子 STM32F1精英版 开发板

    单片机：STM32F103ZET6

    Keil版本：5.32

    STM32CubeMX版本：6.9.2

    STM32Cube MCU Packges版本：STM32F1 V1.8.5

    虽然这里演示的是STM32F103，但是STM32F407还是STM32H系列等，但是可直接将LED、按键、串口文件复制使用，仅供需改头文件的引脚，这里是用STM32F407实现的介绍（http://t.csdnimg.cn/CWVUM）。之前介绍了很多关于点灯的方法，比如轮询、定时器中断、PWM、按键点灯等方式，这些文章使用的编程方法都不是模块化的编写方式，往往会导致代码可读性差、重用性差、扩展性差以及测试和维护困难等问题。为了避免这些问题，我们实际工作中通常会采用模块化的编写方法，这样可以确保代码结构清晰、功能明确，提高代码的可读性和可维护性，同时降低功能之间的耦合度，增强代码的重用性和扩展性。模块化的编写方式还有助于实现代码的并行开发，提高开发效率，使得整个项目更加易于管理和维护。

    基于之前的按键点灯的程序和printf重定向输出进行修改，我将为您详细阐述如何使用STM32F103的HAL库，并结合STM32CubeMX配置工具，通过模块化方法用按键分别控制两个LED灯并通过串口打印按键与灯的状态，即用引脚PE3和PE4按键分别控制PB5和PE5引脚LED，通过USART1打印信息。这一简洁而高效的流程将助您迅速掌握LED、按键、串口模块化编写方法。

    1.LED灯
    用drv_led.h和drv_led.c作为一个独立的模块，并提供三个LED驱动程序的接口

    int LedDrvInit(BoardLed led);//初始化指定的LED

    int LedDrvWrite(BoardLed led, LedStatus status);//设置指定LED的状态

    int LedDrvRead(BoardLed led);//读取指定LED的当前状态

    2.按键

    用drv_key.h和drv_key.c作为一个独立的模块，并提供两个KEY驱动程序的接口

    int KeyDrvInit(BoardKey key);//用于初始化指定的按键。  
    int KeyDrvRead(BoardKey key);//用于读取指定按键的状态。  

    3.串口USART1

    int UartDrvInit(BoardUart uart);// 定义宏，将DbgUart映射到具体的USART（通用同步异步收发器）硬件接口，这里映射到USART1 
    // 声明UartDrvWrite函数，该函数用于向指定的UART接口写入数据，参数pbuf指向要写入的数据，length表示数据长度
    int UartDrvWrite(BoardUart uart, unsigned char *pbuf, unsigned short length);
    // 声明UartDrvRead函数，该函数用于从指定的UART接口读取数据，参数pbuf用于存储读取到的数据，length表示读取的数据长度
    int UartDrvRead(BoardUart uart, unsigned char *pbuf, unsigned short length);

     二、配置STM32CubeMX

    1. 启动STM32CubeMX，新建STM32CubeMX项目：​​​
    2. 选择MCU：在软件中选择你的STM32型号-STM32F103ZET6。
    3. 选择时钟源：
    4. 配置时钟：
    5. ​使能Debug功能：Serial Wire
    6. ​HAL库时基选择：SysTick
    7. ​配置LED引脚：当前硬件的LED灯的引脚是PB5和PE5：在Pinout & Configuration标签页中，找到LED连接的GPIO端口，并设置为输出模式，通常选择Push-Pull，GPIO output level选低电平。
    8. ​配置KEY引脚：当前硬件的KEY的引脚是PE3和PE4：在Pinout & Configuration标签页中，找到KEY连接的GPIO端口，并设置为输入模式，通常选择Pull-up。​​
    9. 配置USART1串口：
    10. 配置工程参数：在Project标签页中，配置项目名称和位置，选择工具链MDK-ARM。​​​
    11. 生成代码：在Code Generator标签页中，配置工程外设文件与HAL库，勾选头文件.c和.h文件分开，然后点击Project > Generate Code生成代码。 ​​

    三、代码实现与部署

    1.  新建文件：在工程目录下建立ModuleDrivers的文件夹，名字随意,用于保存LED灯的驱动drv_led.h和drv_led.c ：​​ drv_led.h

      1. #ifndef __DRV_LED_H
      2. #define __DRV_LED_H
      3.  
      4. typedef enum{
      5.     LED1 = 1,
      6.     LED2
      7. }BoardLed;
      8.  
      9. typedef enum{
      10.     led_on = 0,
      11.     led_off = 1
      12. }LedStatus;
      13.  
      14. /*
      15. #define LED1_PIN      GPIO_PIN_9
      16. #define LED1_PORT     GPIOF
      17. #define LED2_PIN      GPIO_PIN_10
      18. #define LED2_PORT     GPIOF
      19. */
      20. #define LED1_PIN      GPIO_PIN_5
      21. #define LED1_PORT     GPIOB
      22. #define LED2_PIN      GPIO_PIN_5
      23. #define LED2_PORT     GPIOE
      24.  
      25. int LedDrvInit(BoardLed led);
      26. int LedDrvWrite(BoardLed led, LedStatus status);
      27. int LedDrvRead(BoardLed led);
      28.  
      29. #endif /* __DRV_LED_H */

      drv_led.c

      1. #include "drv_led.h"
      2. #include "stm32f1xx_hal.h"
      3.  
      4. int LedDrvInit(BoardLed led)
      5. {
      6.     switch(led)
      7.     {
      8.         case LED1:
      9.         {
      10.             break;
      11.         }
      12.         case LED2:
      13.         {
      14.             break;
      15.         }
      16.         default:break;
      17.     }
      18.     
      19.     return 0;
      20. }
      21.  
      22. int LedDrvWrite(BoardLed led, LedStatus status)
      23. {
      24.     switch(led)
      25.     {
      26.         case LED1:
      27.         {
      28.             HAL_GPIO_WritePin(LED1_PORT, LED1_PIN, (GPIO_PinState)status);
      29.             break;
      30.         }
      31.         case LED2:
      32.         {
      33.             HAL_GPIO_WritePin(LED2_PORT, LED2_PIN, (GPIO_PinState)status);
      34.             break;
      35.         }
      36.  
      37.         default:break;
      38.     }
      39.     
      40.     return 0;
      41. }
      42.  
      43. int LedDrvRead(BoardLed led)
      44. {
      45.     LedStatus status = led_on;
      46.     switch(led)
      47.     {
      48.         case LED1:
      49.         {
      50.             status = (LedStatus)HAL_GPIO_ReadPin(LED1_PORT, LED1_PIN);
      51.             break;
      52.         }
      53.         case LED2:
      54.         {
      55.             status = (LedStatus)HAL_GPIO_ReadPin(LED2_PORT, LED2_PIN);
      56.             break;
      57.         }
      58.         default:break;
      59.     }
      60.     
      61.     return status;
      62. }
    2. 添加路径：将drv_led.c添加到所属组， drv_led.h添加到头文件的路径中。​​​​
    3. 添加按键代码：drv_key.h和drv_key.c，方法与LED的一样。drv_key.h 
      1. // #ifndef __DRV_KEY_H 是预处理指令，用于防止头文件的内容在一个编译单元中被多次包含。  
      2. // 如果__DRV_KEY_H还没有被定义，则继续处理此头文件的内容；如果已经定义了，则忽略。  
      3. #ifndef __DRV_KEY_H
      4. #define __DRV_KEY_H
      5.  
      6. // 定义一个名为BoardKey的枚举类型，用于表示不同的按键。
      7. typedef enum{
      8.     K1 = 1,// K1键，其值为1  
      9.     K2,    // K2键，其值为2（因为K1为1，所以K2自动为2）  
      10.     K3,
      11.     K4
      12. }BoardKey;
      13.  
      14. // 定义一个名为KeyStatus的枚举类型，用于表示按键的状态。  
      15. typedef enum{  
      16.     isPressed = 0,  // 按键被按下，其值为0  
      17.     isReleased = 1  // 按键被释放，其值为1  
      18. }KeyStatus; 
      19.  
      20. // 定义了一系列的宏，用于表示按键对应的GPIO引脚和端口。  
      21. // 例如，K1_PIN代表K1键连接的GPIO引脚，而K1_PORT代表该引脚所在的GPIO端口。  
      22. #define K1_PIN          GPIO_PIN_0
      23. #define K1_PORT         GPIOA
      24. #define K2_PIN          GPIO_PIN_2
      25. #define K2_PORT         GPIOE
      26. #define K3_PIN          GPIO_PIN_3
      27. #define K3_PORT         GPIOE
      28. #define K4_PIN          GPIO_PIN_4
      29. #define K4_PORT         GPIOE
      30.  
      31. int KeyDrvInit(BoardKey key);//用于初始化指定的按键。  
      32. int KeyDrvRead(BoardKey key);//用于读取指定按键的状态。  
      33.  
      34. #endif /* __DRV_KEY_H */
      drv_key.c 
      1. #include "drv_key.h"
      2. #include "stm32f1xx_hal.h"
      3.  
      4. int KeyDrvInit(BoardKey key)
      5. {
      6.     switch(key)
      7.     {
      8.         case K1:
      9.         {
      10.             break;
      11.         }
      12.         case K2:
      13.         {
      14.             break;
      15.         }
      16.         case K3:
      17.         {
      18.             break;
      19.         }
      20.         case K4:
      21.         {
      22.             break;
      23.         }
      24.         default:break;
      25.     }
      26.     
      27.     return 0;
      28. }
      29.  
      30. int KeyDrvRead(BoardKey key)
      31. {
      32.     KeyStatus status = isReleased;
      33.     switch(key)
      34.     {
      35.         case K1:
      36.         {
      37.             status = (KeyStatus)HAL_GPIO_ReadPin(K1_PORT, K1_PIN);
      38.  
      39.             break;
      40.         }
      41.         case K2:
      42.         {
      43.             status = (KeyStatus)HAL_GPIO_ReadPin(K2_PORT, K2_PIN);
      44.             break;
      45.         }
      46.         case K3:
      47.         {
      48.             status = (KeyStatus)HAL_GPIO_ReadPin(K3_PORT, K3_PIN);
      49.             break;
      50.         }
      51.         case K4:
      52.         {
      53.             status = (KeyStatus)HAL_GPIO_ReadPin(K4_PORT, K4_PIN);
      54.             break;
      55.         }
      56.         default:break;
      57.     }
      58.     
      59.     return status;
      60. }
    4. 添加串口代码：drv_uart.h和drv_uart.c，方法与LED的一样。                                   drv_uart.h 
      1. // 防止头文件被重复包含，这是一种常见的预处理指令用法，用来确保头文件在一个编译单元中只被包含一次  
      2. #ifndef __DRV_UART_H
      3. #define __DRV_UART_H
      4.  
      5. // 定义一个枚举类型BoardUart，用来区分不同功能的UART（通用异步收发器）  
      6. typedef enum{
      7.     DbgUart = 1,// 定义一个枚举类型BoardUart，用来区分不同功能的UART（通用异步收发器）  
      8.     WiFiBTUart // WiFi蓝牙UART,后面会介绍WiFi蓝牙  
      9. }BoardUart;
      10.  
      11. // 定义宏，将DbgUart映射到具体的USART（通用同步异步收发器）硬件接口，这里映射到USART1  
      12. #define DBGUART     USART1
      13. #define WiFiUART    USART3
      14.  
      15. int UartDrvInit(BoardUart uart);// 定义宏，将DbgUart映射到具体的USART（通用同步异步收发器）硬件接口，这里映射到USART1 
      16. // 声明UartDrvWrite函数，该函数用于向指定的UART接口写入数据，参数pbuf指向要写入的数据，length表示数据长度
      17. int UartDrvWrite(BoardUart uart, unsigned char *pbuf, unsigned short length);
      18. // 声明UartDrvRead函数，该函数用于从指定的UART接口读取数据，参数pbuf用于存储读取到的数据，length表示读取的数据长度
      19. int UartDrvRead(BoardUart uart, unsigned char *pbuf, unsigned short length);
      20.  
      21. // 结束头文件防止重复包含的检查  
      22. #endif /* __DRV_UART_H */
      drv_uart.c 
      1. #include "drv_uart.h"
      2. #include "usart.h"
      3. #include "stm32f1xx_hal.h"
      4.  
      5. int UartDrvInit(BoardUart uart)
      6. {
      7.     switch(uart)
      8.     {
      9.         case DbgUart:
      10.         {
      11.             break;
      12.         }
      13.         case WiFiBTUart:
      14.         {
      15.             break;
      16.         }
      17.         default:break;
      18.     }
      19.     
      20.     return 0;
      21. }
      22.  
      23. int UartDrvWrite(BoardUart uart, unsigned char *pbuf, unsigned short length)
      24. {
      25.     int ret = -1;
      26.     switch(uart)
      27.     {
      28.         case DbgUart:
      29.         {
      30.             HAL_StatusTypeDef status = HAL_UART_Transmit(&huart1, pbuf, length, length*5);
      31.             if(HAL_OK == status)    ret = 0;
      32.             break;
      33.         }
      34.         case WiFiBTUart:
      35.         {
      36.             break;
      37.         }
      38.         default:break;
      39.     }
      40.     
      41.     return ret;
      42. }
      43.  
      44. int UartDrvRead(BoardUart uart, unsigned char *pbuf, unsigned short length)
      45. {
      46.     int ret = -1;
      47.     switch(uart)
      48.     {
      49.         case DbgUart:
      50.         {
      51.             HAL_StatusTypeDef status = HAL_UART_Receive(&huart1, pbuf, length, length*5);
      52.             if(HAL_OK == status)    ret = 0;
      53.             break;
      54.         }
      55.         case WiFiBTUart:
      56.         {
      57.             break;
      58.         }
      59.         default:break;
      60.     }
      61.     
      62.     return ret;
      63. }
      64.
    5. 添加打印重定向代码：printf.h和printf.c，方法与LED的一样。                                               printf.h  
      1. #ifndef __PRINTF_H
      2. #define __PRINTF_H
      3.  
      4. #ifndef USE_PRINTF
      5. #define USE_PRINTF  (1)
      6. #endif /* USE_PRINTF */
      7.  
      8. #if USE_PRINTF
      9.     #include 
      10.     #define xprintf(...)    printf(__VA_ARGS__)
      11. #else 
      12.     #define xprintf(...)
      13. #endif /* USE_PRINTF */
      14.  
      15. #endif /* __PRINTF_H */
       printf.c 
      1. #include "drv_uart.h"
      2. #include 
      3.  
      4. struct __FILE{
      5.     int handle;
      6. };
      7.  
      8. FILE __stdout;
      9.  
      10. int fputc(int ch, FILE *f)
      11. {
      12.     (void)f;
      13.     int ret = UartDrvWrite(DbgUart, (unsigned char*)&ch, 1);
      14.     if(0 == ret)
      15.         return ch;
      16.     
      17.     return 0;
      18. }
    6. 在main.c添加代码：添加头文件 
      1. #include "drv_led.h"
      2. #include "drv_key.h"
      3. #include "drv_uart.h"
      4. #include "printf.h"
      5. #include
      ​​ 
      1.    /* USER CODE BEGIN 2 */
      2.    LedStatus d1_s = led_off; //灯状态
      3.    LedStatus d2_s = led_off;
      4.    LedDrvInit(LED1);
      5.    LedDrvInit(LED2);
      6.    KeyDrvInit(K3);
      7.    KeyDrvInit(K4);
      8.    UartDrvInit(DbgUart);
      9.  
      10.   /* USER CODE END 2 */
      11.  
      12.   /* Infinite loop */
      13.   /* USER CODE BEGIN WHILE */
      14.   while (1)
      15.   {
      16.     /* USER CODE END WHILE */
      17.     /* USER CODE BEGIN 3 */
      18. 	  if(KeyDrvRead(K4) == isPressed)/* 检测按键的状态 */  
      19.       {
      20.           HAL_Delay(100);/* 消抖处理 */ 
      21.           if(KeyDrvRead(K4) == isPressed)
      22.           {
      23.               d1_s =!d1_s; /* 切换LED1状态 */  
      24. 			 if(d1_s)
      25. 			 {
      26. 				 LedDrvWrite(LED1, d1_s); /* 更新LED1的显示状态 */  
      27. 				 UartDrvWrite(DbgUart,(unsigned char *)"KEY1 is Pressed,LED1 is Off\r\n", strlen("KEY1 is Pressed,LED1 is Off\r\n"));
      28. 			 }
      29. 			else
      30. 			{
      31. 			     LedDrvWrite(LED1, d1_s); /* 更新LED1的显示状态 */  
      32. 				 UartDrvWrite(DbgUart,(unsigned char *)"KEY1 is Pressed,LED is On\r\n", strlen("KEY1 is Pressed,LED1 is On\r\n"));
      33. 			 }	
      34. 							
      35.            }
      36.       }
      37.      if(KeyDrvRead(K3) == isPressed)		/* 检测按键的状态 */  
      38.       {
      39.           HAL_Delay(100);/* 消抖处理 */ 
      40.           if(KeyDrvRead(K3) == isPressed)
      41.           {
      42.               d2_s =!d2_s;/* 切换LED1状态 */  
      43. 				if(d2_s)
      44. 				{
      45. 					LedDrvWrite(LED2, d2_s);/* 检测按键的状态 */  
      46. 					UartDrvWrite(DbgUart,(unsigned char *)"KEY2 is Pressed,LED2 is Off\r\n", strlen("KEY2 is Pressed,LED2 is Off\r\n"));
      47. 				}
      48. 				else
      49. 				{
      50. 					LedDrvWrite(LED2, d2_s);/* 检测按键的状态 */  
      51. 					UartDrvWrite(DbgUart,(unsigned char *)"KEY2 is Pressed,LED2 is On\r\n", strlen("KEY2 is Pressed,LED2 is On\r\n"));
      52. 				}
      53.           }
      54.       }	
      55.   }
      56.   /* USER CODE END 3 */
    7. 编译代码：Keil编译生成的代码。

    8. 烧录程序：将编译好的程序用ST-LINK烧录到STM32微控制器中。

    四、运行结果

    观察结果：一旦程序烧录完成并运行，你应该能看到按不同的按键会点亮不同的LED灯，串口打印按键和灯的状态。如果一切正常，恭喜你，你现在已经是一个掌握模块化的编写“点灯大师”了！​​

    ​​​

    五、总结

    模块化的编写方式对之前的代码封装了一层，提供了与LED、按键、串口硬件交互的接口，使得软件开发者可以在不直接操作硬件的情况下控制LED灯、按键、串口，将STM32F1（LED灯、按键、串口）的代码直接用到STM32F407、STM32H系列等中，如果引脚不一样，只需修改引脚即可。通过上面的代码，希望你更多的采用模块化的编写方式，确保代码结构清晰、功能明确，提高可读性和可维护性，降低功能耦合，增强重用和扩展性，也促进并行开发（比如A员工做LED灯、B员工做按键、C员工做串口），提升效率，便于项目管理和维护。

    六、注意事项

    1.确保你的开发环境和工具链已经正确安装和配置。

    2.在STM32CubeMX中配置GPIO时，注意选择正确的引脚和模式。

    3.在编写代码时，确保使用正确的GPIO端口和引脚宏定义。

    4.LED没有按预期点亮，按一下复位键，检查代码、连接和电源是否正确。

    6.串口没有打印，检查代码、连接、电源、波特率是否正确，串口是否打开。

    七、预告

    后面将将LED、按键、串口封装成一个GPIO类，直接3归1，敬请关注！

  • 相关阅读:
    PMP每日一练 | 考试不迷路-7.5
    定时器方案之红黑树与最小堆、时间轮详解
    java学习记录
    学科核心素养
    高性能MySQL实战第01讲：MySQL体系结构与存储引擎
    【框架】MyBatis
    操作系统：了解操作系统（编译、操作系统管理、进程、线程）
    计算机网络-传输层
    新零售项目及离线数仓核心面试，，220807，，
    Flink入门系列01-概述
  • 原文地址：https://blog.csdn.net/m0_37371085/article/details/138140178