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

% o9 N- a, k9 F1 h3 l: U
- m0 l  ]$ [# z. R1 ]EC11旋转编码器
# l& S. k' Z3 L

- u/ }" y$ l' r2 {/ }& B' N! f

3 w5 K0 L( N0 V

2 H; L' s) H9 c( ?: [. _

/ `! G; C, \. T$ V$ A8 o* H/ C从这个数据手册中，我们可以设计出我们的思路，主要就是，以A信号作为一个时钟信号，也就是基准信号，检测到Ａ之后，再去判断B的动作，一个相对的电平。

7 n3 e$ |% L$ B; O

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

7 R/ E: \) T1 w2 {

1. ///****************旋转编码开关，版本1*****************************/
   
2. uint8_t EC11Direction(void)
   
3. {
   4 A7 N8 M' B) i5 L# P0 T
4.         while(1)
   
5.         {
   
6.                 if(A_flag == 1)//A下降沿触发外部中断，A_flag ＝　1
   8 m5 d& i6 ]! V# R( h" f
7.           {
   
8.                   if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)　//检测B信号电平
   ; K. D( ?- Z3 }8 |$ b8 B3 t6 E
9.                         {
   
10.                                 printf("正转\r\n");
    
11.                                 Direction_flag = 1;
    
12.                                 break;
    
13.                         }
    
14.                   else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    ! V- H( e4 I+ x
15.                         {
    * \: X- ^$ ?) |0 b5 Z; \
16.                                 printf("反转\r\n");
    
17.                                 Direction_flag = 2;
    
18.                                 break;
    
19.                         }         
    9 X3 o- G; i+ }4 a/ O
20.           }        
    
21.   return Direction_flag;        
    1 }7 m( r4 x  X  G* T9 M
22. 
    : @7 h( e; y# X6 L5 f$ Y: O, V  H
23. }

复制代码

% ~# h4 K4 T3 b! `( b0 X" w

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

$ K, U' T1 W7 N% M2 Z  y5 c3 k- i( o

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

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

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

软件设计流程图如下

2 {7 s5 ^1 V1 ?! L

在函数中实际代码如下

7 l1 ^7 [) [1 Z6 `& s4 X: d

1. ///****************旋转编码开关，版本2*****************************/
   
2. 返回值1 正转
   . `; }) x+ J' \' S
3. 返回值2 反转
   % }2 E8 `. o6 k' F& x
4. uint8_t EC11Direction_2(void)
   % ]/ B& J& m5 l" C
5. {
   
6.         char Direction_flag = 0;
   
7.         while(1)
   & u: n, o: d6 G, w0 \$ K
8.         {
   , S* Z9 r: A, E  u7 _+ \2 B
9.                 if(A_flag == 1)//A下降沿触发外部中断
   
10.                 {
    8 \9 F1 l- V7 d' M& D% @
11.                         HAL_Delay(1);//延时消抖
    # L4 Q+ _8 f; L4 z3 ?8 K  W
12.                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_13) == 0)//A下降沿触发1ms后判断是否稳定在了低电平
    , X: y0 B9 _& }6 R) w
13.                         {
    
14.                                 HAL_TIM_Base_Start_IT(&htim2);//开启定时器
    * u7 v, d( c; o. L4 u0 }% Y) N; I  I4 X
15.                                 while(TIM2_flag <= 10)//定时器的一个周期是1ms，这里是10ms
    : Y3 `9 D( U% g- k0 Q/ o
16.                                 {
    7 B3 O) S3 h8 ^% k% ~: n
17.                                         if(B_flag == 1)//10ms内检测是不是有B上/下降沿触发
    
18.                                         {
    
19.                                                 TIM2_flag = 0;//清除定时器中断标志位
      u4 s' l& R1 g' J, i; T
20.                                             HAL_TIM_Base_Stop_IT(&htim2);//检测到B了直接关闭定时器
    0 E' a/ a2 w$ {5 t6 D
21.                                                 HAL_Delay(1);//延时消抖
    5 @! A6 c0 s* C4 E
22.                                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)//判断Pin_14的电平，返回旋转方向
    ' o4 P% d8 d, s& ^$ X+ N8 s. T, Y
23.                                                 {
    " j2 L- |' _/ q' o. @5 ^& a  a
24. //                                                        printf("A\r\n");
    
25.                                                     Direction_flag = 1;
    4 A1 b  p' T- n3 H7 u' R
26.                                                         break;
    ; q( X2 t; R7 L4 G4 b3 \
27.                                                 }
    
28.                                                         
    * r$ N. n  |) p2 [; w: p
29.                                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
30.                                                 {
    3 i# R4 a0 }7 y; C# z; N2 ]
31. //                                                        printf("B\r\n");
    - P2 |: ^" H5 i
32.                                                         Direction_flag = 2;
    , d# g% D! f+ S3 Q. k! Q% ]" l
33.                                                         break;
    2 x7 {* h4 ?2 G0 Y5 u! u4 Y
34.                                                 }
    
35.                                         }
    
36.                                 }
    9 ]5 ]) M0 P4 E" v( ]4 V
