devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32单片机C语言模块化编程实战：按键控制LED灯详解与示例

作者：Gausst松鼠会 | 2024-04-29 09:50:51

赞

踩

STM32单片机C语言模块化编程实战：按键控制LED灯详解与示例

  一、开发环境

硬件：正点原子探索者 V3 STM32F407 开发板

单片机：STM32F407ZGT6

Keil版本：5.32

STM32CubeMX版本：6.9.2

STM32Cube MCU Packges版本：STM32F4 V1.27.1

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

基于之前的按键点灯的程序进行修改，我将为您详细阐述如何使用STM32F407的HAL库，并结合STM32CubeMX配置工具，通过模块化分层方法用按键分别控制两个LED灯，即用引脚PE2和PE3按键分别控制PF9和PF10引脚LED。这一简洁而高效的流程将助您迅速掌握LED和按键模块化分层的编写方法。

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的当前状态

按键

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

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

 二、配置STM32CubeMX

  1. 启动STM32CubeMX，新建STM32CubeMX项目：​
  2. 选择MCU：在软件中选择你的STM32型号-STM32F407ZGT6。​

  3. 选择时钟源：

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

三、代码实现与部署

  1.  新建文件：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. #define LED1_PIN      GPIO_PIN_9
    15. #define LED1_PORT     GPIOF
    16. #define LED2_PIN      GPIO_PIN_10
    17. #define LED2_PORT     GPIOF
    18.  
    19.  
    20. int LedDrvInit(BoardLed led);
    21. int LedDrvWrite(BoardLed led, LedStatus status);
    22. int LedDrvRead(BoardLed led);
    23.  
    24. #endif /* __DRV_LED_H */

    drv_led.c

    1. #include "drv_led.h"
    2. #include "stm32f4xx_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 "stm32f4xx_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. 在main.c添加代码：添加头文件 
    1. #include "drv_led.h"
    2. #include "drv_key.h"
    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(K2);
    7. 		KeyDrvInit(K3);
    8.   /* USER CODE END 2 */
    9.  
    10.   /* Infinite loop */
    11.   /* USER CODE BEGIN WHILE */
    12.   while (1)
    13.   {
    14.     /* USER CODE END WHILE */
    15.  
    16.     /* USER CODE BEGIN 3 */
    17. 		  if(KeyDrvRead(K2) == isPressed)/* 检测按键的状态 */  
    18.       {
    19.           HAL_Delay(100);/* 消抖处理 */ 
    20.           if(KeyDrvRead(K2) == isPressed)
    21.           {
    22.               d1_s =!d1_s; /* 切换LED1状态 */  
    23.               LedDrvWrite(LED1, d1_s); /* 更新LED1的显示状态 */  
    24.           }
    25.       }
    26.      if(KeyDrvRead(K3) == isPressed)		/* 检测按键的状态 */  
    27.       {
    28.           HAL_Delay(100);/* 消抖处理 */ 
    29.           if(KeyDrvRead(K3) == isPressed)
    30.           {
    31.               d2_s =!d2_s;/* 切换LED1状态 */ 
    32.               LedDrvWrite(LED2, d2_s);/* 检测按键的状态 */  
    33.           }
    34.       }	
    35.   }
  5. 编译代码：Keil编译生成的代码。

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

四、运行结果

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

五、总结

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

六、注意事项

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

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

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

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

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/507131
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号