但当一个项目软件代码多了以后，尤其是分了很多模块后，这样打印就不方便了，因为有时我只想看本模块的打印的信息，而又不想被其他模块信息干扰，怎么办呢？
一种简单直观的方法是为本模块单独写一个打印信息的函数来调用。然而当模块很多时，这样做就效率就不高了，并显得冗余。下面介绍我设计的一个可配置的模块打印信息的方法（此适用于裸机程序） 。
# `! F1 g- X6 t9 Q, z1 J
1 Y. S9 l, ?8 Q在此我单独写了一个 debug 模块，包含 debug.c 和 debug.h 两文件，.c 定义了所要调用打印信息函数等，.h 可配置，以方便地选择性打印你需要的模块信息。

如我一个工程中包含有系统模块、温度检测模块、电机控制模块，则首先在 debug.c 中定义如下字符串数组
9 {0 P/ }9 o; P3 f9 j1 r. U

1. char *DEBUG_MODULE_MSG[] =
   % }2 x% J9 \# w: }8 d  [
2. {
   
3.     "NOTHING",
   % |7 E: S/ O  T7 n" P
4.     "SYS",
   
5.     "TEMP",
   
6.     "MOTOR",
   ! r" P& {* I" ~
7. };

复制代码

在.h 中作如下定义

1. #if 1
   
2. #define SYS_DEBUG
   
3. #define TEMP_DEBUG
   
4. #define MOTOR_DEBUG
   . q" b; a$ h- Q( W7 }+ Y
5. #endif
   4 r& R  E2 c: }, M
6. //-------
   
7. #ifdef  SYS_DEBUG
   & ^4 O. E8 A' r# ^4 S- V
8. #define SYS   (1<<0)
   
9. #else
   
10. #define SYS    0
    
11. #endif
    
12. //-------
    4 S# [2 k$ t, f
13. #ifdef  TEMP_DEBUG
    $ j" ^3 s: q5 _6 H- z# R
14. #define TEMP  (1<<1)
    9 h8 c3 b$ M4 j
15. #else
    1 S& ?$ C* B+ n& s, E" B
16. #define TEMP    0
    / q6 B. X8 d% j$ W& W/ k
17. #endif
    
18. //-------
    
19. #ifdef  MOTOR_DEBUG
    
20. #define MOTOR (1<<2)
    
21. #else
    , y7 g$ {5 N$ a# A/ P
22. #define MOTOR 0
    7 k0 i0 T, F0 J; M6 n
23. #endif
    
24. #define DEBUG_MODULE_NUM  3
    
25. //-------

复制代码

其中通过最上面几个宏定义你就可以选择性地打印需要的模块的调试信息，不要打印的直接屏蔽掉就好了，如果再增加模块，只需再多定义一个宏，然把模块数量增加，并在字符串数组里依次添加此模块要打印出名称。

下面介绍如何对以上配置进行解析并按要求打印出来，在.c 里如下实现代码

1. /**
   9 N( o) I$ }5 W/ L: T
2.   * @brief  检测询要打印的模块
   / Z6 `& k* u1 p7 p
3.   * @param  module: 宏定义模块名
   
4.   * @retval 对应模块字符串偏移量
   * c1 d# i+ D  Z" F- z
5.   */
   
6. static u16 check_debug_sw(u module)  
   
7. {
   
8.     u16 i ;
   
9.    
   2 j5 n, Z" P- w- L3 c
10.     if (0 == module)
    ) s+ E) m$ p/ B
11.     {
    
12.         return 0;
    
13.     }
    
14.     else
    
15.     {
    
16.         for (i = 0; i < DEBUG_MODULE_NUM ; i++)
    . ]; u9 T  J7 g8 U8 i
17.         {
    
18.             if (module & (1 << i))
    " N* n, n: [( ]% g; H
19.             {
    $ E" y+ _5 f, p: A! J6 F  o6 i6 }
20.                 return (i + 1);
    - S0 Y" H3 S! i4 }; `
21.             }
    
22.         }
    $ u$ z/ ?- O/ t9 D$ _
23.     }
    
24.    
    7 [4 W  j! W7 C* v/ N, t1 S9 u
25.     return 0;
    
26. }

复制代码

此函数用于检测要打印的模块是否开启，如开启则返回模块对应的偏移量，以方便打印字符串数组中对应的模块名，若没找到，则返回 0。
! b6 L( C' B2 T! |
下面就是调试信息打印函数了，其实只需模仿 printf 函数的实现，并作简单的修改就可实现模块化打印。如下
6 J3 `: c7 O% A6 q

1. /**
   
2.   * @brief  可进行模块选择的可变参数的打印调试函数
   + s% I, L6 P& a. W7 F) P7 x3 M5 l9 ~
3.   * @param  module: 宏定义模块名  ...
   ) X) _* ?# q7 x
4.   * @retval None
   ! n* M/ R" {/ g2 U
5.   */
   
6. void Debug_Msg_Module_Printf(u16 module, char *fmt, ...)
   # J+ u; ?& E9 h6 g! O+ a, Q" R
7. {
   * i! G1 x2 m" t: G3 s3 }: F
8.     va_list ap;
   
9.     char *p = NULL , *sval = NULL;
   
10.     int  ival;
    ) l+ x$ M! h) G+ B- ~5 o/ C
11.     unsigned uval;
    5 j# ^& `! f8 B% Y  U
12.     double dval;
    % @5 p8 O. U& ~+ w7 Z5 ?
13.     u16 flag = 0 ;
      H. w  ]7 y7 ?
