一、IIC的定义
    I2C(IIC,Inter－Integrated Circuit),两线式串行总线,由PHILIPS开发用于连接微控制器及其外围设备。IIC是一种多向控制总线，就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实施数据传输的控制源。这种方式简化信号传输总线。

    它由数据线SDA和时钟SCL构成的串行总线，接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上，可发送接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，高速IIC总线一般可达400kbps以上。

IIC是半双工通信方式。
; j* e1 A# y0 S/ N. j7 c  Z, o
二、多主机I2C总线系统结构
) r3 a/ c7 m9 i* J. e
' \0 @8 B/ Z) [% }+ k6 P. A
9 v6 I2 y( }+ w1 a$ G+ ]
2）多设备的使用举例

每个接到I2C总线的设备都有一个唯一的地址
7 f+ p! {% T: y
7 _, K9 H; a; ^. E# W/ }

& r0 p, _3 B* q. g0 \0 j" d2 H; P三、I2C协议
- L, @. C; R% X( L+ ]7 P& z空闲状态
( u8 G8 N+ ~9 x/ I2 E$ _! `5 d开始信号
停止信号
应答信号
& _3 q+ C$ H% A) t0 F! I: q. H数据的有效性
数据传输
  Z7 ~! `: c( J' g2 l我们以斗地主为例：

8 i. v3 m2 @- |# `4 E, C
; R: S  D# a  T! ~" V" g% L& V, A: z6 [
% s/ }' R# k& i2 y1 i* g0 X1）空闲状态
I2C总线总线的SDA和SCL两条信号线同时处于高电平时，规定为总线的空闲状态。此时各个器件的输出级场效应管均处在截止状态，即释放总线，由两条信号线各自的上拉电阻把电平拉高。

2）起始信号与停止信号
起始信号：当SCL为高期间，SDA由高到低的跳变；启动信号是一种电平跳变时序信号，而不是一个电平信号。
% W1 C" l2 J$ N: j6 O- Y停止信号：当SCL为高期间，SDA由低到高的跳变；停止信号也是一种电平跳变时序信号，而不是一个电平信号。
$ {& x( Z' V% p8 \
( R" N& ~% A7 _  K) a9 h4 P
& d' J7 O9 h$ q
% a. \/ X- T: V3）应答信号ACK
发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。

5 W; F% \9 s, F: _& s) ]对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P。

5 u% Z. J  a( K4 s+ [- i
3 @9 e/ _. Y2 @, r% A
4）数据有效性
3 q& i4 j# u. O, L  o7 FI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。
( q" ]/ c: }; [+ g5 G5 D" X
/ x6 W% r6 S7 Q& V即：数据在SCL的上升沿到来之前就需准备好。并在在下降沿到来之前必须稳定。
, f# Z4 A* [5 E0 p, O, i


5）数据的传送
% _! {) t% {$ I$ q! Y2 u6 D在I2C总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。

STM32F4的IIC代码如下：

1. IIC.c
   3 R$ T! ?" F  o% B* X
2. #include "myiic.h"
   1 O9 }0 G) w) [# {; k- s  f1 p
3. #include "delay.h"
   & j- H' j5 N  y% x: }9 g
4. 
   
5. //初始化IIC
   ( W+ Y& o, O9 C9 R: v9 f! E
6. void IIC_Init(void)
   
7. {                        
   
8.   GPIO_InitTypeDef  GPIO_InitStructure;
   $ l# S, ]  W5 ]- \2 n8 j% ~
9. 
   , P& q$ S: a+ U; o2 B
10.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    
11. 
    
12.   //GPIOB8,B9初始化设置
    0 e) X( z6 H: [- v
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
    5 D* f* k: \) N
14.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    
15.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    . B# J% Z+ W6 T3 G% C3 C
16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    & b, X7 K; Y& I  \* G$ _
17.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
18.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    2 D, d2 f, b/ T. C
19.         IIC_SCL=1;
    
20.         IIC_SDA=1;
    4 Q# B3 ]; K8 H7 f1 a. `
21. }
    
22. 
    
23. //产生IIC起始信号
    * L6 M( L( ~: Q$ K' Y
24. void IIC_Start(void)
    
25. {
    1 z8 {5 s2 s0 A$ z# _- B
26.         SDA_OUT();     //sda线输出
    
27.         IIC_SDA=1;                    
    : {5 R- B, i. g& I( W
28.         IIC_SCL=1;
    0 c9 u9 D" }5 G4 [
29.         delay_us(4);
    5 x5 `( `( b. V) G0 h
30.          IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
31.         delay_us(4);
    
32.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    
33. }
    
34.          
    ' p. C0 {* J' q  @  q; Y9 w
35. //产生IIC停止信号
    
36. void IIC_Stop(void)
    
37. {
    
38.         SDA_OUT();//sda线输出
    
39.         IIC_SCL=0;
    0 D* l! E% K/ p) R1 A. k4 v
40.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
41.          delay_us(4);
      z: ^7 h& H1 H/ y9 K  k* v
42.         IIC_SCL=1;
    
43.         IIC_SDA=1;//发送I2C总线结束信号
    
44.         delay_us(4);                                                                  
    
45. }
    
46. 
    
47. //等待应答信号到来
    * F( i, T5 J+ A" q- v+ X# |6 B# x) o' \  S
48. //返回值：1，接收应答失败
    ) m3 L+ W! Z  l- Y* h9 R
49. //        0，接收应答成功
    1 g3 W3 U+ D2 F% ?
50. u8 IIC_Wait_Ack(void)
    
51. {
    ; j+ \9 [) i' @  ?/ H4 o6 f
52.         u8 ucErrTime=0;
    ; I* d4 G* M& l5 d1 U0 g: p
53.         SDA_IN();      //SDA设置为输入  
    
54.         IIC_SDA=1;delay_us(1);           
    3 p" R' E2 F6 \) P" F4 Y% D) l
55.         IIC_SCL=1;delay_us(1);         
    
56.         while(READ_SDA)
    1 h& w- Y2 b+ m4 @
57.         {
    ) `8 h- n" m* F6 H3 ~9 _
58.                 ucErrTime++;
    
59.                 if(ucErrTime>250)
    3 A& o. U" }; b8 o. _
60.                 {
    
61.                         IIC_Stop();
    
62.                         return 1;
    9 @3 i: I8 ]  _9 g3 m7 o& T$ o
63.                 }
    " n7 F3 o8 X  g4 c. C( |4 o0 p  `3 x
64.         }
    
65.         IIC_SCL=0;//时钟输出0            
    
66.         return 0;  
    
67. }
    
68. 
    / q# y( S% e; `0 j0 T2 F% H6 G- J
69. //产生ACK应答
    , {! M2 U: `+ P8 Z2 p! C, I6 f
70. void IIC_Ack(void)
    
71. {
    " S2 Q* U0 F; `/ x" r4 B) o
72.         IIC_SCL=0;
    
73.         SDA_OUT();
    
74.         IIC_SDA=0;
    
75.         delay_us(2);
    
76.         IIC_SCL=1;
    % M% g$ s! C. H% n' m
77.         delay_us(2);
    - z: V# S- z2 C) e& E' i' W
78.         IIC_SCL=0;
    5 l- Y- Z, `) f2 q
79. }
    - }3 u- H  e2 ^; O  p5 x/ _
80. 
    
81. //不产生ACK应答                    
    : @+ G$ |7 q6 R: O
82. void IIC_NAck(void)
    6 o6 L! H. D: R5 n) w( Y
83. {
    * u* e, e5 x' G
84.         IIC_SCL=0;
    2 o& Z7 G! q) x* _
85.         SDA_OUT();
    8 r2 E- o+ t8 a( {
86.         IIC_SDA=1;
    
87.         delay_us(2);
    8 A6 e3 m9 m: D; g( J( X# P' M; s
88.         IIC_SCL=1;
    
89.         delay_us(2);
    + G8 X; b6 b, p  z- r
90.         IIC_SCL=0;
    
91. }
    
92.                                                                               
    
93. //IIC发送一个字节
    
94. //返回从机有无应答
    
95. //1，有应答
    ! {5 U/ _1 D4 `. i' P
96. //0，无应答                          
    
97. void IIC_Send_Byte(u8 txd)
    
98. {                        
    % }! J1 A8 H7 V6 H
99.     u8 t;   
    
100.         SDA_OUT();            
     
101.     IIC_SCL=0;//拉低时钟开始数据传输
     
102.     for(t=0;t<8;t++)
     
103.     {              
     
104.         IIC_SDA=(txd&0x80)>>7;
     
105.         txd<<=1;           
     & T" _  A9 t# U4 x
106.                 delay_us(2);   //对TEA5767这三个延时都是必须的
     + @: v3 ?  e1 |2 o  v, X9 v' X+ f
107.                 IIC_SCL=1;
     
108.                 delay_us(2);
     
109.                 IIC_SCL=0;        
     " t; w  d/ v8 f5 d
110.                 delay_us(2);
     
111.     }         
     
112. }
     
113.             
     ' y- C  e( ]" ~2 T
114. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
     
115. u8 IIC_Read_Byte(unsigned char ack)
     1 T7 y# Y; j# X+ Q$ x
116. {
     
117.         unsigned char i,receive=0;
     
118.         SDA_IN();//SDA设置为输入
     
119.     for(i=0;i<8;i++ )
     
120.         {
     
121.         IIC_SCL=0;
     7 ~5 ^% p/ b! g5 E# f2 T
122.         delay_us(2);
     
123.                 IIC_SCL=1;
     0 b8 f( L9 S; @! o0 ]
124.         receive<<=1;
     
125.         if(READ_SDA)receive++;   
     
126.                 delay_us(1);
     
127.     }                                         
     
128.     if (!ack)
     * A' M9 F0 Y. n: @7 a: `, E. z% f1 a
129.         IIC_NAck();//发送nACK
     / t5 B) s2 e( u: p  M; ~
130.     else
     . i' W0 [1 u3 y8 a# x
131.         IIC_Ack(); //发送ACK   
     3 G8 e' Q9 O$ ?5 K1 t
132.     return receive;
     , A8 E- c6 x7 Q8 S: H0 h( p
133. }

复制代码

# ]1 k* P( B( k8 Q
$ ^  }1 V+ I2 U

1. IIC.h
   " i, v/ v! o3 P# F, I. o. S
2. 
   
3. #ifndef __MYIIC_H
   
4. #define __MYIIC_H
     k- W! M0 d) W/ a& V. O
5. #include "sys.h"
   . B' v& ?' ?% l; V: Q+ F
6. 
   
7. //IO方向设置
   
8. #define SDA_IN()  {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=0<<9*2;}        //PB9输入模式
   
9. #define SDA_OUT() {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=1<<9*2;} //PB9输出模式
   " d9 g+ Y/ s$ _! G. L) ?
10. //IO操作函数         
    
11. #define IIC_SCL    PBout(8) //SCL
    
12. #define IIC_SDA    PBout(9) //SDA         
    # E& R- |1 L7 L& ~3 G
13. #define READ_SDA   PBin(9)  //输入SDA
    
14. 
    ! h8 M% x& _/ C0 _0 z9 I
15. //IIC所有操作函数
    
16. void IIC_Init(void);                //初始化IIC的IO口                                 
    
17. void IIC_Start(void);                                //发送IIC开始信号
    ; ~$ p) r' ~+ n! i5 H& z  f
18. void IIC_Stop(void);                                  //发送IIC停止信号
    . k# `4 }/ P- L/ p7 d. L
19. void IIC_Send_Byte(u8 txd);                        //IIC发送一个字节
      {, l! t% ~1 ]% [6 P: [6 |
20. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
    : @; l. a  P+ m* F
21. u8 IIC_Wait_Ack(void);                                 //IIC等待ACK信号
    
22. void IIC_Ack(void);                                        //IIC发送ACK信号
    $ G* _9 V) n- n* S5 W  U- h$ p
23. void IIC_NAck(void);                                //IIC不发送ACK信号
    1 a; p3 E" V* ^- D0 s, q9 u
24. 
    + Y0 Q: h1 K0 X3 M- U
25. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    * A! a) c. H, W9 V; h" W3 o
26. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);         
    3 z3 d8 H7 }$ G+ a, Q+ f
27. 
    ( ^# z' q; T, u2 @% a; u) J) D
28. #endif

复制代码

2 d2 ]# c& s; q+ P6 K+ w; G四、EEPROM(24C02）的使用
总容量是256（2K/8)个字节。接口：IIC

( ]$ D% G7 Z, }" L( c$ S$ P芯片图:
; u5 R$ k" t. A7 [5 n
1 }7 [8 s) z9 Z1 ?
这里的A0=A1=A2=0

