IIC总线是常用的串行总线，它只需要简单的两根线就可以实现数据的高速传输，同时还可以实现多机通信功能。

  在单片机中用的比较多的就是通过IIC总线操作EEPROM芯片。比较常用的EEPROM芯片就是24Cxx系列的芯片，主要用来存储系统运行过程中的关键数据。

1 }% |9 l( l; }$ X

要操作这个芯片的话，必须按照一定的时序去读写。这个时序通常被称为通信协议。24Cxx系列芯片通信协议如下。

# z7 m5 a; t; M$ N" u1 e8 e0 G, EI2 C 总线协议
' q) B4 W7 I8 u+ e% @2 o, R9 W- q
& c% }0 I+ }6 C* d* b; M. L; p% XI 2 C 总线协议定义如下：
  p% j* s2 D1 F$ Z$ y8 a* @只有在总线空闲时才允许启动数据传送
在数据传送过程中 当时钟线为高电平时 数据线必须保持稳定状态 不允许有跳变 时钟线为高电平时 数据线的任何电平变化将被看作总线的起始或停止信号。



起始信号
时钟线保持高电平期间 数据线电平从高到低的跳变作为 I 2 C 总线的起始信号
: W: U! k+ l* K, d& Z0 p
# q1 S7 E% z' J* f1 c' E) [停止信号
时钟线保持高电平期间 数据线电平从低到高的跳变作为 I 2 C 总线的停止信号

7 \$ ?# J, {) A( Z& J& c
. x+ L4 ?" h+ K1 X1 x, q
) @+ ^0 I0 z$ B8 D% m; x
, v, M2 e* g8 I0 q. i& f4 Y) ~
+ H* d) e4 P3 ?( @+ V
- s" k% w( [( q2 I2 G

% C: m$ J+ L# u7 _+ O( w/ f
: G. V9 l! {  |这里就使用最简单的几个通信时序起始、停止、读、写和应答时序。
  U3 C8 P& B- l; g
为了IIC协议的通用性，将这几个协议封装为一个c文件，这样以后每个使用IIC协议的器件都能调用这个文件。

1. //IIC产生起始信号
   
2. void IIC_Start(void)
   / I% O# M  A+ q3 ?: {( ^: L
3. {
   1 I6 d& J' I& v& j7 T. \% e- K! z
4.     //START:when CLK is high,DATA change form high to low
   
5.     SDA_OUT();
   
6.     IIC_SDA = 1;
   2 P: x( Q/ N2 ^1 u
7.     IIC_SCL = 1;
   
8.     delay_us(4);
   7 S5 B. N% G/ \% g& h: M
9.     IIC_SDA = 0;
   ; u' b. B$ u9 x( `
10.     delay_us(4);
    # u( s2 {1 C# s, p
11.     IIC_SCL = 0;
    
12. }
    ) m6 \* |1 {4 H- F% W' h
13. //产生停止信号
    : u: S3 w* N+ s' J4 i* N) N
14. void IIC_Stop(void)
    
15. {
    ) c) X) |2 b$ j- r1 U& W
16.     //STOP:when CLK is high DATA change form low to high
    8 _: T; m' T" w' G! G( D& b6 o. |
17.     SDA_OUT();
    
18.     IIC_SCL = 0;
    
19.     IIC_SDA = 0;
    
20.     delay_us(4);
    
21.     IIC_SCL = 1;
    9 s/ k5 \8 I  E% \" c3 U
22.     IIC_SDA = 1;
    6 H; K" Z9 o+ b  d- _" B& ~
23.     delay_us(4);
    % c$ O# Z; a, Y2 h4 s5 V
24. }
    
25. //等待应答信号
    1 y2 e: K( q' a( v/ U- d  Q6 C
26. //返回值: 1 应答失败
    : \9 c  E1 o, ?
27. //        0 应答成功
    
28. u8 IIC_Wait_Ack(void)
    
29. {
    
30.     u8 errTime = 0;
    5 l& P& R+ A& @( |9 x
31.     SDA_IN();
    
32.     IIC_SDA = 1;
    / }! r, \% w& G) L; M
33.     delay_us(1);
    4 @" ?" l& G1 N1 L$ d" E
34.     IIC_SCL = 1;
    
35.     delay_us(1);
    
36.     while(READ_SDA)
    
37.     {
    
38.         errTime++;
    
39.         if(errTime > 250)
    9 s* l! o1 z! \* q, i! B* W
40.         {
    
41.             IIC_Stop();
    
42.             return 1;
    
43.         }
    
44.     }
    
45.     IIC_SCL = 0;
    
46.     return 0;
    
47. }
    & J  S) A: _1 C& p
