学习目标

  1. 掌握驱动移植驱动

  2. 掌握动态修改周期

    学习内容

    需求

    图像_2023-08-19_081042121.png
    通过控制PB0来播放音乐
    PB0，采用Timer2 CH2来实现

    Timer功能实现

    ```c static void PWM_config() { uint32_t timerx = TIMER2; uint32_t timerx_rcu = RCU_TIMER2; uint32_t timerx_psc = RCU_TIMER_PSC_MUL4;

    uint32_t timerx_prescaler = PRESCALER; // 分频计数 uint32_t timerx_period = PERIOD; // 周期计数

    // ch2 uint32_t timerx_ch2_port = GPIOB; uint32_t timerx_ch2_port_rcu = RCU_GPIOB; uint32_t timerx_ch2_pin = GPIO_PIN_0; uint32_t timerx_ch2_af = GPIO_AF_2;

    /* GPIO config **/ //// ch2 //// p // 配置时钟 rcu_periph_clock_enable(timerx_ch2_port_rcu); // 配置GPIO模式 gpio_mode_set(timerx_ch2_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch2_pin); // 配置GPIO输出 gpio_output_options_set(timerx_ch2_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch2_pin); // 配置复用功能 gpio_af_set(timerx_ch2_port, timerx_ch2_af, timerx_ch2_pin);

    /* Timer config */ // 时钟配置 rcu_periph_clock_enable(timerx_rcu); // 复位定时器 timer_deinit(timerx); // 倍频配置 rcu_timer_clock_prescaler_config(timerx_psc);

    // 初始化定时器 timer_parameter_struct tps; timer_struct_para_init(&tps); tps.prescaler = timerx_prescaler; // 分频计数 tps.period = timerx_period; // 周期计数 timer_init(timerx, &tps);

    ////////// 配置输出通道 timer_oc_parameter_struct tops; ///// ch2 timer_channel_output_struct_para_init(&tops); // p config tops.outputstate = TIMER_CCX_ENABLE; timer_channel_output_config(timerx, TIMER_CH_2, &tops);

  1. ////////// 输出模式配置
  2. // ch2
  3. timer_channel_output_mode_config(timerx, TIMER_CH_2, TIMER_OC_MODE_PWM0);
  5. // 初始化
  6. timer_enable(timerx);

}

  1. ```c
  2. static void PWM_update_ch2(float duty) {
  3.     uint32_t timerx = TIMER2;
  4.     uint32_t timerx_chn = TIMER_CH_2;
  6.     uint32_t pulse = duty * (PERIOD + 1) / 100;
  7.     /***************** pwm update *******************/
  8.     // 配置输出的占空比
  9.     timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);
  10. }

