简述
/ q9 \% P; N; {6 W, [  m- j    IIC（Inter-Integrated Circuit）其实是IICBus简称，它是一种串行通信总线，使用多主从架构，在STM32开发中经常见到。


    关于IIC可以参考之前发的一篇文章《通信协议 IIC 与 SPI 最全对比》来了解。
8 a4 g/ s6 L0 `: Y- G) I

    使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。


    底层驱动方法不重要，封装的思想很重要。在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使用面向对象的思想封装AT24C64驱动。


( F8 d- z& z0 b0 U0 x6 YIIC驱动面向对象封装
) H+ {4 H0 [+ N4 D: z- ~5 \+ X    iic.h头文件主要是类模板的定义，具体如下：
1 b1 u7 a& ^' B

1. 
   
2. //定义IIC类
   
3. typedef struct IIC_Type
   
4. {
   ! S% b/ u  Z- Z$ @0 Q, Z
5.    //属性
   0 Y; O& w5 o, \" F
6.    GPIO_TypeDef  *GPIOx_SCL;  //GPIO_SCL所属的GPIO组(如：GPIOA)
   
7.    GPIO_TypeDef  *GPIOx_SDA;  //GPIO_SDA所属的GPIO组(如：GPIOA)
   
8.    uint32_t GPIO_SCL;     //GPIO_SCL的IO引脚(如：GPIO_PIN_0)
   
9.    uint32_t GPIO_SDA;     //GPIO_SDA的IO引脚(如：GPIO_PIN_0)
   
10.    //操作
    
11.    void (*IIC_Init)(const struct IIC_Type*);        //IIC_Init
    : g9 n$ ]/ N/ e; Z0 g, [
12.    void (*IIC_Start)(const struct IIC_Type*);       //IIC_Start
      |$ x$ }& k- K7 R* G- B+ E4 ]
13.    void (*IIC_Stop)(const struct IIC_Type*);        //IIC_Stop
    9 @# }) y- T9 Q/ T) {* I( a
14.    uint8_t (*IIC_Wait_Ack)(const struct IIC_Type*);    //IIC_Wait_ack,返回wait失败或是成功
    
15.    void (*IIC_Ack)(const struct IIC_Type*);       //IIC_Ack,IIC发送ACK信号
    & |4 h: M. m, z% \# J4 }
16.    void (*IIC_NAck)(const struct IIC_Type*);       //IIC_NAck,IIC发送NACK信号
    ! N4 s! Z1 H. w2 c8 D+ H
17.    void (*IIC_Send_Byte)(const struct IIC_Type*,uint8_t);       //IIC_Send_Byte，入口参数为要发送的字节
    
18.    uint8_t (*IIC_Read_Byte)(const struct IIC_Type*,uint8_t);     //IIC_Send_Byte，入口参数为是否要发送ACK信号
    
19.    void (*delay_us)(uint32_t);              //us延时
    6 T- g3 A2 B2 l. O# ?4 E- f3 Q
20. }IIC_TypeDef;

复制代码

  iic.c源文件主要是类模板具体操作函数的实现，具体如下：

1. //设置SDA为输入模式
   7 q7 r- B5 L. V
2. static void SDA_IN(const struct IIC_Type* IIC_Type_t)
   : a8 A- m& q) J' u0 L
3. {
   2 T5 i4 K7 F/ g
4.   uint8_t io_num = 0;  //定义io Num号
   
5.   switch(IIC_Type_t->GPIO_SDA)
   1 V3 e/ G) {& Q' L2 K$ G6 V/ x0 U- |
6.   {
   
7.    case GPIO_PIN_0:
   
8.     io_num = 0;
   $ h; l0 V: t  T9 }* {
9.    break;
   5 J: L8 x0 s$ A2 I2 [: L1 C
10.    case GPIO_PIN_1:
    - W' S% r  s- g0 S5 G/ N" R
11.     io_num = 1;
    
12.    break;
    
13.    case GPIO_PIN_2:
    * ~# ~- |2 n: F1 T" ]
14.     io_num = 2;
      t# P3 M! @4 d1 K9 |) o
15.    break;
    
16.    case GPIO_PIN_3:
      a% V- h- u6 u( H% T3 T/ p
17.     io_num = 3;
    3 o2 q2 ]+ h, C4 x* p  z8 M
18.    break;
    3 p6 R6 F0 x) ^  K, p- q: r: C: l
19.    case GPIO_PIN_4:
    
20.     io_num = 4;
    
21.    break;
    8 ~) w/ ^/ R/ v5 Z2 v" E% e
22.     case GPIO_PIN_5:
    
23.     io_num = 5;
    
24.    break;
    - G2 o1 H  n$ p. q, |1 ]
25.    case GPIO_PIN_6:
    
26.     io_num = 6;
    
27.    break;
    
28.    case GPIO_PIN_7:
    ( F3 E% C) j9 j$ G  D( m0 r5 k
29.     io_num = 7;
    - N  C* C$ d3 ?1 g
30.    break;
    * w9 t2 h$ {' c
31.    case GPIO_PIN_8:
    1 a4 j# Q0 v9 X  n
32.     io_num = 8;
    
33.    break;
    ! `, g  e5 m$ ~" A) f& P
34.    case GPIO_PIN_9:
    + E% U1 m. u$ m) U# ]# D- \1 [
35.     io_num = 9;
    $ M# t" C0 q! E2 u
36.    break;
    4 F! E; }6 }/ V! X
