串口发送数据1、串口发送数据最直接的方式就是标准调用库函数 。
& w' G: P5 o( X7 o1 G1 w) w

1. void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

复制代码

) r1 Q  k+ g' w) U

第一个参数是发送的串口号，第二个参数是要发送的数据了。但是用过的朋友应该觉得不好用，一次只能发送单个字符，所以我们有必要根据这个函数加以扩展：

1. void Send_data(u8 *s)
   1 @- H+ f# G' m* o- ]2 j; f3 m
2. {
   
3. while(*s!='\0')
   
4. {
   # i5 s4 i$ ]+ f1 ?% M$ i7 E1 R
5.   while(USART_GetFlagStatus(USART1,USART_FLAG_TC )==RESET);
   
6.   USART_SendData(USART1,*s);
   ' X3 y$ d2 ]3 I0 k' k$ N# K& u
7.   s++;
   ; J* \2 E* X- x$ [, m3 T$ |, M5 {# M
8. }
   " b$ i- v! B: p: a3 j
9. }

复制代码

以上程序的形参就是我们调用该函数时要发送的字符串，这里通过循环调用USART_SendData来一 一发送我们的字符串。

while(USART_GetFlagStatus(USART1,USART_FLAG_TC )==RESET);
, J; K6 T5 t' c$ Z' s8 A

这句话有必要加，他是用于检查串口是否发送完成的标志，如果不加这句话会发生数据丢失的情况。这个函数只能用于串口1发送。有些时候根据需要，要用到多个串口发送那么就还需要改进这个程序。如下：

1. void Send_data(USART_TypeDef * USARTx,u8 *s)
   
2. {
   
3. while(*s!='\0')
   9 ^* r; V; c- R5 W1 b6 P
4. {
   4 K1 k+ A2 |4 G( q/ z
5.   while(USART_GetFlagStatus(USARTx,USART_FLAG_TC )==RESET);
   " d6 q0 b/ c( a' I) d  U
6.   USART_SendData(USARTx,*s);
   
7.   s++;
   
8. }
   ) }1 z9 v+ Q* C3 i# _  O6 x, `4 t
9. }

复制代码

! o0 ?4 ^# |' C5 L! _& L) y

这样就可实现任意的串口发送。但有一点，我在使用实时操作系统的时候（如UCOS,Freertos等），需考虑函数重入的问题。

当然也可以简单的实现把该函数复制一下，然后修改串口号也可以避免该问题。然而这个函数不能像printf那样传递多个参数，所以还可以在改进，最终程序如下：

1. void USART_printf ( USART_TypeDef * USARTx, char * Data, ... )
   
2. {
   6 Z, H& T( S$ d) N  k7 z
3. const char *s;
   
4. int d;   
   & l2 i% j! r7 k
5. char buf[16];
   7 R$ [! A" M1 P' d5 _3 F
6. 
   9 [4 H: d+ L3 }5 E2 g. p& @! C1 [
7. va_list ap;
   
8. va_start(ap, Data);
   9 T& W/ K4 p! b1 V. i7 _
9. 
   8 H; c- R* t- J. j7 c0 M5 G; j
10. while ( * Data != 0 )     // 判断是否到达字符串结束符
    
11. {                              
    
12.   if ( * Data == 0x5c )  //'\'
    
13.   {           
    
14.    switch ( *++Data )
    
15.    {
    - \; h$ _5 B- o. U! j
16.     case 'r':                 //回车符
    $ D6 g7 [% m* d8 Y/ |: ]
17.     USART_SendData(USARTx, 0x0d);
    8 V! r2 G+ |- L9 r& ?* v4 Y
18.     Data ++;
      j+ \# R0 \0 V& ?; o
19.     break;
    + P+ F7 H" x. k( G% l6 ~
20. 
    / ?% u. x+ J  s4 L7 D. L" {4 G
21.     case 'n':                 //换行符
    
22.     USART_SendData(USARTx, 0x0a);
    
23.     Data ++;
    3 a/ b6 d- c: Z, O# v
24.     break;
    7 z& {2 I$ L6 }; ^( _6 P
25. 
    2 z- ]+ ]& r' p: ]  K" r
26.     default:
    
27.     Data ++;
    
28.     break;
    
29.    }   
    0 ^, f1 d: Q5 Q; A; F
30.   }
    
31.   
    
32.   else if ( * Data == '%')
    * h; {! M9 C' r
33.   {           //
    
34.    switch ( *++Data )
    & \: z6 r" w2 S( P( V' C9 m5 m
35.    {   
    # ]7 b% F" ]  W- N+ u
36.     case 's':            //字符串
    
37.     s = va_arg(ap, const char *);
    
38.    
      H% {1 J' T3 `- D* V( k% x
39.     for ( ; *s; s++)
    . H0 u/ L5 G+ ]& ^
40.     {
    - a7 ~# b& d+ [4 _0 S: P# J, U% q. R
41.      USART_SendData(USARTx,*s);
    
42.      while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
    
43.     }
    * ]2 y" z- z1 q/ Z4 o
44.    
    
45.     Data++;
    ; n3 Q- I& _% E
46.    
    7 |! q9 q9 a3 {
47.     break;
    - s/ U/ o, u) Q3 C
48. 
    
49.     case 'd':   
    5 v3 L' r. u7 h
50.      //十进制
    
51.     d = va_arg(ap, int);
    0 T0 ^  d: U2 ?% M* j* O
52.    
    - _% V+ Y0 o3 M7 @: I3 [& z
53.     itoa(d, buf, 10);
    
54.    
    
55.     for (s = buf; *s; s++)
    5 i$ ^% U  A/ `6 J6 }' w8 n
56.     {
    8 o) J2 Z$ s9 H& n1 _
57.      USART_SendData(USARTx,*s);
    % s' U5 i$ ~. V' T. f4 \& c; u5 G
58.      while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
    
59.     }
    ! ?1 c! d2 D, M7 A, A: N
60.    
    
61.     Data++;
    ) P% L+ }7 n/ r
62.    
    6 X' a/ y- Z. o* N
63.     break;
    
64.    
    
65.     default:
    4 L0 M' S: d# @* m
66.     Data++;
    
67.    
    
68.     break;
    1 j. h0 x$ P! J7 x% X  A( t
69.    
    . O7 f* C" X8 |( ]
70.    }   
    / x3 @1 E3 O" U1 P1 _2 K
71.   }
    
72.   
    
73.   else USART_SendData(USARTx, *Data++);
    
74.   
    
75.   while ( USART_GetFlagStatus ( USARTx, USART_FLAG_TXE ) == RESET );
    
76.   
    , O) d, O9 W9 X' R) F
77. }
    
78. }

复制代码

5 ]) [7 c! \1 h' L. ]" f4 D

该函数就可以像printf使用可变参数，方便很多。通过观察函数但这个函数只支持了%d,%s的参数，想要支持更多，可以仿照printf的函数写法加以补充。

! X% ?# m+ Z* F; Y

2、 直接使用printf函数。

很多朋友都知道想要STM32要直接使用printf不行的。需要加上以下的重映射函数：

3 `9 m5 Y/ \$ z, _% u8 k2 `7 t

如果不想添加以上代码，也可以勾选以下的Use MicroLI选项来支持printf函数使用：

3 P- a) O1 a% D0 E8 W2 Z

串口接收数据

串口接收最后应有一定的协议，如发送一帧数据应该有头标志或尾标志，也可两个标志都有。

这样在处理数据时既能能保证数据的正确接收，也有利于接收完后我们处理数据。串口的配置在这里就不在赘述，这里我以串口2接收中断服务程序函数且接收的数据包含头尾标识为例。

1. #define Max_BUFF_Len 18
   ; {" B! A5 R& e+ d+ J
2. unsigned char Uart2_Buffer[Max_BUFF_Len];
   
3. unsigned int Uart2_Rx=0;
   ) \/ Q3 Z  \) M1 ]; w
4. void USART2_IRQHandler()
   $ u5 c1 V- r$ h$ ^
5. {
   - G7 w7 |; u' w2 S; i2 @, I/ w
6. if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET) //中断产生
   
7. {
   8 R$ Y5 e* H9 `. S
8.   USART_ClearITPendingBit(USART2,USART_IT_RXNE); //清除中断标志
   : q5 q* j4 d$ s" {6 l, L
9.    
   
10.   Uart2_Buffer[Uart2_Rx] = USART_ReceiveData(USART2);     //接收串口1数据到buff缓冲区
    4 @4 P3 d% Z2 j; A4 R+ I
11.   Uart2_Rx++;
    ! k, \0 E7 D9 Q2 l
12.         
    5 U; _) i& Y/ ]+ S
13.   if(Uart2_Buffer[Uart2_Rx-1] == 0x0a || Uart2_Rx == Max_BUFF_Len)    //如果接收到尾标识是换行符（或者等于最大接受数就清空重新接收）
    
14.   {
    
15.    if(Uart2_Buffer[0] == '+')                      //检测到头标识是我们需要的
    
16.    {
    
17.     printf("%s\r\n",Uart2_Buffer);        //这里我做打印数据处理
    
18.     Uart2_Rx=0;                                   
    
19.    }
    . Z; f2 S0 z+ B4 l
20.    else
    
21.    {
    
22.     Uart2_Rx=0;                                   //不是我们需要的数据或者达到最大接收数则开始重新接收
    
23.    }
    
24.   }
    
25. }
    ; Q. ]. a* d' J, n( h
26. }

复制代码

" ]( y# K; [' W& ]3 y

数据的头标识为“\n”，即换行符，尾标识为“+”。该函数将串口接收的数据存放在USART_Buffer数组中，然后先判断当前字符是不是尾标识，如果是说明接收完毕，然后再来判断头标识是不是“+”号，如果还是那么就是我们想要的数据，接下来就可以进行相应数据的处理了。但如果不是那么就让Usart2_Rx=0重新接收数据。

这样做的有以下好处：

• 可以接受不定长度的数据，最大接收长度可以通过Max_BUFF_Len来更改

• 可以接受指定的数据

• 防止接收的数据使数组越界

  
  & v) @; M; R7 G* Q7 j
  

这里我的把接受正确数据直接打印出来，也可以通过设置标识位，然后在主函数里面轮询再操作。

以上的接收形式，是中断一次就接收一个字符，这在UCOS等实时内核系统中频繁的中断，非常消耗CPU资源，在有些时候我们需要接收大量数据时且波特率很高的情况下，长时间中断会带来一些额外的问题。

所以以DMA形式配合串口的IDLE（空闲中断）来接受数据将会大大的提高CPU的利用率，减少系统资源的消耗。首先还是先看代码。

1. #define DMA_USART1_RECEIVE_LEN 18
   * b5 s6 U: [4 `) o3 |* d
2. void USART1_IRQHandler(void)                                 
   
3. {     
   7 L. Y; |) f" x: G/ v6 ^
4.     u32 temp = 0;  
   : Z; v+ j& r/ [# r8 G
5.     uint16_t i = 0;  
   
6.       
   8 y8 B- y& c0 f* e1 a
7.     if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)  
   
8.     {  
   ' H8 j( E7 ]1 }
9.         USART1->SR;  
   
10.         USART1->DR; //这里我们通过先读SR（状态寄存器）和DR（数据寄存器）来清USART_IT_IDLE标志   
    
11.         DMA_Cmd(DMA1_Channel5,DISABLE);  
    
12.         temp = DMA_USART1_RECEIVE_LEN - DMA_GetCurrDataCounter(DMA1_Channel5); //接收的字符串长度=设置的接收长度-剩余DMA缓存大小
    
13.         for (i = 0;i < temp;i++)  
    
14.         {  
    & s8 }+ y- g. r
15.             Uart2_Buffer = USART1_RECEIVE_DMABuffer;  
    
16.                
    5 Q  W% ^; n0 u6 o
17.         }  
    2 v* i6 k6 A( O( |  ~
18.         //设置传输数据长度  
    & [, x; j# n, E5 d2 J6 {
19.         DMA_SetCurrDataCounter(DMA1_Channel5,DMA_USART1_RECEIVE_LEN);  
    ! `, h/ X! u8 ]1 R& u
20.         //打开DMA  
    
21.         DMA_Cmd(DMA1_Channel5,ENABLE);  
    9 X6 C* [6 O2 C- C( W% K5 W& M
22.     }        
    
23. }

复制代码

之前的串口中断是一个一个字符的接收，现在改为串口空闲中断，就是一帧数据过来才中断进入一次。而且接收的数据时候是DMA来搬运到我们指定的缓冲区（也就是程序中的USART1_RECEIVE_DMABuffer数组），是不占用CPU时间资源的。

最后在讲下DMA的发送：

1. #define DMA_USART1_SEND_LEN 64
   
2. void DMA_SEND_EN(void)
   ' D% t4 @6 D+ e5 R2 Z# ^
3. {
   
4. DMA_Cmd(DMA1_Channel4, DISABLE);      
   
5. DMA_SetCurrDataCounter(DMA1_Channel4,DMA_USART1_SEND_LEN);   
   
6. DMA_Cmd(DMA1_Channel4, ENABLE);
   . G  J7 F( e) [7 K  Q# Z
7. }

复制代码

3 s% P/ E4 C2 }$ I

这里需要注意下DMA_Cmd(DMA1_Channel4,DISABLE)函数需要在设置传输大小之前调用一下，否则不会重新启动DMA发送。

有了以上的接收方式，对一般的串口数据处理是没有问题的了。下面再讲一下，在ucosiii中我使用信号量+消息队列+储存管理的形式来处理我们的串口数据。先来说一下这种方式对比其他方式的一些优缺点。

一般对串口的处理形式是"生产者"和"消费者"的模式,即本次接收的数据要马上处理，否则当数据大量涌进的时候，就来不及"消费"掉生产者（串口接收中断）的数据，那么就会丢失本次的数据处理。所以使用队列就能够很方便的解决这个问题。

在下面的程序中，对数据的处理是先接受，在处理，如果在处理的过程中，有串口中断接受数据，那么就把它依次放在队列中，队列的特征是先进先出，在串口中就是先处理先接受的数据，所以根据生产和消费的速度，定义不同大小的消息队列缓冲区就可以了。缺点就是太占用系统资源，一般51单片机是没可能了。下面是从我做的项目中截取过来的程序：

1. OS_MSG_SIZE  Usart1_Rx_cnt;          //字节大小计数值
   8 I- P9 w4 }( D2 c! i
2. unsigned char Usart1_data;           //每次中断接收的数据
   
3. unsigned char* Usart1_Rx_Ptr;        //储存管理分配内存的首地址的指针
   
4. unsigned char* Usart1_Rx_Ptr1;       //储存首地址的指针
   & q4 c1 j: S1 w% A
5. 
   
6. void USART1_IRQHandler()
   
7. {
   
8. OS_ERR err;
   
9. OSIntEnter();
   
10. 
      H" Q' h& k( M3 V$ A
11.   if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) != RESET) //中断产生
    , b$ m; I! `* A8 ?. ^1 u" u6 c
12.   {   
    
13.     USART_ClearFlag(USART1, USART_FLAG_RXNE);     //清除中断标志
    $ u5 r, [- O5 z, d* A
14.   
    
15.     Usart1_data = USART_ReceiveData(USART1);     //接收串口1数据到buff缓冲区
    7 ?) o3 c. s' @: I1 C
16.   
    
17.   if(Usart1_data =='+')                     //接收到数据头标识
    0 w% `8 J7 y. ^6 q5 x1 N
