基于STM32的编码器详解
基本原理：
' p8 _7 A# J7 J  K* \$ R  S       光电编码器由三个部分组成：发光二极管，码盘以及码盘背面的光传感器。

       这个码盘安装在旋转轴上，上面均匀地排列着透光和不透光的扇形区域。当码盘转动时，不透光的部分能够挡住光线，而透光区则允许光线透过，那么码盘背面的光传感器就会周期性地收到光信号，从而输出一列方波。

% H5 b6 z5 g* d
       我们知道，码盘转动一周时，光传感器输出的脉冲个数是一定的，通过检测一定时间内收到的脉冲个数，就可以知道在这段时间内码盘转动了多少圈，进而换算为速度。例如，一个码盘转动一周时会输出100个脉冲，在0.1s内我们收到了500个脉冲，这意味着0.1s内码盘转动了5周，即码盘的转速为50r/s。
/ @* v# [% p) x- V+ ^1 t' }  y& K

; A8 |2 _7 k( m: k3 |      但是，还有一个问题。设想，如果编码器只输出一列方波（假设为A），我们该怎样判断码盘是正转还是反转？因为无论是正转还是反转，都会产生同样的方波，而它们对速度的贡献显然是相反的！
! |& g% B! C. P! Y0 N6 z

       接下来我们看一看这个问题该怎样解决：
' y) w4 a/ K3 t) L% Q

- {7 ?/ R1 j, t      上面我们已经说过，码盘上均匀地刻着透光和不透光的扇形区域，我们在这一圈扇形区域内再均匀地刻上一圈透光和不透光的扇形区域，不同的是，外圈和内圈的区域是“交错”的。也就是说，当外圈处于不透光区域时，内圈对应的一半为透光区域，一半为不透光区域；当外圈处于透光区域时，内圈对应的一半为不透光区域，一半为透光区域。

0 H& G9 g' s1 l. B3 l+ `1 b' _% k
      于是，当码盘转动时编码器会输出两列相位差为90°方波，波形如下：





      下面左图为正转时的波形，右图为反转时的波形：

7 Z* ~4 t2 o0 @" d, ^+ i- T! N& S



      当码盘正转时，在方波A的上升沿，方波B恒为低电平；当码盘反转时，在方波A的上升沿，方波B恒为高电平。通过判断A处于上升沿时，B的电平状态就可以方便地知道码盘旋转的方向。

* Q$ U6 R! _- N! S8 p6 \: i$ q
: {  t. P* H7 d' l; S       速度计算：
6 m0 M; y  a% J: h- I! _8 W

  _5 I# J3 Y# z( F- D! b       不同型号的编码器，码盘旋转一周输出的脉冲个数是不同的，我使用的编码器码盘旋转一周输出的脉冲个数为90，小车轮子的直径为75mm 。
$ E+ [* L1 P% H) B! @

       假如我们在时间T内统计到的有效脉冲数目为S（正转脉冲数+1，反转脉冲数-1），小车轮子的直径为D，圆周率为pi（约为3.14），那么小车的速度换算公式如下：
. ~) k/ Z  y4 E
( N3 P9 D& U- `% h
- I9 F" R, x* ^% q                  V = pi*S*D / (90*T)
- \, @9 \, n+ _8 a) z0 {4 l

       例如，我们每隔1 s统计一次有效脉冲数目，某一次得到的有效脉冲数目为500，那么小车此时的速度为：


# D1 {& _: m) J1 HV = 3.14*500*75*10^(-3)/(90*1）
# j% m8 f. b& v- \7 m
* ?% D. g' ~+ j0 t
   ≈ 1.31 m/s


* s9 v0 U& z4 h2 `       我们可以看出，问题的关键在于，如何统计一定时间内的脉冲数目？目前有两种思路：

+ u% z: Z# M! J/ u0 Q
       ①利用中断检测A的上升沿，触发中断时判断B的电平，来决定计数值加还是减；

7 ^" f9 j3 Y5 ^5 m, p& G) s. ]5 E$ z* ]
        ②将定时器设置为编码器模式，直接读取计数值和方向。
% r: I8 _1 T5 f3 \6 k, J+ C$ t1 Y
  W7 V5 J( X& {% u0 ?2 N9 ~9 l6 G
      下面分别介绍这两种方法的实现：

0 f- {! Q$ t) D9 F7 {
代码实现
利用中断检测A的上升沿，触发中断时判断B的电平，来决定计数值加还是减
1 I% N1 `) X0 R) `9 Y; y$ h
7 j/ v$ `  t7 w7 v( J
（1）打开CubeMX，设置相关管脚，我这里使用的是PC2和PC3来           接A、B相
4 O1 s( I/ q1 i  _. j, [
9 I8 u' n% X+ w$ H
- z* @) E( _1 [7 f% s9 y

0 q/ k! O; ~1 Q3 z; [8 t, U9 j
3 K, N/ O& ~7 I4 D+ r5 }, f设置A、B相接口
! W8 M0 T* H; ]8 a& T5 s4 t- N+ @: B
: ^3 A- A3 J* m! k
3 @& b9 O! z7 Q* Z! O* x0 b

6 x9 |; t2 {4 A3 ~- d. h
将PC2设置为上升沿触发

" n- y; d% H( l
- W- g* s4 y. t& z, u/ D) M! c（2）为方便观察，打开UART串口，从串口读取采集到的数据


& h0 j" T7 v# R! D1 X# {7 k- z
0 m) H8 c& w& C$ b8 Y* c

" F4 g, o' G2 g2 b0 R' c打开UART1
% h1 }- N4 U/ s+ m' }, Z" _
6 X2 i/ |% c: E4 s2 ~' A+ q% J
3 q/ ^! v/ Y' ~
+ O2 O5 E) q: f/ l  }
2 q+ }; W' m! g' f  b3 t4 F
UART串口设置
( s. S6 v% J: {/ m
5 f: x; x. ?8 v5 c& V
（3）打开定时器2，定时器响应时通过UART串口把计数值打印出来

3 x( |7 \9 ~) B$ W6 F( `
2 l' N6 `) _2 L0 x7 b1 s7 `


配置TIM2
- i2 U- y% G4 _




计时200ms


* U# @" S- s& Y( O& j; E5 k( t（4）导入Cube工程
/ y9 T! s' y4 _  h/ |9 t

1. 
   
2. int COUNT = 0;             //用来计数
   
3. char str_buff[64];
   
4. char point[64];
   ) s7 `$ Q2 Y7 O: k+ X' @% b1 s# v  w& O
5. float speed = 0;               //速度
   
6. int flag = 0;                  //flag=0时计数，flag=1时清零

复制代码

定义相关变量

1. 
   * H0 e9 x2 Q6 b$ \
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
3. {
   7 I9 \+ |  T6 a& Q4 D4 f* x
4.   if (GPIO_Pin == GPIO_PIN_2)
     K% D+ m6 S! v8 {0 e
5.   {
   
6.     if (flag == 1)
   
7.       COUNT = 0;
   ) ~- ^6 z$ q0 f2 i' R
8.     else
   
9.     {
   
10.       if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_3) == 0)
    ! k7 [$ D8 h9 f, _/ I5 T
11.         COUNT++;
    7 ~" `0 H1 t1 I  F" X
12.       else
    
13.       {
    
14.         COUNT--;
    
15.       }
    . g. _5 F. r, }5 {# G
16.     }
    / i7 V. m0 l. f& ^
17.   }
    - b6 M5 p: y0 Z3 c: {
18. }

复制代码

重写中断回调函数
! J, g* T+ l  c

1. 
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
3. {
   
4.   if (htim->Instance == TIM2)
     H* M) U8 x& N& Q5 |
5.   {
   5 P- g3 K, s# m. n  K
6.     if (flag == 0)
   ( ~: o9 l" h. R1 n7 k! {) A+ F
7.     {
   
8.       speed = (float)COUNT * 3.14 * 0.14 / (90 * 0.2)*100/34; //cm/s
   
9.       sprintf(str_buff, "speed:%dcm/s\r\n",(int)speed);
   + y" C8 H% Y$ {& k
10.       HAL_UART_Transmit_IT(&huart1, (uint8_t*)str_buff, sizeof(str_buff));
    9 A; g; Q  ?+ e; I# \
11.       flag = 1;
    9 ]. D5 q  q9 r% ?, ]) R% p" i5 b0 C
12.     }
    % U- c) x4 p/ O
13.     else
    
14.     {
    
15.       flag = 0;
    
16.     }
    * A8 k' l+ F, _/ t& u* X2 N# y
17.   }
    7 t6 }9 K* T! B  e# P
