STM32串口通信中使用printf发送数据配置方法(开发环境 Keil RVMDK)

, b1 [6 o8 m& A, p5 m- c. e
在STM32串口通信程序中使用printf发送数据，非常的方便。可在刚开始使用的时候总是遇到问题，常见的是硬件访真时无法进入main主函数，其实只要简单的配置一下就可以了。

下面就说一下使用printf需要做哪些配置。
3 A3 d+ G; u4 m+ _3 B
有两种配置方法：

$ g, v& b# P) J; L  O9 |一、对工程属性进行配置，详细步骤如下
3 e: N; D% p8 D* l% P- i" p
1、首先要在你的main 文件中 包含“stdio.h” （标准输入输出头文件）。
% p4 ]( v9 l7 O7 l/ A
2、在main文件中重定义函数   
+ U4 G! S5 j( D1 {3 B$ P如下：

1. // 发送数据
   / \4 P+ e! `% @4 B# x# L
2.    int fputc(int ch, FILE *f)
   ; I- w2 G6 F! `3 w2 d& M
3.    {
   
4.       USART_SendData(USART1, (unsigned char) ch);// USART1 可以换成 USART2 等
   ( {& G; f+ X0 g
5.       while (!(USART1->SR & USART_FLAG_TXE));
   
6.       return (ch);
   9 V4 o% I) Z# c, u
7.    }
   1 w# M6 Z( P. M0 T
8.    // 接收数据
   
9.    int GetKey (void)  
   
10. 
    ! p0 G0 X3 D& [; z. x3 b
11.   {
    
12.       while (!(USART1->SR & USART_FLAG_RXNE));
    & N! _7 O) }9 ]
13.       return ((int)(USART1->DR & 0x1FF));
    5 f8 ]( \0 m: A  b! o6 u/ C
14.    }

复制代码

这样在使用printf时就会调用自定义的fputc函数，来发送字符。
) A# e% T. K0 x! O" o
. v) ~% q) Z+ w3 N4 _0 C3、在工程属性的 “Target" -> "Code Generation" 选项中勾选 "Use MicroLIB"
7 A( Z, j6 r# P4 n( {) I   MicroLIB 是缺省C的备份库，关于它可以到网上查找详细资料。

二、第二种方法是在工程中添加“Regtarge.c”文件
1、在main文件中包含 “stdio.h” 文件
' E9 c8 P- x: L4 e3 r& _
2、在工程中创建一个文件保存为 Regtarge.c ， 然后将其添加工程中在文件中输入如下内容（直接复制即可）

1. #include
   3 g/ B* q' U# L9 F+ I
2. #include
   
3. #pragma import(__use_no_semihosting_swi)
   ; \6 K; @- J0 z$ t. s
4. extern int  SendChar(int ch); // 声明外部函数，在main文件中定义
   : C; C# v/ C; V9 q
5. extern int  GetKey(void);
   
6. struct __FILE {
   
7.   int handle;                 // Add whatever you need here
   5 ^2 e1 K$ V2 F/ f! g# `3 q) I3 s
8. };
   
9. FILE __stdout;
   0 i4 K; L" G& u
10. FILE __stdin;
    3 a6 V5 F4 n# i- m5 m
11. int fputc(int ch, FILE *f) {
    
12.   return (SendChar(ch));
    
13. }
    
14. int fgetc(FILE *f) {
    8 G1 i9 t! a& N7 A( O: y
15.   return (SendChar(GetKey()));
    
16. }
    
17. void _ttywrch(int ch) {
    3 ]! Y4 i( v' h
18. SendChar (ch);
    9 ?: n; W0 t3 l0 T+ f/ J
19. }
    . a* _4 S( Y* [
20. int ferror(FILE *f) {                            // Your implementation of ferror
    6 l5 ], R; ?5 `5 Y& S
21.   return EOF;
    
22. }
    / T) S1 u  p) O5 n, F: z
23. void _sys_exit(int return_code) {
    % Q5 D& D0 ]" _7 `
24. label:  goto label;           // endless loop
    0 t. J! j( }# e
25. }

复制代码

3、在main文件中添加定义以下两个函数

1. int SendChar (int ch)  {
   
2.   while (!(USART1->SR & USART_FLAG_TXE)); // USART1 可换成你程序中通信的串口
     ]! ?4 R! u6 K0 A3 P7 D
3.   USART1->DR = (ch & 0x1FF);
   ) ]$ ^6 T3 O+ U6 b
4.   return (ch);
   : G1 {) z, l( G' q2 J  q5 @8 y
5. }
   7 g7 u3 m4 C' c3 X
6. int GetKey (void)  {
   
7.   while (!(USART1->SR & USART_FLAG_RXNE));
   
8.   return ((int)(USART1->DR & 0x1FF));
   , I! M4 {, {0 p+ a8 P$ t) D
9. }

复制代码

至此完成配置，可以在main文件中随意使用 printf 。


STM32程序添加printf函数后无法运行的解决方法（串口实验）
$ {' z! ?8 n6 I  [1 Z9 [; Q. C- q
标准库函数的默认输出设备是显示器，要实现在串口或LCD输出，必须重定义标准库函数里调用的与输出设备相关的函数.

  N# L# w( s% i" G6 F& M; j例如:printf输出到串口，需要将fputc里面的输出指向串口(重定向),方法如下:
" G, E6 ~& u- k# W( R- s
) ~& N( B  M9 z, p只要自己添加一个int fputc(int ch, FILE *f)函数，能够输出字符就可以了
. m& G  @5 L  t1 c# H0 C! Q6 V# p

1. #ifdef __GNUC__
   
2. 
   
3. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   
4. #else
   
5. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   
6. #endif
   
7. 
   0 ~" K  i& y0 n2 D: a/ U
8. PUTCHAR_PROTOTYPE
   : a9 G1 z7 m, N& I! S
9. {
   
10.   
    
11.   
      ?- h" {6 n& J
12.   USART_SendData(USART1, (uint8_t) ch);
    
13.   
    
14.   while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    " |! _. g5 }8 H. u
15.   return ch;
    
16. }

复制代码

因printf()之类的函数，使用了半主机模式。使用标准库会导致程序无法运行,以下是解决方法:


方法1.使用微库,因为使用微库的话,不会使用半主机模式.


方法2.仍然使用标准库,在主程序添加下面代码:

1. #pragma import(__use_no_semihosting)
   
2. 
   
3. _sys_exit(int x)
   1 U0 Z& D( s% A) I
4. {
   
5.   x = x;
   ; y& f% a( @/ a3 @5 c
6. }
   
7. 
   ' h$ o# \4 _, c, J  c! I  ^" N
8. struct __FILE
   
9. {
   
10.   int handle;
    
11. };
    
12. 
    # F& N9 S3 C1 t
13. FILE __stdout;

复制代码

IAR EWARM

General Options -- Library Configuration -- Library : Full < file descriptor support >
2 o" E1 \* }( r6 ?3 B- x8 ]
8 X. i) C6 E" t- Q/ w

1. #include
     ~( C. w4 j! {* K# Q
2. 
   " p. u! M+ [1 D. V$ F: _
3. #ifdef __GNUC__
   
4. 
   
5. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   & c0 d) ]3 Z4 T8 Z
6. #else
   4 r( q/ F: {1 T* F
7. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   2 M; ~# z6 i$ l' f7 J( G/ Z8 S
8. #endif
   
9. PUTCHAR_PROTOTYPE
   
10. {
    
11.   
    
12.   
    % m% q* k( ?+ c" R* I6 @6 N7 O
13.   USART_SendData(USART1, (uint8_t) ch);
    & k2 b% p/ z+ C5 i3 B8 }
14.   
    ' Z3 j6 f5 v# ?8 _- m
15.   while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    
16.   return ch;
    " c' M5 O2 {, d! [
17. }

复制代码

General Options -- Library Configuration -- Library : Normal < NO file descriptor support >

1. #include
   
2. 
   
3. size_t __write(int handle, const unsigned char * buffer, size_t size)
   
4. {
   
5.   // byte by byte write
   % N! G8 P# k- f6 L. x
6. }
   - e& Y/ n4 G3 A) J  m
7. 
   
8. size_t __dwrite(int handle, const unsigned char * buffer, size_t size)
   / ]# h$ _- @4 r; ?4 d1 B
9. {
   0 f. r* V( c4 K
10.   // buffer[ 0x50 ]
    
11. }

复制代码

Buffered Terminal Output : Enabled

% ]7 ]8 G$ S; ?. ~% T) p" uxxwritebuffered.c
5 \( G0 ]: ?- a, v

1. #define STORE_SIZE 80
   
2. 
   
3. static size_t storeLen = 0;
   * N/ A8 S3 w4 l8 E
4. static unsigned char store[STORE_SIZE];

复制代码

uint8_t store[ 0x50 ];
7 c$ Y5 p" M1 G4 ?* ~
/ ]+ Y# _- C' R" _) u) F+ z8 l& Xuint32_t storelen;

