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

2 F6 ]! l+ J) Y0 o% \7 S+ A( j7 }    它由数据线SDA和时钟SCL构成的串行总线，接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上，可发送接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，高速IIC总线一般可达400kbps以上。
% z+ s" @$ |6 O# l- W& ^& B
1 Q/ r# ^* b: i2 M+ D* [IIC是半双工通信方式。

二、多主机I2C总线系统结构
3 N* ^, G6 a- s2 j

9 r3 }; v6 [1 `3 o4 M8 \, |
8 V2 q- _4 v7 S) L, l  Z2）多设备的使用举例
3 g; K9 q7 `' L5 M# x
4 P2 q* F2 f. Y; C3 \8 Y9 x每个接到I2C总线的设备都有一个唯一的地址
& j* x* G/ A# `


三、I2C协议
+ [. [" m0 F+ ^0 C! j; {空闲状态
开始信号
停止信号
应答信号
数据的有效性
数据传输
5 n# Q) v/ R! |& f4 N8 _我们以斗地主为例：
/ p* \1 V- B8 o. u( ]
! W7 A) u  J2 }) M
" k# `+ v' ?" ?. [
1）空闲状态
/ A3 k0 U$ X3 D3 t9 Q' w& Y$ N0 SI2C总线总线的SDA和SCL两条信号线同时处于高电平时，规定为总线的空闲状态。此时各个器件的输出级场效应管均处在截止状态，即释放总线，由两条信号线各自的上拉电阻把电平拉高。
; `# @, B  B3 x; V+ @
2）起始信号与停止信号
1 Q/ X2 D$ O* r1 p/ c起始信号：当SCL为高期间，SDA由高到低的跳变；启动信号是一种电平跳变时序信号，而不是一个电平信号。
5 _6 r; F8 z" {: c; y9 U7 ?停止信号：当SCL为高期间，SDA由低到高的跳变；停止信号也是一种电平跳变时序信号，而不是一个电平信号。
  l* m8 n. S9 W: r5 A

5 C% Y; w, }. q+ ]
8 z8 v6 l: w4 z6 a3）应答信号ACK
发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。
. _% g6 y, v6 d) u' b! R# D
对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P。

3 d7 j3 v; N9 ^) {: v( _; l

4）数据有效性
; w/ X6 G, q) U! sI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。

8 }( B& x) ]! i即：数据在SCL的上升沿到来之前就需准备好。并在在下降沿到来之前必须稳定。
% x$ k! ^+ b& v0 Q2 \8 D, v6 E


8 G" |  z7 u! p" w# H+ r% @5）数据的传送
; W. @/ w: u- k( y在I2C总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。

" e$ Q  S0 f0 j  T* e* J2 {STM32F4的IIC代码如下：

1. IIC.c
   + c- t+ e+ }* o
2. #include "myiic.h"
   
3. #include "delay.h"
   
4. 
   
5. //初始化IIC
   , c4 _) B7 h- L6 F- j/ _
6. void IIC_Init(void)
   
7. {                        
   
8.   GPIO_InitTypeDef  GPIO_InitStructure;
   : J+ F9 P9 _( \. q
9. 
   1 a$ S3 k! c; h/ h8 K  d# Z
10.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    1 G, Q6 A, k& T! F9 n, ]' {5 m/ {, Q8 j
11. 
    / v8 H) W4 b) x% R1 ~0 R- k$ f1 a
12.   //GPIOB8,B9初始化设置
    . E, Q( [4 b% L/ |; b# l
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
    : m( h- }$ ~2 E
14.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    3 Q7 g) P; k" @# R3 s* W
15.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
17.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
18.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
19.         IIC_SCL=1;
    7 H" Q. ?( A5 z3 Z0 D& T
20.         IIC_SDA=1;
    
21. }
    
22. 
    7 O5 a! R) C- Z7 C1 p; c  Z) w
23. //产生IIC起始信号
    ! J& {  l2 q8 U
24. void IIC_Start(void)
    
25. {
    ' i4 T3 ^/ X' F& L( g" m$ p, t* N
26.         SDA_OUT();     //sda线输出
    - Q1 g! w" J% R2 Z6 C& D
27.         IIC_SDA=1;                    
    
28.         IIC_SCL=1;
    8 d0 v. L% ^, F/ o; x  Y' R( Z5 l. E
29.         delay_us(4);
    . ~* X$ ^5 a% [' w1 k
30.          IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    1 f) c% s5 V, c/ }) {
31.         delay_us(4);
    
32.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    
33. }
    
34.          
    
35. //产生IIC停止信号
    . u& c" r: P# o; J- e% @. [" ^! G
36. void IIC_Stop(void)
    
37. {
    2 p4 C8 F3 V9 V4 O$ E9 C8 X0 O2 A
38.         SDA_OUT();//sda线输出
    4 F7 Q( T4 o& Y2 o, ~
39.         IIC_SCL=0;
    
40.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
41.          delay_us(4);
    
42.         IIC_SCL=1;
    
43.         IIC_SDA=1;//发送I2C总线结束信号
    
44.         delay_us(4);                                                                  
    2 t, {2 @0 L+ q" U, A
45. }
    
46. 
    + n4 ]; u* a6 Z0 h# o% {* H2 C
47. //等待应答信号到来
    . n  Z% L7 ^2 E1 q6 d. W! U
48. //返回值：1，接收应答失败
    
49. //        0，接收应答成功
    ; P0 S3 r. s1 L; U2 ^* ?
50. u8 IIC_Wait_Ack(void)
    ; o, g0 N; D* [' s" i, \" ?3 L- n
51. {
    
52.         u8 ucErrTime=0;
    
53.         SDA_IN();      //SDA设置为输入  
    9 J7 N8 F& |; {( `) g
