一、IIC的定义
  _* q# V4 ?( E; L1 t8 o/ i    I2C(IIC,Inter－Integrated Circuit),两线式串行总线,由PHILIPS开发用于连接微控制器及其外围设备。IIC是一种多向控制总线，就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实施数据传输的控制源。这种方式简化信号传输总线。
& r5 {  f, e/ W# M9 U
: p; `8 X  S$ H    它由数据线SDA和时钟SCL构成的串行总线，接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上，可发送接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，高速IIC总线一般可达400kbps以上。

IIC是半双工通信方式。
- \7 I( F) Z! |6 [, M
) p% o$ c- k7 N' T) [3 t5 y二、多主机I2C总线系统结构
! |) d8 l6 Z: J: i
  P5 W) F1 q$ t7 I

2）多设备的使用举例
0 d1 m* z; }8 i% S4 I
2 U$ d8 Q7 _" l每个接到I2C总线的设备都有一个唯一的地址

3 y3 w( ?5 V' n9 O) |9 s9 F

% o4 ?0 Y0 ~, P三、I2C协议
. D: M4 x) n7 o& S( r2 j. [空闲状态
) f. R$ Q" d% X$ ~; v3 L2 q# t开始信号
% w$ N. y% S. t  l5 j停止信号
: [1 q$ Z; G8 \* |应答信号
6 \* G- W4 ~* f4 `+ s( z数据的有效性
4 r& M0 `+ K0 B数据传输
9 n. H- i& N" L# S我们以斗地主为例：

  y+ G0 C( J% N/ U2 Z$ |
& W  M7 E, v, h+ C
1）空闲状态
I2C总线总线的SDA和SCL两条信号线同时处于高电平时，规定为总线的空闲状态。此时各个器件的输出级场效应管均处在截止状态，即释放总线，由两条信号线各自的上拉电阻把电平拉高。
4 g8 Z1 A* E1 I; v% D
2）起始信号与停止信号
起始信号：当SCL为高期间，SDA由高到低的跳变；启动信号是一种电平跳变时序信号，而不是一个电平信号。
* n& V" w! Z: Q& C停止信号：当SCL为高期间，SDA由低到高的跳变；停止信号也是一种电平跳变时序信号，而不是一个电平信号。
- M$ Q8 e- d" S; S/ D6 z7 Z
! _' O% [% A' V/ L& k2 K# r

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

9 j* }$ b9 V1 O( s% Z+ I* b1 O- V对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P。
4 I3 f! D* F* p. w# Y
) ~6 s3 r$ n  I* }( Y& q, L
* |% V- y! S* X6 Q! @
4）数据有效性
6 R3 x- X+ d. D9 F$ B3 B  {2 y$ pI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。
! P" j, G  ]! _
即：数据在SCL的上升沿到来之前就需准备好。并在在下降沿到来之前必须稳定。

7 Z! \* G2 t7 C. B: S4 w

5）数据的传送
- S  x# X* H/ c' B* B8 _$ X在I2C总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。

, O8 q- [8 L$ b- E5 u% ^2 @7 QSTM32F4的IIC代码如下：
4 A/ {" R& W+ T) j* Q8 v; Q

1. IIC.c
   1 `7 @( m* N- L5 @: z1 K8 C$ C( x) L. H
2. #include "myiic.h"
   + _) k* J0 ?3 ?- A) F3 ~6 g) f, L
3. #include "delay.h"
   
4. 
   
5. //初始化IIC
   
6. void IIC_Init(void)
   ' Q" G* c& g% R
7. {                        
   
8.   GPIO_InitTypeDef  GPIO_InitStructure;
   
9. 
   
10.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    
11. 
    
12.   //GPIOB8,B9初始化设置
    : i- M% o+ c4 F# t
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
    
14.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    
15.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    9 ~) @" k, v! p$ ]$ S5 P
16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    * M! w- v" G- n- Y, X
17.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
18.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
19.         IIC_SCL=1;
    % Q9 A: B; e( L: i' @
20.         IIC_SDA=1;
    & X$ W  ?2 k% u. V8 d$ S% c) M  x