48. //产生ACK应答
    
49. void IIC_Ack(void)
    5 }% I! @, @$ Y& S( r# z" L
50. {
    
51.     IIC_SCL = 0;
    - P1 ]8 o9 M* B' v
52.     SDA_OUT();
    
53.     IIC_SDA = 0;
    $ Z& y- M5 D$ v' N' X# m) _
54.     delay_us(2);
    
55.     IIC_SCL = 1;
    
56.     delay_us(2);
    6 b; W+ o( ?5 v+ y  f8 u
57.     IIC_SCL = 0;
    
58. }
    
59. //不产生应答
    
60. void IIC_NAck(void)
    - D8 X/ n  L& }; s
61. {
    * J: w$ ^0 e1 [, a/ j0 p
62.     IIC_SCL = 0;
    - \6 k6 j- O2 T3 g/ p5 x! S* h! H
63.     SDA_OUT();
    
64.     IIC_SDA = 1;
    
65.     delay_us(2);
    7 f, `1 ?. c( C1 N
66.     IIC_SCL = 1;
    
67.     delay_us(2);
    
68.     IIC_SCL = 0;
    
69. }
    ; r7 x/ Q4 z* o! j6 \0 V2 f
70. //IIC发送一个字节
    
71. void IIC_Send_Byte(u8 txd)
    1 S& x4 C! e  t9 _
72. {
    6 o  b! u0 G9 N4 @
73.     u8 t;
    
74.     SDA_OUT();
    8 g/ n% |; T' d% O
75.     IIC_SCL = 0;
    ; Z+ W! Z/ O! @
76.     for(t = 0; t < 8; t++)
    9 k! l" _3 m6 q
77.     {
    
78.         if((txd & 0x80) >> 7)
    
79.             IIC_SDA = 1;
    
80.         else
    / a6 W7 G1 o9 g1 i% ^7 |
81.             IIC_SDA = 0;
    / Q/ Z$ c# ~3 f1 `
82.         txd <<= 1;
    # g* Y  `/ f! Z0 K; [
83.         delay_us(2);
    + ?2 k- t% p7 A6 U' A/ G# t
84.         IIC_SCL = 1;
    
85.         delay_us(2);
    
86.         IIC_SCL = 0;
    
87.         delay_us(2);
    
88.     }
    
89. }
    