18. }

复制代码

定时器响应后通过UART串口发送数据

1. 
   4 Z. L: o/ H4 u! N1 d
2. HAL_TIM_Base_Start_IT(&htim2);

复制代码

在主函数中打开定时器2


实际测试
测试效果如图：

/ Y+ X2 F" q% |) O8 Z# @

8 ^- l9 w4 k) b/ d- p7 n" |" `
# E1 ]1 ~  ], e/ ?1 D' L8 f" `8 A实际效果


9 x2 Q/ L- u5 V2. 使用定时器的编码器模式
* V3 [4 b8 p; F1 i! `: y6 u. a

! f: M  r0 ?. G. K（1）设置TIM4为编码器模式
0 w$ [- K1 r% M( n6 Q, C
& T1 E8 G$ A( z4 {( q3 _5 `) J

9 c) {  U$ T5 G) n- A5 N- a, K
: [" x% D- h, s! j8 _7 a2 t1 q
3 a! z9 a9 w  W3 Q5 k+ L设置Combined Channels

2 i- O( B. T$ o" G) T1 C* N
（2）配置编码模式
  P- N9 P! k- k


: d, Z3 v+ R, v# }/ Z$ dPrescaler：分频系数

3 @% E# G$ q; ~$ y( k1 @2 u: L: U
+ h1 M3 v% _( ^; ~( l, _Counter Mode：计数模式，设置为UP代表码盘正转时计数值增加，反                             转时计数值减小
+ Y5 f: L: j1 v/ Y- o# W0 K4 W  L

Counter Period：当编码器计数值等于该值时，计数值会清零，一般避                              免编码器清零设置为65535（最大值）
8 W# [! {: w$ Q/ L" g

% m/ ]$ D( k5 r: c. t  PEncoder Mode：计数模式，编码器计数有三种模式可选


①T1

) _: e  p% H# W8 l+ X' h
* X& j  c5 J+ h8 A$ ]" u' g只在上升沿计数，例如在一定时间内A产生了100个脉冲，那么编码器计数值为200（A、B产生脉冲数相等），由于分频系数的存在，实际调用函数得到的计数值为200 / ( Prescaler + 1 )；
8 S5 N+ m0 O3 }4 ~8 X
; }! l! W: n* [" ?* [
②T2
) R0 S7 m* R% P. o

