文章

关于LED驱动，同样适用于蜂鸣器，使其更适合状态指示

状态指示灯.pdf

源码

文章中的代码整理
基本思想是不用定时器，参考芯片自己的时钟调整LED闪烁频率

  1. #define LED_TIME_CYCLE                     1500  // ms
  2. #define LED_TIME_OUTPUT                    150   // ms
  4. typedef enum {
  5.     LED_ON,
  6.     LED_OFF,      
  7. }led_level_def;
  9. typedef struct {
  10.     uint16_t last_time_show_cycle;  // 状态查询时间
  11.     uint16_t set_time_cycle;        // 循环时间
  12.     uint16_t set_last_time;         // 上一次电平输出时间
  13.     uint8_t  curr_number;        // 当前
  14.   uint8_t  next_number;           // 下一个指示次数
  15.     void    (*led_set)(led_level_def); 
  16. }led_para_def;
  18. // LED 设置
  19. void led_set_level(led_level_def level)
  20. {
  21.     if(level == LED_ON){
  22.        GPIO_ResetBits(GPIOB, GPIO_Pin_13);
  23.     }
  24.     else{
  25.        GPIO_SetBits(GPIOB, GPIO_Pin_13); 
  26.     }
  27. }
  29. // 参数初始化
  30. led_para_def led_para = 
  31. {
  32.     .set_time_cycle  = (uint16_t)-1,
  33.     .curr_number     =  0,
  34.     .led_set         =  led_set_level,
  35. };
  37. // 调用频率小于 10 ms
  38. void led_set_handle(led_para_def *p_led_para, uint32_t time)
  39. {
  40.   // 设置 LED
  41.     if(((uint16_t)(time - p_led_para->set_last_time)) >= p_led_para->set_time_cycle) {
  42.         p_led_para->set_last_time = time;
  43.         if(p_led_para->curr_number) {
  44.             p_led_para->led_set(((p_led_para->curr_number & 1) == 1) ? LED_OFF : LED_ON);
  45.             p_led_para->curr_number--;
  46.             if(p_led_para->curr_number == 0) {
  47.                 p_led_para->set_time_cycle = (uint16_t)-1;// 下一个周期不再进入
  48.             }
  49.         }
  50.     }
  51.   // 更新当前参数（1.5 s 更新一次）
  52.   if(((uint16_t)(time - p_led_para->last_time_show_cycle)) >= LED_TIME_CYCLE){
  53.         p_led_para->last_time_show_cycle = time;
  55.         if(!p_led_para->curr_number){
  56.       uint8_t number = p_led_para->next_number; // 获取当前指示次数
  57.       // 限制闪烁次数
  58.       if(number < LED_TIME_CYCLE / LED_TIME_OUTPUT / 2){
  59.         p_led_para->curr_number    = number * 2 - 1;
  60.         p_led_para->set_last_time  = time;
  61.         p_led_para->set_time_cycle = LED_TIME_OUTPUT;
  62.         p_led_para->led_set(LED_ON);
  63.       }
  64.         }
  65.     }
  66. }
  68. // number 闪烁次数
  69. void led_show(led_para_def *p_led_para, uint8_t number)
  70. {
  71.   p_led_para->next_number = number;
  72. }

改写

使LED状态灯成为独立的模块，且符合模块组件设计