21. }
    3 Y. |5 a0 U5 B# Z% }! ]6 c+ ~
22. 
    
23. //产生IIC起始信号
    
24. void IIC_Start(void)
    3 I" D& q1 X! q2 f! X0 a$ z% f
25. {
    ( g2 U! [, w/ t; q% U5 y
26.         SDA_OUT();     //sda线输出
    : X8 A' Q0 Y" M* M4 ]# r
27.         IIC_SDA=1;                    
    $ H7 m$ d& @) M- d: U
28.         IIC_SCL=1;
    
29.         delay_us(4);
    8 A  e) Q+ H3 M$ Y+ s7 W. u
30.          IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
31.         delay_us(4);
    - o; B9 M; z, v$ F
32.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    
33. }
    6 l% B6 q7 ~6 l
34.          
    7 }/ k% `) m& m; L5 k; [
35. //产生IIC停止信号
    
36. void IIC_Stop(void)
    ! S5 ^, A' v- _2 W" @2 r& X
37. {
    
38.         SDA_OUT();//sda线输出
    ! ?  z* h# K, k
39.         IIC_SCL=0;
    1 n0 O' i5 H* H; M
40.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
41.          delay_us(4);
    # c9 ]5 q2 W! u6 c  u8 p
42.         IIC_SCL=1;
    ( ?% \$ t: w6 P1 p* H( b
43.         IIC_SDA=1;//发送I2C总线结束信号
    7 F* l  r/ q2 J, K0 [1 l# S7 ^% y( f) O
44.         delay_us(4);                                                                  
    
45. }
    
46. 
    5 i5 U3 ^' L5 _- e& f7 _
47. //等待应答信号到来
      r6 T  f: J: a9 b3 N& W6 t# ]
48. //返回值：1，接收应答失败
    
49. //        0，接收应答成功
    3 ]/ t2 k7 i6 \. _0 M/ H
50. u8 IIC_Wait_Ack(void)
    
51. {
    
52.         u8 ucErrTime=0;
    4 m% d$ S$ q2 O9 j, V: A
53.         SDA_IN();      //SDA设置为输入  
    
54.         IIC_SDA=1;delay_us(1);           
    
55.         IIC_SCL=1;delay_us(1);         
    1 O! Y& b; _) {0 i5 ?8 V
56.         while(READ_SDA)
    
57.         {
    # R! a3 R, k5 s  s
58.                 ucErrTime++;
    
59.                 if(ucErrTime>250)
    ( @. ^$ E$ l: g3 u4 q* e5 J4 l
60.                 {
    3 `) M7 l/ A4 @; l/ @
61.                         IIC_Stop();
    
62.                         return 1;
    " S+ C* u: T% a. W9 M6 U
63.                 }
    
64.         }
    - a6 \! n6 B. Z1 G# t
65.         IIC_SCL=0;//时钟输出0            
    
66.         return 0;  
    
67. }
    
68. 
    ) R8 \8 }6 D( {5 D2 o% i
69. //产生ACK应答
    7 E# A3 u3 h) r+ ^# _: M  J
70. void IIC_Ack(void)
    
71. {
    
72.         IIC_SCL=0;
    : b' {& {$ f& D- X
73.         SDA_OUT();
    , p/ }: |) K% I0 \4 H2 ~
74.         IIC_SDA=0;
    
75.         delay_us(2);
    5 h0 V# f  M3 i9 h8 E1 g+ V- m
76.         IIC_SCL=1;
    
77.         delay_us(2);
    & |0 y  n- L! M, o* q" g
78.         IIC_SCL=0;
    7 b  q3 N- J% B4 p
79. }
    
80. 
    
