前言

一般进行远程监控时，2.4G无线通信是充当远程数据传输的一种方法。这时就需要在现场部分具备无线数据发送装置，而在上位机部分由于一般只有串口，所以将采集到的数据送到电脑里又要在上位机端设计一个数据接收的适配器。这里基于stm32分别设计了现场部分和适配器部分，这里只是基本通信功能实现的讲解，一些复杂的技术比如加密、可靠等要根据具体的应用来设计~

+ f$ _$ {3 V1 G9 ?- [, }& K

  L$ v6 b! x8 e2 r# A

总体说明

这里采用stm32作为MCU,采用nRF24L01作为2.4G通信模块。其中适配器中仅仅采用了USART和NRF24L01两个主要部分，负责将下位机通过2.4G发送过来的数据通过串口发送给上位机，或者将上位机的通过串口传来的数据通过2.4G发送给下位机来实现远程监控（没有采用uc-os操作系统，也没有界面，要用串口和上位机相连）；其中下位机比较复杂，因为一般下位机是一个集成的系统，包括从各种传感器收集数据、向各种类型的驱动电路发送控制命令、将数据输给打印机或显示器、和无线通信或有线通信设备进行互相通信来实现数据传输等，这里的下位机比较简单：采用uc-os实时操作系统+uc-gui负责界面显示，外接7寸TFT液晶显示屏，和适配器类似也包括USART和NRF24L01通信部分，但是因为有了操作系统和可视化交互界面，所以也有点不同，接下来开始介绍。

适配器部分

这里介绍的流程是以main函数为基准，广度拓宽知识点，最后main函数说完，整个工程的细节也就大致能了解了~

1. 1 int main(void){
   9 s( n0 Q0 D# t
2. 2   uint8_t a=0;//LED高低电压控制
   
3. 3   /* System Clocks Configuration */
   " h. W5 ]& `; y- ^) G, j+ j
4. 4   RCC_Configuration();                                              //系统时钟设置   
   
5. 5   /*嵌套向量中断控制器
   + d; \/ _1 I- h# \4 f
6. 6       说明了USART1抢占优先级级别0（最多1位） ，和子优先级级别0（最多7位） */
   ' c7 d' ?! k" p3 Y( v! o. E
7. 7   NVIC_Configuration();                                              //中断源配置
   5 k2 w9 C7 w' y
8. 8   /*对控制LED指示灯的IO口进行了初始化，将端口配置为推挽上拉输出，口线速度为50Mhz。PA9,PA10端口复用为串口1的TX，RX。
   
9. 9   在配置某个口线时，首先应对它所在的端口的时钟进行使能。否则无法配置成功，由于用到了端口B， 因此要对这个端口的时钟
   
10. 10   进行使能，同时由于用到复用IO口功能用于配置串口。因此还要使能AFIO（复用功能IO）时钟。*/
    
11. 11   GPIO_Configuration();                                              //端口初始化
    9 D& U% [6 ~7 V! }& k3 B
12. 12   SPI2_NRF24L01_Init();                                           //SPI2及NRF24L01接口初始化  
    6 H# H/ i4 S2 ]: k, \8 I8 N" V
13. 13   USART_Config(USART1);                                              //串口1初始化
    & ]3 u! o+ {  ^! M  k) R  E( ]/ F
14. 14   /*NRF24L01设置为接收模式*/
    . x( q  L5 V0 t  n
15. 15   RX_Mode();
    " E# y8 }- S2 R/ E: I% B
16. 16
    
17. 17    while (1)
    
18. 18   {
    
19. 19     if(usart_rec_flag==1) //判断是否收到一帧有效数据
    
20. 20     {                                                  
    
21. 21         usart_rec_flag=0;
    9 m2 Z0 t4 g1 J2 L! Q8 c) ]
22. 22         NRF_Send_Data(TxBufferRF,sizeof(TxBufferRF));
    " G( b5 ~: f0 v& l7 v9 j
23. 23         if(a==0){GPIO_SetBits(GPIOB, GPIO_Pin_5);a=1;}          //LED1  明暗闪烁               
    , ]& m' i5 N  V0 Z# T# c
24. 24         else{GPIO_ResetBits(GPIOB, GPIO_Pin_5);a=0;}
    
25. 25     }
    
26. 26     if(rf_rec_flag==1)
    ; g' s) g2 Q0 L4 y# g) T! l8 m" D
27. 27     {
    ! y/ s% P: _, Q& |& n7 f# @
28. 28           rf_rec_flag=0;
    
29. 29            for(i=0;i<32;i++)//发送字符串
    5 U5 j4 G: d% s. |( ~
30. 30         {
    % ?0 ~9 E6 C4 Q/ r/ n
31. 31             USART_SendChar(USART1,TxBufferUSART[i]);
    
32. 32         //    Delay(0x0000ff00);
    
33. 33         }
    
34. 34     }
    
35. 35   }
    
36. 36 }

复制代码

- E) ^6 s. P- F! I- N

第4行RCC初始化主要是系统时钟和外设时钟配置，这里注意要使能RCC_APB2Periph_USART1，当时忘了使能这个结果串口出现异常，我还以为是初始化和中断向量什么的弄错了呢，浪费了很长时间。

1. 1 /*--------------------------------------------------------------------------------------
   
2. 2 系统时钟配置为72MHZ+外设时钟配置*/
   8 o  u( ]1 V% W3 ]% i
3. 3 void RCC_Configuration(void){
   2 f: u7 _2 h- A& ~/ U6 E6 j) v
4. 4    SystemInit();
   
5. 5    RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1 |RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |RCC_APB2Periph_AFIO  , ENABLE);  
   
6. 6 }

复制代码

1 r: F* M! ]+ F1 q8 w9 }; V, o. ]) M
0 R5 P% S5 M/ ^5 Z5 R) J5 [

第7行中断向量初始化设置，主要是设置串口接收中断和NRF24L01中断的，这样设置好了之后当串口中断被触发时其对应的中断子程序将被执行（这个科班的大概都知道这里就不多说了），所以我们就要在stm32f10x_it.c里实现他们各自的中断子程序了（这个一会再详细介绍，咱们先把整个框架了解下）。另外说一句，这里的的优先级组将影响主优先级和子优先级数量具体请参考stm32f10X_的固件库的NVIC.

1. 1 void NVIC_Configuration(void){
   . H6 u: H7 h9 w( X$ o& D3 @
2. 2  /*  结构声明*/
   
3. 3   NVIC_InitTypeDef NVIC_InitStructure;
   % b1 C% |" V! Z6 S# b) f7 _
4. 4   EXTI_InitTypeDef EXTI_InitStructure;        
   
5. 5   
   ( Y" G3 y# A6 Z# l6 q, q! }$ V
6. 6   /* 优先级组 1  */   
   8 S6 v; m' H5 r5 O4 k5 K
7. 7   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);           
   ) ?+ e* {' Z" D1 t+ C2 j, ?5 B
8. 8   
   0 r5 O0 W+ y! n) i
9. 9   /* Enable the USART1 Interrupt */
   2 D: j0 Q. `0 W! B
10. 10   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;                     //设置串口1中断
    2 {# H/ S) K0 R0 A& k. v- b5 Q
11. 11   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;             //抢占优先级 0
    
12. 12   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                //子优先级为0
    
13. 13   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                    //使能
      ?  }5 J% o7 ~/ F* r1 H5 c& \
14. 14   NVIC_Init(&NVIC_InitStructure);                                             
    
15. 15
    : f# G# C( D2 `. V$ r* C, ?! U2 n; K  i( G
16. 16                                                                     
      {4 h; `0 f$ P7 s$ k
17. 17   NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;                    //NRF24L01 中断响应
    
18. 18   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;            //抢占优先级 0
      |/ Y/ `  z1 c6 _1 A+ a. g2 C
19. 19   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                //子优先级为1
    * ~/ H( w* D) a5 ?
20. 20   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                    //使能
    
21. 21   NVIC_Init(&NVIC_InitStructure);                                                
    
22. 22
    
23. 23   GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);       //NRF24L01 IRQ  PA0
    : x" o) Q# n2 T0 |4 v) [
24. 24   
    ! G- A4 e1 L9 _9 D" q
25. 25   EXTI_InitStructure.EXTI_Line = EXTI_Line0;                       //NRF24L01 IRQ PA0
    
26. 26   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;               //EXTI中断
    # k* k- J" H1 q7 N
27. 27   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;           //下降沿触发
    
28. 28   EXTI_InitStructure.EXTI_LineCmd = ENABLE;                           //使能
    
29. 29   EXTI_Init(&EXTI_InitStructure);   
    ( C. _, a7 B+ }! l% K) F  ^
30. 30 }

复制代码

$ a; b) P7 L7 e3 Q3 U& W
  O" P& |( {1 H

