前言
如果我们想对电机进行速度或者转角的精确控制，需要使用到很多算法，比如非常经典的PID控制算法，或者一些只能算法，但这些算法都需要传感器来提供转速或转角的反馈值，对于电机来说，编码器是非常流行并且实用的电机配套传感器，本文使用STM32F103C8T6+L298N+MG513P30电机进行直流电机的编码器测速。

一、编码器原理
1.分类

+ y( e- I+ K4 V5 L
8 }" A& ?7 k/ n5 P  T. m
! E; s) H9 r( w 光电式编码器的精准度比霍尔式要高，但是由于它需要红外线发生器和接收器，相对来说造价要贵一些。现在我们比较常用的是霍尔式增量编码器，有很多电机都会自带编码器。
2 U2 ~; t) x' P1 q5 I

8 J) k# v& ?6 T) _
; o  Z- O. D) R& _2.测速方法分类
* t8 u9 b1 ~  s; s8 t（1）M法测速
编码器输出的脉冲个数代表了位置，那么单位时间里的脉冲个数表示这段时间里的平均速度。因此，我们可以通过计量单位时间脉冲个数即可以估算出平均速度，称为M法测速（测脉冲个数）测速原理如图所示。
. }1 Q$ a0 w4 S& Y
% R6 t% t; m1 }1 Q4 Q

; b3 {* O* h# i& B6 n* }' d例如，若编码器每转产生N个脉冲，在T时间（单位s）产生m个脉冲，那么平均转速如公式所示。

& ^* `5 B$ i" U" M  v9 n- H* v

# N7 M4 w% P% k: x  E式中 n——平均转速（r/min）；
. W8 q' N% A1 c0 ?
1 Y8 r# c0 j4 J0 z6 X  MT——测速采样时间（s）；

m——T时间内测得的编码器脉冲个数；

N——编码器每转脉冲数。

+ U; x- o$ q4 y9 n9 v. p+ A6 z（2）T法测速
& c) y2 l0 f& b/ ?' j! k1 O9 T* _若用M法测速，在记录时间短、速度低的时候，只能记录几个脉冲，则分辨率降低。针对该问题，目前解决方法为：可以采用输出码盘脉冲为一个时间间隔，然后用计数器记录在这段时间里高速脉冲源发出的脉冲数。即通过采集到脉冲源脉冲数来计量编码器两个脉冲时间间隔，从而估算出速度，称为T法测速（测脉冲周期），测速原理图如图所示。
; T" I  c) E! P" }7 g  _0 `


. t# R. S5 S) X+ C% h- B( OT法测速，利用编码器产生的脉冲用作门电路的触发信号；用已知频率f的时钟信号做输入。若控制门电路在编码器脉冲上升沿到来时开始导通，再次上升沿到来时关闭，即计数器只记录一个编码器脉冲周期内的时钟脉冲个数。若在编码器相邻脉冲之间记录的脉冲时钟个数为m，那么，可以计算两个编码器脉冲的时间间隔为m /f；若编码器每转有N个线脉冲输出，那么我们就知道编码器转过1/N转时需要时间m /f。据此，可计算与编码器同轴转速为公式所示。



式中 n——平均转速（r/min）；
: b( l5 O* a; H1 a( e
* V+ ]! U1 K6 d6 c5 b) Z) W- @f——时钟脉冲频率（个/s）；
$ O. \* N) o6 `
+ `% S1 B: H2 }+ ~- Om——两个编码器脉冲之间的时钟脉冲个数；
. v& }; l+ {' r: b- R
5 z1 d& H8 G" k* zN——编码器每转脉冲数。
# P( c, R9 D% [- }: a
2 a  U' ^/ q* h+ y6 w" V编码器一般会输出两路信号，分别称为A相和B相，它们相差90°，因此编码器也称为十字码盘，通过捕获两路输出信号可以测算出电机的转速和转向。

$ A9 o6 g9 r, {STM32使用编码器的方法有两种分别是外部中断法和输入捕获法，这两种方法都属于M法测速，两种方法比较来说外部中断法占用CPU资源较多，平时比较常用的是输入捕获法，但博主两种方法都调试出来了，因此记录下来跟大家分享一下。
* t8 {4 Y6 v$ ~' }
, N, y& E7 |6 V4 L! [- P. G0 |, m5 T二、外部中断法测速
3 |7 q2 n) L# C3 s3 t对于外部中断的知识，各个讲STM32的教程都有，我就不过多赘述，外部中断的初始化都一样，主要是出发外部中断时需要进行的操作。


1 P& ]; x- G, u7 b
看这张图，正转方向是信号向右走，因为我们是同时捕获两路信号，有以下几种情况：



- b- D4 ~4 c) @) b" k然后我们设置两个变量用来存储捕获的脉冲数，每捕获到一次脉冲信号根据上表进行判断，正转时使其加1；反转时使其减1；然后配置一个定时器，每隔一段时间反馈一次测速值。
$ \* J2 |) l6 n5 d% k
  v) x  B7 g1 f  m* T1.外部中断配置