$ C$ l8 z% ]4 m# B, `  w; oprintf() --> __dwrite() : buffer[0x50]

Buffered Terminal Output : Disabled

$ ~0 \1 _' }! J1 @% n- Gprintf() --> __write(), byte by byte
1 a+ p; R% J# i- c- o

; Y2 D& m) D/ C  M自定义输出缓冲区
, @5 B0 P' E; r1 T6 e/ e4 d

1. #define LOG_MAX_STR_LEN  512
   
2. void log_printf( const char * fmt, ... )
   
3. {
   
4.   char log_buf[ LOG_MAX_STR_LEN ];
   
5.   va_list args;
   $ w  f0 B% e, I1 a. K" `
6. 
   ; G* {7 F% _' G% J
7.   va_start( args, fmt );
   
8.   int count = vsnprintf( log_buf, LOG_MAX_STR_LEN, fmt, args );
   
9.   va_end( args );
   6 Z1 {) }4 z4 @) f4 s
10. 
    
11.   // If an output error is encountered, a negative value is returned.
    ! U2 B6 z# T9 \& C  |
12.   if ( count < 0 )
    
13.     return;
    : P( _" w' \: x- N- h' R# o8 e8 J' K
14. 
    
15.   // "123456"    [123456][0X] : count = 6, n = 8
    
16.   // "1234567"   [1234567][0] : count = 7, n = 8
    
17.   // "12345678"  [1234567][0] : count = 8, n = 8
    . ^# s/ r, y& |  q% \3 e/ S
18.   // "123456789" [1234567][0] : count = 9, n = 8
    & Z$ B% C9 s3 j2 J7 |
19.   if ( count >= LOG_MAX_STR_LEN )
    " \) l* d; _: |+ X3 p6 h, a3 W
20.     count = LOG_MAX_STR_LEN - 1;
    - T2 H3 b8 F, C( k1 F* m5 D) n
21. 
    
22.   // now log_buf is C string with the terminating null character
    3 b% d9 G$ m2 ~1 c
23.   __write(0, log_buf, count );
    
24. }

