学习目标

  1. 加强掌握PWM开发流程
  2. 理解定时器与通道的关系
  3. 掌握多通道配置策略
  4. 掌握互补PWM配置策略
  5. 掌握定时器查询方式
  6. 掌握代码抽取优化策略
  7. 掌握PWM调试方式

    学习内容

    需求

    210.png209.png
    211.png
    点亮8个灯，采用pwm的方式。
定时器 通道 引脚 AF 极性 LED序号
T0 ch0 PA7 AF1 ON LED1
PA8 AF1 OP LED2
T7 ch2 PB15 AF3 ON LED3
PC8 AF3 OP LED4
ch1 PB14 AF3 ON LED5
PC7 AF3 OP LED6
ch0 PA5 AF3 ON LED7
PC6 AF3 OP LED8

实现互补效果。

高级定时器单通道互补功能

开发流程

  1. 添加Timer依赖
  2. 初始化PWM
  3. 配置通道的P极和N极
  4. PWM占空比控制

    通道配置

    1. ////////// 配置输出通道
    2. timer_oc_parameter_struct tops;
    3. // ch0
    4. timer_channel_output_struct_para_init(&tops);
    5. // n config
    6. tops.outputnstate  = TIMER_CCXN_ENABLE;
    7. // p config
    8. tops.outputstate = TIMER_CCX_ENABLE;
    9. timer_channel_output_config(timerx, TIMER_CH_0, &tops);
  • ocnpolarity：N极性电平
  • ocpolarity：P极性电平

    完整代码

    ```c

    include “gd32f4xx.h”

    include “systick.h”

    include

    include “main.h”

    include “Usart0.h”

// T0 // ch0 PA7 ON // ch0 PA8 OP

// 分频计数 // 周期计数

define PRESCALER (10 - 1)

define PERIOD (SystemCoreClock / 100000 - 1)

void Usart0_recv(uint8_t *data, uint32_t len) {

}

static void PWM_config() { uint32_t timerx = TIMER0; uint32_t timerx_rcu = RCU_TIMER0; uint32_t timerx_psc = RCU_TIMER_PSC_MUL2;

  1. uint32_t timerx_prescaler = PRESCALER; // 分频计数
  2. uint32_t timerx_period = PERIOD; // 周期计数
  4. uint32_t timerx_ch0_p_port = GPIOA; 
  5. uint32_t timerx_ch0_p_port_rcu = RCU_GPIOA;
  6. uint32_t timerx_ch0_p_pin = GPIO_PIN_8;
  7. uint32_t timerx_ch0_p_af = GPIO_AF_1;
  9. uint32_t timerx_ch0_n_port = GPIOA; 
  10. uint32_t timerx_ch0_n_port_rcu = RCU_GPIOA;
  11. uint32_t timerx_ch0_n_pin = GPIO_PIN_7;
  12. uint32_t timerx_ch0_n_af = GPIO_AF_1;
  14. /*************** GPIO config **************/
  15. //// ch0 p
  16. // 配置时钟
  17. rcu_periph_clock_enable(timerx_ch0_p_port_rcu);
  18. // 配置GPIO模式
  19. gpio_mode_set(timerx_ch0_p_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch0_p_pin);
  20. // 配置GPIO输出
  21. gpio_output_options_set(timerx_ch0_p_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch0_p_pin);
  22. // 配置复用功能
  23. gpio_af_set(timerx_ch0_p_port, timerx_ch0_p_af, timerx_ch0_p_pin);
  25. //// ch0 n
  26. // 配置时钟
  27. rcu_periph_clock_enable(timerx_ch0_n_port_rcu);
  28. // 配置GPIO模式
  29. gpio_mode_set(timerx_ch0_n_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch0_n_pin);
  30. // 配置GPIO输出
  31. gpio_output_options_set(timerx_ch0_n_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch0_n_pin);
  32. // 配置复用功能
  33. gpio_af_set(timerx_ch0_n_port, timerx_ch0_n_af, timerx_ch0_n_pin);
  35. /*************** Timer config *************/
  36. // 时钟配置
  37. rcu_periph_clock_enable(timerx_rcu);
  38. // 复位定时器
  39. timer_deinit(timerx);
  40. // 倍频配置
  41. rcu_timer_clock_prescaler_config(timerx_psc);
  43. // 初始化定时器
  44. timer_parameter_struct tps;
  45. timer_struct_para_init(&tps);
  46. tps.prescaler = timerx_prescaler; // 分频计数
  47. tps.period =  timerx_period; // 周期计数
  48. timer_init(timerx, &tps);
  50. ////////// 配置输出通道
  51. timer_oc_parameter_struct tops;
  52. // ch0
  53. timer_channel_output_struct_para_init(&tops);
  54. // n config
  55. tops.outputnstate  = TIMER_CCXN_ENABLE;
  56. // p config
  57. tops.outputstate = TIMER_CCX_ENABLE;
  58. timer_channel_output_config(timerx, TIMER_CH_0, &tops);
  61. ////////// 输出模式配置
  62. // ch0
  63. timer_channel_output_mode_config(timerx, TIMER_CH_0, TIMER_OC_MODE_PWM0);
  65. ////////// Break配置
  66. timer_break_parameter_struct tbps;
  67. timer_break_struct_para_init(&tbps);
  68. tbps.breakpolarity   = TIMER_BREAK_POLARITY_HIGH;
  69. tbps.outputautostate = TIMER_OUTAUTO_ENABLE;
  70. tbps.breakstate = TIMER_BREAK_ENABLE;
  71. timer_break_config(timerx, &tbps);
  73. // 初始化
  74. timer_enable(timerx);

}

static void PWM_update_ch0(float duty) { uint32_t timerx = TIMER0; uint32_t timerx_chn = TIMER_CH_0;

  1. uint32_t pulse = duty * (PERIOD + 1) / 100;
  2. /***************** pwm update *******************/
  3. // 配置输出的占空比
  4. timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);

}

static void GPIO_config() { // 配置时钟 rcu_periph_clock_enable(RCU_GPIOA); // 配置GPIO模式 gpio_mode_set(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_3); // 配置GPIO输出 gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, GPIO_PIN_3); }

int main(void) { systick_config(); nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2); Usart0_init(); GPIO_config(); PWM_config();

  1. gpio_bit_reset(GPIOA, GPIO_PIN_3);
  3. int8_t i;
  4. while(1) {
  5.     for(i = 0; i < 25; i++) {
  6.         PWM_update_ch0(i);            
  7.         delay_1ms(50);
  8.     }
  9.     for(i = 24; i >= 0; i--) {
  10.         PWM_update_ch0(i);
  11.         delay_1ms(50);
  12.     }
  14.     delay_1ms(1000);
  15. }

}

  1. <a name="q1l0U"></a>
  2. ### 高级定时器多通道互补功能
  3. <a name="qXpuR"></a>
  4. #### 开发流程
  6. 1. 添加Timer依赖
  7. 2. 初始化PWM
  8. 3. 配置通道的P极和N极
  9. 4. PWM占空比控制
  10. <a name="sLxj0"></a>
  11. #### 多通道配置
  12. ```c
  13. timer_oc_parameter_struct tops;
  14. timer_channel_output_struct_para_init(&tops);
  15. // n config
  16. tops.outputnstate  = TIMER_CCXN_ENABLE;
  17. tops.ocnpolarity  = TIMER_OCN_POLARITY_LOW;
  18. // p config
  19. tops.outputstate = TIMER_CCX_ENABLE;
  20. tops.ocpolarity  = TIMER_OC_POLARITY_LOW;
  22. ///// ch0
  23. timer_channel_output_config(timerx, TIMER_CH_0, &tops);
  25. ///// ch1
  26. timer_channel_output_config(timerx, TIMER_CH_1, &tops);
  28. ///// ch2
  29. timer_channel_output_config(timerx, TIMER_CH_2, &tops);

