在调试程序的时候经常需要使用printf’函数来打印相关调试信息，在STM103单片机中printf函数默认只能在串口1使用，有时候串口1被占用了，想要输出调试信息时会比较麻烦。现在就总结一下如何在其他串口上使用printf函数。这里使用正点原子的例程来做说明。
. `/ C2 e$ p! X$ d+ p- E! s默认串口1初始化代码如下
0 I- t/ ~" p5 ~* a: I( i! d2 i4 s% f0 v
2 Y& \1 Q+ z) n8 i! t+ l9 d

1. #if 1
   
2. #pragma import(__use_no_semihosting)
   ' U0 E, }3 T$ o
3. //标准库需要的支持函数
   
4. struct __FILE
   
5. {
   7 R6 m$ Y. B: d2 R' P
6.     int handle;
   
7. };
   
8. FILE __stdout;
   
9. //定义_sys_exit()以避免使用半主机模式
   
10. _sys_exit(int x)
    5 S2 T: B# `9 X  i, v# O  I
11. {
    
12.     x = x;
    ! G3 ^2 p2 A1 w% @' D9 D3 X
13. }
    / o6 u$ t5 R+ t7 ?. v- Z$ d
14. //重定义fputc函数
    " S5 e  V  z" \9 a) ^' T$ C
15. int fputc(int ch, FILE *f)
    
16. {
    2 ?% a( e  j# f
17.     while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕
    ' ]4 {8 r( c4 [, ?
18.     USART1->DR = (u8) ch;
    3 _& Y5 v- d. U1 B  s
19.     return ch;
    7 V$ q8 q: Y; T' L' Z/ ]
20. }
    
21. #endif
    
22. 
    