. a: q: @2 L! A% i先编写一个函数初始化外部中断，使用PB12-15引脚复用为外部中断输入，外部中断配置步骤如下：
" l! l, _$ r$ z7 _
5 f; p! C* m: c, A端口初始化：RCC_APB2PeriphClockCmd（）、GPIO_Init（）
; S6 H' v2 }$ L& l, g. y使能复用功能时钟：RCC_APB2PeriphClockCmd（）
设置IO口与中断线的映射关系：GPIO_EXTILineConfig（）
2 D* _. l; q) w  ^% `初始化线上中断：EXTI_Init（）
配置中断分组：NVIC_Init（）
完整函数如下：
) o5 P# b, D5 r  J; o2 j
- G+ H  ~) C- o

1. /**************************************************************************
   ; B+ g% B* e$ f/ {3 m
2. 功能：应用外部中断方式采集编码器数据，使用M法测速反馈车轮实时速度
   8 t) ~- i1 b* L
3. 函数：Encoder_EXTIX_Init(void)  EXTI15_10_IRQHandler(void)
   / k6 z" s& K+ b& U% w9 k
4. 作者：K.Fire
   
5. 日期：2022.01.30
   
6. 引脚：PB12(左轮A相) PB13(左轮B相) PB14(右轮A相) PB15(右轮B相)
   ) z% t  {5 ]" c
7. 参数：void
   * y0 G; f- r; S3 O% |3 E! C' E
8. *************************************************************************/
   
9. 
   
10. int Encoder_L_EXTI=0;
    " D5 A6 ^4 C8 F3 S' F
11. int Encoder_R_EXTI=0;
    
12. 
    2 {8 m/ Z: r* O
13. void Encoder_EXTIX_Init(void)
    
14. {
    ' Z) Q1 r! b) T& ?- h, J; T
15.         //1.端口初始化
    6 J  z+ i% l3 V
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    
17.         GPIO_InitTypeDef GPIO_InitStruct;
    0 U+ g- _, U5 r* G+ K
18.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPD;
    * q8 R2 ~$ t" k1 D* ?
19.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 |GPIO_Pin_14 | GPIO_Pin_15;
    
20.         
    
21.         GPIO_Init(GPIOB,&GPIO_InitStruct);
    , U  W, j( W  k/ l- R
22.         
    
23.         //2.使能复用功能时钟
    
24.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    
25. 
    
26.         //3.设置IO口与中断线的映射关系
    
27.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource12);
    / s- W8 t, m* z/ P0 n' |
28.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource13);
    1 M  O/ M1 \6 j' F! u% Y) C# O
29.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource14);
    / T0 L( ]: _3 A% I( }6 }6 ^, f
30.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource15);
    
31.         
    9 S; l& n5 Q8 V4 a' E% D) ]1 [
32.         //4.初始化线上中断
    ; b2 l  ^! _+ \2 c
33.         EXTI_InitTypeDef EXTI_InitStruct;
    
34.         EXTI_InitStruct.EXTI_Line = EXTI_Line12 | EXTI_Line13 | EXTI_Line14 | EXTI_Line15;
    
35.         EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    # L  J( ^( b  Q  n2 E/ [$ ~5 Z- H
36.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    - M5 P# B0 V- s6 c& x
37.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling;//跳变沿触发
    & f6 m. c" N1 h# l
38.         EXTI_Init(&EXTI_InitStruct);
    . \7 A  t2 _  ?5 k" E; }& E6 W0 v
39.         
    
40.         //5.配置中断分组
    
41.         NVIC_InitTypeDef NVIC_InitStruct;
      B/ l8 o$ I( n- Z7 A. ?8 {+ k
42.         NVIC_InitStruct.NVIC_IRQChannel = EXTI15_10_IRQn;
    9 p* i" Y7 c! h( j7 |
43.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    5 x' c+ a0 M! D- E
44.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    
45.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    
46.         NVIC_Init(&NVIC_InitStruct);
    * l8 T- ^! K3 z5 Y; y! S
47. 
    
48. 
    ! Q: ?; B- }" N. u- U( T
49. }
    9 P/ M8 {6 Y0 c0 g( w9 w

复制代码

2.外部中断服务函数
- h5 Q% s+ f& G* D4 {函数的判断逻辑与上表一致，外部中断捕获判断函数如下：

1. void EXTI15_10_IRQHandler(void)
   
2. {
   
3.         if(EXTI_GetITStatus(EXTI_Line12) != RESET)//左轮A相 PB12
   
4.         {
   ) s) h5 t- }3 e' H  A
5.                 EXTI_ClearITPendingBit(EXTI_Line12);  //清除LINE上的中断标志位
   
6.                 if(PBin(12)==0)   //这里判断检测到的是否是下降沿
   
7.                 {
   ' ?" a, ]6 L" ]4 `! R
