在单片机中使用最多的通信接口基本就是串口了，说起串口就不得不提串口中最常用的一个函数就是打印函数printf()函数，通常使用这个函数都是直接调用库函数来实现的，在单片机中如何要使用printf（）函数一般都是在串口中进行重映射。如要在串口1中使用printf()函数，可以使用下面的代码进行重映射。
" w5 z9 v0 E6 q1 d, n  F

1. //加入以下代码,支持printf函数,而不需要选择use MicroLIB
   
2. #if 1
   
3. #pragma import(__use_no_semihosting)
   4 s( o% o& ]( u2 T
4. //标准库需要的支持函数
   
5. struct __FILE
   
6. {
   ; Q% j+ h# [$ i2 d. O: }
7.     int handle;
   
8. };
   
9. FILE __stdout;
   9 v: ^2 c9 l/ F  w2 A
10. //定义_sys_exit()以避免使用半主机模式
    & o' f9 {  {6 a& P: Y+ t( G1 ]
11. _sys_exit(int x)
    6 V4 U  a$ o  R( W6 q! h
12. {
    3 b, Q: I4 f( W5 O$ ?+ @' O
13.     x = x;
    
14. }
      a4 E4 ^' j7 Q
15. //重定义fputc函数
    
16. int fputc(int ch, FILE *f)
      A: F# I$ W. _: n2 c! C2 `
17. {
    : \3 N$ n7 x: K1 Q
18.     while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕
    3 }1 M# p# a. |3 r1 P
19.     USART1->DR = (u8) ch;
    6 z1 _+ ^( C) f! j  Q9 W+ S
20.     return ch;
    ( L  {% \( g3 `
21. }
    + S6 W. d. H0 x0 r* }1 g
22. #endif

复制代码

  在串口1的c文件中，添加上面的代码后，使用printf（）函数时，就可以通过串口1来打印了。那么不通过库函数的话，自己能不能实现printf（）函数的功能呢？当然是可以的，下面就通过串口2来演示，如何在串口2上直接实现printf（）函数的功能。
2 `: I8 t. w& N2 t, f6 g: a0 Z; f
/ [) d1 A7 M3 r0 F6 y& i+ a

1. void UART2_Init(u32 bound)
   
2. {
   1 e3 O" y& |) R1 h, X* E! T, b
3.     GPIO_InitTypeDef GPIO_InitStructure;
   9 y7 b7 O$ V; N$ k' d& m5 J
4.     USART_InitTypeDef USART_InitStructure;
   
5.     NVIC_InitTypeDef NVIC_InitStructure;
   
6. 
   & q% d! |' T( z& n$ ]  s
7.     // 1、串口时钟使能 GPIO时钟使能
   4 X3 T1 R' L3 h
8.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   3 H* C7 A- J# e% r, m) h2 p
9.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
   7 ~. `, l- B1 P% Z3 ]' ?( y* W
10. 
    , n9 q  q! W7 h) }9 W8 E
11.     // 2、串口复位
    , i9 s8 s8 @* W% |& A) t5 ?
12.     USART_DeInit(USART2);
    
13. 
    . G3 F6 y) z' ^% ]" k
14.     // 3、GPIO端口设置
    
15.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;                         //PA2 TX
    
16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出
    
17.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      U* @/ j1 O( O% m8 r
18.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    
19. 
    
20.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;                               //PA3 RX
    9 p: |) C+ [; N$ ~' q, I
21.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
    ' ~: b) b" V& S  B! J
22.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
23.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    ) N; I% H  T7 F6 u
24. 
    2 }5 o, {7 d  z  s
25.     // 4、串口参数初始化
    + d1 _1 T# N. ?2 a
26.     USART_InitStructure.USART_BaudRate = bound;
    
27.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
28.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    4 R0 `2 T2 R' o5 a
29.     USART_InitStructure.USART_Parity = USART_Parity_No;
    
30.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    * V# g3 c" ?: C) Q3 }$ J
31.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
32.     USART_Init(USART2, &USART_InitStructure);
    
33. 
    
34.     // 5、初始化NVIC
    ! ~1 L3 x/ q7 m+ J/ t( R8 D. f
35.     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    ; P: A! z+ W( w  a( S- z
36.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
    
37.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
    ; ~2 X4 ]" U$ g. h
38.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
39.     NVIC_Init(&NVIC_InitStructure);
    
40. 
    2 d9 A0 i2 n; X8 E4 H
41.     // 6、开启中断
    7 v# L7 R5 W8 H0 F
42.     USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    
43. 
    
44.     // 7、使能串口
    
45.     USART_Cmd(USART2, ENABLE);
    
46. 
    
47. }
    , @+ D6 A- n5 c; Y' G& X
48. void USART2_IRQHandler(void)
    . H: L3 N& U9 y! d. E( |" u/ |# k
49. {
    
50.     u8 res;
    2 q7 O4 I* C2 C1 g5 {/ f* Z
51.     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
    " K" l" L4 A+ t
52.     {
    
53.         res = USART_ReceiveData(USART2);
    * u+ E; d5 H5 ?# h
54.         USART_SendData(USART2, res);                        //把接收到的数据发送出去
    - {0 |- H. O: w6 A1 [, ]; t8 _" X9 N
55.     }
    * D" M# ^8 r2 y$ I. s7 M
56. }

复制代码

" s% L- a. u0 b" c  首先初始化串口2，初始化方式和正常情况下一样，初始化完成之后开始自定义一个函数来实现printf（）函数的功能。
* [2 E2 w; _6 Y$ P3 _7 e9 k% E
5 m" n0 j9 {9 N& }

1. //自定义串口2 的printf 函数
   
2. char UART2_TX_BUF[200];
   # d9 i1 T# t# R8 b+ M) P  ~
3. void u2_printf(char* fmt, ...)    //无法列出传递函数的所有实参的类型和数目时,可以用省略号指定参数表
   ( ~4 A! Z% y5 _* {  K9 P, b
4. {
   
5.     u16 i, j;
   
6.     va_list ap;          //va_list 是一个字符指针，可以理解为指向当前参数的一个指针，取参必须通过这个指针进行。
   + [3 w9 a7 P* M5 w$ A
7.     va_start(ap, fmt);   //va_start函数来获取参数列表中的参数，使用完毕后调用va_end()结束
   
8.     vsprintf((char*)UART2_TX_BUF, fmt, ap);        // 把生成的格式化的字符串存放在这里
   
9.     va_end(ap);
   
10.     i = strlen((const char*)UART2_TX_BUF);              //此次发送数据的长度
    0 L! x) A& D  q5 F, J2 W
11.     for(j = 0; j < i; j++)                                                    //循环发送数据
    6 t/ ]: \1 o2 M% [7 A
12.     {
    
13.         while((USART2->SR & 0X40) == 0);                    //循环发送,直到发送完毕
    ; P4 J/ t$ [4 s; O" j( M
14.         USART2->DR = UART2_TX_BUF[j];
    
15.     }
    
16. }

复制代码

$ t1 c/ `  g' c' C- z& A- L( w  这个函数名定义为 ：u2_printf(char* fmt, …) 使用省略号表示当前参数为可变参数。接下里就可以直接使用这个函数来打印数据了。在主函数中通过一段代码来测试串口1和串口2 printf函数的功能。
" R; t, b% A/ L0 t8 q. d, i% a8 e
+ v( @7 t4 o+ y& x

1. int main(void)
   
2. {
   " }1 m. G) c0 h# y  n2 _
3.     u8 t;
   
4.     u8 len;
   7 Q0 O) O  X! M. @+ R
5.     u16 times = 0;
   
6.     delay_init();       //延时函数初始化
   + G! `: d/ N5 k- Y+ n8 S
7.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
8.     uart_init(115200);
   
9.     LED_Init();
   5 [7 {* J  a! A% m  {' f+ T5 C
10.     UART2_Init(115200);
    ! j" I& u. h+ f! l1 m
11.     printf("USART1 AND USART2 TEST!!!");
    - [* l+ f" _; v( |- v: s
12.     while(1)
    
13.     {
    
14.         if(USART_RX_STA & 0x8000)
    6 S- k* i5 R9 j. Z, Y$ j
15.         {
    
16.             LED1 = !LED1;
    : @. p6 e/ ]( B* E% V# e! u0 \5 |
17.             len = USART_RX_STA & 0x3fff;                //获取本次接收数据长度
    3 R- l* I& Q2 }6 h9 l0 ]5 y# o3 J( x
18.             printf("\r\n您发送的消息为:\r\n");
    : w1 D0 j3 ?" }- }
19.             for(t = 0; t < len; t++)
    
20.             {
    
21.                 USART_SendData(USART1, USART_RX_BUF[t]); //向串口1发送数据
    $ T. W2 H6 {9 E$ n3 t( J" g9 }7 b1 d% r
22.                 while(USART_GetFlagStatus(USART1, USART_FLAG_TC) != SET); //等待发送完成
    
23.             }
    6 K: l9 A" l, a
24.             printf("\r\n");
    / q2 y7 ~7 g9 `( _8 Q
25.             USART_RX_STA = 0;
    4 C0 m  u1 A) [7 y0 l2 ^# n
26.         }
    # W/ `* i5 d' M* Q
27.         else
    9 {4 E; q& A8 q/ x- y
28.         {
    9 F' _( o9 b7 M1 D7 e5 B4 r
29.             times++;
    
30.             if(times % 5000 == 0)
    
31.             {
    , O: W3 e3 i- ^: c4 }0 b' N
32.                 printf("串口实验\r\n");
    
33.                 u2_printf("串口实验\r\n");                                                                        //调用串口2 printf 函数
    
34.             }
    
35.             if(times % 300 == 0)
    
36.             {
    
37.                 printf("请输入数据，以回车键结束\r\n");
    
38.                 u2_printf("请输入数据，以回车键结束\r\n");                //调用串口2 printf 函数
    # K1 }. _4 X* ?- z) ?! \/ N
39.             }
    ! E. e/ b+ s& O. X! ~: q
40.             if(times % 30 == 0)
    
41.                 LED0 = !LED0;
    
42.             delay_ms(10);
    
43. 
    
44.         }
    1 k8 h+ s4 \( I; R' G% a
45. 
    
46.     }
    % t3 l8 G5 b# @; |
47. }

复制代码

# r( V/ N4 _  h) }1 g  通过串口1和串口2输出同样的提示信息，然后用串口助手分别给串口1和串口2发送数据，当串口1和串口2接收到数据后就会通过串口打印出来。串口1和串口2输出的提示信息都是用printf函数输出的。
9 O- X/ p6 `# q
  a7 x1 Q9 L; K0 y8 u! @

6 ~0 e; Z! ~4 [: D" f1 m  可以看出串口2的printf函数和功能和串口1的printf函数功能一样，可以正常输出字符串。也可以使用串口2的printf函数打印变量值，比如在代码中增加一句变量打印的功能。

4 \# s- a: ^* n) E) j
: W9 I1 j' J& ^. e  i7 @
  每次输出提示信息的时候，顺便打印一下变量times的值。
- S* l+ g$ O1 z. `

* H) Z9 u" P1 Z; g4 S1 e
  可以看到变量times的值也可以正常打印。

$ G& B  P: r, L) k2 L! w) J" ?  i
; s4 t5 N( k/ f! p* |