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


EC11旋转编码器

从这个数据手册中，我们可以设计出我们的思路，主要就是，以A信号作为一个时钟信号，也就是基准信号，检测到Ａ之后，再去判断B的动作，一个相对的电平。

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

1. ///****************旋转编码开关，版本1*****************************/
   
2. uint8_t EC11Direction(void)
   
3. {
   
4.         while(1)
   
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");
    
11.                                 Direction_flag = 1;
    
12.                                 break;
    
13.                         }
    
14.                   else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
15.                         {
    
16.                                 printf("反转\r\n");
    
17.                                 Direction_flag = 2;
    
18.                                 break;
    
19.                         }         
    
20.           }        
    
21.   return Direction_flag;        
    
22. 
    
23. }

复制代码

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

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

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

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

软件设计流程图如下

在函数中实际代码如下

1. ///****************旋转编码开关，版本2*****************************/
   
2. 返回值1 正转
   
3. 返回值2 反转
   
4. uint8_t EC11Direction_2(void)
   
5. {
   
6.         char Direction_flag = 0;
   
7.         while(1)
   
8.         {
   
9.                 if(A_flag == 1)//A下降沿触发外部中断
   
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);//开启定时器
    
15.                                 while(TIM2_flag <= 10)//定时器的一个周期是1ms，这里是10ms
    
16.                                 {
    
17.                                         if(B_flag == 1)//10ms内检测是不是有B上/下降沿触发
    
18.                                         {
    
19.                                                 TIM2_flag = 0;//清除定时器中断标志位
    
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");
    
25.                                                     Direction_flag = 1;
    
26.                                                         break;
    
27.                                                 }
    
28.                                                         
    
29.                                                 else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
30.                                                 {
    
31. //                                                        printf("B\r\n");
    
32.                                                         Direction_flag = 2;
    
33.                                                         break;
    
34.                                                 }
    
35.                                         }
    
36.                                 }
    
37.                                 HAL_TIM_Base_Stop_IT(&htim2);//定时器一个周期溢出后（TIM2_flag>1），关闭
    
38.                                 TIM2_flag = 0;//清除定时器标志位
    
39.                         }
    
40.                         A_flag = 0;//清除A中断的标志位
    
41.                 }        
    
42.                
    
43.                 if(Direction_flag == 1 | Direction_flag == 2)
    
44.                         break;
    
45.         }
    
46. return Direction_flag;        
    
47. 
    
48. }

复制代码

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

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
2. {
   
3. 
   
4.         if (htim->Instance == TIM2)
   
5.         {
   
6.         HAL_IncTick();
   
7.                 TIM2_flag++;
   
8.   }
   
9. 
   
10. }
    

复制代码

在tim.c文件中TIM2的配置

TIM2的时钟输入是75MHZ，所以设置分频和计数分别为 750-1 和 100-1，这样的话一个时间周期就是1ms 频率是1000hz。

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

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

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

中断回调函数中实现

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

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，也就是都会使用同一个回调函数，也就是无法完成这种操作

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

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

1. 
   
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
3. {
   
4.   /* Prevent unused argument(s) compilation warning */
   
5.   UNUSED(GPIO_Pin);
   
6. 
   
7.                 if(GPIO_Pin == A_Pin)//A下降沿触发外部中断
   
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状态
    
12.                         while(TIM2_flag <= 60)//定时器一个周期1ms，计时20ms内看看B有没有电跳变
    
13.                         {
    
14. //                                printf("等待B的触发\r\n");
    
15.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) != B_last)//在20ms内，检测到电平变化
    
16.                                 {
    
17. //                                        printf("B下降沿触发\r\n");
    
18.                                         HAL_TIM_Base_Stop_IT(&htim2);
    
19. //                                        printf("TIM2定时器关闭\r\n");
    
20.                                   TIM2_flag = 0;
    
21.                                         if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    
22.                                         {
    
23.                                                 printf("A\r\n");
    
24.                                                 break;
    
25.                                         }        
    
26.                                         else if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 0)
    
27.                                         {
    
28.                                                 printf("B\r\n");
    
29.                                                 break;
    
30.                                         }
    
31.                                         break;
    
32.                                 }
    
33.                         }
    
34.                         HAL_TIM_Base_Stop_IT(&htim2);
    
35.                         TIM2_flag = 0;
    
36.         
    
37.                         
    
38.                 }        
    
39. }

复制代码

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

中断函数中实现

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

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

1. void EXTI15_10_IRQHandler(void)
   
2. {
   
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);
   
8. //  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
   
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.                
    
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)
    
19.                         {
    
20. //                                printf("B下降沿触发\r\n");
    
21.                                 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_14);
    
22.                                 HAL_TIM_Base_Stop_IT(&htim2);
    
23. //                                printf("TIM2定时器关闭\r\n");
    
24.                                 TIM2_flag = 0;
    
25.                                 if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_14) == 1)
    
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");
    
33.                                         break;
    
34.                                 }
    
35.                                 break;
    
36.                         }
    
37.                 }
    
38.                 HAL_TIM_Base_Stop_IT(&htim2);
    
39.                 TIM2_flag = 0;
    
40.                
    
41.         }
    
42.         
    
43.         if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_15) != RESET)
    
44.         {
    
45.                 printf("SW按键\r\n");
    
46.         }
    
47. 
    
48.   /* USER CODE END EXTI15_10_IRQn 1 */
    
49. }

复制代码

有几个错别字

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

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

总觉得有点不顺口