37.    case GPIO_PIN_10:
    
38.     io_num = 10;
    
39.    break;
    ( z" S1 ?4 J# J8 C' f" _
40.    case GPIO_PIN_11:
    : C( }! I% X9 D' F, w
41.     io_num = 11;
    , g% b! I; A* |; E
42.    break;
    1 y/ C* @5 o. c* M
43.    case GPIO_PIN_12:
    
44.     io_num = 12;
    $ c& a3 B% ?# }3 h
45.    break;
    
46.    case GPIO_PIN_13:
    5 u- M3 ?9 x$ H# i6 j
47.     io_num = 13;
    
48.    break;
    # j: p/ D6 o+ `
49.    case GPIO_PIN_14:
    ! h" ^& G% L! K( Q+ H8 x
50.     io_num = 14;
    
51.    break;
    
52.    case GPIO_PIN_15:
    ! D6 C& c) ^/ S
53.     io_num = 15;
    ( t8 e. n0 U% `0 t  r1 V; i) }
54.    break;
    
55.   }
    
56.   IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
    
57.   IIC_Type_t->GPIOx_SDA->MODER|=0<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输入模式
    # X, }$ k/ A: \; V0 E5 Q" u- h
58. }
    8 B; v$ i: W: `; {1 ~4 b7 f) S
59. 
    
60. //设置SDA为输出模式
    1 u2 I, d2 }4 `! m/ L- X4 u
61. static void SDA_OUT(const struct IIC_Type* IIC_Type_t)
    
62. {
    
63.   uint8_t io_num = 0;  //定义io Num号
    % O- S$ l8 e& W6 B
64.   switch(IIC_Type_t->GPIO_SDA)
    
65.   {
    
66.    case GPIO_PIN_0:
    1 w$ z( p7 y. p/ e7 D
67.     io_num = 0;
    
68.    break;
    ! M. @, L% x5 Y5 P4 B3 c
69.    case GPIO_PIN_1:
    , r7 l) L5 d6 y) h! }- T
70.     io_num = 1;
    
71.    break;
    
72.    case GPIO_PIN_2:
    6 z/ ^+ Z: S) w% f/ m% x/ b0 G
73.     io_num = 2;
    * I5 y0 _) F$ }, h
74.    break;
    0 K( Z/ {  _. \; A
75.    case GPIO_PIN_3:
    
76.     io_num = 3;
    % ~4 H' B& j0 G6 z- K' O, k* U
77.    break;
    
78.    case GPIO_PIN_4:
    
79.     io_num = 4;
    
80.    break;
    ' C& N- W3 r' F, L
81.     case GPIO_PIN_5:
    
82.     io_num = 5;
    ; X9 d: H% J2 E; V& j
83.    break;
    # d1 w9 g3 r5 k9 A
84.    case GPIO_PIN_6:
    1 l. W) G% }# t& c
85.     io_num = 6;
    
86.    break;
    7 w- F  B1 z' L, i6 e/ s3 D
87.    case GPIO_PIN_7:
    ; u5 m7 e2 _+ ^4 ~! k( D  H
88.     io_num = 7;
    
89.    break;
    5 r. }" v- I% s6 |
90.    case GPIO_PIN_8:
    
91.     io_num = 8;
    
92.    break;
    
93.    case GPIO_PIN_9:
    6 \1 u+ k/ `/ F7 L/ r/ x, e* x& E5 P
94.     io_num = 9;
    % I5 T# z( K0 `% U1 L/ }
95.    break;
    
96.    case GPIO_PIN_10:
    4 R- s( }8 \1 s& F0 A
97.     io_num = 10;
    - s9 b" C; Z& O
98.    break;
    
99.    case GPIO_PIN_11:
    
100.     io_num = 11;
     ; R/ C! f- c! q- u% S" f8 U
101.    break;
     / }# l& ~3 q0 ~
102.    case GPIO_PIN_12:
     8 Y/ e( b) m- p/ I4 o" N! B