Module_LED.h

  1. /*
  2.  * Copyright (c) 2020 - ~, HIT_HERO Team
  3.  *
  4.  * LED MODULE HEAD FILE
  5.  * Used in RT-Thread Operate System
  6.  *
  7.  * Change Logs:
  8.  * Date           Author       Notes                Mail
  9.  * 2020-06-02     WangXi       first version        WangXi_chn@foxmail.com
  10.  * 2020-07-30     WangXi       second version        WangXi_chn@foxmail.com
  11.  */
  12. #ifndef _MODULE_LED_H_
  13. #define _MODULE_LED_H_
  15. #define _LED_POSITIVE_POLE      //RESET Enable LED
  16. //#define _LED_NEGETIVE_POLE    //SET Enable LED
  18. #include <rtthread.h>
  19. #include <rtdevice.h>
  20. #include <board.h>
  22. typedef enum
  23. {
  24. #ifdef _LED_POSITIVE_POLE
  25.     MODULE_LED_ON = 0,
  26.     MODULE_LED_OFF
  27. #endif
  29. #ifdef _LED_NEGETIVE_POLE
  30.     MODULE_LED_OFF = 0,
  31.     MODULE_LED_ON
  32. #endif  
  33. }led_level_def;
  35. struct _MODULE_LED
  36. {
  37.     /* Property */
  38.     rt_base_t pin;          /*!< Specifies the LED module pins to be configured.
  39.                             This parameter is defined by function @ref GET_PIN(GPIOPORT, GPIO_PIN_NUM) */
  41.     rt_uint32_t LED_TIME_CYCLE;
  42.     rt_uint32_t LED_TIME_OUTPUT;  
  44.     /* Value */
  45.     rt_uint16_t last_time_show_cycle;      // 状态查询时间
  46.     rt_uint16_t set_time_cycle;            // 循环时间
  47.     rt_uint16_t set_last_time;             // 上一次电平输出时间
  48.     rt_uint8_t  curr_number;            // 当前
  49.     rt_uint8_t  next_number;               // 下一个指示次数
  51.     /* Method */
  52.     void (*Init)(struct _MODULE_LED *module);
  53.     void (*Handle)(struct _MODULE_LED *module);
  54.     void (*Set)(struct _MODULE_LED *module,rt_uint8_t number);
  56. };
  57. typedef struct _MODULE_LED MODULE_LED;
  59. /* Glodal Method */
  60. rt_err_t Module_Led_Config(MODULE_LED *Dev_LED);
  62. #endif 
  63. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

