学习目标

  1. 能够理解bsp开发

  2. 能够基于需求进行bsp驱动封装

    学习内容

    需求介绍

    009.png
    开发版中有4个灯，现在需要用4个灯显示充电情况：

  3. 开始充电时，需要呈现出流水灯闪烁

  4. 4盏灯表示当前的电量
  5. 充电流水灯起始位置是当前电量，全部点亮后，再次从当前电量位置进入流水灯效果
  6. 结束充电时，关闭充电显示，当前电量进行闪烁3次，然后熄灭。

充电.gif

现实问题

  1. 产品最终电路板还没画好，目前只有产品所使用的芯片对应的开发板。
  2. ADC功能是别人开发，还没完成。

  3. 老板要求，如果开发板好了，要尽快完成工作。

    需求分析

    要啥没啥，还得尽快完成。盘点手头有的东西，开发板。构建测试案例逻辑，方便后续移植。
    测试案例设计：

  4. 准备工作，4个灯，3个按钮

  5. 按钮1按下时，模拟开始充电
  6. 按钮2按下时，模拟停止充电
  7. 按钮3按下时，模拟电量增加。

如果测试方案通过，基本上功能完成，那么后续其他人工作完成后，只需要对接以下逻辑：

  1. 灯对应的引脚和最终设计的电路板引脚进行校准
  2. 开始充电
  3. 电量变化时，更新电量
  4. 结束充电

编码实现分析：

  1. 需要把4个灯作为一个业务逻辑整体，完成一套关于电池电量显示的驱动
  2. 需要抽象出业务逻辑，转换为函数实现

    测试案例构建

    174.png175.png
  • PD0作为：开始按钮
  • PD1作为：停止按钮
  • PD5作为：电量更新按钮

按钮逻辑构建

  1. static void GPIO_config(){
  2.     // LED1    测试按钮
  3.     // rcu时钟 
  4. //    rcu_periph_clock_enable(RCU_GPIOE);
  5. //    // GPIO
  6. //    gpio_mode_set(GPIOE,GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_3);
  7. //    gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);
  9.     // PD0    开始充电
  10.     // PD1     结束充电
  11.     // PD5    电量变化
  12.     // rcu时钟
  13.     rcu_periph_clock_enable(RCU_GPIOD);
  14.     // 配置GPIO模式
  15.     gpio_mode_set(GPIOD,GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_5);    
  16. }
  2. int main(void)
  3. {
  4.     systick_config();
  6.     GPIO_config();
  8.     Battery_led_init();
  10.     uint32_t cnt = 0;
  11.     uint8_t power = 1;
  12.     FlagStatus pre_key1 = SET;
  13.     FlagStatus pre_key2 = SET;
  14.     FlagStatus pre_key3 = SET;
  15.     while(1) {
  17.             FlagStatus cur_key1 = gpio_input_bit_get(GPIOD, GPIO_PIN_0);            
  18.             if (cur_key1 != pre_key1){
  19.                     if (cur_key1 == RESET){
  20.                         // 按下
  21.                     }else {
  22.                         // 抬起, 开始充电
  23.                         Battery_led_start(power);
  24.                     }
  25.                     pre_key1 = cur_key1;
  26.             }
  28.             FlagStatus cur_key2 = gpio_input_bit_get(GPIOD, GPIO_PIN_1);            
  29.             if (cur_key2 != pre_key2){
  30.                     if (cur_key2 == RESET){
  31.                         // 按下
  32.                     }else {
  33.                         // 抬起, 停止充电
  34.                         Battery_led_stop();
  35.                     }        
  36.                     pre_key2 = cur_key2;
  37.             }
  39.             FlagStatus cur_key3 = gpio_input_bit_get(GPIOD, GPIO_PIN_5);            
  40.             if (cur_key3 != pre_key3){
  41.                     if (cur_key3 == RESET){
  42.                         // 按下
  43.                     }else {
  44.                         // 抬起, 增加电量
  45.                         power++;
  46.                         if(power > 4) power = 4;
  47.                         Battery_led_update(power);
  48.                     }
  50.                     pre_key3 = cur_key3;
  51.             }
  53.             if(++cnt % 25 == 0){    // 20ms * 25 = 500ms
  54.                 Battery_led_loop();
  55.             }
  57.             delay_1ms(20);
  58.     }
  59. }

BSP驱动构建

接口定义

  1. 驱动初始化，属于标配
  2. 业务相关的操作行为抽象化

  3. 时序问题

    1. void Battery_led_int();

    具体的业务抽象行为

    1. void Battery_led_start(uint8_t power);
    1. void Battery_led_stop();
    1. void Battery_led_update(uint8_t power);

    在涉及到需要控制时间的问题时，我们通常有以下做法：

  4. 自己主动调用 delay来进行延时

  5. 使用统一的延时，到达自己的时间点就去执行