第11行的GPIO初始化，主要是对通用IO口的属性设置和初始化，这里一定要对串口所需的A9和A10配置好！

1. 1 void GPIO_Configuration(void){
   9 Q' |; N% i8 J! M7 J( p) v
2. 2   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;                     //LED1控制--PB5
   1 Y0 K4 v$ j3 r& P) f
3. 3   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;             //推挽输出
   
4. 4   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   ' D5 O! Q# t+ _6 K# k# T' V6 k
5. 5   GPIO_Init(GPIOB, &GPIO_InitStructure);                     
   
6. 6
   
7. 7   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                      //USART1 TX
   
8. 8   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;             //复用推挽输出
   
9. 9   GPIO_Init(GPIOA, &GPIO_InitStructure);                     //A端口
   4 Y9 }- j3 g  k
10. 10
    
11. 11   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                  //USART1 RX
    8 f, B! ]& [- w1 R6 @" @& s; |5 H
12. 12   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;        //复用开漏输入
    
13. 13   GPIO_Init(GPIOA, &GPIO_InitStructure);                      //A端口
    : u: H3 {) d7 O: U7 [4 D  e
14. 14 }

复制代码

- h; W$ X9 ^0 k& t0 l
5 O8 i) q8 j9 A7 n) ?; O1 S' |

第12行的SPI2_NRF24L01_Init();主要是驱动NRF24L01的接口初始化，因为NRF24L01采用的是SPI通信，所以这里免不了SPI的设置和相关操作了，不过幸好都封装好了~像以前在51上做SPI就得自己模拟SPI，没有示波器调试起来甚是坑~此外这里我已经把NRF24L01的整个驱动都封装在NRF24L01.c这个文件里了，当想用的时候只要在中断向量里设置其中断接收函数，并在it.c里实现其接收函数；一般主函数里用到的是其初始化函数SPI2_NRF24L01_Init();和 RX_Mode();，当在过程中想利用NRF24L01向外发数据时只要调用函数void NRF_Send_Data(uint8_t* data_buffer, uint8_t Nb_bytes)：

1. 1 /****************************************************************************
   
2. 2 * 名    称：NRF_Send_Data(uint8_t* data_buffer, uint8_t Nb_bytes)
   ! R2 h* H) O; Q, C: Z1 f& \1 a
3. 3 * 功    能：将保存在接收缓存区的32字节的数据通过NRF24L01+发送出去
   # s& n6 F( s+ u4 U: ~" ^* K
4. 4 * 入口参数：data_buffer   待发送数据
   
5. 5             Nb_bytes      待发送数据长度
   
6. 6 * 出口参数：无
   
7. 7 * 说    明：数据小于32，把有效数据外的空间用0填满
   & C6 {3 G: r+ S" z4 z2 B) s0 b/ [
8. 8 * 调用方法：RX_Mode();
   
9. 9 ****************************************************************************/
   8 @. m1 Y2 k0 b# @( Q1 Y6 w0 w5 Z
10. 10 void NRF_Send_Data(uint8_t* data_buffer, uint8_t Nb_bytes)
    " X: u* m% r, W
11. 11 {  
    3 S/ {& [; i2 _8 c
12. 12     uchar i=0;  
    % W. Y: g* D/ R! C% O; R
13. 13     MODE_CE(0);                                 //NRF 模式控制     
    ! l, _9 z8 f  C7 ~) X# j
14. 14
    ; {! ~2 n* ?  |  n# Q: h; }
15. 15     SPI_RW_Reg(WRITE_REG1+STATUS,0xff);         //设置状态寄存器初始化
    
16. 16     SPI_RW_Reg(0xe1,0);                         //清除TX FIFO寄存器
    
17. 17     SPI_RW_Reg(0xe2,0);                         //清除RX FIFO寄存器
    
18. 18     TX_Mode();                                 //设置为发送模式
    5 Q4 c, \- }  S8 w# j
19. 19     delay_ms(1);
    # h" d9 S* G5 R' O0 A5 U6 \
20. 20     if(Nb_bytes<32){                         //当接收到的USB虚拟串口数据小于32，把有效数据外的空间用0填满
    
21. 21         for(i=Nb_bytes;i<32;i++) data_buffer[i]=0;
    - U1 d; c! g# i; I
22. 22     }
    
23. 23     MODE_CE(0);
    
24. 24       SPI_Write_Buf(WR_TX_PLOAD, data_buffer, TX_PLOAD_WIDTH);        //发送32字节的缓存区数据到NRF24L01
    / ~" F+ d3 r8 J
25. 25     MODE_CE(1);                                                        //保持10us以上，将数据发送出去        
    
26. 26 }

复制代码

5 @( Q& k; P) l. \3 h

第13行是USART初始化，包括波特率、数据位、停止位等~

1. 1 void USART_Config(USART_TypeDef* USARTx){
   / ~) `+ m; l2 k5 I$ L" B! \
2. 2   USART_InitStructure.USART_BaudRate = 9600;                        //速率9600bps
   ( W# A# w* }1 {  R5 @
3. 3   USART_InitStructure.USART_WordLength = USART_WordLength_8b;        //数据位8位
   
4. 4   USART_InitStructure.USART_StopBits = USART_StopBits_1;            //停止位1位
   
5. 5   USART_InitStructure.USART_Parity = USART_Parity_No;                //无校验位
   
6. 6   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;   //无硬件流控
   " }+ i% m5 l% j! P5 ]8 T: f* i3 }
7. 7   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;                    //收发模式
   & Y' x5 f) P% Y
8. 8
   % t# U+ Z- B4 h0 c4 z8 s
9. 9   /* Configure USART1 */
   ) Q! T3 G  H& v; O8 o* C, c( y
10. 10   USART_Init(USARTx, &USART_InitStructure);                            //配置串口参数函数
    ; W1 z/ b$ g) i/ H( a6 |! F8 ~
11. 11  
    
12. 12   
    6 E4 x; R* m) |9 E/ U
13. 13   /* Enable USART1 Receive and Transmit interrupts */
    
14. 14   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);                    //使能接收中断
    
15. 15   USART_ITConfig(USART1, USART_IT_TXE, ENABLE);                        //使能发送缓冲空中断   
    : P' g9 u7 H( t/ Z
16. 16
    
17. 17   /* Enable the USART1 */
    
18. 18   USART_Cmd(USART1, ENABLE);   
    
19. 19 }

复制代码

$ `9 X7 g2 b( ]0 a
7 k9 G# K/ `% N5 i

同样的类似于NRF24L01一旦初始化之后，其数据接收一般采用中断方式、数据发送一般采用直接发送的方式。所以在中断向量里也要设置，也要在it.c中实现其接收中断子函数。其发送直接调用stm32f10的固件库函数（这里我稍加封装了下）：其实就是发送一个data之后要监听是否发送完成才能进行下次发送~

1. 1 void USART_SendChar(USART_TypeDef* USARTx,uint8_t data){
   / q- z3 d5 {  u
2. 2     USART_SendData(USARTx,data);
   
3. 3     while(USART_GetFlagStatus(USARTx,USART_FLAG_TC)==RESET);
   
4. 4 }

复制代码

接下来进入while循环，不断进行监听看是否有串口接收标志位置1或者无线模块接收标志位置1，如果有表明相应的有数据从该通道传送过来。当是从串口传来的数据表明数据是从上位机发送来的数据，并且想把该数据通过2.4G发送出去，所以这里调用：NRF_Send_Data(TxBufferRF,sizeof(TxBufferRF));将数据发送出去；当数据是从2.4G通道中传过来的，表明数据是从下位机传送过来的想给上位机，于是调用串口发送函数将数据发送给上位机：USART_SendChar(USART1,TxBufferUSART);

3 I, |; {# b, Z+ C; S0 @

看了上图适配器端的数据交换过程就明白了串口中断和无线中断大致要干的事了，这里我就不多介绍，看看下面的代码就明白了（在stm32f10x_it.c中），要再次提醒的是无论是串口还是无线其接收都是采用中断，而发送采用循环直接发送，他们的中断和中断向量有关并要在stm32f10x_it.c里实现相应的中断子程序~

1. 1 /******************************************************************************/
   
2. 2 /*            STM32F10x Peripherals Interrupt Handlers                        */
   0 ]$ s3 f, m- O" b
3. 3 /******************************************************************************/
   * D- V* i* T) O
4. 4
   
5. 5 /**
   
6. 6   * @brief  This function handles USART1 global interrupt request.
   
7. 7   * @param  None
   
8. 8   * @retval : None
   ' @" v) G) W9 @% a6 [$ I- f
9. 9   */
   
10. 10 void USART1_IRQHandler(void)      //串口1 中断服务程序
    
11. 11 {
    / S6 Y; ~6 i) B4 |
12. 12   unsigned int i;
    & V8 |( ~# r, l8 g
13. 13   if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)       //判断读寄存器是否非空
    
14. 14   {   
    
15. 15     
    - L8 i) y, A, \+ c! G0 S. V" p
16. 16     RxBufferUSART[RxCounter1++] = USART_ReceiveData(USART1);   //将读寄存器的数据缓存到接收缓冲区里
    
17. 17     
    7 U+ e) h- }, K- f
