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

1. while(1)
   1 e% O3 T/ d/ j# F" ?
2. {
   % P4 V% \/ G( u; Y- t: }
3.                 if( newEVENT_id & EVENT_1)
   . O$ ?; r5 b" N2 _
4.                 {
   
5.                         newEVENT_id = newEVENT_id & (~EVENT_1);
     N! ^0 s+ ]7 Y7 P0 N% f5 P5 I1 {
6. 
   
7.                         newEventStart(EVENT_1,  2000);
   ; Y, b* `# c& K# u2 d4 `8 @' c
8.                 }
     n! y* F0 R2 @( t/ o5 Z
9. 
   2 K5 r  Z8 y7 E) e2 U9 K5 _
10.               if( newEVENT_id & EVENT_2)
    
11.                 {
    
12.                         newEVENT_id = newEVENT_id & (~EVENT_2);
    
13. 
    * M1 F9 p$ H& T' v
14.                         newEventStart(EVENT_2,  3000);
    # V# t/ A1 R& D1 v
15.                 }
    
16. }

复制代码

1. //-------------------------------------------------
   ; n1 C( H$ S: y6 s% {
2. void  newEventStart(uint32_t   inputID,  uint16_t  endTime)
   
3. {
   0 k' x8 z* p- B2 v
4.       switch(inputID)
   + `# t9 J* U$ i) H% I- \8 ]. E
5.       {
   
6.            case EVENT_1:
   
7.                    EVENT_1_start=1;
   
8.                    EVENT_1_count=0;
   " m# I# [' n! l# I
9.                    EVENT_1_endTime = endTime;
   - h2 _6 m/ r- H- d) {6 B4 }) e
10.            break;
    
11. 
    
12.            case EVENT_2:
    ' y/ K! `  g9 W  D: o+ t$ X
13.                EVENT_2_start=1;
    * t1 p; Q+ R5 I5 ^1 |7 c; @/ a
14.                EVENT_2_count=0;
    
15.                EVENT_2_endTime = endTime;
      L- t9 Y  N$ J
16.            break;
    
17.        }
    
18. }

复制代码

EVENT的计时，放在Timer3的中断里面：
  u; K8 Z0 X. [到了EndTime以后，则置位EVENT标志
" \1 ^& E3 H5 A( t3 K4 w
3 E5 J& U( {" f. G7 `" U

1. /* USER CODE BEGIN 1 */
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
3. {
   
4.     if (htim->Instance == htim3.Instance)   //---Timer3 中断入口 ---------
   
5.     {
   
6.             newEventCount();
   ! r, b$ U8 |! I
7.     }
     s9 ?: A. m; E+ J4 H
8. }

复制代码

1. //------------------------------------------------
   
2. void  newEventCount()
   
3. {
   ; p9 _' g$ |/ p& @% M) E( r$ R# p
4.    if(EVENT_1_start)
   ' \# K- _5 q; D; u" ?
5.    {
   & B" x0 q* p2 K  b; P* p: r
6.            EVENT_1_count++;
   
7.            if(EVENT_1_count >= EVENT_1_endTime)
   
8.            {
   ; \5 z1 G; h6 x; p
9.                    EVENT_1_start = 0;
   
10.                    EVENT_1_count =0;
    
11.                    newEVENT_id = newEVENT_id | EVENT_1;
    + d; }4 O- ~% a8 d6 x% `% \% g4 V0 s
12.            }
    + r5 S1 ~8 ?: F  z7 M1 `
13.    }
    & @. Z  t! Y' f$ p# Y% k
14. 
    
15.    if(EVENT_2_start)
    
16.    {
    3 t& ~/ C  f* C4 }, j* c
17.               EVENT_2_count++;
    ) R, L7 N5 u( n/ J. _8 |
18.               if(EVENT_2_count >= EVENT_2_endTime)
    7 N) n" _2 g' \$ o( y
19.               {
    
20.                       EVENT_2_start = 0;
    8 M* C7 r% [# Z' G& f1 W8 j
21.                       EVENT_2_count =0;
    4 L( ~& u$ @8 b8 D
22.                       newEVENT_id = newEVENT_id | EVENT_2;
    ) @# u1 _1 P  t  o/ b5 v
23.               }
    3 A& ?* H/ D5 o
24.    }
    
25. }

复制代码

这样的话，我们开启一个EVENT，来指示系统是否正常运行，就很简单了，下面的简单代码就实现了：
$ X. ?! Z' p( ~2 W) y: @3 g  s- v

1. 
   
2.                 //--LED1 Indicate the system running-------
   
3.                 if( newEVENT_id & EVENT_1)
   5 m( j$ r, P# t( Q9 ?, p& H
4.                 {
   
5.                         newEVENT_id = newEVENT_id & (~EVENT_1);
   ) M3 u' f$ \9 d' \2 |; B
6. 
   
7.                         LED1_status = LED_FLASH_oneTime;
   0 E, b% S  @! R- a" Z  r" e. D
8.                         LED1_FLASH_count=0;
   
9. 
   ! {2 n2 g* m+ [
10.                         newEventStart(EVENT_1,  2000);
      Z6 v7 `, c6 B% s
11.                 }
    

复制代码

" L+ U  }# \/ n. I: u2，串口的接收
7 B7 i' |7 ]# @1 @串口接收按以下思路进行：
2 J; R# T+ _, @2 F" y8 T1，打开串口接收中断，每接收到一个字节即中断一次；
2，在中断里，把收到的字节移入接收数组里，同时启动一个EVENT，如果不断的有新的字节收到，即不断进入中断，即不断重新启动EVENT；
3，当没有新的数据进来的时候，EVENT会不断计数到终止；
4，EVENT计数到终止的时候，会置位串口收到数据的标志；
5，在主程序里面处理收到的数据；
这样串口接收的好处，不需要知道来的数据是否有特殊标志、是否有特殊长度，它实际上是判断如果6MS没有新的数据，即表示当前数据接收完毕。
3 C' j8 T2 r, g# c, P2 s) f# k  U

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

复制代码

1. //------------------------
   ) }7 ~: F( G  q# O; ]
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
3. {
   
4.    //----UART1收到1个字节后 中断后来到这里----------
   ) y4 K  r2 ?" a
5.    if(huart->Instance == huart1.Instance )
   
6.    {
   
7.            UART1_received =1;   //--设置UART1收到数据的标志
   
8.            UART1_receiveData[UART1_receive_len] = aRxBuffer1[0];  //--把数据放在UART1接收数据的数组里
   
9.            UART1_receive_len++;
     W" E- u2 z: P; e& n5 H
10.            if ( UART1_receive_len >= UART1_receiveBufLen)
    
11.            {
    ! D' e  u2 p1 {
12.                    UART1_receive_len=0;
    
13.            }
    9 m2 @6 Y- c/ u( M) G  \
14.            UART1_receive_count=0;  //--清零收到数据的计数，该计数在TIMER3中断里面累加，如果累加到6，则认为这次串口接收数据结束
    
15.    }
    
16. }

复制代码

1. /* USER CODE BEGIN 1 */
   3 Z6 A: N  }2 v* H; I* {9 W
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
3. {
   % Q) v6 O. F' }: b/ _
4.     if (htim->Instance == htim3.Instance)   //---Timer3 中断入口 ---------
   0 I* |) h% W* q, U& N6 l5 d
5.     {
   
6.             LED1_FLASH();
   ' O# U6 s; }* Y% X, _& S
7.             LED2_FLASH();
   1 d6 e% ~1 C! x& N* P& X
8. 
   ) ?8 y3 K3 y; q  T- f
9.             newEventCount();
   " i, y0 }; |$ J3 h
10. 
    
11.             HAL_UART_ReceivedCount();
    
12. 
    2 K+ Z& P# Q  I' c% X% f* E
13.             //HAL_I2C_ReceivedCount();
    , J$ {8 x. r$ R$ d7 ^) h& ?
14.     }
    2 ~# ^6 l. N" l, a. @: `8 G
15. }

复制代码

1. //-------------------------------
   5 ^7 I( ~/ q/ @! q) z% B
2. void HAL_UART_ReceivedCount()
   0 @3 D4 i7 m: g7 s0 @0 H$ v3 q/ |
3. {
   
4.     //---如果UART1收到了数据，则计数累加，到6表明UART1串口接收结束------
   
5.     if ( UART1_received )
   
6.         {
   1 X, T" d1 |/ V$ d( ]) i
7.                 UART1_receive_count++;
   & I# U9 H# ~3 Y, W* s4 u
8.                 if (UART1_receive_count >= 6)   //---Default is 6
   
9.                 {
   
10.                         EVENT_DO_UART = EVENT_DO_UART | EVENT_uart1_Received;
    
11.                         UART1_received=0;
    0 w3 d8 m0 W8 N; b& ]$ C( _
12.                         UART1_receive_count=0;
    
13.                 }
    : T) J6 ^3 f3 N& N" w, X
14.         }
    
15. }

复制代码

2 [* Q0 Q% R& \4 T8 i% P5 Z+ j            

1.                //----UART1 Received Data Completed-----------------------------------
   0 C+ ]# C6 O0 v* e5 c( x  \4 N
2.                 if(EVENT_DO_UART & EVENT_uart1_Received)
   - |# p: U' Q' [" |/ G
3.                 {
   4 a# M) ~8 i" r% B
4.                    EVENT_DO_UART = EVENT_DO_UART & (~EVENT_uart1_Received);
   
5.                    dtk_uart1receivedData(UART1_receiveData, UART1_receive_len);
   
6. 
   1 d3 w# T& Q0 [; |: z7 D  u
7.                    UART1_receive_len=0;
   
8.                 }
   

复制代码

: Y! Q2 |1 i4 r3 T, D! w