stm32c8t6多路舵机PWM输出
对于舵机的简单使用大家都不陌生，在实验中使用的SG90舵机最大转动角度为180度，而对舵机控制的原理是我们每一个使用者都应该了解的，具体的可以从下面这张角度和占空比的关系看看出来。（本次实验基于前一篇多路串口使用改写）通过串口中断接收数据来控制不同的舵机转动，对串口使用不太会的小伙伴前看前面一篇文章

舵机转动原理：
$ k+ }4 y, q( g9 V( ^( @舵机的控制一般需要一个20ms的时基脉冲，该脉冲的高电平部分一般为0.5ms~2.5ms范围内的角度控制脉冲部分。以180度角度舵机为例，那么对应的控制关系是这样的：
3 O2 m/ C4 c# I1 i3 G* T
4 p; D: S8 ^: j# p1 E- d  Y

可以发现一个规律：角度每次增加45度，高电平时间相应增加0.5ms

/ z1 Z5 y/ i! Q3 X/ ` 总周期 - 高电平脉冲 = 低电平脉冲
* g. o; V# q$ l5 U! _9 g; \, m" l
' @* h% I1 i, J3 [. q* m' s" @ 舵机角度的转动就是通过高、低脉冲的变化实现的
; t/ }: S& L6 w$ a, D
硬件接线引脚对应关系
/ P" ?. A4 b, T% c. R9 M% N( h2 q

3 T) q3 t! r2 t' B0 p3 e2 X


  m9 n0 u5 c- j; r/ U+ X" `2 s0 O( p: @了解完舵机的基本原理后，下面我们就进行pwm的配置。在stm32c8t6最小系统中使用pwm的时候我们需要进行定时器相应的重映射，每个定时器有四路PWM输出，大家可以根据自己情况配置不同的定时器进行多路PWM的输出，下面是重映射对应关系。
9 ^' n/ s+ z: T1 @


6 e5 j, n6 H5 c! Z5 M$ I4 A: v
. J4 Z$ n2 C1 ]+ }; F- ]本次实验中使用的是定时器3的4个通道
TIM3_CH1---------------------->PB4
+ y5 O* h, V7 r% ?7 H9 j( HTIM3_CH2---------------------->PB3
TIM3_CH3---------------------->PB0
TIM3_CH4---------------------->PB1

1 C3 [- [$ y" e4 m8 J自己在实验的时候搞了很久，配置没问题一开始就是不能控制多路Pwm，在配置的四路中有时候只有两路，甚至一路可以，然后就改成其他定时器重新进行映射，结果还是一样不能同时控制，折腾了很久时间，后面突然又可以了，就挺离谱的，代码一模一样的有时候一下就成功，有时候要好久才成功。
所以各位小伙伴不管做什么都一定要有耐心哦
+ E, D: q- A/ t2 }$ s" T
实验源码
2 P" B) {( I" B6 F# p& v( h$ R/ Z

1. /*--------------------servo.h-------------------*/
   
2. #ifndef __SERVO_H
   
3. #define __SERVO_H
   
4. 
   & ~+ u. H6 y& ~* }7 ~3 N
5. #include "stm32f10x.h"
   
6. 
     j/ g( }0 p& @6 b* X# R
7. #define SERVO_GPIO_PORT GPIOB
   
8. #define SERVO_GPIO_CLK  RCC_APB2Periph_GPIOB
   
9. #define SERVO_GPIO_PIN  (GPIO_Pin_5 |GPIO_Pin_0 |GPIO_Pin_1| GPIO_Pin_4)
   
10. 
    
11. void servo_init(void);
    $ o1 E: F4 J! r/ {2 y+ v& c
12. void Servo_Run2(uint16_t angle);
    
13. void Servo_Run(uint16_t angle);
    
14. void Servo_Run3(uint16_t angle);
    
15. 
    
16. void Servo_Run4(uint16_t angle);
    / ~: n( o( x5 c$ m+ X
17. 
    
18. #endif /* __SERVO_H */

复制代码

1. /*-----------------------servo.c---------------------*/
   
2. #include "./servo/servo.h"
   
3. /**
   
4. * 功能：舵机初始化函数
   
5. * 参数：None
   + _% n' K: h! F; w6 I
6. * 返回值：None
   7 `3 |* H+ ~9 ]  @, z8 J
7. */
   0 ^" q# k; l* n" K4 h* m8 D0 j+ N
8. void servo_init(void)
   
9. {
   * F& ]7 i4 z! T2 g8 |
10.     GPIO_InitTypeDef GPIO_Init_Structure;                  //定义GPIO初始化结构体
      M, g3 c! q1 [- D8 H. n3 |1 x5 T
11.     TIM_TimeBaseInitTypeDef Timer_Init_Structure;          //定义定时器初始化结构体
    
12.     TIM_OCInitTypeDef Timer_OC_Init_Structure;             //定义定时器输出PWM结构体
    / v7 d0 \1 j/ h
13. 
    
14.     RCC_APB2PeriphClockCmd(SERVO_GPIO_CLK, ENABLE);        //开Timer3通道2GPIO时钟
    # H5 T2 V$ W" ?1 Q
15.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);   //开定时器3时钟
    5 h9 J2 p1 a& q. d6 ~+ @) O
16.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);   //开复用时钟
    
17. 
    
18.     GPIO_PinRemapConfig(GPIO_PartialRemap_TIM3, ENABLE);   //选择部分重映射
    8 x; e. z4 H/ Z; T
19. 
    
20.     //配置GPIO初始化结构体
    
21.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_AF_PP;
    
22.     GPIO_Init_Structure.GPIO_Pin   = SERVO_GPIO_PIN;
      {) r& p0 I3 t  h. X7 ^
23.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_50MHz;
    
24. 
    
25.     GPIO_Init(SERVO_GPIO_PORT, &GPIO_Init_Structure);
    ! H# c9 c3 s8 U) e6 Z. G0 r- K
26. 
    
27.     //配置通用定时器初始化结构体
    ! |. i9 @7 Q/ N' z5 A
28.     Timer_Init_Structure.TIM_ClockDivision = TIM_CKD_DIV1;        //设置分频系数，通常采用默认的分频
    % p( d4 I, @5 N# w  o0 u$ A
29.     Timer_Init_Structure.TIM_CounterMode = TIM_CounterMode_Up;    //设置捕获模式为向上计数(基本定时器仅有向上计数)
    
30.     Timer_Init_Structure.TIM_Period = 200-1;                      //设置重装载值(在预分频值为72000下，10000为一秒)
    1 D- z- c6 s( T' q# ?& h9 h8 `
31.     Timer_Init_Structure.TIM_Prescaler = 7200-1;                  //设置初始化预分频值为7200
    
32. //    Timer_Init_Structure.TIM_RepetitionCounter = 0              //重复计数器，仅高级定时器需要设置
    * |! }+ T6 Y) S) q2 R' w& h9 H
33. 
    ' y7 [; O6 w% ^2 `$ c4 ~8 [# L
34.     TIM_TimeBaseInit(TIM3, &Timer_Init_Structure);
    
35. 
    
36.     //配置定时器输出PWM结构体
    . U) Y/ o# g, o; B; N' t
37.     Timer_OC_Init_Structure.TIM_OCMode = TIM_OCMode_PWM1;                 //定时器模式选择Timer脉冲宽度调制模式 1
    / I7 k' P. ?: w, M! o
38.     Timer_OC_Init_Structure.TIM_OutputState = TIM_OutputState_Enable;     //比较输出使能
    
39.     Timer_OC_Init_Structure.TIM_OCPolarity = TIM_OCPolarity_Low;          //选择有效输出为低电平
    2 C$ d3 {1 k' v+ j6 E- K, z
40.                
    7 g" w) \( F+ H
41.         TIM_OC1Init(TIM3, &Timer_OC_Init_Structure);  //PB4
    
42. 
    
43.     TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);                     //使能预装载寄存器
    / l) r* l* z# L* n