+ o; c2 t* k! a' ?8 u! x: Z1 i. `只在下降沿计数，计数值与T1相等( Prescaler相等的情况下）；


( J1 `' N: N9 i/ F  N- }1 v③TI and T2
. D2 F* J* M+ N. U: q9 ^
& V/ F: Z0 }2 |, L1 ?- }
) q( A( W$ x0 Z) o/ W7 [. \在上升沿、下降沿都计时，计数值为T1的两倍( Prescaler相等的情况下）；
5 [+ L% x+ e" N
) z7 @* X9 G2 H& ^' R( x
（3）导入CubeMx工程
# y3 c' b4 e# c5 h( v

1. 
   
2. uint8_t GetData;     //编码器计数
   & e2 N, F9 x8 o; f
3. uint8_t data[64];
   # l# r: `% r2 u; \  F9 f; ?
4. uint8_t Direction;  //编码器方向

复制代码

定义相关变量

1. HAL_TIM_Encoder_Start(&htim4, TIM_CHANNEL_ALL);

复制代码

打开定时器模式
! N- |  x5 P9 d) L; k

1. 
   # S) Y: c* g' q# ^8 X3 {
2. while (1)
   ' Z2 |3 [  `! I& S' d9 r" [; x
3.   {
   
4.    
   5 o9 A& A# n  J$ c
5.     GetData = __HAL_TIM_GET_COUNTER(&htim4);
   - |' j% j. {7 x8 \) I" f- s$ c
6.     Direction = __HAL_TIM_IS_TIM_COUNTING_DOWN(&htim4);  
   
7.     sprintf((char *)data, "fre:%4d dir:%d",GetData*2,Direction);
   + T' k' Q& H; E  K
8.    
   0 x9 p4 ]3 `% Y& ]* b- S
9.     OLED_Clear();
   
10.     OLED_ShowString(0,0,data);
    8 O- }# A3 i( G, f2 L& t7 J
11.     __HAL_TIM_SET_COUNTER(&htim4,0);
    $ ~8 `9 n9 G# k# }! I; G- b
12.     HAL_Delay(500);
    / t& S) B5 s7 K. m& e  |5 m
13.     /* USER CODE END WHILE */
    
14. 
    
15.     /* USER CODE BEGIN 3 */
    % H: R  B5 ?  X4 O: v$ K( a0 e
16.   }

复制代码

读取相关值并通过OLED显示出来

1 k- j" @2 e* M, I
% j5 Y& C7 t' B0 w实际效果
4 {8 ^- v8 U$ t* P$ U$ J* v       用函数发生器模拟两列方波，配置编码器时我采用T1 and T2模式，分频系数为3，所以1s内采集到的脉冲个数为( 50 * 4 ) / ( 3 + 1 ) = 50，延时时间为500ms，所以OLED显示的值为 50 / 2 * 2 = 50 。
; X9 [0 i6 [9 @- ]. l3 x) F/ }

: m! g+ a$ W/ e  T& l
9 D; G& l4 l$ {$ Y$ v
. ?; J% g1 M- V
实际效果


6 W- ?% e( t( N3 X


  M( Q/ o/ n8 l. `9 {' _! f

支持！