原来的驱动

  1. #ifndef __BUZZER_H__
  2. #define __BUZZER_H__
  4. #include "config.h"
  6. // 初始化蜂鸣器
  7. void Buzzer_init();
  9. // 按照指定频率播放
  10. void Buzzer_play(u16 hz_val);
  12. // 按照指定的音调播放 1,2,3,4，..7
  13. void Buzzer_beep(u8 hz_val_index);
  15. // 停止播放
  16. void Buzzer_stop();
  18. #endif
  1. #include "Buzzer.h"
  3. #include "GPIO.h"
  4. #include "PWM.h"
  5. //               C     D    E     F     G     A      B       C`
  6. //u16 hz[] = {523, 587, 659, 698, 784, 880, 988, 1047};
  8. //            C            D            E             F            G            A            B          C`
  9. u16 hz[] = { 1047, 1175, 1319,  1397, 1568, 1760, 1976, 2093 };
  11. static void GPIO_config(void) {
  12.     GPIO_InitTypeDef    GPIO_InitStructure;        //结构定义
  13.     GPIO_InitStructure.Pin  = GPIO_Pin_0;        //指定要初始化的IO,
  14.     GPIO_InitStructure.Mode = GPIO_OUT_PP;    //指定IO的输入或输出方式,GPIO_PullUp,GPIO_HighZ,GPIO_OUT_OD,GPIO_OUT_PP
  15.     GPIO_Inilize(GPIO_P0, &GPIO_InitStructure);//初始化
  16. }
  18. void Buzzer_init(){
  19.     GPIO_config();
  20. }
  22. void Buzzer_beep(u8 hz_val_index){ // 1,2,3,4 ... 7
  24.     u16 hz_val = hz[hz_val_index - 1];
  26.     Buzzer_play(hz_val);
  27. }
  29. void Buzzer_play(u16 hz_val){
  31.     u16 Period = MAIN_Fosc / hz_val;
  33.     PWMx_InitDefine        PWMx_InitStructure;
  34.     // 总配置
  35.     // (MAIN_Fosc / 1000 - 1) 周期计数值
  36.     PWMx_InitStructure.PWM_Period           = Period - 1;    //周期时间,   0~65535
  37.     PWMx_InitStructure.PWM_DeadTime         = 0;                                //死区发生器设置, 0~255
  38.     PWMx_InitStructure.PWM_EnoSelect        = ENO5P;    //输出通道选择,    ENO1P,ENO1N,ENO2P,ENO2N,ENO3P,ENO3N,ENO4P,ENO4N / ENO5P,ENO6P,ENO7P,ENO8P
  39.     PWMx_InitStructure.PWM_PS_SW            = PWM5_SW_P00;//切换端口
  41.     // 具体PWM端口配置
  42.     // pwm5
  43.     PWMx_InitStructure.PWM5_Mode            = CCMRn_PWM_MODE1;    //模式,        CCMRn_FREEZE,CCMRn_MATCH_VALID,CCMRn_MATCH_INVALID,CCMRn_ROLLOVER,CCMRn_FORCE_INVALID,CCMRn_FORCE_VALID,CCMRn_PWM_MODE1,CCMRn_PWM_MODE2
  44.     PWMx_InitStructure.PWM5_Duty            = Period / 2;            //PWM4占空比时间, 0~Period     声音的大小、响度
  46.     // pwm5
  47.     PWMx_InitStructure.PWM_CC5Enable   = ENABLE;                //开启PWM6P输入捕获/比较输出,  ENABLE,DISABLE
  49.     // PWM启动配置
  50.     PWMx_InitStructure.PWM_MainOutEnable= ENABLE;                //主输出使能, ENABLE,DISABLE
  51.     PWMx_InitStructure.PWM_CEN_Enable   = ENABLE;                //使能计数器, ENABLE,DISABLE
  52.     PWM_Configuration(PWMB, &PWMx_InitStructure);                //初始化PWM,  PWMA,PWMB
  53. }
  56. void Buzzer_stop(){
  58.     PWMx_InitDefine        PWMx_InitStructure;
  59.     PWMx_InitStructure.PWM_MainOutEnable= DISABLE;                //主输出使能, ENABLE,DISABLE
  60.     PWMx_InitStructure.PWM_CEN_Enable   = DISABLE;                //使能计数器, ENABLE,DISABLE
  61.     PWM_Configuration(PWMB, &PWMx_InitStructure);                //初始化PWM,  PWMA,PWMB
  62. }
  1. #include "config.h"
  2. #include "delay.h"
  3. #include "GPIO.h"
  4. #include "Buzzer.h"
  6. // 两只老虎 
  7. // 音符
  8. u8 code notes[] = {
  9.     1, 2, 3, 1,                    1, 2, 3, 1,                    3, 4, 5,        3, 4, 5,
  10.     5, 6, 5, 4, 3, 1,     5, 6, 5, 4, 3, 1,     1, 5, 1,        1, 5, 1,
  11. };
  13. // 延时时长
  14. u8 code durations[] = {
  15.     4, 4, 4, 4,                    4, 4, 4, 4,                    4, 4, 8,        4, 4, 8,
  16.     3, 1, 3, 1, 4, 4,        3, 1, 3, 1, 4, 4,        4, 4, 8,        4, 4, 8,
  17. };
  19. int main() {
  20.     u8 i = 0;
  21.     u8 len = 0;
  22.     u16 delay = 0;
  24.     Buzzer_init();
  26.     len = sizeof(notes) / sizeof(u8);
  27.     while(1) {
  29.         for(i = 0; i < len; i++){
  30.             Buzzer_beep(notes[i]);
  31.             delay = durations[i] * 100;
  33.             // 声响延时
  34.             delay_X_ms(delay);
  36.             // stop
  37.             Buzzer_stop();
  38.             delay_ms(20);
  39.         }
  40.         // stop
  41.         Buzzer_stop();
  43.         delay_ms(250);
  44.         delay_ms(250);
  45.         delay_ms(250);
  46.         delay_ms(250);
  48.     }
  49. }

移植操作

替换初始化

  1. void Buzzer_init(){
  2.     PWM_config();
  3. }

将原有的初始化逻辑修改为新的pwm更新

