一、IIC
IIC是什么？
/ o' Y! P' p' lIIC(Inter－Integrated Circuit)总线是一种由 PHILIPS 公司开发的两线式串行总线，用于连接微控制器及其外围设备。它是由数据线 SDA 和时钟 SCL 构成的串行总线，可发送和接收数据。在 CPU 与被控 IC 之间、 IC 与 IC 之间进行双向传送， 高速 IIC 总线一般可达 400kbps 以上。这种总线类型是由飞利浦半导体公司（后被NXP收购）在八十年代初设计出来的一种简单、双向、二线制、同步串行总线，主要是用来连接整体电路(ICS) ，IIC是一种多向控制总线，也就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实时数据传输的控制源。多主多从的通讯协议。所以 它是半双工通信方式。 关于通信方式，可以查阅我的另一篇博文：STM32串口实验，从入门到放弃。
7 m$ h* Y6 _  J/ n
) e: c0 H3 Z% p+ Y优点一：简单性和有效性。
1 S1 m+ Q& M) C
0 v+ J& ~( o$ `3 p! r; S" c  m由于接口直接在组件之上，因此IIC总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。总线的长度可高达25英尺，并且能够以10Kbps的最大传输速率支持40个组件。
7 D7 C  K7 g# W1 X  p: e2 z
优点二：多主控

% H: ?& ~9 Q+ O4 r, g! r, \其中任何能够进行发送和接收的设备都可以成为主总线。一个主控能够控制信号的传输和时钟频率。当然，在任何时间点上只能有一个主控。
. m0 O2 S/ p* [% [) ]& _! l
" t$ c+ ^/ z7 q) w4 H: ^
" g6 V9 q5 m& m
IIC串行总线有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL，其时钟信号是由主控器件产生。所有接到IIC总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上。对于并联在一条总线上的每个IC都有唯一的地址（这个在后面有用）。
5 g2 Q% Y5 c$ g/ [3 P& O5 A" W一般情况下，数据线SDA和时钟线SCL都是处于上拉电阻状态（在总线空闲状态时，这两根线一般被上面所接的上拉电阻拉高，保持着高电平）。
0 v% V4 p( O- e
IIC协议
. w1 K7 X& P1 S7 Q开始之前，我们先了解一下下面的部分：
( R- u5 ]) e2 P2 B$ ^
7 g, M6 z2 r, P$ w9 o, s% O( F0 y①空闲状态
% E9 l  E9 h2 J, `: n②开始信号
③停止信号
④应答信号
⑤数据有效性
* l1 R7 k6 _; w2 E. [⑥数据的传输

空闲状态
. B6 E" S/ y# Q
+ n) D- X3 z4 ~. N( q& F总线的空闲状态规定为：IIC总线的SDA和SCL两条信号线同时为高电平。此时的各个期间的输出及场效应均处于截至状态，即释放总线，由两条信号线各自将上拉电阻把电平拉高。

开始信号和停止信号
2 K5 Q! \5 E7 A& q/ d# m
开始信号：当SCL线是高电平时，SDA线从高电平向低电平跳变，开始传送数据。（注意：启动信号是一种电平跳变时序信号，而不是一个电平信号。）


7 O8 ]/ L( W" E" z3 K
停止信号：当SCL线是高电平时， SDA 由低电平向高电平跳变，结束传送数据。（注意：停止信号也是一种电平跳变时序信号，而不是一个电平信号。）
( U- g5 F$ p$ b
' I% V& S2 C( Q

应答信号（ACK）

发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。
, V' l: j7 I% f6 g0 h: L, h对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P。

$ B6 z' z+ `( r  v* }+ A7 e6 t
9 U7 B: m5 g. c
2 s3 ]) |9 L0 }1 U5 A5 f/ J( G数据有效性
. a6 c3 P: |; s9 H$ u9 R# C
0 B+ m9 b2 I: `, @/ r. rI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。
即：数据在SCL的上升沿到来之前就需准备好。并在在下降沿到来之前必须稳定。

0 Q3 b: {9 T1 l# p


; j- b! L) H0 n1 i/ p2 `数据传输
7 C' I. v# J- z1 H8 r# H在I2C总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。


0 b; U5 n% _$ G# X: ~- D  t
0 X7 J* m% v; R( @. x, ~% kIIC总线上的每一个设备都可以作为主设备或者从设备，而且每一个设备都会对应一个唯一的地址（地址通过物理接地或者拉高），主从设备之间就通过这个地址来确定与哪个器件进行通信，在通常的应用中，我们把CPU带I2C总线接口的模块作为主设备，把挂接在总线上的其他设备都作为从设备。
, ?& r0 A  v$ x( x; n0 \6 I2 l
也就是说，主设备在传输有效数据之前要先指定从设备的地址，地址指定的过程和上面数据传输的过程一样，只不过大多数从设备的地址是7位的，然后协议规定再给地址添加一个最低位用来表示接下来数据传输的方向，0表示主设备向从设备写数据，1表示主设备向从设备读数据。

% \: j% V5 M/ O. C% e  y2 l  s
# e9 ^# W! S  J4 s/ f7 k$ L
( _8 [- H* h  D  E9 X
拿24C02举例



) v, p* [( ^2 ~+ U; w2 }A0，A1，A2为器件地址线，WP为写保护引脚，SCL，SDA为二线串行接口，符合I2C总线协议。
1 `$ c9 g# G1 E- J1 {* A/ H& _


* x8 j! I# e; L2 `) N' V& M* h
6 W1 P( |! ?& ?; T+ j4 w
写字节的时序：

: K4 R' g, S, n
: m4 q4 g" s7 d: ^. `; @

, p2 m: R, m# S/ D& P! T读字节的时序：


  r: t! i1 }! I3 s& Q
7 _5 n+ w! O& [
关于延时时间
! p9 _  u$ u. D' S) _
/ i6 l* @: x" M  N

二、代码部分
IIC底层代码分析
" h9 E4 h; B% T; J9 p- z代码如下：
, O/ Z1 ^# g% u  o$ {7 A& o打开 IIC 实验工程，我们可以看到工程中加入了两个源文件分别是 myiic.c 和 24cxx.c，myiic.c 文件存放 iic 驱动代码， 24cxx.c 文件存放 24C02 驱动代码：
打开 myiic.c 文件，代码如下：
  K& r' C9 d8 g9 z" r# L. l/ v

1. //复制到keil软件中注释恢复正常
   
2. #include "myiic.h"
   & F6 D- g8 a* `* a& c+ e, y
3. #include "delay.h"
   9 [( B9 H3 V4 _( x. s
4. 
   
5. //³õʼ»¯IIC
   6 I! e2 W3 F0 w
6. void IIC_Init(void)
   
7. {                                             
   % c- \% T: G' _: T# s$ T
8.         GPIO_InitTypeDef GPIO_InitStructure;
   ( ?" @, R, C3 i. R- U. l0 T" F
9.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );        //ʹÄÜGPIOBʱÖÓ
   
10.            
    7 P/ C5 v! X: K% u* u5 ^$ `
11.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
    
12.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //ÍÆÍìÊä³ö
    
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
14.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
15.         GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);         //PB6,PB7 Êä³ö¸ß
    ; B- C$ }, K) t
16. }
    
17. //²úÉúIICÆðʼÐźÅ
    
18. void IIC_Start(void)
    
19. {
    ' e( B$ F: M6 [& j7 [. A
20.         SDA_OUT();     //sdaÏßÊä³ö
    . h6 {4 r7 ~6 ~
21.         IIC_SDA=1;                    
    0 k% o' |" `+ w
22.         IIC_SCL=1;
    0 J) K( r8 T) j0 t/ a
23.         delay_us(4);
    
24.          IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    2 W2 ^) Z( w# r3 ?
25.         delay_us(4);
    
26.         IIC_SCL=0;//ǯסI2C×ÜÏߣ¬×¼±¸·¢ËÍ»ò½ÓÊÕÊý¾Ý
    ) G6 @4 w( Z' o& m+ Y% _7 R
27. }         
    " _# q1 E, |- F) a
28. //²úÉúIICÍ£Ö¹ÐźÅ
    # o- l6 |9 e7 q% I6 Y. N- h
29. void IIC_Stop(void)
    / K6 F. s0 A+ o. A1 K2 j
30. {
    
31.         SDA_OUT();//sdaÏßÊä³ö
    : G  q1 C  B2 d0 V# d1 g
32.         IIC_SCL=0;
    0 F! x- ~# k  ]- V6 \
33.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
34.          delay_us(4);
    / v+ {, l' P! {! @" X
35.         IIC_SCL=1;
    
36.         IIC_SDA=1;//·¢ËÍI2C×ÜÏß½áÊøÐźÅ
    
37.         delay_us(4);                                                                  
    ' l. N. o7 D( D, L* [
38. }
    
39. //µÈ´ýÓ¦´ðÐźŵ½À´
      ?4 u' l4 w8 q) f
40. //·µ»ØÖµ£º1£¬½ÓÊÕÓ¦´ðʧ°Ü
      y" x) G2 b8 H* C4 [  W0 L) C
41. //        0£¬½ÓÊÕÓ¦´ð³É¹¦
    
42. u8 IIC_Wait_Ack(void)
    5 T/ V3 O0 p! B) Q# A
43. {
    
44.         u8 ucErrTime=0;
    0 V( A" ^( j; N
45.         SDA_IN();      //SDAÉèÖÃΪÊäÈë  
    1 R# }# K& i$ Z% T
46.         IIC_SDA=1;delay_us(1);           
    
47.         IIC_SCL=1;delay_us(1);         
    
48.         while(READ_SDA)
    % g2 @8 {! Z1 q; l3 D7 `
49.         {
    
50.                 ucErrTime++;
    
51.                 if(ucErrTime>250)
    
52.                 {
    
53.                         IIC_Stop();
    
54.                         return 1;
    9 |% o  D6 d5 B! d
55.                 }
    " k* ^5 L% f& N
56.         }
    
57.         IIC_SCL=0;//ʱÖÓÊä³ö0            
    ( r# c7 r% u* V( m/ ^' S
58.         return 0;  
    
59. }
    8 _# v/ v7 z4 E, u6 [2 ]9 x
60. //²úÉúACKÓ¦´ð
    ! s) ?: U3 a3 U
61. void IIC_Ack(void)
    
62. {
    
63.         IIC_SCL=0;
    $ r( Q( z& j+ M+ {
64.         SDA_OUT();
    
65.         IIC_SDA=0;
    % D* N3 A  v5 z. b3 t8 g, o
66.         delay_us(2);
    
67.         IIC_SCL=1;
    & i/ M7 s) K8 L9 T
68.         delay_us(2);
    9 C4 c, t0 M0 a2 v1 k
69.         IIC_SCL=0;
    " b/ p$ ?# ], z$ H( V! e2 `
70. }
    8 R- c% v5 h) E0 I' j% c" Q
71. //²»²úÉúACKÓ¦´ð                    
    
72. void IIC_NAck(void)
    & R( s6 V; F/ S9 ]; j: R8 X" |2 H
73. {
    $ g" q9 j0 O7 d" Z& P% ~
74.         IIC_SCL=0;
    
75.         SDA_OUT();
    / n$ T, f' E4 h* |6 K& P
76.         IIC_SDA=1;
    ! j" v7 p9 `& F  p( Y1 E& g
77.         delay_us(2);
    
78.         IIC_SCL=1;
    
79.         delay_us(2);
    
80.         IIC_SCL=0;
    
81. }                                                                              
    # Y' c  Q1 F( H" m: G* e0 {8 P& m. M
82. //IIC·¢ËÍÒ»¸ö×Ö½Ú
    ) q' n& O: I! [7 {
83. //·µ»Ø´Ó»úÓÐÎÞÓ¦´ð
    
84. //1£¬ÓÐÓ¦´ð
    
85. //0£¬ÎÞÓ¦´ð                          
    # M& M, G- l, u, `0 f5 s0 x3 T
86. void IIC_Send_Byte(u8 txd)
    
87. {                        
    ! ]+ b) N8 y$ `4 \" g
88.     u8 t;   
    % n4 O1 f: T: n' G: s" i0 b
89.         SDA_OUT();            
    
90.     IIC_SCL=0;//À­µÍʱÖÓ¿ªÊ¼Êý¾Ý´«Êä
    
91.     for(t=0;t<8;t++)
    
92.     {              
    
93.         //IIC_SDA=(txd&0x80)>>7;
    
94.                 if((txd&0x80)>>7)
    
95.                         IIC_SDA=1;
    5 x! g/ g1 s4 {& z0 ?
96.                 else
    ) T$ |4 m- g( H/ Q) O
97.                         IIC_SDA=0;
    ; h6 y3 v$ |" V0 S
98.                 txd<<=1;           
    
99.                 delay_us(2);   //¶ÔTEA5767ÕâÈý¸öÑÓʱ¶¼ÊDZØÐëµÄ
    & p( [9 T! l- ]0 R5 K) R/ S
100.                 IIC_SCL=1;
     
101.                 delay_us(2);
       [' Y, Z% C7 J) S4 \
102.                 IIC_SCL=0;        
     ! B; l, I: L& o
103.                 delay_us(2);
     
104.     }         
     ( R7 W3 b0 H1 T& K; T* \$ i
105. }            
     8 {9 K  j6 H9 g) x0 ?
106. //¶Á1¸ö×Ö½Ú£¬ack=1ʱ£¬·¢ËÍACK£¬ack=0£¬·¢ËÍnACK   
     
107. u8 IIC_Read_Byte(unsigned char ack)
     
108. {
       @" F7 l' y9 s( U1 `/ Q