18. 18     if(RxBufferUSART[RxCounter1-2]==0x0d&&RxBufferUSART[RxCounter1-1]==0x0a)     //判断结束标志是否是0x0d 0x0a
    / p/ I6 L9 k* f; G0 p1 d# f2 b- }" Z7 K
19. 19     {
    
20. 20       for(i=0; i< RxCounter1; i++) TxBufferRF[i] = RxBufferUSART[i];          //将接收缓冲器的数据转到发送缓冲区，准备转发
    # k' K% Z( a* P# Q7 e
21. 21       usart_rec_flag=1;                                                             //接收成功标志
    & r2 h  I. L8 j$ A* ~
22. 22       TxBufferRF[RxCounter1]=0;                                             //发送缓冲区结束符   
    
23. 23       TxCounter1=RxCounter1;
    3 g8 I2 m$ Q3 r6 ?* a0 G1 q
24. 24       RxCounter1=0;
    7 L& S: B( C% v3 b8 {# G! O) k  Z
25. 25     }
    ; z1 y7 V8 b( e, a# f% S
26. 26   }
    % R6 v( w9 _) L
27. 27   
    : l0 n' n. S' V: g) i
28. 28   if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)                   //这段是为了避免STM32 USART 第一个字节发不出去的BUG
    # B* k, F7 f' U3 n( X
29. 29   {
    
30. 30      USART_ITConfig(USART1, USART_IT_TXE, DISABLE);                         //禁止发缓冲器空中断，
    0 X/ Z! F/ j; n( z
31. 31   }   
      {. g3 R& [6 v/ C' v3 G/ m
32. 32 }  
    0 ?) g2 X1 W1 ~# e
33. 33 /*******************************************************************************
    
34. 34 * Function Name  : EXTI0 中断函数
    . ], F8 b' |3 `6 p# Q9 e
35. 35 * Description    : NRF24L01中断服务程序
    
36. 36 * Input          : None
    / r  L+ t" V3 u7 F) L! b
37. 37 * Output         : None
    5 z0 F9 j, C. }, z" O; m
38. 38 * Return         : None
    
39. 39 *******************************************************************************/
    
40. 40 void EXTI0_IRQHandler(void){
    
41. 41     u8 i=0;
    ; G5 q2 z  Z- z
42. 42      u8 status;   
    5 v' q& ]* O; r
43. 43     if(EXTI_GetITStatus(EXTI_Line0) != RESET)            //判断是否产生了EXTI0中断
    
44. 44       {
    
45. 45         if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)==0){ //判断是否是PA0线变低            
    
46. 46             status=SPI_Read(READ_REG1+STATUS);            // 读取状态寄存其来判断数据接收状况   
    
47. 47             if(status & 0x40)                            // 判断是否接收到数据                  
    
48. 48             {            
    
49. 49                 //GPIO_ResetBits(GPIOB, GPIO_Pin_5);   
    
50. 50                  SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);  //从接收缓冲区里读出数据
    
51. 51                 for(i=0; i<32; i++)TxBufferUSART[i] = rx_buf[i];  //向USB 端点1的缓冲区里放置数据      
    
52. 52                 rf_rec_flag=1;
    
53. 53             }
    ' T* ]# u! A/ [  ]6 Q4 K9 a
54. 54             else if((status &0x10)>0){                     //发射达到最大复发次数               
    
55. 55                 SPI_RW_Reg(0xe1,0);                          //清除发送缓冲区                  
    
56. 56                 RX_Mode();                                 //进入接收模式                  
    ' H; x8 F8 G! ^/ Y9 ?
57. 57             }
    ( v* d5 d& s6 _
58. 58             else if((status &0x20)>0){                     //发射后收到应答
    
59. 59                 GPIO_SetBits(GPIOB, GPIO_Pin_5);   
    3 n" Q: x( C6 T
60. 60                 SPI_RW_Reg(0xe1,0);                         //清除发送缓冲区              
    
61. 61                 RX_Mode();                                 //进入接收模式                  
    $ h5 C) U4 G+ \
62. 62             }
    
63. 63             SPI_RW_Reg(WRITE_REG1+STATUS, status);         //清除07寄存器标志
    
64. 64         }        
    
65. 65         EXTI_ClearITPendingBit(EXTI_Line0);             //清除EXTI0上的中断标志              
    
66. 66     }
    
67. 67 }

复制代码

下位机部分