自己调用delay 不利于后续的移植。
采用统一时钟，方便移植，也方便时间片统一调度管理

业务实现

  1. 采用bsp独立驱动进行开发
  2. 状态管理，通过status记录当前状态。
  3. 电量记录，记录当前电量。
  4. 充电闪烁计数，记录当前的闪烁的值。 ```c

    ifndef BSP_BATTERY_LED_H

    define BSP_BATTERY_LED_H

include “gd32f4xx.h”

include “systick.h”

define LED1_RCU RCU_GPIOE

define LED1_GPIO GPIOE, GPIO_PIN_3

define LED2_RCU RCU_GPIOD

define LED2_GPIO GPIOD, GPIO_PIN_7

define LED3_RCU RCU_GPIOG

define LED3_GPIO GPIOG, GPIO_PIN_3

define LED4_RCU RCU_GPIOA

define LED4_GPIO GPIOA, GPIO_PIN_5

define LED1_ON() gpio_bit_set(LED1_GPIO)

define LED1_OFF() gpio_bit_reset(LED1_GPIO)

define LED2_ON() gpio_bit_set(LED2_GPIO)

define LED2_OFF() gpio_bit_reset(LED2_GPIO)

define LED3_ON() gpio_bit_set(LED3_GPIO)

define LED3_OFF() gpio_bit_reset(LED3_GPIO)

define LED4_ON() gpio_bit_set(LED4_GPIO)

define LED4_OFF() gpio_bit_reset(LED4_GPIO)

void Battery_led_init();

void Battery_led_start(uint8_t power);

void Battery_led_loop();

void Battery_led_update(uint8_t power);

void Battery_led_stop();

endif

  1. ```c
  2. #include "bsp_battery_led.h"
  5. static void LED_GPIO_init(rcu_periph_enum periph, uint32_t gpio_periph, uint32_t pin) {
  6.     // 时钟
  7.     rcu_periph_clock_enable(periph);
  8.     // GPIO
  9.     gpio_mode_set(gpio_periph,GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, pin);
  10.     gpio_output_options_set(gpio_periph, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, pin);
  11. }
  13. void Battery_led_init() {
  14.     // 初始化LED为推挽输出模式
  15.     // PE3 PD7 PG3 PA5
  16.     LED_GPIO_init(LED1_RCU, LED1_GPIO);
  17.     LED_GPIO_init(LED2_RCU, LED2_GPIO);
  18.     LED_GPIO_init(LED3_RCU, LED3_GPIO);
  19.     LED_GPIO_init(LED4_RCU, LED4_GPIO);
  21. }
  23. // 0: stop , 1: start, 2: stoping
  24. int status = 0;
  25. // 当前电量
  26. static int current_power = 0;
  27. // 充电显示灯位置
  28. static int show_power = 0;
  30. void Battery_led_start(uint8_t power) {
  31.     // power [0, 4]
  32.     current_power = power;
  33.     show_power = current_power;
  35.     status = 1;
  36. }
  38. void Battery_led_loop() {
  39.     if (status == 0) {
  41.         LED1_OFF();
  42.         LED2_OFF();
  43.         LED3_OFF();
  44.         LED4_OFF();
  46.     } else if (status == 1) {
  48.         show_power++;
  49.         if (show_power > 4) {
  50.             show_power = current_power;
  51.         }
  53.         // 亮前show_power个灯
  54.         show_power >= 1 ? LED1_ON() : LED1_OFF();
  55.         show_power >= 2 ? LED2_ON() : LED2_OFF();
  56.         show_power >= 3 ? LED3_ON() : LED3_OFF();
  57.         show_power >= 4 ? LED4_ON() : LED4_OFF();
  58.     } else if (status == 2) {
  59.         uint8_t i;
  60.         // 当前电量闪三次
  61.         for( i = 0; i < 3; i++) {
  62.             LED1_OFF();
  63.             LED2_OFF();
  64.             LED3_OFF();
  65.             LED4_OFF();
  66.             delay_1ms(250);
  67.             current_power >= 1 ? LED1_ON() : LED1_OFF();
  68.             current_power >= 2 ? LED2_ON() : LED2_OFF();
  69.             current_power >= 3 ? LED3_ON() : LED3_OFF();
  70.             current_power >= 4 ? LED4_ON() : LED4_OFF();
  71.             delay_1ms(250);
  72.         }
  73.         status = 0;
  74.     }
  75. }
  77. void Battery_led_update(uint8_t power) {
  78.     current_power = power;
  79. }
  81. void Battery_led_stop() {
  82.     status = 2;
  83. }

练习

  1. 实现充电led驱动实现