81. //不产生ACK应答                    
    % F7 ^5 [+ i  E+ q, Z6 Y9 e+ L
82. void IIC_NAck(void)
    
83. {
    
84.         IIC_SCL=0;
    6 `: j& r4 a, Z! X( v2 \  _6 y
85.         SDA_OUT();
    8 u2 `# V; J: I' d4 h( b
86.         IIC_SDA=1;
    
87.         delay_us(2);
    , m% ]/ W. J2 @
88.         IIC_SCL=1;
    
89.         delay_us(2);
    9 C3 E# G% W" b# v8 @- X# `
90.         IIC_SCL=0;
    0 c0 p. n! a; R
91. }
    4 x/ c% A2 y7 B5 t0 \
92.                                                                               
    
93. //IIC发送一个字节
    1 ~" j1 d" ]+ z2 q
94. //返回从机有无应答
    
95. //1，有应答
    
96. //0，无应答                          
    + |0 i4 Y, d0 y$ V) ~
97. void IIC_Send_Byte(u8 txd)
    
98. {                        
    & L/ [( t$ b, w0 p! C2 u
99.     u8 t;   
    / T9 j. f* a1 G7 y# E+ G
100.         SDA_OUT();            
     3 g9 q' o5 {9 a8 L3 c" Q
101.     IIC_SCL=0;//拉低时钟开始数据传输
     0 t1 ^4 R3 r% Q$ A
102.     for(t=0;t<8;t++)
     
103.     {              
     % p5 j1 z1 R# M* y
104.         IIC_SDA=(txd&0x80)>>7;
     ) x9 j$ M8 _5 J8 V
105.         txd<<=1;           
     
106.                 delay_us(2);   //对TEA5767这三个延时都是必须的
     
107.                 IIC_SCL=1;
     7 h8 _4 X  k* C
108.                 delay_us(2);
     
109.                 IIC_SCL=0;        
     ! ^# E) m4 w6 Z" o) J2 M5 V
110.                 delay_us(2);
     
111.     }         
     + E3 f7 w1 z9 o3 Y* |
112. }
     % c9 c7 B) J+ r3 A! P5 }
113.             
     1 l: B+ Q" C* v. k1 s+ x/ E+ ?# R
114. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
     3 T3 v/ P) b; f' U4 @4 R
115. u8 IIC_Read_Byte(unsigned char ack)
     % k; @0 j3 H# g# H' _. T5 f' h# L
116. {
     ' E" n, X: s4 v, j1 l4 H
117.         unsigned char i,receive=0;
     9 \3 V' s* E; k
118.         SDA_IN();//SDA设置为输入
     ! {( P/ N) P+ a% e
119.     for(i=0;i<8;i++ )
     
120.         {
     + M8 A: d9 ?) n" [( y" l8 r
121.         IIC_SCL=0;
     * R' E! z8 Y2 D; ^' ^9 H
122.         delay_us(2);
     
123.                 IIC_SCL=1;
     
124.         receive<<=1;
     ' V. e: O* z7 j. C# |7 v4 H
125.         if(READ_SDA)receive++;   
     
126.                 delay_us(1);
     
127.     }                                         
     + _2 d+ K* Y1 ?8 u1 d
128.     if (!ack)
     1 n; e) L1 D/ ?7 \
129.         IIC_NAck();//发送nACK
     
130.     else
     
131.         IIC_Ack(); //发送ACK   
     
132.     return receive;
     8 d" S6 M9 _5 \9 b
133. }

复制代码

