项目背景是在STM32平台上的 普通IO口PE13 PE14使用外部中断+定时器实现，这里因为设计没有选择可以支持 ENCODE MODE的端口。


# N) h/ X( z7 i, [# v: dEC11旋转编码器
0 L/ G5 {( u; o: G9 u8 D

/ C; C; `+ g& O: s; x+ |
0 l' y2 G3 @- Y' _' y/ u

' Y9 I% m  ^4 i! E# S; t* |
& v, O1 i6 M. @6 d% D) ?% k
* f' g+ C( T' d  x9 n: z从这个数据手册中，我们可以设计出我们的思路，主要就是，以A信号作为一个时钟信号，也就是基准信号，检测到Ａ之后，再去判断B的动作，一个相对的电平。

例如，当检测到A信号下降沿触发，检测B信号此时如果是高电平，那就是逆时针，如果是低电平，那就是顺时针。

( H/ N* c  R6 R6 I, D9 s" A

1. ///****************旋转编码开关，版本1*****************************/
   * E# ?) `8 V+ U, Y
2. uint8_t EC11Direction(void)
   
3. {
   
4.         while(1)
   0 O* b2 J) Q3 z3 K  u
5.         {
   
6.                 if(A_flag == 1)//A下降沿触发外部中断，A_flag ＝　1
   
7.           {
   & N0 U* B4 C' \
8.                   if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)　//检测B信号电平
   
9.                         {
   # f! K, X+ q7 o" r9 f& O; a
10.                                 printf("正转\r\n");
    
11.                                 Direction_flag = 1;
    
12.                                 break;
    ( M" U  x  v0 B6 ?& A
13.                         }
    
14.                   else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
15.                         {
    3 {% ^, Z& H% U1 |
16.                                 printf("反转\r\n");
    * \( P  y( Y1 |, M0 D( c1 k2 c
17.                                 Direction_flag = 2;
    
18.                                 break;
    
19.                         }         
    : i" U; M* x& @- X0 R
20.           }        
    6 D6 t3 _, u! s) Q- i7 z+ P8 [
21.   return Direction_flag;        
    9 ?; U  H2 W3 W4 O2 Y& h8 w
22. 
    
23. }

复制代码

$ M6 o* b5 \. R9 c& z

这个是最简单的判断方法，这个方法不是特别完善，容易出现干扰和误判断现象。不过整体是思路是这样走的。

4 m- L! b; N- J

中断标志位外部函数中实现

第一个实现版本，因为起初对于中断的不熟悉，没有直接在中断中直接写，而是只使用了中断产生的标注为来作为判断。

这个的设计思路主要是，A信号中断，消抖，确定A信号下降沿触发，打开定时器，10ms检测B信号是否上/下降沿触发，关闭定时器，判断B信号的电平高低。

! a+ t/ }" b5 ?8 W" S) H

软件设计流程图如下

% y+ o8 w+ z+ R" `" `8 O1 N3 A

在函数中实际代码如下

+ j# s! U" {! Z2 A' ~# p

1. ///****************旋转编码开关，版本2*****************************/
   0 C- i% s- U; b: u  n3 d+ t
2. 返回值1 正转
   
3. 返回值2 反转
   
4. uint8_t EC11Direction_2(void)
   : ?, Q% o9 V( t! ?- N
5. {
   3 \. K0 p, N9 n0 W
6.         char Direction_flag = 0;
   
7.         while(1)
   . a- p; q. Z# W2 l# h; F& |
8.         {
   
9.                 if(A_flag == 1)//A下降沿触发外部中断
   
10.                 {
    5 R: u" X- D" N6 T0 u
11.                         HAL_Delay(1);//延时消抖
    5 M" R6 m+ ~! ~8 c! c4 E& H: p
12.                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_13) == 0)//A下降沿触发1ms后判断是否稳定在了低电平
    ; a: i" Z$ c$ ]6 D( t  Z
13.                         {
    
14.                                 HAL_TIM_Base_Start_IT(&htim2);//开启定时器
    
15.                                 while(TIM2_flag <= 10)//定时器的一个周期是1ms，这里是10ms
    
16.                                 {
    
17.                                         if(B_flag == 1)//10ms内检测是不是有B上/下降沿触发
    9 C+ R0 f2 g: o
18.                                         {
    3 M5 T" r6 w' o3 X, _4 Y- O
19.                                                 TIM2_flag = 0;//清除定时器中断标志位
    2 ~( T8 x3 l) \/ d6 G  P8 ~5 Y
20.                                             HAL_TIM_Base_Stop_IT(&htim2);//检测到B了直接关闭定时器
    8 W3 P/ Q( c- ]% A# @4 z  P
21.                                                 HAL_Delay(1);//延时消抖
    
22.                                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)//判断Pin_14的电平，返回旋转方向
    
23.                                                 {
    $ g! d# z. X' u7 T2 x/ [
24. //                                                        printf("A\r\n");
    
25.                                                     Direction_flag = 1;
    3 f4 P  q  {- k; J5 d
26.                                                         break;
    
27.                                                 }
    6 q1 ?# ]+ |+ r
28.                                                         
    3 p; z6 V7 x3 v, \% r9 G8 }
29.                                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
30.                                                 {
    # d" E  H  S  R
31. //                                                        printf("B\r\n");
    , H7 w9 |: M5 E( x4 S8 r: P
32.                                                         Direction_flag = 2;
    ; V2 r& _, b3 D* s$ S8 ~
33.                                                         break;
    
34.                                                 }
    ) O. c& l+ k" B5 g
35.                                         }
    0 E; X) C7 V3 a$ u, X
36.                                 }
    : @$ X1 f- ?) u: G5 C, g
37.                                 HAL_TIM_Base_Stop_IT(&htim2);//定时器一个周期溢出后（TIM2_flag>1），关闭
    
38.                                 TIM2_flag = 0;//清除定时器标志位
    , Q' i0 d' {. ?
39.                         }
    , @9 D" E, d% [) w' R
40.                         A_flag = 0;//清除A中断的标志位
    
41.                 }        
    + C' \8 t/ {: z- T- B0 Y
42.                
    . l* P  I* O; A- o& [8 [, N+ m
43.                 if(Direction_flag == 1 | Direction_flag == 2)
    
44.                         break;
    : {- B% @/ _2 a- G7 i
45.         }
    
46. return Direction_flag;        
    $ P7 Y) |; D" b
47. 
    " g8 z5 F( C  ~
48. }

复制代码

4 t: Y2 P. s9 U1 _: X

在main.c中的定时器的标志位设置，使用了TIM2定时器，溢出就+1

8 p. ?) G! Y  p( D; k; {0 I

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   4 H1 m0 {" o) V4 w8 Q6 Q
2. {
   6 Q) E" C* o6 Q7 j; V0 D- T
3. 
   + n- ^( I7 u" Y
4.         if (htim->Instance == TIM2)
   
5.         {
   
6.         HAL_IncTick();
   
7.                 TIM2_flag++;
   2 j( U! c& Z! u0 r1 W9 \  t% c0 Q
8.   }
   
9. 
   
10. }
    

复制代码

1 U1 `# Y2 `. ?, U

在tim.c文件中TIM2的配置

( p/ N( k2 w+ ~/ o7 DTIM2的时钟输入是75MHZ，所以设置分频和计数分别为 750-1 和 100-1，这样的话一个时间周期就是1ms 频率是1000hz。

在stm32f4xx_hal_gpio.c文件中，我们找到外部中断对应的回调函数HAL_GPIO_EXTI_Callback，直接判断到外部电平触发后返回标志位就可以了。

, C  ]( R# f: J5 @; ^( I

这样写，虽然可以实现对于旋转编码器的检测，但是有一个问题，没有办法很方便的运用到实际工程中，以为进入到这个函数后才能进行编码器的判断，显然我们的编码器要实现的是一个翻页的功能，触发就要有操作的，而不是等着。

虽然可以设计进去超时函数让编码器跳出，但是还是没有办法实现实际项目的需要。于是准备直接写到中断回调函数中。

, {$ @  u, G$ o( T" G

中断回调函数中实现

按理说直接写到中断回调函数应该挺容易的，直接改就行了 ，逻辑反正是通的，但是遇到了几个问题，一个是延时消抖的问题。

HAL_Delay本质也是一个中断服务函数，这种延时函数中断的嵌套是非常危险的操作，很容易卡死程序，比较有隐患，所以HAL_Delay函数是不能用了。

% i1 q0 y+ P! g2 @

同时，因为回调函数是这样来使用的void EXTI15_10_IRQHandler(void)中检测到外部中断， 调用HAL_GPIO_EXTI_IRQHandler(GPIO_PIN);函数，然后再调用里面的回调函数void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)。

4 }* @/ x. m8 s. l, E

我们这个里面用到了两个外部中断，PE13 和 PE14，也就是都会使用同一个回调函数，也就是无法完成这种操作

. p# L) @) l0 q/ Q" k5 d

这里就是举了个例子，因为回调函数的调用逻辑，没有办法在检测了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);函数中，这个也就是我后面的一个方法。

回调函数中想要实现，可以采用这个方法

. a8 U& M* s) F) Q. _
  E* w4 e& G( v( {5 J

( t7 ]% [7 w1 X# ]* p

1. 
   2 X1 e5 K/ q0 ]( c$ @
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
3. {
   
4.   /* Prevent unused argument(s) compilation warning */
   
5.   UNUSED(GPIO_Pin);
   
6. 
   6 j) z2 k1 C! M5 @- @
7.                 if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   
8.                 {
   2 h& e) r4 Q) W7 T- S
9. //                        printf("A下降沿触发\r\n");
   
10.                         HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    * Q6 G6 j4 o6 T+ R' O* Z! ]
11.                         B_last = HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14);//记录此状态的B状态
    . P% Y$ x+ k/ [) M) M# s, Z, ~6 X
12.                         while(TIM2_flag <= 60)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    * l9 S/ G4 O7 T$ X: `3 k' L
13.                         {
    
14. //                                printf("等待B的触发\r\n");
    
15.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) != B_last)//在20ms内，检测到电平变化
    
16.                                 {
    # W. M' H$ l% ]8 o- j
17. //                                        printf("B下降沿触发\r\n");
    
18.                                         HAL_TIM_Base_Stop_IT(&htim2);
    
19. //                                        printf("TIM2定时器关闭\r\n");
    
20.                                   TIM2_flag = 0;
    9 @9 S# U" X% i& w+ k( J
21.                                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    
22.                                         {
    # o" D# C: h- O+ \
23.                                                 printf("A\r\n");
    
24.                                                 break;
    
25.                                         }        
    / Y5 O( ]5 p1 H- h: e; A% j, Q
26.                                         else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
27.                                         {
    
28.                                                 printf("B\r\n");
    2 q, P' _0 L: p$ }
29.                                                 break;
    
30.                                         }
    3 c" m  ~; [: J3 E! z" I3 l
31.                                         break;
    ( F, w& a! J0 r% A
32.                                 }
    
33.                         }
    
34.                         HAL_TIM_Base_Stop_IT(&htim2);
    ( b/ Y! |" O5 z0 A
35.                         TIM2_flag = 0;
    
36.         
      N/ ]5 S" r/ [  Q9 j
37.                         
    $ W6 u; o( u* H9 q! a6 ^7 ?
38.                 }        
    7 ]& d  q% j) F4 b
39. }

复制代码

; ]) B2 ~# J- \4 G3 L3 j* o

7 m2 e" e) s; C2 B

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

6 Z- z% u9 n1 o" C6 h+ X: x

中断函数中实现

直接写在void EXTI15_10_IRQHandler(void)；函数中无非就是多了步在中断触发之后需要手动清除中断标志位，其他都大同小异的思路，这里就可以检测A中断触发后，然后检测B中断触发，就不会出现什么问题了。

- i. p  G, S& i/ u8 J/ x

写在回调函数中的这些实验现象和问题，现在的话就都不存在了。

; ^$ A+ I( u) u% [7 L' }9 G
, T% ?/ i% Z8 S5 _9 ?, x/ ^$ s

1. void EXTI15_10_IRQHandler(void)
   
2. {
   4 T/ |) F" j5 E5 t6 O/ e6 s
3.   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
   
4. 
   
5.   /* USER CODE END EXTI15_10_IRQn 0 */
   
6. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
   
7. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
     N1 a# h2 \. l  R! o1 s3 |
8. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
   ) W  `1 k! d6 q2 q4 M
9.   /* USER CODE BEGIN EXTI15_10_IRQn 1 */
   
10.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_13) != RESET) //A下降沿触发
    / Z0 @  H/ D8 v
11.         {
    
12. //                printf("A下降沿触发\r\n");
    
13.                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_13);
    
14.                
    
15.                 HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    ) z, w: {, z4 @: I2 `: M4 ~
16.                 while(TIM2_flag <= 10)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    
17.                 {
    
18.                         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_14) != RESET)
    
19.                         {
    
20. //                                printf("B下降沿触发\r\n");
    
21.                                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_14);
    * R! S' o3 _$ @. t
22.                                 HAL_TIM_Base_Stop_IT(&htim2);
      [' Z7 P. S2 B7 x6 z" C; G
23. //                                printf("TIM2定时器关闭\r\n");
    
24.                                 TIM2_flag = 0;
    
25.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    * b6 T; |4 K1 \" v
26.                                 {
    
27.                                         printf("A\r\n");
    
28.                                         break;
    
29.                                 }        
    
30.                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
31.                                 {
    7 u! @3 R) N, \
32.                                         printf("B\r\n");
    : Y; }/ Q2 N( D8 x  f. ]7 c: I+ c
33.                                         break;
    . o# ?# f0 P& M3 {
34.                                 }
    
35.                                 break;
    
36.                         }
    
37.                 }
    
38.                 HAL_TIM_Base_Stop_IT(&htim2);
    1 r2 B. [# O" e5 c
39.                 TIM2_flag = 0;
    
40.                
    
41.         }
    # y0 @1 H# k# A( n- s& T0 J9 l9 E
42.         
    & B4 Z: p8 N7 R2 x6 c
43.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_15) != RESET)
    ; B: M$ P% W) t7 A
44.         {
    
45.                 printf("SW按键\r\n");
    % `0 A# i' k+ u8 D8 i# Z
46.         }
    
47. 
    * B! N2 h) c9 B! O
48.   /* USER CODE END EXTI15_10_IRQn 1 */
    
49. }

复制代码

( J  r( ^2 r' C6 G) M6 R
1 Q- K2 m+ ?! P
+ O# S2 A9 j* x, l' [

有几个错别字

乐天乐 发表于 2020-9-16 13:53
0 a$ z2 P/ H$ t+ u/ Z% C$ G! o有几个错别字

4 X, q+ Q7 E9 Z* n8 G2 x我看看哈，那个地方啊，我来改

总觉得有点不顺口