上面说过一般具有远程通信能力的嵌入式系统其下位机部分往往要干很多事，这里我们采用stm32作为MCU并搭载uc-OS实时操作系统负责任务调度，同时采用7寸TFT彩屏和uc-GUI设计可视化人机交互界面。其中任务包括主任务、界面任务和触摸任务，主任务负责建立其他任务，界面任务中将包含整个人机交互界面的界面刷新逻辑，触摸任务负责获取触摸位置数据获取~

% }& r! L3 _* _' h" {7 x! `* K) [

这里我们还是得从main函数先说起：首先在main函数中进行相关初始化，然后建立主任务并启动uc-OS内核；接着在主任务中调用App_TaskCreate(); 分别建立界面任务和触摸任务（如下每个任务的建立类似，要给出指向任务代码的指针、任务执行时传递给任务的参数的指针，分配给这个任务的栈信息，任务优先级等）。这样当任务建立好之后，其执行权就由操作系统调度了~

1. 1 static  void App_TaskCreate(void)
   5 S- b% [0 Y6 P2 B# h# n* k
2. 2 {
   8 w% n) r$ P! d# w8 H& b3 M0 T
3. 3    /*  建立用户界面任务 */
   
4. 4    OSTaskCreateExt(AppTaskUserIF,                                               //指向任务代码的指针
   9 Y8 A% ?. w  N0 w5 j
5. 5                        (void *)0,                                                   //任务开始执行时，传递给任务的参数的指针
   
6. 6                        (OS_STK *)&AppTaskUserIFStk[APP_TASK_USER_IF_STK_SIZE-1],  //分配给任务的堆栈的栈顶指针   从顶向下递减
   $ V! W+ u- f& x5 E$ ^% l- R
7. 7                     APP_TASK_USER_IF_PRIO,                                       //分配给任务的优先级
   # I/ `: k! ^+ I2 Z; N* X4 p
8. 8                     APP_TASK_USER_IF_PRIO,                                       //预备给以后版本的特殊标识符，在现行版本同任务优先级
   
9. 9                     (OS_STK *)&AppTaskUserIFStk[0],                               //指向任务堆栈栈底的指针，用于堆栈的检验
   5 j9 X  z; K! Q5 C
10. 10                     APP_TASK_USER_IF_STK_SIZE,                                    //指定堆栈的容量，用于堆栈的检验
    
11. 11                     (void *)0,                                                    //指向用户附加的数据域的指针，用来扩展任务的任务控制块
    , [  ^* S2 r: I* W4 a0 \
12. 12                     OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);                    //选项，指定是否允许堆栈检验，是否将堆栈清0,任务是否要
    6 W% B1 p8 q8 t. @7 ~0 `3 ?+ z
13. 13                                                                                 //进行浮点运算等等。
    + u9 [& g2 s! K2 N  C5 \, T; B
14. 14                     
    ! y4 D' R" n( x
15. 15    /* 建立触摸驱动任务 */
    
16. 16    OSTaskCreateExt(AppTaskKbd,
    : D0 @& {9 ^9 [0 q1 l6 s2 c
17. 17                        (void *)0,
    
18. 18                     (OS_STK *)&AppTaskKbdStk[APP_TASK_KBD_STK_SIZE-1],
    
19. 19                     APP_TASK_KBD_PRIO,
    9 K, `3 V, b( a5 G& f& q" ]$ t
20. 20                     APP_TASK_KBD_PRIO,
    
21. 21                     (OS_STK *)&AppTaskKbdStk[0],
    ( x- p. f2 _3 M! L: ]2 K$ Z
22. 22                     APP_TASK_KBD_STK_SIZE,
    0 C/ l" P& A" L2 z' d6 S
23. 23                     (void *)0,
    6 h/ t" I( L" V0 w: C; [
24. 24                     OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);   
    
25. 25
    " _, z  Y- G8 _5 T5 h! z2 [
26. 26 }

复制代码

这里以界面任务为例：因为我们在建立界面任务时已经指定其任务代码指针AppTaskUserIF，所以这里来写其对应的函数（也就是说这里是界面任务的入口）。从下面的代码可以看出进入界面任务时首先对uc-GUI进行初始化，然后进入死循环不断执行Fun()函数（有人会疑惑：这里while死循环不就只能死在这里吗？怎么执行其他任务呢？哈哈，这就是具有操作系统和不具有操作系统的不同啦~虽然这里是while死循环，但是当OS要把CPU占有权分给其他任务时就会把当前执行的任务的信息压入其对应的栈空间，当再次要把CPU分配给该任务时，则把栈里保存的上次执行的情况拿出来继续执行，从而实现抢占与多任务的效果！）

1. 1 static  void  AppTaskUserIF (void *p_arg)
   
2. 2 {                                               
   4 t% p0 A, h- z6 M5 I7 p. H
3. 3  (void)p_arg;                                    
   
4. 4   GUI_Init();                    //ucgui初始化
   4 q& ~2 Y% k4 z. y" Z/ ]% r' M
5. 5   while(1)
   
6. 6   {   
   
7. 7      Fun();                     //界面主程序
   
8. 8   }
   0 R+ [' _0 b  W7 P2 R( u" z+ v
9. 9 }

复制代码

所以接下来我们主要看Fun.c里的Fun函数：虽然代码有点长，但是很好理解，其核心思路就是建立整个界面并对界面中的每个控件进行相关设置同时获得其句柄，在最后又进入了while死循环，在循环中不断检测2.4G是否接受到数据(和适配器端类似也是中断子程序中收数据然后置接收标志为1的),然后根据从2.4G收到的数据来刷新文本显示区；下面一个if判断speed_change_flag是否有效来向串口发送相应的数据。那么我们的问题又来了：这个speed_change_flag是在哪里被改变的呢？这个我们就要参看窗口回调函数了！这里的窗口回调函数是窗口动作响应函数（就像安卓开发里的按钮监听或MFC里的按钮点击事件等），一旦窗口里的控件有相应的触发动作就会调用该函数，并把事件类型封装在WM_MESSAGE里传过来，在该函数里对该消息进行解析并作出相应的动作即可(非常像Win32!!!我怀疑做这个uc-GUI的人有copy微软的嫌疑,♪(^∇^*)随便猜测，如有雷同，纯属巧合)。这样我们就很容易找到send按钮的监听用于将数据通过NRF24L01发送出去的相关操作，也就明白了滑动条监听用来改变speed1~5.上面说了这么多，少了介绍整个界面是怎么建立的了~其实整个窗体的布局都要放在一个结构体里，然后在fun()函数里调用hWin = GUI_CreateDialogBox(aDialogCreate, GUI_COUNTOF(aDialogCreate), _cbCallback, 0, 0, 0);根据定义的窗口资源和回调函数进行窗体的建立~这样我们就圆满地理解了stm32基于uc-OS并搭载uc-GUI的运行逻辑啦！

1.   1 void Fun(void) {   
   
2.   2   GUI_CURSOR_Show();                                        //打开鼠标图形显示  
   7 _5 U! I3 h7 b- |& B0 Z5 p# n
3.   3   
   " _2 c+ [) x! K8 E9 S. I
4.   4   /* 建立对话框时，包含了资源列表，资源数目， 并且指定了用于动作响应的回调函数  */
   + _2 V- j, k$ X# C. h3 d+ b. x$ ?
5.   5   hWin = GUI_CreateDialogBox(aDialogCreate, GUI_COUNTOF(aDialogCreate), _cbCallback, 0, 0, 0);
   
6.   6
   
7.   7   FRAMEWIN_SetFont(hWin, &GUI_FontComic18B_1);                  //对话框字体设置
   
8.   8   FRAMEWIN_SetClientColor(hWin, GUI_BLACK);                      //对话框的窗体颜色是黑色
   
9.   9   memcpy(tx_buf, "1234567890abcdefghij!@#$%^&*()-=", 32);   //将长度为32字节的发送字符串拷贝到发送缓冲区，
   
10. 10   memcpy(rx_buf, "", 32);                                    //将接收缓存区清空
    + \3 T! N! t+ ^1 c0 f1 Y) R
11. 11  
    # K) \. }9 [1 V2 c6 _
12. 12   /* 获得文本框句柄 */        
    
13. 13   text1 = WM_GetDialogItem(hWin, GUI_ID_TEXT0);                //获得对话框里GUI_ID_TEXT0项目(文本框Send Text Area)的句柄
    
14. 14   text2 = WM_GetDialogItem(hWin, GUI_ID_TEXT1);                //获得对话框里GUI_ID_TEXT1项目(文本框Receive Text Area)的句柄
    : `$ o" h) }: Z5 F  c$ U
15. 15   text3 = WM_GetDialogItem(hWin, GUI_ID_TEXT2);                //获得对话框里GUI_ID_TEXT2项目(文本框2M BPS)的句柄
    0 {  Z$ V5 P! [+ J, S- C/ ?
16. 16   text4 = WM_GetDialogItem(hWin, GUI_ID_TEXT3);                //获得对话框里GUI_ID_TEXT3项目(文本框1M BPS)的句柄
    " M2 O5 Y. v0 P: C% T5 I* a
17. 17   text6 = WM_GetDialogItem(hWin, GUI_ID_TEXT5);                //获得对话框里GUI_ID_TEXT5项目(文本框250K BPS)的句柄
    
18. 18   text5 = WM_GetDialogItem(hWin, GUI_ID_TEXT4);                //获得对话框里GUI_ID_TEXT4项目(状态字符文本框)的句柄  
    
19. 19   /* 设置文本框字体 */
    
20. 20   TEXT_SetFont(text1,pFont);                                //设置对话框里文本框Send Text Area的字体
    ! W( z, N  T7 h4 T. q8 e4 t. D; Z
21. 21   TEXT_SetFont(text2,pFont);                                //设置对话框里文本框Receive Text Area的字体
    
22. 22   TEXT_SetFont(text3,pFont18);                                //设置对话框里文本框2M BPS的字体
    : s$ h" V0 _& ~5 L( W8 K4 d  R. m
23. 23   TEXT_SetFont(text4,pFont18);                                //设置对话框里文本框1M BPS的字体
    
24. 24   TEXT_SetFont(text6,pFont18);                                //设置对话框里文本框250K BPS的字体
    8 @. e9 Z+ B& x; l, T
25. 25   TEXT_SetFont(text5,pFont);                                //设置对话框里状态字符文本框的字体
    . O8 k$ s  C7 F6 h1 j) f( i8 i
26. 26   /* 设置文本框颜色 */
    , `2 A3 U1 T1 @- c$ |1 w7 F8 l
27. 27   TEXT_SetTextColor(text1,GUI_GREEN);                        //设置对话框里文本框Send Text Area的字体颜色
    6 F; Z4 m9 l$ S' T# D5 q
28. 28   TEXT_SetTextColor(text2,GUI_GREEN );                        //设置对话框里文本框Receive Text Area的字体颜色
    
29. 29   TEXT_SetTextColor(text3,GUI_YELLOW);                        //设置对话框里文本框2M BPS的字体颜色
    0 G' S9 Z( L& b/ V+ ?: k
30. 30   TEXT_SetTextColor(text4,GUI_YELLOW);                        //设置对话框里文本框1M BPS的字体颜色
    ! T4 N3 _+ j% L$ M
31. 31   TEXT_SetTextColor(text6,GUI_YELLOW);                       //设置对话框里文本框250K BPS的字体颜色
    
32. 32   TEXT_SetTextColor(text5,GUI_YELLOW);                        //设置对话框里状态字符文本框的字体颜色
    
33. 33   TEXT_SetBkColor(text5,GUI_BLUE);                            //设置对话框里状态字符文本框的背景颜色
    ' }" K* v# S2 j" C+ k
34. 34
    
35. 35   /* 编辑框相关 */
    1 }3 z- d/ U2 v/ Z& \( i
36. 36   edit1 = WM_GetDialogItem(hWin, GUI_ID_EDIT1);                //获得对话框里GUI_ID_EDIT1项目(编辑框 发送字符串显示区)的句柄
    # Q3 ^6 p$ |3 w. B0 i0 }
37. 37   EDIT_SetFont(edit1,pFont18);                                //设置对话框里编辑框 发送字符串显示区的字体
    # d) q0 x: ^$ o/ g+ f" b2 M, V
38. 38   EDIT_SetText(edit1,(const char *)tx_buf);                    //设置对话框里编辑框 发送字符串显示区的字符串
    0 h( t- R. u, ^! i
39. 39   edit2 = WM_GetDialogItem(hWin, GUI_ID_EDIT2);                //获得对话框里GUI_ID_EDIT2项目(编辑框 接收字符串显示区)的句柄
    1 x" l4 y* U, a) f& d6 a# |' p& f
40. 40   EDIT_SetFont(edit2,pFont18);                                //设置对话框里编辑框 接收字符串显示区的字体
    & o5 `5 ~+ a7 c  ~3 q' `4 F8 X" ]5 D
41. 41   EDIT_SetText(edit2,(const char *)rx_buf);                    //设置对话框里编辑框 接收字符串显示区的字符串
    
42. 42
    
43. 43   /* 按钮相关 */
    
44. 44   bt[0]=WM_GetDialogItem(hWin,GUI_ID_BUTTON0);                //获得对话框里GUI_ID_BUTTON0项目(按键SEND)的句柄
    + b) n# V, v/ N
45. 45   bt[1]=WM_GetDialogItem(hWin, GUI_ID_BUTTON2);                //获得对话框里GUI_ID_BUTTON2项目(按键CLEAR)的句柄
    
46. 46   BUTTON_SetFont(bt[0],pFont);                                //设置对话框里按键SEND的字体
    
47. 47   BUTTON_SetFont(bt[1],pFont);                                //设置对话框里按键CLEAR的字体
    
48. 48   BUTTON_SetTextColor(bt[0],0,GUI_WHITE);                     //设置对话框里按键SEND未被按下的字体颜色
    
49. 49   BUTTON_SetTextColor(bt[1],0,GUI_WHITE);                    //设置对话框里按键CLEAR未被按下的字体颜色
    $ h- ]1 L9 O8 Q, S7 S% w$ @
50. 50
    3 s1 `2 C& L1 T# X! Q
51. 51   /* List相关 */            
    
52. 52   nrf_Pipe=0;                                                //NRF24L01初始发射通道设置为0
      y) h5 M( G, S( {
53. 53   list1 = WM_GetDialogItem(hWin, GUI_ID_LISTBOX0);            //获得对话框里GUI_ID_LISTBOX0项目(列表框-通道选择)的句柄     
    
54. 54   LISTBOX_SetText(list1, _apListBox);                        //设置对话框里列表框-通道选择里的条目
    
55. 55   LISTBOX_SetFont(list1,pFont18);                            //设置对话框里列表框-通道选择的字体
    
56. 56   LISTBOX_SetSel(list1,nrf_Pipe);                            //设置对话框里列表框-通道选择的焦点选择
    * W  w% \2 C! ~1 @% f
57. 57   SCROLLBAR_CreateAttached(list1, SCROLLBAR_CF_VERTICAL);    //设置对话框里列表框-通道选择的卷动方向为下拉        
    
58. 58
    0 ?, r5 l8 F" f, F6 B
59. 59   /* Radio按钮相关 */        
    
60. 60   rd0 = WM_GetDialogItem(hWin, GUI_ID_RADIO0);                //获得对话框里GUI_ID_RADIO0项目(点选框-速率选择)的句柄
    
61. 61   nrf_baud=0;                                                //NRF24L01速率 初始为2MPS
    
62. 62   RADIO_SetValue(rd0,0);                                    //设置对话框里点选框-速率选择的焦点选择
    # _: L9 E7 r/ E- t% ?3 m6 G3 P
63. 63   RX_Mode();                                                //NRF24L01进入接收模式
    
64. 64  
    
65. 65   /* 获得slider部件的句柄 */   
    
66. 66   slider1 = WM_GetDialogItem(hWin, GUI_ID_SLIDER1);
    
67. 67   slider2 = WM_GetDialogItem(hWin, GUI_ID_SLIDER2);
    
68. 68   slider3 = WM_GetDialogItem(hWin, GUI_ID_SLIDER3);
    " q0 q( I' v. z6 t! o' y* l
69. 69   slider4 = WM_GetDialogItem(hWin, GUI_ID_SLIDER4);
    
70. 70   slider5 = WM_GetDialogItem(hWin, GUI_ID_SLIDER5);
    
71. 71   /* 设置slider部件的取值范围-8-8*/  
    ( z3 n1 c! p) w: t3 e3 ~- T
72. 72   SLIDER_SetRange(slider1,-8,8);   
    
73. 73   SLIDER_SetRange(slider2,-8,8);
    
74. 74   SLIDER_SetRange(slider3,-8,8);
    
75. 75   SLIDER_SetRange(slider4,-8,8);
    & a/ h5 G8 H; }6 p8 M( h
76. 76   SLIDER_SetRange(slider5,-8,8);
    
77. 77   /* 设置slider部件的值*/      
    
78. 78   SLIDER_SetValue(slider1,0);  
    + X( I6 C4 K% k* r/ Q9 g
79. 79   SLIDER_SetValue(slider2,0);   
    5 i; C& d1 h  ]# k2 J. o% |( O
80. 80   SLIDER_SetValue(slider3,0);  
    
81. 81   SLIDER_SetValue(slider4,0);  
    2 N. [) u" }8 [; K! V7 T
82. 82   SLIDER_SetValue(slider5,0);  
    
83. 83   /* 获取文本框句柄 */
      H& \* ?9 W( P" Y  l# F
84. 84   text_speed1 = WM_GetDialogItem(hWin, GUI_ID_TEXT_SPEED1);   
    
85. 85   text_speed2 = WM_GetDialogItem(hWin, GUI_ID_TEXT_SPEED2);   
    5 X/ V9 g; y/ L4 l" A- K
86. 86   text_speed3 = WM_GetDialogItem(hWin, GUI_ID_TEXT_SPEED3);   
    % S, t) ], z' S* q+ [. n# f" K; x2 P
87. 87   text_speed4 = WM_GetDialogItem(hWin, GUI_ID_TEXT_SPEED4);   
    . n9 n9 ]  i" q0 e! L
88. 88   text_speed5 = WM_GetDialogItem(hWin, GUI_ID_TEXT_SPEED5);   
    
89. 89   /* 设置文本框字体 */
    2 m2 u' m) Q4 m
90. 90   TEXT_SetFont(text_speed1,pFont18);
    # ]5 P* Z2 [  F! A& y
91. 91   TEXT_SetFont(text_speed2,pFont18);
    
92. 92   TEXT_SetFont(text_speed3,pFont18);
    : `# I$ K( o& \- S
93. 93   TEXT_SetFont(text_speed4,pFont18);
    
94. 94   TEXT_SetFont(text_speed5,pFont18);                                    
    
95. 95   /* 设置文本框颜色 */
    ) ?; l. {, {0 L& e: O
96. 96   TEXT_SetTextColor(text_speed1,GUI_YELLOW);        
    
97. 97   TEXT_SetTextColor(text_speed2,GUI_YELLOW);        
      r& c# ]( e" f: o0 `) W: {
98. 98   TEXT_SetTextColor(text_speed3,GUI_YELLOW);        
    : W0 x$ i3 k1 r$ Y" Y$ I% }
99. 99   TEXT_SetTextColor(text_speed4,GUI_YELLOW);        
    
100. 100   TEXT_SetTextColor(text_speed5,GUI_YELLOW);        
     2 B0 r, T1 y( j" w) f% J6 \+ L& e1 E$ x
101. 101
     ( d1 I: [/ ]2 }+ T9 M! l- n
102. 102   speed_change_flag=0;
     
103. 103
     # g9 g) G2 @/ Y) \7 Q
104. 104   while (1)
     
105. 105   {               
     
106. 106     if(Rx_Succ==1){                                            //当NRF24L01接收到有效数据
     1 }1 ~2 S0 v3 l& P' x' @6 H
107. 107         EDIT_SetText(edit2,(const char *)rx_buf);            //将接收缓冲区的字符写入到接收字符编辑框内
     
108. 108         TEXT_SetText(text5,(const char *)status_buf);        //将状态文本缓冲区的字符写入到状态文本框内
     
109. 109         Rx_Succ=0;
     : ?! |5 T% c2 l$ N6 O$ U
110. 110 //        for(i=0;i<sizeof(rx_buf);i++)        
     
111. 111 //            USART_SendChar(USART1,rx_buf[i]);
     . V9 c: h4 H4 I" G0 h3 J" `
112. 112     }
     # z/ n: N; b3 W7 ?. K8 L
113. 113     if(speed_change_flag!=0)
     
114. 114     {
     
115. 115        speed_change_flag=0;
     
116. 116        USART_SendChar(USART1,control_data);
     ; P, s% K: V8 Y. \4 x1 E
117. 117     }
       d3 F) B; }7 `: t" x( I1 q0 M
118. 118     WM_Exec();                                                //刷新屏幕
     ' W6 t; l7 [1 c! m
119. 119   }      
     ' w  ]; Q" K$ O7 G6 L
120. 120 }

复制代码

1. 1 /* 定义了对话框资源列表 */
   
2. 2 static const GUI_WIDGET_CREATE_INFO aDialogCreate[] = {
   6 q1 W+ ^1 C4 `! a; i8 R6 M( A( J
3. 3   //建立窗体， 大小是800X480  原点在0，0
   5 H4 o) C+ O+ ]0 {* q* s/ X
4. 4   { FRAMEWIN_CreateIndirect, "http://beautifulzzzz", 0,0,0, 800, 480, FRAMEWIN_CF_ACTIVE },
   
5. 5   { BUTTON_CreateIndirect,   "SEND",    GUI_ID_BUTTON0,       0,    395,  200,  55 },
   
6. 6  
   & J  T! v2 g: J7 ~' q* j8 S3 j
7. 7   { BUTTON_CreateIndirect,   "CLEAR", GUI_ID_BUTTON2,   200,    395, 200,  55 },
   
8. 8   { EDIT_CreateIndirect,     "",       GUI_ID_EDIT1,    0,   190, 400,  65, EDIT_CF_LEFT, 50 },
     ~" V7 ^: w+ X( _& M- I9 X
9. 9   { EDIT_CreateIndirect,     "",       GUI_ID_EDIT2,    0,   290, 400,  65, EDIT_CF_LEFT, 50 },
   % N0 \6 A( _. j; B" o
10. 10   
    7 e" D& Z8 Q9 h9 \5 q4 d% N
11. 11   //建立TEXT控件，起点是窗体的X，X，大小XXY  文字左对齐
    
12. 12   { TEXT_CreateIndirect,     "Send Text Area",  GUI_ID_TEXT0,   1,   160,  400,  25, TEXT_CF_LEFT },
    
13. 13   { TEXT_CreateIndirect,     "Receive Text Area ",  GUI_ID_TEXT1,     1,   263,  400, 25, TEXT_CF_LEFT },
    
14. 14  
    
15. 15   { TEXT_CreateIndirect,     "2M bps",  GUI_ID_TEXT2,   23,   22,  140,  25, TEXT_CF_LEFT },
    
16. 16   { TEXT_CreateIndirect,     "1M bps",  GUI_ID_TEXT3,     23,   42,  140,  25, TEXT_CF_LEFT },
    / H/ @  `" y# \9 ]& M- s
17. 17   { TEXT_CreateIndirect,     "250K bps",  GUI_ID_TEXT5,     23,   62,  140,  25, TEXT_CF_LEFT },
    & n" ^2 w* h. A) T4 ]: Y  M
18. 18   
    
19. 19   { TEXT_CreateIndirect,     "",  GUI_ID_TEXT4,     0,   120,  400,  25, TEXT_CF_LEFT },
    ! S4 a" x1 R& a/ o2 w
20. 20
    " W( P; l% I0 l0 T
21. 21   { RADIO_CreateIndirect,     "Receive Mode",  GUI_ID_RADIO0,     3,   33,  40,  52, RADIO_TEXTPOS_LEFT,3},
    / Z! g! z$ Y* w' l! ?
22. 22
    
23. 23   { LISTBOX_CreateIndirect,  "",       GUI_ID_LISTBOX0,  134,    13,  130,  90, 0, 0 },
    ! c9 j( n0 x& m& e; h8 ^1 R$ `+ J
24. 24
    
25. 25    //建立滑块
    
26. 26   { SLIDER_CreateIndirect,   NULL,     GUI_ID_SLIDER1,  440,  60, 320, 25, 0, 0 },
    
27. 27   { SLIDER_CreateIndirect,   NULL,     GUI_ID_SLIDER2,  440,  120, 320, 25, 0, 0 },
    + A, `9 h% \" x! |9 k
28. 28   { SLIDER_CreateIndirect,   NULL,     GUI_ID_SLIDER3,  440,  180, 320, 25, 0, 0 },
    2 |2 I$ {8 |2 {  H6 n, N
29. 29   { SLIDER_CreateIndirect,   NULL,     GUI_ID_SLIDER4,  440,  240, 320, 25, 0, 0 },
    $ O8 }6 J6 J9 }, b  _5 L& A
30. 30   { SLIDER_CreateIndirect,   NULL,     GUI_ID_SLIDER5,  440,  300, 320, 25, 0, 0 },
    
31. 31   //建立滑块对应的text
    * u5 n* m& P2 t
32. 32   { TEXT_CreateIndirect,     "0",  GUI_ID_TEXT_SPEED1,   770,   60,   25,  25, TEXT_CF_LEFT },
    
33. 33   { TEXT_CreateIndirect,     "0",  GUI_ID_TEXT_SPEED2,   770,   120,  25,  25, TEXT_CF_LEFT },
    
34. 34   { TEXT_CreateIndirect,     "0",  GUI_ID_TEXT_SPEED3,   770,   180,  25,  25, TEXT_CF_LEFT },
    " M5 R, m7 u" ^# b( q5 I" L
35. 35   { TEXT_CreateIndirect,     "0",  GUI_ID_TEXT_SPEED4,   770,   240,  25,  25, TEXT_CF_LEFT },
    
36. 36   { TEXT_CreateIndirect,     "0",  GUI_ID_TEXT_SPEED5,   770,   300,  25,  25, TEXT_CF_LEFT },
    ) w6 b1 F" Z8 N' z: V
37. 37 };

复制代码

还要回过头说说我们的USART和NRF24L01，他们的初始化要看main函数中的BSP_Init();函数，该函数负相关硬件的初始化设置（中文意思是板级支持包初始化函数，因为uc-OS可以并不只限于stm32单片机，所以这里要根据不同平台进行相应的设置）。该函数位于bsp.c函数中，其作用相当于将以前我们在main函数中进行的相关硬件初始化单独拿出来封装成一个函数而已~但是，串口和无线对应的中断接收程序却有点不一样，因为这里是操作系统，所以在每个中断子程序前要调用OS_ENTER_CRITICAL();保存当前的全局中断标志，然后OSIntNesting++;中断嵌套深度加1，最后调用OS_EXIT_CRITICAL();恢复全局中断标志进入正常的中断处理，此外在中断响应函数最后要调用OSIntExit(); 检测如果有更高优先级的任务就绪了,则执行一次任务切换。  

1. 1 /*******************************************************************************
   
2. 2 * Function Name  : USART1_IRQHandler
   & Z" w* t, c9 f* X. S) n( z
3. 3 * Description    : This function handles USART1 global interrupt request.
   
4. 4 * Input          : None
   
5. 5 * Output         : None
   
6. 6 * Return         : None
   
7. 7 *******************************************************************************/
   
8. 8 void USART1_IRQHandler(void)
   * ^6 A( u& h  V; y) t5 Z/ s2 p( w
9. 9 {
   
10. 10     unsigned int i;
    
11. 11     OS_CPU_SR  cpu_sr;
    
12. 12     OS_ENTER_CRITICAL();  //保存全局中断标志,关总中断 Tell uC/OS-II that we are starting an ISR
    # J; ~$ S1 f+ {/ p5 P6 @
13. 13     OSIntNesting++;
    7 n7 q9 _$ m0 R0 e; I1 i
14. 14     OS_EXIT_CRITICAL();      //恢复全局中断曛?        
    
15. 15
    
16. 16     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)       //判断读寄存器是否非空
    8 Z9 w+ E- p9 W$ |- @) l
17. 17     {   
    ! a- X. V$ u+ O+ L0 ?
18. 18         RxBufferUSART[RxCounter1++] = USART_ReceiveData(USART1);   //将读寄存器的数据缓存到接收缓冲区里
    / O+ U+ M, b6 e' O! p
19. 19         if(RxBufferUSART[RxCounter1-2]==0x0d&&RxBufferUSART[RxCounter1-1]==0x0a)     //判断结束标志是否是0x0d 0x0a
    
20. 20         {
    
21. 21             for(i=0; i< RxCounter1; i++) TxBufferRF[i] = RxBufferUSART[i];          //将接收缓冲器的数据转到发送缓冲区，准备转发
    
22. 22             usart_rec_flag=1;                                                             //接收成功标志
    
23. 23             TxBufferRF[RxCounter1]=0;                                             //发送缓冲区结束符   
    
24. 24             TxCounter1=RxCounter1;
    ) x- O" C1 o( c# M8 C
25. 25             RxCounter1=0;
    2 ]) w, i: e5 c) f5 `' Z7 G) m1 P
26. 26         }
    ; m; L& ~4 h# b3 \: O# |
27. 27     }
    
28. 28     if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)                   //这段是为了避免STM32 USART 第一个字节发不出去的BUG
    
29. 29     {
    8 E: H0 m8 [. l3 M* \
30. 30         USART_ITConfig(USART1, USART_IT_TXE, DISABLE);                         //禁止发缓冲器空中断，
    
31. 31     }   
    
32. 32     OSIntExit();           //在os_core.c文件里定义,如果有更高优先级的任务就绪了,则执行一次任务切换   
    
33. 33 }
    
34. 34 /////////////////////////////
    $ S7 F. R8 Y9 _5 Q( f! E
35. 35 void EXTI0_IRQHandler(void)
    & A7 K" t! H* E$ j
36. 36 {
    
37. 37   unsigned char status,i;
    
38. 38   OS_CPU_SR  cpu_sr;
    8 j- e$ a0 ?  z5 g+ @# T; f" L
39. 39   OS_ENTER_CRITICAL();  //保存全局中断标志,关总中断 Tell uC/OS-II that we are starting an ISR
    
40. 40   OSIntNesting++;
    
41. 41   OS_EXIT_CRITICAL();      //恢复全局中断标志            
    . E+ D/ k9 g. v- b" }: a: g3 v
42. 42   
    8 Q5 i% _8 i( }% m" \; r8 K
43. 43   if(EXTI_GetITStatus(EXTI_Line0) != RESET)            //判断是否产生了EXTI0中断
    
44. 44   {
    - a9 |) D: p5 G4 K# Q4 i
45. 45       if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)==0){ //判断是否是PA0线变低            
    & A6 i5 _8 F3 T1 Q8 r
46. 46         status=SPI_Read(READ_REG1+STATUS);            // 读取状态寄存其来判断数据接收状况   
    - C2 t9 T9 M% A% O  n0 w
47. 47         if(status & 0x40)                            // 判断是否接收到数据                  
    - G+ G" l+ j1 k( W/ C5 |
48. 48         {                                                         
    , J& j5 S+ I! x# T* N4 `
49. 49              SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);  //从接收缓冲区里读出数据
    
