简述

5 d# Z: e& z: d, B2 w    IIC（Inter-Integrated Circuit）其实是IICBus简称，它是一种串行通信总线，使用多主从架构，在STM32开发中经常见到。
       使用面向对象的编程思想封装IIC驱动，将IIC的属性和操作封装成一个库，在需要创建一个IIC设备时只需要实例化一个IIC对象即可，本文是基于STM32和HAL库做进一步封装的。
    底层驱动方法不重要，封装的思想很重要。在完成对IIC驱动的封装之后借助继承特性实现AT24C64存储器的驱动开发，仍使用面向对象的思想封装AT24C64驱动。
4 C1 R% y; J' p) a3 ?
IIC驱动面向对象封装
    iic.h头文件主要是类模板的定义，具体如下：

1. //定义IIC类
   
2. typedef struct IIC_Type
   ! z6 [. h+ O8 X% p( r2 L
3. {
   : J7 H5 R" Z  r; N, j
4. //属性
   3 W& {. S3 J( O) o  |/ u
5.    GPIO_TypeDef  *GPIOx_SCL;  //GPIO_SCL所属的GPIO组(如：GPIOA)
   
6.    GPIO_TypeDef  *GPIOx_SDA;  //GPIO_SDA所属的GPIO组(如：GPIOA)
   ( x; b! X" |& l3 ^8 \7 w+ w
7. uint32_t GPIO_SCL;     //GPIO_SCL的IO引脚(如：GPIO_PIN_0)
   ; n4 V' p  G* R# @
8. uint32_t GPIO_SDA;     //GPIO_SDA的IO引脚(如：GPIO_PIN_0)
   6 p/ |) O* g% ?1 S& i6 G! p
9. //操作
   
10. void (*IIC_Init)(const struct IIC_Type*);        //IIC_Init
    
11. void (*IIC_Start)(const struct IIC_Type*);       //IIC_Start
    5 M: c! d0 ~- T3 v6 u3 l
12. void (*IIC_Stop)(const struct IIC_Type*);        //IIC_Stop
    2 t( W- {! J6 C% C8 s( G* M- I
13. uint8_t (*IIC_Wait_Ack)(const struct IIC_Type*);    //IIC_Wait_ack,返回wait失败或是成功
    
14. void (*IIC_Ack)(const struct IIC_Type*);       //IIC_Ack,IIC发送ACK信号
    
15. void (*IIC_NAck)(const struct IIC_Type*);       //IIC_NAck,IIC发送NACK信号
    
16. void (*IIC_Send_Byte)(const struct IIC_Type*,uint8_t);       //IIC_Send_Byte，入口参数为要发送的字节
    
17. uint8_t (*IIC_Read_Byte)(const struct IIC_Type*,uint8_t);     //IIC_Send_Byte，入口参数为是否要发送ACK信号
    
18. void (*delay_us)(uint32_t);              //us延时
    
19. }IIC_TypeDef;

复制代码

9 Z: M  r! f9 m& m3 f3 o/ f

iic.c源文件主要是类模板具体操作函数的实现，具体如下：
, }4 Z7 Z2 w8 m5 V. s/ t" ]+ ^; ^1 U

1. //设置SDA为输入模式
   2 P1 Z; Z+ m: V% o9 i7 C
2. static void SDA_IN(const struct IIC_Type* IIC_Type_t)
   3 x' L) k2 W6 q
3. {
   : o' ^3 a4 \" g% q* K/ q2 @
4.   uint8_t io_num = 0;  //定义io Num号
   # f4 d# ~3 |$ v) @0 B
5. switch(IIC_Type_t->GPIO_SDA)
   # B$ Q$ l' i* }* ?
6.   {
   ! {( u. T, ?+ z3 y- L3 o
7. case GPIO_PIN_0:
   - N- X" m# i" G( z. \* u8 P
8.     io_num = 0;
   ' g! a( ~) H2 j9 M4 ]  S% S( i
9. break;
   
10. case GPIO_PIN_1:
    
11.     io_num = 1;
    8 n: \; \  H. m3 W7 |8 r
12. break;
    - X9 k& m* E8 M$ o6 O
13. case GPIO_PIN_2:
    7 s3 `( H' ~2 S3 M3 g
14.     io_num = 2;
    ' e0 j) Q$ r- T1 \; m. {7 s
15. break;
    / o/ ^8 [  q( v  l1 Y
16. case GPIO_PIN_3:
    ; s; S4 H8 G6 b  u; ~
17.     io_num = 3;
    3 S( v, U8 u8 W  X+ K
18. break;
    & j& n* g) f! U' e  Z8 f& N
19. case GPIO_PIN_4:
    7 g8 ^, W# ]2 [" I+ v) ]# r5 Z
20.     io_num = 4;
    
21. break;
    
22. case GPIO_PIN_5:
    
23.     io_num = 5;
    
24. break;
    
25. case GPIO_PIN_6:
    
26.     io_num = 6;
    
27. break;
    
28. case GPIO_PIN_7:
    
29.     io_num = 7;
    
30. break;
    5 i$ I$ E5 a6 \8 G# }
31. case GPIO_PIN_8:
    3 N& j" }/ _; M6 [. _
32.     io_num = 8;
    8 Q! m1 O6 \  `  e+ H
33. break;
    
34. case GPIO_PIN_9:
    - ~2 h, g& m- E3 }8 A4 G# T
35.     io_num = 9;
    
36. break;
    
37. case GPIO_PIN_10:
    
38.     io_num = 10;
    ! x, @- n& ^- _2 n
39. break;
    
40. case GPIO_PIN_11:
    / q5 Z/ V6 g! {4 u& z% c
41.     io_num = 11;
    
42. break;
    / y8 I/ p& J/ @  S* v
43. case GPIO_PIN_12:
    
44.     io_num = 12;
    % k5 u3 @8 J8 j& `
45. break;
    
46. case GPIO_PIN_13:
    3 o! O$ v5 l, p! w
47.     io_num = 13;
    $ z/ }  ]( M' a. v+ [$ D. {
48. break;
    
49. case GPIO_PIN_14:
      i  H( Y! x4 A) B0 r# E/ G1 x0 f
50.     io_num = 14;
    ) r' o0 \, |; Q$ x6 ?( C
51. break;
    : Q$ _" c! i8 d! u
52. case GPIO_PIN_15:
    & {( Q+ I) m' y6 |5 V8 D* e+ D+ ~7 i
53.     io_num = 15;
    ( i# X' O6 b8 [& P
54. break;
    - e7 J/ O2 k6 f7 u
55.   }
    $ M1 ~# P' M2 n2 \# \
56.   IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
    & b: D1 g& n7 o: Q1 G0 ^) N1 W. j* X
57.   IIC_Type_t->GPIOx_SDA->MODER|=0<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输入模式
    
58. }
    * J/ Z; x& w( a: w+ W, A' p+ b2 U) J4 V
59. 
    8 ~, h. c. T2 [* `( M
60. //设置SDA为输出模式
    4 j4 k) ~: U( K  [( d0 b3 j
61. static void SDA_OUT(const struct IIC_Type* IIC_Type_t)
    8 }5 L1 C4 H" ]4 _; z  o  J) f
62. {
    
63.   uint8_t io_num = 0;  //定义io Num号
    ! {' z( {: v2 t. _
64. switch(IIC_Type_t->GPIO_SDA)
    2 P! p9 x& f3 P7 j, v3 M; N
65.   {
    6 B4 H$ p: {* [1 F
66. case GPIO_PIN_0:
    1 d( t% B6 q) F& y# ~7 R# o9 v
67.     io_num = 0;
    
68. break;
    
69. case GPIO_PIN_1:
    9 O/ z/ E0 P+ l" u4 s
70.     io_num = 1;
    ' ~* o; r' [$ r) C# }8 }8 G. @
71. break;
    
72. case GPIO_PIN_2:
    0 C  l' J7 ?) }7 u& o- S5 x
73.     io_num = 2;
    2 P) L) C. ]/ n' H4 A
74. break;
    , s$ S- S* \' p/ X' o0 b
75. case GPIO_PIN_3:
    
76.     io_num = 3;
    4 r8 L% I7 r% T
77. break;
    
78. case GPIO_PIN_4:
    + F* l. P1 _3 w$ b1 b
79.     io_num = 4;
    8 F1 g+ x6 ^& D! P$ }* O* v
80. break;
    
81. case GPIO_PIN_5:
    : l, V7 ?, o4 N, {+ c) z4 R
82.     io_num = 5;
    
83. break;
      y& E" l# \# R0 d
84. case GPIO_PIN_6:
    
85.     io_num = 6;
    
86. break;
    
87. case GPIO_PIN_7:
    & a, R, L$ s1 b: w2 V* {
88.     io_num = 7;
    
89. break;
    
90. case GPIO_PIN_8:
    ' W7 _2 v; I6 R  D" I$ w/ m4 `
91.     io_num = 8;
    
92. break;
    
93. case GPIO_PIN_9:
    
94.     io_num = 9;
    
95. break;
    
96. case GPIO_PIN_10:
    ) A# I3 X7 B6 C+ n
97.     io_num = 10;
    
98. break;
    6 u9 |' I0 t& {, o; O
99. case GPIO_PIN_11:
    
100.     io_num = 11;
     2 _. O  T) v- i6 ^# m
101. break;
     
102. case GPIO_PIN_12:
     + W& C+ j* N5 m6 [
103.     io_num = 12;
     / W) X& _0 X5 r( U/ H0 j8 L
104. break;
     ! ~9 F, x- a! a% N& k* z" s
105. case GPIO_PIN_13:
     
106.     io_num = 13;
     
107. break;
     ' s8 J# F/ e$ P- S: Z, H
108. case GPIO_PIN_14:
     % W9 `- k/ P0 P8 ~6 B
109.     io_num = 14;
     & t- e, b/ |2 R' y/ ?4 x
110. break;
     : [( z5 `& O0 K% s% e
111. case GPIO_PIN_15:
     
112.     io_num = 15;
     ( {3 ~! `3 L9 o
113. break;
     8 h, z1 N' k. r, u6 s
114.   }
     
115.   IIC_Type_t->GPIOx_SDA->MODER&=~(3<<(io_num*2)); //将GPIOx_SDA->GPIO_SDA清零
     , o/ X( F1 w% @! A, h, ?1 a# B
116.   IIC_Type_t->GPIOx_SDA->MODER|=1<<(io_num*2);   //将GPIOx_SDA->GPIO_SDA设置为输出模式
     ' K; ?: R' j6 `" n. z: d
117. }
     
118. //设置SCL电平
     
119. static void IIC_SCL(const struct IIC_Type* IIC_Type_t,int n)
     ! f7 e" t: \" I  s! B0 W$ x
120. {
     6 a) p/ V  O/ f' p
121. if(n == 1)
     
122.   {
     1 e+ M- ^3 u, F- t" F
123.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_SET);     //设置SCL为高电平
     
124.   }
     
125. else{
     7 I1 h" X4 u2 i! _* o# C
126.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SCL,IIC_Type_t->GPIO_SCL,GPIO_PIN_RESET);     //设置SCL为低电平
     - s  Z8 B3 l8 y( h
127.   }
     
128. }
     
129. //设置SDA电平
     
130. static void IIC_SDA(const struct IIC_Type* IIC_Type_t,int n)
     
131. {
     
132. if(n == 1)
     
133.   {
     
134.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_SET);     //设置SDA为高电平
     
135.   }
     4 H8 s! m! O) h, E- H
136. else{
     6 T: g# V' a6 s8 C# V6 e
137.     HAL_GPIO_WritePin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA,GPIO_PIN_RESET);     //设置SDA为低电平
     : ]( s! Z  `; i7 g/ {; Q
138.   }
     
139. }
     9 j4 j- {: t6 r, W0 {% a+ E* J
140. //读取SDA电平
     
141. static uint8_t READ_SDA(const struct IIC_Type* IIC_Type_t)
     9 L8 z+ C- o* p
142. {
     - x; g( G; J5 R$ j: D
143. return HAL_GPIO_ReadPin(IIC_Type_t->GPIOx_SDA,IIC_Type_t->GPIO_SDA);  //读取SDA电平
     6 i! ?% G+ k4 B0 I2 m* g1 v2 c. E7 c
144. }
     1 a6 z" Q. q& W' Z3 F. z; u
145. //IIC初始化
     
146. static void IIC_Init_t(const struct IIC_Type* IIC_Type_t)
     
147. {
     
148.       GPIO_InitTypeDef GPIO_Initure;
     
149. 
     5 x2 o  S1 V3 V0 j& E
150. //根据GPIO组初始化GPIO时钟
     5 ]" \$ P7 [3 k* g2 b
151. if(IIC_Type_t->GPIOx_SCL == GPIOA || IIC_Type_t->GPIOx_SDA == GPIOA)
     
152.    {
     
153.      __HAL_RCC_GPIOA_CLK_ENABLE();   //使能GPIOA时钟
     6 u/ V# ]/ ^) E* p, _+ r2 O, e
154.    }
     * }; o: Y0 x" o3 C; a. L  C
155. if(IIC_Type_t->GPIOx_SCL == GPIOB || IIC_Type_t->GPIOx_SDA == GPIOB)
     % v( i  X# n' n: G& |  ]4 V3 r" b
156.    {
     3 C, ~$ o9 y% b/ w/ }% A" l3 ]
157.      __HAL_RCC_GPIOB_CLK_ENABLE();   //使能GPIOB时钟
     
158.    }
     
159. if(IIC_Type_t->GPIOx_SCL == GPIOC || IIC_Type_t->GPIOx_SDA == GPIOC)
     
160.    {
     ! s. ~; f# x" y1 S% I1 p* o
161.      __HAL_RCC_GPIOC_CLK_ENABLE();   //使能GPIOC时钟
     5 N" u; I1 T' h" N2 ]+ k0 }  @
162.    }
     
163. if(IIC_Type_t->GPIOx_SCL == GPIOD || IIC_Type_t->GPIOx_SDA == GPIOD)
     3 Y( r& F& q/ D4 r
164.    {
     % u0 E$ S, }0 {
165.      __HAL_RCC_GPIOD_CLK_ENABLE();   //使能GPIOD时钟
     " L. K9 K; X$ ^6 G/ o
166.    }
     7 `& p, }8 ]3 D
167. if(IIC_Type_t->GPIOx_SCL == GPIOE || IIC_Type_t->GPIOx_SDA == GPIOE)
     + W7 G( E& p+ i( U8 E( Y
168.    {
     + t) i) |7 D( z2 G2 }
169.      __HAL_RCC_GPIOE_CLK_ENABLE();   //使能GPIOE时钟
     
170.    }
     
171. if(IIC_Type_t->GPIOx_SCL == GPIOH || IIC_Type_t->GPIOx_SDA == GPIOH)
     
172.    {
     
173.      __HAL_RCC_GPIOH_CLK_ENABLE();   //使能GPIOH时钟
     
174.    }     
     
175. 
     : A* p  [7 B; |5 b; R" z. D7 o! M, x
176. //GPIO_SCL初始化设置
     
177.      GPIO_Initure.Pin=IIC_Type_t->GPIO_SCL;
     
178.      GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
     
179.      GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
     + N# o2 P1 ], \- f1 S/ _
180.      GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
     " @0 D4 X) H. j4 p, W, o; V* p( \# r) ^
181.      HAL_GPIO_Init(IIC_Type_t->GPIOx_SCL,&GPIO_Initure);
     ( I6 Z+ ]/ k7 a2 b! ^$ n8 t
182. //GPIO_SDA初始化设置
     
183.      GPIO_Initure.Pin=IIC_Type_t->GPIO_SDA;
     
184.      GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
     
185.      GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
     . q: a+ c4 ~5 d' x/ {0 e
186.      GPIO_Initure.Speed=GPIO_SPEED_FREQ_VERY_HIGH;    //快速
     
187.      HAL_GPIO_Init(IIC_Type_t->GPIOx_SDA,&GPIO_Initure);
     " a. S/ T9 r! e  D
188. 
     
189. //SCL与SDA的初始化均为高电平
     6 e$ r! _8 b* j4 |# S
190.       IIC_SCL(IIC_Type_t,1);
     
191.        IIC_SDA(IIC_Type_t,1);
     
192. }
     
193. //IIC Start
     2 p/ w. i# R; x) r6 L& [
194. static void IIC_Start_t(const struct IIC_Type* IIC_Type_t)
     1 _; H  f1 D( z: u
195. {
       U' B3 ?* k- Y7 u& [" j
196.   SDA_OUT(IIC_Type_t);      //sda线输出
     
197.   IIC_SDA(IIC_Type_t,1);      
     
198.   IIC_SCL(IIC_Type_t,1);
     
199.   IIC_Type_t->delay_us(4);
     3 E' U  d" M0 W
200.    IIC_SDA(IIC_Type_t,0);  //START:when CLK is high,DATA change form high to low
     , Y0 e* I, `* i2 s+ A+ x" J1 k
201.   IIC_Type_t->delay_us(4);
     
202.   IIC_SCL(IIC_Type_t,0);  //钳住I2C总线，准备发送或接收数据
     7 d! f- Q( o$ K$ D& a9 N' {
203. }
     
204. //IIC Stop
     
205. static void IIC_Stop_t(const struct IIC_Type* IIC_Type_t)
       q# W. `; f) U1 Q) R8 x5 D& C
206. {
     , ^7 Y2 e/ S. t: ]) R
207.   SDA_OUT(IIC_Type_t); //sda线输出
     
208.   IIC_SCL(IIC_Type_t,0);
     ' k+ O% @. @0 j
209.   IIC_SDA(IIC_Type_t,0); //STOP:when CLK is high DATA change form low to high
     $ H% {8 x4 z7 n. i+ g/ ]" w4 }- f
210.    IIC_Type_t->delay_us(4);
     : ?  c9 P* _- I7 N3 c6 S$ q$ o
211.   IIC_SCL(IIC_Type_t,1);
     3 |5 _" c5 ?" e3 E
212.   IIC_SDA(IIC_Type_t,1); //发送I2C总线结束信号
     + I: }; v# v" U4 j5 O" ]/ N
213.   IIC_Type_t->delay_us(4);
     ; {7 Y3 v7 B3 ]" A% y
214. }
     % y% O9 x8 s; W3 ^2 S. u
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失败或是成功
     4 m# |* N/ Q- Q& c
217. {
     
218.   uint8_t ucErrTime = 0;
     ( C' ~: Z2 S; \2 s+ d7 K9 I
219.   SDA_IN(IIC_Type_t);      //SDA设置为输入  
     9 {% K6 g; E# l
220.   IIC_SDA(IIC_Type_t,1);IIC_Type_t->delay_us(1);   
     " h) V7 B; g, s
221.   IIC_SCL(IIC_Type_t,1);IIC_Type_t->delay_us(1);
     
222. while(READ_SDA(IIC_Type_t))
     
223.   {
     
224.     ucErrTime++;
     & ?6 N3 G: h) u8 i* m: v# W
225. if(ucErrTime>250)
     ) O0 M, v( S- }7 g5 l1 e
226.     {
     + G' s2 a& U  T0 I& X
227.       IIC_Type_t->IIC_Stop(IIC_Type_t);
     
228. return HAL_ERROR;
     : ?- k- B: c* R$ e' T$ Y
229.     }
     
230.   }
     
231.   IIC_SCL(IIC_Type_t,0);//时钟输出0     
     
232. return HAL_OK;  
     
233. }
     
234. //产生ACK应答
     
235. static void IIC_Ack_t(const struct IIC_Type* IIC_Type_t)      
     2 u! i; f1 c  h' `: u# h2 Z* \; P
236. {
     % |! a# x% ?% N, y' u" s
237.   IIC_SCL(IIC_Type_t,0);
     
238.   SDA_OUT(IIC_Type_t);
     ! R# D# n! |* R1 W
239.   IIC_SDA(IIC_Type_t,0);
     
240.   IIC_Type_t->delay_us(2);  
     
241.   IIC_SCL(IIC_Type_t,1);
     ; Z* m0 G3 K* H- o
242.   IIC_Type_t->delay_us(2);  
     , V) z, O4 M3 R
243.   IIC_SCL(IIC_Type_t,0);
     
244. }
     
245. //产生NACK应答
     
246. static void IIC_NAck_t(const struct IIC_Type* IIC_Type_t)      
     
247. {
     
248.   IIC_SCL(IIC_Type_t,0);
     
249.   SDA_OUT(IIC_Type_t);
     / `0 V+ k; [$ [: K: k% w
250.   IIC_SDA(IIC_Type_t,1);
     ( E1 r- S1 i% t$ r3 J5 }+ a# p
251.   IIC_Type_t->delay_us(2);  
     
252.   IIC_SCL(IIC_Type_t,1);
     9 l1 q9 @0 B' o5 d
253.   IIC_Type_t->delay_us(2);  
     
254.   IIC_SCL(IIC_Type_t,0);
     , _1 }+ i" b1 M3 [6 d  f- G* p
255. }
     
256. //IIC_Send_Byte，入口参数为要发送的字节
     
257. static void IIC_Send_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t txd)     
     
258. {
     2 q+ x$ e. q5 s6 ]
259.      uint8_t t = 0;   
     6 T$ g; [% t/ w# U
260.      SDA_OUT(IIC_Type_t);      
     * R1 d( d$ t# y7 v3 c$ A
261.      IIC_SCL(IIC_Type_t,0);//拉低时钟开始数据传输
     
262. for(t=0;t<8;t++)
     
263.      {              
     
264.           IIC_SDA(IIC_Type_t,(txd&0x80)>>7);
     
265.           txd <<= 1;   
     8 q3 N; x  x) E! \: I' t
266.        IIC_Type_t->delay_us(2);     //对TEA5767这三个延时都是必须的
     
267.        IIC_SCL(IIC_Type_t,1);
     
268.        IIC_Type_t->delay_us(2);  
     9 ^6 P' i& A9 D7 O9 q) Q4 X) z. E
269.        IIC_SCL(IIC_Type_t,0);
     7 a' c* P5 G1 T
270.        IIC_Type_t->delay_us(2);  
     
271.      }  
     
272. }
     
273. //IIC_Send_Byte，入口参数为是否要发送ACK信号
     
274. static uint8_t IIC_Read_Byte_t(const struct IIC_Type* IIC_Type_t,uint8_t ack)     
     
275. {
     5 s* q' [2 d2 T# {1 [
276.    uint8_t i,receive = 0;
     3 Z; ^, B6 ~9 Y. o
277.    SDA_IN(IIC_Type_t);//SDA设置为输入
     
278. for(i=0;i<8;i++ )
     
279.    {
     $ b5 {: l* P: T8 u7 I- R
280.       IIC_SCL(IIC_Type_t,0);
     , T' ?1 \  Z0 p, t9 @
281.       IIC_Type_t->delay_us(2);
     
282.       IIC_SCL(IIC_Type_t,1);
     
283.       receive<<=1;
     ( U  c& X8 a/ z1 e6 K
284. if(READ_SDA(IIC_Type_t))receive++;   
     
285.       IIC_Type_t->delay_us(1);
     4 G4 M% z' ^3 `- E2 _
286.    }      
     
287. if (!ack)
     
288.          IIC_Type_t->IIC_NAck(IIC_Type_t);//发送nACK
     
289. else
     4 h- r7 w5 v: P% q1 ?
290.          IIC_Type_t->IIC_Ack(IIC_Type_t); //发送ACK   
     
291. return receive;
     % {  |: ~5 m! y* M) K) W5 h& Y# f% s
292. }
     
293. //实例化一个IIC1外设，相当于一个结构体变量，可以直接在其他文件中使用
     
294. IIC_TypeDef IIC1 = {
     
295.   .GPIOx_SCL = GPIOA,   //GPIO组为GPIOA
     
296.   .GPIOx_SDA = GPIOA,   //GPIO组为GPIOA
     ; S" X& F$ z( \8 }7 }5 @
297.   .GPIO_SCL = GPIO_PIN_5,   //GPIO为PIN5
     
298.   .GPIO_SDA = GPIO_PIN_6,  //GPIO为PIN6
     4 y) i7 ~& {2 F4 o7 u' e- Z6 E
299.   .IIC_Init = IIC_Init_t,
     
300.   .IIC_Start = IIC_Start_t,
     5 z( }" Z. [8 J/ E
301.   .IIC_Stop = IIC_Stop_t,
       i* q& A. ~( S$ ~$ H5 {
302.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
     
303.   .IIC_Ack = IIC_Ack_t,
     ! `1 b2 x  t6 m9 R, |
304.   .IIC_NAck = IIC_NAck_t,
     
305.   .IIC_Send_Byte = IIC_Send_Byte_t,
     
306.   .IIC_Read_Byte = IIC_Read_Byte_t,
     & z% Q. M+ k. {7 R/ T
307.   .delay_us = delay_us     //需自己外部实现delay_us函数
     . O5 b6 |: _+ h' q- V9 r" c) c
308. };

复制代码

- [# F7 k7 O1 F& v9 q0 P

: [; I! y$ o! q- g' \6 L   上述就是IIC驱动的封装，由于没有应用场景暂不测试其实用性，待下面ATC64的驱动缝缝扎黄写完之后一起测试使用。
0 L: ~8 E; E5 E! {$ u* n8 ]7 x: D
  U# {, K' b  nATC64XX驱动封装实现
    at24cxx.h头文件主要是类模板的定义，具体如下：
  }1 [! j) G+ |+ G

1. // 以下是共定义个具体容量存储器的容量
   : {- E4 t' @) \: d/ u! m
2. #define AT24C01  127
   
3. #define AT24C02  255
   
4. #define AT24C04  511
   
5. #define AT24C08  1023
   
6. #define AT24C16  2047
   * x0 x, U0 ~/ d) D0 B; _% P- N% r
7. #define AT24C32  4095
   : m$ v( r$ U* H! L" [) y
8. #define AT24C64   8191         //8KBytes
   5 T. U0 V/ s( Z8 `) b& r) L6 V6 O# w
9. #define AT24C128 16383
   - W) \0 G! R+ ^4 W
10. #define AT24C256 32767  
    # P( A$ r8 T% T8 \. o, w
11. 
    ) N! f$ ^8 g+ k7 ]! o
12. //定义AT24CXX类
    
13. typedef struct AT24CXX_Type
    + l- G1 e( E1 z: Z9 e$ ]
14. {
    
15. //属性
    
16.   u32 EEP_TYPE;           //存储器类型（存储器容量）
    & B! U0 J/ E2 Z3 v! A/ a# W
17. //操作
    
18.   IIC_TypeDef IIC;       //IIC驱动
    
19. uint8_t (*AT24CXX_ReadOneByte)(const struct AT24CXX_Type*,uint16_t);  //指定地址读取一个字节
    & n/ A! w3 ~! [6 h" J
20. void (*AT24CXX_WriteOneByte)(const struct AT24CXX_Type*,uint16_t,uint8_t); //指定地址写入一个字节
    + b8 j7 r7 K/ w4 D# s" y9 S
21. void (*AT24CXX_WriteLenByte)(uint16_t,uint32_t,uint8_t); //指定地址开始写入指定长度的数据
    
22. uint32_t (*AT24CXX_ReadLenByte)(uint16_t,uint8_t);   //指定地址开始读取指定长度数据
    5 r( i4 p) j* b1 o8 {% E
23. void (*AT24CXX_Write)(uint16_t,uint8_t *,uint16_t);  //指定地址开始写入指定长度的数据
    
24. void (*AT24CXX_Read)(uint16_t,uint8_t *,uint16_t);   //指定地址开始写入指定长度的数据
    $ ^; D8 j' i' B0 [9 ]" A* m$ U
25. void (*AT24CXX_Init)(const struct AT24CXX_Type*); //初始化IIC
    
26. uint8_t (*AT24CXX_Check)(const struct AT24CXX_Type*);   //检查器件
    9 p% s9 R& T4 u
27. }AT24CXX_TypeDef;
    
28. 
    
29. extern AT24CXX_TypeDef AT24C_64;     //外部声明实例化AT24CXX对象
    
30.     at24cxx.c源文件主要是类模板具体操作函数的实现，具体如下：
    
31. //在AT24CXX指定地址读出一个数据
    " k- ^; N( Z, q% f9 C7 h8 N9 B! }4 A
32. //ReadAddr:开始读数的地址  
    
33. //返回值  :读到的数据
    
34. static uint8_t AT24CXX_ReadOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t ReadAddr)
    2 X/ o' k4 }( f# M3 C; y
35. {      
    , {' D: i* m  ?, b3 Y
36.   uint8_t temp=0;                          
    
37.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);  
    # L" }: H2 {5 G9 ?' D3 t9 v7 i
38. //根据AT的型号发送不同的地址
    " n& k: F# X6 s' Z
39. if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
    8 v% l- V3 v# J/ v2 {7 d( Y/ F
40.   {
    & a. r6 n  E. q& y0 V; b# ?$ a
41.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
    # C/ L, h7 G. d/ y" B; r
42.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    1 M! g  e; k; p( S$ k! g8 G
43.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr>>8);//发送高地址     
    
44.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据     
    " N% N5 _5 |1 {; V! ]7 L, Y
45.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    / b% h- N3 d- F+ ~% c9 _
46.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr%256);   //发送低地址
    
47.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);     
    % P3 ?- Y' |( E: ^" I
48.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);        
    " Y2 k0 Q- n8 T% _+ o
49.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA1);           //进入接收模式      
    
50.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);  
    8 A4 d4 X$ R/ _2 i
