你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

STM32CubeMX EC11旋转编码器普通IO口外部中断+定时器实现

[复制链接]
STMCU-管管 发布时间:2020-9-16 13:13
项目背景是在STM32平台上的 普通IO口PE13 PE14使用外部中断+定时器实现,这里因为设计没有选择可以支持 ENCODE MODE的端口。$ M9 a" R; z) t. d* a
, u: f3 u- T; j. w: t* G( Y

7 u; _1 }6 L0 y- a0 f, `; p$ T
EC11旋转编码器

; }0 @# m' c5 S& P$ M9 ~6 T, _5 k6 k: a$ |) n
20200916130829.65952b82dc2654750351984d50b3748e.png

- n% z- [6 Z7 X
# Z5 @$ {/ A+ O5 S  P3 w4 b& I& @6 O0 J! }
20200916130841.4b1622a2ed1a56c1b6f24e5769f81f91.png

! i0 a$ C) @1 d4 V+ C. j* x
4 r- v5 K. y7 W1 b! t2 n; w5 R1 I. e5 k; y* ^
从这个数据手册中,我们可以设计出我们的思路,主要就是,以A信号作为一个时钟信号,也就是基准信号,检测到A之后,再去判断B的动作,一个相对的电平。8 D+ d  V7 M0 @( P1 t: t; m# p


4 M; ^! K: z# `0 X- K

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