103.     io_num = 12;
     / {8 \0 `8 n# F" q* H) W
104.    break;
     
105.    case GPIO_PIN_13:
     
106.     io_num = 13;
     3 A; _# k7 h0 {0 b3 r! C/ {7 w
107.    break;
     
108.    case GPIO_PIN_14:
     % h  k, m$ g0 ^7 u/ @' d* T& G
109.     io_num = 14;
     
110.    break;
     
111.    case GPIO_PIN_15:
     
112.     io_num = 15;
     * N- B( r) Y4 L+ x* v
113.    break;
     , o4 f5 n0 n% v3 b  Y
114.   }
     " b7 @: ^5 {. b6 g2 S) `
115.   IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
     , d+ f" b7 H/ {% m" u& H
116.   IIC_Type_t->GPIOx_SDA->MODER|=1<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输出模式
       `5 I  {4 t7 \* p0 g  H
117. }
     
118. //设置SCL电平
     9 I1 J5 u1 ^: [: A$ j6 J: b5 x; I
119. static void IIC_SCL(const struct IIC_Type* IIC_Type_t,int n)
     ) Z, c; E$ E4 j
120. {
     % H1 x; R" m" ?" p/ P9 f
121.   if(n == 1)
     
122.   {
     6 a3 t4 c) d* h
123.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_SET);     //设置SCL为高电平
     " U. X( O2 H9 V  y+ T" g
124.   }
     
125.   else{
     7 S, [) u/ ^7 c/ \0 Y4 e& z
126.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_RESET);     //设置SCL为低电平
     
127.   }
     
128. }
     
129. //设置SDA电平
     
130. static void IIC_SDA(const struct IIC_Type* IIC_Type_t,int n)
     . F3 l& V( q7 X) C4 q0 K0 N( m
131. {
     4 ~. l: W+ I$ u- `) o6 `$ I& s0 u
132.   if(n == 1)
     0 R9 {# r5 V( |
133.   {
     8 o1 d; V$ f7 y3 F' Y! p
134.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_SET);     //设置SDA为高电平
     & r  [$ I2 q0 Q$ [  j* G
135.   }
     
136.   else{
     
137.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_RESET);     //设置SDA为低电平
     0 z) i# @$ o8 _; ]' b4 v% s
138.   }
     
139. }
     
140. //读取SDA电平
     
141. static uint8_t READ_SDA(const struct IIC_Type* IIC_Type_t)
     
142. {
     
143.   return HAL_GPIO_ReadPin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA);  //读取SDA电平
     1 F. G4 j- C' I/ \# X* ?# c6 G
144. }
     ; k- X& B: w, O: Y
145. //IIC初始化
     
146. static void IIC_Init_t(const struct IIC_Type* IIC_Type_t)
     2 i: \* S9 N9 s: j
147. {
     
148.       GPIO_InitTypeDef GPIO_Initure;
     ) B+ J# T- z, b, j( i- E9 |5 H
149.    
     # X& Y0 ~* w% P5 B& f' ^
150.    //根据GPIO组初始化GPIO时钟
     
151.    if(IIC_Type_t->GPIOx_SCL == GPIOA || IIC_Type_t->GPIOx_SDA == GPIOA)
     + F, m$ O5 j5 t3 i) a6 C  J
152.    {
     8 _/ w$ T6 F) H+ y
153.      __HAL_RCC_GPIOA_CLK_ENABLE();   //使能GPIOA时钟
     ( {" V! d' F0 O$ S  P- f' Y
154.    }
     & q3 z' _% L8 A' A- y
155.    if(IIC_Type_t->GPIOx_SCL == GPIOB || IIC_Type_t->GPIOx_SDA == GPIOB)
     3 M$ [: [1 u% }1 Z8 E* R3 U% ?- C
156.    {
     $ E/ S8 ~+ u) \, G6 A. \1 j4 `
157.      __HAL_RCC_GPIOB_CLK_ENABLE();   //使能GPIOB时钟
     ; d- T$ v; g! x* Z
158.    }
     * L) A- n: ^! o) L' ~2 l: \
159.    if(IIC_Type_t->GPIOx_SCL == GPIOC || IIC_Type_t->GPIOx_SDA == GPIOC)
     2 `( ?* q3 q( o0 |9 K! @7 l
160.    {
     % o( c5 X% ~: m. |6 A) J4 [# W; V! R
161.      __HAL_RCC_GPIOC_CLK_ENABLE();   //使能GPIOC时钟
     + d  L: e, g$ l4 M! K, x
162.    }
     
163.    if(IIC_Type_t->GPIOx_SCL == GPIOD || IIC_Type_t->GPIOx_SDA == GPIOD)
     
164.    {
     
165.      __HAL_RCC_GPIOD_CLK_ENABLE();   //使能GPIOD时钟
     
166.    }
     
167.    if(IIC_Type_t->GPIOx_SCL == GPIOE || IIC_Type_t->GPIOx_SDA == GPIOE)
     % v; v+ x' i8 U, c
168.    {
     - y1 P3 D/ L& I6 r
169.      __HAL_RCC_GPIOE_CLK_ENABLE();   //使能GPIOE时钟
       Z; `# p/ W% N9 w4 b
170.    }
     
171.    if(IIC_Type_t->GPIOx_SCL == GPIOH || IIC_Type_t->GPIOx_SDA == GPIOH)
     # R) F) z' G2 j  c
172.    {
     
173.      __HAL_RCC_GPIOH_CLK_ENABLE();   //使能GPIOH时钟
     / ]+ \& y! T5 m) G
174.    }     
     
175.    
     # Z& R! c, `8 q
176.      //GPIO_SCL初始化设置
       A; ^* q2 c+ N2 P& W1 v5 z: L  R4 S4 b
177.      GPIO_Initure.Pin=IIC_Type_t->GPIO_SCL;
     ; |! Z6 s; ~: S- ~' E2 \* M+ u
178.      GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
     
179.      GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
     
180.      GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
     * c% \: A4 F- J; N5 s3 Q1 Y; o
181.      HAL_GPIO_Init(IIC_Type_t->GPIOx_SCL,&GPIO_Initure);
     6 W: ~( X8 H2 ^6 T* l7 \" U
182.      //GPIO_SDA初始化设置
     
183.      GPIO_Initure.Pin=IIC_Type_t->GPIO_SDA;
     7 u) R: |" d  A6 ~7 O+ [
184.      GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
     ) N' D0 G* _% e: j. K
185.      GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
     
186.      GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
     
