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

) w- g/ i" p6 M) v+ ?. ^) K, Z% L- K项目背景是在STM32平台上的普通IO口PE13 PE14使用外部中断+定时器实现，这里因为设计没有选择可以支持ENCODE MODE的端口。
5 j7 D% L" U6 y7 r) o( e- I/ [! U

EC11旋转编码器

; I9 w+ E7 G( W  {: R  h从这个数据手册中，我们可以设计出我们的思路，主要就是，以A信号作为一个时钟信号，也就是基准信号，检测到Ａ之后，再去判断B的动作，一个相对的电平。
例如，当检测到A信号下降沿触发，检测B信号此时如果是高电平，那就是逆时针，如果是低电平，那就是顺时针。
4 ^, ~- v5 y, O& ^1 s8 q. l
( p; s9 z% R2 M. h
5 g3 Z+ m( F7 u

1. ///****************旋转编码开关，版本1*****************************/
   
2. uint8_t EC11Direction(void)
   
3. {
   
4.         while(1)
   
5.         {
   8 D, @1 V- H7 K! `9 Z
6.                 if(A_flag == 1)//A下降沿触发外部中断，A_flag ＝　1
   0 }  U& A* f: l
7.           {
   0 o  K2 R4 u, B. r5 Q+ [/ C; X9 ?
8.                   if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)　//检测B信号电平
   
9.                         {
   ' @! v* D0 q  k
10. ////                                printf("正转\r\n");
    
11.                                 Direction_flag = 1;
    & n, ?! b7 C, S: O# }3 K9 b
12.                                 break;
    5 D  K; q" \, i7 g5 p  ]4 o9 u9 j3 D
13.                         }
    
14.                   else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
15.                         {
    
16. ////                                printf("反转\r\n");
    6 M, r) x2 O, }
17.                                 Direction_flag = 2;
    
18.                                 break;
    
19.                         }          
    : A" o! o/ ?) K0 |: ]" z
20.           }       
    
21.   return Direction_flag;       
    9 B3 `9 y! ~; ^5 a. A
22. 
    
23. }

复制代码

这个是最简单的判断方法，这个方法不是特别完善，容易出现干扰和误判断现象。不过整体是思路是这样走的。
7 ]6 {, P, M  Z' v# v. J' b
3 j) t4 I* ~0 s* @2 N1 Y/ v" G
& w; F$ L9 d% ^" x中断标志位外部函数中实现
第一个实现版本，因为起初对于中断的不熟悉，没有直接在中断中直接写，而是只使用了中断产生的标注为来作为判断。
这个的设计思路主要是，A信号中断，消抖，确定A信号下降沿触发，打开定时器，10ms检测B信号是否上/下降沿触发，关闭定时器，判断B信号的电平高低。
6 a% {1 }$ |( E/ _软件设计流程图如下
) B3 Q3 O/ c! l- z# H' X1 R$ A0 h- |
* h+ g6 r  D) G' a! }

  t2 S" l' A# X6 `! |在函数中实际代码如下


; k' E8 A# h( S) f0 y

1. ///****************旋转编码开关，版本2*****************************/
   " D3 c8 L: c+ q
2. ////返回值1 正转
   5 n8 f% S+ m/ }: G" F8 r7 n2 b
3. ////返回值2 反转
   ' h! w8 g, o2 p3 h. o
4. uint8_t EC11Direction_2(void)
   
5. {
   0 N2 v9 \- ~' q4 B
6.         char Direction_flag = 0;
   
7.         while(1)
   
8.         {
   3 O) v2 t( A& ]3 K( A
9.                 if(A_flag == 1)//A下降沿触发外部中断
   
10.                 {
    
11.                         HAL_Delay(1);//延时消抖
    
12.                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_13) == 0)//A下降沿触发1ms后判断是否稳定在了低电平
    " g. T- p1 g; i  u: i) A
13.                         {
    ; ^% F) W2 d* @1 \1 L/ P5 v
14.                                 HAL_TIM_Base_Start_IT(&htim2);//开启定时器
    
15.                                 while(TIM2_flag <= 10)//定时器的一个周期是1ms，这里是10ms
    
16.                                 {
    
17.                                         if(B_flag == 1)//10ms内检测是不是有B上/下降沿触发
    
18.                                         {
    5 i* H, h7 B9 w
19.                                                 TIM2_flag = 0;//清除定时器中断标志位
    1 x  x& x1 v+ m: b* x& D
20.                                             HAL_TIM_Base_Stop_IT(&htim2);//检测到B了直接关闭定时器
    
21.                                                 HAL_Delay(1);//延时消抖
    
22.                                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)//判断Pin_14的电平，返回旋转方向
    
23.                                                 {
    
24. //                                                        printf("A\r\n");
    + d, [8 N/ Z# v- S9 e8 l8 B
25.                                                     Direction_flag = 1;
    
26.                                                         break;
    
27.                                                 }
    
28.                                                        
    
29.                                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
30.                                                 {
    # U% O  @$ s3 J# I$ f$ q6 t" N
31. //                                                        printf("B\r\n");
    2 F: E/ _1 z2 J
32.                                                         Direction_flag = 2;
    
33.                                                         break;
    # c6 M6 }7 i( q
34.                                                 }
    
35.                                         }
    
36.                                 }
    
37.                                 HAL_TIM_Base_Stop_IT(&htim2);//定时器一个周期溢出后（TIM2_flag>1），关闭
    ! A& b' y3 X" j
38.                                 TIM2_flag = 0;//清除定时器标志位
    ! ~$ K8 W1 U5 F6 A% D
39.                         }
    
40.                         A_flag = 0;//清除A中断的标志位
    
41.                 }       
    
42.                
    
43.                 if(Direction_flag == 1 | Direction_flag == 2)
    
44.                         break;
    
45.         }
    ; m. `+ k# w$ d0 L  U7 h3 c
46. return Direction_flag;       
    7 {$ }  _9 L  C& h
47. 
    
48. }

复制代码

# M1 o5 o- F& Y3 l9 C$ V
4 n& Z+ [3 M- c* o1 `在main.c中的定时器的标志位设置，使用了TIM2定时器，溢出就+1
2 h4 w& D1 ?: B* S- p7 ~' M0 c

