前言
4 i3 c6 y9 K. ~0 C3 j4 B1 \: K

    通俗的讲，适配器模式是将一个类的接口转换成客户希望的另外一个接口，在我们编写程序的时候，尤其是在我们使用到单片机做项目的时候，经常会用到。

    但是往往我们做项目写程序的时候，并没有想到那么多，如果在不带操作系统的情况下，想要整个框架易于移植，易于理解，那么我们真的需要好好想想这个设计模式怎么写了。

    下面我根据自己的项目经验，来说说适用于单片机的接口适配器模式的实现。大佬勿扰，多多指教。

一般实现

    在我们做项目的时候，一般的实现，可能我们会这样写代码

1. <font color="#001000"><font style="background-color:rgb(255, 255, 255)"><font face="Tahoma">
   
2. // FileName: test.c
   
3. // 来源：公众号【技术让梦想更伟大】
   
4. #include <stdio.h>
   * S; o9 d- g6 P; z) \
5. #include “ExternModule.h”
   / G$ M2 g* |5 i6 k
6. 
   
7. int main(void)
   
8. {
   
9. 
   , L& |- |7 x9 J) w" D
10.   /*初始化*/
    
11.   vAllInit();
    
12.   
    1 G; M& N+ c- W! E8 A; Q
13.   while(1)
    * _7 L, U; R7 m3 ]. t
14.   {
    
15.   
    6 G6 C6 s9 u; V9 D* F2 k0 Y8 u
16.     /*项目逻辑*/
    
17.     vLogicModule1();
    7 ^2 j* M; M0 q0 o
18.    
    
19.     vLogicModule2();
    1 n# n7 e, }' `, C5 E4 j! R
20.    
    ) D1 P  t+ l4 M$ E$ A; v9 m# a
21.   }
    
22. }</font></font></font>
    

复制代码

    在其外部文件中，调用相对应的初始化函数以及逻辑函数，但是当我们项目很复杂的时候，逻辑关系也层层覆盖、交替的时候，这样的写法就有些不是很好看了。

接口适配器

    首先我们还是要来定义数据结构，一般这样的项目分为这样几个步骤：

• 初始化
• 输入
• 处理
• 输出
  

    我们把这四个步骤封装起来，再定义数据结构如下：

1. <font color="#001000"><font style="background-color:rgb(255, 255, 255)"><font face="Tahoma">
   3 X7 G3 M, J5 V( g7 Y6 }
2. // FileName: test1.c
   " _" y% |! J) E0 n& L
3. // 来源：公众号【技术让梦想更伟大】
   0 f6 W) _5 C; d4 F8 v# L
4. /* 适配器类型定义 */
   0 K- U, {8 _9 a1 D/ E
5. struct _ADAPTER
   9 V) v: i; u; A( ~
6. {
   
7.     void (*Init    )( void );  //初始化函数
   
8.     void (*Input   )( void );  //输入转换函数
   
9.     void (*Process )( void );  //处理函数
   
10.     void (*Output  )( void );  //输出转换函数
    / _) z: C6 {+ {# F1 A5 r
11. };
    
12. typedef struct _ADAPTER ADAPTER ;</font></font></font>
    

复制代码

    那么初始化函数，我们先来这样定义

1. 
   5 c3 M, c$ B' R& f( S. q, A6 m. X% k
2. // FileName: test1.c
   
3. // 来源：公众号【技术让梦想更伟大】
   
4. /* 模块初始化 */
   # \& m* h  l" o9 j5 q- o! c
5. void moduleInit( ADAPTER *module )
   $ T, x/ h: h6 k& W) s  J
6. {
   ' V" `0 }4 q! R) u6 D, t9 M* C" S9 f" W: c
7.     if( module->Init != NULL )
   ' A3 Q2 O3 F, Q$ O3 @/ ~; d
8.     {
   
9.         module->Init();
   - [3 g5 d6 n9 l; n
10.     }
    
11. }

复制代码

    模块的逻辑运行，我们可以这样使用

1. <font color="#001000"><font style="background-color:rgb(255, 255, 255)"><font face="Tahoma">
   . G+ W/ o7 R9 j& T
2. // FileName: test1.c
   
3. // 来源：公众号【技术让梦想更伟大】
   0 c% s( H) D. ^" w- l! Z0 Y
4. /* 模块逻辑运行 */
   ) E' G/ O" Y( z, o$ X! c5 M9 S9 a
5. void moduleRun( ADAPTER *module )
   : @# p* V" P; a
6. {
   
7.     // 模块输入适配接口不为空，则执行输入适配操作
   9 V) h  D- @2 |9 C# y' J9 c
8.     if( module->Input != NULL )
   
9.     {
   
10.         module->Input();
    1 f' w( c2 X" K* h' e1 G
11.     }
    
12. 
    5 p) x  E! S8 j
13.     // 模块处理接口不为空，则执行处理操作   
    + s0 y: R0 K. i* ^' I* ~
14.    
    
15.     // 模块输出适配接口不为空，则执行输出适配操作
    ( J) X% P# _; l0 w) J
16. }</font></font></font>
    

复制代码

5 |0 i, k% R; Q

    在定好了这些数据结构以及封装之后，我们在每个子模块中都只需要调用这个模式即可。例如有一个需求，需要点一个灯，我们建立独立文件，在文件中申明

1. 
   
2. // FileName: led.c
   ' Z& G/ d! o8 f
3. // 来源：公众号【技术让梦想更伟大】
   - m9 e1 b7 T; Y. w0 B
4. /*led灯运行 */
   
5. ADAPTER LedModule = { vLedInit, NULL, vLedRunModule, NULL };

复制代码

    那么接下来只需要对初始化函数，逻辑运行函数进行描述就可以了。同理，我们需要一个按键的功能，在另一个独立文件申请

1. 
   : g. |! M/ B) }
2. // FileName: key.c
   / Z9 r( r9 ], l( d( s! d
3. // 来源：公众号【技术让梦想更伟大】
   
4. /*按键运行 */
   ( Y, L) m3 W. J: m
5. ADAPTER KeyModule = { vKeyInit, NULL, vKeyRunModule, NULL };

复制代码

    这样的话就便于我们拆分需求，便于移植，同时程序也就模块化了，最后我们在main文件中做的就是调用这些函数就行。我们需要这样做。

1. 
   
2. // FileName: main.c
   
3. // 来源：公众号【技术让梦想更伟大】
   % ~" x/ I7 y4 ?& |  G* r% r
4. /*主函数 */
   
5. void main( void )
   
6. {
   9 v/ G8 h  B- }
7. 
   " J$ l* b' K1 W; Y6 {! Y
8.     moduleInit( &LedModule         );
   9 c4 v4 o! i$ Y# H+ V( T
9.     moduleInit( &keyModule         );
   
10.    
    5 H; R. W* S/ G# r% k# z# m
11.     while( 1 )
    ) g' G( K: x& H
12.     {
    
13.         moduleRun( &LedModule        );
    ( b0 z1 Q4 w" O
14.         moduleRun( &keyModule        );
    4 B. l4 u% G3 C# D6 a3 Q/ H$ e
15.     }
    
16.    
    0 f( _) ?3 i0 y
17. }

复制代码

最后

    main函数就是这么简单了，整个架构也是很清晰，体现出编程之美。

谢谢分享

好厉害哦