1，系统EVENT的实现
本项目是一个简单的系统，在这个项目中，我们采用了一种Timer3中断计时，时间到了以后，置位EVENT标志，然后再在主程序执行的方案。

1. while(1)
   
2. {
   & @3 j4 s# S: Z1 ~
3.                 if( newEVENT_id & EVENT_1)
   ! u: M6 ~! F7 y# a* y
4.                 {
   0 K$ H$ f* n8 z2 k
5.                         newEVENT_id = newEVENT_id & (~EVENT_1);
   
6. 
   # \" e( Q7 L2 k
7.                         newEventStart(EVENT_1,  2000);
   
8.                 }
   1 J3 f  e2 A8 M( L
9. 
   5 Q2 ~" P$ ~- }- g6 k6 }# v
10.               if( newEVENT_id & EVENT_2)
    
11.                 {
    % ^& A$ c2 F. T, f: s/ M* u( l: N
12.                         newEVENT_id = newEVENT_id & (~EVENT_2);
    0 }" O1 l: W1 a9 t% Q
13. 
    
14.                         newEventStart(EVENT_2,  3000);
    
15.                 }
    * o% P, `. O! K* }5 v
16. }

复制代码

1. //-------------------------------------------------
   
2. void  newEventStart(uint32_t   inputID,  uint16_t  endTime)
   
3. {
   , K/ H9 a5 S" X  \( G" x' d
4.       switch(inputID)
   
5.       {
   1 D- }4 c  h# I  u/ Y4 g% A  y
6.            case EVENT_1:
   9 u( U- ~0 D% K  T
7.                    EVENT_1_start=1;
   9 a6 J6 I6 H7 V7 s" u) e; ^' J$ Y7 }
8.                    EVENT_1_count=0;
   
9.                    EVENT_1_endTime = endTime;
   
10.            break;
    / ^) Q2 `5 |  Z" W
11. 
    3 p( e- V" M. }0 c- r! N
12.            case EVENT_2:
    
13.                EVENT_2_start=1;
    + B3 R$ B6 d& s/ E/ w6 j
14.                EVENT_2_count=0;
    / E1 m. ^1 M) B
15.                EVENT_2_endTime = endTime;
    
16.            break;
    
17.        }
    
18. }

复制代码

EVENT的计时，放在Timer3的中断里面：
& e  c* q$ |7 n& j# y到了EndTime以后，则置位EVENT标志
" z# X: H* a6 h- ^$ S8 |

1. /* USER CODE BEGIN 1 */
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
3. {
   
4.     if (htim->Instance == htim3.Instance)   //---Timer3 中断入口 ---------
   
5.     {
   
6.             newEventCount();
     e( s. h# c) E3 d
7.     }
   
8. }

复制代码

1. //------------------------------------------------
   + X1 F! _! u% L+ O2 c' a
2. void  newEventCount()
   # p+ ^8 Z7 c/ X* u
3. {
   
4.    if(EVENT_1_start)
   
5.    {
   ' J) ^* }8 L$ N: \5 K
6.            EVENT_1_count++;
   + Z0 k$ N1 B4 m
7.            if(EVENT_1_count >= EVENT_1_endTime)
   # \1 K$ l. a0 Z+ a4 j
8.            {
   
9.                    EVENT_1_start = 0;
   + r* ~7 d, G$ g9 j* ~
10.                    EVENT_1_count =0;
    
11.                    newEVENT_id = newEVENT_id | EVENT_1;
    
12.            }
    + y# Q9 |1 [% ?7 \7 @2 K0 h9 y
13.    }
    6 g) i6 w4 T% e
14. 
    
15.    if(EVENT_2_start)
    + I& R: ~3 G5 n; y8 Y
16.    {
    
17.               EVENT_2_count++;
    1 B- ?3 o# t3 [8 `4 J" y1 K
18.               if(EVENT_2_count >= EVENT_2_endTime)
    
19.               {
    $ G! }& l/ ~+ D3 Z. e! N3 a
20.                       EVENT_2_start = 0;
    ( c3 r- G$ k. N5 g7 R9 D
21.                       EVENT_2_count =0;
    
22.                       newEVENT_id = newEVENT_id | EVENT_2;
    # m( G( `+ ]! R( B
23.               }
    + R! O: c" r- M$ K! ?. g* K
24.    }
    2 {- @( J8 W1 }) x
25. }

复制代码

这样的话，我们开启一个EVENT，来指示系统是否正常运行，就很简单了，下面的简单代码就实现了：

1. 
   
2.                 //--LED1 Indicate the system running-------
   
3.                 if( newEVENT_id & EVENT_1)
   . ^7 X2 z5 G! H- n; w% D