更新Play函数

  1. void Buzzer_play(uint16_t hz_val){
  3.     period = SystemCoreClock / hz_val / 10 - 1;
  5.     uint32_t timerx = TIMER2;
  6.     // 初始化定时器
  7.     timer_parameter_struct tps;
  8.     timer_struct_para_init(&tps);
  9.     tps.prescaler = 10 - 1; // 分频计数 
  10.     tps.period =  period; // 周期计数
  11.     timer_init(timerx, &tps);
  13.     PWM_update_ch2(50);
  14. }
  • 分频问题需要解决
  • 分频根据hz值来设定

    完整代码

    ```c

    ifndef BSP_BUZZER_H

    define BSP_BUZZER_H

include “gd32f4xx.h”

// 初始化蜂鸣器 void Buzzer_init();

// 按照指定频率播放 void Buzzer_play(uint16_t hz_val);

// 按照指定的音调播放 1,2,3,4，..7 void Buzzer_beep(uint8_t hz_val_index);

// 停止播放 void Buzzer_stop();

endif

  1. ```c
  2. #include "bsp_buzzer.h"
  4. #define PRESCALER        (10 - 1) 
  5. #define PERIOD             (SystemCoreClock / 100000 - 1) 
  7. uint16_t period;
  8. //               C     D    E     F     G     A      B       C`
  9. //u16 hz[] = {523, 587, 659, 698, 784, 880, 988, 1047};
  11. //            C            D            E             F            G            A            B          C`
  12. uint16_t hz[] = { 1047, 1175, 1319,  1397, 1568, 1760, 1976, 2093 };
  14. static void PWM_config() {
  15.     uint32_t timerx = TIMER2;
  16.     uint32_t timerx_rcu = RCU_TIMER2;
  17.     uint32_t timerx_psc = RCU_TIMER_PSC_MUL4;
  19.     uint32_t timerx_prescaler = PRESCALER; // 分频计数
  20.     uint32_t timerx_period = PERIOD; // 周期计数
  23.     // ch2
  24.     uint32_t timerx_ch2_port = GPIOB; 
  25.     uint32_t timerx_ch2_port_rcu = RCU_GPIOB;
  26.     uint32_t timerx_ch2_pin = GPIO_PIN_0;
  27.     uint32_t timerx_ch2_af = GPIO_AF_2;
  29.     /*************** GPIO config **************/
  30.     //// ch2
  31.     ////    p
  32.     // 配置时钟
  33.     rcu_periph_clock_enable(timerx_ch2_port_rcu);
  34.     // 配置GPIO模式
  35.     gpio_mode_set(timerx_ch2_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch2_pin);
  36.     // 配置GPIO输出
  37.     gpio_output_options_set(timerx_ch2_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch2_pin);
  38.     // 配置复用功能
  39.     gpio_af_set(timerx_ch2_port, timerx_ch2_af, timerx_ch2_pin);
  41.     /*************** Timer config *************/
  42.     // 时钟配置
  43.     rcu_periph_clock_enable(timerx_rcu);
  44.     // 复位定时器
  45.     timer_deinit(timerx);
  46.     // 倍频配置
  47.     rcu_timer_clock_prescaler_config(timerx_psc);
  49.     // 初始化定时器
  50.     timer_parameter_struct tps;
  51.     timer_struct_para_init(&tps);
  52.     tps.prescaler = timerx_prescaler; // 分频计数
  53.     tps.period =  timerx_period; // 周期计数
  54.     timer_init(timerx, &tps);
  56.     ////////// 配置输出通道
  57.     timer_oc_parameter_struct tops;
  58.     ///// ch2
  59.     timer_channel_output_struct_para_init(&tops);
  60.     // p config
  61.     tops.outputstate = TIMER_CCX_ENABLE;
  62.     timer_channel_output_config(timerx, TIMER_CH_2, &tops);
  65.     ////////// 输出模式配置
  66.     // ch2
  67.     timer_channel_output_mode_config(timerx, TIMER_CH_2, TIMER_OC_MODE_PWM0);
  69.     // 初始化
  70.     timer_enable(timerx);
  71. }
  73. static void PWM_update_ch2(float duty) {
  74.     uint32_t timerx = TIMER2;
  75.     uint32_t timerx_chn = TIMER_CH_2;
  77.     uint32_t pulse = duty * (period + 1) / 100;
  78.     /***************** pwm update *******************/
  79.     // 配置输出的占空比
  80.     timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);
  81. }
  84. void Buzzer_init(){
  85.     PWM_config();
  86. }
  88. void Buzzer_beep(uint8_t hz_val_index){ // 1,2,3,4 ... 7
  90.     uint16_t hz_val = hz[hz_val_index - 1];
  92.     Buzzer_play(hz_val);
  93. }
  95. void Buzzer_play(uint16_t hz_val){
  97.     period = SystemCoreClock / hz_val / 10 - 1;
  99.     uint32_t timerx = TIMER2;
  100.     // 初始化定时器
  101.     timer_parameter_struct tps;
  102.     timer_struct_para_init(&tps);
  103.     tps.prescaler = 10 - 1; // 分频计数 
  104.     tps.period =  period; // 周期计数
  105.     timer_init(timerx, &tps);
  107.     PWM_update_ch2(50);
  108. }
  111. void Buzzer_stop(){
  112.     PWM_update_ch2(0);
  113. }

练习题

  1. 实现buzzer播放music
  2. 体会所有Timer的逻辑，尝试封装Timer