概述
这篇文章是对刚刚学习单片机的小伙伴们，提的一些处理技巧思维。（我在项目上经常使用这样的处理思路）

现在举个栗子，应用场景是这样的，比如：在while(1)中在处理一些裸机，然后碰巧又在延时时候，当你又有其他事件（这个事件是外部触发而来的）比较紧急要处理这个事件时，这时候，CUP肯定是处理不来，需要等待while(1)处理完延时之后，才能处理这个比较紧急的事件，这时候，可能有人会说，你干嘛不在外部中断去处理这个事件呢，但是如果这个事件刚好也要延时呢？怎么办，一般好的程序不会在中断函数里面使用过多的延时，还有很多逻辑的事件，这时候就要换一种处理思维了。哈哈，想必大家也会想到它，那就是定时器，如果这时候使用定时器的话，问题肯定能处理的比在while(1)的大循环干等待延时要强的多，完美的组合就是，要中断与定时器搭配来使用才行，这样的处理事件就不会因为延时逻辑过长导致其它事件处理不及时的问题。（废话有点多，请谅解）
& ^, B) G( d0 E1 J* \& x
1、打个比方：我的项目上有关机功能

/ C: T( W; x' T$ o0 d% m8 n2、首先配置一个单独的定时器（我这里配置的是 基本定时器6，注意：如果Tim不够用的话，可以使用SysTick_Handler/滴答定时器代替，使用方法同理。）
& Z$ S' f$ ?+ [& P( U( q2 l& D
2 l  e  ]0 V' m/ r. Q" W/ c
! \4 z' b  Y' h& R9 S3、该定时专门处理这个关机逻辑的，这时根据自己的需求修改定时器的频率

tim.c 文件

1. <font face="微软雅黑" size="3">/* USER CODE BEGIN 0 */
   6 ^; k0 J7 L1 N1 N' \8 n" t
2. #include "adc.h"
   
3. 
   / ^& Z6 V% }, x2 E
4. extern void Power_OFF(void);
   ' z. Q+ ^, L. P* m3 J
5. /* USER CODE END 0 */
   ; ?5 W3 a2 ~5 c8 _- G9 M
6. .
     Y$ d; a8 {' @; l3 @
7. .
   * u- D; y1 }  e8 F/ T( h" a
8. .
   
9. 
   1 }+ _; v  a1 e' n
10. /* USER CODE BEGIN 1 */
    
11. 
    
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
13. {
    
14.         if(htim->Instance == TIM2)
    
15.         {
    / |  d8 a9 ?. i9 O
16.                 #ifdef TIMER_SAMPLING_MODE
    % u3 o' J8 t. \1 t$ G3 m
17.                         get_ADC_Channel_Val();
    
18.                 #endif
    
19.         }
    ! A! d" v+ @$ v/ k( t" N+ n1 n
20.         else if(htim->Instance == TIM6)
    ) A8 j4 ?1 H' O, M% H& u, t& K- n6 d
21.         {
    
22.                 //编写回调逻辑，即定时器6定时1000us后的逻辑 1ms=1次
    9 K9 e* I! N* [& z* q) T
23.                 Power_OFF();
    1 _# X$ ?( l% c8 P! B  u
24.         }
    " ^; L- N) r* A$ f
25. }
    
26. 
    
27. /* USER CODE END 1 */
    
28. </font>

复制代码

Power_OFF（）函数：
! D+ P, K. y8 s3 w6 D

1. <font face="微软雅黑" size="3">
   - S7 `1 n  u. W/ K
2. void Power_ON(void)
   1 i: _) Z9 U( ~1 o8 T
3. {
   
4.         uint32_t tickstart = HAL_GetTick();
   
5.         while(1)
   
6.         {
   7 z) d7 f5 y* O5 |% N9 o
7.                 //读Power_on是否是高电平
   
8.                 if(HAL_GPIO_ReadPin(POWER_OFF_GPIO_Port,POWER_OFF_Pin)==GPIO_PIN_SET)
   $ Z3 k2 Q7 a; z: z0 T
9.                 {
   . l7 g7 s' U( J1 t
10.                         if((HAL_GetTick() - tickstart) >= 3000)        //如果大于3s
    
11.                         {
    9 ^1 o# `. |3 }# x( ^- S9 W; O
12.                                 g_powerON_flag = 1;
    
13.                                 HAL_GPIO_WritePin(POWER_ON_GPIO_Port,POWER_ON_Pin,GPIO_PIN_SET);        //开机
    
14.                                 
    2 h8 y+ q& l2 P' w
15.                                 HAL_GPIO_WritePin(MOT_EN_GPIO_Port,MOT_EN_Pin,GPIO_PIN_SET);                  //MOT_ON
    
16.                                 HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_SET);                                    //LED_ON
    
17.                                 HAL_Delay(500);                                                   
    
18.                                 HAL_GPIO_WritePin(MOT_EN_GPIO_Port,MOT_EN_Pin,GPIO_PIN_RESET);    //MOT_OFF
    
19.                                 HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET);                            //LED_OFF
    
20.                                 HAL_Delay(500);                                                   
    9 a( x3 g& B/ ^0 I1 J1 t
21.                                 HAL_GPIO_WritePin(MOT_EN_GPIO_Port,MOT_EN_Pin,GPIO_PIN_SET);                  //MOT_ON
    
22.                                 HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_SET);                                          //LED_ON
    8 u+ P/ r* P8 [/ n$ x4 T
23.                                 HAL_Delay(500);
    
24.                                 HAL_GPIO_WritePin(MOT_EN_GPIO_Port,MOT_EN_Pin,GPIO_PIN_RESET);                //MOT_OFF
    3 Y3 B2 G; b: m: x3 n4 Z3 P
25.                                 HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET);                                        //LED_OFF
    