18.   {
    
19. //   OSSemPend((OS_SEM*  )&SEM_IAR_UART,  //这里请求信号量是为了保证分配的存储区，但一般来说不允许
    2 j; r& N7 r4 ]' B: H( n  C
20. //   (OS_TICK  )0,                   //在终端服务函数中调用信号量请求但因为
    
21. //   (OS_OPT   )OS_OPT_PEND_NON_BLOCKING,//我OPT参数设置为非阻塞，所以可以这么写
    + O+ g0 s$ d+ [) |7 h; b. @
22. //   (CPU_TS*  )0,
    
23. //   (OS_ERR*  )&err);
    
24. //   if(err==OS_ERR_PEND_WOULD_BLOCK)     //检测到当前信号量不可用
    
25. //   {
    # a' R) z; l, O- D/ t6 x3 j2 X7 T7 b
26. //     printf("error");
    
27. //   }   
    ! O& P' m7 Q& S  z
28.    Usart1_Rx_Ptr=(unsigned char*) OSMemGet((OS_MEM*)&UART1_MemPool,&err);//分配存储区
    $ C! B5 V) ~  G7 H& F5 m- |" ?
29.    Usart1_Rx_Ptr1=Usart1_Rx_Ptr;          //储存存储区的首地址
    
30.   }
    