51.   temp=AT24CXX_Type_t->IIC.IIC_Read_Byte(&AT24CXX_Type_t->IIC,0);     
    6 E+ z1 H# L8 f) c& g7 n
52.   AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件     
    5 A0 Q' \: m' X
53. return temp;
    
54. }
    . l  f) |* j. J( {  J
55. //在AT24CXX指定地址写入一个数据
    
56. //WriteAddr  :写入数据的目的地址   
    
57. //DataToWrite:要写入的数据
    8 W. O# H& Q$ l- I' l, [
58. static void AT24CXX_WriteOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t WriteAddr,uint8_t DataToWrite)
    * l$ }6 ?% G  M4 G
59. {                                
    & U: T( `, R) A- Q- D$ ~/ C3 O7 x
60.    AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);   
    
61. if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
    - C( e# `- }3 j' [: i) @1 o/ P
62.   {
    & n' t$ |+ T6 W. K6 D  q
63.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
    
64.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    ) _/ @' h' d2 @: G$ S$ G
65.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr>>8);//发送高地址     
    
66.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据     
    6 d- F3 m3 k: N
67.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    
68.    AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr%256);   //发送低地址
    
69.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);               
    1 m/ P) d* e  B2 }
70.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,DataToWrite);     //发送字节         
    
71.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);            
    . H" i6 {. M% H' u: M
