学习目标

  1. 实现舵机控制
  2. 实现板级舵机驱动

    学习内容

    原理图

    071.png
    8路PWM来控制舵机转动。

    舵机功能

    072.png
    073.png
    舵机PWM控制
转动角度 高电平时长（ms） 低电平时长(ms) 周期时长(ms) 占空比
0 0.5 19.5 20 2.5%
45 1 19 20 5%
90 1.5 18.5 20 7.5%
135 2 18 20 10%
180 2.5 17.5 20 12.5%

通过串口控制占空比的实现：

  1. #include "gd32f4xx.h"
  2. #include "systick.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include "main.h"
  6. #include "Usart0.h"
  9. void PWM_config() {
  10.     uint32_t timerx = TIMER1;
  11.     uint32_t timerx_chn = TIMER_CH_3;
  12.     uint32_t timerx_rcu = RCU_TIMER1;
  14.     uint32_t timerx_prescaler = 1000 - 1;// 分频系数
  15.     uint32_t timerx_period = SystemCoreClock / 50000 - 1; // 周期
  17.     uint32_t timerx_port_rcu = RCU_GPIOA;
  18.     uint32_t timerx_port = GPIOA;
  19.     uint32_t timerx_pin = GPIO_PIN_3;
  20.     uint32_t timerx_af = GPIO_AF_1;
  22.     //////////////// GPIO config ///////////////
  23.     // 配置时钟
  24.     rcu_periph_clock_enable(timerx_port_rcu);
  25.     // 配置GPIO模式
  26.     gpio_mode_set(timerx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, timerx_pin);
  27.     // 配置GPIO输出
  28.     gpio_output_options_set(timerx_port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, timerx_pin);
  29.     // 配置复用功能
  30.     gpio_af_set(timerx_port, timerx_af, timerx_pin);
  31.     /////////////// PWM config /////////////////
  32.     // 配置时钟
  33.     rcu_periph_clock_enable(timerx_rcu);
  34.     // 时钟倍频
  35.     rcu_timer_clock_prescaler_config(RCU_TIMER_PSC_MUL4);
  36.     // timer复位
  37.     timer_deinit(timerx);
  38.     // 初始化timer
  39.     timer_parameter_struct tps;
  40.     timer_struct_para_init(&tps);
  41.     tps.prescaler = timerx_prescaler; // 分频系数
  42.     tps.period = timerx_period; // 周期计数 
  43.     timer_init(timerx, &tps);
  44.     // 配置输出通道
  45.     timer_oc_parameter_struct tops;
  46.     tops.ocpolarity = TIMER_OC_POLARITY_HIGH;//电平极性
  47.     tops.outputstate = TIMER_CCX_ENABLE;// 比较输出模式
  48.     timer_channel_output_config(timerx, timerx_chn, &tops);
  49.     // 配置输出的占空比
  50.     timer_channel_output_pulse_value_config(timerx, timerx_chn, 0);
  51.     timer_channel_output_mode_config(timerx, timerx_chn, TIMER_OC_MODE_PWM0);
  52. //    timer_channel_output_shadow_config(timerx, timerx_chn, TIMER_OC_SHADOW_ENABLE);
  53. //    timer_auto_reload_shadow_enable(timerx);
  54.     // 使能timer
  55.     timer_enable(timerx);
  56. }
  58. void PWM_update(float duty) {
  59.     uint32_t timerx = TIMER1;
  60.     uint32_t timerx_chn = TIMER_CH_3;
  61.     uint32_t timerx_period = SystemCoreClock / 50000 - 1; // 周期
  62.     // 更新占空比
  63.     if(duty > 100) duty = 100;
  64.     uint32_t pulse = duty * timerx_period / 100.0;
  65.     timer_channel_output_pulse_value_config(timerx, timerx_chn, pulse);
  66. }
  68. void Usart0_recv(uint8_t *data, uint32_t len) {
  69.         printf("recv: %s\r\n", data);
  71.         float duty = atof((const char *)data);
  72.         printf("duty: %f\r\n", duty);
  73.         PWM_update(duty);
  74. }
  77. int main(void)
  78. {
  79.     systick_config();
  80.         Usart0_init();
  81.         PWM_config();
  83.         while(1) {
  84.     }
  85. }

角度与占空比之间的关系：
duty = angle * (10 / 180) + 2.5
将串口接收代码改为如下：

  1. void Usart0_recv(uint8_t *data, uint32_t len) {
  2.         printf("recv: %s\r\n", data);
  4. //        float duty = atof((const char *)data);
  5. //        printf("duty: %f\r\n", duty);
  6. //        PWM_update(duty);
  7.         float angle = atof((const char *)data);
  8.         PWM_set_angle(angle);
  9. }

驱动封装