完整代码

  1. #include "gd32f4xx.h"
  2. #include "systick.h"
  3. #include <stdio.h>
  4. #include "main.h"
  5. #include "Usart0.h"
  7. // T7
  8. // ch0    
  9. //    N:    PA5        ON
  10. //    P:    PC6        OP
  11. // ch1    
  12. //    N:    PB14    ON
  13. //    P:    PC7        OP
  14. // ch2    
  15. //    N:    PB15    ON
  16. //    P:    PC8        OP
  18. // 分频计数
  19. // 周期计数
  20. #define PRESCALER        (10 - 1) 
  21. #define PERIOD             (SystemCoreClock / 100000 - 1) 
  23. void Usart0_recv(uint8_t *data, uint32_t len) {
  25. }
  27. static void PWM_config() {
  28.     uint32_t timerx = TIMER7;
  29.     uint32_t timerx_rcu = RCU_TIMER7;
  30.     uint32_t timerx_psc = RCU_TIMER_PSC_MUL2;
  32.     uint32_t timerx_prescaler = PRESCALER; // 分频计数
  33.     uint32_t timerx_period = PERIOD; // 周期计数
  35.     // ch0
  36.     uint32_t timerx_ch0_n_port = GPIOA; 
  37.     uint32_t timerx_ch0_n_port_rcu = RCU_GPIOA;
  38.     uint32_t timerx_ch0_n_pin = GPIO_PIN_5;
  39.     uint32_t timerx_ch0_n_af = GPIO_AF_3;
  41.     uint32_t timerx_ch0_p_port = GPIOC; 
  42.     uint32_t timerx_ch0_p_port_rcu = RCU_GPIOC;
  43.     uint32_t timerx_ch0_p_pin = GPIO_PIN_6;
  44.     uint32_t timerx_ch0_p_af = GPIO_AF_3;
  46.     // ch1
  47.     uint32_t timerx_ch1_n_port = GPIOB; 
  48.     uint32_t timerx_ch1_n_port_rcu = RCU_GPIOB;
  49.     uint32_t timerx_ch1_n_pin = GPIO_PIN_14;
  50.     uint32_t timerx_ch1_n_af = GPIO_AF_3;
  52.     uint32_t timerx_ch1_p_port = GPIOC; 
  53.     uint32_t timerx_ch1_p_port_rcu = RCU_GPIOC;
  54.     uint32_t timerx_ch1_p_pin = GPIO_PIN_7;
  55.     uint32_t timerx_ch1_p_af = GPIO_AF_3;
  57.     // ch2
  58.     uint32_t timerx_ch2_n_port = GPIOB; 
  59.     uint32_t timerx_ch2_n_port_rcu = RCU_GPIOB;
  60.     uint32_t timerx_ch2_n_pin = GPIO_PIN_15;
  61.     uint32_t timerx_ch2_n_af = GPIO_AF_3;
  63.     uint32_t timerx_ch2_p_port = GPIOC; 
  64.     uint32_t timerx_ch2_p_port_rcu = RCU_GPIOC;
  65.     uint32_t timerx_ch2_p_pin = GPIO_PIN_8;
  66.     uint32_t timerx_ch2_p_af = GPIO_AF_3;
  68.     /*************** GPIO config **************/
  69.     //// ch0 
  70.     ////    p
  71.     // 配置时钟
  72.     rcu_periph_clock_enable(timerx_ch0_p_port_rcu);
  73.     // 配置GPIO模式
  74.     gpio_mode_set(timerx_ch0_p_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch0_p_pin);
  75.     // 配置GPIO输出
  76.     gpio_output_options_set(timerx_ch0_p_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch0_p_pin);
  77.     // 配置复用功能
  78.     gpio_af_set(timerx_ch0_p_port, timerx_ch0_p_af, timerx_ch0_p_pin);
  79.     ////  n
  80.     // 配置时钟
  81.     rcu_periph_clock_enable(timerx_ch0_n_port_rcu);
  82.     // 配置GPIO模式
  83.     gpio_mode_set(timerx_ch0_n_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch0_n_pin);
  84.     // 配置GPIO输出
  85.     gpio_output_options_set(timerx_ch0_n_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch0_n_pin);
  86.     // 配置复用功能
  87.     gpio_af_set(timerx_ch0_n_port, timerx_ch0_n_af, timerx_ch0_n_pin);
  89.     //// ch1
  90.     ////    p
  91.     // 配置时钟
  92.     rcu_periph_clock_enable(timerx_ch1_p_port_rcu);
  93.     // 配置GPIO模式
  94.     gpio_mode_set(timerx_ch1_p_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch1_p_pin);
  95.     // 配置GPIO输出
  96.     gpio_output_options_set(timerx_ch1_p_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch1_p_pin);
  97.     // 配置复用功能
  98.     gpio_af_set(timerx_ch1_p_port, timerx_ch1_p_af, timerx_ch1_p_pin);
  99.     ////  n
  100.     // 配置时钟
  101.     rcu_periph_clock_enable(timerx_ch1_n_port_rcu);
  102.     // 配置GPIO模式
  103.     gpio_mode_set(timerx_ch1_n_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch1_n_pin);
  104.     // 配置GPIO输出
  105.     gpio_output_options_set(timerx_ch1_n_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch1_n_pin);
  106.     // 配置复用功能
  107.     gpio_af_set(timerx_ch1_n_port, timerx_ch1_n_af, timerx_ch1_n_pin);
  109.     //// ch2
  110.     ////    p
  111.     // 配置时钟
  112.     rcu_periph_clock_enable(timerx_ch2_p_port_rcu);
  113.     // 配置GPIO模式
  114.     gpio_mode_set(timerx_ch2_p_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch2_p_pin);
  115.     // 配置GPIO输出
  116.     gpio_output_options_set(timerx_ch2_p_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch2_p_pin);
  117.     // 配置复用功能
  118.     gpio_af_set(timerx_ch2_p_port, timerx_ch2_p_af, timerx_ch2_p_pin);
  119.     ////  n
  120.     // 配置时钟
  121.     rcu_periph_clock_enable(timerx_ch2_n_port_rcu);
  122.     // 配置GPIO模式
  123.     gpio_mode_set(timerx_ch2_n_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_ch2_n_pin);
  124.     // 配置GPIO输出
  125.     gpio_output_options_set(timerx_ch2_n_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_ch2_n_pin);
  126.     // 配置复用功能
  127.     gpio_af_set(timerx_ch2_n_port, timerx_ch2_n_af, timerx_ch2_n_pin);
  129.     /*************** Timer config *************/
  130.     // 时钟配置
  131.     rcu_periph_clock_enable(timerx_rcu);
  132.     // 复位定时器
  133.     timer_deinit(timerx);
  134.     // 倍频配置
  135.     rcu_timer_clock_prescaler_config(timerx_psc);
  137.     // 初始化定时器
  138.     timer_parameter_struct tps;
  139.     timer_struct_para_init(&tps);
  140.     tps.prescaler = timerx_prescaler; // 分频计数
  141.     tps.period =  timerx_period; // 周期计数
  142.     timer_init(timerx, &tps);
  144.     ////////// 配置输出通道
  145.     timer_oc_parameter_struct tops;
  146.     ///// ch0
  147.     timer_channel_output_struct_para_init(&tops);
  148.     // n config
  149.     tops.outputnstate  = TIMER_CCXN_ENABLE;
  150.     tops.ocpolarity  = TIMER_OC_POLARITY_LOW;
  151.     // p config
  152.     tops.outputstate = TIMER_CCX_ENABLE;
  153.     tops.ocpolarity  = TIMER_OC_POLARITY_LOW;
  154.     timer_channel_output_config(timerx, TIMER_CH_0, &tops);
  156.     ///// ch1
  157.     timer_channel_output_struct_para_init(&tops);
  158.     // n config
  159.     tops.outputnstate  = TIMER_CCXN_ENABLE;
  160.     // p config
  161.     tops.outputstate = TIMER_CCX_ENABLE;
  162.     tops.ocpolarity  = TIMER_OC_POLARITY_LOW;
  163.     timer_channel_output_config(timerx, TIMER_CH_1, &tops);
  165.     ///// ch2
  166.     timer_channel_output_struct_para_init(&tops);
  167.     // n config
  168.     tops.outputnstate  = TIMER_CCXN_ENABLE;
  169.     // p config
  170.     tops.outputstate = TIMER_CCX_ENABLE;
  171.     tops.ocpolarity  = TIMER_OC_POLARITY_LOW;
  172.     timer_channel_output_config(timerx, TIMER_CH_2, &tops);
  175.     ////////// 输出模式配置
  176.     // ch0
  177.     timer_channel_output_mode_config(timerx, TIMER_CH_0, TIMER_OC_MODE_PWM0);
  178.     // ch1
  179.     timer_channel_output_mode_config(timerx, TIMER_CH_1, TIMER_OC_MODE_PWM0);
  180.     // ch2
  181.     timer_channel_output_mode_config(timerx, TIMER_CH_2, TIMER_OC_MODE_PWM0);
  183.     ////////// Break配置
  184.     timer_break_parameter_struct tbps;
  185.     timer_break_struct_para_init(&tbps);
  186.     tbps.breakpolarity   = TIMER_BREAK_POLARITY_HIGH;
  187.     tbps.outputautostate = TIMER_OUTAUTO_ENABLE;
  188.     tbps.breakstate = TIMER_BREAK_ENABLE;
  189.     timer_break_config(timerx, &tbps);
  191.     // 初始化
  192.     timer_enable(timerx);
  193. }
  195. static void PWM_update_ch0(float duty) {
  196.     uint32_t timerx = TIMER7;
  197.     uint32_t timerx_chn = TIMER_CH_0;
  199.     uint32_t pulse = duty * (PERIOD + 1) / 100;
  200.     /***************** pwm update *******************/
  201.     // 配置输出的占空比
  202.     timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);
  203. }
  205. static void PWM_update_ch1(float duty) {
  206.     uint32_t timerx = TIMER7;
  207.     uint32_t timerx_chn = TIMER_CH_1;
  209.     uint32_t pulse = duty * (PERIOD + 1) / 100;
  210.     /***************** pwm update *******************/
  211.     // 配置输出的占空比
  212.     timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);
  213. }
  215. static void PWM_update_ch2(float duty) {
  216.     uint32_t timerx = TIMER7;
  217.     uint32_t timerx_chn = TIMER_CH_2;
  219.     uint32_t pulse = duty * (PERIOD + 1) / 100;
  220.     /***************** pwm update *******************/
  221.     // 配置输出的占空比
  222.     timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);
  223. }
  225. static void GPIO_config() {
  226.     // 配置时钟
  227.     rcu_periph_clock_enable(RCU_GPIOA);
  228.     // 配置GPIO模式
  229.     gpio_mode_set(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_3);
  230.     // 配置GPIO输出
  231.     gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, GPIO_PIN_3);
  232. }
  234. int main(void)
  235. {
  236.     systick_config();
  237.     nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
  238.     Usart0_init();
  239.     GPIO_config();
  240.     PWM_config();
  242.     gpio_bit_reset(GPIOA, GPIO_PIN_3);
  244.     int8_t i;
  245.     while(1) {
  246.         for(i = 0; i < 25; i++) {
  247.             PWM_update_ch0(i);
  248.             PWM_update_ch1(i);
  249.             PWM_update_ch2(i);
  250.             delay_1ms(50);
  251.         }
  252.         for(i = 24; i >= 0; i--) {
  253.             PWM_update_ch0(i);
  254.             PWM_update_ch1(i);
  255.             PWM_update_ch2(i);
  256.             delay_1ms(50);
  257.         }
  259.         delay_1ms(1000);
  260.     }
  261. }

练习题

  1. 实现互补pwm