109.         unsigned char i,receive=0;
     
110.         SDA_IN();//SDAÉèÖÃΪÊäÈë
     8 s2 l( g6 d4 @# W6 s+ n, \+ L" l
111.     for(i=0;i<8;i++ )
     
112.         {
     $ k, t) h9 E7 `/ }8 R% h0 _  j
113.         IIC_SCL=0;
     3 V; c+ D) R+ t5 V8 {
114.         delay_us(2);
     , X, B7 f$ s# a. y/ a- Z+ A. \) D
115.                 IIC_SCL=1;
     
116.         receive<<=1;
     
117.         if(READ_SDA)receive++;   
     3 q% z) R! C( g, j/ V
118.                 delay_us(1);
     - o5 C/ @9 A( T* W& |3 E; f- X
119.     }                                         
     5 D! P  Z  U. a. f; p
120.     if (!ack)
     
121.         IIC_NAck();//·¢ËÍnACK
     
122.     else
     7 `; t& Q- D/ R. s0 C4 y9 V
123.         IIC_Ack(); //·¢ËÍACK   
     
124.     return receive;
     
125. }

复制代码

该部分为 IIC 驱动代码，实现包括 IIC 的初始化（IO 口）、 IIC 开始、 IIC 结束、 ACK、 IIC读写等功能，在其他函数里面，只需要调用相关的 IIC 函数就可以和外部 IIC 器件通信了，这里并不局限于 24C02，该段代码可以用在任何 IIC 设备上。
接下来我们看看 24cxx.c 文件代码：
8 z9 ~% d- g! D