187.      HAL_GPIO_Init(IIC_Type_t->GPIOx_SDA,&GPIO_Initure);
     % A1 N  V/ ?- M6 k
188.      
     % l- Y4 q, a! X% |' J2 S' M3 J
189.             //SCL与SDA的初始化均为高电平
     2 U8 n$ R0 m$ D. `& t' T
190.       IIC_SCL(IIC_Type_t,1);
     , Q& }, a) l% y! n
191.        IIC_SDA(IIC_Type_t,1);
     
192. }
     
193. //IIC Start
     ' P- d5 o5 N! C2 `5 q5 A
194. static void IIC_Start_t(const struct IIC_Type* IIC_Type_t)
     7 W* k" N8 p6 O* R7 t4 K
195. {
     ' L. Q. c. r, t% i5 Q+ Z0 \
196.   SDA_OUT(IIC_Type_t);      //sda线输出
     5 E, @5 f8 o7 k, C" Q: P
197.   IIC_SDA(IIC_Type_t,1);      
     * ?, Z1 `2 Y4 n7 d6 i( a  h
198.   IIC_SCL(IIC_Type_t,1);
     
199.   IIC_Type_t->delay_us(4);
     
200.    IIC_SDA(IIC_Type_t,0);  //START:when CLK is high,DATA change form high to low
     : r/ A* c  `9 c$ Y( D% n/ L- [; [" y
201.   IIC_Type_t->delay_us(4);
     / L2 @& M2 |$ y( |( }' ?- a
202.   IIC_SCL(IIC_Type_t,0);  //钳住I2C总线，准备发送或接收数据
     / ^. N5 C$ ~$ O* l  R$ j; [
203. }
     
204. //IIC Stop
     
205. static void IIC_Stop_t(const struct IIC_Type* IIC_Type_t)
     
206. {
     
207.   SDA_OUT(IIC_Type_t); //sda线输出
     
208.   IIC_SCL(IIC_Type_t,0);
     - j1 O$ D3 B3 S' P! h) E
209.   IIC_SDA(IIC_Type_t,0); //STOP:when CLK is high DATA change form low to high
     
210.    IIC_Type_t->delay_us(4);
     ) N5 `, Z4 \" e3 S" p- e
211.   IIC_SCL(IIC_Type_t,1);
     
212.   IIC_SDA(IIC_Type_t,1); //发送I2C总线结束信号
     ) j7 E8 q( f5 Q" A1 `! x
213.   IIC_Type_t->delay_us(4);
     : A/ e( J) a9 T! s
214. }
     0 V: S6 j. f% ?+ x' ^
215. //IIC_Wait_ack 返回HAL_OK表示wait成功，返回HAL_ERROR表示wait失败
     
216. static uint8_t IIC_Wait_Ack_t(const struct IIC_Type* IIC_Type_t)   //IIC_Wait_ack,返回wait失败或是成功
     ' ]: r. o# m8 q/ R% T" j
217. {
     & j9 T# J; ~, p# R% H  }
218.   uint8_t ucErrTime = 0;
     
219.   SDA_IN(IIC_Type_t);      //SDA设置为输入  
     
220.   IIC_SDA(IIC_Type_t,1);IIC_Type_t->delay_us(1);   
     
221.   IIC_SCL(IIC_Type_t,1);IIC_Type_t->delay_us(1);
     + m4 \1 ^0 g( i/ p- u5 D8 G
222.   while(READ_SDA(IIC_Type_t))
     
223.   {
     4 x/ j  o# p( [/ _3 H, K
224.     ucErrTime++;
     
225.     if(ucErrTime>250)
     + c3 U7 S) V  n4 P. m$ g
226.     {
     
227.       IIC_Type_t->IIC_Stop(IIC_Type_t);
     
228.       return HAL_ERROR;
     3 w/ W! @6 c: R. c3 m5 y5 R
229.     }
     4 H$ ]$ A; H$ a/ e8 n9 N0 Q9 i* K! X
230.   }
     4 }0 l- _, U7 X
231.   IIC_SCL(IIC_Type_t,0);//时钟输出0     
     + h' v8 S; J8 d' T0 y( L+ Q
232.   return HAL_OK;  
     
233. }
     + r0 Y! ~. J) F8 f8 M# ]
234. //产生ACK应答
       y5 k+ y  R! u' c: _
235. static void IIC_Ack_t(const struct IIC_Type* IIC_Type_t)      
     ! I& H6 }; E" w8 Q
236. {
     ' ~8 Q; `9 i# u
237.   IIC_SCL(IIC_Type_t,0);
       F8 w$ W/ ]' d9 z
238.   SDA_OUT(IIC_Type_t);
     4 s4 V" f) a& T7 S, W; K0 I
239.   IIC_SDA(IIC_Type_t,0);
     
240.   IIC_Type_t->delay_us(2);  
     ' i5 i( u- ?" w: g$ a, u
241.   IIC_SCL(IIC_Type_t,1);
     
242.   IIC_Type_t->delay_us(2);  
     
243.   IIC_SCL(IIC_Type_t,0);
     / J8 o8 X" o' w$ x( F: N% K5 d9 o5 K
244. }
     # c7 B% m2 A& \
245. //产生NACK应答
     # @9 {: r( t. h5 M, h% {" ~2 t; s
246. static void IIC_NAck_t(const struct IIC_Type* IIC_Type_t)      
     