54.         IIC_SDA=1;delay_us(1);           
    - U2 }: M5 U6 o1 a
55.         IIC_SCL=1;delay_us(1);         
    " l0 d- H+ ]% A) O7 T* u$ ~
56.         while(READ_SDA)
    & M! l+ o3 m( i! @5 J. T+ u
57.         {
    
58.                 ucErrTime++;
    
59.                 if(ucErrTime>250)
    
60.                 {
    
61.                         IIC_Stop();
    5 [, B" |8 C/ U) O7 d
62.                         return 1;
    : y* A8 q0 S, d) X0 M
63.                 }
    
64.         }
    ! `. T4 J0 C, w( _- F
65.         IIC_SCL=0;//时钟输出0            
    3 M8 h1 m" K0 j5 b. p3 F. w% a! T7 _
66.         return 0;  
    9 B& J4 \5 H! B% T/ E9 E" X
67. }
    ' d6 e& b3 n! L1 S# _9 O. \
68. 
    
69. //产生ACK应答
    ) Q# Q% |: S! y8 L/ t9 T5 c
70. void IIC_Ack(void)
    , H8 i5 e9 q" x& x
71. {
    & ]! r4 T8 o, z$ z- B# T: c
72.         IIC_SCL=0;
    $ P8 `4 p: K% l  N
73.         SDA_OUT();
    
74.         IIC_SDA=0;
    
75.         delay_us(2);
    * j4 w$ w; l) p) z, L4 Z1 F( w
76.         IIC_SCL=1;
    - n  K5 C% w( V8 D
77.         delay_us(2);
    % |1 y7 v; k/ l. F2 D
78.         IIC_SCL=0;
    
79. }
    
80. 
    & d" @5 M+ t& Z( I; e9 _' v
81. //不产生ACK应答                    
    # J8 M) u1 t2 q. H. [) H
82. void IIC_NAck(void)
    2 O! e, L- t$ t8 d3 Q/ R1 T; K' D
83. {
    0 Z% e; ], a* l+ c" O) Q( c
84.         IIC_SCL=0;
    
85.         SDA_OUT();
    5 ?8 H4 a0 w" H! E% V
86.         IIC_SDA=1;
    
87.         delay_us(2);
    
88.         IIC_SCL=1;
    % o6 v7 A. [' @' z  l$ g
89.         delay_us(2);
    ! J: E( f' {6 [. x1 e5 F9 \7 l
90.         IIC_SCL=0;
    ( _$ f! z1 n: e8 p9 e/ H, i9 [
91. }
    0 A& i' x: g/ o% h3 V7 R. H) c
92.                                                                               
    " B- ^# \+ f* J, q3 b9 q
93. //IIC发送一个字节
    
94. //返回从机有无应答
    
95. //1，有应答
    
96. //0，无应答                          
    
97. void IIC_Send_Byte(u8 txd)
    
98. {                        
    
99.     u8 t;   
    
100.         SDA_OUT();            
     
101.     IIC_SCL=0;//拉低时钟开始数据传输
     ) c6 c* f: x8 V! t' ]  \% y6 n
102.     for(t=0;t<8;t++)
     ( e) e3 R& {4 l6 U2 B
103.     {              
     
104.         IIC_SDA=(txd&0x80)>>7;
     
105.         txd<<=1;           
     5 Y" d7 U0 B1 d
106.                 delay_us(2);   //对TEA5767这三个延时都是必须的
     
107.                 IIC_SCL=1;
     : N; p! Y# s4 |# W. \; @9 A4 \
108.                 delay_us(2);
     . I( W2 l* j& G0 o5 t/ S5 P+ [
109.                 IIC_SCL=0;        
     
110.                 delay_us(2);
     - P1 X2 v6 `( L2 E% R$ D! m
111.     }         
     1 G' t. G9 {/ V" U+ F/ s# y4 s0 ]  C8 @
112. }
     / t/ _- R( R1 b5 Z2 P
113.             
     
114. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
     0 d3 r( }8 q$ z! Y* d
115. u8 IIC_Read_Byte(unsigned char ack)
     
116. {
     
117.         unsigned char i,receive=0;
     8 s! [" A* l. J2 h5 V: t
118.         SDA_IN();//SDA设置为输入
     + f* r) \9 z( Y
119.     for(i=0;i<8;i++ )
     * {1 O/ M. w1 k% x5 ~
120.         {
     3 z. T6 E$ M- d# p8 e0 w' I4 j7 G4 x
121.         IIC_SCL=0;
     
122.         delay_us(2);
     
123.                 IIC_SCL=1;
     
124.         receive<<=1;
     4 ?! g0 {. ~: f; x  y" R" r8 p
125.         if(READ_SDA)receive++;   
     8 V5 j; ~6 _0 }, U
126.                 delay_us(1);
     $ T9 v9 f7 \8 h1 V+ Z
127.     }                                         
     % J1 [' v1 |8 E( f7 j8 q, p
128.     if (!ack)
     # z5 r0 y4 _% C8 a3 g3 @+ F
129.         IIC_NAck();//发送nACK
     
130.     else
     
131.         IIC_Ack(); //发送ACK   
     
132.     return receive;
     2 Q+ u; _+ D1 w% Z0 i! s
133. }

复制代码

! e, X, b) q" a! w# F3 L4 X2 B& Q

1. IIC.h
   . u0 S0 I7 k7 ?! Q: o0 ?0 w
2. 
   
3. #ifndef __MYIIC_H
   
4. #define __MYIIC_H
   ; L, r/ R, A; l8 [& L3 R) R& i4 V
5. #include "sys.h"
   
6. 
   
7. //IO方向设置
   
8. #define SDA_IN()  {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=0<<9*2;}        //PB9输入模式
   1 a4 n4 i* Y) T( Z) A- l3 L2 _  f
9. #define SDA_OUT() {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=1<<9*2;} //PB9输出模式
   # \- s0 c$ \$ K' n9 X4 R5 u: S$ {
10. //IO操作函数         
    
11. #define IIC_SCL    PBout(8) //SCL
    
12. #define IIC_SDA    PBout(9) //SDA         
    
13. #define READ_SDA   PBin(9)  //输入SDA
    . F5 r) K5 U: v( v# ~7 Z/ a
14. 
    
15. //IIC所有操作函数
      u: j# B5 `% U7 g  M5 Q+ `
16. void IIC_Init(void);                //初始化IIC的IO口                                 
    
17. void IIC_Start(void);                                //发送IIC开始信号
    + z: l4 C& h- D; T4 A. {
18. void IIC_Stop(void);                                  //发送IIC停止信号
    - J: I  y# u, A8 ]- j! ?
19. void IIC_Send_Byte(u8 txd);                        //IIC发送一个字节
    6 F3 j6 x! [& Q) `! i5 E" r
20. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
    
21. u8 IIC_Wait_Ack(void);                                 //IIC等待ACK信号
    . B7 u# D& g+ s/ U
22. void IIC_Ack(void);                                        //IIC发送ACK信号
    
23. void IIC_NAck(void);                                //IIC不发送ACK信号
    
24. 
    0 _3 ^; c$ _# s* ~& q
25. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    ) c, k0 N) t4 x* P" Z' @4 l
26. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);         
    3 H+ Z7 I# s1 k9 w
27. 
    " @3 r2 |3 f3 ?, ]. |+ \
28. #endif

复制代码

. |7 ?. Y( ]: q) q. a: Z: g: @四、EEPROM(24C02）的使用
3 L9 G/ _- X  _, a& B总容量是256（2K/8)个字节。接口：IIC
, ~2 @9 Z: w4 Q* I" R, A8 Y/ t
芯片图:
) x; O, l5 u" a

* h* w+ _0 k7 h5 R+ V这里的A0=A1=A2=0


9 C( m0 k6 [! s+ ]
7 Y* T$ f7 d9 r. \. v+ w4 ]& [

24C02读写字节时序

写：

& Y% g" i6 L' M% ^
) y$ P& y" C$ X$ n, Z
读：
6 d8 L4 l! }/ T9 b5 r% X
9 |' j4 x$ @7 H# i/ l; \

3 i7 q7 m- R2 U7 {0 ~3 u, ?: @1 h1 |24C02的代码如下：
9 Y9 h( h0 N  b" x7 U/ Q

1. 24cxx.c:
   ' E' I# F" ~( A* f. b6 ?) l7 F
2. #include "24cxx.h"
   . C5 X  H0 J8 p/ j: W5 u
3. #include "delay.h"                                 
   & V6 q6 i, a3 J' Q3 {: X
4. 
   
5. //初始化IIC接口
   
6. void AT24CXX_Init(void)
     Y3 L  o3 [! Y% H$ _8 r' P
7. {
   
8.         IIC_Init();//IIC初始化
   
9. }
   
10. //在AT24CXX指定地址读出一个数据
    9 T/ e& @& _( H1 e5 Z/ z# H3 U  e
11. //ReadAddr:开始读数的地址  
    
12. //返回值  :读到的数据
    
13. u8 AT24CXX_ReadOneByte(u16 ReadAddr)
    
14. {                                 
    
15.         u8 temp=0;                                                                                                                                                               
    ) `" I- i! B6 c/ ]% L
16.     IIC_Start();  
    8 U4 h$ I4 n4 X8 A2 C4 l8 Q* o
17.         if(EE_TYPE>AT24C16)
    
18.         {
    ! Y, z; P" K' V6 s+ n  B
19.                 IIC_Send_Byte(0XA0);           //发送写命令
    
20.                 IIC_Wait_Ack();
    5 n9 ^. M- w2 {! T
21.                 IIC_Send_Byte(ReadAddr>>8);//发送高地址            
    
22.         }else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据            
    
23.         IIC_Wait_Ack();
    5 I% w- p& W8 d  k1 p% a
24.     IIC_Send_Byte(ReadAddr%256);   //发送低地址
    . ^0 C+ M3 [5 d' u2 h) C: P6 |
25.         IIC_Wait_Ack();            
    
26.         IIC_Start();                     
    * K9 F/ m' v6 N( M. \- V
27.         IIC_Send_Byte(0XA1);           //进入接收模式                           
    
28.         IIC_Wait_Ack();         
    
29.     temp=IIC_Read_Byte(0);                  
    
30.     IIC_Stop();//产生一个停止条件            
    
31.         return temp;
    
32. }
    & M) o: R! z9 c" @
33. //在AT24CXX指定地址写入一个数据
    8 C9 o4 |! [6 H/ g
34. //WriteAddr  :写入数据的目的地址   
    
35. //DataToWrite:要写入的数据
    
36. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
    # G* N. }/ m# u" T% p0 ]" |% \
37. {                                                                                                                                                                                          
    / U5 _, t- Z6 e
38.     IIC_Start();  
    
39.         if(EE_TYPE>AT24C16)
    ! U/ l: g. J+ g0 l: o
40.         {
    
41.                 IIC_Send_Byte(0XA0);            //发送写命令
    
42.                 IIC_Wait_Ack();
    
43.                 IIC_Send_Byte(WriteAddr>>8);//发送高地址         
    
44.         }else IIC_Send_Byte(0XA0+((WriteAddr/256)<<1));   //发送器件地址0XA0,写数据         
    # [$ I& w; ~8 Y6 o( c  s
45.         IIC_Wait_Ack();           
    
46.     IIC_Send_Byte(WriteAddr%256);   //发送低地址
    
47.         IIC_Wait_Ack();                                                                                                               
    / D. T' ]# ^4 g" b3 v# m
48.         IIC_Send_Byte(DataToWrite);     //发送字节                                                           
    
49.         IIC_Wait_Ack();                                 
    
50.     IIC_Stop();//产生一个停止条件
    
51.         delay_ms(10);         
    3 m0 w; c! h" u
52. }
    
53. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    # g) D/ P+ L: \
54. //该函数用于写入16bit或者32bit的数据.
    
55. //WriteAddr  :开始写入的地址  
    
56. //DataToWrite:数据数组首地址
    
57. //Len        :要写入数据的长度2,4
    
58. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
    
59. {         
    5 z0 B" p( B! h4 ~0 P7 b$ e# y( |
60.         u8 t;
    ' {7 j6 b) A4 L4 o0 F. D
61.         for(t=0;t<Len;t++)
    
62.         {
      Z, x7 ]% u- U8 S3 \
63.                 AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    
64.         }                                                                                                   
    7 J- l; l  K5 G# g/ ?
65. }
    
66. 
    
67. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    
68. //该函数用于读出16bit或者32bit的数据.
    8 k3 q6 k: J2 a  V. c
69. //ReadAddr   :开始读出的地址
    + I) ]% z" r% w0 e
70. //返回值     :数据
    
71. //Len        :要读出数据的长度2,4
    
72. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
    & k) S! c7 w, U* O2 h1 G) p
73. {         
    ; `$ X# ?2 f9 `- e8 w  M
74.         u8 t;
    ) g) p: s6 F+ s
75.         u32 temp=0;
    
76.         for(t=0;t<Len;t++)
    , b* W) m1 W/ G$ z
77.         {
    ( W8 K0 u& \& N4 _' X" t- }8 O
78.                 temp<<=8;
    
79.                 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);                                             
    4 ?4 `/ A) \8 q& {, t0 K& Y7 w/ ^5 _
80.         }
    
81.         return temp;                                                                                                   
    , o% k' m6 i! V; `2 M" x, A8 {6 V5 ^
82. }
    
83. //检查AT24CXX是否正常
    
84. //这里用了24XX的最后一个地址(255)来存储标志字.
    ; x; r  C. A: K: w8 H
85. //如果用其他24C系列,这个地址要修改
    8 H7 f: s6 E! K/ r! F2 V
86. //返回1:检测失败
    
87. //返回0:检测成功
    , N5 i' }  [. Z- d$ e
88. u8 AT24CXX_Check(void)
    
89. {
    " v" N4 {2 {; y' o# ]$ d
90.         u8 temp;
    
91.         temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX                           
    
92.         if(temp==0X55)return 0;                  
    
93.         else//排除第一次初始化的情况
    
94.         {
    
95.                 AT24CXX_WriteOneByte(255,0X55);
    + s9 a9 A, R: y$ ^) x1 S" d) H- A
96.             temp=AT24CXX_ReadOneByte(255);         
    
97.                 if(temp==0X55)return 0;
    
98.         }
    
99.         return 1;                                                                                          
    
100. }
     ) w; v+ `2 L3 K6 H* F# y- S
101. 
     9 F8 v* K) R( D; F& M! v, O4 q: K' z
102. //在AT24CXX里面的指定地址开始读出指定个数的数据
     
103. //ReadAddr :开始读出的地址 对24c02为0~255
     ) {% m9 \/ K# _4 z: I& J
104. //pBuffer  :数据数组首地址
     . k9 |0 g( `( j! O8 o" z; r2 [1 F3 B
105. //NumToRead:要读出数据的个数
     8 ?" r0 M2 ^7 T: p7 \# }
106. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
     6 l9 e/ }. i  k2 e" [
107. {
     
108.         while(NumToRead)
     + A6 [: j( `0 N5 H6 M/ J
109.         {
     
110.                 *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);        
     
111.                 NumToRead--;
     
112.         }
     
113. }  
     $ Y$ V: E% z% F. q/ i! ~
114. //在AT24CXX里面的指定地址开始写入指定个数的数据
     ) f" _( o, h/ G+ H3 r2 ?- E
115. //WriteAddr :开始写入的地址 对24c02为0~255
     & W' ~; d3 B6 `1 v% K% l
116. //pBuffer   :数据数组首地址
     9 Z# f  }" W" \' H. k2 g
117. //NumToWrite:要写入数据的个数
     6 W# [% B! e  h& p) o; P
118. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
     
119. {
     1 l! w: d5 X' {3 G# y$ ]# B
120.         while(NumToWrite--)
     * h7 d5 a1 C1 v: ?6 X
121.         {
     ; u% b( M- B, \, {3 L, W
122.                 AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
     
123.                 WriteAddr++;
     " m7 N' B8 S6 w# M  U, |4 ]
124.                 pBuffer++;
     
125.         }
     
126. }

复制代码

1. 24cxx.h:
   , C/ ~4 Q$ z' {
2. #ifndef __24CXX_H
   
3. #define __24CXX_H
   0 W  {1 Q0 i4 t$ G
4. #include "myiic.h"   
   
5. 
   
6. #define AT24C01                127
   ; |: ?. W# N, S
7. #define AT24C02                255
   
8. #define AT24C04                511
   
9. #define AT24C08                1023
   
10. #define AT24C16                2047
    : V0 {: s/ W  B3 m
11. #define AT24C32                4095
    8 s; _$ J( W, ?; E
12. #define AT24C64            8191
    * k+ J6 j6 D( B# D
13. #define AT24C128        16383
    ( H5 Y5 L+ z; O* m7 J
14. #define AT24C256        32767  
    8 r& n* O; {. c1 P" a% }) i; g5 F
15. //Mini STM32开发板使用的是24c02，所以定义EE_TYPE为AT24C02
    5 d& D0 ?1 ^* F6 h# R
16. #define EE_TYPE AT24C02
    
17.                                           
    ' l( N" e! T3 c9 y1 C) p+ P
18. u8 AT24CXX_ReadOneByte(u16 ReadAddr);                                                        //指定地址读取一个字节
    + W- B* M7 f  @; t
19. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite);                //指定地址写入一个字节
    
20. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len);//指定地址开始写入指定长度的数据
    ; w  y4 }* G2 m" o3 ^  \6 Z
21. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len);                                        //指定地址开始读取指定长度数据
    4 X' K! B" D5 P, R1 S1 b
22. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite);        //从指定地址开始写入指定长度的数据
    ! U* D9 \7 D, s& V
23. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead);           //从指定地址开始读出指定长度的数据
    8 k! J7 x0 B* d" ~# G8 w" B. E
24. 
    
25. u8 AT24CXX_Check(void);  //检查器件
    8 g. n2 J* c# ]! F+ U
26. void AT24CXX_Init(void); //初始化IIC
    
27. #endif
    $ M- z7 z: O# w
28. 
    
29. main.c:
    
30. #include "sys.h"
    4 D5 ^+ d) Z" J" ?
31. #include "delay.h"
    
32. #include "usart.h"
    
33. #include "led.h"
    7 r3 M8 M: Q6 a" y- l3 l3 G- A& w; [
34. #include "lcd.h"
    * n: o( O/ O0 s7 G
35. #include "24cxx.h"
    
36. #include "key.h"  
    
37. 
    4 f/ M7 `' p1 E9 o; p# f; d+ w
38. //要写入到24c02的字符串数组
    7 ~9 H4 y. h6 A8 Y9 L# z
39. const u8 TEXT_Buffer[]={"Explorer STM32F4 IIC TEST"};
    
40. #define SIZE sizeof(TEXT_Buffer)         
    0 M* |3 H; z9 M
41.         
    + w8 k# e5 U, x# P! J) r3 k
42. int main(void)
    " X' r/ ~9 o: S! n# o
43. {
    0 G) E! @9 ^3 m# t( }0 Q
44.         u8 key;
    $ p8 x2 T" g8 z) ]
45.         u16 i=0;
    9 b' R8 m% K* k3 j! ~; |
46.         u8 datatemp[SIZE];        
    ' E7 w1 z3 p6 J% T- s7 U: p
47.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
48.         delay_init(168);    //初始化延时函数
    
49.         uart_init(115200);        //初始化串口波特率为115200
    % ?( s8 M5 }- |' P* v5 S7 o: q
50.         
    
51.         LED_Init();                                        //初始化LED
    
52.         KEY_Init();                                 //按键初始化  
      |/ L- t  k+ z8 e( N3 E
53.         AT24CXX_Init();                        //IIC初始化
    # [  _# [% c3 A$ g# Q
54.                         
    
55.          while(AT24CXX_Check())//检测不到24c02
    ( U( V8 I' B. Y
56.         {
    
57.                 printf("24C02 Check Failed!");
    8 Z# J& R9 e+ m9 F
58.                 delay_ms(500);
    
59.                 printf("Please Check!      ");
      ]7 t- @0 g8 D9 P
60.                 delay_ms(500);
    + O: m2 S3 n0 a& l# w  A
61.                 LED0=!LED0;//DS0闪烁
    
62.         }
    
63.         
    
64.         while(1)
    
65.         {
    
66.                 key=KEY_Scan(0);
    4 s: ]; S/ t" x! E! P# \; Q
67.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
    
68.                 {
    ; s/ Q, ?, S& X0 e( V  V
69.                         printf("Start Write 24C02....");   
    
70.                         AT24CXX_Write(0,(u8*)TEXT_Buffer,SIZE);
    ! `+ g4 a& ?8 z& z3 u$ ^
71.                         printf("24C02 Write Finished!");  //提示传送完成
    . a) Z: E( h! _+ q. e" y- |1 f
72.                 }
    : I: T) m9 P' b. D1 i9 d
73.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    . [5 F7 [4 R' L, N( s
74.                 {
    
75.                         printf("Start Read 24C02.... ");
    
76.                         AT24CXX_Read(0,datatemp,SIZE);
    
77.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    + l0 s! x" E8 ?2 ]) k5 n3 P. o) q* f
78.                         printf("%s\r\n ",datatemp);
    / X6 i0 r$ A- s
79.                 }           
    
80.         }            
    
81. }
    1 |* j" I3 C; v% Q$ s

复制代码

0 C7 m2 G# ?# _- I" N# h
. a( v3 x, F2 _/ L- N& d