90. //读1个字节，ack=1时，发送ACK，ack=0，发送NACK
    0 {9 `* V+ N4 x: t, F! u! L( c
91. u8 IIC_Read_Byte(unsigned char ack)
    7 p# \: u$ z3 v" Q- ?, c( R2 @
92. {
    
93.     unsigned char i, receive = 0;
    
94.     SDA_IN();
    
95.     for(i = 0; i < 8; i++)
    
96.     {
    
97.         IIC_SCL = 0;
    
98.         delay_us(2);
    ! j% b& p* f1 H$ b- P
99.         IIC_SCL = 1;
    3 j0 F# @" {" D7 i" y
100.         receive <<= 1;
     
101.         if(READ_SDA)
     / z% u% G1 n4 s# E/ V+ C
102.             receive++;
     $ A% c8 u) T  I9 }! r  i
103.         delay_us(1);
     
104.     }
     : B) T6 d+ c" i
105.     if(!ack)
     
106.         IIC_NAck();
     2 m+ a# {0 J, G- b  ]6 D: N5 K
107.     else
     
108.         IIC_Ack();
     ' a& s8 A1 ?) O* d; f( P
109.     return receive;
     6 t: o2 R% x5 |5 i4 i& Z  v
110. }
     3 A3 D+ J5 _4 _5 [

复制代码

' U8 S$ l% g  l- W这里将最常用的几个信号封装为函数，当操作24Cxx芯片的时候，直接调用这几个函数。
1 B- _0 }/ L' l

1. #include "24Cxx.h"
   
2. #include "delay.h"
   1 ?% c) Y: v& l
3. 
   ' @/ o; d6 k8 K
4. void AT24Cxx_Init(void)
   # r* V7 w7 j4 i& |. U# F
5. {
   ; r/ }; _( g+ m
6.     IIC_Init();
   ' s, f2 [$ k9 Z+ }# z2 t
7. }
   / L0 N8 W7 T+ n
8. //在AT24CXX指定地址读出一个数据
   6 U( g* p% m; J: k& ?, b% f$ g2 b
9. //ReadAddr:开始读数的地址
   
10. //返回值  :读到的数据
    
11. u8 AT24Cxx_ReadOneByte(u16 ReadAddr)
    
12. {
    
13.     u8 temp = 0;
    
14.     IIC_Start();
    2 v) M- k% g- z  U+ L3 x) l+ j+ G6 d
15.     if(EE_TYPE > AT24C16)
    
16.     {
    & F' a( t6 |2 M( r. g" v8 ~
17.         IIC_Send_Byte(0xA0);                        //发送写命令
    
18.         IIC_Wait_Ack();
    
19.         IIC_Send_Byte(ReadAddr >> 8);        //发送高地址
    ( T  N% u; p0 Z! L1 Z+ }* i
20.         IIC_Wait_Ack();
    
21.     }
    
22.     else
    4 t8 M, B6 r& a: @2 b0 [: _8 N' h# s
23.         IIC_Send_Byte(0xA0 + ((ReadAddr / 256) << 1));        //发送器件地址0XA0,写数据
    / Z$ Y. A# S$ b# I8 L
24. 
    
25.     IIC_Wait_Ack();
    8 g# B( n- u+ q! x/ ~
26.     IIC_Send_Byte(ReadAddr % 256);                //发送低地址
    1 _8 ^; D; v( m7 p( T3 [
27.     IIC_Wait_Ack();
    
28.     IIC_Start();
    
29.     IIC_Send_Byte(0xA1);                                //进入接收模式
    
30.     IIC_Wait_Ack();
    
31.     temp = IIC_Read_Byte(0);
    
32.     IIC_Stop();                                                        //产生一个停止条件
    - b- @( z* d4 }+ I
33.     return temp;
    
34. }
    
35. //在AT24CXX指定地址写入一个数据
    * N0 o6 v( u( q$ t& s5 Z6 n4 M9 b
36. //WriteAddr  :写入数据的目的地址
    4 R  P% I1 N+ m
37. //DataToWrite:要写入的数据
    2 g2 x5 r! {8 [0 P4 ^( w; p& p+ A$ Q
38. void AT24Cxx_WriteOneByte(u16 WriteAddr, u8 DataToWrite)
    ) ^! P( i4 g7 a) Z" G& V
39. {
    
40.     IIC_Start();
    
41.     if(EE_TYPE > AT24C16)
    
42.     {
    
43.         IIC_Send_Byte(0xA0);                        //发送写命令
    
44.         IIC_Wait_Ack();
    
45.         IIC_Send_Byte(WriteAddr >> 8);        //发送高地址
    
46.     }
    
47.     else
    
48.         IIC_Send_Byte(0xA0 + ((WriteAddr / 256) << 1));        //发送器件地址0XA0,写数据
    ( v  y, @. Z0 v' j, ?
49.     IIC_Wait_Ack();
      ~8 N  B: C1 L) {6 K$ J
50.     IIC_Send_Byte(WriteAddr % 256);
    # Z/ Q( @7 y8 v# M7 A! r
51.     IIC_Wait_Ack();
    - M9 W& Z: n5 f; e
52.     IIC_Send_Byte(DataToWrite);
    4 U3 Q" M3 \, x
53.     IIC_Wait_Ack();
    
54.     IIC_Stop();
    * y* M% x. \5 T2 @5 B* i" a
55.     delay_ms(10);
    
56. }
    
57. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    1 q/ D' k6 e- k+ A6 j
58. //该函数用于写入16bit或者32bit的数据.
    
59. //WriteAddr  :开始写入的地址
    4 G4 i8 _  V; w! Q0 ?# n
60. //DataToWrite:数据数组首地址
    ' w, ^6 G$ H0 V5 w1 G& ~
61. //Len        :要写入数据的长度2,4
    ) A' T, F9 Y' T; B- S' G
62. void AT24Cxx_WriteLenByte(u16 WriteAddr, u32 DataToWrite, u8 Len)
    1 q/ N, @' \) P8 m7 }
63. {
    
64.     u8 t;
      {# f0 ?  s+ K2 O; T
65.     for(t = 0; t < Len; t++)
    " R" t2 N% U) o9 U7 s7 i# j' `
66.     {
    
67.         AT24Cxx_WriteOneByte(WriteAddr + t, (DataToWrite >> (8 * t)) & 0xff);
    
68.     }
    
69. }
    