247. {
     
248.   IIC_SCL(IIC_Type_t,0);
     1 L+ h- x. J5 M# n6 F7 h6 ?: G1 H3 s
249.   SDA_OUT(IIC_Type_t);
     
250.   IIC_SDA(IIC_Type_t,1);
     4 t& x  o5 a" g) h$ L3 ]6 R0 G
251.   IIC_Type_t->delay_us(2);  
     
252.   IIC_SCL(IIC_Type_t,1);
     
253.   IIC_Type_t->delay_us(2);  
     
254.   IIC_SCL(IIC_Type_t,0);
     ) q7 O- X' M8 H" R; S( X
255. }
     5 t) @) z0 r. E, A
256. //IIC_Send_Byte，入口参数为要发送的字节
     
257. static void IIC_Send_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t txd)     
     
258. {
     5 G, O( F$ u+ {" G, f' n
259.      uint8_t t = 0;   
     
260.      SDA_OUT(IIC_Type_t);      
     
261.      IIC_SCL(IIC_Type_t,0);//拉低时钟开始数据传输
     2 i8 r% C$ H5 L( E1 N
262.      for(t=0;t<8;t++)
     # k" A8 E: d- c$ J
263.      {              
     
264.           IIC_SDA(IIC_Type_t,(txd&0x80)>>7);
     
265.           txd <<= 1;   
       ~  e6 w7 g" j' l; c/ |5 F; s
266.        IIC_Type_t->delay_us(2);     //对TEA5767这三个延时都是必须的
     
267.        IIC_SCL(IIC_Type_t,1);
     
268.        IIC_Type_t->delay_us(2);  
     ( f$ t' M( q8 d
269.        IIC_SCL(IIC_Type_t,0);
     
270.        IIC_Type_t->delay_us(2);  
     & I' H, L$ z$ n/ D1 @: Z' t# |
271.      }  
     
272. }
     
273. //IIC_Send_Byte，入口参数为是否要发送ACK信号
     ( Q& r5 q6 G# j: W6 O3 p
274. static uint8_t IIC_Read_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t ack)     
     
275. {
     8 p* a: S: _9 o* X, F( ^  p
276.    uint8_t i,receive = 0;
     
277.    SDA_IN(IIC_Type_t);//SDA设置为输入
     ' d4 J$ }- U0 ]3 F, O" r6 v
278.    for(i=0;i<8;i++ )
     
279.    {
     / Z: E( G- s! g
280.       IIC_SCL(IIC_Type_t,0);
     ! Z$ [5 V6 _; S2 N. l# c, N' R
281.       IIC_Type_t->delay_us(2);
     ) p' O; ^$ c; r- U
282.       IIC_SCL(IIC_Type_t,1);
     
283.       receive<<=1;
     7 F$ p' z( w' u" ?3 Z4 [2 R
284.       if(READ_SDA(IIC_Type_t))receive++;   
     
285.       IIC_Type_t->delay_us(1);
     
286.    }      
     
287.   if (!ack)
     ! J5 y9 b1 ]2 R# |8 _6 u) u# E
288.          IIC_Type_t->IIC_NAck(IIC_Type_t);//发送nACK
     
289.   else
     . S$ L* p% p1 a, r5 @1 p
290.          IIC_Type_t->IIC_Ack(IIC_Type_t); //发送ACK   
     " }4 S; `2 U, N1 n7 a& z: z: E
291.   return receive;
     
292. }
     
293. //实例化一个IIC1外设，相当于一个结构体变量，可以直接在其他文件中使用
     9 F/ E5 W, \, y/ s
294. IIC_TypeDef IIC1 = {
     
295.   .GPIOx_SCL = GPIOA,   //GPIO组为GPIOA
     & U5 C# S8 Y/ h5 T9 {9 C- [; n; a
296.   .GPIOx_SDA = GPIOA,   //GPIO组为GPIOA
     
297.   .GPIO_SCL = GPIO_PIN_5,   //GPIO为PIN5
     8 E3 P' z& u1 q! K
298.   .GPIO_SDA = GPIO_PIN_6,  //GPIO为PIN6
     
299.   .IIC_Init = IIC_Init_t,
     
300.   .IIC_Start = IIC_Start_t,
     
301.   .IIC_Stop = IIC_Stop_t,
     , v. H3 b$ y$ d, J$ Q3 C
302.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
     % Q7 u0 n9 x' E
303.   .IIC_Ack = IIC_Ack_t,
     
304.   .IIC_NAck = IIC_NAck_t,
     + ~  P# }4 b4 y! s; |1 v8 n
305.   .IIC_Send_Byte = IIC_Send_Byte_t,
     * ?( m* i& s1 l6 ~8 O) q: X
306.   .IIC_Read_Byte = IIC_Read_Byte_t,
     
307.   .delay_us = delay_us     //需自己外部实现delay_us函数
     
308. };

复制代码

上述就是IIC驱动的封装，由于没有应用场景暂不测试其实用性，待下面ATC64的驱动缝缝扎黄写完之后一起测试使用。
( g3 C5 T$ v. Z; x7 h2 Z

* G6 c/ Q: p0 d. M' m/ XATC64XX驱动封装实现
    at24cxx.h头文件主要是类模板的定义，具体如下：

1. // 以下是共定义个具体容量存储器的容量
   
2. #define AT24C01  127
   % w" ]+ Q7 }. L
3. #define AT24C02  255
   : n& M: {- q( }1 J, a1 h7 \* v
4. #define AT24C04  511
   
5. #define AT24C08  1023
   & c( D9 T0 L  O; R- L* l
6. #define AT24C16  2047
   
7. #define AT24C32  4095
   
8. #define AT24C64   8191         //8KBytes
   1 n* O6 Z6 j' o3 `0 Z/ a
9. #define AT24C128 16383
   
10. #define AT24C256 32767  
    8 G( m, X' v' }6 R" Q
11. 
    5 @8 }& Q4 u( s
12. //定义AT24CXX类
    ( |# i7 y4 T+ ~) |! S7 ^' e) x
13. typedef struct AT24CXX_Type
    & N- ~3 t( E$ }! b7 s8 `
14. {
    ( q' L8 e( ]1 u# C1 H- x
15.   //属性
    
16.   u32 EEP_TYPE;           //存储器类型（存储器容量）
    
17.   //操作
    5 z$ \& Q" l5 \" M
18.   IIC_TypeDef IIC;       //IIC驱动
    
19.   uint8_t (*AT24CXX_ReadOneByte)(const struct AT24CXX_Type*,uint16_t);  //指定地址读取一个字节
    , ~/ \. |3 D* o
20.   void (*AT24CXX_WriteOneByte)(const struct AT24CXX_Type*,uint16_t,uint8_t); //指定地址写入一个字节
    
21.   void (*AT24CXX_WriteLenByte)(uint16_t,uint32_t,uint8_t); //指定地址开始写入指定长度的数据
    " N# {6 @9 [" s3 l; e: `
22.   uint32_t (*AT24CXX_ReadLenByte)(uint16_t,uint8_t);   //指定地址开始读取指定长度数据
    8 K2 u$ N$ o, D! l! `1 S$ v1 Z
23.   void (*AT24CXX_Write)(uint16_t,uint8_t *,uint16_t);  //指定地址开始写入指定长度的数据
    
24.   void (*AT24CXX_Read)(uint16_t,uint8_t *,uint16_t);   //指定地址开始写入指定长度的数据
    
25.   void (*AT24CXX_Init)(const struct AT24CXX_Type*); //初始化IIC
    . S: e5 a5 P# C- O" k
26.   uint8_t (*AT24CXX_Check)(const struct AT24CXX_Type*);   //检查器件
    
27. }AT24CXX_TypeDef;
    6 W0 m4 h! w5 k) U
28. 
    0 b4 l/ }; ~: a  _4 H; i
29. extern AT24CXX_TypeDef AT24C_64;     //外部声明实例化AT24CXX对象

复制代码

at24cxx.c源文件主要是类模板具体操作函数的实现，具体如下：
# R' Y' X6 q& p6 K  F

1. //在AT24CXX指定地址读出一个数据
   ( F7 C& }4 k5 [5 w0 k
2. //ReadAddr:开始读数的地址  
   
3. //返回值  :读到的数据
   
4. static uint8_t AT24CXX_ReadOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t ReadAddr)
   6 b( L: ~7 A8 i' I" Z
5. {      
   
6.   uint8_t temp=0;                          
   3 \4 \! s0 c& t. P
7.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);  
   
8.   //根据AT的型号发送不同的地址
   
9.   if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
   7 }) _# M9 L% N9 ~, g  t
10.   {
    
11.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
    
12.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    ( ^5 a/ n" d  q" T
13.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr>>8);//发送高地址     
    
14.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据     
    
15.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    
16.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr%256);   //发送低地址
    
17.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);     
    ( t) n4 c7 E$ ?4 D- V# q2 d" t7 q" g
18.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);        
    ; b4 {: D# Y& v1 k5 v/ z
19.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA1);           //进入接收模式      
    
20.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);  
    $ m# V3 r* S7 n
21.   temp=AT24CXX_Type_t->IIC.IIC_Read_Byte(&AT24CXX_Type_t->IIC,0);     
    
22.   AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件     
    
23.   return temp;
    
24. }
    
25. //在AT24CXX指定地址写入一个数据
    
26. //WriteAddr  :写入数据的目的地址   
    
27. //DataToWrite:要写入的数据
    
28. static void AT24CXX_WriteOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t WriteAddr,uint8_t DataToWrite)
    
29. {                                
    / `$ h: e) c1 Q
30.    AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);   
    4 S3 B- _7 E1 R4 @2 D# {$ G1 J
31.   if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
    
32.   {
    4 k6 z# }  _. C4 `0 s$ `7 ]3 q
33.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
    
34.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    
35.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr>>8);//发送高地址     
    * A' Y! T) O9 J" P' a* g) B) @
36.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据     
    
37.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    ! M7 n; ^' Z, n, z
38.    AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr%256);   //发送低地址
    0 W- o: y3 V- m
39.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);               
    
40.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,DataToWrite);     //发送字节         
    
41.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);            
    . P1 j) S9 f- ?" D. H: x0 w6 a