72.    AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件
    - N0 ]. B& q! y( u- e
73. AT24CXX_Type_t->IIC.delay_us(10000);  
    
74. }
    
75. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    8 C0 n5 y9 ?1 I6 Z: o" y
76. //该函数用于写入16bit或者32bit的数据.
    
77. //WriteAddr  :开始写入的地址  
    
78. //DataToWrite:数据数组首地址
    
79. //Len        :要写入数据的长度2,4
    9 S& S( n4 V# M0 j: g* h3 N# }
80. static void AT24CXX_WriteLenByte_t(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
    6 P" X% X7 S5 z! H8 I
81. {   
    
82.   uint8_t t;
    
83. for(t=0;t<Len;t++)
    
84.   {
    
85.     AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    ' C9 S5 e: k8 ^6 ?% `0 n* y
86.   }               
    " _4 o0 X: ?" @) [
87. }
    
88. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    4 W0 E1 b$ a  T0 b
89. //该函数用于读出16bit或者32bit的数据.
    
90. //ReadAddr   :开始读出的地址
    . m4 d) v9 w7 K1 s  _; z
91. //返回值     :数据
    
92. //Len        :要读出数据的长度2,4
    
93. static uint32_t AT24CXX_ReadLenByte_t(uint16_t ReadAddr,uint8_t Len)
    & R- G+ c* i# [3 I# q9 F
94. {   
    
95.   uint8_t t;
    ' a( {% m" u  v( P3 f$ x" l
96.   uint32_t temp=0;
    
97. for(t=0;t<Len;t++)
    0 D3 `0 p# a# D& S
98.   {
    , i- _6 A- G6 c8 v
99.     temp<<=8;
    , T" S2 t% D8 I0 t* q
100.      temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);         
     3 i7 e. I, {$ [, N; Q
101.   }
     
102. return temp;               
     
103. }
     
104. //在AT24CXX里面的指定地址开始写入指定个数的数据
     
105. //WriteAddr :开始写入的地址 对24c64为0~8191
     
106. //pBuffer   :数据数组首地址
     
107. //NumToWrite:要写入数据的个数
     
108. static void AT24CXX_Write_t(uint16_t WriteAddr,uint8_t *pBuffer,uint16_t NumToWrite)
     ) a* [  C1 H; Y$ g: n3 |
109. {
     
110. while(NumToWrite--)
     
111.   {
     3 Y! ~6 d$ N) t3 Q+ @0 J& t
112.    AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
     * N# [0 t0 r1 u; @7 \8 i7 m
113.     WriteAddr++;
     
114.     pBuffer++;
     
115.   }
     
116. }
     
117. //在AT24CXX里面的指定地址开始读出指定个数的数据
     * M( n; ?" M/ p  N& G
118. //ReadAddr :开始读出的地址 对24c64为0~8191
     
119. //pBuffer  :数据数组首地址
     
120. //NumToRead:要读出数据的个数
     
121. static void AT24CXX_Read_t(uint16_t ReadAddr,uint8_t *pBuffer,uint16_t NumToRead)
     . L* W# I6 w3 `, `! g: x: Q' c
122. {
     
123. while(NumToRead)
     
124.   {
     % ?8 D) W& T8 [2 J; w
125.     *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
     
126.     NumToRead--;
       Z4 e( ?- q( a
127.   }
     9 R/ o( g, |$ e1 W# g
128. }
     , |  I9 c$ K& \# g% a
129. //初始化IIC接口
     8 X' h# H! ^* Y5 B
130. static void AT24CXX_Init_t(const struct AT24CXX_Type* AT24CXX_Type_t)
     
131. {
     
132.   AT24CXX_Type_t->IIC.IIC_Init(&AT24CXX_Type_t->IIC);//IIC初始化
     $ S+ M/ h" n& X& J" }
133. }
     1 g. w$ Q* B' i3 p# v
134. //检查器件,返回0表示检测成功,返回1表示检测失败
     : S+ k) y# {* S. s% X4 {1 _) F/ @
135. static uint8_t AT24CXX_Check_t(const struct AT24CXX_Type* AT24CXX_Type_t)   
     : o3 r; d2 o. a; |* H% h
136. {
     . E/ a- f' c* r; C
137. uint8_t temp;
     
138.   temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);//避免每次开机都写AT24CXX      
     7 B6 F8 C, ]* |$ h' F0 `1 @- ^
139. if(temp == 0X33)return 0;     
     , _" Y  E+ i7 J. m( ]
140. else//排除第一次初始化的情况
     
141.   {
       p! X9 c. y! {. m) p
142.       AT24CXX_Type_t->AT24CXX_WriteOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE,0X33);
     * o* N! O9 Q7 n4 H& m
143.        temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);
     
144. if(temp==0X33)return 0;
     ) ]( H% ]  G+ Z: W