8.                         if(PBin(13)==0)   Encoder_L_EXTI++;//B相的电平如果是低，电机就是正转加1
   
9.                         else             Encoder_L_EXTI--;//否则就是反转减1
   * }4 ^9 r5 V# `' }
10.                 }
    ( F6 p1 a- U. V; b3 o
11.                 else                  //上升沿
    
12.                 {
    
13.                         if(PBin(13)==1)  Encoder_L_EXTI++; //B相电平如果为高，电机就是正转加1
    % S& U; h7 D) Y& x) N/ f5 `
14.                         else             Encoder_L_EXTI--;//否则就是反转减1
    2 f+ ?% o; P+ X/ p+ F& ~6 J1 v4 O
15.                 }
    * x3 H  K: [9 N& I* i# C+ s
16.         }
    
17.         
    
18.         if(EXTI_GetITStatus(EXTI_Line13) != RESET)//左轮B相 PB13
    " i, ~' j  N% \' J9 d2 u+ h
19.         {
    9 l; m7 M0 B: s' G' [% Q
20.                 EXTI_ClearITPendingBit(EXTI_Line13);  //清除LINE上的中断标志位
    
21.                 if(PBin(13)==0)   //这里判断检测到的是否是下降沿
    
22.                 {
    
23.                         if(PBin(12)==1)   Encoder_L_EXTI++;//B相的电平如果是高，电机就是正转加1
    6 }. Y) d4 x& o, l" [
24.                         else             Encoder_L_EXTI--;//否则就是反转减1
    
25.                 }
    % \1 U& [- E8 y9 n& h
26.                 else                  //上升沿
    , n# S2 Q( ]; _2 N/ B' {& }. A. m
27.                 {
    
28.                         if(PBin(12)==0)  Encoder_L_EXTI++; //B相电平如果为高，电机就是正转加1
    
29.                         else             Encoder_L_EXTI--;//否则就是反转减1
    ! I- d0 @! A9 d; D4 `8 v, W# v
