STM32CubeMX EC11旋转编码器普通IO口外部中断+定时器实现（防干扰电平）

, a7 j* ?, n& i) b, x- Q. A0 D
3 F* z, O. [: O1 W4 s9 t" o/ B项目背景是在STM32平台上的普通IO口PE13 PE14使用外部中断+定时器实现，这里因为设计没有选择可以支持ENCODE MODE的端口。

; u" |0 n8 o, i% o
EC11旋转编码器
: P3 Z; @1 {" |

" q- L# P# v4 A& _5 V0 H

+ e( D, O& N* B. l从这个数据手册中，我们可以设计出我们的思路，主要就是，以A信号作为一个时钟信号，也就是基准信号，检测到Ａ之后，再去判断B的动作，一个相对的电平。
. y0 Z5 Q# M3 d' x7 F例如，当检测到A信号下降沿触发，检测B信号此时如果是高电平，那就是逆时针，如果是低电平，那就是顺时针。
  [4 R: t4 R4 e* v

1. ///****************旋转编码开关，版本1*****************************/
   
2. uint8_t EC11Direction(void)
   
3. {
   # Y/ a; l6 c& S4 `" T
4.         while(1)
   + Z2 S, |) B* Z
5.         {
   
6.                 if(A_flag == 1)//A下降沿触发外部中断，A_flag ＝　1
   
7.           {
   
8.                   if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)　//检测B信号电平
   
9.                         {
   
10. ////                                printf("正转\r\n");
    ! C. C4 |$ r- U% K9 T' u$ }" X
11.                                 Direction_flag = 1;
    
12.                                 break;
    1 j+ Z1 |5 p) u
13.                         }
    
14.                   else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
15.                         {
    
16. ////                                printf("反转\r\n");
    
17.                                 Direction_flag = 2;
    7 n' }0 ^9 F& E) u" z  N- J. g7 P
18.                                 break;
    , ?& w$ J7 E5 |  \$ z& D
19.                         }          
    
20.           }       
    ) a: s  f5 H- {
21.   return Direction_flag;       
    
22. 
    
23. }

复制代码

# ]: A8 o  j# C) E8 q
5 W8 C9 F$ C! H0 z9 z4 s' E这个是最简单的判断方法，这个方法不是特别完善，容易出现干扰和误判断现象。不过整体是思路是这样走的。
  `$ z# i5 U! }2 D

* ~+ {9 g4 v6 i+ K% u1 Q中断标志位外部函数中实现
第一个实现版本，因为起初对于中断的不熟悉，没有直接在中断中直接写，而是只使用了中断产生的标注为来作为判断。
这个的设计思路主要是，A信号中断，消抖，确定A信号下降沿触发，打开定时器，10ms检测B信号是否上/下降沿触发，关闭定时器，判断B信号的电平高低。
软件设计流程图如下

, q7 v) R) J2 X8 O7 D

在函数中实际代码如下
5 A# U: w: o* e/ q, T

1. ///****************旋转编码开关，版本2*****************************/
   3 E; D$ }2 w- c+ H- F; ]2 y; o; A$ b! I
2. ////返回值1 正转
   
3. ////返回值2 反转
   2 x: ]$ Y5 M; z& j
4. uint8_t EC11Direction_2(void)
   
5. {
   ! Y: m$ j: U: n9 `$ {
6.         char Direction_flag = 0;
   ) A' b: u9 R6 i- }
7.         while(1)
   ( q# S: B3 X; S$ m* @# f: `' j
8.         {
   
9.                 if(A_flag == 1)//A下降沿触发外部中断
   " U8 Z- L! t  t
10.                 {
    
11.                         HAL_Delay(1);//延时消抖
    
12.                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_13) == 0)//A下降沿触发1ms后判断是否稳定在了低电平
    
13.                         {
    
14.                                 HAL_TIM_Base_Start_IT(&htim2);//开启定时器
    5 {9 h  z3 b; U! G' T0 I) B
15.                                 while(TIM2_flag <= 10)//定时器的一个周期是1ms，这里是10ms
    
16.                                 {
    
17.                                         if(B_flag == 1)//10ms内检测是不是有B上/下降沿触发
    
18.                                         {
    7 j$ x8 d+ q: a1 r: Y7 {
19.                                                 TIM2_flag = 0;//清除定时器中断标志位
    
20.                                             HAL_TIM_Base_Stop_IT(&htim2);//检测到B了直接关闭定时器
    3 Z. X5 C" c" e
21.                                                 HAL_Delay(1);//延时消抖
    
22.                                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)//判断Pin_14的电平，返回旋转方向
    
23.                                                 {
    
24. //                                                        printf("A\r\n");
    
25.                                                     Direction_flag = 1;
    
26.                                                         break;
    + L: ?/ [' U& R8 t, D, x" b
27.                                                 }
    ) @6 v1 L. I8 O/ X7 m
28.                                                        
    
29.                                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    ( V1 K* E5 w: x$ X0 @
30.                                                 {
    
31. //                                                        printf("B\r\n");
    
32.                                                         Direction_flag = 2;
    
33.                                                         break;
    
34.                                                 }
    / R. T% Z" H2 a. E$ L
35.                                         }
    
36.                                 }
    
37.                                 HAL_TIM_Base_Stop_IT(&htim2);//定时器一个周期溢出后（TIM2_flag>1），关闭
    6 ?; V% F; }& y; i$ \
38.                                 TIM2_flag = 0;//清除定时器标志位
    
39.                         }
    
40.                         A_flag = 0;//清除A中断的标志位
    : K! @& O' t) @- D- Z7 q6 ^
41.                 }       
    
42.                
    . R! J& m8 l+ F0 P3 T  t
43.                 if(Direction_flag == 1 | Direction_flag == 2)
    0 w+ T1 M9 s9 {0 ^
44.                         break;
    
45.         }
    ) I9 k$ {0 U+ {; V# K
46. return Direction_flag;       
    
47. 
    8 Q6 O& m# t! T
48. }

复制代码

- q6 G6 ^0 y$ W) L; ~0 G在main.c中的定时器的标志位设置，使用了TIM2定时器，溢出就+1
" o0 k4 i/ ?: V; y" Y9 q- a* x. s

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
2. {
   9 j: W4 [- R& Z! K
3. 
   # [# O$ q- r  z, R7 O
4.         if (htim->Instance == TIM2)
   
5.         {
   
6.         HAL_IncTick();
   ; R% A& f) A+ @( `: F
7.                 TIM2_flag++;
   
8.   }
   / l" S0 F- o: y% `% F" c
9. 
   
10. }
    

复制代码

4 ^; x7 z/ [& ]$ t
) _) q& e& Q$ M9 ]5 R+ r# x3 N) r# N在tim.c文件中TIM2的配置

7 ~. [/ |5 y3 x+ O; C# l

TIM2的时钟输入是75MHZ，所以设置分频和计数分别为 750-1 和 100-1，这样的话一个时间周期就是1ms 频率是1000hz。
0 j* Z, C$ H" w* t在stm32f4xx_hal_gpio.c文件中，我们找到外部中断对应的回调函数HAL_GPIO_EXTI_Callback，直接判断到外部电平触发后返回标志位就可以了。
5 ~" {. o2 \7 S# k% b, I
9 o# l- `- |3 m; V

1. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   ( l0 Q  D, J6 h
2. {
   : y( k! C: H/ A; |* k
3.   /* Prevent unused argument(s) compilation warning */
   " @- T1 G( S! @" l3 u2 G
4.   UNUSED(GPIO_Pin);
   
5.   /* NOTE: This function Should not be modified, when the callback is needed,
   
6.            the HAL_GPIO_EXTI_Callback could be implemented in the user file
   0 o$ |2 S2 k5 a
7.    */
   ( V% h- W7 L6 J, {6 _! b( ^# \4 G
8.         if(GPIO_Pin == A_Pin)
   - Q! T) `; C  A1 N* q! {6 X
9.         {
   
10.                 A_flag = 1;
    
11.         }
    
12.         if(GPIO_Pin == B_Pin)
    
13.         {
    
14.                 B_flag = 1;
    
15.         }
    
16. }

复制代码

$ A+ f6 L7 R* k; o$ _9 m$ ^, x8 \0 V
这样写，虽然可以实现对于旋转编码器的检测，但是有一个问题，没有办法很方便的运用到实际工程中，以为进入到这个函数后才能进行编码器的判断，显然我们的编码器要实现的是一个翻页的功能，触发就要有操作的，而不是等着。
% U: }/ |! J' S6 t8 {' Y* v6 ~' _虽然可以设计进去超时函数让编码器跳出，但是还是没有办法实现实际项目的需要。于是准备直接写到中断回调函数中。

4 W% O8 G. D& ^+ O2 B
中断回调函数中实现
& H  e7 f7 @# i; W0 @按理说直接写到中断回调函数应该挺容易的，直接改就行了 ，逻辑反正是通的，但是遇到了几个问题，一个是延时消抖的问题。
HAL_Delay本质也是一个中断服务函数，这种延时函数中断的嵌套是非常危险的操作，很容易卡死程序，比较有隐患，所以HAL_Delay函数是不能用了。
同时，因为回调函数是这样来使用的void EXTI15_10_IRQHandler(void)中检测到外部中断， 调用HAL_GPIO_EXTI_IRQHandler(GPIO_PIN);函数，然后再调用里面的回调函数void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)。
我们这个里面用到了两个外部中断，PE13 和 PE14，也就是都会使用同一个回调函数，也就是无法完成这种操作
3 U- C2 p4 S3 E3 V% U

1. if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   # J" _5 U( H6 d
2. {
   
3.    if(GPIO_Pin == B_Pin)
   : x" v! Y9 s6 o) L
4.    {}
   7 P) @& K6 P/ j2 ~* _1 B  ?
5. }

复制代码

" x4 k5 _% c- f; o9 V& b
6 i$ j+ _' L) M/ R2 l2 g这里就是举了个例子，因为回调函数的调用逻辑，没有办法在检测了A信号触发后在操作里面检测B信号的触发。这是做不到的，这是回调函数限制了操作。为了避免这种，最好的方法还是直接写在void EXTI15_10_IRQHandler(void）函数中，HAL_GPIO_EXTI_IRQHandler(GPIO_PIN);函数和void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)都不使用，把他们实现的服务函数还有中断标志位清除操作全都直接写在AL_GPIO_EXTI_IRQHandler(GPIO_PIN);函数中，这个也就是我后面的一个方法。
7 [9 w' u' t$ P- q! f7 i' |) T- U回调函数中想要实现，可以采用这个方法

1. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   % T6 w9 J* }0 H2 @+ U* k% E) K
2. {
   3 J" K3 G% j" K  [# P( L
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(GPIO_Pin);
   : P! L( l: f. p) K/ D% }
5. 
   , I' U' P# ~% H7 h7 G/ @/ z- u
6.                 if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   & }6 V. h2 B1 ]" C
7.                 {
   
8. //                        printf("A下降沿触发\r\n");
   9 x! f4 [, R3 F6 x9 `+ V+ s
9.                         HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
   
10.                         B_last = HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14);//记录此状态的B状态
    
11.                         while(TIM2_flag <= 60)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    
12.                         {
    3 s9 e* |$ N1 Z$ y% K: r
13. //                                printf("等待B的触发\r\n");
    
14.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) != B_last)//在20ms内，检测到电平变化
    ; H) m; h& [  I- B/ A* {
15.                                 {
    + C; I/ U; q+ w* I8 b. `
16. //                                        printf("B下降沿触发\r\n");
    
17.                                         HAL_TIM_Base_Stop_IT(&htim2);
    
18. //                                        printf("TIM2定时器关闭\r\n");
    " Q2 E7 Z$ m) t8 D" r
19.                                   TIM2_flag = 0;
    , ~- V6 Z) m" i* r! B' F
20.                                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    3 z- W+ G" H& _' k! x( J
21.                                         {
    3 C3 N% Z) ~6 h4 G- |1 X; Q* ?2 P; T
22.                                                 printf("A\r\n");
    : j5 D% C0 ^' [
23.                                                 break;
    " w/ j$ L" M* \; |8 n, Y6 J
24.                                         }       
    1 Q+ }- e# u1 t: W5 `1 ]$ k
25.                                         else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
26.                                         {
    * \$ E: C, e& z2 R/ _0 T
27.                                                 printf("B\r\n");
    & E3 S" {+ W. x1 O; E5 E
28.                                                 break;
    3 [; {+ X& _9 ^1 r3 o) ~
29.                                         }
    
30.                                         break;
    
31.                                 }
    " ~/ ^5 i0 q7 h, b! D
32.                         }
    
33.                         HAL_TIM_Base_Stop_IT(&htim2);
    , I4 {: t' ^2 M
34.                         TIM2_flag = 0;
    
35.        
    
36.                        
    4 Z# A" S0 Z# W3 k1 T4 z9 M- M
37.                 }       
    0 X: e' d- B8 Y7 y- F  D
38. }

复制代码

1 F( Q: B6 N3 Q4 T- v2 x$ u: x也就是相较于之前，去掉了消抖的函数，然后也不是检测B的边沿触发，而是判断B信号，在一个时间范围内，有没有发生电平的变化，直接检测B信号电平高低的变化，实现了一样的目的。


中断函数中实现
: T( t+ b  e1 }7 X! g) x直接写在void EXTI15_10_IRQHandler(void)；函数中无非就是多了步在中断触发之后需要手动清除中断标志位，其他都大同小异的思路，这里就可以检测A中断触发后，然后检测B中断触发，就不会出现什么问题了。
. y. L9 k+ t/ H. TSTM32CubeMX外部中断定时器嵌套问题及实验现象
写在回调函数中的这些实验现象和问题，现在的话就都不存在了。
/ y7 M- r6 o/ n4 ~0 e4 E6 W; t

. m' W0 d' A0 W  H

1. void EXTI15_10_IRQHandler(void)
   
2. {
   ' @! Z1 n5 \/ Z$ l' G
3.   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
   + @3 ]8 v: @9 \( G1 d
4. 
   6 S1 ~" G. b( M' I  S, p
5.   /* USER CODE END EXTI15_10_IRQn 0 */
   
6. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
   ' N7 j. x, Q+ i7 t( ?) z
7. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
   
8. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
   + n5 b- @; s9 g# }
9.   /* USER CODE BEGIN EXTI15_10_IRQn 1 */
   
10.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_13) != RESET) //A下降沿触发
    
11.         {
    
12. //                printf("A下降沿触发\r\n");
    
13.                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_13);
    
14.                
    5 G2 u1 E7 ?/ V. P( s4 L, {
15.                 HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    
16.                 while(TIM2_flag <= 10)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    ( u+ D3 d  V* {8 j4 v
17.                 {
    
18.                         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_14) != RESET)
    
19.                         {
    8 F1 ~& a# @& i: C
20. //                                printf("B下降沿触发\r\n");
    - b" \+ D2 }; c, L
21.                                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_14);
    
22.                                 HAL_TIM_Base_Stop_IT(&htim2);
    
23. //                                printf("TIM2定时器关闭\r\n");
    ' v5 K8 m  l, M4 B; f
24.                                 TIM2_flag = 0;
    1 _, Q$ q  \' k7 a1 ?% I1 M* N
25.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    1 ]% r+ p) G7 y5 H+ T! u: S$ A: q7 K
26.                                 {
    
27.                                         printf("A\r\n");
    
28.                                         break;
    
29.                                 }       
    
30.                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
31.                                 {
    
32.                                         printf("B\r\n");
    ; p, R  [3 J( c7 P' S
33.                                         break;
    ! K& I2 N. P$ N7 J
34.                                 }
    1 H& U7 r4 v  V: [7 t/ ~  `
35.                                 break;
    . s/ n, U+ J/ b7 X2 g4 @
36.                         }
    
37.                 }
    
38.                 HAL_TIM_Base_Stop_IT(&htim2);
    1 @# L+ x' n: V& w* G# |
39.                 TIM2_flag = 0;
    2 j, `9 l) b) b0 V
40.                
    : @4 m2 Q+ W7 u. Q" |; @7 y# g. {
41.         }
    2 \+ O* O( Q% V# n% G
42.        
    
43.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_15) != RESET)
    ( B# H' H; A0 K: n
44.         {
    2 S* ~0 h' Q' S7 J. y
45.                 printf("SW按键\r\n");
    ' v* W5 v6 M7 m5 K: y0 B5 Z
46.         }
    9 y( J/ B8 X" S. @) a5 X! E/ @
47. 
    9 n3 d( t& T% ?, w
48.   /* USER CODE END EXTI15_10_IRQn 1 */
    5 d; S. p7 u% f$ |9 d; p
49. }

复制代码

' \% M+ S( O9 H; H9 D
) a, b' R% s& o1 E
  X2 \( D( d0 _" v

1 k' ~$ b3 V- u3 [8 Z

通用

你这个太麻烦了，当有下降沿触发时直接检测两路信号同是低电平就能判断左右旋转。

代码又长又臭，其实很简单就可以实现了

ts2000 发表于 2020-10-28 10:07
代码又长又臭，其实很简单就可以实现了

+ [3 f5 m+ O9 ~# U+ b这个确实复杂了，大佬有机会做个分享

jtb1111 发表于 2020-10-27 15:45
你这个太麻烦了，当有下降沿触发时直接检测两路信号同是低电平就能判断左右旋转。 ...

大佬有机会做个分享

STMCU 发表于 2020-10-29 09:12
大佬有机会做个分享

& ^7 }) z4 R, K1 G9 C& z8 F7 O我记得我以前搞过，貌似没有你这么复杂，而且程序实现也比较简单可靠，
不需要定时器，也不需要中断，普通的 io 口就可以了
现在程序一时忘记放在哪里了，有空我找找