1. #include "24cxx.h"
   
2. #include "delay.h"
   ) \% ]. F/ w' L" ]; N  p) U) k
3. 
   4 R  O5 \7 d+ r# Y
4. //³õʼ»¯IIC½Ó¿Ú
   ; ]  k  B" T' [& _- y- f$ B
5. void AT24CXX_Init(void)
   
6. {
   * b- m2 m0 K$ \
7.         IIC_Init();
   * q3 ^) ^# |: X$ Z! B( y: @' o
8. }
   
9. //ÔÚAT24CXXÖ¸¶¨µØÖ·¶Á³öÒ»¸öÊý¾Ý
   
10. //ReadAddr:¿ªÊ¼¶ÁÊýµÄµØÖ·  
    
11. //·µ»ØÖµ  :¶Áµ½µÄÊý¾Ý
    $ T6 ]* m: n8 n0 S; G2 |* n- n
12. u8 AT24CXX_ReadOneByte(u16 ReadAddr)
    
13. {                                 
    1 Y9 w9 J! r, u7 j% h# m
14.         u8 temp=0;                                                                                                                                                               
    
15.     IIC_Start();  
    9 e* I2 f, n1 ^. a3 w
16.         if(EE_TYPE>AT24C16)
    
17.         {
    / Y, t) _* \$ d$ _; y
18.                 IIC_Send_Byte(0XA0);           //·¢ËÍдÃüÁî
    7 q1 i$ X+ F6 [' {% g
19.                 IIC_Wait_Ack();
    
20.                 IIC_Send_Byte(ReadAddr>>8);//·¢Ë͸ߵØÖ·
    
21.                 IIC_Wait_Ack();                 
    
22.         }else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1));   //·¢ËÍÆ÷¼þµØÖ·0XA0,дÊý¾Ý         
    / p7 k. O5 ?! @