30.                 }
    
31.         }
    
32.         
    & ^- _7 S& d( a4 m, Q" {! p/ ]
33.         if(EXTI_GetITStatus(EXTI_Line14) != RESET)//右轮A相 PB14
    0 P! S  m+ x% w1 @
34.         {
    8 _8 F/ w7 ~5 s7 R
35.                 EXTI_ClearITPendingBit(EXTI_Line14);  //清除LINE上的中断标志位
    
36.                 if(PBin(14)==0)   //这里判断检测到的是否是下降沿
    2 h& H' x( Z& Y1 E' I; d! c- t
37.                 {
    
38.                         if(PBin(15)==0)   Encoder_R_EXTI++;//B相的电平如果是低，电机就是正转加1
    
39.                         else             Encoder_R_EXTI--;//否则就是反转减1
    
40.                 }
    ' D/ [. [) u, N" q  h5 t
41.                 else                  //上升沿
    
42.                 {
    
43.                         if(PBin(15)==1)  Encoder_R_EXTI++; //B相电平如果为高，电机就是正转加1
    
44.                         else             Encoder_R_EXTI--;//否则就是反转减1
    
45.                 }
    . G/ D& I* n/ ^$ `# l
46.         }
    9 h/ p' J1 o2 u$ j' I' a/ m
47.         
    
48.         if(EXTI_GetITStatus(EXTI_Line15) != RESET)//右轮B相 PB15
    + J$ e- a$ e6 }' k) a1 O  w5 z
49.         {
    . s& H2 @- c( I) D1 L) L
50.                 EXTI_ClearITPendingBit(EXTI_Line15);  //清除LINE上的中断标志位
    
51.                 if(PBin(15)==0)   //这里判断检测到的是否是下降沿
    2 W% q- k; a% u6 O2 e* ~' M1 r
52.                 {
    
53.                         if(PBin(14)==1)   Encoder_R_EXTI++;//A相的电平如果是高，电机就是正转加1
    
54.                         else             Encoder_R_EXTI--;//否则就是反转减1
    
55.                 }
    
56.                 else                  //上升沿
    - o1 X/ M- M) K7 C5 \1 M  n6 F
57.                 {
    0 N% f* l, a* J/ @% h9 ], D1 O
58.                         if(PBin(14)==0)  Encoder_R_EXTI++; //A相电平如果为低，电机就是正转加1
    
59.                         else             Encoder_R_EXTI--;//否则就是反转减1
    
60.                 }
    # I4 W; s2 M0 F) K( A% Y1 ^
61.         }
    $ X2 |! D4 s4 c: ~! p- ^% S! k
62.         
    
63. }

复制代码

注意一下，在使用引脚时不要重复，因为Px0（x=AB..F）都是使用的同一条外部中断线（EXIT0）

3.读取捕获脉冲数值
8 |/ O6 P3 F! b( @) W配置完定时器后，每过一段时间调用读取函数，通过公式可以计算出实际的脉冲值。
/ _, e1 G3 q9 }8 n  E
9 t9 `8 E; b) W4 J/ Q: |/ c: B函数如下：
3 W* s# d. d  \2 m
" a0 C1 c4 w. v

1. /**************************************************************************
   ; d" e5 \0 r, D
2. 功能：获取不同方式下的脉冲值
   
3. 函数：int Read_Encoder(u8 TIMX)
   4 H7 }! R' p0 F2 h( z3 }: }/ S8 n
4. 作者：K.Fire
   : g" Q+ G+ Z/ w: Q: z+ P5 m/ j
5. 日期：2022.01.30
   
6. 参数：1：外部中断法左轮 2：外部中断法右轮 3：输入捕获法左轮 4：输入捕获法右轮
     v$ ~* o$ c  G4 _& U7 W. ?
7. **************************************************************************/
     m- h6 U) a% D# P, W5 o9 X
8. 
   : a1 ~$ x6 V  [6 l, T: ]$ H
