19：I2C一：程序模仿I2C通讯时序

1、什么是I2C

   I2C通讯协议和串口通讯USART不同，USART是异步，全双工的通讯协议。而I2C通讯协议是一种同步，半双工，带数据应答，支持总线挂载多装备的通讯协议。USART传输数据的时间是先传输数据帧的低位，在传高位。而I2C传输数据的时间是高位先行。

   由上图所示：有2条总线，数据总线SDA和时钟总线SCL。其中时钟线SCL只能由主机控制，而SDA主机和从机都可以控制。
   当主机向从机发送一个字节数据时：①主机先发送一个起始信号，②然后在发送一个字节的数据（从机地址（7位）+W），然后接收从机的应答信号，③然后在发送一个字节的数据（从机寄存器的地址），然后接收一个应答信号，④然后开始发送需要发送给从机的数据，然后接收应答信号，⑤发送一个停止信号。 如下图所示：

   当主机读取从机一个字节的数据时：①主机先发送一个起始信号，②然后在发送一个字节的数据（从机地址（7位）+W），然后接收从机的应答信号，③然后在发送一个字节的数据（从机寄存器的地址）④然后主机在发送一个起始信号，⑤然后在发送一个字节的数据（从机地址（7位）+R），然后接收从机的应答信号，⑥然后开始读取SDA上面的数据，读取到一个字节后，给从机发送一个应答信号，如下图所示：

2、I2C的通讯时序

2.1：起始信号

   起始信号和停止信号都是由主机举行发送，主机需要发送起始信号时：SCL高电平期间，SDA从高电平切换到低电平。

使用程序模仿此时序代码如下：

1. void I2C_W_SCL(uint8_t BitValue)//拉低SCL或者释放SCL(拉高)
2. {
3.         GPIO_WriteBit(GPIOB,GPIO_Pin_10,(BitAction)BitValue);
4.         Delay_us(10);
5. }
7. void I2C_W_SDA(uint8_t BitValue)//给SDA写数据（拉低SDA/释放SDA(拉高)）
8. {
9.         GPIO_WriteBit(GPIOB,GPIO_Pin_11,(BitAction)BitValue);
10.         Delay_us(10);
11. }
13. void MyI2C_Start(void)//起始信号
14. {
15. //        SCL(1);//释放SCL
16.         I2C_W_SDA(1);//释放SDA
17.         I2C_W_SCL(1);//释放SCL
18.         I2C_W_SDA(0);//拉低SDA
19.         I2C_W_SCL(0);//拉低SCL
20. }

复制代码

2.2：停止信号

   主机需要发送停止信号时：SCL高电平期间，SDA从低电平切换到高电平。

使用程序模仿此时序代码如下：

1. void MyI2C_Stop(void)
2. {
3.         I2C_W_SCL(0);
4.         I2C_W_SDA(0);
5.         I2C_W_SCL(1);
6.         I2C_W_SDA(1);
7. }

复制代码

2.3：主机向从机发送一个字节数据

   SCL低电平期间，主机将数据位依次给SDA写入数据（高位先行），然后开释SCL，从机将在SCL高电平期间读取数据位，以是SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可发送一个字节，从机读取到一个字节，会有一个应答信号。

使用程序模仿此时序代码如下：

1. /*
2.         发送数据前，主机会发送一个起始信号，由上面的程序可知：起始信号发送完后SCL和SDA都被拉低。
3.         所以函数里面不用在拉低，直接向SDA写入数据即可。
4. */
5. void MyI2C_SendByte(uint8_t Byte)//主机向从机发送一个字节，高位先行
6. {
7.         I2C_W_SDA(Byte & 0x80);//给SDA写入数据,只要Byte不是0，那么写入的就是1。因为BitAction
8.         I2C_W_SCL(1);//释放SCL，从机读取数据
9.         I2C_W_SCL(0);//拉低SCL，主机准备给SDA写入字节的次高位数据
10.        
11.         I2C_W_SDA(Byte & 0x40);//给SDA写入数据,
12.         I2C_W_SCL(1);//释放SCL，从机读取数据
13.         I2C_W_SCL(0);//拉低SCL，主机准备给SDA写入字节的次次高位数据
14.         .
15.         .
16.         .
17. }