50. 50             for(i=0; i<32; i++){                              //向USB 端点1的缓冲区里放置数据
    ( |/ Q2 X+ M' c4 K
51. 51                 TxBufferUSART[i] = rx_buf[i];     
    
52. 52             }
    * c% G( y  E' L; d2 f; H
53. 53             rf_rec_flag=1;         
    ' {: b  o% }! l1 Y
54. 54             if((status&0x0e)<=0x0a){                           
    
55. 55                nrf_Pipe_r=(status&0x0e)>>1;                      //读出是在哪个通道接收的
    
56. 56             }
    ) x% ?* @+ ~% w
57. 57             else nrf_Pipe_r=0;                     
    
58. 58             Rx_Succ=1;            //读取数据完成标志
    4 v7 \8 A) [7 l6 N0 X8 o+ u% _
59. 59             /* 根据读出的接收通道号，将相应信息写入状态文本缓冲区 */
    . J0 N, M, }* Y
60. 60             if(nrf_Pipe_r==0) memcpy(status_buf, "Pipe 0 Recive OK!   ", 20);           
    
61. 61             else if(nrf_Pipe_r==1) memcpy(status_buf, "Pipe 1 Recive OK!   ", 20);
    
62. 62             else if(nrf_Pipe_r==2) memcpy(status_buf, "Pipe 2 Recive OK!   ", 20);
    