9. int Read_Encoder(u8 TIMX)
   
10. {
    8 e) F8 G0 ]/ {, R4 G8 f) N0 G
11.     int Encoder_TIM;   
    
12.     switch(TIMX)
    $ `! N# c( R2 U9 G
13.         {
    
14.                 case 1:Encoder_TIM=Encoder_L_EXTI;  Encoder_L_EXTI=0; break;
    
15.                 case 2:Encoder_TIM=Encoder_R_EXTI;  Encoder_R_EXTI=0; break;
    
16.                 case 3:Encoder_TIM=TIM3 -> CNT;  TIM3 -> CNT=0;break;        
    
17.                 case 4:Encoder_TIM=TIM4 -> CNT;  TIM4 -> CNT=0;break;
    
18.             default:Encoder_TIM=0;break;
    
19.         }
    $ v7 L7 Y2 R. n7 Z' V- e5 E5 d
20.                 return Encoder_TIM;
    
21. }
    
22. 
    9 a% ?1 p$ Q- V! Y
23. /**************************************************************************
    
24. 功能：获取并打印输出实际速度值
    : L1 O; B, K9 @: K/ u0 ^8 X
25. 函数：void Get_SpeedNow(float* CurrentVelcity_L,float* CurrentVelcity_R)
    # i3 W( e9 @$ U( X
26. 作者：K.Fire
    + Q# ~5 m8 b9 N# j- M1 `) L
27. 日期：2022.01.30
    
28. 参数：CurrentVelcity_L:左轮实时速度(地址)  CurrentVelcity_R:右轮实时速度(地址)
    
29. **************************************************************************/
    
30. 
    
31. extern int Current_LN,Current_RN;//速度脉冲数
    % Y" |' c, ]8 I* u" ?! U
32. 
    : k* Z9 j2 [8 r1 y: q- ^4 f* ~+ b5 ]
33. void Get_SpeedNow(int* CurrentVelcity_L,int* CurrentVelcity_R)
    