. g8 O' `3 q) ^6 ]' z1 m1 B

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
2. {
   
3. 
   " y9 }' y( F' v& w
4.         if (htim->Instance == TIM2)
   
5.         {
   
6.         HAL_IncTick();
   
7.                 TIM2_flag++;
   " u9 {* f, Y4 F) h, W1 ^- t
8.   }
   1 f3 l# g! f4 q8 X9 E
9. 
   
10. }
    ! Q( X* O3 o" ?$ i" t0 x9 {

复制代码

3 ^* F( K% I  p. n- A; F
在tim.c文件中TIM2的配置
& v8 p+ p; @' ^! q  Q5 f9 Z  e% A) {

" a+ F  k% i% }7 q! ?  L

TIM2的时钟输入是75MHZ，所以设置分频和计数分别为 750-1 和 100-1，这样的话一个时间周期就是1ms 频率是1000hz。
- x3 T$ ~9 t) J% J$ M8 }# D在stm32f4xx_hal_gpio.c文件中，我们找到外部中断对应的回调函数HAL_GPIO_EXTI_Callback，直接判断到外部电平触发后返回标志位就可以了。
- |7 _8 w: `* K% L# r. s0 i: Y& a9 ]

1. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   6 B) T" t$ D0 m- K' G# T$ K4 W/ W
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   , X8 K- i1 G0 k/ y4 a& @" a' X
4.   UNUSED(GPIO_Pin);
   
5.   /* NOTE: This function Should not be modified, when the callback is needed,
     _8 y# r& n1 J8 a4 A0 _; ?2 v
6.            the HAL_GPIO_EXTI_Callback could be implemented in the user file
   : s8 |( F7 f, F9 x
7.    */
   
8.         if(GPIO_Pin == A_Pin)
   / o# `" \" y) U. Z
9.         {
   
10.                 A_flag = 1;
    ( j  E, C9 K0 h4 @4 q0 Q
11.         }
    ; H0 M% p9 Y( P
12.         if(GPIO_Pin == B_Pin)
    $ {) n% S! E# h# F: r0 D
13.         {
    
14.                 B_flag = 1;
    
15.         }
    . D( {. @5 a6 k+ ^
16. }

复制代码

& `- _! w* M4 {; \这样写，虽然可以实现对于旋转编码器的检测，但是有一个问题，没有办法很方便的运用到实际工程中，以为进入到这个函数后才能进行编码器的判断，显然我们的编码器要实现的是一个翻页的功能，触发就要有操作的，而不是等着。
1 n" S% t8 [: {2 D! ?8 }虽然可以设计进去超时函数让编码器跳出，但是还是没有办法实现实际项目的需要。于是准备直接写到中断回调函数中。

: a. S4 }* w9 q
中断回调函数中实现
按理说直接写到中断回调函数应该挺容易的，直接改就行了 ，逻辑反正是通的，但是遇到了几个问题，一个是延时消抖的问题。
HAL_Delay本质也是一个中断服务函数，这种延时函数中断的嵌套是非常危险的操作，很容易卡死程序，比较有隐患，所以HAL_Delay函数是不能用了。
同时，因为回调函数是这样来使用的void EXTI15_10_IRQHandler(void)中检测到外部中断， 调用HAL_GPIO_EXTI_IRQHandler(GPIO_PIN);函数，然后再调用里面的回调函数void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)。
" k8 M& g3 c) e5 _我们这个里面用到了两个外部中断，PE13 和 PE14，也就是都会使用同一个回调函数，也就是无法完成这种操作
2 p) `0 \# Q: y7 n$ I  ^4 L& g: h; g

1. if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   
2. {
   
3.    if(GPIO_Pin == B_Pin)
   $ n, m; P9 E4 N$ L% \& i1 C
4.    {}
   . U& F- |6 I: Q# s' W! ^
5. }

复制代码

9 R* J1 o$ x2 w8 g
- |) I# c2 m8 H5 x9 X( G9 x这里就是举了个例子，因为回调函数的调用逻辑，没有办法在检测了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);函数中，这个也就是我后面的一个方法。
- h. l& r8 i6 q1 Y1 P7 a! W! @: A回调函数中想要实现，可以采用这个方法
( M8 G7 b' w! R4 {: R3 X

- p3 j0 ?+ g% z+ _  _1 B. b9 ^

1. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   ( N3 f- E$ M$ S; s
4.   UNUSED(GPIO_Pin);
   
5. 
   
6.                 if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   
7.                 {
   
8. //                        printf("A下降沿触发\r\n");
   3 ?' F" J/ n$ c1 [% V& ]6 l
9.                         HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
   - [4 G( B8 q  \* ]
10.                         B_last = HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14);//记录此状态的B状态
    , o  G1 f/ p. ^5 I
11.                         while(TIM2_flag <= 60)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    ; |! I1 b$ B" N+ B6 J0 _
12.                         {
    
13. //                                printf("等待B的触发\r\n");
    8 c% @; _! g* x0 r0 ~4 w
14.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) != B_last)//在20ms内，检测到电平变化
    
15.                                 {
    
16. //                                        printf("B下降沿触发\r\n");
    
17.                                         HAL_TIM_Base_Stop_IT(&htim2);
    
18. //                                        printf("TIM2定时器关闭\r\n");
    
19.                                   TIM2_flag = 0;
    3 N" x/ [. S2 N- @) K) z. P1 S  w
20.                                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    0 V  P5 f( N; ~* S& k) ~( B* O* b) R
21.                                         {
    * R6 e% a8 Y/ ^  E: S5 ~# \7 [
22.                                                 printf("A\r\n");
    
23.                                                 break;
    1 m0 D+ ^: Q# I# Y
24.                                         }       
    + H, m& o5 ^- X5 b3 ?! v
25.                                         else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
26.                                         {
    
27.                                                 printf("B\r\n");
    ; L/ y" |7 d" h# p6 X- U, \
28.                                                 break;
    3 Y3 _: {# ~, i  |% J
29.                                         }
    
30.                                         break;
    ! Z- p' @  S0 V) D/ v
31.                                 }
    8 F% |( e' o4 a$ R: G, m) ~
32.                         }
    2 a8 F( _4 V  A' j& x7 A' {
33.                         HAL_TIM_Base_Stop_IT(&htim2);
    
34.                         TIM2_flag = 0;
    
35.        
    
36.                        
    7 y1 o/ u1 h: M
37.                 }       
    $ [0 P5 ^' i6 }# U+ K0 i
38. }

复制代码

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


; W, Y. i: f4 l$ u0 b# w中断函数中实现
7 x$ @3 F* G/ S  p( K直接写在void EXTI15_10_IRQHandler(void)；函数中无非就是多了步在中断触发之后需要手动清除中断标志位，其他都大同小异的思路，这里就可以检测A中断触发后，然后检测B中断触发，就不会出现什么问题了。
STM32CubeMX外部中断定时器嵌套问题及实验现象
写在回调函数中的这些实验现象和问题，现在的话就都不存在了。

* |% a1 `; Z+ z2 e- y) R2 Y2 V

1. void EXTI15_10_IRQHandler(void)
   
2. {
   1 g  L8 C2 b& y5 a/ j
3.   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
   
4. 
   & d* K  ]" b; W0 `* z( q' k+ k
5.   /* USER CODE END EXTI15_10_IRQn 0 */
   
6. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
   - |! N6 z( H6 ~, H3 Q& {. ]" b, T
7. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
   6 |! ^" u% {1 C6 W" `* b, U( H' s* Z$ g. ^
8. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
   1 I  _2 `/ J" U' u
9.   /* USER CODE BEGIN EXTI15_10_IRQn 1 */
   ' c" z1 ~% T. X" f* ?
10.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_13) != RESET) //A下降沿触发
    - S) @3 v- T/ H8 L# Z; D
11.         {
    3 ]8 A* @- D+ o2 Q0 k* d
12. //                printf("A下降沿触发\r\n");
    
13.                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_13);
    ' w) Y$ A& A, g  B3 X" J
14.                
    + s) _% L! S; O! }! M. G
15.                 HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    
16.                 while(TIM2_flag <= 10)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    5 s- K5 b2 i$ _( C
17.                 {
    
18.                         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_14) != RESET)
    
19.                         {
    3 Z, D$ D; t& _7 D; E8 C$ Q6 ~. j8 c
20. //                                printf("B下降沿触发\r\n");
    / q. A$ |8 Q# F5 o; o. a, V; W7 I6 P* Y
21.                                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_14);
    
22.                                 HAL_TIM_Base_Stop_IT(&htim2);
    9 d! I* X: @7 A6 J+ Y; l3 ]
23. //                                printf("TIM2定时器关闭\r\n");
    ( O# h3 s( N- I- i
24.                                 TIM2_flag = 0;
    
25.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    ) s& w5 ?- z9 C% R- C6 [: P
26.                                 {
    1 i$ z) G! O' b; W2 N/ `, u
27.                                         printf("A\r\n");
    
28.                                         break;
    2 t, c/ Z: o/ E1 w4 r+ n
29.                                 }       
    
30.                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
      R8 U4 B) x5 r7 }( a1 W1 Q+ P! p
31.                                 {
    8 y. ]+ K- S" g: ?# I' H
32.                                         printf("B\r\n");
    
33.                                         break;
    7 {" d& P2 E' m- A6 u
34.                                 }
    
35.                                 break;
    ; x7 W5 ~* r4 l& u
36.                         }
    
37.                 }
    
38.                 HAL_TIM_Base_Stop_IT(&htim2);
    ; E6 t  b" D+ E
39.                 TIM2_flag = 0;
    
40.                
    
41.         }
    ; r0 [9 V" W5 o0 ~& [/ E2 L
42.        
    
43.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_15) != RESET)
    
44.         {
    
45.                 printf("SW按键\r\n");
    : l" M# H9 a: B, r: R" Z
46.         }
    
47. 
    
48.   /* USER CODE END EXTI15_10_IRQn 1 */
    
49. }

复制代码

& Z7 b1 B. y* ?6 n9 r


6 c9 ]0 R, T( O3 z
% E! l4 G5 E3 ^# {

通用

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

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

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

这个确实复杂了，大佬有机会做个分享

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

大佬有机会做个分享

STMCU 发表于 2020-10-29 09:12
" b/ d+ T# h, j8 i0 Q大佬有机会做个分享

我记得我以前搞过，貌似没有你这么复杂，而且程序实现也比较简单可靠，
3 q/ L* g" {: z, Z, w不需要定时器，也不需要中断，普通的 io 口就可以了
现在程序一时忘记放在哪里了，有空我找找