42.    AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件
    ' u/ f. E" y' @6 D) K4 B- l4 Z& X
43. AT24CXX_Type_t->IIC.delay_us(10000);  
    
44. }
    
45. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    
46. //该函数用于写入16bit或者32bit的数据.
    * `( A* N! C$ x3 Z2 I9 v/ F
47. //WriteAddr  :开始写入的地址  
    ( ]3 C! r8 m, v3 v0 \, a$ k
48. //DataToWrite:数据数组首地址
    + M8 `! P6 k" Z& b
49. //Len        :要写入数据的长度2,4
    
50. static void AT24CXX_WriteLenByte_t(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
    % j" ]; K, S) G* p
51. {   
    9 G/ O  U: C* [! o" g
52.   uint8_t t;
    
53.   for(t=0;t<Len;t++)
    : v* k) |$ ^! u2 F: [, @
54.   {
    . m: {; i( Q- C% p
55.     AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    : y1 b+ g/ ^+ {( g0 w- ]
56.   }               
    
57. }
    
58. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    5 w( _  z) o1 E/ k
59. //该函数用于读出16bit或者32bit的数据.
    , d& d2 v+ w: B+ `
60. //ReadAddr   :开始读出的地址
    
61. //返回值     :数据
    , Q1 @: l. X1 W$ h) P) S0 C
62. //Len        :要读出数据的长度2,4
    
63. static uint32_t AT24CXX_ReadLenByte_t(uint16_t ReadAddr,uint8_t Len)
    
64. {   
    
65.   uint8_t t;
    & E+ i- p+ S8 ]6 G% Z% K  o% d/ A/ x
66.   uint32_t temp=0;
    ; C$ j$ p9 G( l6 ~( a& W- H  D
67.   for(t=0;t<Len;t++)
    : O, N* J/ x6 @6 x/ `
68.   {
    
69.     temp<<=8;
    : {# X; ~2 y$ U4 y' s) R) s7 ?; @, V
70.      temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);         
    
71.   }
    
72.   return temp;               
    , L* z5 r7 l5 X9 [+ e/ F. ~( p$ k
73. }
    0 H+ C7 ?  U8 n* A
74. //在AT24CXX里面的指定地址开始写入指定个数的数据
    
75. //WriteAddr :开始写入的地址 对24c64为0~8191
    
76. //pBuffer   :数据数组首地址
    0 e8 K3 n- R. y0 ]
77. //NumToWrite:要写入数据的个数
    9 d- V' p. F- F. s9 }+ F
78. static void AT24CXX_Write_t(uint16_t WriteAddr,uint8_t *pBuffer,uint16_t NumToWrite)
      G/ ~& N+ X2 F& Z4 Q7 R  D
79. {
    % ]- Q. _; h8 V$ E; d
80.   while(NumToWrite--)
    , x. N( c3 B5 |4 u8 Y
81.   {
    
82.    AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
    ) d- i0 m2 l$ r( P7 s3 I5 ]
83.     WriteAddr++;
    
84.     pBuffer++;
    
85.   }
    0 ^  s7 u4 t+ A
86. }
    
87. //在AT24CXX里面的指定地址开始读出指定个数的数据
    1 m. k1 }( P' }7 x
88. //ReadAddr :开始读出的地址 对24c64为0~8191
    
89. //pBuffer  :数据数组首地址
    " V" u! c6 E/ L, `. L+ }8 Q1 V* h9 i
90. //NumToRead:要读出数据的个数
    / B- ^) g4 ^: j$ j/ J
91. static void AT24CXX_Read_t(uint16_t ReadAddr,uint8_t *pBuffer,uint16_t NumToRead)
    8 C$ H" _- s2 y' r7 G
92. {
    : _7 ~% ]1 A7 y
93.   while(NumToRead)
    3 D4 d( J0 }& H# I+ H  Z
94.   {
    8 J; _4 \7 |0 y
95.     *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
    
96.     NumToRead--;
    
97.   }
    ) |9 c5 ~- `- _' j
98. }
    
99. //初始化IIC接口
    
100. static void AT24CXX_Init_t(const struct AT24CXX_Type* AT24CXX_Type_t)
     0 s7 E' y: n4 f9 n6 z8 [* B4 ^, G5 f
101. {
     " V; F% A1 D3 L; M; h  j* d
102.   AT24CXX_Type_t->IIC.IIC_Init(&AT24CXX_Type_t->IIC);//IIC初始化
     
103. }
     
104. //检查器件,返回0表示检测成功,返回1表示检测失败
     . U6 Z% q1 F! {- @7 ~
105. static uint8_t AT24CXX_Check_t(const struct AT24CXX_Type* AT24CXX_Type_t)   
     . M0 T" t% b7 C' I# s: a
106. {
     & }; l5 b; f" k9 E( K# ~
107. uint8_t temp;
     
108.   temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);//避免每次开机都写AT24CXX      
     
109.   if(temp == 0X33)return 0;     
     ) p8 h9 ^9 k+ Z/ z
110.   else//排除第一次初始化的情况
     $ e$ T+ v& z% c
111.   {
     
112.       AT24CXX_Type_t->AT24CXX_WriteOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE,0X33);
     0 u* H% V9 J, ~0 e3 a$ U3 h* c4 I
113.        temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);
     
114.       if(temp==0X33)return 0;
     
115.   }
     2 s1 t) r. @* Q7 X