26.                                 break;
    
27.                         }
    # Z' R  t. W' b  [5 W5 @
28.                 }
    
29.                 else
    7 H9 t  V2 Z# }# i( q1 B0 u
30.                 {
    
31.                         HAL_GPIO_WritePin(POWER_ON_GPIO_Port,POWER_ON_Pin,GPIO_PIN_RESET);        //不开机
    
32.                         HAL_GPIO_WritePin(MOT_EN_GPIO_Port,MOT_EN_Pin,GPIO_PIN_RESET);                  //MOT_OFF
    
33.                         HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET);                                                //LED_OFF
    " M* m! Y( i) g
34.                 }
    
35.         }
      U* J0 w9 c5 m! H; a) n
36. }
    ( H) |% e2 l/ Z7 v- V4 ?3 O1 W, |
37. </font>

复制代码

外部中断脚代码处理逻辑

1. <font face="微软雅黑" size="3">
     p# s8 i1 m7 I( N
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)               
   , D1 i0 W9 ]2 T
3. {
   
4.     if(GPIO_Pin == POWER_OFF_Pin)
   
5.         {
   8 F  K- P7 ]* e4 C
6.                 /* Clear Wake Up Flag */
   
7.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
   
8.                 if(HAL_GPIO_ReadPin(POWER_OFF_GPIO_Port,POWER_OFF_Pin)==SET)
   
9.                 {
   
10.                         //printf("关机唤醒中断\r\n");
    
11.                         g_powerOffWakeUp_flag=1;
    ; r8 @2 b; t- C4 M) v4 e
12.                         HAL_TIM_Base_Start_IT(&htim6);                                //开启定时器
    ' U! J3 f1 ~8 k5 Z
13.                 }
    
14.         }
    - e$ R7 f( k7 S6 N/ X2 C
15. }
    / `" ^; n1 w4 l7 E4 H$ C: E, t9 ]
16. </font>

复制代码

main.c 文件
2 @8 w- G  [: ?( z3 W- `

1. <font face="微软雅黑" size="3">
   
2. int main(void)
   
3. {
   1 e5 m7 o1 j+ _- p2 V* q6 S
4.   /* USER CODE BEGIN 1 */
   
5. 
   
6.   /* USER CODE END 1 */
   5 n0 k( y& F; a7 H
7. 
   , M4 L, f' \  ]" \$ c
8.   /* MCU Configuration--------------------------------------------------------*/
   
9. 
   
10.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
11.   HAL_Init();
    3 g6 D% `7 a% U
12. 
    
13.   /* USER CODE BEGIN Init */
    
14. 
    
15.   /* USER CODE END Init */
    ' v7 F3 z; H& j/ q9 _" r0 O, x
16. 
    : n: v2 Y) v5 d% v1 x6 X& o% N. v
17.   /* Configure the system clock */
    ; R) X* b: w; j
18.   SystemClock_Config();
    
19. 
    
20.   /* USER CODE BEGIN SysInit */
    ' w# a' e8 j, c* p$ F! A) F
21. 
    
22.   /* USER CODE END SysInit */
    
23. 
    
24.   /* Initialize all configured peripherals */
    ) B9 D# d: j- g9 Q6 Q7 O3 z$ Y% Y, H
25.   MX_GPIO_Init();
    
26.   MX_LPUART1_UART_Init();
    6 t1 _' _  ^+ y8 G( m6 v
27.   MX_USART1_UART_Init();
    
28.   /* USER CODE BEGIN 2 */
    
29. 
    
30.   /* USER CODE END 2 */
    % V3 L% S9 [8 ~1 I4 g5 k6 q$ Z
31. 
    
32.   /* Infinite loop */
    
33.   /* USER CODE BEGIN WHILE */
    
34.   while (1)
    0 M- m6 F" ~9 }/ M/ @) P
35.   {
    3 J1 e, W5 L* W5 P, w/ H7 b
36.           //事件1
    0 |4 m% X5 V& B7 D8 b5 ]
37.           HAL_Delay(1000);
    
38.           //事件2
    8 T+ A) ~& h. B. t2 B! o
39.           HAL_Delay(3000);
    
40.     /* USER CODE END WHILE */
    ! m2 d3 `0 p% Z/ X0 ^% s
41. 
    
42.     /* USER CODE BEGIN 3 */
    ! R6 c+ o6 h! [5 ]; H
43.   }
    2 i9 u/ n0 w! x2 E0 w1 K
44.   /* USER CODE END 3 */
    5 ?' Z) e8 I9 m5 M! R
45. 
    
46. </font>

复制代码

总结一下：其实这样处理思想，可以应用在很多地方，可达到实时性。不需要管while(1)中大循环的逻辑。有点像多线程处理一样。

这里的main.c代码，在实际开发中也不太允许这样处理，这样实时性太差了，也是很多小白刚学单片机犯最多的错误。这样写一看就知道是菜鸟。当然，我那样写不是很高大尚，其实想处理多线程的思路，还是引入RTOS好些。当然也不是说逻辑不好，各有利弊，看使用情况而定。