37.                                 HAL_TIM_Base_Stop_IT(&htim2);//定时器一个周期溢出后（TIM2_flag>1），关闭
    " o0 Z/ [4 B9 }  m3 d2 d9 ]0 v
38.                                 TIM2_flag = 0;//清除定时器标志位
    2 n$ Z: g6 T+ w) Q# U* G
39.                         }
    
40.                         A_flag = 0;//清除A中断的标志位
    ! m4 X; q5 |. I1 H5 n% Q8 T9 x
41.                 }        
    
42.                
    
43.                 if(Direction_flag == 1 | Direction_flag == 2)
    3 O& L0 s0 u1 z
44.                         break;
    ' a0 P/ P( a2 J- K' w' J, \. ^
45.         }
    
46. return Direction_flag;        
    
47. 
    
48. }

复制代码

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

' K( k. A) G- u- M; ~: o% h

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
2. {
   
3. 
   ) [+ e3 x# h' C9 u6 h
4.         if (htim->Instance == TIM2)
   ' s. l  v  r  x& W8 l! p6 t
5.         {
   6 M8 H7 M3 r1 L1 U0 H
6.         HAL_IncTick();
   
7.                 TIM2_flag++;
   
8.   }
   * F4 {" U% o: }& f: U$ J- _4 p
9. 
   
10. }
    

复制代码

在tim.c文件中TIM2的配置

3 Y5 a0 G2 C2 o5 p# s& `( |9 d

% q" \( J; e! ?8 S9 E" W
TIM2的时钟输入是75MHZ，所以设置分频和计数分别为 750-1 和 100-1，这样的话一个时间周期就是1ms 频率是1000hz。
0 X  y  n5 J% [; V3 y( \- d

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

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

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

中断回调函数中实现
- Y, U, \8 h2 x4 f

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

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

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

) J, a' S0 l1 q+ R) ]

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

6 ^3 n% H* l5 F

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

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

: q  e0 G% _  M/ D4 s9 l: u2 h

; \' X9 ~3 s4 c- o$ @; t

1. 
   
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   / f) E) x+ p4 E; u: b# Q
3. {
   
4.   /* Prevent unused argument(s) compilation warning */
   
5.   UNUSED(GPIO_Pin);
   ' V( }6 I* H3 Y
6. 
   ) X4 H- M6 U2 O
7.                 if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   ( k  t" P, h; |" b7 G" Q( B
8.                 {
   
9. //                        printf("A下降沿触发\r\n");
   
10.                         HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    
11.                         B_last = HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14);//记录此状态的B状态
    % l6 n, [3 ^" b# U. e& r* S- J
12.                         while(TIM2_flag <= 60)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    
13.                         {
    
14. //                                printf("等待B的触发\r\n");
    / d! T: y) U+ R9 l" R( Z6 X
15.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) != B_last)//在20ms内，检测到电平变化
    $ ~4 \3 ], n# p- ~: W3 X7 j
16.                                 {
    
17. //                                        printf("B下降沿触发\r\n");
    
18.                                         HAL_TIM_Base_Stop_IT(&htim2);
    
19. //                                        printf("TIM2定时器关闭\r\n");
    5 r4 v3 c7 B7 E) j
20.                                   TIM2_flag = 0;
    