Module_LED.c

  1. /*
  2.  * Copyright (c) 2020 - ~, HIT_HERO Team
  3.  *
  4.  * LED MODULE SOUCE FILE
  5.  * Used in RT-Thread Operate System
  6.  *
  7.  * Change Logs:
  8.  * Date           Author       Notes                Mail
  9.  * 2020-06-02     WangXi       first version        WangXi_chn@foxmail.com
  10.  * 2020-07-30     WangXi       second version        WangXi_chn@foxmail.com
  11.  */
  13. #include "Module_LED.h"
  14. #include <stdlib.h>
  16. /* User Code Begin*/
  17. static void led_shine_entry(void *parameter){
  18.     MODULE_LED* dev_led_1 = (MODULE_LED *)parameter;
  19.     dev_led_1->Handle(dev_led_1);
  20. }
  22. void LEDTest(int argc,char **argv)
  23. {
  24.     rt_err_t res = RT_EOK;
  26.     MODULE_LED dev_led_1 = {GET_PIN(H, 11)};
  27.     res = Module_Led_Config(&dev_led_1);
  28.     if(res != RT_EOK){
  29.         rt_kprintf("Error: Some wrong happened while led config\n");
  30.         return;
  31.     }
  33.     if (argc < 2){
  34.         rt_kprintf("Error: Command missing arguments\n");
  35.         return;
  36.     }
  38.     rt_uint32_t num = atoi(argv[1]); 
  39.     dev_led_1.Set(&dev_led_1,num);
  42.     rt_thread_t led_thread = rt_thread_create("ledshine", led_shine_entry, &dev_led_1,
  43.                                   192, RT_THREAD_PRIORITY_MAX - 2, 20);
  44.     if (led_thread != RT_NULL){
  45.         rt_thread_startup(led_thread);
  46.     }
  47. }
  48. MSH_CMD_EXPORT(LEDTest , LEDTest(PH11) <-number>(1~4));
  49. /* User Code End */
  51. /* Static Method */
  52. static void Module_LedInit(MODULE_LED *module);
  53. static void Module_LedSet(MODULE_LED *module,rt_uint8_t number);
  54. static void Module_LedHandle(MODULE_LED *module);
  56. /* Global Method */
  57. rt_err_t Module_Led_Config(MODULE_LED *Dev_LED){
  58.     if(Dev_LED->Init==NULL &&
  59.         Dev_LED->Set==NULL &&
  60.         Dev_LED->Handle==NULL
  62.     ){  
  63.         /* Link the Method */
  64.         Dev_LED->Init = Module_LedInit;
  65.         Dev_LED->Set = Module_LedSet;
  66.         Dev_LED->Handle = Module_LedHandle;
  67.     }
  68.     else{
  69.         rt_kprintf("Warning: Module Led is Configed twice\n");
  70.         return RT_ERROR;
  71.     }
  73.     /* Device Init */
  74.     Dev_LED->Init(Dev_LED);
  75.     return RT_EOK;
  76. }
  78. /* Static Method */
  79. static void Module_LedInit(MODULE_LED *module){
  80.     rt_pin_mode(module->pin, PIN_MODE_OUTPUT);
  81.     module->set_time_cycle = (rt_uint16_t)-1;
  82.     module->curr_number = 0;
  84. }
  86. static void Module_LedSet(MODULE_LED *module,rt_uint8_t number){
  87.     module->next_number = number;
  89. }
  91. static void Module_LedHandle(MODULE_LED *module){
  92.     /* get system clock */
  93.     rt_uint32_t time = rt_tick_get();
  95.     /* toggle the LED */
  96.     if(((uint16_t)(time - module->set_last_time)) >= module->set_time_cycle) {
  97.         module->set_last_time = time;
  98.         if(module->curr_number) {
  99.             //module->led_set(((module->curr_number & 1) == 1) ? LED_OFF : LED_ON);
  100.             rt_pin_write(module->pin, ((module->curr_number & 1) == 1) ? MODULE_LED_OFF : MODULE_LED_ON);
  101.             module->curr_number--;
  102.             if(module->curr_number == 0) {
  103.                 module->set_time_cycle = (uint16_t)-1;// 下一个周期不再进入
  104.             }
  105.         }
  106.     }
  107.     /* enable the new param */
  108.     if(((uint16_t)(time - module->last_time_show_cycle)) >= module->LED_TIME_CYCLE){
  109.         module->last_time_show_cycle = time;
  111.         if(!module->curr_number){
  112.             uint8_t number = module->next_number; // 获取当前指示次数
  113.             // 限制闪烁次数
  114.             if(number < (module->LED_TIME_CYCLE / module->LED_TIME_OUTPUT / 2)){
  115.                 module->curr_number    = number * 2 - 1;
  116.                 module->set_last_time  = time;
  117.                 module->set_time_cycle = module->LED_TIME_OUTPUT;
  118.                 //module->led_set(LED_ON);
  119.                 rt_pin_write(module->pin, MODULE_LED_ON);
  120.             }
  121.         }
  122.     }
  124. }
  128. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