23. 
    . |* t/ c; m2 O% ~% D
24.         IIC_Wait_Ack();
    
25.     IIC_Send_Byte(ReadAddr%256);   //·¢Ë͵͵ØÖ·
    
26.         IIC_Wait_Ack();            
    % H' \1 P! E7 q+ W: F7 m4 y4 P) ^
27.         IIC_Start();                     
    : ^- R) J" j  A9 x& D1 q
28.         IIC_Send_Byte(0XA1);           //½øÈë½ÓÊÕģʽ                           
    4 |1 R* l: s8 n$ Z+ B( u* }
29.         IIC_Wait_Ack();         
    ! r6 d. c( D, f& t( Y. ^0 N
30.     temp=IIC_Read_Byte(0);                  
    " ^$ s, V# t0 ]& o' q- W1 L
31.     IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ            
    $ T  Y, k$ x  R5 a- ]6 \% d
32.         return temp;
    2 N. J7 V3 r4 ~, G6 Z+ D
33. }
    / g6 ]# D" Z- P3 e4 X+ A0 c
34. //ÔÚAT24CXXÖ¸¶¨µØַдÈëÒ»¸öÊý¾Ý
    
35. //WriteAddr  :дÈëÊý¾ÝµÄÄ¿µÄµØÖ·   
    