9 X) _, ^6 `& T* ~0 l! s8 R4 J! i8 s( F. U

1. IIC.h
   
2. 
   
3. #ifndef __MYIIC_H
   ( {! R, v# ^. q  s9 t
4. #define __MYIIC_H
   ( v# |/ `/ [1 a5 j# Y2 E* q% X: y
5. #include "sys.h"
   
6. 
   3 M% G. j8 D$ j$ e
7. //IO方向设置
   # Y, K$ U5 }# z* B! I4 T. d8 f9 r1 [6 k
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输出模式
   % a7 z9 Y  {6 z. \
10. //IO操作函数         
    7 U: V. j" U5 g* j% m! X- q
11. #define IIC_SCL    PBout(8) //SCL
    
12. #define IIC_SDA    PBout(9) //SDA         
    
13. #define READ_SDA   PBin(9)  //输入SDA
    
14. 
    " Y  C8 y, i3 l% A7 P4 F$ M! U
15. //IIC所有操作函数
    % e+ K7 w! H* L8 Q
16. void IIC_Init(void);                //初始化IIC的IO口                                 
    
17. void IIC_Start(void);                                //发送IIC开始信号
    ' E8 k8 ~6 |" ~: f4 O
18. void IIC_Stop(void);                                  //发送IIC停止信号
      G: C* Y0 ^  G  [6 `$ g2 C: S! T$ W
19. void IIC_Send_Byte(u8 txd);                        //IIC发送一个字节
    
20. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
    + |3 K' c/ A6 K. G% j
21. u8 IIC_Wait_Ack(void);                                 //IIC等待ACK信号
    
22. void IIC_Ack(void);                                        //IIC发送ACK信号
    + K7 g6 }: W7 O: f9 E( q
23. void IIC_NAck(void);                                //IIC不发送ACK信号
    * @4 @( f9 v7 W5 A) r5 p& B
24. 
    
25. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    5 i4 M8 B" L4 m+ V
26. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);         
    
27. 
    * T! L1 H. ^3 \0 D8 B0 W
28. #endif

复制代码

& K; e# F6 Y& d1 I9 R四、EEPROM(24C02）的使用
总容量是256（2K/8)个字节。接口：IIC
/ Y# i+ Y! N( J
芯片图:

8 W/ Q' ^/ M, c4 f
& G8 q; k" C  T6 N  |& Z这里的A0=A1=A2=0
& s( }( G. U- V. K3 N% n



8 k- Z: T! e9 j0 u
24C02读写字节时序

. _& I* ^/ Y. w5 o写：
' E! a) v( q) F0 I% S9 e* b2 l
" z8 k( C* N" E! i- j# m3 s

" y  g4 S/ `7 {) z" \: M: B读：

: {1 C' U- x: C3 d

) ~7 a) ?$ B2 K/ l8 H24C02的代码如下：

1. 24cxx.c:
   $ F3 {6 `) _- l7 L" N) p& S
2. #include "24cxx.h"
     T: N. I$ M# Y' ~# n9 p9 }
3. #include "delay.h"                                 
   # m! t/ k2 N( a  u9 Y  i
4. 
   6 a# y% d* G* E- k7 V8 d' w
5. //初始化IIC接口
   ; s* H9 s: |8 C2 }; i9 P2 D4 H
6. void AT24CXX_Init(void)
   8 F7 H) o4 x: `
7. {
   & L" [4 Z. \& G; ^8 j9 g% H  t
8.         IIC_Init();//IIC初始化
   5 @( t  N: `( C( V" j& n
9. }
   
10. //在AT24CXX指定地址读出一个数据
    % M- t2 z  k  ?0 Q- N4 i. m
11. //ReadAddr:开始读数的地址  
    
12. //返回值  :读到的数据
    ! T$ ^& g1 A( T) `% q3 Q
13. u8 AT24CXX_ReadOneByte(u16 ReadAddr)
    6 l, ~" j$ ]8 ]0 L; a  O
14. {                                 
    5 L7 f# ~- v8 F. N1 S" t! U% e# \
15.         u8 temp=0;                                                                                                                                                               
    : x$ k* `2 Y6 n& v4 Y
16.     IIC_Start();  
    , V% A4 K  v. p* v
17.         if(EE_TYPE>AT24C16)
    + J1 P8 X" M2 G1 ?1 \9 x* w# i
18.         {
    
19.                 IIC_Send_Byte(0XA0);           //发送写命令
    5 E" C0 s; y& K9 _: b2 V% j; A7 I
20.                 IIC_Wait_Ack();
    ! |5 `" E) B6 F" K( K! _# I; h
21.                 IIC_Send_Byte(ReadAddr>>8);//发送高地址            
    ! c; u' a* }+ B; j
22.         }else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据            
    
23.         IIC_Wait_Ack();
    
24.     IIC_Send_Byte(ReadAddr%256);   //发送低地址
    7 R2 X. c) ?" t5 \5 }
25.         IIC_Wait_Ack();            
    & p2 t  L$ C. I7 Z
26.         IIC_Start();                     
    & b3 x2 l" y4 U% Q+ q4 m
27.         IIC_Send_Byte(0XA1);           //进入接收模式                           
    
28.         IIC_Wait_Ack();         
    
29.     temp=IIC_Read_Byte(0);                  
    , p9 c* L- _& R; c% b
30.     IIC_Stop();//产生一个停止条件            
    . Z" i  f- A6 ]2 x
31.         return temp;
    
32. }
    0 x- J2 d+ \5 ^! ^+ v1 Z
33. //在AT24CXX指定地址写入一个数据
    
34. //WriteAddr  :写入数据的目的地址   
    3 w  h, T) D. C, X* O3 U4 R
35. //DataToWrite:要写入的数据
    9 C/ E+ K0 o4 O; w  z
36. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
    3 f5 V! m. \4 I
37. {                                                                                                                                                                                          
    ' t# c1 \* M8 t/ C# e* Z/ v) f
38.     IIC_Start();  
    
39.         if(EE_TYPE>AT24C16)
    / k$ l& O  n% K
40.         {
    / @! O0 O' e  R+ p9 r! d0 O) @1 z
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,写数据         
    . _0 |4 W) O5 V4 j4 g  ?
45.         IIC_Wait_Ack();           
    $ ~3 j% ~( c( f# H0 ^% U( a$ S
46.     IIC_Send_Byte(WriteAddr%256);   //发送低地址
    4 `4 b$ l: i7 i! ?
47.         IIC_Wait_Ack();                                                                                                               
    
48.         IIC_Send_Byte(DataToWrite);     //发送字节                                                           
    , p8 M1 `- u+ B. l( Z8 v7 w* Z
49.         IIC_Wait_Ack();                                 
    ; P5 {% u. O# K
50.     IIC_Stop();//产生一个停止条件
    
51.         delay_ms(10);         
    8 b# @3 z$ g1 u/ J* j
52. }
    " Y1 m1 E, f, u; N; z  i. y
53. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    $ d* Z/ O1 x4 h6 `
54. //该函数用于写入16bit或者32bit的数据.
    . P. x; K( E# E/ v, s- z, T- e
55. //WriteAddr  :开始写入的地址  
    
56. //DataToWrite:数据数组首地址
    
57. //Len        :要写入数据的长度2,4
    ) G& d0 Q1 u8 p
58. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
    
59. {         
    ( k, M* w( H7 w, ^$ i
60.         u8 t;
    
61.         for(t=0;t<Len;t++)
    ' O, G' }( b' o2 Q6 h2 j/ O7 w: y! m
62.         {
    " s2 ^: N! {* D7 K, K
63.                 AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    - G. w* Z! W5 J# ~6 s
64.         }                                                                                                   
    
65. }
    
66. 
    , M) j; A1 e+ r& \" k& E* b: |0 U
67. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    0 k  w3 E' _( O2 k2 b
68. //该函数用于读出16bit或者32bit的数据.
    $ ]6 q' d& P' y, j* a
69. //ReadAddr   :开始读出的地址
    % \  {$ c6 h2 x
70. //返回值     :数据
    / D5 _0 W! Z9 v
71. //Len        :要读出数据的长度2,4
    - U, t" l- _; C" e7 j1 v
72. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
    8 N' t0 E8 e, n( j% H; E6 F
73. {         
    
74.         u8 t;
    * m+ c1 D! n; }: V. e
75.         u32 temp=0;
    
76.         for(t=0;t<Len;t++)
    ( I9 N! q4 P/ P3 L; `, B
77.         {
    
78.                 temp<<=8;
    ! x# }, D: o8 I8 ]8 y3 I/ v  j2 a
79.                 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);                                             
    
80.         }
    
81.         return temp;                                                                                                   
    
82. }
    ' k8 K% }- G' M5 W
83. //检查AT24CXX是否正常
    / r  m# B6 N! b, J2 Q" L  j' _# {
84. //这里用了24XX的最后一个地址(255)来存储标志字.
    6 p) `; J. G2 W
85. //如果用其他24C系列,这个地址要修改
    7 S" h$ k9 F$ A! r
86. //返回1:检测失败
    8 T& f0 ]. U0 @
87. //返回0:检测成功
    
88. u8 AT24CXX_Check(void)
    - ~6 @9 ^3 l1 i: T: [  Q5 A
89. {
    1 Z6 {8 h$ ^- N8 V: a( i0 N
90.         u8 temp;
    
91.         temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX                           
    
92.         if(temp==0X55)return 0;                  
    
93.         else//排除第一次初始化的情况
    4 y0 l# J& i' Y
94.         {
    + h! y# l- O  F
95.                 AT24CXX_WriteOneByte(255,0X55);
    
96.             temp=AT24CXX_ReadOneByte(255);         
    
97.                 if(temp==0X55)return 0;
    
98.         }
    
99.         return 1;                                                                                          
    + z& I  @# _1 h% T' R; m4 ?+ n% a* n
100. }
     / O) ]  B! M" m& c$ {6 p) W
101. 
     
102. //在AT24CXX里面的指定地址开始读出指定个数的数据
     
103. //ReadAddr :开始读出的地址 对24c02为0~255
     & ]6 i9 V* F( M/ X" Z
104. //pBuffer  :数据数组首地址
     . ?% v" m* m% L, X/ M" G& Q) |
105. //NumToRead:要读出数据的个数
     0 e' u$ G) O3 k% P6 K
106. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
     . I; @1 d1 B( q2 I
107. {
       `) ^3 B' ~( H/ x$ L, v+ B
108.         while(NumToRead)
     * d/ y% I- l" U4 F, ^
109.         {
     9 Y% `2 k8 U( F
110.                 *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);        
     
111.                 NumToRead--;
     
112.         }
     
113. }  
     
114. //在AT24CXX里面的指定地址开始写入指定个数的数据
     ; D0 c3 `! J# y' |, q1 t' c5 Z* j+ ~
115. //WriteAddr :开始写入的地址 对24c02为0~255
     3 S% ~* q$ Q2 y4 P
116. //pBuffer   :数据数组首地址
     1 L1 ^# a: }1 j% g
117. //NumToWrite:要写入数据的个数
     
118. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
     5 \1 c& o- m: }: a0 z
119. {
     
120.         while(NumToWrite--)
     
121.         {
     9 D4 z3 M2 C0 s$ N$ M
122.                 AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
     : H/ X1 |. Q4 n& z, `& V
123.                 WriteAddr++;
     . F* x4 V8 @8 |4 c
124.                 pBuffer++;
     9 X% v+ X: |  c
125.         }
     8 X5 c3 y" A  P/ J0 \/ @% w
126. }

复制代码

1. 24cxx.h:
   2 u" L% y' h6 b( u( ~
2. #ifndef __24CXX_H
   
3. #define __24CXX_H
   
4. #include "myiic.h"   
   
5. 
   & b$ n% I) o- A# n
6. #define AT24C01                127
   
7. #define AT24C02                255
   
8. #define AT24C04                511
   
9. #define AT24C08                1023
   
10. #define AT24C16                2047
    3 H4 [8 ]! Z; G* y: \6 S% c
11. #define AT24C32                4095
    
12. #define AT24C64            8191
    & `8 m1 w  T" A# g2 X7 ^
13. #define AT24C128        16383
    0 z* g; P! w/ U) F6 o
14. #define AT24C256        32767  
    
15. //Mini STM32开发板使用的是24c02，所以定义EE_TYPE为AT24C02
    5 @* {5 |. H6 w/ Z! f
16. #define EE_TYPE AT24C02
    
17.                                           
    
18. u8 AT24CXX_ReadOneByte(u16 ReadAddr);                                                        //指定地址读取一个字节
    
19. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite);                //指定地址写入一个字节
    6 _& S/ r' w- v4 A6 _% P8 M
20. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len);//指定地址开始写入指定长度的数据
    & a. V. @; C9 P& e& }( `
21. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len);                                        //指定地址开始读取指定长度数据
    
22. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite);        //从指定地址开始写入指定长度的数据
    & V7 ]2 p& J* m# R& s2 `
23. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead);           //从指定地址开始读出指定长度的数据
    ) K5 v0 l& L: e9 `, `- i. A) [
24. 
    
25. u8 AT24CXX_Check(void);  //检查器件
    
26. void AT24CXX_Init(void); //初始化IIC
    ' _0 Q) p0 J) N* _( g
27. #endif
    ' @0 P/ X& J! o: a! w( |& n4 N# {
28. 
    
29. main.c:
    
30. #include "sys.h"
    8 J; m& R* Z: D% U6 I9 q
31. #include "delay.h"
    , }' u* p9 ?$ |1 G6 L
