IIC总线是常用的串行总线，它只需要简单的两根线就可以实现数据的高速传输，同时还可以实现多机通信功能。
; o; ^' p' Z2 l1 X+ V
  在单片机中用的比较多的就是通过IIC总线操作EEPROM芯片。比较常用的EEPROM芯片就是24Cxx系列的芯片，主要用来存储系统运行过程中的关键数据。

/ V$ Q" f" V8 @5 e) C
& i$ r) k! g9 P7 a6 @4 M6 D0 ^8 p! ]
0 m6 p9 J2 a3 s要操作这个芯片的话，必须按照一定的时序去读写。这个时序通常被称为通信协议。24Cxx系列芯片通信协议如下。

I2 C 总线协议
' ~8 z# Z; c: ?0 A' e
) Q6 _+ Z4 d2 e) EI 2 C 总线协议定义如下：
9 Y2 w' @: P$ ~7 y( A* I2 x$ |只有在总线空闲时才允许启动数据传送
在数据传送过程中 当时钟线为高电平时 数据线必须保持稳定状态 不允许有跳变 时钟线为高电平时 数据线的任何电平变化将被看作总线的起始或停止信号。



7 K- ~$ v% u2 }  I3 }0 S起始信号
# V6 v1 h- u3 K, e' C6 k2 T时钟线保持高电平期间 数据线电平从高到低的跳变作为 I 2 C 总线的起始信号
" Q- x2 P* G' [* Y+ \* c  m7 Q! E% \
; h, S1 B; c6 d& e( M/ F8 {停止信号
$ k! `- |8 U+ p  p时钟线保持高电平期间 数据线电平从低到高的跳变作为 I 2 C 总线的停止信号

' _1 C! p3 p9 c0 @% G2 Y7 M
0 Y/ b$ l) h6 s8 K, h5 U2 [. n

& \( i- Z4 s  Q2 E* M% I- S

' a* X( |1 x) h, O; V4 j! ^4 O
  ]  {7 m  F8 o* }8 f" M0 q
. d0 z' M% a) g# S* E2 n/ ?) z
这里就使用最简单的几个通信时序起始、停止、读、写和应答时序。

( \( O8 N' N/ m为了IIC协议的通用性，将这几个协议封装为一个c文件，这样以后每个使用IIC协议的器件都能调用这个文件。

8 F( ~- `/ [- S# @, l" S2 x

1. //IIC产生起始信号
   $ V' T$ q0 A) G9 p0 m. j' H. I6 g
2. void IIC_Start(void)
   
3. {
   - Y4 X( P8 H. O2 `
4.     //START:when CLK is high,DATA change form high to low
   
5.     SDA_OUT();
   ; ~: j7 I- @3 d; Y/ w+ H% c( H
6.     IIC_SDA = 1;
   3 O( u& ?1 C6 g! [+ J
7.     IIC_SCL = 1;
   ( y9 \+ m) [( h* n
8.     delay_us(4);
   
9.     IIC_SDA = 0;
   4 F- p$ J' Z! Y; u( k+ m! W! a8 k) V
10.     delay_us(4);
    
11.     IIC_SCL = 0;
    
12. }
    
13. //产生停止信号
    
14. void IIC_Stop(void)
      \  p6 N( g3 i/ N' T
15. {
    $ t% y3 E9 \. Q
16.     //STOP:when CLK is high DATA change form low to high
    ( |, S) X' P$ ^* R3 }8 ^6 N
17.     SDA_OUT();
    
18.     IIC_SCL = 0;
    . U- c( i. D4 d; W! x: l
19.     IIC_SDA = 0;
      k0 j& @3 y4 N/ s% P% j7 T
20.     delay_us(4);
    
21.     IIC_SCL = 1;
    
22.     IIC_SDA = 1;
    
23.     delay_us(4);
    ( c% o" j! s0 f( @" ]0 Q* P
24. }
    : F9 s, v3 _' ?  B! H- O
25. //等待应答信号
    
26. //返回值: 1 应答失败
    . d' r: D  J! p/ n+ \
27. //        0 应答成功
    2 Y  h# R. D+ K) a7 A6 d$ [
28. u8 IIC_Wait_Ack(void)
    ! U% j' Q5 [% X1 l& z/ s
29. {
    
30.     u8 errTime = 0;
    / ~8 f8 L) y, l. N' S7 I4 t- q
31.     SDA_IN();
    # V& x; v& r! o0 E; N, B
32.     IIC_SDA = 1;
    
33.     delay_us(1);
    * M* M) r3 Q. ]0 I6 @
34.     IIC_SCL = 1;
    
35.     delay_us(1);
    
36.     while(READ_SDA)
    
37.     {
    
38.         errTime++;
    8 {' w6 o& s; t6 I/ I/ e/ c
39.         if(errTime > 250)
      P, v2 @1 w3 N0 _
40.         {
    : @, p2 B. I: m9 T) p& [6 ?+ }
41.             IIC_Stop();
    
42.             return 1;
    $ D, i/ x& J' w1 ]9 v8 z. J1 S
43.         }
      P/ o. q' {8 s
44.     }
    
45.     IIC_SCL = 0;
    , W% A$ J( ?8 n+ S" ^% w' l, @
46.     return 0;
    / k2 e: \1 |  b" r" T: ~
47. }
    
48. //产生ACK应答
    
49. void IIC_Ack(void)
    ; s9 V5 V6 q! E+ x
50. {
    
51.     IIC_SCL = 0;
      M3 _' b( l' I% ]9 W6 Z
52.     SDA_OUT();
    1 X; ~6 [8 n8 v3 L" }3 Z
53.     IIC_SDA = 0;
    & A2 w1 `- t  a* w% `% M
54.     delay_us(2);
    / g8 @8 W" |+ @/ a  @8 ?2 n! w+ C
55.     IIC_SCL = 1;
      ?, u- I" F& t# j0 V
56.     delay_us(2);
    
57.     IIC_SCL = 0;
    ) T& F; _  o( j# t
58. }
    & f) Z& p3 g& N3 }9 `
59. //不产生应答
    
60. void IIC_NAck(void)
    
61. {
    
62.     IIC_SCL = 0;
    : E$ F8 z! P$ c" a0 u
63.     SDA_OUT();
    
64.     IIC_SDA = 1;
    / f" V' J+ o/ e$ H
65.     delay_us(2);
    
66.     IIC_SCL = 1;
    
67.     delay_us(2);
    % v) B+ J0 w9 ~8 Z# m
68.     IIC_SCL = 0;
    
69. }
    ; \$ U$ M* K6 T! S; A& i! V# W* S
70. //IIC发送一个字节
      V# r4 y( H) F! a8 p7 A  R
71. void IIC_Send_Byte(u8 txd)
    
72. {
    
73.     u8 t;
    
74.     SDA_OUT();
    
75.     IIC_SCL = 0;
    7 G! Y  z  |% O( g
76.     for(t = 0; t < 8; t++)
    ( }" m1 _$ ^1 Q7 L7 e3 D" \1 f
77.     {
    8 L/ s9 \. y# ?- ^; }2 k
78.         if((txd & 0x80) >> 7)
    ' U$ c  Q% {0 X5 o- a' Q7 `. y4 z
79.             IIC_SDA = 1;
    
80.         else
    6 L/ o( _6 y4 D
81.             IIC_SDA = 0;
    ) W3 x# M4 \) c. T. ~
82.         txd <<= 1;
    2 I, u3 Y/ t( a4 S) K: \; A
83.         delay_us(2);
    ! A" V. N% \4 v; r
84.         IIC_SCL = 1;
    5 \  _  x0 s; H- r7 ~/ E. Q2 g
85.         delay_us(2);
    , S$ E; k# S) Q* Y
86.         IIC_SCL = 0;
    + i) }: K! u3 N0 A; \" p. f
87.         delay_us(2);
    
88.     }
      w  \/ K  i; S/ K" b! C. x
89. }
    4 Z2 G) K( ]+ w3 Y3 N# A
90. //读1个字节，ack=1时，发送ACK，ack=0，发送NACK
    , p5 f! \/ w+ I: ?% j
91. u8 IIC_Read_Byte(unsigned char ack)
    
92. {
    
93.     unsigned char i, receive = 0;
    ! K7 N" W; B+ E# n- b" P+ M
94.     SDA_IN();
    
95.     for(i = 0; i < 8; i++)
    
96.     {
    
97.         IIC_SCL = 0;
    9 G/ |% ?1 B  f  y1 L) S" i
98.         delay_us(2);
    
99.         IIC_SCL = 1;
    $ }) @1 d) ~3 n$ l/ G+ X
100.         receive <<= 1;
     
101.         if(READ_SDA)
     
102.             receive++;
     
103.         delay_us(1);
     $ t0 q& b  k0 h  v
104.     }
     
105.     if(!ack)
     
106.         IIC_NAck();
     
107.     else
     ; D# x4 g' X5 e& U( o2 A$ c- ]
108.         IIC_Ack();
     
109.     return receive;
     3 n- @$ g5 W5 G4 o* Y1 o/ M" m
110. }
     

复制代码

* F% e4 H* n1 J这里将最常用的几个信号封装为函数，当操作24Cxx芯片的时候，直接调用这几个函数。

1. #include "24Cxx.h"
   9 T# s" {; \6 z, u
2. #include "delay.h"
   
3. 
   
4. void AT24Cxx_Init(void)
   3 I+ f8 s, I& m4 G% v) T- E
5. {
   
6.     IIC_Init();
   , x4 h& N! G: B  W. ?
7. }
   
8. //在AT24CXX指定地址读出一个数据
   1 |! H/ }. Q* v2 M# B1 S
9. //ReadAddr:开始读数的地址
   
10. //返回值  :读到的数据
    0 ]. T5 L) L3 H) `, b
11. u8 AT24Cxx_ReadOneByte(u16 ReadAddr)
    * Q* h" I4 o, b: L5 S& g3 G( |' K( K; ~
12. {
    * E: r( o! t& N/ X; Q1 d* k. P
13.     u8 temp = 0;
    
14.     IIC_Start();
    3 N& _5 F$ _% |, T
15.     if(EE_TYPE > AT24C16)
    : E% w) f( D) o! B& ~
16.     {
    
17.         IIC_Send_Byte(0xA0);                        //发送写命令
    ( Q& q  Z$ n9 w+ g, L' |5 z" U
18.         IIC_Wait_Ack();
    ! K8 E$ k9 \" W" P5 g
19.         IIC_Send_Byte(ReadAddr >> 8);        //发送高地址
    
20.         IIC_Wait_Ack();
    9 Q: k) l- L. N6 @6 K. B
21.     }
    7 o9 x1 H/ T% R- t* K, D8 K
22.     else
    
23.         IIC_Send_Byte(0xA0 + ((ReadAddr / 256) << 1));        //发送器件地址0XA0,写数据
    6 W! A1 j8 }+ q" |4 A& b" A
24. 
    3 W) f8 W4 l9 q2 ~+ {2 k. L
25.     IIC_Wait_Ack();
    $ C* f6 K( q" h! c7 Z& K
26.     IIC_Send_Byte(ReadAddr % 256);                //发送低地址
    2 p" F) ^4 ]: M0 X" e. P
27.     IIC_Wait_Ack();
    
28.     IIC_Start();
    
29.     IIC_Send_Byte(0xA1);                                //进入接收模式
    $ [/ |& }3 K6 T
30.     IIC_Wait_Ack();
    
31.     temp = IIC_Read_Byte(0);
    ) G5 F3 ]( o$ I" y7 m9 g  E
32.     IIC_Stop();                                                        //产生一个停止条件
    
33.     return temp;
    9 f2 j& `6 W5 J, W4 S- }
34. }
    , R: _6 a  K  K8 @0 `/ E6 b! s
35. //在AT24CXX指定地址写入一个数据
    
36. //WriteAddr  :写入数据的目的地址
    
37. //DataToWrite:要写入的数据
    . ^3 s) f2 V, h9 C, ]
38. void AT24Cxx_WriteOneByte(u16 WriteAddr, u8 DataToWrite)
    
39. {
    
40.     IIC_Start();
    ( [! r7 ?4 W7 o9 i# N0 V% L
41.     if(EE_TYPE > AT24C16)
    9 y! T$ \8 Y& z
42.     {
    * l+ N% A* [/ g9 u
43.         IIC_Send_Byte(0xA0);                        //发送写命令
    
44.         IIC_Wait_Ack();
    5 \$ H  ?9 ?  d) J) i
45.         IIC_Send_Byte(WriteAddr >> 8);        //发送高地址
    
46.     }
    
47.     else
    . ~$ |3 J0 H7 Q; S7 z: f! C
48.         IIC_Send_Byte(0xA0 + ((WriteAddr / 256) << 1));        //发送器件地址0XA0,写数据
    " l% i9 [5 p1 r( V
49.     IIC_Wait_Ack();
    
50.     IIC_Send_Byte(WriteAddr % 256);
    ( J* e4 w  N" T  n
51.     IIC_Wait_Ack();
    
52.     IIC_Send_Byte(DataToWrite);
    
53.     IIC_Wait_Ack();
    : U/ Q* M+ X7 P6 V' H) q
54.     IIC_Stop();
      ~& K/ f) J7 q* j+ J% e' `) y
55.     delay_ms(10);
    
56. }
      s5 @% A" D8 L2 v
57. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    4 i8 T2 J$ ?: ?4 d
58. //该函数用于写入16bit或者32bit的数据.
    
59. //WriteAddr  :开始写入的地址
    
60. //DataToWrite:数据数组首地址
    5 d/ G, k4 n# z# w0 t
61. //Len        :要写入数据的长度2,4
    
62. void AT24Cxx_WriteLenByte(u16 WriteAddr, u32 DataToWrite, u8 Len)
    9 _9 K1 i$ Z% B5 }
63. {
    
64.     u8 t;
    
65.     for(t = 0; t < Len; t++)
    
66.     {
    
67.         AT24Cxx_WriteOneByte(WriteAddr + t, (DataToWrite >> (8 * t)) & 0xff);
    
68.     }
    
69. }
    0 ]6 z: w. M- R' A$ o" ^0 }9 U2 Y
70. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    # t( _# ]9 e! C5 z: c% o. _% J# l
71. //该函数用于读出16bit或者32bit的数据.
    . R- {0 N! d/ C; P7 f1 q, p9 k) P
72. //ReadAddr   :开始读出的地址
    
73. //返回值     :数据
    % B/ p0 C" J& O' k4 ~( d4 \
74. //Len        :要读出数据的长度2,4
    
75. u32 AT24Cxx_ReadLenByte(u16 ReadAddr, u8 Len)
    0 E! B, f: P! D! ~3 |5 B
76. {
    
77.     u8 t;
    2 M8 I/ a& R2 D) I2 |3 n# e. u# Z
78.     u32 temp = 0;
    7 k/ g2 e* J/ P& p
79.     for(t = 0; t < Len; t++)
    # \6 L& A$ j( A& x+ _
80.     {
    8 Y$ ?! e9 b' O; f1 g+ ]0 s
81.         temp <<= 8;
    5 \7 K- x" G0 j0 [4 \; Q* r
82.         temp += AT24Cxx_ReadOneByte(ReadAddr + Len - t - 1);
    8 V/ M: l1 u8 K8 i, z
83.     }
    
84.     return temp;
    
85. }
    % E% J2 S' K, ]+ G, B
86. //检查AT24CXX是否正常
    + y7 i; C! E; Z2 t/ |5 x/ Q
87. //这里用了24XX的最后一个地址(255)来存储标志字.
    " l" _8 \0 Y! E+ r9 P
88. //如果用其他24C系列,这个地址要修改
    , ^5 U. c9 n; o; H9 k- |
89. //返回1:检测失败
    
90. //返回0:检测成功
    
91. u8 AT24Cxx_Check(void)
    % ~& r- E8 `; _
92. {
    9 p. _  l. ?$ [: u# S
93.     u8 temp;
    3 O- D; A- O5 a% b& P0 _
94.     temp = AT24Cxx_ReadOneByte(255);
    
95.     if(temp == 0x55)
    + p; c/ G% `9 ?9 ~3 e* N2 R; F
96.         return 0;
    
97.     else
    7 q/ F: ~' P6 x7 g  D* @, _0 T' Q
98.     {
    
99.         AT24Cxx_WriteOneByte(1023, 0x55);
    
100.         temp = AT24Cxx_ReadOneByte(255);
     : K4 G- o4 y  @4 X! p
101.         if(temp == 0x55)
     ' S: W2 M6 ]* T7 Q
102.             return 0;
     ' I! F+ K2 F- p6 B& r
103.     }
     5 t6 {: X% K! U3 N3 H
104.     return 1;
     0 d, V/ H6 s* a" y: J- F
105. }
     
106. 
     # N7 `! x/ b1 S# |$ A$ ~# s
107. //在AT24CXX里面的指定地址开始读出指定个数的数据
     
108. //ReadAddr :开始读出的地址 对24c02为0~255
     - Q1 F& B8 s! a" c3 h
109. //pBuffer  :数据数组首地址
     - E, l( U6 h7 G2 k* D) r
110. //NumToRead:要读出数据的个数
     
111. void AT24Cxx_Read(u16 ReadAddr, u8 *pBuffer, u16 NumToRead)
     8 e9 e/ Y$ e' @7 u' b! N
112. {
     
113.     while(NumToRead)
     : m9 d  ~$ r' F3 R$ u4 x
114.     {
     0 b  _+ X! Q! a1 ~
115.         *pBuffer++ = AT24Cxx_ReadOneByte(ReadAddr++);
     
116.         NumToRead--;
     
117.     }
     
118. }
     
119. //在AT24CXX里面的指定地址开始写入指定个数的数据
     
120. //WriteAddr :开始写入的地址 对24c02为0~255
     / j9 ~& m+ w( |
121. //pBuffer   :数据数组首地址
     - e6 D# O( k4 q
122. //NumToWrite:要写入数据的个数
     
123. void AT24Cxx_Write(u16 WriteAddr, u8 *pBuffer, u16 NumToWrite)
     
124. {
     
125.     while(NumToWrite--)
     
126.     {
     2 G. |! O, d( ^/ w& N4 M" ], W
127.         AT24Cxx_WriteOneByte(WriteAddr, *pBuffer);
     
128.         WriteAddr++;
     ; c1 f; A4 G  x4 A
129.         pBuffer++;
       E, V! v, E5 J  ^1 g
130.     }
     : ?% d. Y# u& a1 O8 i, h
131. }

复制代码

9 j6 h- x4 I% p. [9 t1 H# D* b这里就是对具体的芯片操作函数，在主函数中通过这几个函数就可读写EEPROM存储芯片的内容了。
+ i/ q; W1 }3 {; D$ {& y4 G
1 V, L. M5 Y# h. ]  w. z) U

1. int main(void)
   % O6 x" n. [( A8 r- Y$ M
2. {
   ' x! T3 b0 e6 Y$ V6 G& i7 L* s: E
3. 
     d& M# P. ^) ~) C' E5 T$ f
4.     u8 key;
   & d5 u: s6 p/ I1 M" n
5.     u16 i = 0, j = 0;
   
6.     u8 datatemp[SIZE];
   : n/ k1 ]8 D+ F" H
7. 
   
8.     delay_init();
   ; u/ S, p5 e  }3 c! X' W
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     uart_init(115200);
    . E: O8 {0 O8 P% s' ?4 j
11.     LED_Init();
    
12.     KEY_Init();
    
13. 
    & d4 m2 j% J. i- l
14.     AT24Cxx_Init();
    5 {- E1 [: x' X$ T5 N$ Y
15. 
    + e0 `% s1 |" H* o0 q% ]
16.     printf("IIC test!!!\r\n");
    
17.     while(AT24Cxx_Check())
    
18.     {
    - Y" [6 }; I8 R+ N2 c' m: T  {& |$ e
19.         printf("The chip is not detected, please check whether the hardware connection is normal!!!\r\n");
    
20.         delay_ms(300);
    " r4 R' I# n( x& b: Z! X; |
21.         LED1 = !LED1;
    
22.     }
    ( e* y9 ^0 l5 _3 L- i; L
23. 
    ' |5 \, v4 {, ]; H9 a# @/ D7 a' z
24.     while(1)
    ! C* J  L$ o% b+ p0 o1 j
25.     {
    % C% B) h7 b4 b/ ^" S" a+ |$ d
26. 
    
27.         key = KEY_Sacn(0);
    
28.         if(key == WKUP_PRES)
    
29.         {
    8 I* O: q. C' \' M- R/ I9 f( i
30.             printf("\r\nStart Write 24C02....\r\n");
    . b: ~$ v* x* v! k; Z
31.             AT24Cxx_Write(0, (u8 *)TEXT_Buffer, SIZE);
    / e" l. X$ g& d( x$ a
32.             printf("24C02 Write Finished!\r\n");
    
33.         }
    ! s$ I4 l$ V" o* H
34.         else if(key == KEY1_PRES)
    8 V# u7 d9 [8 q+ X* Y
35.         {
    & J# C9 |8 H0 |. a6 x; j
36.             printf("\r\nStart Read 24C02....\r\n");
    $ J8 A. C4 S6 J1 J% H5 y& W) G
37.             AT24Cxx_Read(0, datatemp, SIZE);
    
38.             printf("The Data Readed Is:  ");
    
39.             for(j = 0; j < SIZE; j++)
    2 u, f/ q, o: i  B: Z3 u: J' \
40.             {
    6 q$ P7 N) ?" n$ G
41.                 printf("%c", datatemp[j]);
      ~4 z$ D# G; }1 M9 e% W$ x* b/ r2 o
42.             }
    # P) g6 R! }3 _- f1 ~: Y% n
43.         }
    6 C2 I- T  I, k! N
44. 
    # d/ D* ?' x. ?7 T* Z7 I
45.         i++;
    * p: U1 L7 ~6 \# ~, K# c
46.         if(i == 20)
    : ~/ r9 s; f, F5 Q
47.         {
    9 i* z9 D& Z( I( \/ Z
48.             i = 0;
    % h& j2 o9 r' W+ ^
49.             LED0 = !LED0;
      g! `. c. U1 ]& |
50.         }
    
51.         delay_ms(5);
    
52.     }
    2 @4 i( H, ?5 J8 v, N
53. }

复制代码

5 ^" `: y  @( _/ ^1 K9 m0 S" f( Q7 U: l这里通过按键来测试存储芯片，一个按键按下后向芯片内写入数据，另一个按键按下后从芯片中读取刚才写入的内容。

2 o- j$ I0 N; ]3 A4 \# O& ?. @