复制代码

代码优化如下：

1. /*
2.         发送数据前，主机会发送一个起始信号，由上面的程序可知：起始信号发送完后SCL和SDA都被拉低。
3.         所以函数里面不用在拉低，直接向SDA写入数据即可。
4. */
5. void MyI2C_SendByte(uint8_t Byte)//主机向从机发送一个字节，高位先行
6. {
7.         for(uint8_t i = 0;i<8;i++)
8.         {
9.                 I2C_W_SDA(Byte & (0x80 >> i));//给SDA写入数据,只要Byte不是0，那么写入的就是1。因为BitAction
10.                 I2C_W_SCL(1);//释放SCL，从机读取数据
11.                 I2C_W_SCL(0);//拉低SCL，主机准备给SDA写入字节的次高位数据
12.         }
13. }

复制代码

2.4：主机向从机读取一个字节数据

   接收一个字节：SCL低电平期间，从机将数据位依次放到SDA线上（高位先行），然后开释SCL，主机将在SCL高电平期间读取数据位，以是SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可接收一个字节（主机在接收之前，需要开释SDA，即SDA拉高）

使用程序模仿此时序代码如下：

1. uint8_t I2C_R_SDA(void)//主机读SDA数据，即判断引脚的电平
2. {
3.         uint8_t BitValue;
4.         BitValue = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_11);
5.         Delay_us(10);
6.         return BitValue;
7. }
9. /*
10.         主机接收数据之前，主机会给从机发送一个字节，由上面的代码得发送完数据后此时SCL为低电平。之后释放SDA总线让从机拥有SDA总线的控制权。
11. */
12. uint8_t MyI2C_ReceiveByte(void)
13. {
14.         uint8_t Byte = 0x00;//接收数据的变量
15.         I2C_W_SDA(1);//主机释放SDA，让控制权给从机，而SCL也是低电平，释放的一瞬间，从机就给SDA写入了数据
16.        
17.         I2C_W_SCL(1);
18.         if(I2C_R_SDA() == 1)//读取第一位数据
19.         {
20.                 Byte |= 0x80;
21.         }
22.         I2C_W_SCL(0);//主机拉低SCL，让从机给SDA写入数据       
23.        
24.         I2C_W_SCL(1);//主机拉高SCL，准备开始读取SDA上面的数据
25.         if(I2C_R_SDA() == 1)
26.         {
27.                 Byte |= 0x40;
28.         }
29.         I2C_W_SCL(0);//主机拉低SCL，让从机给SDA写入数据       
30.         .
31.         .
32.         .
33.         return Byte;
34. }

复制代码

代码优化如下：

1. uint8_t MyI2C_ReceiveByte(void)
2. {
3.         uint8_t Byte = 0x00;//接收数据的变量
4.         I2C_W_SDA(1);//主机释放SDA，让控制权给从机
5.        
6.         for(uint8_t i =0; i<8;i++)
7.         {
8.                 I2C_W_SCL(1);//主机拉高SCL，准备开始读取SDA上面的数据
9.                 if(I2C_R_SDA() == 1)
10.                 {
11.                         Byte |= (0x80 >> i);
12.                 }       
13.                 I2C_W_SCL(0);//主机拉低SCL，准备让从机给SDA写入数据       
14.         }
15.         return Byte;
16. }

复制代码

2.5：主机接收应答

   接收应答：主机在发送完一个字节之后，在下一个时钟接收一位数据，判断从机是否应答，数据0（SDA被从机拉低）表示应答，数据1（SDA没有被从机拉低）表示非应答（主机在接收之前，需要开释SDA，即SDA拉高）

使用程序模仿此时序代码如下：