复制代码

log_printf --> __write(), bufferred
/ p, k# t" Y) |1 |, D
( Y& r) j( D3 N' {8 H' Gstm32系列单片机之printf重定向

在程序的调试过程中，除了那些高大上的调试手段外，printf无疑是我们最熟悉最顺手的调试方法。
* ~* x% A( s; R) m/ J. M
0 c' G  C& [; Z3 q& e) M+ A3 N  d: l通过使用printf，我们可以很方便很直观的获取当前程序的运行状态。

6 k2 B4 B# w/ }  [) wprintf()函数是格式化输出函数, 一般用于向标准输出设备按规定格式输出信息。

但是在单片机开发中，一般情况下并不存在标准输出设备，因此我们需要将printf的输出信息重定向，也就是输出到其他输出设备中去。

在stm32平台上实现重定向的方式有两种，重定向至UART，或者通过JTAG的SW模式将printf重定向至SWO引脚输出。
4 o6 k! S7 I, P9 F5 h3 d2 C
1 E/ Q( h  s' P+ [) e7 i: L5 G  ]首先介绍第一种，重定向至UART，这种方式我们比较熟悉，ST官方提供的固件库中也是使用的这种方法。
& T$ x8 W- z3 P6 O* \. y$ H% C: o
" j9 r3 E: F- f. G9 @- K- t代码如下：在对UART进行初始化后，通过如下代码对printf进行重定向

1. int fputc(int ch, FILE *f)
   : S' `8 B( q4 R
2. {
   $ b3 R3 N& W$ _( E  \
3.   USART_SendData(USART1, (uint8_t) ch);
   / B: ?5 J3 c- Q
4.   
   1 D: X) H# ~4 I$ o( s0 ^
5.   while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
   
6.   {}
   
7.   return ch;
   
8. }

复制代码

通过JTAG的SW模式将printf重定向至SWO引脚输出

1.在源码中添加对ITM端口寄存器的定义

1. #define ITM_Port8(n)    (*((volatile unsigned char *)(0xE0000000+4*n)))
   + r5 g% [9 e  |! }
2. #define ITM_Port16(n)   (*((volatile unsigned short*)(0xE0000000+4*n)))
   
3. #define ITM_Port32(n)   (*((volatile unsigned long *)(0xE0000000+4*n)))
   
4. 
   
5. #define DEMCR           (*((volatile unsigned long *)(0xE000EDFC)))
   4 W* l; B9 X8 F7 e( L2 s6 M
6. #define TRCENA          0x01000000

复制代码

2.通过如下代码将printf的输出重定向至ITM的Port 0
( D$ n& n; ~* G! f

1. int fputc(int ch, FILE *f)
   
2. {
   2 u) [, J" h; J8 o2 w' l" t0 H
3.   if (DEMCR & TRCENA) {
   
4.     while (ITM_Port32(0) == 0);
   4 n( Q, n* q7 C# I
5.     ITM_Port8(0) = ch;
   : L9 w( L2 D( b
6.   }
     ~. o, ?! K7 C- J# A# C
7.   return(ch);
   
8. }

复制代码

3.通过printf输出调试信息
3 n: ?% L9 [" L  W& k& M

1. printf("AD value = 0xX\r\n", AD_value);

复制代码

4.将Jtag设置为SW模式，并设置ITM的Port 0 获取信息。

STM32中重定向printf到SWO口
  g. Y: m$ i7 `) G( a) b
4 @9 s, d% e* F3 k% I3 t( A# oprintf在命令行编程的时候是非常常用的，虽然是个老函数，但是功能强大，经久不衰

4 u7 D1 V$ {% s2 [5 ^9 ?  A3 Y! q51等8位单片机由于RAM比较小，栈就比较小，跑printf比较吃力，

但是STM32这种32位单片机跑printf就很容易了，而作为一种调试手段，printf十分方便、直观。
3 `9 M$ k& O2 \1 o( a; m5 |1 u
比较常见的方法是把printf重定向到串口，不过这需要外接一个串口线，比较麻烦。
/ l% g7 q# l/ W" z
其实STM32自带的SWO口是能够异步输出数据的，而且不需要外接什么设备，

! X2 r$ i- A. ~4 a$ p+ cST-LINK/J-Link等带SWO口的调试器都支持。
8 K) U3 a, `9 [$ N. I3 @* T0 @
下面以STM32F4Discovery开发板+GCC为例说明。

根据这里的方法，也可以把printf定位到其他外设。
; b# X% m  [' D
PS：IAR在编译选项里自带了printf via SWO的功能，就不需要外加设置了。
+ o5 ^7 ^4 t! }1 g4 P' g/ _
( p! e, B" I" @9 y" y) |( y# F9 {首先来说说怎么把信息输出到SWO口，一句话搞定。
" I1 [# c1 f) s9 j4 P. l; N
ITM_SendChar(ch);
' r' p$ z/ i: l6 q# y
, A7 ?4 C* ]7 l/ r这是在core_cm4.h(如果是F1系列的那就是core_cm3.h)中定义的内联函数。
) B7 v. z- E' @9 u+ ~5 {
不过不需要特意去include这个头文件，通过#include "stm32f4xx.h"就间接地将core_cm4.h包含进来。
, T1 Q6 N5 \  q( v  U8 c. [; h
' t- K/ c2 w+ @: A" [不过说起来，ITM这个东西其实严格来说是Cortex-M提供的一个特性，而不是STM32。
9 O' }7 @9 e- |4 o7 R5 A/ i* S
利用这个函数把信息输出到SWO口之后再打开St-Link Utility，

在菜单里找到ST-LINK→Printf via SWO Viewer就会弹出一个窗口，

( u3 j, B% A) w" S. y设置System Clock为单片机内核频率，点Start就能看到输出的信息了。
7 o! I1 L( ^1 E9 S$ g0 G1 g( b
接下来就是把printf函数输出的字符串重定向过去了。
4 }" b: i3 ?; P0 U: `- i" j' r
由于单片机的外设功能是根据需求变化的，编译器不可能确定printf需要用到的外设资源，
; c& l7 [3 |5 t0 ~! r
于是乎它就干脆留了个接口，也就是_write函数，
- _6 ]  v! Y  k: Q1 g7 {; P
当然除了_write函数之外还有_read等其他函数，不过这里我们用不到。
) I  s; S1 A/ s0 X) U, ^; f
) i1 Q, f: p% _9 d2 o其声明为 int _write(int fd, char* ptr, int len);

关于_write函数，说简单点，就是所有涉及到输出字符串的函数，

: n7 H8 G1 k# v) p4 M$ m# v比如printf和putchar()，最终都会跑到_write函数，这里fd是文件标识符，说开来就比较复杂了，

这里我们用得到的就只有STDOUT_FILENO跟STDERR_FILENO，

其中前一个是标准输出的文件标识符的预定义变量，后一个是错误输出的文件标识符预定义变量。
1 T  [9 n; k- W8 h
第二个变量ptr是需要输出的字符串首地址，len就是输出长度。
4 ^7 z, g" Q( X! U! s6 Q
8 v7 a# U% M9 j& E2 g7 q9 f' g当我们调用printf函数后，C运行库会把输入变量转换为最终需要输出的字符串，
% e& Z5 t( w9 c
然后调用_write函数，将结果输出。我们的工作就是实现一个_write函数。
* M; u6 ~  y% Q2 f
# A0 W% M; y9 ~, m' _新建一个_write.c文件，内容如下：
' }* d$ S2 H6 O+ {$ T0 S

1. #include
   - C  w" {" f/ \9 X: D6 \0 L( x. H% I
2. #include
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   & _/ o, `( `0 W$ B
6. #ifdef _DEBUG
   8 m1 ~' p; V5 O% |  x( d, S" y% H
7. 
   
8. int _write(int fd, char* ptr, int len)
   
9. {
   3 W8 N) ]4 O0 i4 C& i
10. if (fd == STDOUT_FILENO || fd == STDERR_FILENO)
    
11. {
    0 W4 i& |; s. Q& e' F6 t
12. int i = 0;
    
13. while(i<<span style="font-family: 'Courier New' !important; line-height: 1.8; margin: 0px; padding: 0px;">len)
    * B; A$ Y" W: n* E0 I
14. ITM_SendChar(ptr[i++]);
    
15. }
    
16. return len;
    : V4 o# V+ j. }) G* k* T6 O3 J
17. }
    
18. 
    
19. #endif

复制代码

加了个#ifdef _DEBUG 的效果是未加 _DEBUG 定义的时候就忽略下面的东西，
9 O! @9 }: b4 ~8 [6 H/ g
& H6 i6 G, e7 R4 b6 D# U因为这东西主要是用在调试阶段，RELEASE版本里面都用不到了，而且多少还是会影响速度。

" f; C) ^& f6 J, }其他东西就很简单了- -不需要多说明了吧。

# S0 f6 G. m* z# [. ~直接编译能通过，但是链接会报错，提示无法找到_read之类的一堆函数。

在链接脚本的下面libgcc.a ( * )后面加上libnosys.a ( * )，就不会报错了。

9 ?0 T$ L# Y! C, Q1 b; C$ o具体原因涉及到Cortex-M3使用的newlib库的实现，就不具体展开了。
: ?9 \) u; z- r( w1 l5 b2 H* @
; k3 D; I! m" }9 F好吧好吧，其实我也不知道。

$ ]! I9 K* N& b7 v如果想把信息定位到串口，可以直接把ITM_SendChar改成相应的串口函数，
5 S2 q: v- L& r2 }! z+ U) R1 {; \
1 |6 Z: j( [5 H. g+ b+ X0 G, J也可以利用DMA，先把数据拷贝到DMA缓冲区，让DMA自动传数据，提高响应速度。

) i2 S2 [5 x9 e7 ^$ u
STM32片内外设--DBG之Keil SWO输出
( o1 R6 D# G) |# g. N( c
( z7 X- c; W% ?% d1) 加入stdio.h,这样你就可以调用printf函数了
2) 使能SWO输出

! s2 q! h6 S) ]" t; f* ?. ~使能SWO输出。最简单的办法就是将如下的函数拷贝到你的工程里面，并且在mian函数初始化之后调用该函数。
4 }$ a5 W% R6 M. i4 X

1. void setupSWO(void)
   4 g" K: e* p9 m0 h0 U. p
2. {
   
3. uint32_t *dwt_ctrl = (uint32_t *) 0xE0001000;
   
4. uint32_t *tpiu_prescaler = (uint32_t *) 0xE0040010;
   
5. uint32_t *tpiu_protocol = (uint32_t *) 0xE00400F0;
   , K, N6 z* j! Y& x" P: a/ S; |
6. 
   
7. CMU->HFPERCLKEN0 |= CMU_HFPERCLKEN0_GPIO;
   
8. 
   
9. GPIO->ROUTE |= GPIO_ROUTE_SWOPEN;
   
10. #if defined(_EFM32_GIANT_FAMILY)
    
11. 
    
12. GPIO->ROUTE = (GPIO->ROUTE & ~(_GPIO_ROUTE_SWLOCATION_MASK)) | GPIO_ROUTE_SWLOCATION_LOC0;
    
13. 
    - g5 Q/ v/ Y. l. i  i) z- V/ ^; R% V
14. GPIO->P[5].MODEL &= ~(_GPIO_P_MODEL_MODE2_MASK);
    
15. GPIO->P[5].MODEL |= GPIO_P_MODEL_MODE2_PUSHPULL;
    4 d. K* u; J- o
16. #else
    
17. 
    : G" ^# c' F- ^6 j
18. GPIO->ROUTE = (GPIO->ROUTE & ~(_GPIO_ROUTE_SWLOCATION_MASK)) | GPIO_ROUTE_SWLOCATION_LOC1;
    1 b3 t# ]% d1 i8 l# U9 V
19. 
    
20. GPIO->P[2].MODEH &= ~(_GPIO_P_MODEH_MODE15_MASK);
    $ M- L" `5 I0 @  m# m1 i
21. GPIO->P[2].MODEH |= GPIO_P_MODEH_MODE15_PUSHPULL;
    . z# o4 f1 k& ~9 w' g6 k
22. #endif
    - n; ~+ N0 H! y6 \( i( @
23. 
    
24. CMU->OSCENCMD = CMU_OSCENCMD_AUXHFRCOEN;
    ; i- N% i8 h6 H2 Z/ s$ i. U$ _
25. 
    5 n6 ^9 _1 q6 y7 l
26. while(!(CMU->STATUS & CMU_STATUS_AUXHFRCORDY));
    
27. 
    " b- I3 u) P( f) ]5 I9 [9 q$ ~
28. 
    0 v8 ?7 W, ^, ^8 Q4 e& |2 A
29. CoreDebug->DHCSR |= 1;
    & Z. P/ n/ D# T8 Z" Y1 Q
30. CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    " G, h- D* s5 r. ~% [. ^. S
31. 
    
32. 
    
33. *dwt_ctrl = 0x400113FF;
    
34. 
    , g# w" P! `7 |$ H  f, E
35. *tpiu_prescaler = 0xf;
    
36. 
    4 ^3 b1 d/ N( }
37. *tpiu_protocol = 2;
    
38. 
    7 b. P  a8 [- n* `' a, t' Z8 o
39. ITM->LAR = 0xC5ACCE55;
    
40. ITM->TCR = 0x10009;
    ! n$ L! [, J9 u8 \" e. f# M5 j
41. }

复制代码

3) 配置Keil的工程选项
- t9 P( g$ y+ w# B
打开Keil的工程配置，选择Debug页面，选择仿真器为Cortex-M/R J-Link/J-Trace, 并点击仿真器选项边上的setting选项，打开具体的设置窗口。
7 l" v& c$ V9 H$ e. ~( ?
在打开的窗口中，切换到Trace页面，选中Enable，并且设置Core Clock为14MHz，分频选项为Core Clock/16。详情如下:
4) 在初始化SWO函数之后的地方，使用printf函数进行输出。例如printf("Hello world")。
( I  \, j8 H$ i  q% _
5) 在你的工程里面，需要添加如下的函数：

1. struct __FILE
   9 |- [; O5 j7 h; F, n
2. 
   
3. {
   
4. 
   4 Q: H% r: l4 y( z  b" o3 K) N
5.   int handle;
   
6. 
   
7. };
   
8. 
   - V6 Z9 s2 T. ~
9. FILE __stdout;
   2 Y) R, h6 @/ |/ Q
10. FILE __stdin;
    
11. int fputc(int ch, FILE *f)
    
12. 
    
13. {
    6 L* J( v7 [7 u2 \! O
14.   ITM_SendChar(ch);
    & h, b5 f, h# @: o# x
15.   return(ch);
    , Q* I& V( r& y1 c. @0 b4 o0 i# K
16. }

复制代码

6) 编译你的代码，并且进入Debug状态
5 D9 @1 o4 Q4 ]' E- V
$ E0 \, ~' h7 k7) 打开Keil的printf-view窗口, 通过 View -> Serial Windows -> Debug(printf) View
. k/ Z4 [) E& P! G- A! O
8) 点击运行之后，在Debug (printf) View里即可查看
- z0 _2 ~: r  m1 }* q: S9 f( k

先收藏，需要的时候拿出来弄一下printf

支持一个！！

在群里看到朋友共享的GCC下printf函数实现的方法：

1. int _write(int fd, char *ptr, int len)
   7 x5 m" {2 E6 U4 @  u
2. {
   
3.     HAL_UART_Transmit(&huart1, (uint8_t*) ptr, len, 0xFFFF);
   
4.     return len;
   2 R" I8 g3 J. P
5. }
   
6. 
   
7. int _read(int fd, char *ptr, int len)
   
8. {
   5 r8 Z6 [/ J. ^4 w. d% K
9.     *ptr = 0x00;    //Flush the character buffer
   # U  {' ~* R( D) l
10.     HAL_UART_Receive(&huart1, (uint8_t*) ptr, 1, 0xFFFF);
    8 I% |: K. W- G. u  r, H, _# z0 o
11.     return 1;
    $ ^1 V$ Z3 R' J5 U7 o
12. }
    & e% v' u  e/ i* M7 U7 I

复制代码

一开始使用时总觉得有问题，有些数没被发出来。
后来查询得知，printf()语句里面最后加上\r\n后才输出数据，我之前习惯在前边加\r\n。
+ x5 m; Y% I  _/ t! e/ W2 u" P

这个太厉害了！谢谢分享。以前看正点原子的串口代码看得云里雾里