34. {
    
35.         
    / N& B; }4 N1 o. {2 B( c
36.         /*外部中断方式*/
    
37.         Current_LN = Read_Encoder(1);
    % T0 L- {+ x# l  P( ^( a, i6 X4 F
38.         Current_RN = Read_Encoder(2);
    5 q2 V/ B; Z. f" x6 G% q: r
39.                
    
40.         *CurrentVelcity_L = Current_LN * MPN * 100;//计算实际速度值
    ; K& {8 ?% g; j
41.         *CurrentVelcity_R = Current_RN * MPN * 100;
    
42.                
    " F, t: T! h' w0 E" j
43.         printf("The Current Left Wheel Velocity is: %d mm/s.\r\n",*CurrentVelcity_L);
    5 m: Q# `$ u7 P2 r1 {
44.         printf("The Current Right Wheel Velocity is: %d mm/s.\r\n",*CurrentVelcity_R);
    
45. }

复制代码

0 n  D. `+ }5 Y$ N$ s& `7 |4.测试结果
6 M% z7 ~* n/ k5 \$ G通过USART1串口向电脑输出实时速度值，结果如下：
: X  F1 U  e8 Q, |1 g3 U
" K! c* e" W1 O$ K
1 _0 g& R$ g" g2 T7 t" g9 E+ `: ^! |
; t4 O, V* Z# [1 Y8 x% ~9 u: J7 h三、输入捕获法测速
输入捕获是将TIM定时器的CHx通道配置为输入捕获模式，每捕获到一个信号会将响应定时器的CNT计数器的值加/减1，然后每隔一段时间提取并清空计数器的值就可以测算出电机的实时转速。

1.输入捕获模式配置
输入捕获模式的初始化，各个STM32的教学视频都有，只是在配置编码器模式时，需要用到一个编码器模式的配置函数：TIM_EncoderInterfaceConfig（）
7 }; I5 |8 V' d8 c
输入捕获模式的初始化步骤如下：
9 p9 R% G, s8 I' x使能定时器和通道对应的时钟：RCC_APB1PeriphClockCmd（）
2 U7 ]. v3 ?2 P( L4 K4 e5 ]) T- j初始化IO口：GPIO_Init（）
3 C/ `/ j. @4 a4 [: P初始化定时器：TIM_TimeBaseInit（）
配置编码器模式：TIM_EncoderInterfaceConfig（）
9 N- G4 P$ f; B: y初始化输入捕获通道：TIM_ICInit（）
* E3 ~+ }1 B. H" M5 e7 X开启更新中断：TIM_ITConfig（）
% N& V& d5 T6 A3 D+ x使能定时器：TIM_Cmd（）
" |% R. p" v6 c' F
  [' [  t1 e1 @2 C# z0 }  t完整的代码如下：
$ |: o  w+ D. f: J
3 g# v5 ^" a( s: n

1. /**************************************************************************
     K; A1 P# c* R0 e( h5 P
2. 功能：应用输入捕获方式采集编码器数据，使用M法测速反馈车轮实时速度
   
3. 函数：void Encoder_CAP_Init()
   & L" `2 l" b/ ^. ~; A4 v; J" k
4. 作者：K.Fire
   5 ?4 ]! M  v2 T' F: A; @
5. 日期：2022.01.30
   8 t: B0 ^3 E4 q2 H" P2 R
6. 引脚：PA6(左轮A相) PA6(左轮B相) PB6(右轮A相) PB7(右轮B相)
   
7. 参数：无
   
8. **************************************************************************/
   5 C: }% x4 `5 `0 n' n6 P/ X6 h0 F
9. 
   ( P# g: B0 l. t$ G) a1 b' P
10. void Encoder_CAP_Init_L()
    
11. {
    
12.         /*1.使能定时器和通道对应的时钟*/
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
    8 G8 v) k. v- L
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
15.         
    
16.         /*2.初始化IO口*/
    
17.         GPIO_InitTypeDef GPIO_InitStruct;
    9 c; u9 `7 ]. u9 E$ @7 Y
18.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPD;//推挽下拉输入
    & |. n! o$ W4 R1 M9 Q
19.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
    0 F1 h7 k2 e$ H" d
20.         GPIO_Init(GPIOA,&GPIO_InitStruct);
      n, K4 f7 H4 f$ }
21.         
    9 K9 y1 ~9 l3 s3 u$ \8 D# [
22.         /*3.初始化定时器*/
    ! @8 }+ U& L0 z" d) T) z- R" g$ |1 {& |  |
23.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
    
24.         TIM_TimeBaseInitStruct.TIM_ClockDivision = 0;
    " p5 r0 T" @8 d+ q1 [
25.         TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    5 I! K4 y3 c5 M
26.         TIM_TimeBaseInitStruct.TIM_Period = 0xffff;
    6 R& k* M0 P: G; ]& O4 K
27.         TIM_TimeBaseInitStruct.TIM_Prescaler = 0x0;
    6 O. D% x! v" w3 J) p& z
28.         TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);
    5 H" A; ?" `1 }% n
29.         
    
30.         //配置编码器模式
    
31.         TIM_EncoderInterfaceConfig(TIM3,TIM_EncoderMode_TI12,TIM_ICPolarity_Rising,TIM_ICPolarity_Rising);
    
32.         
    
33.         /*4.初始化输入捕获通道*/
    
34.         TIM_ICInitTypeDef TIM_ICInitStruct;
    1 G5 y9 Z# N- E& N& I
35.         TIM_ICStructInit(&TIM_ICInitStruct);
    . b$ ~+ E) d9 j1 s8 l: i8 A1 i
36.         TIM_ICInitStruct.TIM_ICFilter = 10;//设置滤波器,重复检测10次，防止抖动，增加精度
    
37.         TIM_ICInit(TIM3,&TIM_ICInitStruct);
    # u8 s! t0 y& S% u# [3 `
38.         
    , q, B0 B" Q1 ~
39.         TIM_ClearFlag(TIM3, TIM_FLAG_Update);//清除TIM的更新标志位
    ' b; F5 N$ u, ?# |
40.         
    
41.         /*5.开启更新中断*/
    
42.         TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);
    
43.         
    ( H* K2 ~; _9 N1 `2 {1 ~
44.         TIM_SetCounter(TIM3,0);//计数器置零
    
45.         TIM3->CNT = 0x7fff;
    : {) j( e/ Q9 m# F
46. 
    
47. //        /*4.初始化输入捕获通道*/
    3 f" s  G2 o1 f3 X9 O* ?7 u& I
48. //        TIM_ICInitTypeDef TIM_ICInitStruct;
    4 ~( D/ V+ I# D8 b( S$ i
49. //        TIM_ICInitStruct.TIM_Channel = TIM_Channel_1 | TIM_Channel_2;//通道1和2
    
50. //        TIM_ICInitStruct.TIM_ICFilter = 10;//设置滤波器,重复检测10次，防止抖动，增加精度
    ; \* u% q7 f, h. s- }; h1 ?, o$ b
51. //        TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_TIM_ICPolarity_Rising;//上升沿捕获
    
52. //        TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;//配置输入分频,不分频
    
53. //        TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;//不设置重映射
    2 t5 d6 q0 {/ t5 n2 |  Q# I* O3 E
54. //        TIM_ICInit(TIM2,&TIM_ICInitStruct);
    ) Y) r; z; K6 P1 q" }, D7 ^0 i! k
55. //        
    - j' w- Z, e3 S$ r0 I
56. //        /*5.开启捕获中断,并配置中断*/
    
57. //        TIM_ITConfig(TIM2, TIM_IT_CC1 | TIM_IT_CC2, ENABLE);
    1 v) C) `2 K$ c- h! K# H" ~3 p
58. //        
    
59. //        NVIC_InitTypeDef NVIC_InitStruct;
    9 q* M  g. `5 A. w" K% H+ H% v" ?4 C
60. //        NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
    ( V; H  U6 v' f2 O5 p; e
61. //        NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
62. //        NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    ! k. o: M5 {$ q! M
63. //        NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    
64. //        NVIC_Init(&NVIC_InitStruct);
    
65.         
    
66.         /*6.使能定时器*/
    2 P; l$ ^5 j5 B% P( u/ M# n
67.         TIM_Cmd(TIM3,ENABLE);
    1 C) V$ D( f: c9 H. P; F6 }
68.         
    9 C5 ^; h2 P0 k" ]! Y) x9 L- C
69.         /*7.编写中断服务函数*/
    
70.         
      b; s  M8 V0 H( a1 A7 x% P
71. }

复制代码

注释部分是当时学输入捕获时跟教程写的，不用管。
5 z- S$ D9 p( p. ], v
, D; G/ O1 _( N( s8 G  O. O一个编码器需要占用一个定时器，这里我使用的是TIM3和TIM4

注意：在初始化IO口时，选择输入输出模式有点问题。

+ ^; g! C5 d! I1 M  l, w7 {我看网上有的说选择输入浮空模式、有的说选择输入上拉模式，但是我调试的时候这两种都不出结果，我改成输入下拉模式的是才调试成功，大家在实际调试过程中可以几个输入模式都试一下。
1 Z4 k5 [  |+ `5 P
2.读取捕获脉冲数值
0 ~5 j1 f) x8 K9 @# c) C这部分和上面外部中断法的函数一样，输入3和4参数使用输入捕获方式提取计数器的值。
# N3 s+ @, x( N  J3 ]" T7 J9 L

1. /**************************************************************************
   0 k1 l3 U) o# Q7 c( E% y
2. 功能：获取不同方式下的脉冲值
   5 x& j8 b/ w2 @
3. 函数：int Read_Encoder(u8 TIMX)
   # v; c) C8 S1 P* i. o
4. 作者：K.Fire
   
5. 日期：2022.01.30
   ' |2 l6 C$ l, N4 b; I' O2 Q
6. 参数：1：外部中断法左轮 2：外部中断法右轮 3：输入捕获法左轮 4：输入捕获法右轮
   3 _" q+ I0 I1 j8 J% `* H" K3 y
7. **************************************************************************/
   0 t' q  P  ?3 C, n- ^, T8 |
8. 
   ! G, s6 \5 X! \# Q
9. int Read_Encoder(u8 TIMX)
   
10. {
    / g8 Q) L0 H2 r1 X% X' T
11.     int Encoder_TIM;   
    & l( X. K1 \0 e$ G( F" _( X1 q
12.     switch(TIMX)
    
13.         {
    
14.                 case 3:Encoder_TIM=TIM3->CNT-0x7fff;  TIM3->CNT=0x7fff;break;        
    * ]3 j' l* o( Q* \9 U: E
15.                 case 4:Encoder_TIM=TIM4->CNT-0x7fff;  TIM4->CNT=0x7fff;break;
    9 h- b0 }3 O9 _4 k, j
16.             default:Encoder_TIM=0;break;
    
17.         }
    
18.                 return Encoder_TIM;
    
19. }
    6 ?* O$ j' S% n( i8 r0 K$ X1 u, O