1. uint8_t I2C_R_SDA(void)//主机读SDA数据，即判断引脚的电平
2. {
3.         uint8_t BitValue;
4.         BitValue = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_11);
5.         Delay_us(10);
6.         return BitValue;
7. }
9. uint8_t MyI2C_ReceiveACK(void)//主机接收应答
10. {
11. /*
12.         主机发送完一个字节后，SCL为低电平，
13.         等待从机给SDA上面写入数据，如果拉低则代表接收成功
14. */
15.         uint8_t ACKBit;
16.         I2C_W_SDA(1);//主机释放SDA，让控制权给从机
17.         I2C_W_SCL(1);//主机释放SCL，准备开始读取SDA上面的数据
18.         ACKBit = I2C_R_SDA();
19.         I2C_W_SCL(0);//主机拉低SCL，进入下一个时序单元，主机准备给SDA写入字节的数据
20.         return ACKBit;
21. }

复制代码

2.6：主机发送应答

   主机在接收完一个字节之后，在下一个时钟发送一位数据，数据0表示应答，数据1表示非应答。

1. void MyI2C_SendACK(uint8_t ACKBit)//主机发送应答
2. {
3. /*
4.         从机发送完一个字节后，SCL为低电平，
5.         等待主机给SDA上面写数据，如果拉低代表接收成功。
6. */
7.        
8.         I2C_W_SDA(ACKBit);//主机给SDA写入应答信号，0为应答，1为非应答
9.         I2C_W_SCL(1);//主机拉高SCL，让从机读取应答信号
10.         I2C_W_SCL(0);//主机拉低SCL，准备写入数据
11. }

复制代码

3、程序模仿I2C的通讯时序

3.1：指定地址写一个字节的数据

用程序模仿I2C时序实现如上图的波形：
①I2C.c文件使用程序模仿I2C时序程序如下：

1. #include "stm32f10x.h"                 #include "Delay.h"                 //#define SCL(x)          GPIO_WriteBit(GPIOB,GPIO_Pin_10,(BitAction)(x))//#define SDA(x)          GPIO_WriteBit(GPIOB,GPIO_Pin_11,(BitAction)(x))void I2C_W_SCL(uint8_t BitValue)//拉低SCL/开释SCL(拉高){        GPIO_WriteBit(GPIOB,GPIO_Pin_10,(BitAction)BitValue);        Delay_us(10);}void I2C_W_SDA(uint8_t BitValue)//给SDA写数据（拉低SDA/开释SDA(拉高)）{        GPIO_WriteBit(GPIOB,GPIO_Pin_11,(BitAction)BitValue);        Delay_us(10);}uint8_t I2C_R_SDA(void)//主机读SDA数据，即判断引脚的电平{        uint8_t BitValue;        BitValue = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_11);        Delay_us(10);        return BitValue;}void MyI2C_Init(void){        //1. 使能挂载在APB2总线上面的片上外设时钟        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);                //2. 对GPIO_PA10/PA11举行配置        GPIO_InitTypeDef GPIOInitStruct;        GPIOInitStruct.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;        GPIOInitStruct.GPIO_Mode = GPIO_Mode_Out_OD;//输出开漏模式，0才有驱动能力，开漏模式没有输出低电平时，也可以作为输入        GPIOInitStruct.GPIO_Speed = GPIO_Speed_50MHz;//最大输出速度        GPIO_Init(GPIOB,&GPIOInitStruct);                GPIO_SetBits(GPIOB,GPIO_Pin_10 | GPIO_Pin_11);//先给输出高电平，开释总线                                                                                                                                                                                                //PB10连接SCL。PB11连接SDA}void MyI2C_Start(void)//起始信号{        I2C_W_SDA(1);//开释SDA        I2C_W_SCL(1);//开释SCL        I2C_W_SDA(0);//拉低SDA        I2C_W_SCL(0);//拉低SDA}void MyI2C_Stop(void)
2. {
3.         I2C_W_SCL(0);
4.         I2C_W_SDA(0);
5.         I2C_W_SCL(1);
6.         I2C_W_SDA(1);
7. }
8. void MyI2C_SendByte(uint8_t Byte)//主机向从机发送一个字节，高位先行{        for(uint8_t i = 0;i<8;i++)        {                I2C_W_SDA(Byte & (0x80 >> i));//给SDA写入数据,只要Byte不是0，那么写入的就是1。因为BitAction                I2C_W_SCL(1);//开释SCL，从机读取数据                I2C_W_SCL(0);//拉低SCL，主机预备给SDA写入字节的次高位数据        }}uint8_t MyI2C_ReceiveByte(void){        uint8_t Byte = 0x00;//接收数据的变量                I2C_W_SDA(1);//主机开释SDA，让控制权给从机        for(uint8_t i =0; i<8;i++)        {                I2C_W_SCL(1);//主机开释SCL，预备开始读取SDA上面的数据                if(I2C_R_SDA() == 1)                {                        Byte |= (0x80 >> i);                }                I2C_W_SCL(0);//主机拉低SCL，让从机给SDA写入数据                }        return Byte;}void MyI2C_SendACK(uint8_t ACKBit)//主机发送应答{/*        从机发送完一个字节后，SCL为低电平，        等待主机给SDA上面写数据，如果拉低代表接收获功。*/                I2C_W_SDA(ACKBit);        I2C_W_SCL(1);        I2C_W_SCL(0);}uint8_t MyI2C_ReceiveACK(void)//主机接收应答{/*        主机发送完一个字节后，SCL为低电平，        等待从机给SDA上面写入数据，如果拉低则代表接收获功*/        uint8_t ACKBit;        I2C_W_SDA(1);//主机开释SDA，让控制权给从机        I2C_W_SCL(1);//主机开释SCL，预备开始读取SDA上面的数据        ACKBit = I2C_R_SDA();        I2C_W_SCL(0);//主机拉低SCL，进入下一个时序单元，主机预备给SDA写入字节的数据        return ACKBit;}