- M. [! B9 X1 N9 [. C; z: E
$ V1 ~0 p, w, y- e! K5 ?5 W


24C02读写字节时序

5 y( Z8 [& P( m* M写：

2 S2 I0 {5 p, m# l: Y6 x9 Y5 i
, W& u) j0 J6 Q4 `% U# J6 h  K9 z
- L  i& j+ }  _/ u  z5 ]读：
/ f* x  Y6 z3 |7 N! V) Z
4 }4 t0 _! Z- W" F
& A: Z+ u4 P6 X: t& R
+ D" _9 ^$ e* m- p* e24C02的代码如下：

1. 24cxx.c:
   + Q7 G7 e" y- Q& }- K! y
2. #include "24cxx.h"
   
3. #include "delay.h"                                 
   
4. 
   " E0 b* e& r: A5 J0 |! a
5. //初始化IIC接口
   3 _4 V7 R: W, j% c
6. void AT24CXX_Init(void)
   7 a3 U. M$ w. K1 u% l% S
7. {
   
8.         IIC_Init();//IIC初始化
   
9. }
   $ Y7 s3 R- t- s
10. //在AT24CXX指定地址读出一个数据
    5 B+ f  {2 J! O
11. //ReadAddr:开始读数的地址  
    ( s- p0 q7 v  z: E* M
12. //返回值  :读到的数据
    
13. u8 AT24CXX_ReadOneByte(u16 ReadAddr)
    . V4 ^; g5 g. z
14. {                                 
    - `3 K. {# h' T/ D. S4 g
15.         u8 temp=0;                                                                                                                                                               
    
16.     IIC_Start();  
    
17.         if(EE_TYPE>AT24C16)
    % N) L: C# u8 R1 ~  g
18.         {
    
19.                 IIC_Send_Byte(0XA0);           //发送写命令
    7 \4 Z5 P" X: c
20.                 IIC_Wait_Ack();
    + X: Q  q/ l* \0 F
21.                 IIC_Send_Byte(ReadAddr>>8);//发送高地址            
    . \+ P% O7 \7 L6 u! q  h
22.         }else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据            
    
23.         IIC_Wait_Ack();
    
24.     IIC_Send_Byte(ReadAddr%256);   //发送低地址
    
25.         IIC_Wait_Ack();            
    
26.         IIC_Start();                     
    
27.         IIC_Send_Byte(0XA1);           //进入接收模式                           
    6 ^, N" A8 A+ S7 h+ B
28.         IIC_Wait_Ack();         
    # f% C# t3 X( l0 W
29.     temp=IIC_Read_Byte(0);                  
    
30.     IIC_Stop();//产生一个停止条件            
    
31.         return temp;
    ' N- ], Y+ p0 L! |4 j
32. }
      W7 j* f2 C* h; n) K% }
33. //在AT24CXX指定地址写入一个数据
    + a+ [0 T: S8 H# _5 V# O  |
34. //WriteAddr  :写入数据的目的地址   
    
35. //DataToWrite:要写入的数据
    
36. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
    9 T7 E% s* m( u8 X$ S! H7 m" `" d
37. {                                                                                                                                                                                          
    6 J3 x3 K' d# Z. _
38.     IIC_Start();  
    
39.         if(EE_TYPE>AT24C16)
    
40.         {
    ) o$ h# q; Q) K# s1 @" }
41.                 IIC_Send_Byte(0XA0);            //发送写命令
    
42.                 IIC_Wait_Ack();
    & e3 v$ D0 F; v1 z% A: {0 J$ |
43.                 IIC_Send_Byte(WriteAddr>>8);//发送高地址         
    ! U6 M/ {/ k  H) U
44.         }else IIC_Send_Byte(0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据         
    5 a+ O9 @! O  T- w3 ^# m7 C. A
45.         IIC_Wait_Ack();           
    ( p$ p' n. `2 v* X0 _$ ^( M' B
46.     IIC_Send_Byte(WriteAddr%256);   //发送低地址
    
47.         IIC_Wait_Ack();                                                                                                               
    ! Q& H  z6 w0 w; g
48.         IIC_Send_Byte(DataToWrite);     //发送字节                                                           
    ! l/ f" h: L$ Q8 [2 U
49.         IIC_Wait_Ack();                                 
    
50.     IIC_Stop();//产生一个停止条件
      d* R  t9 O8 t/ O8 [, Z
51.         delay_ms(10);         
    
52. }
    - \9 ]3 n) @6 I3 c% ~- C1 R+ I
53. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    ; t5 Z+ J0 w. N0 D- j
54. //该函数用于写入16bit或者32bit的数据.
    
55. //WriteAddr  :开始写入的地址  
    ; ]& [( Z  |! ?" A! ]
56. //DataToWrite:数据数组首地址
    ( P) W2 }. |5 f5 f
57. //Len        :要写入数据的长度2,4
    7 ^  v" \( j- ?4 |
58. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
    
59. {         
    ! J# G  g2 S, w( v  L% f
60.         u8 t;
    & e2 L2 w: `2 q: K
61.         for(t=0;t<Len;t++)
    
62.         {
    . a! J* a5 D, E, s6 D0 I( A1 [
63.                 AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    
64.         }                                                                                                   
    
65. }
    7 t) o3 S; L# |
66. 
    : l( B0 w$ A( `; Q( H8 J- Z5 g
67. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    5 p- ~8 e" V0 n2 a- K: _
68. //该函数用于读出16bit或者32bit的数据.
    
69. //ReadAddr   :开始读出的地址
    
70. //返回值     :数据
    
71. //Len        :要读出数据的长度2,4
    : B  ]  V5 T6 [2 a& p8 l
72. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
    
73. {         
    
74.         u8 t;
    
75.         u32 temp=0;
    
76.         for(t=0;t<Len;t++)
    
77.         {
    - Z. X, q! Z  w* l1 T
78.                 temp<<=8;
    ( W; a% i. `$ I# `* O4 S
79.                 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);                                             
    
80.         }
    
81.         return temp;                                                                                                   
    
82. }
    
83. //检查AT24CXX是否正常
    
84. //这里用了24XX的最后一个地址(255)来存储标志字.
    
85. //如果用其他24C系列,这个地址要修改
    
86. //返回1:检测失败
      D3 A4 S. @: L0 v+ N
87. //返回0:检测成功
    . ~9 Y1 O' W! ~: @2 C
88. u8 AT24CXX_Check(void)
    
89. {
    
90.         u8 temp;
    
91.         temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX                           
    1 X# g! F4 y8 ]9 W# C% ]) t
92.         if(temp==0X55)return 0;                  
    
93.         else//排除第一次初始化的情况
    & m3 E* y$ v5 `+ d, q8 g
94.         {
    
95.                 AT24CXX_WriteOneByte(255,0X55);
    
96.             temp=AT24CXX_ReadOneByte(255);         
    6 x, r0 F0 o: n; n% v1 b7 Y
97.                 if(temp==0X55)return 0;
    " _- b* R* O0 p$ [1 u" w; H# E
98.         }
    
99.         return 1;                                                                                          
    # e9 z8 f3 g9 W! a" Z. [, _# h
100. }
     
101. 
     3 Z0 l9 n+ X9 q1 u
102. //在AT24CXX里面的指定地址开始读出指定个数的数据
     
103. //ReadAddr :开始读出的地址 对24c02为0~255
     
104. //pBuffer  :数据数组首地址
     
105. //NumToRead:要读出数据的个数
     ( [7 D& Z& W; i, c
106. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
     
107. {
     
108.         while(NumToRead)
     
109.         {
     
110.                 *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);        
     
111.                 NumToRead--;
     
112.         }
     
113. }  
     
114. //在AT24CXX里面的指定地址开始写入指定个数的数据
     
115. //WriteAddr :开始写入的地址 对24c02为0~255
     
116. //pBuffer   :数据数组首地址
     1 O2 `: G2 X% K5 }( i: c, B
117. //NumToWrite:要写入数据的个数
     ; }7 ~  s  `- u3 f7 p
118. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
     
119. {
     . M6 v( ^7 F9 n; K3 G% ~$ ^5 l. c
120.         while(NumToWrite--)
     
121.         {
     - p6 s5 Z$ O' N# W" V
122.                 AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
       Y! m5 }' |) l9 ~. @" X, g0 R
123.                 WriteAddr++;
     
124.                 pBuffer++;
     6 h  s- i# k2 d7 N( g+ A3 Z! [. _, v
125.         }
     & |  h- Y9 G: u- n4 g) Q6 `) X
126. }

复制代码

1. 24cxx.h:
   
2. #ifndef __24CXX_H
   : h7 L$ H5 r) {
3. #define __24CXX_H
   , L6 p& w- j8 {7 U5 c
4. #include "myiic.h"   
   ' R3 `3 d" Q; z: }
5. 
   
6. #define AT24C01                127
   * q8 E0 \/ i4 j2 _& J! h3 }
7. #define AT24C02                255
   * K  Z5 Z: u2 v
8. #define AT24C04                511
   
9. #define AT24C08                1023
   ! z. P( E- q, D& w# ]
10. #define AT24C16                2047
    
11. #define AT24C32                4095
    ; Z: c- O+ n, X# [) z
12. #define AT24C64            8191
    
13. #define AT24C128        16383
    
14. #define AT24C256        32767  
    
15. //Mini STM32开发板使用的是24c02，所以定义EE_TYPE为AT24C02
    6 S' q+ N( P, r! p! ^
16. #define EE_TYPE AT24C02
    
17.                                           
    , U+ c0 r4 r( [
18. u8 AT24CXX_ReadOneByte(u16 ReadAddr);                                                        //指定地址读取一个字节
    5 t6 c9 U" i: S7 y- M  t9 c
19. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite);                //指定地址写入一个字节
    
20. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len);//指定地址开始写入指定长度的数据
    
21. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len);                                        //指定地址开始读取指定长度数据
    
22. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite);        //从指定地址开始写入指定长度的数据
    " ^9 W; q  t8 w- c
23. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead);           //从指定地址开始读出指定长度的数据
    
24. 
    / u' K7 s2 ?, J6 I& f% g) a6 w
25. u8 AT24CXX_Check(void);  //检查器件
    
26. void AT24CXX_Init(void); //初始化IIC
    ! g4 @. A) c$ ]" o' {7 ^
27. #endif
    
28. 
    0 C( g$ P2 K8 t* C1 D/ [( H
29. main.c:
    8 F6 h7 h/ W9 a; ^
30. #include "sys.h"
    
31. #include "delay.h"
    
32. #include "usart.h"
    
33. #include "led.h"
    * k6 M1 |0 p7 v6 D
34. #include "lcd.h"
    # P; C  l1 X& g  h' ^+ R
35. #include "24cxx.h"
    
36. #include "key.h"  
    # I3 @9 \( s/ l$ {- V+ b. g
37. 
    / a9 m& P9 Z$ Y% z2 f) x
38. //要写入到24c02的字符串数组
    
39. const u8 TEXT_Buffer[]={"Explorer STM32F4 IIC TEST"};
    , |# M0 i8 W# {* ~  `$ _
40. #define SIZE sizeof(TEXT_Buffer)         
    
41.         
    
42. int main(void)
    0 d' l6 \2 P2 V+ @0 j  {
43. {
    
44.         u8 key;
    
45.         u16 i=0;
    
46.         u8 datatemp[SIZE];        
    
47.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
48.         delay_init(168);    //初始化延时函数
    - m7 s1 [5 K  X. U8 M* h# q" C- ?
49.         uart_init(115200);        //初始化串口波特率为115200
    " g. ?: ?& Q( U# Q
50.         
    
51.         LED_Init();                                        //初始化LED
    . V+ N$ d3 U' D$ Z
52.         KEY_Init();                                 //按键初始化  
    
53.         AT24CXX_Init();                        //IIC初始化
    
54.                         
    
55.          while(AT24CXX_Check())//检测不到24c02
    
56.         {
    / p# q# z0 ]% N$ {. F% _
57.                 printf("24C02 Check Failed!");
    + Y/ d4 e; p/ k7 V
58.                 delay_ms(500);
    
59.                 printf("Please Check!      ");
    
60.                 delay_ms(500);
    
61.                 LED0=!LED0;//DS0闪烁
    ) m: I# _6 e9 j  m3 ]3 D9 t
62.         }
    
63.         
    
64.         while(1)
    1 }' R- i4 Q7 i0 d( }; ]
65.         {
    
66.                 key=KEY_Scan(0);
    
67.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
    8 P) W6 _" e( C; [. o9 d% T# q$ W  X$ i
68.                 {
    
69.                         printf("Start Write 24C02....");   
    8 o0 }$ J1 h, ~- {
70.                         AT24CXX_Write(0,(u8*)TEXT_Buffer,SIZE);
    
71.                         printf("24C02 Write Finished!");  //提示传送完成
      B. N! |% @/ W, a( Z
72.                 }
    
73.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    " Y7 R. ^! g, q2 L' h
74.                 {
    
75.                         printf("Start Read 24C02.... ");
    9 D2 g$ G- m3 L
76.                         AT24CXX_Read(0,datatemp,SIZE);
    ! u2 D; j5 N  Q  k
77.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    
78.                         printf("%s\r\n ",datatemp);
    
79.                 }           
    6 ?% V: G% \( ~: o( n
80.         }            
    
81. }
    

复制代码

8 k& M7 d2 _, d' Q0 |4 V  U2 J- g$ V) Z9 X

1 C+ J6 N0 C+ }8 O) m