32. #include "usart.h"
    
33. #include "led.h"
    7 F) ~4 ~, L7 W6 a) ?. X
34. #include "lcd.h"
    
35. #include "24cxx.h"
    
36. #include "key.h"  
    
37. 
    
38. //要写入到24c02的字符串数组
    # x. z$ N! p, K  d3 ~& i
39. const u8 TEXT_Buffer[]={"Explorer STM32F4 IIC TEST"};
    
40. #define SIZE sizeof(TEXT_Buffer)         
    # V5 J5 }+ y. V0 t
41.         
    6 P. R: |7 ?/ N3 t. b
42. int main(void)
    0 d3 b) M8 j# h- Z- l9 w- E' z
43. {
    
44.         u8 key;
    
45.         u16 i=0;
    
46.         u8 datatemp[SIZE];        
    
47.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    8 U4 I) G) O" i* x' g* L/ z& |6 `
48.         delay_init(168);    //初始化延时函数
    
49.         uart_init(115200);        //初始化串口波特率为115200
    3 b$ ~$ o$ s' j* k+ N1 m! Q
50.         
    ) `8 u/ E  A) z6 l4 e. v0 r% n
51.         LED_Init();                                        //初始化LED
    
52.         KEY_Init();                                 //按键初始化  
    $ E% w7 u# y' I" Z8 ~
53.         AT24CXX_Init();                        //IIC初始化
    4 s+ t4 }# p! v" s& g! c: c; G
54.                         
    . {; o3 [( Q/ o) s
55.          while(AT24CXX_Check())//检测不到24c02
    , r5 t9 }7 M" B9 |7 G" X% {" f
56.         {
    
57.                 printf("24C02 Check Failed!");
    
58.                 delay_ms(500);
    
59.                 printf("Please Check!      ");
    
60.                 delay_ms(500);
    9 c! m" y6 w* n2 C, O& _& G# P
61.                 LED0=!LED0;//DS0闪烁
    + ]0 C# |$ g2 o1 W* ]
62.         }
    
63.         
      ^7 |& s1 y% B8 W
64.         while(1)
    ) ?* s) y2 F4 _5 X
65.         {
    
66.                 key=KEY_Scan(0);
    
67.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
    ! c# _! f6 P$ `
68.                 {
    + f, E9 D! @, R( c0 o
69.                         printf("Start Write 24C02....");   
    
70.                         AT24CXX_Write(0,(u8*)TEXT_Buffer,SIZE);
    3 I4 t$ s! H' J0 j0 P# l
71.                         printf("24C02 Write Finished!");  //提示传送完成
    
72.                 }
    
73.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    
74.                 {
    
75.                         printf("Start Read 24C02.... ");
    - U: o6 H$ Q1 h0 ^: i% j! m& A
76.                         AT24CXX_Read(0,datatemp,SIZE);
    2 I; j  c$ B' |3 j; y: m) l
77.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    
78.                         printf("%s\r\n ",datatemp);
    
79.                 }           
    5 D9 f, D+ W& `1 b) c) g! X
80.         }            
      B, d' u: e2 P$ m
81. }
    

复制代码

$ ~. Q- ?' f# ]; X8 W- k" W, d
2 z# e1 s( K; K/ a' S