63. 63             else if(nrf_Pipe_r==3) memcpy(status_buf, "Pipe 3 Recive OK!   ", 20);
    8 V# ?9 i% ?  i: n& u' K2 q8 s
64. 64             else if(nrf_Pipe_r==4) memcpy(status_buf, "Pipe 4 Recive OK!   ", 20);
    
65. 65             else if(nrf_Pipe_r==5) memcpy(status_buf, "Pipe 5 Recive OK!   ", 20);
    
66. 66         }
    9 @1 a' P2 Z) }4 V5 H! s+ b
67. 67         else if((status &0x10)>0){                     //发射达到最大复发次数               
    
68. 68             SPI_RW_Reg(0xe1,0);                          //清除发送缓冲区                  
    
69. 69             RX_Mode();                                 //进入接收模式                                 
    0 ?/ Q' Y0 I0 Y8 O! D
70. 70             Rx_Succ=1;                                                                                    
    ! r, P4 j+ ^/ X! D3 n
71. 71             /* 根据发送通道，将相应信息写入状态文本缓冲区 */
    
72. 72             if(nrf_Pipe==0) memcpy(status_buf, "Pipe 0 NO ACK!      ", 20);
    
73. 73             else if(nrf_Pipe==1) memcpy(status_buf, "Pipe 1 NO ACK!      ", 20);
    3 T8 Y& k: z: [# y( m! z
74. 74             else if(nrf_Pipe==2) memcpy(status_buf, "Pipe 2 NO ACK!      ", 20);
    
75. 75             else if(nrf_Pipe==3) memcpy(status_buf, "Pipe 3 NO ACK!      ", 20);  
    
76. 76             else if(nrf_Pipe==4) memcpy(status_buf, "Pipe 4 NO ACK!      ", 20);
    . L; v$ X: G. D% G' x* |9 a/ m2 U
77. 77             else if(nrf_Pipe==5) memcpy(status_buf, "Pipe 5 NO ACK!      ", 20);            
    
78. 78         }
    & r: K+ R* w8 c" k$ m9 E! \& y, O7 S
79. 79         else if((status &0x20)>0){                     //发射后收到应答            
    
80. 80             SPI_RW_Reg(0xe1,0);                         //清除发送缓冲区              
    
81. 81             RX_Mode();                                 //进入接收模式
    ) Z2 c  X! [+ H: O, c6 O4 c5 p
82. 82             Rx_Succ=1;
    / C1 D  z3 N% N3 ^
83. 83             /* 根据发送通道，将相应信息写入状态文本缓冲区 */
    " v' b) U/ d8 ~
84. 84             if(nrf_Pipe==0) memcpy(status_buf, "Pipe 0 Send OK!     ", 20);
    
85. 85             else if(nrf_Pipe==1) memcpy(status_buf, "Pipe 1 Send OK!     ", 20);
    / M5 A4 ]! Y4 t; S  n& o
86. 86             else if(nrf_Pipe==2) memcpy(status_buf, "Pipe 2 Send OK!     ", 20);
    : M% L6 I% n; u* A2 {5 q& r$ a
87. 87             else if(nrf_Pipe==3) memcpy(status_buf, "Pipe 3 Send OK!     ", 20);
    * n2 z; P2 _! ?; r2 M2 ]% T/ Y% |
88. 88             else if(nrf_Pipe==4) memcpy(status_buf, "Pipe 4 Send OK!     ", 20);
    ' S% @, `, C" o- E9 X- U" P( R' |
89. 89             else if(nrf_Pipe==5) memcpy(status_buf, "Pipe 5 Send OK!     ", 20);               
    
90. 90         }
    
91. 91         
    
92. 92         SPI_RW_Reg(WRITE_REG1+STATUS, status);         //清除07寄存器标志              
    ( {1 Y8 m+ j% o8 a% \1 t
93. 93       }        
    
94. 94       EXTI_ClearITPendingBit(EXTI_Line0);             //清除EXTI0上的中断标志              
    
95. 95   }   
    2 A7 s6 L9 _0 O: |3 T
96. 96   OSIntExit();           //在os_core.c文件里定义,如果有更高优先级的任务就绪了,则执行一次任务切换     
    
97. 97 }

复制代码

最后说明

对于纯玩软件的小伙伴，这里涉及的东西有点多，不必细究，看看了解即可。但是对于初学stm32,尤其是还在为stm32控制NRF24L01不通的同学，这个还是挺有用滴~下面有工程的链接，里面有些注释不规范，一切以我博客里说的为准哦~