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

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



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

I2 C 总线协议

I 2 C 总线协议定义如下：
只有在总线空闲时才允许启动数据传送
在数据传送过程中 当时钟线为高电平时 数据线必须保持稳定状态 不允许有跳变 时钟线为高电平时 数据线的任何电平变化将被看作总线的起始或停止信号。



起始信号
时钟线保持高电平期间 数据线电平从高到低的跳变作为 I 2 C 总线的起始信号

停止信号
时钟线保持高电平期间 数据线电平从低到高的跳变作为 I 2 C 总线的停止信号









这里就使用最简单的几个通信时序起始、停止、读、写和应答时序。

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

1. //IIC产生起始信号
   
2. void IIC_Start(void)
   
3. {
   
4.     //START:when CLK is high,DATA change form high to low
   
5.     SDA_OUT();
   
6.     IIC_SDA = 1;
   
7.     IIC_SCL = 1;
   
8.     delay_us(4);
   
9.     IIC_SDA = 0;
   
10.     delay_us(4);
    
11.     IIC_SCL = 0;
    
12. }
    
13. //产生停止信号
    
14. void IIC_Stop(void)
    
15. {
    
16.     //STOP:when CLK is high DATA change form low to high
    
17.     SDA_OUT();
    
18.     IIC_SCL = 0;
    
19.     IIC_SDA = 0;
    
20.     delay_us(4);
    
21.     IIC_SCL = 1;
    
22.     IIC_SDA = 1;
    
23.     delay_us(4);
    
24. }
    
25. //等待应答信号
    
26. //返回值: 1 应答失败
    
27. //        0 应答成功
    
28. u8 IIC_Wait_Ack(void)
    
29. {
    
30.     u8 errTime = 0;
    
31.     SDA_IN();
    
32.     IIC_SDA = 1;
    
33.     delay_us(1);
    
34.     IIC_SCL = 1;
    
35.     delay_us(1);
    
36.     while(READ_SDA)
    
37.     {
    
38.         errTime++;
    
39.         if(errTime > 250)
    
40.         {
    
41.             IIC_Stop();
    
42.             return 1;
    
43.         }
    
44.     }
    
45.     IIC_SCL = 0;
    
46.     return 0;
    
47. }
    
48. //产生ACK应答
    
49. void IIC_Ack(void)
    
50. {
    
51.     IIC_SCL = 0;
    
52.     SDA_OUT();
    
53.     IIC_SDA = 0;
    
54.     delay_us(2);
    
55.     IIC_SCL = 1;
    
56.     delay_us(2);
    
57.     IIC_SCL = 0;
    
58. }
    
59. //不产生应答
    
60. void IIC_NAck(void)
    
61. {
    
62.     IIC_SCL = 0;
    
63.     SDA_OUT();
    
64.     IIC_SDA = 1;
    
65.     delay_us(2);
    
66.     IIC_SCL = 1;
    
67.     delay_us(2);
    
68.     IIC_SCL = 0;
    
69. }
    
70. //IIC发送一个字节
    
71. void IIC_Send_Byte(u8 txd)
    
72. {
    
73.     u8 t;
    
74.     SDA_OUT();
    
75.     IIC_SCL = 0;
    
76.     for(t = 0; t < 8; t++)
    
77.     {
    
78.         if((txd & 0x80) >> 7)
    
79.             IIC_SDA = 1;
    
80.         else
    
81.             IIC_SDA = 0;
    
82.         txd <<= 1;
    
83.         delay_us(2);
    
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
    
91. u8 IIC_Read_Byte(unsigned char ack)
    
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);
    
99.         IIC_SCL = 1;
    
100.         receive <<= 1;
     
101.         if(READ_SDA)
     
102.             receive++;
     
103.         delay_us(1);
     
104.     }
     
105.     if(!ack)
     
106.         IIC_NAck();
     
107.     else
     
108.         IIC_Ack();
     
109.     return receive;
     
110. }
     

复制代码

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

1. #include "24Cxx.h"
   
2. #include "delay.h"
   
3. 
   
4. void AT24Cxx_Init(void)
   
5. {
   
6.     IIC_Init();
   
7. }
   
8. //在AT24CXX指定地址读出一个数据
   
9. //ReadAddr:开始读数的地址
   
10. //返回值  :读到的数据
    
11. u8 AT24Cxx_ReadOneByte(u16 ReadAddr)
    
12. {
    
13.     u8 temp = 0;
    
14.     IIC_Start();
    
15.     if(EE_TYPE > AT24C16)
    
16.     {
    
17.         IIC_Send_Byte(0xA0);                        //发送写命令
    
18.         IIC_Wait_Ack();
    
19.         IIC_Send_Byte(ReadAddr >> 8);        //发送高地址
    
20.         IIC_Wait_Ack();
    
21.     }
    
22.     else
    
23.         IIC_Send_Byte(0xA0 + ((ReadAddr / 256) << 1));        //发送器件地址0XA0,写数据
    
24. 
    
25.     IIC_Wait_Ack();
    
26.     IIC_Send_Byte(ReadAddr % 256);                //发送低地址
    
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();                                                        //产生一个停止条件
    
33.     return temp;
    
34. }
    
35. //在AT24CXX指定地址写入一个数据
    
36. //WriteAddr  :写入数据的目的地址
    
37. //DataToWrite:要写入的数据
    
38. void AT24Cxx_WriteOneByte(u16 WriteAddr, u8 DataToWrite)
    
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,写数据
    