4.                 {
   2 V% G4 J, B8 l/ L1 g7 W
5.                         newEVENT_id = newEVENT_id & (~EVENT_1);
   6 C: [8 m2 s' \& p* ?3 r1 b
6. 
   
7.                         LED1_status = LED_FLASH_oneTime;
   ( t) t4 b5 x9 z
8.                         LED1_FLASH_count=0;
   % F5 p; ~' o4 b% g
9. 
   
10.                         newEventStart(EVENT_1,  2000);
    6 w1 X, _/ v4 k0 G* f
11.                 }
    ) [  u5 ~- d. w4 \

复制代码

2，串口的接收
串口接收按以下思路进行：
1，打开串口接收中断，每接收到一个字节即中断一次；
6 o4 A% C  j+ D6 }2，在中断里，把收到的字节移入接收数组里，同时启动一个EVENT，如果不断的有新的字节收到，即不断进入中断，即不断重新启动EVENT；
3，当没有新的数据进来的时候，EVENT会不断计数到终止；
* w0 A' e1 H5 y- q3 W4，EVENT计数到终止的时候，会置位串口收到数据的标志；
5，在主程序里面处理收到的数据；
) Q) n  v5 R! W) j- [8 N这样串口接收的好处，不需要知道来的数据是否有特殊标志、是否有特殊长度，它实际上是判断如果6MS没有新的数据，即表示当前数据接收完毕。

+ q* D. D9 x  ]- U8 Y

1. HAL_UART_Receive_IT(&huart1, aRxBuffer1, 1);          // Enable the USART1 Interrupt

复制代码

1. //------------------------
   ; n1 Q  R7 [4 w/ ~, j
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
3. {
   
4.    //----UART1收到1个字节后 中断后来到这里----------
   
5.    if(huart->Instance == huart1.Instance )
   
6.    {
   # y7 u1 w* M* Y
7.            UART1_received =1;   //--设置UART1收到数据的标志
   1 G6 {: P- q, \/ ?
8.            UART1_receiveData[UART1_receive_len] = aRxBuffer1[0];  //--把数据放在UART1接收数据的数组里
   
9.            UART1_receive_len++;
   
10.            if ( UART1_receive_len >= UART1_receiveBufLen)
    0 c; B9 O" J# I
11.            {
    
12.                    UART1_receive_len=0;
    7 e% l" l9 X2 h
13.            }
    : w; h* n$ {6 T- M" Q( H9 d
14.            UART1_receive_count=0;  //--清零收到数据的计数，该计数在TIMER3中断里面累加，如果累加到6，则认为这次串口接收数据结束
    
15.    }
    + B) Q, Y# `) j6 [% D2 X( i
16. }

复制代码

1. /* USER CODE BEGIN 1 */
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   ; H" w, P( y$ Y
3. {
   
4.     if (htim->Instance == htim3.Instance)   //---Timer3 中断入口 ---------
   
5.     {
   
6.             LED1_FLASH();
   . k$ I5 f9 [, y1 o0 m
7.             LED2_FLASH();
   % @, r$ {" J+ \6 B! E7 l
8. 
   
9.             newEventCount();
   ! n1 y* \0 @7 E& k: x
10. 
    4 K5 x7 ~6 I7 e' h
11.             HAL_UART_ReceivedCount();
    9 c0 k! {/ D- {' x6 {
12. 
    ! g4 D1 t0 ?) O. s7 g
13.             //HAL_I2C_ReceivedCount();
    
14.     }
    
15. }

复制代码

1. //-------------------------------
   9 G. E! I' s! }4 K/ E
2. void HAL_UART_ReceivedCount()
   4 j+ P4 |' p, B9 b- J5 C
3. {
   + ~7 V5 O, F- i0 _. J
4.     //---如果UART1收到了数据，则计数累加，到6表明UART1串口接收结束------
   6 m% a2 i; G) @3 x7 N0 p  w
5.     if ( UART1_received )
   
6.         {
   * q& I: b1 X' j$ v
7.                 UART1_receive_count++;
   
8.                 if (UART1_receive_count >= 6)   //---Default is 6
   
9.                 {
   7 ]7 U6 X3 Z$ I. N; ^# }6 X/ o
10.                         EVENT_DO_UART = EVENT_DO_UART | EVENT_uart1_Received;
    
11.                         UART1_received=0;
    
12.                         UART1_receive_count=0;
    : W8 i' D9 z7 u  x
13.                 }
    
14.         }
    
15. }

复制代码

  Q$ ]" Q* @$ a/ V* Y. ?            

1.                //----UART1 Received Data Completed-----------------------------------
   1 E/ W/ H- T. X' Z/ d
2.                 if(EVENT_DO_UART & EVENT_uart1_Received)
   9 J% A8 {- X9 O
3.                 {
   
4.                    EVENT_DO_UART = EVENT_DO_UART & (~EVENT_uart1_Received);
   
5.                    dtk_uart1receivedData(UART1_receiveData, UART1_receive_len);
   8 ~: o7 [3 @% ?- c8 G
6. 
   
7.                    UART1_receive_len=0;
   ( E' W4 D& U4 r6 L$ M$ p& o$ v" |
8.                 }
   / |+ Q! J7 T- i1 A. t  }  O1 V! ^& G

复制代码

: o+ u0 b& r3 a; Y4 u3 V! C% y5 C
. k- n$ X- o) v- c" J9 A