36. //DataToWrite:ҪдÈëµÄÊý¾Ý
    
37. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
    2 H4 N, p( j6 B( {, B3 M) T9 C
38. {                                                                                                                                                                                          
    ) J: ?0 ^- {0 ]4 Q5 v* e" K1 m
39.     IIC_Start();  
    
40.         if(EE_TYPE>AT24C16)
    ' j+ y1 b* Y1 ~: x
41.         {
    
42.                 IIC_Send_Byte(0XA0);            //·¢ËÍдÃüÁî
    - k- ?- F& x, d( @$ j" C; m
43.                 IIC_Wait_Ack();
    - q$ \6 a3 |4 x- T5 q+ r, q
44.                 IIC_Send_Byte(WriteAddr>>8);//·¢Ë͸ߵØÖ·
    , h: M% W( k% g! d0 L
45.          }else
    
46.         {
    
47.                 IIC_Send_Byte(0XA0+((WriteAddr/256)<<1));   //·¢ËÍÆ÷¼þµØÖ·0XA0,дÊý¾Ý
    & Z, W- ]; ~4 D) G
48.         }         
    , y& m8 C% H( F& [$ v
49.         IIC_Wait_Ack();           
    9 f' b! q: g2 q, q( |3 Z
50.     IIC_Send_Byte(WriteAddr%256);   //·¢Ë͵͵ØÖ·
    
51.         IIC_Wait_Ack();                                                                                                               
    
52.         IIC_Send_Byte(DataToWrite);     //·¢ËÍ×Ö½Ú                                                           
    
53.         IIC_Wait_Ack();                                 
    
54.     IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ
    8 D0 r7 M  \) M
55.         delay_ms(10);         
    3 I% m- G' ^# N0 i: `
56. }
    
57. //ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼Ð´È볤¶ÈΪLenµÄÊý¾Ý
    
58. //¸Ãº¯ÊýÓÃÓÚдÈë16bit»òÕß32bitµÄÊý¾Ý.
    8 G( c7 Q- \3 W: r0 A& [: a
59. //WriteAddr  :¿ªÊ¼Ð´ÈëµÄµØÖ·  
    & h7 }. @5 x! T8 _- _+ `. u
60. //DataToWrite:Êý¾ÝÊý×éÊ×µØÖ·
    0 @$ W& M6 n1 J8 b  K
61. //Len        :ҪдÈëÊý¾ÝµÄ³¤¶È2,4
    
62. void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
    7 T; j2 h6 y+ v  F
63. {         
    
64.         u8 t;
    & {/ _9 i. h5 K* h
65.         for(t=0;t<Len;t++)
    5 S& t2 s/ v) Y) r! z2 k: j
66.         {
      v4 p1 }( i5 G7 p$ A: C
67.                 AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    
68.         }                                                                                                   
    
69. }
    
70. 
    
71. //ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼¶Á³ö³¤¶ÈΪLenµÄÊý¾Ý
    : x$ {' ]  Q: C2 I
72. //¸Ãº¯ÊýÓÃÓÚ¶Á³ö16bit»òÕß32bitµÄÊý¾Ý.
    
73. //ReadAddr   :¿ªÊ¼¶Á³öµÄµØÖ·
    
74. //·µ»ØÖµ     :Êý¾Ý
    
75. //Len        :Òª¶Á³öÊý¾ÝµÄ³¤¶È2,4
    * |$ n" b/ J  @; m9 G( T9 Y3 ^
76. u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
    
77. {         
    
78.         u8 t;
    
79.         u32 temp=0;
    - l3 F' L+ Q! L9 {9 ^
80.         for(t=0;t<Len;t++)
    
81.         {
    5 z7 a' A6 s$ m1 a4 I
82.                 temp<<=8;
    # D3 {' m0 T, j# _% Y
83.                 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);                                             
    + x2 L7 I- }' M0 Z5 g
84.         }
    
85.         return temp;                                                                                                   
    
86. }
    
87. //¼ì²éAT24CXXÊÇ·ñÕý³£
    % C/ p! X# z; @* x" M2 V3 P
88. //ÕâÀïÓÃÁË24XXµÄ×îºóÒ»¸öµØÖ·(255)À´´æ´¢±êÖ¾×Ö.
    
89. //Èç¹ûÓÃÆäËû24CϵÁÐ,Õâ¸öµØÖ·ÒªÐÞ¸Ä
    
90. //·µ»Ø1:¼ì²âʧ°Ü
    * v6 `" w& C" R, J6 [$ W
91. //·µ»Ø0:¼ì²â³É¹¦
    6 C* b) Y! ^" ^9 |- \( |
92. u8 AT24CXX_Check(void)
    4 T6 E/ h5 d& u; l8 A0 O  t
93. {
    - p' \4 l0 b/ B' m9 w% ~
94.         u8 temp;
    
95.         temp=AT24CXX_ReadOneByte(255);//±ÜÃâÿ´Î¿ª»ú¶¼Ð´AT24CXX                           
    
96.         if(temp==0X55)return 0;                  
    1 M' A0 |& D+ n' ]
97.         else//ÅųýµÚÒ»´Î³õʼ»¯µÄÇé¿ö
    
98.         {
    3 B/ r0 r4 s6 \
99.                 AT24CXX_WriteOneByte(255,0X55);
    ! _' j; `7 n1 Z+ n8 p
100.             temp=AT24CXX_ReadOneByte(255);         
     
101.                 if(temp==0X55)return 0;
     
102.         }
     4 ~. B8 }* O5 f1 w4 C
103.         return 1;                                                                                          
     
104. }
     
105. 
     - W. R& x0 A0 i2 w( G! {
106. //ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼¶Á³öÖ¸¶¨¸öÊýµÄÊý¾Ý
     
107. //ReadAddr :¿ªÊ¼¶Á³öµÄµØÖ· ¶Ô24c02Ϊ0~255
     " A7 ~1 N* h) M
108. //pBuffer  :Êý¾ÝÊý×éÊ×µØÖ·
     
109. //NumToRead:Òª¶Á³öÊý¾ÝµÄ¸öÊý
     2 k+ ?, P$ O, v- M: i3 x. @
110. void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
     + U# K" X" F1 p& N) V# f# ?5 z
111. {
     6 b4 z& W7 K4 ^
112.         while(NumToRead)
     " U* ?4 l9 s# ~3 }. I% m: N/ C* I4 S, Y
113.         {
     0 H! q" p, Q( D$ [  R* B+ }4 j
114.                 *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);        
     ' E5 N/ |) Y2 d5 b/ v! e" o
115.                 NumToRead--;
     $ X! f% U% @1 G, a( V0 Q6 f
116.         }
     
117. }  
     
118. //ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼Ð´ÈëÖ¸¶¨¸öÊýµÄÊý¾Ý
     + \- j# _8 G* J" u& `( E$ m
119. //WriteAddr :¿ªÊ¼Ð´ÈëµÄµØÖ· ¶Ô24c02Ϊ0~255
     1 E' P/ Z, z% U
120. //pBuffer   :Êý¾ÝÊý×éÊ×µØÖ·
     
121. //NumToWrite:ҪдÈëÊý¾ÝµÄ¸öÊý
     
122. void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
     5 i1 N2 ?# K; [: M% o9 {
123. {
     
124.         while(NumToWrite--)
     
125.         {
     
126.                 AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
     
127.                 WriteAddr++;
     % S1 r1 n+ `3 S% e
128.                 pBuffer++;
     
129.         }
     ; O( T5 Z' O1 Q! O- d9 B
130. }

复制代码