44. 
    
45.     TIM_OC2Init(TIM3, &Timer_OC_Init_Structure); //PB5
    2 H) o5 n. T1 c) C# J7 h
46. 
    . l  g9 x! M* @2 `
47.     TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);                     //使能预装载寄存器
    
48.                
    2 j  H7 e( Y7 W( R+ A8 Y* Y
49.                
    ) x7 y+ c% i" X% i1 _( q
50.                  
    $ M5 V8 l- D4 h& e  J$ r
51.     TIM_OC3Init(TIM3, &Timer_OC_Init_Structure); //PB0
    1 s9 n  c8 b, J2 O$ s7 B
52. 
    4 H$ e  b, O. Y! A2 z3 F
53.     TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);                     //使能预装载寄存器
    $ a: u, U& g0 O
54.                
    
55.                
    % X2 X% S" v- R' V
56.         TIM_OC4Init(TIM3, &Timer_OC_Init_Structure); //PB1
    $ ^& Y9 J; }/ ?! I
57. 
    
58.     TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);                     //使能预装载寄存器
    
59. 
    
60.     TIM_Cmd(TIM3, ENABLE);
    
61. }
    $ w1 {$ o! ?5 {# W/ T
62. /**
    8 }- _; I" L# Q% m& p# m
63. * 功能：舵机驱动(可从0~180，每45度旋转一次)
    * Q' ?6 m6 A6 ]8 @$ l6 k
64. * 参数：angle  ；舵机旋转度数(相对角度)
    
65. * 返回值：None
    
66. */
    . l4 I& n/ n1 s7 d4 p
67. void Servo_Run(uint16_t angle)
    
68. {
    
69.     switch(angle)
    3 ^5 i# T* x* n; I" e2 D3 `% J