70. //在AT24CXX里面的指定地址开始读出长度为Len的数据
    
71. //该函数用于读出16bit或者32bit的数据.
    
72. //ReadAddr   :开始读出的地址
    
73. //返回值     :数据
    
74. //Len        :要读出数据的长度2,4
    9 g. T6 U) ~( X! Q& s
75. u32 AT24Cxx_ReadLenByte(u16 ReadAddr, u8 Len)
    
76. {
    
77.     u8 t;
    
78.     u32 temp = 0;
    ( ]+ ~) s- M3 P% \
79.     for(t = 0; t < Len; t++)
    $ S- Z" {6 v9 L, X" [$ H
80.     {
    
81.         temp <<= 8;
    
82.         temp += AT24Cxx_ReadOneByte(ReadAddr + Len - t - 1);
    
83.     }
    , R) n, h3 q  }! \$ X) L
84.     return temp;
    3 l7 M, b1 d7 V' }8 F$ b  y
85. }
    / H" }$ H7 K8 j6 m
86. //检查AT24CXX是否正常
    , T+ ]6 l- E! x/ j, R) s
87. //这里用了24XX的最后一个地址(255)来存储标志字.
    
88. //如果用其他24C系列,这个地址要修改
    
89. //返回1:检测失败
    : ?" C4 O  U" J+ O
90. //返回0:检测成功
    ; f$ }2 }' D% C9 V) e8 e6 a
91. u8 AT24Cxx_Check(void)
    
92. {
    
93.     u8 temp;
    & t: M" b  [1 v4 n) Y# S5 g. l
94.     temp = AT24Cxx_ReadOneByte(255);
    . ?, Q* a: g8 ]# V
95.     if(temp == 0x55)
    
96.         return 0;
    
97.     else
    % R' Y- f2 C/ s; O4 S  J" D
98.     {
    
99.         AT24Cxx_WriteOneByte(1023, 0x55);
    % p* F4 k/ v7 S  ~( `7 P
100.         temp = AT24Cxx_ReadOneByte(255);
     ! J5 U3 q0 @! f5 E. m* W
101.         if(temp == 0x55)
     5 K' Q$ I: C  N, P+ V- y/ d
102.             return 0;
     
103.     }
     6 I* a6 j7 T  ~1 h- w( |
104.     return 1;
     
105. }
     ; t- c, _6 Q/ N6 z! Q7 q% h* `. ]
106. 
     4 v) m+ ~/ U, ^8 a* H$ g8 Z$ u" D
107. //在AT24CXX里面的指定地址开始读出指定个数的数据
     
108. //ReadAddr :开始读出的地址 对24c02为0~255
     ) s. Q" y8 v9 f2 Z4 P2 B  y
109. //pBuffer  :数据数组首地址
     
110. //NumToRead:要读出数据的个数
     
111. void AT24Cxx_Read(u16 ReadAddr, u8 *pBuffer, u16 NumToRead)
     + \" ^1 a% _/ ~* @$ M; @3 e' R
112. {
     
113.     while(NumToRead)
     
114.     {
     , F6 [* s9 w: s. Y
115.         *pBuffer++ = AT24Cxx_ReadOneByte(ReadAddr++);
     5 {5 v3 }+ \9 }/ }, X/ q- N! g
116.         NumToRead--;
     
117.     }
     8 b+ V; ^8 R% S" E) g) }+ R7 Y
118. }
     9 _  B6 `3 |5 W8 U
119. //在AT24CXX里面的指定地址开始写入指定个数的数据
     
120. //WriteAddr :开始写入的地址 对24c02为0~255
     
121. //pBuffer   :数据数组首地址
     3 r" o. ~8 X5 ^  S7 Z4 G0 L. z( h
122. //NumToWrite:要写入数据的个数
     " `) E) Z6 f' }+ O+ }/ P( A. l) w