定义板级舵机驱动，控制8路舵机

  1. #ifndef __BSP_STEERING_H__
  2. #define __BSP_STEERING_H__
  4. #include "gd32f4xx.h"
  5. #include "systick.h"
  7. typedef struct {
  8.     rcu_periph_enum rcu_gpio;
  9.     uint32_t port;
  10.     uint32_t pin;
  11.     uint32_t af;
  13.     rcu_periph_enum rcu_timer;
  14.     uint32_t timer;
  15.     uint32_t chn;
  16. } Steering_t;
  18. #define S0    (Steering_t){RCU_GPIOA, GPIOA, GPIO_PIN_3, GPIO_AF_1, RCU_TIMER1, TIMER1, TIMER_CH_3}
  19. #define S1    (Steering_t){RCU_GPIOA, GPIOA, GPIO_PIN_2, GPIO_AF_1, RCU_TIMER1, TIMER1, TIMER_CH_2}
  20. #define S2    (Steering_t){RCU_GPIOA, GPIOA, GPIO_PIN_0, GPIO_AF_1, RCU_TIMER1, TIMER1, TIMER_CH_0}
  21. #define S3    (Steering_t){RCU_GPIOA, GPIOA, GPIO_PIN_1, GPIO_AF_1, RCU_TIMER1, TIMER1, TIMER_CH_1}
  22. #define S4    (Steering_t){RCU_GPIOB, GPIOB, GPIO_PIN_4, GPIO_AF_2, RCU_TIMER2, TIMER2, TIMER_CH_0}
  23. #define S5    (Steering_t){RCU_GPIOB, GPIOB, GPIO_PIN_5, GPIO_AF_2, RCU_TIMER2, TIMER2, TIMER_CH_1}
  24. #define S6    (Steering_t){RCU_GPIOB, GPIOB, GPIO_PIN_0, GPIO_AF_2, RCU_TIMER2, TIMER2, TIMER_CH_2}
  25. #define S7    (Steering_t){RCU_GPIOB, GPIOB, GPIO_PIN_1, GPIO_AF_2, RCU_TIMER2, TIMER2, TIMER_CH_3}
  28. void Steering_init(Steering_t s);
  29. void Steering_turn(Steering_t s, float angle);
  31. #endif
  1. #include "bsp_steering.h"
  3. #define PRESCALER (100 - 1)
  4. #define PERIOD (SystemCoreClock / 5000 - 1)
  6. void Steering_init(Steering_t s) {
  7.     /********* gpio config **********/
  8.         // 配置时钟
  9.     rcu_periph_clock_enable(s.rcu_gpio);
  10.     // 配置GPIO模式
  11.     gpio_mode_set(s.port, GPIO_MODE_AF, GPIO_PUPD_NONE, s.pin);
  12.     // 配置GPIO输出
  13.     gpio_output_options_set(s.port, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, s.pin);
  14.     // 配置复用功能
  15.     gpio_af_set(s.port, s.af, s.pin);
  17.     /******** timer config *********/
  18.     // 配置时钟
  19.     rcu_periph_clock_enable(s.rcu_timer);
  20.     // 时钟倍频
  21.     rcu_timer_clock_prescaler_config(RCU_TIMER_PSC_MUL4);
  22. //    // timer复位
  23. //    timer_deinit(s.timer);
  24.     // 初始化timer
  25.     timer_parameter_struct tps;
  26.     timer_struct_para_init(&tps);
  27.     // 10s 执行 10000次，也就是1s执行1000s
  28.     tps.prescaler = PRESCALER; // 分频系数
  29.     tps.period = PERIOD; // 周期计数 
  30.     timer_init(s.timer, &tps);
  31.     // 配置输出通道
  32.     timer_oc_parameter_struct tops;
  33.     tops.ocpolarity = TIMER_OC_POLARITY_HIGH;//电平极性
  34.     tops.outputstate = TIMER_CCX_ENABLE;// 比较输出模式
  35.     timer_channel_output_config(s.timer, s.chn, &tops);
  36.     // 配置输出的占空比
  37.     timer_channel_output_pulse_value_config(s.timer, s.chn, 0);
  38.     timer_channel_output_mode_config(s.timer, s.chn, TIMER_OC_MODE_PWM0);
  39. //    timer_channel_output_shadow_config(TIMER1, TIMER_CH_0, TIMER_OC_SHADOW_ENABLE);
  40. //    timer_auto_reload_shadow_enable(TIMER1);
  41.     // 使能timer
  42.     timer_enable(s.timer);
  44. }
  46. void Steering_turn(Steering_t s, float angle) {
  47.     float duty = angle * ( 10.0 / 180.0) + 2.5;
  48.     uint32_t pulse = duty * PERIOD / 100.0;
  49.     timer_channel_output_pulse_value_config(s.timer, s.chn, pulse);
  50. }

调用方式：

  1. #include "bsp_steering.h"
  2. ......
  4. // 初始化
  5. Steering_init(S0);
  6. Steering_init(S1);
  7. Steering_init(S2);
  8. Steering_init(S3);
  9. ......
  10. Steering_init(S7);
  12. // 转向
  13. Steering_turn(S0, 45);
  14. Steering_turn(S1, 45);
  15. ......
  16. Steering_turn(S7, 45);

练习题

  1. 实现舵机驱动封装