31.   if(Usart1_data == 0x0a )       //接收到尾标志
    
32.   {                    
    
33.    *Usart1_Rx_Ptr++=Usart1_data;
    
34.    Usart1_Rx_cnt++;                         //字节大小增加
    2 }% r; q: S0 }' i: E
35.    OSTaskQPost((OS_TCB    *  )&Task1_TaskTCB,
    % }" A/ |" L6 r- x
36.                                    (void      *  )Usart1_Rx_Ptr1,    //发送存储区首地址到消息队列
    
37.                                    (OS_MSG_SIZE  )Usart1_Rx_cnt,
    0 u) a" _# B  A" s! M3 r
38.                                    (OS_OPT       )OS_OPT_POST_FIFO,  //先进先出，也可设置为后进先出，再有地方很有用
    
39.                                    (OS_ERR    *  )&err);
    
40.          
    
41.    Usart1_Rx_Ptr=NULL;          //将指针指向为空，防止修改
    5 D; r0 s" a  M! {2 E2 N
42.    Usart1_Rx_cnt=0;      //字节大小计数清零
    
43.   }
    
44.   else
    
45.   {
    0 o  m2 ^; ]" T  R9 G2 \" Y$ ]; t
46.    *Usart1_Rx_Ptr=Usart1_data; //储存接收到的数据
    3 u! e1 S* G" r+ }/ t8 X; q