123. void AT24Cxx_Write(u16 WriteAddr, u8 *pBuffer, u16 NumToWrite)
     ( c9 I- B: J. W4 D! M1 i
124. {
     # @# h" C, Y; k* X7 H+ S3 ]9 E+ l5 g
125.     while(NumToWrite--)
     $ R! m, Y6 }. ~. [$ X
126.     {
     % y7 Q8 {$ `. }1 f
127.         AT24Cxx_WriteOneByte(WriteAddr, *pBuffer);
     : G) T2 l& ~8 L! [6 }
128.         WriteAddr++;
     9 u! ~: P1 r; ]* S
129.         pBuffer++;
     
130.     }
     ' T0 G  K" j. U- w# Y% X
131. }

复制代码

/ W5 A1 A" o# p5 b. N这里就是对具体的芯片操作函数，在主函数中通过这几个函数就可读写EEPROM存储芯片的内容了。
' g  S, t9 [$ n, K
5 i( Q2 d5 n/ c+ G

1. int main(void)
   1 }# N* K+ b; V, ~3 K2 Z8 H
2. {
   
3. 
   9 u2 q# s. f2 U2 x  n
4.     u8 key;
   
5.     u16 i = 0, j = 0;
   / x, L5 B0 O! M3 A1 y
6.     u8 datatemp[SIZE];
   7 g" N; p9 n9 i
7. 
   3 H$ g# @3 C" r
8.     delay_init();
   " c4 Y9 ]* Y* B  b. Q% b
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   % |% y0 J8 k" l
10.     uart_init(115200);
    
11.     LED_Init();
    ) K5 E% s) c: E1 ?/ ]' ^( I) j% S
12.     KEY_Init();
    3 @, m6 d5 s4 o6 u; I, O# l  ~
13. 
    ( ]$ q- s/ }& ?0 Q5 n8 o
14.     AT24Cxx_Init();
    
15. 
    
16.     printf("IIC test!!!\r\n");
    - q6 x/ p2 @! O. p5 r
17.     while(AT24Cxx_Check())
    ) u% ?8 p8 i5 |% k
18.     {
    
19.         printf("The chip is not detected, please check whether the hardware connection is normal!!!\r\n");
    ; ~; v- n- J8 Z* A4 C
20.         delay_ms(300);
    
21.         LED1 = !LED1;
      w% J% y# g! }9 l
22.     }
    , A# K8 s% ?4 A- \. ^
23. 
    
24.     while(1)
    
25.     {
    
26. 
    
27.         key = KEY_Sacn(0);
    
28.         if(key == WKUP_PRES)
    3 x4 \! i+ m. o  ~: g/ V
29.         {
    ( Q* M$ ?# W. ]9 \0 n9 O
30.             printf("\r\nStart Write 24C02....\r\n");
    3 A4 p) W- _  R( D% \6 m& a* y
31.             AT24Cxx_Write(0, (u8 *)TEXT_Buffer, SIZE);
    
32.             printf("24C02 Write Finished!\r\n");
    9 v0 j) p8 x/ a3 J% O% m- Z. \# U7 k& m2 X
33.         }
    
34.         else if(key == KEY1_PRES)
    
35.         {
    * g8 ^% `2 L7 p! f9 R7 V: [. i- @
36.             printf("\r\nStart Read 24C02....\r\n");
    5 V  M- Z8 @+ [6 @" c5 p
37.             AT24Cxx_Read(0, datatemp, SIZE);
    
38.             printf("The Data Readed Is:  ");
      y  m( |  a& X7 u, N  B  f: q
39.             for(j = 0; j < SIZE; j++)
    ) r& s: \: _+ }9 B- h' j
40.             {
    
41.                 printf("%c", datatemp[j]);
    
42.             }
    
43.         }
    
44. 
    3 {# C+ `* x5 s& ]( B' p3 F
45.         i++;
    - f* ?9 J$ i( q* h/ G9 g. |
46.         if(i == 20)
    
47.         {
    0 Q' p( V% A% ^  g! Q: R4 B
48.             i = 0;
    4 C6 Q  e) D. Q3 L% s, f% Z
49.             LED0 = !LED0;
    # t, k3 c6 M: |/ U" w; X
50.         }
    " k3 s) r; G! B$ G$ f+ v
51.         delay_ms(5);
    
52.     }
    
53. }

复制代码

这里通过按键来测试存储芯片，一个按键按下后向芯片内写入数据，另一个按键按下后从芯片中读取刚才写入的内容。
. q( Y3 h$ K  w; x


$ t& j5 J7 i% D* U- A) Y  @. X