145.   }
     7 V9 s( n( m) w$ A/ G4 L( q
146. return 1;  
     , U$ c% |# x4 G' ^
147. }
     
148. //实例化AT24CXX对象
     
149. AT24CXX_TypeDef AT24C_64={
     - Q6 f0 J& j% ?1 p
150. .EEP_TYPE = AT24C64,           //存储器类型（存储器容量）
     
151. //操作
     
152. .IIC={
     . W( y4 t) }3 Y& y0 Y
153.   .GPIOx_SCL = GPIOA,
     
154.   .GPIOx_SDA = GPIOA,
     
155.   .GPIO_SCL = GPIO_PIN_5,
     
156.   .GPIO_SDA = GPIO_PIN_6,
     + e" b& B: X1 i# h, R2 N& s
157.   .IIC_Init = IIC_Init_t,
     7 ^) C( ~- f6 F
158.   .IIC_Start = IIC_Start_t,
     , M. z1 n$ u1 ]6 e
159.   .IIC_Stop = IIC_Stop_t,
     , ]: ]! z# n% |7 J% h
160.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
     
161.   .IIC_Ack = IIC_Ack_t,
     
162.   .IIC_NAck = IIC_NAck_t,
     & \) ?3 J$ f# h% h
163.   .IIC_Send_Byte = IIC_Send_Byte_t,
     