21.                                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    
22.                                         {
    : {0 X7 r5 p% h
23.                                                 printf("A\r\n");
    
24.                                                 break;
    
25.                                         }        
    6 \( h8 ?$ D0 u( [
26.                                         else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    # Q& N3 j9 \: B) I0 l
27.                                         {
    + Q9 y) W; s( x7 {$ [' j7 Z6 T
28.                                                 printf("B\r\n");
    " f1 X* @. K1 Y& c) F/ G2 [
29.                                                 break;
    % ^' y& g3 q4 F% ^
30.                                         }
    
31.                                         break;
    
32.                                 }
    
33.                         }
    ' s0 ^6 `  d2 [3 P
34.                         HAL_TIM_Base_Stop_IT(&htim2);
    
35.                         TIM2_flag = 0;
    
36.         
    
37.                         
    . d& A8 G% m5 v3 N4 c
38.                 }        
    
39. }

复制代码

1 E1 J7 r; A; M5 Y( V
4 q, A% }8 u' @4 U4 E( p
6 N. p9 _2 U5 A1 W# }6 z

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

中断函数中实现

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

0 v. k0 ~' t+ a2 B/ M" Y% U

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

; g) |$ E) @0 N( [# w
$ g- q4 @: j3 ~' S( h

1. void EXTI15_10_IRQHandler(void)
   
2. {
   
3.   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
   . L" F& H, f+ l3 G" {: h# t! e
4. 
   7 A) |' c6 s! J9 l, H$ c# x. N, x
5.   /* USER CODE END EXTI15_10_IRQn 0 */
   " @; B% g: i* n0 B) h
6. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
   " d, d2 C, ?% v
7. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
   $ n1 h4 @2 z$ ?, s0 k- u
8. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
   * }/ m) c& s! H' ?! a
9.   /* USER CODE BEGIN EXTI15_10_IRQn 1 */
   ; |5 r* T' a" I0 r. V; n6 ^& e
10.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_13) != RESET) //A下降沿触发
    
11.         {
    1 i5 @3 o+ m5 W" D2 r" ?8 D/ v
12. //                printf("A下降沿触发\r\n");
    9 v" p! \3 S9 v4 R. C5 P# R
13.                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_13);
    + e1 G- u  Z+ z' r" A
14.                
    
15.                 HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    
16.                 while(TIM2_flag <= 10)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    
17.                 {
    
18.                         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_14) != RESET)
    - F+ D& l) Y  k7 j: K5 a! S6 [
19.                         {
    
20. //                                printf("B下降沿触发\r\n");
    - }* |& n, o9 K  d$ x; J
21.                                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_14);
    & b: b$ J" M0 z) n: U
22.                                 HAL_TIM_Base_Stop_IT(&htim2);
    
23. //                                printf("TIM2定时器关闭\r\n");
    1 d. z  J) x& }
24.                                 TIM2_flag = 0;
    3 t" L% c- O1 _' o4 N
25.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    
26.                                 {
    . ?: H' T6 t+ b+ W) f# @) ]. @
27.                                         printf("A\r\n");
    . u7 r  e( g& _; e+ X# Q
28.                                         break;
    # f- D' ~) l% N5 \; g
29.                                 }        
    
30.                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
31.                                 {
    
32.                                         printf("B\r\n");
    5 D' M" ~: u2 }0 o2 r
33.                                         break;
    / s- ^0 P# t+ ]% Z- \# g' c. T
34.                                 }
    3 u1 i3 l2 T. b- b9 p) B* G) ^
35.                                 break;
    & ^1 n% \: L7 P, `
36.                         }
    , m7 E+ p/ i0 D5 m
37.                 }
    
38.                 HAL_TIM_Base_Stop_IT(&htim2);
    ' A& E" Q2 I. y, r5 z* f
39.                 TIM2_flag = 0;
    1 y' E$ s& n: |5 Z( q* W
40.                
    ( I9 P$ ~1 y7 ?4 [% b4 q# E
41.         }
    4 ?% O, U  b5 K; G; k% r3 x
42.         
    0 _+ V( ^$ z, u" U( [5 U
43.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_15) != RESET)
    
44.         {
    
45.                 printf("SW按键\r\n");
    1 H% E/ H1 x! I- L
46.         }
    
47. 
    5 ]' }3 M; @( M+ [
48.   /* USER CODE END EXTI15_10_IRQn 1 */
      D% U& w  ?  ?- x
49. }

复制代码

- g  ~. A* T( i- R* {
% }; T" `5 ~* E
& Z, g/ [4 _9 ?1 f& C" H; Y
6 n, _' x. l& ~4 S9 ?% ]5 Q

有几个错别字

乐天乐 发表于 2020-9-16 13:53
有几个错别字

我看看哈，那个地方啊，我来改

总觉得有点不顺口