本文主要介绍在嵌入式开发中用来输出log的方法。

    最常用的是通过串口输出uart log，这种方法实现简单，大部分嵌入式芯片都有串口功能。但是这样简单的功能有时候却不是那么好用，比如：

• 一款新拿到的芯片，没有串口驱动时如何打印log
• 某些应用下对时序要求比较高，串口输出log占用时间太长怎么办？比如USB枚举。
• 某些bug正常运行时会出现，当打开串口log时又不再复现怎么办
• 一些封装中没有串口，或者串口已经被用作其他用途，要如何输出log
  
  % a- |4 c( v" f: \1 m& r- \

    下文来讨论这些问题。
+ h/ X( k- o/ }- A, [/ b7 T

1 输出log信息到SRAM

    准确来说这里并不是输出log，而是以一种方式不使用串口就可以看到log。在芯片开发阶段都可以连接仿真器调试，可以使用打断点的方法调试，但是有些操作如果不能被打断就没法使用断点调试了。    这时候可以考虑将log打印到SRAM中，整个操作结束后再通过仿真器查看SRAM中的log buffer，这样就实现了间接的log输出。本文使用的测试平台是STM32F407 discovery，基于usb host实验代码，对于其他嵌入式平台原理也是通用的。首先定义一个结构体用于打印log，如下:

( g4 \8 O0 i3 u8 W. {. G1 w/ H

    定义一段SRAM空间作为log buffer:

1. static u8 log_buffer[LOG_MAX_LEN];

复制代码

  d$ z+ l* z# g+ i+ @# ]1 L

    log buffer是环形缓冲区，在小的buffer就可以无限打印log，缺点也很明显，如果log没有及时输出就会被新的覆盖。Buffer大小根据SRAM大小分配，这里使用1kB。为了方便输出参数，使用printf函数来格式化输出，需要做如下配置（Keil）：

2 l- D5 k% _1 G) Q' T! X% Z' _( u

    并包含头文件#include <stdio.h>, 在代码中实现函数fputc()：

$ }" v5 X) L1 s' u5 u# I7 a

    写入数据到SRAM：

" l1 f( i0 g0 b/ P7 }

0 D# l3 E! l& k) W' q    为了方便控制log打印格式，在头文件中再添加自定义的打印函数。

7 n( D% b+ M' Q

5 }' P" B/ }: }; u8 G# U6 ~% S; Y7 Z

    在需要打印log的地方直接调用DEBUG()即可，最终效果如下，从Memory窗口可以看到打印的log：

9 g' U, d, N) ~* P

2 通过SWO输出log

6 n8 w6 I" n( c" {) ~1 x9 V

    通过打印log到SRAM的方式可以看到log，但是数据量多的时候可能来不及查看就被覆盖了。为了解决这个问题，可以使用St-link的SWO输出log，这样就不用担心log被覆盖。查看原理图f407 discovery的SWO已经连接了，否则需要自己飞线连接：
3 B- j* L, q! g0 S$ W

    在log结构体中添加SWO的操作函数集：
$ j$ z3 ?8 A/ L+ D

1. typedef struct
   
2. {
   9 \. [, T# y* g! G5 i& f$ H
3.     u8 (*init)(void* arg);
   4 ?" z( ?2 ~2 C9 Y
4.     u8 (*print)(u8 ch);
   
5.     u8 (*print_dma)(u8* buffer, u32 len);
   
6. }log_func;
   
7. 
   9 l. Q2 ?$ f" m7 o$ j$ B4 v
8. typedef struct
   3 a/ ]( q0 w  g5 n3 L
9. {
   : T3 V3 {5 }/ p; R& i9 o
10.     volatile u8     type;
    : ^; |. @* @5 P
11.     u8*             buffer;
    2 w1 F$ k8 w8 ^2 Y
12.     volatile u32    write_idx;
    
13.     volatile u32    read_idx;
    ( o7 W5 W1 S  b, F9 {2 T: a
14.     //SWO
    
15.     log_func*       swo_log_func;
    
16. }log_dev;

复制代码

$ a. R& n+ i' l

    SWO只需要print操作函数，实现如下：

1. u8 swo_print_ch(u8 ch)
   
2. {
   3 ~: s6 a' f( o- a6 [; T
3.     ITM_SendChar(ch);
   
4.     return 0;
   / X' K  m. R4 }3 k- w- s, Y  e
5. }

复制代码

    使用SWO输出log同样先输出到log buffer，然后在系统空闲时再输出，当然也可以直接输出。log延迟输出会影响log的实时性，而直接输出会影响到对时间敏感的代码运行，所以如何取舍取决于需要输出log的情形。

    在while循环中调用output_ch()函数，就可以实现在系统空闲时输出log。

7 F4 z& i: P: Q" c1 d6 y/ R

1. /*output log buffer to I/O*/
   
2. void output_ch(void)
   
3. {   
   8 u9 G# Q) J9 ?! e2 q  J% }
4.     u8 ch;
   
5.     volatile u32 tmp_write,tmp_read;
   0 ?2 g6 n8 \5 e* W
6.     tmp_write = log_dev_ptr->write_idx;
   6 `4 D5 s  H7 @1 J4 t8 E2 u
7.     tmp_read = log_dev_ptr->read_idx;
   $ h) M, e9 }; X, g! ?+ ^
8. 
   % H: F8 z! P/ B: M" G
9.     if(tmp_write != tmp_read)
   
10.     {
    
11.         ch = log_dev_ptr->buffer[tmp_read++];
    
12.         //swo
    5 |$ _5 n/ s, B3 s$ d: {
13.         if(log_dev_ptr->swo_log_func)
    8 }$ V) H) M1 F
14.             log_dev_ptr->swo_log_func->print(ch);
    9 B" u$ F* O* T$ l5 v7 Z
15.         if(tmp_read >= LOG_MAX_LEN)
    
16.         {
    " @; S5 J7 N3 H: X: i3 w
17.             log_dev_ptr->read_idx = 0;
    
18.         }
    1 X: M/ {/ F" W# r) r
19.         else
    
20.         {
    ! N# W7 [! m. w
21.             log_dev_ptr->read_idx = tmp_read;
    . D% D3 F- C$ b$ c7 V7 S8 }/ K
22.         }
    
23.     }
    ( `7 @* A8 j( O3 d) k6 w
24. }

复制代码

2 H4 V0 e9 u0 g' Q

2.1 通过IDE输出

    使用IDE中SWO输出功能需要做如下配置（Keil）：

    在窗口可以看到输出的log：

2.2 通过STM32 ST-LINK Utility输出

    使用STM32 ST-LINK Utility不需要做特别的设置，直接打开ST-LINK菜单下的Printf via SWO viewer，然后按start：

. L  y' Z, }1 W

3 通过串口输出log

    以上都是在串口log暂时无法使用，或者只是临时用一下的方法，而适合长期使用的还是需要通过串口输出log，毕竟大部分时候没法连接仿真器。添加串口输出log只需要添加串口的操作函数集即可：

1. typedef struct
   
2. {
   
3.     volatile u8     type;
   
4.     u8*             buffer;
   
5.     volatile u32    write_idx;
   
6.     volatile u32    read_idx;
   ) h9 D: N3 [% l: j% r" c+ V
7.     volatile u32    dma_read_idx;
   ) s, x9 C  }3 j! p1 B" _! |3 G2 Z
8.     //uart
   1 @7 J3 ?; W1 C7 I# D" C
9.     log_func*       uart_log_func;
   
10.     //SWO
    0 S8 \  E$ ]4 V; u$ y
11.     log_func*       swo_log_func;
    
12. }log_dev;

复制代码

    实现串口驱动函数：

& ^3 D. F0 E: n4 {4 ~. G

5 e9 ~* f$ i" q% i: I' K0 x

    添加串口输出log与通过SWO过程类似，不再多叙述。而下面要讨论的问题是，串口的速率较低，输出数据需要较长时间，严重影响系统运行。

    虽然可以通过先打印到SRAM再延时输出的办法来减轻影响，但是如果系统中断频繁，或者需要做耗时运算，则可能会丢失log。要解决这个问题，就是要解决CPU与输出数据到串口同时进行的问题，嵌入式工程师立马可以想到DMA正是好的解决途径。

    使用DMA搬运log数据到串口输出，同时又不影响CPU运行，这样就可以解决输出串口log耗时影响系统的问题。串口及DMA初始化函数如下：

1. u8 uart_log_init(void* arg)
   
2. {
   
3.     DMA_InitTypeDef DMA_InitStructure;
   $ m& |0 q7 y; M! @
4.     u32* bound = (u32*)arg;
   % c% |- _" @. m# j* C" h
5.     //GPIO端口设置
   
6.     GPIO_InitTypeDef GPIO_InitStructure;
   
7.     USART_InitTypeDef USART_InitStructure;
   
8. 
   
9.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
   
10.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART2时钟
    9 Q6 o, s) H1 |* Z" m
11.     //串口2对应引脚复用映射
    # y( f" i" `7 d; Q5 F$ n
12.     GPIO_PinAFConfig(GPIOA,GPIO_PinSource2,GPIO_AF_USART2);
    
13.     //USART2端口配置
    
14.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    6 \9 }0 I, q7 k
15.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    
16.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    
17.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    * Q, s) d7 [7 d1 c7 h/ y
18.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    2 i0 K. d) d* F4 p
19.     GPIO_Init(GPIOA,&GPIO_InitStructure);
    2 r1 t  o' e/ f, {
20.     //USART2初始化设置
    0 Z) ~4 J5 b' P, }2 Y* o
21.     USART_InitStructure.USART_BaudRate = *bound;//波特率设置
    
22.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
23.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
24.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
25.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    ! l" A: ~( u% K2 f9 O; i& u" n
26.     USART_InitStructure.USART_Mode = USART_Mode_Tx; //收发模式
    ! S1 p" Q7 V% d
27.     USART_Init(USART2, &USART_InitStructure); //初始化串口1
    1 V  f7 ]$ ~' ]# l) G: l, p; G