49.     IIC_Wait_Ack();
    
50.     IIC_Send_Byte(WriteAddr % 256);
    
51.     IIC_Wait_Ack();
    
52.     IIC_Send_Byte(DataToWrite);
    
53.     IIC_Wait_Ack();
    
54.     IIC_Stop();
    
55.     delay_ms(10);
    
56. }
    
57. //在AT24CXX里面的指定地址开始写入长度为Len的数据
    
58. //该函数用于写入16bit或者32bit的数据.
    
59. //WriteAddr  :开始写入的地址
    
60. //DataToWrite:数据数组首地址
    
61. //Len        :要写入数据的长度2,4
    
62. void AT24Cxx_WriteLenByte(u16 WriteAddr, u32 DataToWrite, u8 Len)
    
63. {
    
64.     u8 t;
    
65.     for(t = 0; t < Len; t++)
    
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
    
75. u32 AT24Cxx_ReadLenByte(u16 ReadAddr, u8 Len)
    
76. {
    
77.     u8 t;
    
78.     u32 temp = 0;
    
79.     for(t = 0; t < Len; t++)
    
80.     {
    
81.         temp <<= 8;
    
82.         temp += AT24Cxx_ReadOneByte(ReadAddr + Len - t - 1);
    
83.     }
    
84.     return temp;
    
85. }
    
86. //检查AT24CXX是否正常
    
87. //这里用了24XX的最后一个地址(255)来存储标志字.
    
88. //如果用其他24C系列,这个地址要修改
    
89. //返回1:检测失败
    
90. //返回0:检测成功
    
91. u8 AT24Cxx_Check(void)
    
92. {
    
93.     u8 temp;
    
94.     temp = AT24Cxx_ReadOneByte(255);
    
95.     if(temp == 0x55)
    
96.         return 0;
    
97.     else
    
98.     {
    
99.         AT24Cxx_WriteOneByte(1023, 0x55);
    
100.         temp = AT24Cxx_ReadOneByte(255);
     
101.         if(temp == 0x55)
     
102.             return 0;
     
103.     }
     
104.     return 1;
     
105. }
     
106. 
     
107. //在AT24CXX里面的指定地址开始读出指定个数的数据
     
108. //ReadAddr :开始读出的地址 对24c02为0~255
     
109. //pBuffer  :数据数组首地址
     
110. //NumToRead:要读出数据的个数
     
111. void AT24Cxx_Read(u16 ReadAddr, u8 *pBuffer, u16 NumToRead)
     
112. {
     
113.     while(NumToRead)
     
114.     {
     
115.         *pBuffer++ = AT24Cxx_ReadOneByte(ReadAddr++);
     
116.         NumToRead--;
     
117.     }
     
118. }
     
119. //在AT24CXX里面的指定地址开始写入指定个数的数据
     
120. //WriteAddr :开始写入的地址 对24c02为0~255
     
121. //pBuffer   :数据数组首地址
     
122. //NumToWrite:要写入数据的个数
     
123. void AT24Cxx_Write(u16 WriteAddr, u8 *pBuffer, u16 NumToWrite)
     
124. {
     
125.     while(NumToWrite--)
     
126.     {
     
127.         AT24Cxx_WriteOneByte(WriteAddr, *pBuffer);
     
128.         WriteAddr++;
     
129.         pBuffer++;
     
130.     }
     
131. }

复制代码

这里就是对具体的芯片操作函数，在主函数中通过这几个函数就可读写EEPROM存储芯片的内容了。

1. int main(void)
   
2. {
   
3. 
   
4.     u8 key;
   
5.     u16 i = 0, j = 0;
   
6.     u8 datatemp[SIZE];
   
7. 
   
8.     delay_init();
   
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     uart_init(115200);
    
11.     LED_Init();
    
12.     KEY_Init();
    
13. 
    
14.     AT24Cxx_Init();
    
15. 
    
16.     printf("IIC test!!!\r\n");
    
17.     while(AT24Cxx_Check())
    
18.     {
    
19.         printf("The chip is not detected, please check whether the hardware connection is normal!!!\r\n");
    
20.         delay_ms(300);
    
21.         LED1 = !LED1;
    
22.     }
    
23. 
    
24.     while(1)
    
25.     {
    
26. 
    
27.         key = KEY_Sacn(0);
    
28.         if(key == WKUP_PRES)
    
29.         {
    
30.             printf("\r\nStart Write 24C02....\r\n");
    
31.             AT24Cxx_Write(0, (u8 *)TEXT_Buffer, SIZE);
    
32.             printf("24C02 Write Finished!\r\n");
    
33.         }
    
34.         else if(key == KEY1_PRES)
    
35.         {
    
36.             printf("\r\nStart Read 24C02....\r\n");
    
37.             AT24Cxx_Read(0, datatemp, SIZE);
    
38.             printf("The Data Readed Is:  ");
    
39.             for(j = 0; j < SIZE; j++)
    
40.             {
    
41.                 printf("%c", datatemp[j]);
    
42.             }
    
43.         }
    
44. 
    
45.         i++;
    
46.         if(i == 20)
    
47.         {
    
48.             i = 0;
    
49.             LED0 = !LED0;
    
50.         }
    
51.         delay_ms(5);
    
52.     }
    
53. }

复制代码

这里通过按键来测试存储芯片，一个按键按下后向芯片内写入数据，另一个按键按下后从芯片中读取刚才写入的内容。