116.   return 1;  
     
117. }
     
118. //实例化AT24CXX对象
       e' G$ ]8 r4 I6 n  K
119. AT24CXX_TypeDef AT24C_64={
     
120. .EEP_TYPE = AT24C64,           //存储器类型（存储器容量）
     
121. //操作
     5 x- N) M, f4 l) P
122. .IIC={
     8 ]9 R: \7 M9 k) X! f( J+ C
123.   .GPIOx_SCL = GPIOA,
     ( M( ]$ {* k0 `' g* U9 y
124.   .GPIOx_SDA = GPIOA,
     
125.   .GPIO_SCL = GPIO_PIN_5,
     
126.   .GPIO_SDA = GPIO_PIN_6,
     . v5 N1 d; N& z( n/ |, q" d
127.   .IIC_Init = IIC_Init_t,
     + m. h3 |: T" X, u) `) O
128.   .IIC_Start = IIC_Start_t,
       |2 K7 |8 T+ T$ T; q/ D# I
129.   .IIC_Stop = IIC_Stop_t,
     1 V. y- e& }8 D. R8 i7 }# A
130.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
     4 [$ Q2 Q# P( a! R% H  x9 m
131.   .IIC_Ack = IIC_Ack_t,
     
132.   .IIC_NAck = IIC_NAck_t,
     7 p/ b6 i/ N% h
133.   .IIC_Send_Byte = IIC_Send_Byte_t,
     
134.   .IIC_Read_Byte = IIC_Read_Byte_t,
     
135.   .delay_us = delay_us
     
136. },                   //IIC驱动
     