28.     #ifdef LOG_UART_DMA_EN  
    
29.     USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);
    
30.     #endif  
    9 V: q6 n; j" t' D" I, f
31.     USART_Cmd(USART2, ENABLE);  //使能串口1
    
32.     USART_ClearFlag(USART2, USART_FLAG_TC);
    ' E$ z  ~8 f( q0 {; p/ h! w
33.     while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
    
34.     #ifdef LOG_UART_DMA_EN
    
35.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    
36.     //Config DMA channel, uart2 TX usb DMA1 Stream6 Channel
    ) H7 D* F$ |% e5 l* F
37.     DMA_DeInit(DMA1_Stream6);
    + o- O- A+ q9 ^5 I8 c  x7 ]" \
38.     DMA_InitStructure.DMA_Channel = DMA_Channel_4;
    
39.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART2->DR);
    
40.     DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
    
41.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    
42.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    ; Z2 T) {5 H4 H+ e. B
43.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    
44.     DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
    3 @# R! ], [0 s' a( e: [* p
45.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    # p8 ~' S6 ]( o# U  t8 D
46.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    3 j! y% u+ a# P, J: q
47.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
    
48.     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    + q. f1 Y( U" |$ ]$ K
49.     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    . F; l9 }- j5 n
50.     DMA_Init(DMA1_Stream6, &DMA_InitStructure);
    
51.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    5 W: H8 v8 F) a0 b# U4 g
52.     #endif
    , M$ U: h5 \0 t. ]