使用

  2. #include <rtthread.h>
  3. #include <rtdevice.h>
  4. #include <board.h>
  6. #include "Module_LED.h"
  8. MODULE_LED dev_led_state = {GET_PIN(H, 10),1500,150};
  10. int main(void)
  11. {
  12.     int count = 1;
  14.     Module_Led_Config(&dev_led_state);
  15.     dev_led_state.Set(&dev_led_state,4);
  17.     while (count++)
  18.     {
  20.         dev_led_state.Handle(&dev_led_state);
  21.     }
  23.     return RT_EOK;
  24. }
  • 蜂鸣器较为复杂，涉及到无源蜂鸣器，需要驱动pwm设备

    Module_Beep.h

    ```c /*
    • Copyright (c) 2020 - ~, HIT_HERO Team *
    • BEEP MODULE HEAD FILE
    • Used in RT-Thread Operate System *
    • Change Logs:
    • Date Author Notes Mail
    • 2020-07-31 WangXi second version WangXi_chn@foxmail.com */

      ifndef MODULE_BEEP_H

      define MODULE_BEEP_H

enum _BEEP_STATION { MODULE_BEEP_ON = 0, MODULE_BEEP_OFF }; typedef enum _BEEP_STATION BEEP_STATION ;

include

include

include

struct _MODULE_BEEP { / Property / char * PwmDevName;

  1. rt_uint32_t PWM_CHANNEL;    
  2. rt_uint32_t PWM_FREQ;
  3. rt_uint32_t PWM_DUTY;
  5. rt_uint32_t BEEP_TIME_CYCLE;
  6. rt_uint32_t BEEP_TIME_OUTPUT;  
  8. /* Value */
  9. struct rt_device_pwm *pwm_dev;
  10. rt_uint16_t last_time_show_cycle;      // 状态查询时间
  11. rt_uint16_t set_time_cycle;            // 循环时间
  12. rt_uint16_t set_last_time;             // 上一次电平输出时间
  13. rt_uint8_t  curr_number;            // 当前
  14. rt_uint8_t  next_number;               // 下一个指示次数
  16. /* Method */
  17. void (*Init)(struct _MODULE_BEEP *module);
  18. void (*Handle)(struct _MODULE_BEEP *module);
  19. void (*Set)(struct _MODULE_BEEP *module,rt_uint8_t number);
  20. void (*Control)(struct _MODULE_BEEP *module,BEEP_STATION station);

}; typedef struct _MODULE_BEEP MODULE_BEEP;

/ Glodal Method / rt_err_t Module_Beep_Config(MODULE_BEEP *Dev_Beep);

endif

/** (C) COPYRIGHT 2020 WANGXI **END OF FILE**/

  1. <a name="iB5j3"></a>
  2. ## Module_Beep.c
  3. ```c
  4. /*
  5.  * Copyright (c) 2020 - ~, HIT_HERO Team
  6.  *
  7.  * BEEP MODULE SOUCE FILE
  8.  * Used in RT-Thread Operate System
  9.  *
  10.  * Change Logs:
  11.  * Date           Author       Notes                Mail
  12.  * 2020-07-31     WangXi       second version        WangXi_chn@foxmail.com
  13.  */
  15. #include "Module_Beep.h"
  16. #include <stdlib.h>
  18. /* User Code Begin*/
  19. static void Beep_shine_entry(void *parameter){
  20.     MODULE_BEEP* dev_beep_1 = (MODULE_BEEP *)parameter;
  21.     dev_beep_1->Handle(dev_beep_1);
  22. }
  24. void BeepTest(int argc,char **argv)
  25. {
  26.     rt_err_t res = RT_EOK;
  28.     MODULE_BEEP dev_beep_1 = {"pwm1",4,2000,20,1500,15};
  29.     res = Module_Beep_Config(&dev_beep_1);
  30.     if(res != RT_EOK){
  31.         rt_kprintf("Error: Some wrong happened while BEEP config\n");
  32.         return;
  33.     }
  35.     if (argc < 2){
  36.         rt_kprintf("Error: Command missing arguments\n");
  37.         return;
  38.     }
  40.     rt_uint32_t num = atoi(argv[1]); 
  41.     dev_beep_1.Set(&dev_beep_1,num);
  44.     rt_thread_t BEEP_thread = rt_thread_create("beepshine", Beep_shine_entry, &dev_beep_1,
  45.                                   192, RT_THREAD_PRIORITY_MAX - 2, 20);
  46.     if (BEEP_thread != RT_NULL){
  47.         rt_thread_startup(BEEP_thread);
  48.     }
  49. }
  50. MSH_CMD_EXPORT(BeepTest , BeepTest(PH11) <-number>(1~4));
  51. /* User Code End */
  53. /* Static Method */
  54. static void Module_BeepInit(MODULE_BEEP *module);
  55. static void Module_BeepSet(MODULE_BEEP *module,rt_uint8_t number);
  56. static void Module_BeepHandle(MODULE_BEEP *module);
  57. static void Module_BeepControl(MODULE_BEEP *module,BEEP_STATION station);
  59. /* Global Method */
  60. rt_err_t Module_Beep_Config(MODULE_BEEP *Dev_Beep){
  61.     if(Dev_Beep->Init==NULL &&
  62.         Dev_Beep->Set==NULL &&
  63.         Dev_Beep->Handle==NULL &&
  64.         Dev_Beep->Control==NULL
  66.     ){  
  67.         /* Link the Method */
  68.         Dev_Beep->Init = Module_BeepInit;
  69.         Dev_Beep->Set = Module_BeepSet;
  70.         Dev_Beep->Handle = Module_BeepHandle;
  71.         Dev_Beep->Control = Module_BeepControl;
  72.     }
  73.     else{
  74.         rt_kprintf("Warning: Module BEEP is Configed twice\n");
  75.         return RT_ERROR;
  76.     }
  78.     /* Device Init */
  79.     Dev_Beep->Init(Dev_Beep);
  80.     return RT_EOK;
  81. }
  83. /* Static Method */
  84. static void Module_BeepInit(MODULE_BEEP *module){    
  85.     rt_uint32_t PWM_period = 1000000000/module->PWM_FREQ;
  86.     rt_uint32_t PWM_pulse = PWM_period/100*module->PWM_DUTY; 
  87.     module->pwm_dev = (struct rt_device_pwm *)rt_device_find(module->PwmDevName);
  89.     if (module->pwm_dev == RT_NULL)
  90.         rt_kprintf("beep init failed! can't find pwm_beep device!\n");
  92.     rt_pwm_set(module->pwm_dev, module->PWM_CHANNEL, PWM_period, PWM_pulse);
  94.     module->set_time_cycle = (rt_uint16_t)-1;
  95.     module->curr_number = 0;
  97. }
  99. static void Module_BeepSet(MODULE_BEEP *module,rt_uint8_t number){
  100.     module->next_number = number;
  102. }
  104. static void Module_BeepHandle(MODULE_BEEP *module){
  105.     /* get system clock */
  106.     rt_uint32_t time = rt_tick_get();
  108.     /* toggle the BEEP */
  109.     if(((uint16_t)(time - module->set_last_time)) >= module->set_time_cycle) {
  110.         module->set_last_time = time;
  111.         if(module->curr_number) {
  113.             //rt_pin_write(module->pin, ((module->curr_number & 1) == 1) ? MODULE_BEEP_OFF : MODULE_BEEP_ON);
  114.             module->Control(module,((module->curr_number & 1) == 1) ? MODULE_BEEP_OFF : MODULE_BEEP_ON);
  115.             module->curr_number--;
  116.             if(module->curr_number == 0) {
  117.                 module->set_time_cycle = (uint16_t)-1;// 下一个周期不再进入
  118.             }
  119.         }
  120.     }
  121.     /* enable the new param */
  122.     if(((uint16_t)(time - module->last_time_show_cycle)) >= module->BEEP_TIME_CYCLE){
  123.         module->last_time_show_cycle = time;
  125.         if(!module->curr_number){
  126.             uint8_t number = module->next_number; // 获取当前指示次数
  127.             // 限制闪烁次数
  128.             if(number < (module->BEEP_TIME_CYCLE / module->BEEP_TIME_OUTPUT / 2)){
  129.                 module->curr_number    = number * 2 - 1;
  130.                 module->set_last_time  = time;
  131.                 module->set_time_cycle = module->BEEP_TIME_OUTPUT;                
  132.                 module->Control(module,MODULE_BEEP_ON);                
  133.             }
  134.         }
  135.     }
  137. }
  139. static void Module_BeepControl(MODULE_BEEP *module,BEEP_STATION station){
  140.     switch(station){
  141.         case MODULE_BEEP_ON:{
  142.             rt_pwm_enable(module->pwm_dev, module->PWM_CHANNEL);
  143.             break;
  144.             }
  145.         case MODULE_BEEP_OFF:{
  146.             rt_pwm_disable(module->pwm_dev, module->PWM_CHANNEL);
  147.             break;
  148.             }
  149.         }
  150. }
  152. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

使用

  2. #include <rtthread.h>
  3. #include <rtdevice.h>
  4. #include <board.h>
  6. #include "Module_Beep.h"
  8. MODULE_BEEP dev_beep_1 = {"pwm4",3,2000,20,2000,100};
  10. int main(void)
  11. {
  12.     int count = 1;
  14.     Module_Beep_Config(&dev_beep_1);    
  15.     dev_beep_1.Set(&dev_beep_1,4);
  17.     while (count++)
  18.     {        
  19.         dev_beep_1.Handle(&dev_beep_1);
  20.     }
  22.     return RT_EOK;
  23. }