164.   .IIC_Read_Byte = IIC_Read_Byte_t,
     
165.   .delay_us = delay_us
     
166. },                   //IIC驱动
     
167. .AT24CXX_ReadOneByte = AT24CXX_ReadOneByte_t,  //指定地址读取一个字节
     # X* v- Y( Z  o* l) v
168. .AT24CXX_WriteOneByte = AT24CXX_WriteOneByte_t,//指定地址写入一个字节
     
169. .AT24CXX_WriteLenByte = AT24CXX_WriteLenByte_t, //指定地址开始写入指定长度的数据
     
170. .AT24CXX_ReadLenByte = AT24CXX_ReadLenByte_t,   //指定地址开始读取指定长度数据
     8 q& {% q5 [- D( b% E
171. .AT24CXX_Write = AT24CXX_Write_t,  //指定地址开始写入指定长度的数据
     
172. .AT24CXX_Read = AT24CXX_Read_t,   //指定地址开始读取指定长度的数据
     4 a( h2 o  l. v$ ~5 [/ h
173. .AT24CXX_Init = AT24CXX_Init_t, //初始化IIC
     
174. .AT24CXX_Check = AT24CXX_Check_t   //检查器件
     
175. };

复制代码

    at24cxx.c源文件主要是类模板具体操作函数的实现，具体如下：
3 w1 m4 s. q: [2 k

1. //在AT24CXX指定地址读出一个数据
   6 Y, \$ {5 \, ~  k2 I% o2 \1 t  s
2. //ReadAddr:开始读数的地址  
   
3. //返回值  :读到的数据
   
4. static uint8_t AT24CXX_ReadOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t ReadAddr)
   
5. {      
   
6.   uint8_t temp=0;                          
   
7.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);  
   / V2 o+ e1 K& W- H. `2 E- U
8. //根据AT的型号发送不同的地址
   
9. if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
   9 ]$ I$ R5 R7 l7 n! I% m
10.   {
    7 x7 i* G* U" h1 D) O2 p$ N/ B
11.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
    9 s5 X; E2 b! ^! ~! Z4 t
12.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    + G: p; M7 z! J( u
13.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,ReadAddr>>8);//发送高地址     
    1 \( ]6 s* @9 N
14.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据     
    ' j, V, d; q& k( h* Q; ^% D2 _
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);     
    4 F' e0 w) A$ K0 h8 S
18.   AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);        
    " U1 K9 v, n9 u# Z& m& [1 [; M
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);  
    
21.   temp=AT24CXX_Type_t->IIC.IIC_Read_Byte(&AT24CXX_Type_t->IIC,0);     
      l- _# l+ F$ C/ I8 Y2 j5 u
22.   AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件     
    7 b$ F1 P! s" O3 U
23. return temp;
    ) W+ k( `; m; o  c8 \& f! F. Y; k
24. }
    . g8 u4 `& h4 r
25. //在AT24CXX指定地址写入一个数据
    0 O7 w% M9 n+ ~" {/ a% K9 y
26. //WriteAddr  :写入数据的目的地址   
    
27. //DataToWrite:要写入的数据
    
28. static void AT24CXX_WriteOneByte_t(const struct AT24CXX_Type* AT24CXX_Type_t,uint16_t WriteAddr,uint8_t DataToWrite)
    & ?' R8 }8 b) q) v  J& J; e
29. {                                
    
30.    AT24CXX_Type_t->IIC.IIC_Start(&AT24CXX_Type_t->IIC);   
    + t7 ]6 k" K: y* R- R% I+ e& W, d
31. if(AT24CXX_Type_t->EEP_TYPE > AT24C16)
    
32.   {
    ( @1 N8 O8 }/ h- u/ G5 R1 Q
33.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0);    //发送写命令
    , A* l" N0 o5 V! K
34.     AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    0 I$ C% [' X' @8 s; v0 p9 U3 G
35.     AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr>>8);//发送高地址     
    
36.   }else AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据     
      V, G# H' D: h7 d
37.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);
    
38.    AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,WriteAddr%256);   //发送低地址
    . [; E0 j4 \+ q# c4 t! e
39.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);               
    2 ~/ s; v# O8 E7 \- W" P* a
40.   AT24CXX_Type_t->IIC.IIC_Send_Byte(&AT24CXX_Type_t->IIC,DataToWrite);     //发送字节         
    * [3 C/ P/ ~1 O) u9 L
41.   AT24CXX_Type_t->IIC.IIC_Wait_Ack(&AT24CXX_Type_t->IIC);            
    
42.    AT24CXX_Type_t->IIC.IIC_Stop(&AT24CXX_Type_t->IIC);//产生一个停止条件
    # e" n  Q; l. O$ I* b" a
43. AT24CXX_Type_t->IIC.delay_us(10000);  
    ; p: d* x$ l) T; Q3 s) K4 D+ |; ]& f
44. }
    . e0 U: |! Q) q  |# d
45. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    " X( q3 A. S+ y
46. //该函数用于写入16bit或者32bit的数据.
    1 z. J' S& @* B2 _2 s, z* E6 i
47. //WriteAddr  :开始写入的地址  
    
48. //DataToWrite:数据数组首地址
    
49. //Len        :要写入数据的长度2,4
    
50. static void AT24CXX_WriteLenByte_t(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
    
51. {   
    ; K6 W1 i3 M8 A; f( r
52.   uint8_t t;
    
53. for(t=0;t<Len;t++)
    + T- O% W* P0 V4 n2 L! N, s/ M; w
54.   {
    
55.     AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    
56.   }               
    
57. }
    5 m2 `4 H/ N8 i; F
58. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    1 E: Y0 t4 f, B& i8 o6 r, k. ?& J
59. //该函数用于读出16bit或者32bit的数据.
    4 u  i- h, }) M* q0 C  ?5 Y+ P& Y
60. //ReadAddr   :开始读出的地址
    5 D( Q( e4 K- }+ i0 c
61. //返回值     :数据
    
62. //Len        :要读出数据的长度2,4
    
63. static uint32_t AT24CXX_ReadLenByte_t(uint16_t ReadAddr,uint8_t Len)
    0 \5 l0 @. `3 f0 {6 L% ~! H
64. {   
    - D9 ~, H4 U' l' i3 F3 s
65.   uint8_t t;
    
66.   uint32_t temp=0;
    ) @. a+ k2 a+ Z. K  b
67. for(t=0;t<Len;t++)
    
68.   {
    
69.     temp<<=8;
    ; M6 Y! n" Z+ p/ u
70.      temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);         
    1 B5 v, _! U9 [/ d2 J! M
71.   }
    
72. return temp;               
    
73. }
      j/ F2 K5 c4 f3 ^1 Z$ b2 _4 Q
74. //在AT24CXX里面的指定地址开始写入指定个数的数据
    
75. //WriteAddr :开始写入的地址 对24c64为0~8191
    # c- q/ Y" c, a8 H" C3 W; k
76. //pBuffer   :数据数组首地址
    
77. //NumToWrite:要写入数据的个数
    
78. static void AT24CXX_Write_t(uint16_t WriteAddr,uint8_t *pBuffer,uint16_t NumToWrite)
    
79. {
    
80. while(NumToWrite--)
    ' Y! j. I0 c! G2 ?' _5 x/ _; H* P! d9 e
81.   {
    
82.    AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
    
83.     WriteAddr++;
    + C* S3 C: e! U: s3 h5 C
84.     pBuffer++;
    
85.   }
    : @: l# g* Y4 I  p' G" q. r+ Q6 [
86. }
    
87. //在AT24CXX里面的指定地址开始读出指定个数的数据
    
88. //ReadAddr :开始读出的地址 对24c64为0~8191
    
89. //pBuffer  :数据数组首地址
    # r6 S' d. Z7 J" _( P
90. //NumToRead:要读出数据的个数
    
91. static void AT24CXX_Read_t(uint16_t ReadAddr,uint8_t *pBuffer,uint16_t NumToRead)
    
92. {
    8 u: l8 ?% V: a4 D
93. while(NumToRead)
    / U+ }) r- l3 }$ F
94.   {
    
95.     *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
    
96.     NumToRead--;
    
97.   }
    
98. }
    , x2 c+ D& B/ m% p
99. //初始化IIC接口
    
100. static void AT24CXX_Init_t(const struct AT24CXX_Type* AT24CXX_Type_t)
     
101. {
     
102.   AT24CXX_Type_t->IIC.IIC_Init(&AT24CXX_Type_t->IIC);//IIC初始化
     
103. }
     
104. //检查器件,返回0表示检测成功,返回1表示检测失败
     
105. static uint8_t AT24CXX_Check_t(const struct AT24CXX_Type* AT24CXX_Type_t)   
     " v  ~9 E- J0 R& A
106. {
     
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;     
     ) |! E$ P- L  h
110. else//排除第一次初始化的情况
     5 G2 u1 q0 R% Y0 H& K5 A
111.   {
     
112.       AT24CXX_Type_t->AT24CXX_WriteOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE,0X33);
     3 ^% J# T* i+ R# ?5 L0 ]
113.        temp = AT24CXX_Type_t->AT24CXX_ReadOneByte(AT24CXX_Type_t,AT24CXX_Type_t->EEP_TYPE);
     9 q8 k5 f7 u$ x; X) n6 h5 a$ _
114. if(temp==0X33)return 0;
     
115.   }
     
116. return 1;  
     ! m, B' @$ y3 F0 E/ i; l& Q
117. }
     
118. //实例化AT24CXX对象
     
119. AT24CXX_TypeDef AT24C_64={
     9 L, v! b8 ~$ p" q
120. .EEP_TYPE = AT24C64,           //存储器类型（存储器容量）
     
121. //操作
     
122. .IIC={
     
123.   .GPIOx_SCL = GPIOA,
     ) U( [" C) }8 Z7 ]8 m* }) Q
124.   .GPIOx_SDA = GPIOA,
     5 p: ^: k% _5 P" F$ k! P6 L
125.   .GPIO_SCL = GPIO_PIN_5,
     
126.   .GPIO_SDA = GPIO_PIN_6,
     
127.   .IIC_Init = IIC_Init_t,
     6 Q/ y& \- t& C* _  E6 X: ^
128.   .IIC_Start = IIC_Start_t,
     
129.   .IIC_Stop = IIC_Stop_t,
     
130.   .IIC_Wait_Ack = IIC_Wait_Ack_t,
     
131.   .IIC_Ack = IIC_Ack_t,
     
132.   .IIC_NAck = IIC_NAck_t,
     ; i; @" c7 E5 g
133.   .IIC_Send_Byte = IIC_Send_Byte_t,
     
134.   .IIC_Read_Byte = IIC_Read_Byte_t,
     % }6 F/ o; h0 f2 ?2 c
135.   .delay_us = delay_us
     
136. },                   //IIC驱动
     : z# i& ^5 ]* L' ]- H6 L
137. .AT24CXX_ReadOneByte = AT24CXX_ReadOneByte_t,  //指定地址读取一个字节
     
138. .AT24CXX_WriteOneByte = AT24CXX_WriteOneByte_t,//指定地址写入一个字节
     4 G3 h' h% ]2 U% B% p" ^
139. .AT24CXX_WriteLenByte = AT24CXX_WriteLenByte_t, //指定地址开始写入指定长度的数据
     0 F1 b2 x5 n. Y! x
140. .AT24CXX_ReadLenByte = AT24CXX_ReadLenByte_t,   //指定地址开始读取指定长度数据
     
141. .AT24CXX_Write = AT24CXX_Write_t,  //指定地址开始写入指定长度的数据
     
142. .AT24CXX_Read = AT24CXX_Read_t,   //指定地址开始读取指定长度的数据
     4 c' `, q" D* w! A& ]9 D, n1 b
143. .AT24CXX_Init = AT24CXX_Init_t, //初始化IIC
     
144. .AT24CXX_Check = AT24CXX_Check_t   //检查器件
     & g0 U1 Y' P5 k8 u- I) y" x1 j
145. };

复制代码

% J: U" m0 O6 s6 g: k   简单分析：可以看出AT24CXX类中包含了IIC类的成员对象，这是一种包含关系，因为没有属性上的一致性因此谈不上继承。
    之所以将IIC的类对象作为AT24CXX类的成员是因为AT24CXX的实现需要调用IIC的成员方法，IIC相当于AT24CXX更下层的驱动，因此采用包含关系更合适。
4 M8 t; Z# P% a. ?+ g5 L, [    因此我们在使用AT24CXX的时候只需要实例化AT24CXX类对象就行了，因为IIC包含在AT24CXX类中间，因此不需要实例化IIC类对象，对外提供了较好的封装接口。下面我们看具体的调用方法。

! t. ]& u5 z7 Z4 s8 G% V主函数main调用测试
: W; R% ^1 w/ T  T6 s1 g! w    在main函数中直接使用AT24C_64来完成所有操作，下面结合代码来看：
! A7 D0 {$ D7 L, a! X, q+ K2 {7 x

1. #include "at24cxx.h"    //为了确定AT24C_64的成员方法和引用操作对象AT24C_64
   
2. int main(void)
   3 `+ t1 L8 E" @
3. {
   
4. /************省略其他初始化工作****************/
   # x1 j6 L/ _4 z' }& k
5. //第一步：调用对象初始化方法来初始化AT24C64
   . w! y1 r& J) y) ~( G. c7 D& Z; V
6.   AT24C_64.AT24CXX_Init(&AT24C_64);
   / ?/ P$ P5 Y: @; b8 _7 c
7. //第二步：调用对象检测方法来检测AT24C64           
   
8. if(AT24C_64.AT24CXX_Check(&AT24C_64) == 0)
   
9.   {
   3 F/ o, g, K' z% P6 r' [: `
10. printf("AT24C64检测成功\r\n");
    ' A" _- D9 m- y& B1 S+ D  R4 L. ?% D& }
11.   }
    
12. else{
    % d+ g1 R3 L3 z' D
13. printf("AT24C64检测失败\r\n");
    % b$ G) Z0 w; D% U
14.   }
    8 {7 s5 ^2 h3 j8 i& g( Q0 `
15. return 0;
    
16. }

复制代码

  f, D% \' R$ n. a6 {4 {6 Y* ?    可以看出所有的操作都是通过AT24C_64对象调用完成的，在我们初始化好AT24C_64对象之后就可以放心大胆的调用其成员方法，这样封装的好处就是一个设备对外只提供一个对象接口，简洁明了。

& }0 l! P- S6 R7 I总结
   本文详细介绍了面向对象方法实现IIC驱动封装以及AT24CXX存储器的封装，最终对外仅提供一个操作对象接口，大大提高了代码的复用性以及封装性。
( ]# B  B- N; b: ?
# ?7 ^* v, M& S' d$ d) F: F! _

) ?& ^2 p( U6 d6 K6 z+ }6 M0 L; w, X转载自：EE时间