53.     return 0;
    
54. }

复制代码

    DMA输出到串口的函数如下：

. {/ {/ C( t8 y/ ]% B! d6 T

5 n2 O4 r9 K& x8 W' z& q1 q5 E) y

    这里为了方便直接使用了查询DMA状态寄存器，有需要可以修改为DMA中断方式，查Datasheet可以找到串口2使用DMA1 channel4的stream6：

5 W$ j  o: U" m4 R+ H

    最后在PC端串口助手可以看到log输出：

# O5 K" U/ S$ G

    使用DMA搬运log buffer中数据到串口，同时CPU可以处理其他事情，这种方式对系统影响最小，并且输出log及时，是实际使用中用的最多的方式。并且不仅可以用串口，其他可以用DMA操作的接口（如SPI、USB）都可以使用这种方法来打印log。

4 使用IO口模拟串口输出log

    最后要讨论的是在一些封装中没有串口，或者串口已经被用作其他用途时如何输出log，这时可以找一个空闲的普通IO，模拟UART协议输出log到上位机的串口工具。常用的UART协议如下：

2 B0 f& d. Q( f% y

% R, e# S, ?/ A& ?$ N

    只要在确定的时间在IO上输出高低电平就可以模拟出波形，这个确定的时间就是串口波特率。为了得到精确延时，这里使用TIM4定时器产生1us的延时。注意：定时器不能重复用，在测试工程中TIM2、3都被用了，如果重复用就错乱了。初始化函数如下：

1. u8 simu_log_init(void* arg)
   / ?$ U4 n* |4 I/ W
2. {
   # P  l% T' p/ K- W3 m
3.     TIM_TimeBaseInitTypeDef TIM_InitStructure;  
   
4.     u32* bound = (u32*)arg;
   : Q0 b# q2 L4 i, A
5.     //GPIO端口设置
   ' {- a- V. ]- u# J1 }5 b# T
6.     GPIO_InitTypeDef GPIO_InitStructure;
   6 R2 g( Y- n7 |% i4 }
7.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
   
8.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
   
9.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   % i3 T* _/ q4 Y$ y2 v4 `( c$ u
10.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    
11.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    8 B2 y6 P" ]- W+ Y# [8 a7 H0 p
12.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    ; H% X8 c5 G9 B$ U: T! j& T! Q; P
13.     GPIO_Init(GPIOA,&GPIO_InitStructure);
    ( L+ ~4 ~6 X: F$ n2 c
14.     GPIO_SetBits(GPIOA, GPIO_Pin_2);
    
15.     //Config TIM
    
16.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE); //使能TIM4时钟
    
17.     TIM_DeInit(TIM4);
    8 N) x9 n" d5 \
18.     TIM_InitStructure.TIM_Prescaler = 1;        //2分频
    
19.     TIM_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
20.     TIM_InitStructure.TIM_Period = 41;          //1us timer
    * Z+ h+ Z! m# W! t
21.     TIM_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    : r/ Q/ u# O7 H% A5 U$ w
22.     TIM_TimeBaseInit(TIM4, &TIM_InitStructure);
    ' ~" X5 r% Z% M1 M# L) u+ o, g
23.     TIM_ClearFlag(TIM4, TIM_FLAG_Update);
    
24.     baud_delay = 1000000/(*bound);          //根据波特率计算每个bit延时
    
25.     return 0;
    " @, y1 B" h9 S( w5 P8 i3 q/ s/ n
26. }

复制代码

    使用定时器的delay函数为：

( K5 P: N% I9 k. H; {2 _

    最后是模拟输出函数，注意：输出前必须要关闭中断，一个byte输出完再打开，否则会出现乱码：

1. 
   % H. e8 `7 S1 N- z3 k7 G
2. u8 simu_print_ch(u8 ch)
   
3. {
   * k8 W! u5 V, t1 n0 Y
4.     volatile u8 i=8;
   
5.     __asm("cpsid i");
   " b+ i* o! `0 k+ R9 \
6.     //start bit
   " \8 C9 N* Z. D
7.     GPIO_ResetBits(GPIOA, GPIO_Pin_2);
   
8.     simu_delay(baud_delay);
   5 |' i" x+ S! ~9 u5 T
9.     while(i--)
   
10.     {
    
11.         if(ch & 0x01)
    
12.         GPIO_SetBits(GPIOA, GPIO_Pin_2);
    
13.         else
    : O8 l' D+ v, V! t  J0 G
14.         GPIO_ResetBits(GPIOA, GPIO_Pin_2);
    
15.         ch >>= 1;
    9 {" i9 }/ x; e9 u* ?
16.         simu_delay(baud_delay);
    
17.     }
    
18.     //stop bit
    # p2 c1 G; C+ @+ _$ A4 F' \6 _& U/ C
19.     GPIO_SetBits(GPIOA, GPIO_Pin_2);
      R3 `. M4 }4 o5 F  }, b/ v; z, g; {/ K
20.     simu_delay(baud_delay);
    
21.     simu_delay(baud_delay);
    
22.     __asm("cpsie i");
    
23.     return 0;
    
24. }

复制代码

/ T$ c/ s3 S  P' K3 W  g3 f! c

    使用IO模拟可以达到与真实串口类似的效果，并且只需要一个普通IO，在小封装芯片上比较使用。

. D& f* T8 O# V2 n8 r