20. 
    
21. /**************************************************************************
    5 J2 c, w3 B% P+ Q2 B
22. 功能：获取并打印输出实际速度值
    
23. 函数：void Get_SpeedNow(float* CurrentVelcity_L,float* CurrentVelcity_R)
    
24. 作者：K.Fire
    
25. 日期：2022.01.30
    - D% V) o, w$ c
26. 参数：CurrentVelcity_L:左轮实时速度(地址)  CurrentVelcity_R:右轮实时速度(地址)
    
27. **************************************************************************/
    
28. 
    
29. extern int Current_LN,Current_RN;//速度脉冲数
    
30. 
    
31. void Get_SpeedNow(int* CurrentVelcity_L,int* CurrentVelcity_R)
    
32. {
    * a- o& W: S- X1 X& ]
33.         /*输入捕获方式*/
    
34.         Current_LN = -Read_Encoder(3);
    : g% t3 N3 q  h+ C
35.         Current_RN = Read_Encoder(4);
    
36.                
    
37.         *CurrentVelcity_L = (MPN * Current_LN * 1000 * 10)/T;//单位：mm/s
    0 p+ K) }8 T  I/ k* q- }8 I- k- \
38.         *CurrentVelcity_R = (MPN * Current_RN * 1000 * 10)/T;
    