9 Y5 Y1 Z  |1 d  ?" ~* H

  1. ///****************旋转编码开关,版本1*****************************/
    6 ~  a8 t  M" w5 K- u, E
  2. uint8_t EC11Direction(void)
    8 E- `2 L* p* j
  3. {( i! o- |5 F& K" }$ T/ d
  4.         while(1)
    $ K( ~; _: s+ m
  5.         {$ R7 G) x+ X3 v7 g
  6.                 if(A_flag == 1)//A下降沿触发外部中断,A_flag = 13 R: q9 ^9 C% m3 V% k: |2 |; ^
  7.           {
      C9 r5 p5 C7 q5 e
  8.                   if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1) //检测B信号电平9 R! h, ~0 [1 {3 f7 D1 }) e4 P+ k
  9.                         {
    % k2 ?2 r( P/ i7 G! Q
  10.                                 printf("正转\r\n");; ]2 s5 f4 V9 ]5 L
  11.                                 Direction_flag = 1;8 a, ^+ f' o. o; @7 M
  12.                                 break;
      [) q! o! M0 o
  13.                         }
    ! X) E  F' U9 m0 ^* O
  14.                   else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)7 H' z* |9 _5 x: `/ A
  15.                         {; d1 P. |2 m# T1 V+ b  ]
  16.                                 printf("反转\r\n");
    0 C- d4 l, z- g' F+ N! i) h
  17.                                 Direction_flag = 2;9 r5 w6 W, |, x! M: {: C( a/ e
  18.                                 break;
    ( Y) F( H' e2 {0 J) t5 I
  19.                         }         
    , w) R( D/ k5 M  \6 Q: X7 R
  20.           }        
    ; x8 v+ i3 q! k3 T5 l4 k  h
  21.   return Direction_flag;        
    + `0 M0 J- N! A
  22. . r+ D1 H" ^- ]' r# n0 S
  23. }
复制代码
; ~: }6 O) S; j0 @4 B7 J

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

8 `2 v$ j9 W/ n/ P

中断标志位外部函数中实现
( J: @7 |" d; f1 T

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

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


. _, i. z* S( @. L4 t) {6 W9 D$ f/ f

软件设计流程图如下

. Y( r! f& H0 U" `, c. g# l- m. i

20200916130850.72f286e352a4e1e1a84420e87205ce9f.png
$ e, m7 y, J( `( }+ c+ }/ ]* J5 D
: s0 \% W# F* S7 {( X$ W! ~+ t
7 d; O9 b2 t  w0 f; O5 m& `

在函数中实际代码如下

% f8 h/ k6 w' }$ Q- d

  1. ///****************旋转编码开关,版本2*****************************/
    ; n/ W$ G3 @! M( e* g1 P0 T' O
  2. 返回值1 正转( N- \" K9 z5 G# |1 a
  3. 返回值2 反转" R9 |0 C* e; s* j; W7 S
  4. uint8_t EC11Direction_2(void). F; S7 k. Y1 e2 y1 A3 n& U
  5. {) c2 y# G  I- _* o: t, J
  6.         char Direction_flag = 0;  F; |, t+ U# V5 x9 U
  7.         while(1)
    . X. j! c: I, L
  8.         {
    - j; B4 |9 T5 R' [  \" U( i
  9.                 if(A_flag == 1)//A下降沿触发外部中断
    : @/ j9 R/ r) d1 x
  10.                 {5 y3 [% w: @, @' K, g
  11.                         HAL_Delay(1);//延时消抖
    ' F# w: C: I3 D3 h, B
  12.                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_13) == 0)//A下降沿触发1ms后判断是否稳定在了低电平% t3 `' s  Z, i4 Q
  13.                         {
    7 J6 y, j5 B9 v; L. m# J! f
  14.                                 HAL_TIM_Base_Start_IT(&htim2);//开启定时器4 b6 g& {3 _* p  }: i$ x1 }" I5 ~1 {
  15.                                 while(TIM2_flag <= 10)//定时器的一个周期是1ms,这里是10ms
    - t! j9 o! Q% I. Y' X; e- ?
  16.                                 {3 `$ M. R" B- N8 J0 F+ G
  17.                                         if(B_flag == 1)//10ms内检测是不是有B上/下降沿触发* i' Q* X' _1 [
  18.                                         {
    + |" Y4 A7 o' ?/ _3 F- U+ \( s2 E# P. Y
  19.                                                 TIM2_flag = 0;//清除定时器中断标志位
    + u2 p) r, |- ~4 c
  20.                                             HAL_TIM_Base_Stop_IT(&htim2);//检测到B了直接关闭定时器  s; L. P3 q+ [  j6 X. _, H
  21.                                                 HAL_Delay(1);//延时消抖) l; U; H4 q# \' g9 O/ J
  22.                                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)//判断Pin_14的电平,返回旋转方向
    5 A! a: \% X8 d$ \. X3 I4 U
  23.                                                 {9 J9 K7 w8 a7 J" g8 ?. d) u2 X5 W
  24. //                                                        printf("A\r\n");6 [6 V7 J8 |, ~$ y2 {
  25.                                                     Direction_flag = 1;8 |! P& h% W( S) `7 `1 ~/ ]
  26.                                                         break;
    5 w) ~" {' f7 c" W' s: k. D) \
  27.                                                 }; Z9 E. j7 f% e; h
  28.                                                         
      b/ s% A2 X3 p  q* R, Z3 I* A
  29.                                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)" l1 ~4 z( T. d
  30.                                                 {
    8 u" Z! K) _# K) o( y( A6 b
  31. //                                                        printf("B\r\n");
    - r! G1 j' R' [( N" X6 R6 n
  32.                                                         Direction_flag = 2;6 Q' |# R, E1 O% m
  33.                                                         break;, f* C5 w* N8 b: q6 ~
  34.                                                 }( ^' P3 {' i# r, m$ d5 @; e, r
  35.                                         }
      X* T" o3 y0 ?9 j; p. x3 P
  36.                                 }
    * ~+ @9 C2 w& ]( S# }
  37.                                 HAL_TIM_Base_Stop_IT(&htim2);//定时器一个周期溢出后(TIM2_flag>1),关闭
    + j/ f+ e3 i, C
  38.                                 TIM2_flag = 0;//清除定时器标志位1 p! O! w. q) Q9 s+ Q5 e& S: \
  39.                         }
    : f( W3 j" m8 c$ j
  40.                         A_flag = 0;//清除A中断的标志位7 L& [( t2 f- G3 J5 l+ h
  41.                 }        2 Z+ @" M! n9 H% l  o/ v$ C
  42.                
    ; D/ i! {3 P) X/ l
  43.                 if(Direction_flag == 1 | Direction_flag == 2)
    : x6 O  |2 s6 k6 g
  44.                         break;
    ! H$ Z9 d" {" W% D) ?1 h" {( Z
  45.         }
    " w  X. |9 x& \5 m$ ?
  46. return Direction_flag;        ' T5 @. g1 E5 @  A% X

  47. ; Q" g& o4 U8 C) G. _: [; J9 Y
  48. }
复制代码

2 J9 _- o4 L$ c+ B" M2 s) r

6 h+ p( A/ ]" d. A* Z: T3 D" |( a

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

% u9 |' J; D& }# I

6 q. d: f5 b0 T& K) [4 g3 _  K
  1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)5 |7 U* l# i" |$ \- @
  2. {
    : B, M8 \: T+ R( w4 f
  3. 9 _$ _/ B% n. ^" {# g
  4.         if (htim->Instance == TIM2) + P/ D4 B: C( N, o9 @( t# J
  5.         {0 z; }: D7 p' |8 ^- z( |
  6.         HAL_IncTick();5 v) G+ x8 a5 o; i* Q
  7.                 TIM2_flag++;
    5 T6 m+ p# i2 @  i. P
  8.   }5 g& B+ _3 H' j2 e' t

  9. % f& ]) Z( c! I8 P1 z# G6 Q
  10. }% `5 I/ x1 T! e4 ?6 Z
复制代码
: c. q) `1 Q9 _' U0 ]! j

在tim.c文件中TIM2的配置

7 t4 e+ @" {9 K

20200916130859.97b950058a7e3e9f7f324a32a8401021.png

; K4 T# {; g. }4 U6 |6 `1 `' j* V* h
TIM2的时钟输入是75MHZ,所以设置分频和计数分别为 750-1 和 100-1,这样的话一个时间周期就是1ms 频率是1000hz。
% e9 L) \5 H4 Y; S/ |& [

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


% w1 m( \, S) @% d) U) N" k

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

! y6 l/ m, n, J

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


0 M0 [, g! j4 q% N+ q

中断回调函数中实现
( B* e' s4 S( \% [: L/ h) l

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

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


( w3 A$ v9 ~7 g* s. ^1 C

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


2 ~( \5 L( t2 A0 q5 E2 X  y, S

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

2 h1 U1 k4 i0 Y1 w
2 y' o: J2 G+ A- X6 c: a% u( @1 l

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

回调函数中想要实现,可以采用这个方法
6 w* r6 I+ t4 V3 M" J

20200916130916.bd9c04b99b78d32d531ca96e46870abb.png
* a  g6 u. t8 D: x2 X9 D; {
- c: T- r" x4 v1 V2 t  U
) v# f" {3 W! W* u: r' @, q2 n7 H

# [4 @6 i2 A* `
  1. ' n3 `4 o+ d8 ]% F  ]/ J; q
  2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin), w& |$ j2 a. V6 H- Y
  3. {
    % O2 u+ g7 j$ y0 C- l9 `0 N
  4.   /* Prevent unused argument(s) compilation warning */; f# _* ]& ^5 o, n. N
  5.   UNUSED(GPIO_Pin);% X7 E3 I1 }( g/ W- e
  6. 7 {3 P2 w) i# S
  7.                 if(GPIO_Pin == A_Pin)//A下降沿触发外部中断& y5 [6 u. ~1 M: k
  8.                 {
    4 c( e  K; W( Y9 v# K: B
  9. //                        printf("A下降沿触发\r\n");" l9 l4 w1 t4 r* F  T$ n
  10.                         HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    6 b" F( Q# N9 D; Z& F% s
  11.                         B_last = HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14);//记录此状态的B状态' Q/ N. f5 y% K/ L+ u) ?$ A4 I  A
  12.                         while(TIM2_flag <= 60)//定时器一个周期1ms,计时20ms内看看B有没有电跳变
    4 a& _6 Q7 H1 k& O4 B
  13.                         {2 u- @7 T  c, E$ V- `
  14. //                                printf("等待B的触发\r\n");
    . G7 v( I& a! q1 w* H
  15.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) != B_last)//在20ms内,检测到电平变化$ g7 F# z% l$ N" ?& l% M1 i4 u$ u
  16.                                 {
    ' X, m2 l7 Z+ g
  17. //                                        printf("B下降沿触发\r\n");& e9 s' ]' o* f
  18.                                         HAL_TIM_Base_Stop_IT(&htim2);
    . U' N' F) T, T7 Z+ Q; m
  19. //                                        printf("TIM2定时器关闭\r\n");
    - U2 Q- s8 _; m/ o! c
  20.                                   TIM2_flag = 0;
    0 e" X$ P8 I, ^
  21.                                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)1 g; F+ f# @4 k5 v/ L% Q7 e2 U
  22.                                         {
    2 }  i* a' s& X) e
  23.                                                 printf("A\r\n");3 W, ]6 a) Q5 B) D+ \
  24.                                                 break;
    2 H8 x: R* o# q  X2 E+ c5 t; G
  25.                                         }        
    : r' Z" }& F/ @, D* p' q+ o7 }' U6 F: \/ \
  26.                                         else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)2 Q* |/ k/ B$ S
  27.                                         {
    7 d! U; j+ Q/ Z, h5 F# _
  28.                                                 printf("B\r\n");: W$ O: O- S$ Z' V6 x1 u3 c
  29.                                                 break;
    0 z9 a8 P# }& Z* S( f% @! ~
  30.                                         }& I' U$ C: Y/ O7 }
  31.                                         break;
    . \" @& L0 U2 ~# X/ e8 q
  32.                                 }
    $ j4 @& |- e4 x  W! A
  33.                         }
    5 K3 |8 M# ?: R: u
  34.                         HAL_TIM_Base_Stop_IT(&htim2);2 i: r1 m- w: c! R0 E( Z
  35.                         TIM2_flag = 0;7 c! x( m0 s& N: J4 h/ |. U8 [4 s
  36.         
    5 A$ r& c4 L, N) p4 T; \5 r. \
  37.                         
    2 k8 F/ T% W# V  F' s+ t. w! w
  38.                 }        
    - r5 v3 U6 ^9 v5 m( L
  39. }
复制代码
- P. l- c( J. [6 O

9 a  D0 l: @: M/ u6 ?# G. V& d1 G3 v  k' _0 Z+ x+ `) c6 F3 T

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

. h2 j4 y# K6 k- A1 T1 r

中断函数中实现
& T0 @5 ]& A2 \) G

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

! `7 q- o: q2 {

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


  B1 v& z4 C7 |2 P# {& Z2 d3 n+ P+ ?& k1 q7 I4 u/ g+ L" K  z
  1. void EXTI15_10_IRQHandler(void)
    , N- t$ n; U' p' Y( M
  2. {
    ' K% X, S3 c+ P
  3.   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
      e/ ^1 L- G4 ?

  4. , l8 a, x0 S4 Q1 C
  5.   /* USER CODE END EXTI15_10_IRQn 0 */
    ) S! t+ S  I8 y& g0 O, ^4 M
  6. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);* B& t/ @( a9 L$ b
  7. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);) a& q% B, d0 e* ^6 q  O
  8. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
    5 V" g. M# N) z
  9.   /* USER CODE BEGIN EXTI15_10_IRQn 1 */7 F! j$ Z  W: Y  l, g  u
  10.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_13) != RESET) //A下降沿触发
    . L5 w8 x/ M0 o% Z" w8 {# u8 q( O6 U
  11.         {6 e! J$ @' B6 g! |& @) l9 s% \/ P
  12. //                printf("A下降沿触发\r\n");
    $ p4 a7 o  K: Q7 f
  13.                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_13);
    1 w& a7 M  F8 q* u9 J' B  O
  14.                
    , Y7 ^. j+ o  Y0 N# C
  15.                 HAL_TIM_Base_Start_IT(&htim2);//开始TIM2定时器
    . H( @7 J5 u6 Y0 h: b1 G, |6 u  E
  16.                 while(TIM2_flag <= 10)//定时器一个周期1ms,计时20ms内看看B有没有电跳变, D# n+ S6 g5 l, V( L" F5 ~6 J
  17.                 {' W3 u  }' P7 F2 O
  18.                         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_14) != RESET)
    # n' |( S0 `5 w, c
  19.                         {
    ) Q$ }5 q0 @2 i0 r* E
  20. //                                printf("B下降沿触发\r\n");. V% D! x+ i0 O8 z0 `! `, _, x
  21.                                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_14);0 j: @2 G% N+ @9 |6 x' ~
  22.                                 HAL_TIM_Base_Stop_IT(&htim2);% ~' G( w2 ~) S* g5 ~) @
  23. //                                printf("TIM2定时器关闭\r\n");
    7 U5 T  ^! ]+ q; k" q/ h; J
  24.                                 TIM2_flag = 0;
    ; }7 ]+ R( |' s& z% m) ^
  25.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    3 r0 u! `: n% |
  26.                                 {
    ! I3 a6 F; t6 o( L
  27.                                         printf("A\r\n");5 ?8 ?0 d- \# w$ \3 h. d1 `* J, A
  28.                                         break;8 }+ {3 J9 z9 s) g
  29.                                 }        5 e! t" g/ \& c
  30.                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0); {, F! Y( h9 u3 f5 x. N
  31.                                 {
    6 N3 p* d' M5 H1 Y
  32.                                         printf("B\r\n");
    7 H1 r4 I0 I; i  i# _# T
  33.                                         break;2 i: |& Y" }( ]2 x; g9 @
  34.                                 }
    % }% C7 o$ U" |5 R0 b; q* `- ~
  35.                                 break;8 Y, m6 ]; L% \4 O; Y. J2 l
  36.                         }$ r: B! z: a) f5 u
  37.                 }
    ! Q+ x1 [5 k; J6 s# d* m  b
  38.                 HAL_TIM_Base_Stop_IT(&htim2);
    ' b# ^% _5 T( o
  39.                 TIM2_flag = 0;5 ^7 W* t( Y2 P
  40.                 8 j1 {# |4 h3 g4 s) j
  41.         }
    % U2 W* v4 P) R8 S
  42.         
    2 \0 O# E# ^7 K2 W& J0 k: \
  43.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_15) != RESET)" I# c6 r: C# _1 A8 |
  44.         {
      v: h( N6 k- c2 U
  45.                 printf("SW按键\r\n");0 i. F+ a  R& j' t
  46.         }9 q4 u5 Y; Z; A

  47. " a* R) @# R- T$ F6 G
  48.   /* USER CODE END EXTI15_10_IRQn 1 */0 M! S# \' c* r: n$ G8 _
  49. }
复制代码
4 v' I9 x, t2 H

& d; R- {+ U9 F, C# U8 U$ ~1 o# R+ R2 C3 I
! U7 G& v9 R  p! s" `8 P7 y
赞 收藏 评论3 发布时间:2020-9-16 13:13

举报

3个回答
goyhuan 回答时间:2020-9-16 13:53:43
有几个错别字
STMCU-管管 回答时间:2020-9-16 16:09:22
乐天乐 发表于 2020-9-16 13:53- ^  p7 Z+ ?6 g6 d( N1 C
有几个错别字
' u+ S( r0 K; U; d5 z, ~
我看看哈,那个地方啊,我来改
goyhuan 回答时间:2020-9-16 16:51:56
总觉得有点不顺口
e2.jpg
e1.jpg

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版