70.     {
    
71.                 case 180 :TIM_SetCompare2(TIM3, 175); break;//对应180度
    
72.                 case 135 :TIM_SetCompare2(TIM3, 180); break;//对应135度
    
73.                 case 90  :TIM_SetCompare2(TIM3, 185); break;//对应90度
    
74.                 case 45  :TIM_SetCompare2(TIM3, 190); break;//对应45度
    
75.                 case 0   :TIM_SetCompare2(TIM3, 195); break;//对应0度
    ) n3 u" G: K7 k' A
76.     }
    & V0 n2 u5 \# h8 w$ N; I3 u
77. }
    ; H  k% e/ F% Y' R' e5 W! v2 @
78. 
    
79. void Servo_Run2(uint16_t angle)
    
80. {
    
81.     switch(angle)
    
82.     {
    
83.                 case 180 :TIM_SetCompare3(TIM3, 175); break;//对应180度
    
84.                 case 135 :TIM_SetCompare3(TIM3, 180); break;//对应135度
    
85.                 case 90  :TIM_SetCompare3(TIM3, 185); break;//对应90度
    2 F& s  h6 I* U* R7 h8 r: m
86.                 case 45  :TIM_SetCompare3(TIM3, 190); break;//对应45度
    
87.                 case 0   :TIM_SetCompare3(TIM3, 195); break;//对应0度
    
88.     }
    ! ?1 ]" z+ x" d4 R  G5 [7 d5 o
89. }
    , b( T" ^1 P8 u
90. 
    
91. 
    ! A% ~# s9 k/ {
92. void Servo_Run3(uint16_t angle)
    
93. {
    ! b- N- G0 U+ l7 F
94.     switch(angle)
    
95.     {
    
96.                 case 180 :TIM_SetCompare4(TIM3, 175); break;//对应180度
    
97.                 case 135 :TIM_SetCompare4(TIM3, 180); break;//对应135度
    " e" _  o" \3 w, R9 R6 t5 C1 D! `
98.                 case 90  :TIM_SetCompare4(TIM3, 185); break;//对应90度
    % i9 Z. X9 C3 l' u9 n2 `) m
99.                 case 45  :TIM_SetCompare4(TIM3, 190); break;//对应45度
    * |# R  `6 s  J
100.                 case 0   :TIM_SetCompare4(TIM3, 195); break;//对应0度
     
101.     }
     & l9 z8 E+ a; \! ~5 W
102. }
     $ b  O) e- L2 t* {; a  ?
103. 
     , Q% e3 M/ G/ k! Y8 ~1 v
104. void Servo_Run4(uint16_t angle)
     . |, F# Z6 d5 C( c! t8 N. n. u/ V
105. {
     # \' |5 q9 N  L- f5 h
106.     switch(angle)
     
107.     {
     
108.                 case 180 :TIM_SetCompare1(TIM3, 175); break;//对应180度
     - L# ^! h7 x) y& b( E
109.                 case 135 :TIM_SetCompare1(TIM3, 180); break;//对应135度
     
110.                 case 90  :TIM_SetCompare1(TIM3, 185); break;//对应90度
     , T& {* {& Y/ ~! o" _
111.                 case 45  :TIM_SetCompare1(TIM3, 190); break;//对应45度
     * e% E5 d" ?' a' g; P" r( f4 U, i
112.                 case 0   :TIM_SetCompare1(TIM3, 195); break;//对应0度
       u3 }9 j, q5 s1 k. a2 c) p( ^
113.     }
     8 A. G- r  K# g
114. }
     $ ~& y3 |: ^: T6 W

复制代码

" K; D+ I) q8 @1 w9 H" r* f! `如果只有单路PWM输出（通道1）
TIM_OC1Init(TIM3, &Timer_OC_Init_Structure);  //PB4  
) X  `7 L& u: JTIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);  //使能预装载寄存器
在上面初始化中写上述配置的任意一个都可以
% _' Q5 z4 ^6 O" {/ C. [" n一定要进行我们选择的通道要和pwm比较所对应
( A$ I5 w0 r- F4 r这里如果我们选择的通道1 则下面也选择1的比较
void TIM_SetCompare1(TIM_TypeDef* TIMx, uint16_t Compare1);
% X$ c" E# q4 y
( T' L2 A- o' S串口代码在前一篇已经分享了这里就不重复了
1 a" c) a! X9 j

1. /*---------------------main.c---------------------*/
   
2. #include "stm32f10x.h"
   
3. #include "usart.h"
   
4. #include "servo.h"
   
5. #include "delay.h"
   
6. int main()
   
7. {
   
8.             Init_Usart();
   
9.                 servo_init();
   
10.                 led_init();
    
11.                 Servo_Run(45);
    : _: E7 O5 L; b" ]  a4 T8 @5 x/ ~
12.                 Servo_Run2(45);
    ' F4 p+ i! }/ P8 B2 }9 r
13.                 Servo_Run3(45);
    
14.                 Servo_Run4(45);
    1 J& i3 b4 Z& ^( D! q
15.                 printf("====================串口测试=====================\n");
    0 u$ V# a' @+ w& z" ?4 h5 R
16.                 USART_Send_String(USART1,"usart1 test\n");
    " a3 F4 }) V. O
17.                 //USART_Send_String(USART2,"usart1 test\n");        
    
18.                 //USART_Send_String(USART3,"usart1 test\n");
    / O. |) r( g' ^4 N7 O; @6 S
19.     while(1)
    ; N9 ?" c/ t4 e) M+ s
20.     {
    
21.                         
    % z$ G7 }- H2 S9 S
22.     }
    # m+ e" _! a/ f! B8 o
23. }
    
24. 
    4 _9 V+ g& i* y( P+ x. J* d
25. //串口1中断
    
26. void USART1_IRQHandler(void)
    $ K* U2 ~" I3 e
27. {
    5 @3 T. o. \- X+ M& V2 D/ o+ F/ R
28.         char temp;
    ' N. E# o) u. ~* ^5 v- a3 g$ B
29.         //USART_Send_String(USART1,"\nUsart1 interrupt test\n");        
    2 n+ g% X( G% K
30.         if(USART_GetITStatus(USART1,USART_IT_RXNE)!= RESET)
    7 o: t  }( ~) g( O$ b
31.         {
    5 B5 T  j. u3 _& T
32.                 temp = USART_ReceiveData(USART1);
    % U  i; B! U) f' c$ r  f# p6 Y
33.                 if(temp == '1')
    * }, N2 y* c2 k7 V8 p8 l; M% U
34.                 {
    7 U$ \+ c  `$ N4 r2 C
35.                         //GPIO_ResetBits(GPIOC,GPIO_Pin_13);
    
36.                         USART_Send_String(USART1,"servo1 open\n");               
    
37.                         Servo_Run(0);
    ) e; ~+ K$ b1 Q9 b6 p' u
38.                         //delay_ms(500);
    
39.                         USART_Send_String(USART1,"servo1 over\n");               
    ' D1 g; ?# i2 J$ `# X
40.                 }
    
41.                 else if(temp == '2')
    ( v+ d6 W1 v6 r$ j" t! V. p  ~
42.                 {
    
43.                         //GPIO_ResetBits(GPIOC,GPIO_Pin_13);
    + R0 r- b, y. d- G
44.                         USART_Send_String(USART1,"servo1 close\n");               
    
45.                         Servo_Run(45);
    & o* U4 K; F& X: c! g$ Z+ p
46.                         //delay_ms(500);
    
47.                         USART_Send_String(USART1,"servo1 over\n");        
    
48.                         printf("------------servo1-----------\n");
    & ~& F9 T4 x1 a: ~+ u6 z
49.                 }
    
50.         
    
51.                 else if(temp == '3')
    2 ~" I& L8 R6 Y* M" j, ~
52.                 {
    ( `; j2 Y- \; L: p* b
53.                         //GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
54.                         USART_Send_String(USART1,"servo2 open\n");
    
55.                         Servo_Run2(0);
    : c4 U, n( w! R$ n7 z7 C* }
56.                         //delay_ms(500);
    
57.                         USART_Send_String(USART1,"servo2 over\n");               
    
58.                         
    : j5 `: Q6 E0 A# h
59.                 }
    
60.                
    
61.                 else if(temp == '4')
    
62.                 {
    # ~# a$ f3 N7 \# Y5 g) T$ h
63.                         //GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
64.                         USART_Send_String(USART1,"servo2 close\n");
    & C% P* R: y1 X& e+ k9 V
65.                         Servo_Run2(45);
    
66.                         //delay_ms(500);
    ! r2 z3 }/ d. [5 |9 g/ M
67.                         USART_Send_String(USART1,"servo2 over\n");
    : ?; s- L9 F6 Z0 x7 K! D  H
68.                         printf("------------servo2-----------\n");                        
    1 Z+ M: h3 B" c( O* h3 m
69.                         
    
70.                 }
    * I, i, `( N! [9 X$ D$ k% H
71.                
    " v2 \- A8 E$ G
72.                 else if(temp == '5')
    
73.                 {
    
74.                         //GPIO_SetBits(GPIOC,GPIO_Pin_13);
    ; l9 b$ g% J' H9 k
75.                         USART_Send_String(USART1,"servo3 open\n");
    
76.                         Servo_Run3(0);
    4 {* O7 q: n8 ?! ^3 ?9 L
77.                         //delay_ms(500);
    ' x4 b) t/ E- ~& Q- m3 t
78.                         USART_Send_String(USART1,"servo3 over\n");               
    * K5 z3 ]4 u- s3 {
79.                         
    # i. `2 x, L/ Q
80.                 }
    6 g# o! l8 q, V: y4 z
81.                
    5 R2 T& Z3 d& J
82.                 else if(temp == '6')
    4 e+ W* a9 z4 W( V/ W
83.                 {
    9 C" O& `4 z( k& ?
84.                         //GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
85.                         USART_Send_String(USART1,"servo3 close\n");
    
86.                         Servo_Run3(45);
    5 y2 J" D- S1 z$ ^7 |
87.                         //delay_ms(500);
    
88.                         USART_Send_String(USART1,"servo3 over\n");
    
89.                         printf("------------servo3-----------\n");                                
    5 I. I2 @  [' f: M; F! W, w- Q4 b
90.                         
    7 h/ \) E- D# ]$ Z- t3 S; ^8 a
91.                 }
    . t1 w$ t8 C1 `* v. f6 \. {
92.                
    
93.                 else if(temp == '7')
    
94.                 {
    ' z* z( \3 v/ e& }  r7 Z
95.                         //GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
96.                         USART_Send_String(USART1,"servo4 open\n");
    ( Y: p! K1 x. N6 \5 ~( L  J
97.                         Servo_Run4(0);
    1 ^- j/ h! S+ j
98.                         //delay_ms(500);
    
99.                         USART_Send_String(USART1,"servo4 over\n");               
    
100.                         
     6 x% i- A. B% }* D
101.                 }
     
102.                
     
103.                 else if(temp == '8')
     
104.                 {
     
105.                         //GPIO_SetBits(GPIOC,GPIO_Pin_13);
     4 C2 \. s" T! c1 \/ t
106.                         USART_Send_String(USART1,"servo4 open\n");
     
107.                         Servo_Run4(45);
     ' p' Z) }1 c, x
108.                         //delay_ms(500);
     + p7 h/ [2 K0 d+ |) L1 a# ?3 o
109.                         USART_Send_String(USART1,"servo4 over\n");               
     5 H6 N  M$ G" b- ~& k% ^: {
110.                         printf("------------servo4-----------\n");        
     % g1 G3 u6 C9 V% d; s. v$ e1 C2 ^
111.                         
     # B/ s' V5 o: j  m
112.                 }
     
113.                 USART_ClearITPendingBit(USART1,USART_IT_RXNE); //清除中断
     
114.         }
     " ]& `/ F* ]6 f' i" q* _7 w4 d: u5 @" K& e
115. }

复制代码

实验结果

) `0 z" K6 Q* Z1 c& f- o

9 @8 z1 J( T! A/ j注意点
: [5 b# K. t* W  I. [! X! s2 `7 C
4 P$ Y; M$ x: m' d( ~上述串口中断接收时我最开始在每接收完数据了进行短暂延时在打印相关信息，不过在实验的现象是，只能接收一次就卡在了延时的上面，最后就把延时去掉了，大家可以看看，自己哪里有没有这种现象，有错还望大佬指正。
6 a+ u, S; ?' v+ A+ V8 ]( d————————————————
版权声明：@slow-walker

, |) W; L8 d8 i1 B! s  C4 e$ Z+ ]