39.                
    - F/ T2 {+ w  {7 L' q( \  w
40.         printf("The Current Left Wheel Velocity is: %d mm/s.\r\n",*CurrentVelcity_L);
    ; p. L6 e+ K1 D3 v
41.         printf("The Current Right Wheel Velocity is: %d mm/s.\r\n",*CurrentVelcity_R);
    5 P* H8 t' S9 j0 y2 J
42.         
      c" v2 O& F+ t/ w
43. }

复制代码

$ d# I. O% b( K/ X3.测试结果
: Q1 d9 Q/ n! D3 z) f

. Y3 b  R3 L; a* M% E# W% a
测试结果略有误差...
( h0 r& ~8 E7 w1 S( i
程序源代码在此
) N; Y( ^3 Z) a3 A
总结
0 }3 c7 n! c6 q+ [+ S注意：左轮电机和右轮电机是相反的，需要实际测试确定，比如我这里，向前走的时候，右轮是正转，这时左轮反转的时候才是前进，在编写程序时需要给左轮的脉冲值加个负号。

. a% P+ T7 r/ Y, ^1 o; D4 r, a8 z获取到了实时速度值后，就可以用PID算法对电机转速进行准确控制了。


! Z/ D" p0 V0 t' U0 _: L0 @2 Q8 }
' J" u1 Q6 Q( f: `3 a" M