复制代码

②主函数文件模仿波形的程序如下：

1. #include "stm32f10x.h"   
2. #include "MyI2C.h"
3. int main(void)
4. {
5.         MyI2C_Init();
6.         MyI2C_Start();//发送一个起始信号
7.        
8.         MyI2C_SendByte(0xD0);//发送一个字节的数据（从机地址7位+W）,0表示写，1表示读
9.         MyI2C_ReceiveACK();//接收从机应答信号
10.        
11.         MyI2C_SendByte(0x19);//发送一个字节的数据（从机中的寄存器地址）
12.         MyI2C_ReceiveACK();//接收从机应答信号
13.        
14.         MyI2C_SendByte(0xAA);//发送一个字节的数据（需要发送给从机的数据）
15.         MyI2C_ReceiveACK();//接收从机应答信号
16.        
17.         MyI2C_Stop();//发送一个停止信号
18. }

复制代码

3.2：指定地址读一个字节的数据

1. #include "stm32f10x.h"   
2. #include "MyI2C.h"
3. int main(void)
4. {
5.         uint8_t Data;
6.        
7.         MyI2C_Init();
8.         MyI2C_Start();//发送一个起始信号
9.        
10.         MyI2C_SendByte(0xD0);//发送一个字节的数据（从机地址7位+W）,0表示写，1表示读
11.         MyI2C_ReceiveACK();//接收从机应答信号
12.        
13.         MyI2C_SendByte(0x19);//发送一个字节的数据（从机中的寄存器地址）
14.         MyI2C_ReceiveACK();//接收从机应答信号
15.        
16.         MyI2C_Start();//发送一个起始信号
17.        
18.         MyI2C_SendByte(0xD1);//发送一个字节的数据（从机地址7位+R）,0表示写，1表示读
19.         MyI2C_ReceiveACK();//接收从机应答信号
20.        
21.         Data = MyI2C_ReceiveByte();//主机接收一个字节的数据
22.         MyI2C_SendACK(1);//主机发送非应答信号
23.        
24.         MyI2C_Stop();//发送一个停止信号
25. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。