137. .AT24CXX_ReadOneByte = AT24CXX_ReadOneByte_t,  //指定地址读取一个字节
     
138. .AT24CXX_WriteOneByte = AT24CXX_WriteOneByte_t,//指定地址写入一个字节
     
139. .AT24CXX_WriteLenByte = AT24CXX_WriteLenByte_t, //指定地址开始写入指定长度的数据
     
140. .AT24CXX_ReadLenByte = AT24CXX_ReadLenByte_t,   //指定地址开始读取指定长度数据
     / ~" N. W  W  Z, k8 s/ D( q
141. .AT24CXX_Write = AT24CXX_Write_t,  //指定地址开始写入指定长度的数据
     3 w0 y, }: {1 Y4 T7 Y: J
142. .AT24CXX_Read = AT24CXX_Read_t,   //指定地址开始读取指定长度的数据
     3 Y6 a1 o' F0 v, b  R; C/ z
143. .AT24CXX_Init = AT24CXX_Init_t, //初始化IIC
     
144. .AT24CXX_Check = AT24CXX_Check_t   //检查器件
     3 i9 Q* M# d) b2 o: C0 {
145. };

复制代码

简单分析：可以看出AT24CXX类中包含了IIC类的成员对象，这是一种包含关系，因为没有属性上的一致性因此谈不上继承。
. _" f2 Z8 \! L9 u" j0 Y+ b) U" ]
: r, ]5 n% q+ _: j1 c
    之所以将IIC的类对象作为AT24CXX类的成员是因为AT24CXX的实现需要调用IIC的成员方法，IIC相当于AT24CXX更下层的驱动，因此采用包含关系更合适。
4 R) n: t- `: ?9 A' u
+ E; Y, u) J& y7 d; H6 @- B
    因此我们在使用AT24CXX的时候只需要实例化AT24CXX类对象就行了，因为IIC包含在AT24CXX类中间，因此不需要实例化IIC类对象，对外提供了较好的封装接口。下面我们看具体的调用方法。
" y9 b3 Q' k9 W

主函数main调用测试
+ q. w3 @: Q& d5 p% A! w    在main函数中直接使用AT24C_64来完成所有操作，下面结合代码来看：

1. 
   / H* N! L% A8 G1 q9 V1 B8 n# [" |+ U- S% m
2. #include "at24cxx.h"    //为了确定AT24C_64的成员方法和引用操作对象AT24C_64
   
3. int main(void)
   
4. {
   
5.   /************省略其他初始化工作****************/
   
6.   //第一步：调用对象初始化方法来初始化AT24C64
   
7.   AT24C_64.AT24CXX_Init(&AT24C_64);
   
8.   //第二步：调用对象检测方法来检测AT24C64           
   
9.   if(AT24C_64.AT24CXX_Check(&AT24C_64) == 0)
   
10.   {
    . l( N0 c" x! i* j! I
11.     printf("AT24C64检测成功\r\n");
    ( E1 N# x  u! Z
12.   }
    
13.   else{
    ) h! e! `3 _9 Q1 k* ]7 h) ]$ V
14.     printf("AT24C64检测失败\r\n");
    
15.   }
    4 q- ^/ U4 |1 F# N" h
16.   return 0;
    # e9 s( J7 j# m- i. X
17. }

复制代码

可以看出所有的操作都是通过AT24C_64对象调用完成的，在我们初始化好AT24C_64对象之后就可以放心大胆的调用其成员方法，这样封装的好处就是一个设备对外只提供一个对象接口，简洁明了。
2 q# K" N+ _  i% Z9 U5 g
9 Z4 u. c1 f, C: u' j; f
总结
    本文详细介绍了面向对象方法实现IIC驱动封装以及AT24CXX存储器的封装，最终对外仅提供一个操作对象接口，大大提高了代码的复用性以及封装性。
9 ~9 s; O8 V6 {) r: [2 _. F
% ?. K8 U, N; {* s; Z- q2 j* [
% O3 ?; ?' i9 G
& q7 o1 w0 n# z) \+ D