47.    Usart1_Rx_Ptr++;
    
48.    Usart1_Rx_cnt++;
    
49.   }
    9 [7 t! Z- M' O9 v% ^  B5 ~
50. }   
    
51. OSIntExit();
    # H4 E4 A( ?3 P. ^& G1 E
52. }

复制代码

上面被注释掉的代码为我是为了防止当分区中没有空闲的存储块时加入信号量，打印出报警信息。当然我们也可以将存储块直接设置大一点，但是还是无法避免当没有可有存储块时会程序会崩溃现象。希望懂的朋友能告知下~。

下面是串口数据处理任务，这里删去了其他代码，只把他打印出来了而已。

1. void task1_task(void *p_arg)
   
2. {
   ; ]7 r  p* F( ]5 M  F: }' q
3. OS_ERR err;
   $ ?5 @5 x1 h$ f5 `. \( X: F4 m
4. OS_MSG_SIZE Usart1_Data_size;
   " @; p* g2 R& i
5. u8 *p;
     X8 A: o( ^% g+ P
6. 
   ! |5 p8 ~/ h# f9 T6 M! K8 }' D
7. while(1)
   
8. {
   
9.   p=(u8*)OSTaskQPend((OS_TICK  )0, //请求消息队列，获得储存区首地址
   9 |& p  O2 {. o; i; }
10.    (OS_OPT    )OS_OPT_PEND_BLOCKING,
    $ n/ A& e# N! u2 \- b
11.    (OS_MSG_SIZE* )&Usart1_Data_size,
    
12.    (CPU_TS*   )0,
    ! u$ q7 }, g2 p
13.    (OS_ERR*   )&err);
    
14. 
    
15.   printf("%s\r\n",p);        //打印数据
    ; }1 A" g8 ?: y, V- r$ o! h: v
16. 
    * E2 ^5 H! n) K' m1 @1 ?3 p! w
17.   delay_ms(100);
    
18.   OSMemPut((OS_MEM* )&UART1_MemPool,    //释放储存区
    
19.   (void*   )p,
    
20.   (OS_ERR*  )&err);
    
21.       
    8 S, O& o# U3 }, y: m
22.   OSSemPost((OS_SEM* )&SEM_IAR_UART,    //释放信号量
    
23.   (OS_OPT  )OS_OPT_POST_NO_SCHED,
    ! \/ j% \. ~1 w5 Z
24.   (OS_ERR* )&err);
    
25.       
    
26.   OSTimeDlyHMSM(0,0,1,500,OS_OPT_TIME_PERIODIC,&err);     
    ' S% [. C) t# b, n$ n/ O
27. }
    
28. }

复制代码

7 o0 ?1 z1 z8 H% E! h$ Z( |