一、IIC的定义
* x+ ~% q3 e: D7 ^+ V    I2C(IIC,Inter－Integrated Circuit),两线式串行总线,由PHILIPS开发用于连接微控制器及其外围设备。IIC是一种多向控制总线，就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实施数据传输的控制源。这种方式简化信号传输总线。
9 v+ h" {  e( u/ n3 ^
2 \+ T5 D! [4 v' B* v    它由数据线SDA和时钟SCL构成的串行总线，接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上，可发送接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，高速IIC总线一般可达400kbps以上。

$ {7 m5 X, {  k1 y5 w- `3 zIIC是半双工通信方式。

* P. w3 Q4 b0 F3 p二、多主机I2C总线系统结构


7 S& q( T5 m$ [3 }, m
: y* p* v3 |' ?" c: I$ |2）多设备的使用举例

; |  g3 N0 P, \4 j1 s4 i: \每个接到I2C总线的设备都有一个唯一的地址
2 G' T- p" W# H4 z


% {7 X& l1 d( `& C8 f" M0 B6 S8 W三、I2C协议
空闲状态
开始信号
停止信号
1 p' l+ m3 k$ A/ V8 S+ [% Y应答信号
  ?+ V" e8 |) [, `数据的有效性
数据传输
我们以斗地主为例：



1）空闲状态
I2C总线总线的SDA和SCL两条信号线同时处于高电平时，规定为总线的空闲状态。此时各个器件的输出级场效应管均处在截止状态，即释放总线，由两条信号线各自的上拉电阻把电平拉高。
% l9 N9 z. G/ ]! z- L% i
2）起始信号与停止信号
& n3 o; x" r8 x, r# }起始信号：当SCL为高期间，SDA由高到低的跳变；启动信号是一种电平跳变时序信号，而不是一个电平信号。
7 b/ i( `. f5 T- }  V! I# E停止信号：当SCL为高期间，SDA由低到高的跳变；停止信号也是一种电平跳变时序信号，而不是一个电平信号。



3）应答信号ACK
发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。

对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P。
' A8 k  Z( ]# d- O6 e& L
7 R" U8 }+ N. m" E3 Q

4）数据有效性
( h: M4 B  B/ G7 n  e7 p7 AI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。

即：数据在SCL的上升沿到来之前就需准备好。并在在下降沿到来之前必须稳定。
$ l/ L* M; w8 h  q9 K; [! R8 k% w/ F# o2 B


2 r& ?' c% {$ ]( @, P5）数据的传送
9 T, O, t$ O8 `. ^- }在I2C总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。

STM32F4的IIC代码如下：

1. IIC.c
   
2. #include "myiic.h"
   
3. #include "delay.h"
   
4. 
     m( Z9 `. {# B) A$ u  ]
5. //初始化IIC
   : C( L/ d7 G* S% J5 ?% C/ D0 F$ A4 A
6. void IIC_Init(void)
   
7. {                        
   , W! u( T5 E: X- E2 |+ F2 [# k. w7 n
8.   GPIO_InitTypeDef  GPIO_InitStructure;
   ( \3 o- d% [4 b
9. 
   3 n' a8 I0 y* Y5 r2 v. X5 i
10.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    3 O7 J! P( p3 u& o4 G
11. 
    % B, m6 W. M9 H2 O0 Z
12.   //GPIOB8,B9初始化设置
    
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
    ( D7 C0 S( t0 \) K1 \1 t$ U8 v
14.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    - Y' u+ z. ?! ^! u: G& g9 R
15.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    ' {. k* t- t6 v6 B2 i; _3 O  E
16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    & D+ ~* \( O! C$ e; J' r
17.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
18.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
19.         IIC_SCL=1;
    ! x/ S5 h/ P! Q. B  y( ]) S8 m9 O$ Q
20.         IIC_SDA=1;
    
21. }
    
22. 
    
23. //产生IIC起始信号
    
24. void IIC_Start(void)
    
25. {
    
26.         SDA_OUT();     //sda线输出
    
27.         IIC_SDA=1;                    
    ' d1 u" d' O' a% j6 L
28.         IIC_SCL=1;
    / X' R) z. U3 K2 ^1 `
29.         delay_us(4);
    3 n6 M8 O" t4 m' i0 K
30.          IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
31.         delay_us(4);
    7 z( ]- Y7 A6 u" ]5 I  i
32.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    
33. }
    
34.          
    
35. //产生IIC停止信号
    & q# ~8 k; b  K' v0 _
36. void IIC_Stop(void)
    
37. {
    & [& R0 G( ?" U- l+ t" W/ T
38.         SDA_OUT();//sda线输出
    
39.         IIC_SCL=0;
    . r4 X7 t0 g) V- J
40.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    ' e# F7 }: S% X+ }" D3 D
41.          delay_us(4);
    " a  A' H8 s- }! W; s# O& e
42.         IIC_SCL=1;
    
43.         IIC_SDA=1;//发送I2C总线结束信号
    ( D' I+ J- A$ h. I: }
44.         delay_us(4);                                                                  
    7 l; X4 E) I0 k8 ]
45. }
    4 B6 H- h! ^: i( F# n! P2 V
46. 
    9 p. M+ z- S3 T
47. //等待应答信号到来
    
48. //返回值：1，接收应答失败
    ' F3 H# {3 ~; q6 o
49. //        0，接收应答成功
    
50. u8 IIC_Wait_Ack(void)
    4 {* B* O" L8 X7 _
51. {
    
52.         u8 ucErrTime=0;
    8 {4 u7 J$ @3 F# `# T' h7 i$ a
53.         SDA_IN();      //SDA设置为输入  
    
54.         IIC_SDA=1;delay_us(1);           
    
55.         IIC_SCL=1;delay_us(1);         
    
56.         while(READ_SDA)
    
57.         {
    
58.                 ucErrTime++;
    ' b3 X. B" O3 e0 y
59.                 if(ucErrTime>250)
    
60.                 {
    
61.                         IIC_Stop();
    * C( ~* O( t/ @2 r# l; `
62.                         return 1;
    ) b: Y% J4 P$ u' t+ C
63.                 }
    ; ~7 V% h0 v4 s/ p6 Y" \: x
64.         }
    
65.         IIC_SCL=0;//时钟输出0            
    
66.         return 0;  
    % |; i" w8 e; R/ a, P
67. }
    
68. 
    ( C# }) s% C: z
69. //产生ACK应答
    
70. void IIC_Ack(void)
    
71. {
    $ P: N( K9 U% o4 d; L1 ~% r
72.         IIC_SCL=0;
    
73.         SDA_OUT();
    
74.         IIC_SDA=0;
    
75.         delay_us(2);
    
76.         IIC_SCL=1;
    ! G. J1 p1 h/ E% [) ~: B6 l* S: X9 {
77.         delay_us(2);
    ! Q* }/ F+ x7 `% Y2 x% j# L( S
78.         IIC_SCL=0;
    
79. }
    * \" k  r' ~* i3 D: N
80. 
    
81. //不产生ACK应答                    
    4 I( V6 b* w8 L0 B/ X3 F
82. void IIC_NAck(void)
    
83. {
    . `0 P! Y3 ?$ {  A; D# m
84.         IIC_SCL=0;
    
85.         SDA_OUT();
    / {) w1 M1 G" Q4 u4 R- }, V
86.         IIC_SDA=1;
    4 }/ v. ?0 m- O% j: J+ l8 y
87.         delay_us(2);
    
88.         IIC_SCL=1;
    6 L- x; H  j. T( V& K+ X
89.         delay_us(2);
    
90.         IIC_SCL=0;
    
91. }
    
92.                                                                               
    
93. //IIC发送一个字节
    
94. //返回从机有无应答
    ) h" k) U9 n; I6 C; i
95. //1，有应答
    
96. //0，无应答                          
    
97. void IIC_Send_Byte(u8 txd)
    ) I0 I0 |  D& J! V; H
98. {                        
    # x' `& F2 V' v
99.     u8 t;   
    + Q  V/ J6 ?* R& i% K# ?  g0 D
100.         SDA_OUT();            
     
101.     IIC_SCL=0;//拉低时钟开始数据传输
     , j0 _- D9 Z* b- u5 E* @
102.     for(t=0;t<8;t++)
     
103.     {              
     
104.         IIC_SDA=(txd&0x80)>>7;
     " Q& M& s3 O* n8 O. i# Q
105.         txd<<=1;           
     
106.                 delay_us(2);   //对TEA5767这三个延时都是必须的
     8 b- a5 \; R# f
107.                 IIC_SCL=1;
     
108.                 delay_us(2);
       T& q, h2 W  y
109.                 IIC_SCL=0;        
     
110.                 delay_us(2);
     
111.     }         
     
112. }
     2 e, W+ e  a# x
113.             
     : ]8 m1 x, @! F
114. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
     9 T, f# m+ H, v, J
115. u8 IIC_Read_Byte(unsigned char ack)
     
116. {
     
117.         unsigned char i,receive=0;
     3 C: s! L1 m; b6 D6 O  g/ R
118.         SDA_IN();//SDA设置为输入
     # ~, r/ u  J8 D0 \8 b: \; c. A* x. Y
119.     for(i=0;i<8;i++ )
     
120.         {
       X+ Q7 ?% f9 O, P! D0 g# g  n
121.         IIC_SCL=0;
     + V! D6 T5 k. p7 b- L+ Q
122.         delay_us(2);
     
123.                 IIC_SCL=1;
     1 t+ y, T, E" t) `3 G. w; H$ G
124.         receive<<=1;
     9 F( j" u# a9 U8 G) u
125.         if(READ_SDA)receive++;   
     % ?4 U, u8 Z" }  N
126.                 delay_us(1);
     0 u  A  o6 M; q0 a- }4 y+ P9 G
127.     }                                         
     
128.     if (!ack)
     , G+ Q7 ?6 z3 e* H& o& O: z
129.         IIC_NAck();//发送nACK
     ) w; n$ T3 ~1 _5 _
130.     else
     9 H  n9 ]0 Y8 i) L0 t
131.         IIC_Ack(); //发送ACK   
     6 r* S- m! ~* `' ?- g% Y
132.     return receive;
     - g/ o) Q" ~, }8 u5 C! L
133. }

复制代码

1. IIC.h
   . p2 Q! q. U- t
2. 
   
3. #ifndef __MYIIC_H
   $ t+ q" Y" g2 E- I3 l) K
4. #define __MYIIC_H
   
5. #include "sys.h"
   
6. 
   
7. //IO方向设置
   
8. #define SDA_IN()  {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=0<<9*2;}        //PB9输入模式
     n  c# I- w# E6 |
9. #define SDA_OUT() {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=1<<9*2;} //PB9输出模式
   
10. //IO操作函数         
    # y8 @* p% p' C* l1 F
11. #define IIC_SCL    PBout(8) //SCL
    , }$ F" Y9 C# ~
12. #define IIC_SDA    PBout(9) //SDA         
    
13. #define READ_SDA   PBin(9)  //输入SDA
    0 a5 I/ t8 c" v' T4 l
14. 
    " E& {) x, f6 F7 H
15. //IIC所有操作函数
    & n1 {! r! ~" s1 F; r" d
16. void IIC_Init(void);                //初始化IIC的IO口                                 
    % C# b% y( X& `9 r. |5 f
17. void IIC_Start(void);                                //发送IIC开始信号
    
18. void IIC_Stop(void);                                  //发送IIC停止信号
    
19. void IIC_Send_Byte(u8 txd);                        //IIC发送一个字节
    + a% f( _2 o- m; K, f% e% r9 b
20. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
      `0 W0 }9 {6 q! H
21. u8 IIC_Wait_Ack(void);                                 //IIC等待ACK信号
    
22. void IIC_Ack(void);                                        //IIC发送ACK信号
    . H4 E: l; q, W4 K0 k4 A
23. void IIC_NAck(void);                                //IIC不发送ACK信号
    
24. 
      ^: M" a; E1 a
25. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    
26. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);         
    * L4 ~# l1 |* C8 S* E
27. 
    . M5 L9 w- @) e, l1 C/ _- v8 b
28. #endif

复制代码

' g! ?1 z4 V! k% l四、EEPROM(24C02）的使用
0 l1 }; e: @5 C& |5 ]总容量是256（2K/8)个字节。接口：IIC

( }( A: w' {# `2 P" M芯片图:
% A* I+ Y% f4 V* d, a! S

这里的A0=A1=A2=0
& F- ~% }* c1 f0 H1 K4 z


% a) m! i# X* B9 S4 K7 S( d) J

- R" b. o0 r3 [2 V24C02读写字节时序
8 ~" ~  ]& {1 C5 n- B8 v7 x
写：
( M% o$ f5 d* f


读：


& V/ V1 F+ Q& h- t* C
  V; R, O' e  f+ N+ v3 P) O& K- ]! x- x24C02的代码如下：

1. 24cxx.c:
   
2. #include "24cxx.h"
   * _6 a/ S! L2 Z/ C' }2 p) p, Q
3. #include "delay.h"                                 
   
4. 
   , k9 m- O" ], X9 t# K
5. //初始化IIC接口
   
6. void AT24CXX_Init(void)
   3 P5 A4 W8 }  f/ c; w
7. {
   $ V. w; ?5 R1 d1 ~  Q2 w' B3 [
8.         IIC_Init();//IIC初始化
   8 t+ w. J9 L8 L5 o3 [3 i  `# P
9. }
   / K% t6 x6 {+ ?. i
10. //在AT24CXX指定地址读出一个数据
    
11. //ReadAddr:开始读数的地址  
    
12. //返回值  :读到的数据
    / j, S" H- m+ c7 ]; c& W3 w5 h5 U
13. u8 AT24CXX_ReadOneByte(u16 ReadAddr)
    " B9 C* c! a/ D( J" J
14. {                                 
    + _7 n) U; g5 ]$ H! e
15.         u8 temp=0;                                                                                                                                                               
    0 ?7 c, \+ i! i$ z% u' d
16.     IIC_Start();  
    % ?6 }" P5 e  p; b) M
17.         if(EE_TYPE>AT24C16)
    ; ^5 G. I; w7 G, d; G+ |% b3 `4 \! V
18.         {
    
19.                 IIC_Send_Byte(0XA0);           //发送写命令
    
20.                 IIC_Wait_Ack();
    ' Z: D  j) H, t. N1 w
21.                 IIC_Send_Byte(ReadAddr>>8);//发送高地址            
    
22.         }else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据            
    ! z( Y" X7 t6 K% f
23.         IIC_Wait_Ack();
    
24.     IIC_Send_Byte(ReadAddr%256);   //发送低地址
    ) o0 Q1 }! W$ x
25.         IIC_Wait_Ack();            
    % Z) b  R5 R0 s! s4 P0 Y8 {, L* `
26.         IIC_Start();                     
    
27.         IIC_Send_Byte(0XA1);           //进入接收模式                           
      {& z+ r6 i4 F# ~3 b$ u
28.         IIC_Wait_Ack();         
    
29.     temp=IIC_Read_Byte(0);                  
    * W- ?, b9 [/ E! E5 i" ?, S8 C
30.     IIC_Stop();//产生一个停止条件            
    
31.         return temp;
    
32. }
    / ]- I! a( T( |
33. //在AT24CXX指定地址写入一个数据
    
34. //WriteAddr  :写入数据的目的地址   
    
35. //DataToWrite:要写入的数据
    6 b9 e+ [0 d! M; \7 x
36. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
    ( {3 U2 `* d+ A/ }/ {+ g
37. {                                                                                                                                                                                          
    
38.     IIC_Start();  
    
39.         if(EE_TYPE>AT24C16)
    
40.         {
    ( y; m6 v5 O* g0 u' J, F; Z+ }) C( M
41.                 IIC_Send_Byte(0XA0);            //发送写命令
    5 t" e6 \# O* X
42.                 IIC_Wait_Ack();
    
43.                 IIC_Send_Byte(WriteAddr>>8);//发送高地址         
    
44.         }else IIC_Send_Byte(0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据         
    
45.         IIC_Wait_Ack();           
    $ h, u/ [& W5 [/ o
46.     IIC_Send_Byte(WriteAddr%256);   //发送低地址
    1 L' c3 a" L5 j) g+ j& h8 s
47.         IIC_Wait_Ack();                                                                                                               
    0 l1 j( }7 {" c, @2 F
48.         IIC_Send_Byte(DataToWrite);     //发送字节                                                           
    # x) J0 b6 u+ R+ j$ F
49.         IIC_Wait_Ack();                                 
    4 R! [5 U4 [7 ^- O1 b* i" Z
50.     IIC_Stop();//产生一个停止条件
    / m$ Y8 s# B0 j  ?" z! d1 a$ N
51.         delay_ms(10);         
    ' w# B( J6 T  }
52. }
    1 u- H9 W( e  ?) \
53. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    
54. //该函数用于写入16bit或者32bit的数据.
    8 |+ Y$ o2 L  F& \; L: \' ~
55. //WriteAddr  :开始写入的地址  
    
56. //DataToWrite:数据数组首地址
    
57. //Len        :要写入数据的长度2,4
    
58. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
    
59. {         
    
60.         u8 t;
    
61.         for(t=0;t<Len;t++)
    
62.         {
    % ^4 ]1 p. f4 a6 s3 g" u
63.                 AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    0 r* O; v. s# z: D! p& M
64.         }                                                                                                   
    : _2 G& N- \& U) B" W
65. }
    9 Z, P( h9 E! P3 v5 B! g1 \% U
66. 
    2 F6 T" ~2 ^9 Q( J) }+ ]# z
67. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    
68. //该函数用于读出16bit或者32bit的数据.
    
69. //ReadAddr   :开始读出的地址
    ! y  D- V: @' w
70. //返回值     :数据
    1 Z$ N! p+ ^0 _# y# g( g* ~7 W- G
71. //Len        :要读出数据的长度2,4
    / w. D) e" k" j% L+ y& ~3 F
72. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
    
73. {         
    # u5 n, G6 ?# c/ }! [+ {
74.         u8 t;
    
75.         u32 temp=0;
    ' u7 L! h+ _+ @! t% @: m0 [
76.         for(t=0;t<Len;t++)
    
77.         {
    
78.                 temp<<=8;
    1 a8 V( D. v& H% T; {, ^3 F
79.                 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);                                             
    
80.         }
    
81.         return temp;                                                                                                   
    
82. }
    8 X4 ]0 {8 |  [& c7 m
83. //检查AT24CXX是否正常
    
84. //这里用了24XX的最后一个地址(255)来存储标志字.
    8 f$ \4 Z8 D& w7 x- c5 h! ?
85. //如果用其他24C系列,这个地址要修改
    
86. //返回1:检测失败
    
87. //返回0:检测成功
    
88. u8 AT24CXX_Check(void)
    
89. {
    + l  Q3 t$ s* r; A
90.         u8 temp;
    
91.         temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX                           
    
92.         if(temp==0X55)return 0;                  
    
93.         else//排除第一次初始化的情况
    2 d2 I, A6 d0 s; ^8 b9 k
94.         {
    ; c3 v; ~" j! V6 h' o
95.                 AT24CXX_WriteOneByte(255,0X55);
    6 D9 @( x2 f! }; T- }
96.             temp=AT24CXX_ReadOneByte(255);         
    3 @) k6 Z: E+ R% ~
97.                 if(temp==0X55)return 0;
    
98.         }
    
99.         return 1;                                                                                          
    5 i# E1 t# z% v7 o. O
100. }
     
101. 
     & P$ Q) `0 m3 V; G1 R! e
102. //在AT24CXX里面的指定地址开始读出指定个数的数据
     . |7 z7 z7 u/ O9 I/ E  w
103. //ReadAddr :开始读出的地址 对24c02为0~255
     
104. //pBuffer  :数据数组首地址
     
105. //NumToRead:要读出数据的个数
     + y4 ?! K6 a& D* ]$ ?9 I& @
106. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
     
107. {
     - Q3 Z# {& X# G1 E
108.         while(NumToRead)
     
109.         {
     " v$ S3 t- h" |
110.                 *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);        
       ~; A& d  L/ \3 T! m' G
111.                 NumToRead--;
     ! F. x2 }- O. u4 [! i9 ]" m
112.         }
     $ R; Y# }, D' P/ ]/ i8 r/ v+ z
113. }  
     
114. //在AT24CXX里面的指定地址开始写入指定个数的数据
     
115. //WriteAddr :开始写入的地址 对24c02为0~255
     
116. //pBuffer   :数据数组首地址
     ' S& }  v- r6 C" }5 ]) X1 {
117. //NumToWrite:要写入数据的个数
     ( B+ f9 B; N5 e/ @
118. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
     
119. {
     
120.         while(NumToWrite--)
     ) a2 w+ v% E: _1 h
121.         {
     
122.                 AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
     4 y, V4 m) r: B" U8 o; [2 r, j
123.                 WriteAddr++;
     & X: L) V3 ^) s" e
124.                 pBuffer++;
     : P( A6 j& i5 O
125.         }
     
126. }

复制代码

1. 24cxx.h:
   
2. #ifndef __24CXX_H
   
3. #define __24CXX_H
   
4. #include "myiic.h"   
   , j  o; Q1 Z9 c0 I. a% [0 I
5. 
   
6. #define AT24C01                127
   
7. #define AT24C02                255
   3 i: v; \+ _8 O2 h( u& q: @" I
8. #define AT24C04                511
   . Q0 @: I# G0 A- u
9. #define AT24C08                1023
   2 @5 h  A0 c& |% B1 G: R: \
10. #define AT24C16                2047
    
11. #define AT24C32                4095
    2 p4 M7 s! C  _1 F1 x
12. #define AT24C64            8191
    
13. #define AT24C128        16383
    
14. #define AT24C256        32767  
    $ r. O, _4 Z4 j. a
15. //Mini STM32开发板使用的是24c02，所以定义EE_TYPE为AT24C02
    
16. #define EE_TYPE AT24C02
    
17.                                           
    , ?3 i* R' U  P* l
18. u8 AT24CXX_ReadOneByte(u16 ReadAddr);                                                        //指定地址读取一个字节
    # l2 S! |8 Z8 n" i8 ^) m0 [
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);        //从指定地址开始写入指定长度的数据
    8 e) J0 {% I% v; J6 \( w3 i/ J
23. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead);           //从指定地址开始读出指定长度的数据
    : U( {! F! a4 X( `7 a9 ~: p* ?" i6 g
24. 
    
25. u8 AT24CXX_Check(void);  //检查器件
    9 _, r3 a2 i7 r1 }
26. void AT24CXX_Init(void); //初始化IIC
    
27. #endif
    
28. 
    1 r6 j7 ], ~0 }" J. H! j, C
29. main.c:
    
30. #include "sys.h"
    . g) R4 D# c5 l- g+ R
31. #include "delay.h"
    1 F2 w) \0 ^2 w
32. #include "usart.h"
    
33. #include "led.h"
    
34. #include "lcd.h"
    
35. #include "24cxx.h"
    4 U" N6 V/ s3 o& L! \
36. #include "key.h"  
    
37. 
    % s: X/ p& o4 y3 H# w2 d' x
38. //要写入到24c02的字符串数组
    
39. const u8 TEXT_Buffer[]={"Explorer STM32F4 IIC TEST"};
    
40. #define SIZE sizeof(TEXT_Buffer)         
    
41.         
    
42. int main(void)
    * Q. G. R) r, t" \! B( t+ D
43. {
    ! f* z/ `7 b* P3 J9 f4 D2 d
44.         u8 key;
    / J) b4 c& T6 x0 Q6 S
45.         u16 i=0;
    
46.         u8 datatemp[SIZE];        
    
47.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
48.         delay_init(168);    //初始化延时函数
    1 P# E+ G2 c! _" \
49.         uart_init(115200);        //初始化串口波特率为115200
    1 j' i, [* O& v+ [; W0 q* P
50.         
    
51.         LED_Init();                                        //初始化LED
    
52.         KEY_Init();                                 //按键初始化  
    2 Y- t: R  W' n+ x' v' g- T
53.         AT24CXX_Init();                        //IIC初始化
    
54.                         
    2 F1 i* A* P* t; f( [" h6 m9 u( C0 }
55.          while(AT24CXX_Check())//检测不到24c02
    ( D9 A; Q& t9 p
56.         {
    
57.                 printf("24C02 Check Failed!");
    
58.                 delay_ms(500);
    * C- f( h- X. o( [$ p5 N
59.                 printf("Please Check!      ");
    
60.                 delay_ms(500);
    
61.                 LED0=!LED0;//DS0闪烁
    
62.         }
    % T4 _/ d  j( x( u* d) E4 u7 T& }
63.         
    4 C! j$ a. o& B+ i9 D- h0 c
64.         while(1)
    8 I0 z5 t6 _% i6 A. |1 Z. {. I
65.         {
    ) w3 [! ?  w" _8 o  Y2 }# k) b
66.                 key=KEY_Scan(0);
    , z! w2 ~3 X% L' E: }
67.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
    $ z2 b8 i$ H" U- _
68.                 {
    9 \, K  t3 I( J  \6 v1 s
69.                         printf("Start Write 24C02....");   
      j9 p3 ~8 I$ F0 N
70.                         AT24CXX_Write(0,(u8*)TEXT_Buffer,SIZE);
    
71.                         printf("24C02 Write Finished!");  //提示传送完成
    ( ~8 W) \" X+ W+ P
72.                 }
    
73.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    - ]3 {) n; U/ W# g
74.                 {
    2 G9 L6 B; N+ T4 n+ Q
75.                         printf("Start Read 24C02.... ");
    + @& y, J9 g. g( G. y
76.                         AT24CXX_Read(0,datatemp,SIZE);
    
77.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    
78.                         printf("%s\r\n ",datatemp);
    
79.                 }           
    
80.         }            
    
81. }
    

复制代码