14.    
    # z' S5 Z6 e6 `# ?! E
15.     if (0 != (flag = check_debug_sw(module)))
    , S! q5 B6 d0 N) a& n3 O. |! z
16.     {
    / W# a1 n* o% r% c6 v8 ?
17.         printf("[ %s ]", DEBUG_MODULE_MSG[flag]);
    # G: H0 V7 T' a2 ~
18.         va_start(ap, fmt);
    
19.         
    ; u# m& ^. X% V( i2 G/ S
20.         for (p = fmt; *p; p++)
    ) h7 N5 c' A, e. S& y& _9 u% K
21.         {
    9 @' z- ~; t6 d8 J* o: p
22.             if (*p != '%')
    
23.             {
    ! \  p$ H( H% U; `* ~! z
24.                 putchar(*p);
    " d7 u7 W' E+ J
25.                 continue;
    
26.             }
    : A5 [8 U6 ~( O/ ?- l2 |2 j" E
27.             
    
28.             switch (*++p)
    
29.             {
    
30.                 case 'd':
    ; ?% \. L) w$ V% O6 ]
31.                 case 'i':
    
32.                     ival = va_arg(ap, int);
    
33.                     printf("%d", ival);
    
34.                     break;
    
35.                     
    
36.                 case 'c':
    
37.                     ival = va_arg(ap, int);
    . }( S. B- y2 U
38.                     putchar(ival);
    
39.                     break;
    ) h9 y- ^/ a5 k; A/ m
40.                     
    % ]( N/ f! U7 C
41.                 case 'u':
    ' V, A. I4 C% @3 u- y
42.                     uval = va_arg(ap, unsigned);
    
43.                     printf("%u", uval);
    
44.                     break;
    
45.                     
    9 \& L8 d4 H, D3 X8 ]
46.                 case 'x':
    
47.                     uval = va_arg(ap, unsigned);
    6 P) U. M; o0 K2 \9 K+ _! `
48.                     printf("%x", uval);
    
49.                     break;
    
50.                     
    
51.                 case 'X':
    
52.                     uval = va_arg(ap, unsigned);
    
53.                     printf("%X", uval);
    
54.                     break;
    3 f7 {5 ~$ O* O" a9 `" b
55.                     
    * O  i8 v7 _' E2 |
56.                 case 'o':
    / F' A3 s! ]6 F$ L2 w: H
57.                     uval = va_arg(ap, unsigned);
    
58.                     printf("%o", uval);
    
59.                     break;
    
60.                     
    ' I3 ?2 O3 w4 D' ?
61.                 case 'e':
    9 f8 j) T( z0 A9 V7 E7 T* e  S, `* O
62.                     dval = va_arg(ap, double);
    ) b, \; M! G; {5 [- L
63.                     printf("%e", dval);
    
64.                     break;
    ; y9 l1 C$ `0 b4 v0 h  _1 T
65.                     
    
66.                 case 'f':
    7 W$ e2 {' N# x# d8 i: p
67.                     dval = va_arg(ap, double);
    6 {) \) d/ _" k( T! G' ]3 a1 S
68.                     printf("%f", dval);
    - q( K" r% Y3 B3 K+ I0 D$ X. w2 X
69.                     break;
    3 m7 m/ G7 Q( ^4 Z1 ~. a
70.                     
    % J9 Y2 q7 I8 i6 o% N
71.                 case 'g':
    
72.                     dval = va_arg(ap, double);
    ) V) T/ b7 ]7 {* ^  Y
73.                     printf("%g", dval);
    
74.                     break;
    
75.                     
    
76.                 case 's':
    
77.                     for (sval = va_arg(ap, char *); *sval; sval++)
    
78.                     {
    % O9 S1 O: a3 h
79.                         putchar(*sval);
    
80.                     }
    
81.                     
    
82.                     break;
    ( Z7 D2 c3 s7 D6 z9 E: o1 B( J& z
83.                     
    
84.                 default :
    + n8 c7 V% S" h$ A- I
85.                     putchar(*p);
    1 v; a1 {( c: R  f. U
86.                     break;
    
87.             }
    
88.         }
    . F& f7 C; b4 d# V( O
89.         
    
90.         va_end(ap);
    
91.     }
    
92. }

复制代码

! |; O( h) c' S! |( i

至此，模块化信息打印方法就实现了。
* [: u! r  x& w$ ~: R1 f
/ Q3 ?  }7 i' T  K5 g1 ]要进行打印信息调试，如温度检测模块可以如下调用

1. Debug_Msg_Module_Printf(TEMP,"Temp is %d \n",temp);

复制代码

电机控制模块可如此调用：
+ k8 e( S9 y. D& F( ?

1. Debug_Msg_Module_Printf(MOTOR,"Motor Running \n");
   ) q2 P7 e/ M0 r( a7 f+ c/ B( F
2. Debug_Msg_Module_Printf(MOTOR,"Motor Stopped \n");

复制代码

如若要屏蔽掉所有的电机模块打印消息，只需要.h 文件中作如下修改：

1. #if 1
   ) ]: T8 f* S! Z9 S! ~0 |
2. #define SYS_DEBUG
   
3. #define TEMP_DEBUG
   3 Q# b( f; G+ K# Q
4. //#define MOTOR_DEBUG  //注释掉此行宏定义
   
5. #endif

复制代码

转载自：以太快跑