1，系统EVENT的实现
本项目是一个简单的系统，在这个项目中，我们采用了一种Timer3中断计时，时间到了以后，置位EVENT标志，然后再在主程序执行的方案。
0 u* P; ]2 n& a
# ?& @- C" e" r% ^- {' G0 L

1. while(1)
   ( Q- A8 E* N. P
2. {
   
3.                 if( newEVENT_id & EVENT_1)
   7 r6 u& ?7 T  R5 A7 W
4.                 {
   & F3 w, Z8 c; v( [% c/ @. x6 `
5.                         newEVENT_id = newEVENT_id & (~EVENT_1);
   . Z  U9 a: N7 T) O
6. 
   
7.                         newEventStart(EVENT_1,  2000);
   . D2 T: l0 P2 C
8.                 }
   ( U+ M: o. H3 m5 i" ]
9. 
   2 o0 H" W& A$ F+ @
10.               if( newEVENT_id & EVENT_2)
    
11.                 {
    
12.                         newEVENT_id = newEVENT_id & (~EVENT_2);
    , c& j) W, U8 o4 ^
13. 
    ! U6 n: o9 W+ O  z* b
14.                         newEventStart(EVENT_2,  3000);
    
15.                 }
    ) |% J: ?$ _1 z" E" Z' l
16. }

复制代码

1. //-------------------------------------------------
   0 \* p' W9 |8 M
2. void  newEventStart(uint32_t   inputID,  uint16_t  endTime)
   + k. _$ d4 c8 Y2 ?) M1 A
3. {
   
4.       switch(inputID)
   ' u  J6 l# `8 w2 U! R- a
5.       {
   
6.            case EVENT_1:
   / W3 M8 c; v; V, V$ O9 t
7.                    EVENT_1_start=1;
   
8.                    EVENT_1_count=0;
   
9.                    EVENT_1_endTime = endTime;
   . q9 k) U8 K. G2 M  ^0 w
10.            break;
    $ e7 {( y+ I9 J# x: C5 m
11. 
    " H+ S' }- |3 m. |
12.            case EVENT_2:
    9 A. y7 D+ P/ p7 `
13.                EVENT_2_start=1;
    
14.                EVENT_2_count=0;
    
15.                EVENT_2_endTime = endTime;
    ! T  n! `* ^) x! i
16.            break;
    
17.        }
    4 D. ]; U0 L5 p6 ]& n
18. }

复制代码

EVENT的计时，放在Timer3的中断里面：
到了EndTime以后，则置位EVENT标志

1. /* USER CODE BEGIN 1 */
   " u6 p$ E$ [' F- M4 d. m
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   ) X6 L3 l) S2 h( R8 E* P% N
3. {
   + y8 t2 a2 ^( D6 ^. y) }4 i1 o
4.     if (htim->Instance == htim3.Instance)   //---Timer3 中断入口 ---------
   * C6 |; Z1 L% `. r( M
5.     {
   1 T1 }" N* M" q
6.             newEventCount();
   
7.     }
   
8. }

复制代码

1. //------------------------------------------------
   0 h0 o' M0 o3 P0 O/ P8 b
2. void  newEventCount()
   
3. {
   
4.    if(EVENT_1_start)
   
5.    {
   6 S  t! y3 u$ K7 ^
6.            EVENT_1_count++;
   * J/ k; J# a7 ~
7.            if(EVENT_1_count >= EVENT_1_endTime)
   
8.            {
   
9.                    EVENT_1_start = 0;
   ) j4 ~3 Y' ~( t) a/ J
10.                    EVENT_1_count =0;
    
11.                    newEVENT_id = newEVENT_id | EVENT_1;
    
12.            }
      y) w) S6 k$ `) H
13.    }
    
14. 
    
15.    if(EVENT_2_start)
    ; U- D; d! X" r3 \7 X- @, [7 P7 S
16.    {
    . c% _' a% y( w- f) y( q& |
17.               EVENT_2_count++;
    
18.               if(EVENT_2_count >= EVENT_2_endTime)
    4 p: W0 ?1 @0 q) ^: W  T
19.               {
    " W( C( g5 N/ u4 j% X; H( z7 ^. G
20.                       EVENT_2_start = 0;
    
21.                       EVENT_2_count =0;
    
22.                       newEVENT_id = newEVENT_id | EVENT_2;
    6 Y( ]  a" o2 a2 @: [% a& j
23.               }
    
24.    }
    $ y! }2 R/ Q5 M+ [) U
25. }

复制代码

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

1. 
   ' z6 n/ P8 i1 I1 I
2.                 //--LED1 Indicate the system running-------
   7 F/ ]" X* K' n
3.                 if( newEVENT_id & EVENT_1)
   