23. void uart_init(u32 bound) {
    
24.     //GPIO端口设置
    , G% k- n$ B6 ^7 M1 D0 a/ s( E
25.     GPIO_InitTypeDef GPIO_InitStructure;
      Y( m1 S- S) Z; }
26.     USART_InitTypeDef USART_InitStructure;
    
27.     NVIC_InitTypeDef NVIC_InitStructure;
    8 F# N3 n( |9 c
28. 
    7 y/ q/ H: r1 |$ O, Y/ Q  @( \
29.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    & z# u! ?6 V9 y
30. 
    
31.     //USART1_TX   GPIOA.9
    
32.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    8 j4 c& v1 T7 l
33.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
34.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    4 E6 b2 \: Z7 x, @; j
35.     GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
36. 
    0 E# p' ~" a9 T( n6 C  s& O& W
37.     //USART1_RX          GPIOA.10初始化
    
38.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    1 m9 X( v6 O4 R- K' u: y1 t/ w
39.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
40.     GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10
    ' K$ w+ ^( [6 h# @9 \5 T; U
41. 
    9 B: X% f8 ^5 _) l& j8 P
42.     //Usart1 NVIC 配置
    1 `  Z! `! Q# r& t, \& H* v+ A! v5 H
43.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
      M4 y1 H7 b' ?( F
44.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ; //抢占优先级3
    
45.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    
46.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
47.     NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    . H! ?8 t7 y; g3 z/ i: s
48. 
    
49.     //USART 初始化设置
    
50. 
    & W. ]5 F& C0 e- \
51.     USART_InitStructure.USART_BaudRate = bound;//串口波特率
    + i1 `% Y, c" e0 o8 q9 h: p: d! S
52.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
53.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
      k8 c! J; H* g7 U9 d
54.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    7 m9 {! a3 j, y8 K7 _
55.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
56.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    
57. 
    
58.     USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
59.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    + e  G5 T. y. {
60.     USART_Cmd(USART1, ENABLE);                    //使能串口1
    
61. 
    
62. }
    . n0 q8 E* C, [! U. x% M/ z  ~

复制代码

初始化函数uart_init（）上面的部分就是关于printf函数的相关设置，默认情况下printf函数是通过串口1输出数据的。
假如我们现在要将printf函数重新定义到串口3上，那么就可以将uart_init（）上面的一部分代码剪切到串口3初始化函数前面去，同时将fputc（）函数中的串口1修改为串口3就行。
" \( N) d; w  F2 O& W重新修改后的代码如下:
) {. Q4 k  W' C" Z" x串口1初始化代码

) O7 t7 z9 H* \( Q& @2 Z2 F* ]) Q

1. 
   
2. void uart_init(u32 bound) {
   
3.     //GPIO端口设置
   
4.     GPIO_InitTypeDef GPIO_InitStructure;
   + N7 _! B2 o" ?# G0 F# u% h* Q: U
5.     USART_InitTypeDef USART_InitStructure;
   
6.     NVIC_InitTypeDef NVIC_InitStructure;
   
7. 
   
8.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
   
9. 
   4 v0 k' k% t2 F: R
10.     //USART1_TX   GPIOA.9
    # q% J2 a, m' Z+ M5 u+ w  @
11.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    
12.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
13.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
      i6 I  C9 ~! J4 T) T. R# j2 Z
14.     GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    ' D9 D1 {+ z% v( i; o' R8 |8 }/ [# j
15. 
    # @  O$ b3 b& z: [* ?
16.     //USART1_RX          GPIOA.10初始化
      l6 Z2 d# `* x6 b2 |' [
17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    * {3 _4 W6 I& [& X
18.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
19.     GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10
    : Y/ `$ c9 h/ M+ Q% Z# H! `
20. 
    
21.     //Usart1 NVIC 配置
    
22.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
23.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ; //抢占优先级3
    7 _! [- |- F1 _# S1 Y1 Q- G: [
24.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    * s& E. L* w1 _0 X- X4 H* h5 Y% H
25.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    8 g! X; S/ T1 f) F3 @# b% K+ U
26.     NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
27. 
    + L' q% S* `) p+ l
28.     //USART 初始化设置
    
29. 
    
30.     USART_InitStructure.USART_BaudRate = bound;//串口波特率
    9 O. ?% s% c3 ^6 [$ N& f. G
31.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    % r* N" \/ W# a0 m  }! A  ]1 s1 L
32.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    $ Y% J4 v3 h4 e7 n: n
33.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
34.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
35.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    
36. 
    7 E' }; z- m8 v1 C3 f* ~# I* _7 X
37.     USART_Init(USART1, &USART_InitStructure); //初始化串口1
    % j' j" _0 E% |4 {
38.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    - A" _2 N$ F3 ^! p$ B( X) z
39.     USART_Cmd(USART1, ENABLE);                    //使能串口1
    
40. 
    0 n0 D! B2 |: {- E, i3 K
41. }
    

复制代码

) l: n3 d" R) d  t  g串口3初始化代码
' t' Q* n8 q5 v) d0 {
0 k; O3 L/ ^$ p7 F

1. #if 1
   
2. #pragma import(__use_no_semihosting)
   : h! m3 w( W3 d# Z" P
3. //标准库需要的支持函数
   , q5 X$ H) F( t7 b8 G
4. struct __FILE
   6 M( l# P6 ]" R* h9 V, s
5. {
   ' c+ x5 t1 n! X* F
6.     int handle;
   
7. 
   
8. };
   
9. 
   
10. FILE __stdout;
    7 k  O: |( m6 d; c- S
11. //定义_sys_exit()以避免使用半主机模式
    
12. _sys_exit(int x)
    
13. {
    9 F. u" @3 M1 ^8 P$ U
14.     x = x;
    ( ]6 S1 \7 D) {5 X/ L) N7 m7 L
15. }
    
16. //重定义fputc函数
    
17. int fputc(int ch, FILE *f)
    
18. {
    
19.     while((USART3->SR & 0X40) == 0); //循环发送,直到发送完毕
    2 ?4 v6 Y9 q: O" w
20.     USART3->DR = (u8) ch;
    / F; w. g1 g! _: _
21.     return ch;
    
22. }
    4 s9 X) ~9 h6 O4 d9 l/ e+ l
23. #endif
    % b* P" _, }7 m/ b2 u
24. 
    - E+ [2 O9 {( k/ |
25. 
    
26. 
    6 m4 Y% t8 M; b, K6 V
27. 
    9 y/ d, s' W( z7 d. v; `
28. void  uart3_init(u16 baud)
    9 l; ~3 X) E8 [6 e
29. {
    
30.     GPIO_InitTypeDef GPIO_InitStructure;
    / d! I1 c5 z- @
31.     USART_InitTypeDef USART_InitStructure;
    
32.     NVIC_InitTypeDef  NVIC_InitStructure;
    / z5 g. Q% e  o! x* P
33. 
    + T$ e2 U- h9 h6 ]! f' G4 p) l
34.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    & C+ S3 W, Y7 ?1 x2 f5 D8 K
35.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    5 V6 }. K! U- Z' c# K6 R
36. 
    
37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
39.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
40.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    2 \% `; i1 J. Q* V1 Y
41. 
    
42.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    
43.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    0 D! x& q; ~% F7 D- w
44.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
45.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    3 Q5 s$ s/ q5 b" _, O4 o
46. 
    ! @2 g# d$ t( V# U" e$ E, B+ l
47.     NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    
48.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    
49.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    
50.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
51. 
    8 |  y1 x- h3 k" t
52.     NVIC_Init(&NVIC_InitStructure);
    
53. 
    
54.     USART_InitStructure.USART_BaudRate = baud;
    9 o) a- {! Z3 c, i+ m
55.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
56.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    - d% V% E- e, o/ `2 k
57.     USART_InitStructure.USART_Parity = USART_Parity_No;
    % Y4 P4 h7 C; V! Q- l( e
58.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    ( h* N- M* b& _9 h2 f/ Z
59.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    - X5 W# p1 G5 R- A- Z1 T
60. 
    
61.     USART_Init(USART3, &USART_InitStructure);
    
62. 
    
63.     USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    % O( |% ^" _. u7 d
64.     USART_Cmd(USART3, ENABLE);
    , ]8 r: n/ g: v
65. 
    
66. }
    1 J4 G& F, N7 W) o9 T+ R" r

复制代码

修改后再使用printf函数时，就可以通过串口3输出了。
关于printf函数的设置核心代码如下：

1. #pragma import(__use_no_semihosting)
   6 j9 Z9 Z) o3 Z2 c7 S, R
2. //标准库需要的支持函数
   
3. struct __FILE
   ! j: R- Q- L; O: y
4. {
   
5.     int handle;
   ; J: P, h1 U& R+ U1 m
6. 
   
7. };
   3 K" u- Q5 X, f; R* S" q! @+ i' }
8. 
   
9. FILE __stdout;
   & Y9 S1 _) U8 g. B
10. //定义_sys_exit()以避免使用半主机模式
    ' J0 a; S* Y0 _
11. _sys_exit(int x)
    9 H% A: W) y# D
12. {
    
13.     x = x;
    8 ?2 L* v7 M5 G/ k' t) T- l
14. }
    
15. //重定义fputc函数
    # }* L$ k* R0 Q# s/ r
16. int fputc(int ch, FILE *f)
    
17. {
    # D9 `0 D2 {) v7 r. y$ l& o& t$ I' W& @
18.     while((USART3->SR & 0X40) == 0); //循环发送,直到发送完毕
    9 i: ~* M9 d6 J, |
19.     USART3->DR = (u8) ch;
    
20.     return ch;
    
21. }
    

复制代码

通过上面几个函数可以看出，要重新定义printf函数的输出串口时，只需要修改fputc()函数中关于串口的定义就行。
: s/ j* S% q4 H9 P' d- d# H
- q) K" ?( _; J# S6 J+ f% ]4 p