4.                 {
   
5.                         newEVENT_id = newEVENT_id & (~EVENT_1);
   
6. 
   
7.                         LED1_status = LED_FLASH_oneTime;
   
8.                         LED1_FLASH_count=0;
   
9. 
   0 G' ~+ G! i8 P1 k7 s; \
10.                         newEventStart(EVENT_1,  2000);
    # C- D& ?7 a- e7 u' j) @! ~3 }
11.                 }
    

复制代码

2，串口的接收
串口接收按以下思路进行：
1，打开串口接收中断，每接收到一个字节即中断一次；
2，在中断里，把收到的字节移入接收数组里，同时启动一个EVENT，如果不断的有新的字节收到，即不断进入中断，即不断重新启动EVENT；
% v7 T" {1 U. k, K& ^3，当没有新的数据进来的时候，EVENT会不断计数到终止；
4，EVENT计数到终止的时候，会置位串口收到数据的标志；
' t- B6 [# q2 u1 V! w+ A2 I/ h5，在主程序里面处理收到的数据；
这样串口接收的好处，不需要知道来的数据是否有特殊标志、是否有特殊长度，它实际上是判断如果6MS没有新的数据，即表示当前数据接收完毕。
" U5 X: M1 s3 y* A

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

复制代码

1. //------------------------
   , c  h0 A1 h+ V8 {
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   / y% I4 ?' r9 a$ W
3. {
   8 K+ k9 Y4 u4 T  J+ x/ b, X
4.    //----UART1收到1个字节后 中断后来到这里----------
   
5.    if(huart->Instance == huart1.Instance )
   
6.    {
   ' m  g: c6 s/ V4 b1 C) ]/ o$ E
7.            UART1_received =1;   //--设置UART1收到数据的标志
   $ o0 k* \; I) l! `" G
8.            UART1_receiveData[UART1_receive_len] = aRxBuffer1[0];  //--把数据放在UART1接收数据的数组里
   
9.            UART1_receive_len++;
   ) ^2 s8 v& Z9 m: T
10.            if ( UART1_receive_len >= UART1_receiveBufLen)
    
11.            {
    
12.                    UART1_receive_len=0;
    
13.            }
    3 g  a5 u8 l9 J( c# ~1 F" K" R
14.            UART1_receive_count=0;  //--清零收到数据的计数，该计数在TIMER3中断里面累加，如果累加到6，则认为这次串口接收数据结束
    
15.    }
    
16. }

复制代码

1. /* USER CODE BEGIN 1 */
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
3. {
   
4.     if (htim->Instance == htim3.Instance)   //---Timer3 中断入口 ---------
   , b( r. X* E$ J4 S- a% T4 c1 X* N6 D- Z
5.     {
   
6.             LED1_FLASH();
   
7.             LED2_FLASH();
   
8. 
     l: x* D% K5 V. r6 Q* m& L
9.             newEventCount();
   6 m6 K% U- l* w0 }
10. 
    
11.             HAL_UART_ReceivedCount();
    ! O% @9 l2 s' N+ S1 H+ c' \
12. 
    ( b4 z0 J' P) }5 B
13.             //HAL_I2C_ReceivedCount();
    6 V, Z! e9 ]$ b$ R+ @2 N$ t
14.     }
    
15. }

复制代码

1. //-------------------------------
   ' V8 r2 G7 |7 r* ^. m
2. void HAL_UART_ReceivedCount()
     y  \4 u7 }3 l  Z5 o( c
3. {
   
4.     //---如果UART1收到了数据，则计数累加，到6表明UART1串口接收结束------
   
5.     if ( UART1_received )
   
6.         {
   
7.                 UART1_receive_count++;
   ) Z0 B6 W3 S5 g, t5 q
8.                 if (UART1_receive_count >= 6)   //---Default is 6
   % d; v) ^: ]$ j
9.                 {
   
10.                         EVENT_DO_UART = EVENT_DO_UART | EVENT_uart1_Received;
    2 v) M, u7 c5 m& @2 k1 C' I0 S: \
11.                         UART1_received=0;
    % E9 O6 q- B0 K& F
12.                         UART1_receive_count=0;
      R9 d+ o8 E1 @8 U" d" A
13.                 }
    & O* ]; S/ ~$ j1 N( s1 Q) J
14.         }
    $ W3 D1 f1 f* u6 B
15. }

复制代码

            

1.                //----UART1 Received Data Completed-----------------------------------
     L8 s! t) P* [) m, V4 s6 }4 q' B
2.                 if(EVENT_DO_UART & EVENT_uart1_Received)
   
3.                 {
   
4.                    EVENT_DO_UART = EVENT_DO_UART & (~EVENT_uart1_Received);
   ( ~- R8 D7 V8 {8 N( L1 V
5.                    dtk_uart1receivedData(UART1_receiveData, UART1_receive_len);
   
6. 
   
7.                    UART1_receive_len=0;
   
8.                 }
   

复制代码

% w7 X0 N, B, }3 T( o/ z. r