外设驱动库开发笔记8：GPIO模拟I2C驱动

　　I2C总线简单方便，是我们经常使用的一种总线。但有时候我们的MCU没有足够多的I2C控制器来实现我们的应用，所幸我可以使用普通的GPIO引脚来模拟低速的I2C总线通信。这一节我们就来实现使用软件通过普通GPIO操作I2C设备的驱动。

1、功能概述

　　I2C总线使用两条线：串行数据（SDA）和串行时钟（SCL）。所有I2C主设备和从设备仅与这两条线连接。每个设备可以是发射器，接收器或两者。有些设备是主设备，它们生成总线时钟并在总线上启动通信，其他设备是从设备并响应总线上的命令。为了与特定设备通信，每个从设备必须具有总线上唯一的地址。I2C主设备（通常是微控制器）不需要地址，因为没有其他设备向主设备发送命令。总线设备连接示意图如下：

 

1.1、I2C的传输过程

　　I2C总线有标准、快速和高速多种速度模式；也有7位地址和10位地址多种地址格式，但不管什么样的模式其数据传输格式都可以划分为3个阶段：起始阶段、数据传输阶段和终止阶段。如下图：

 

1.1.1、起始阶段

　　在I2C总线不工作的情况下，SDA(数据线)和SCL(时钟线)上的信号均为高电平。如果此时主机需要发起新的通信请求，那么需要首先通过SDA和SCL发出起始标志。当SCL为高电平时，SDA电平从高变低，这一变化表示完成了通信的起始条件。

　　在起始条件和数据通信之间，通常会有延时要求，具体的指标会在设备厂商的规格说明书中给出。

1.1.2、数据传输阶段

　　I2C总线的数据通信是以字节(8位)作为基本单位在SDA上进行串行传输的。一个字节的传输需要9个时钟周期。其中，字节中每一位的传输都需要一个时钟周期，当新的SCL到来时，SCL为低电平，此时数据发送方根据当前传输的数据位控制SDA的电平信号。如果传输的数据位为"1"，就将SDA电平拉高；如果传输的数据位为"0"，就将SDA的电平拉低。当SDA上的数据准备好之后，SCL由低变高，此时数据接收方将会在下一次SCL信号变低之前完成数据的接收。当8位数据发送完成后，数据接收方需要一个时钟周期以使用SDA发送ACK信号，表明数据是否接收成功。当ACK信号为"0"时，说明接收成功；为"1"时，说明接收失败。每个字节的传输都是由高位(MSB)到低位(LSB)依次进行传输。

　　I2C总线协议中规定，数据通信的第一个字节必须由主机发出，内容为此次通信的目标设备地址和数据通信的方向(读/写)。在这个字节中，第1～7位为目标设备地址，第0位为通信方向，当第0位为"1"时表示读，即后续的数据由目标设备发出主机进行接收；当第0位为"0"时表示写，即后续的数据由主机发出目标设备进行接收。在数据通信过程中，总是由数据接收方发出ACK信号。

1.1.3、终止阶段

　　当主机完成数据通信，并终止本次传输时会发出终止信号。当SCL 是高电平时，SDA电平由低变高，这个变化意味着传输终止。

1.2、I2C的传输格式

　　根据I2C总线的技术标准，I2C总线上的数据传输方式有3种：主站向从站写数据方式；主站从从站读数据方式；读写组合的方式。下面将就这几种方式简单说明。

1.2.1、写数据格式

　　主站向从站写数据方式是主栈发送数据给从站。传输方向没有改变，从站接收主站发过来的每一个字节。具体格式如下图：

 

1.2.2、读数据格式

　　主站从从站读数据方式，主站在发送第一个字节之后，立即接收从站数据。也就是说在第一次确认的时刻，主发送器变成了主接收器，从属接收器变成了从属发送器。第一个确认仍然由从站生成。主站则生成后续的确认。停止条件由主主站生成，它在停止条件之前发送一个非确认应答。具体格式如下图：

 

1.2.3、读写组合格式

　　组合格式就是读和写是接连完成的。在传输中改变方向时，启动条件和从地址都要重复，但R/W位要倒过来。如果主接收器发送一个重复启动条件，它在重复启动条件之前发送一个非确认应答，但不会有停止条件。具体格式如下图：

 

2、驱动设计与实现

　　我们已经了解了I2C协议的基本内容，接下来我们需要考虑如何实现这一协议。实现了这一协议也就完成通过GPIO模拟I2C的驱动。

2.1、对象定义

　　我们们依然采用基于对象的操作来实现。所以在使用对象之前，我们需要得到对象。接下来我们就考虑GPIO模拟I2C的对象问题。

2.1.1、对象的抽象

　　一般的，作为一个对象肯定包括属性和操作。所以我们考虑GPIO模拟I2C的对象也要从这两方面来进行。

　　首先来考虑GPIO模拟I2C对象的属性。作为属性应该是必要的且能标识对象特点的参数。我们模拟的I2C其实是主站，作为主站没有地址，所以地址不需要作为属性。但通讯速度却是主站需要控制的，所以我们将速度设置为GPIO模拟I2C的一个属性。除此之外，作为主站没有必须要记录的参数了。

　　还需要考虑GPIO模拟I2C对象的操作。既然是使用GPIO模拟I2C，那么I2C的两根总线SCL和SDA都需要主站操作GPIO来实现，所以控制SCL和控制SDA的行为都是对象的操作。除了控制总线我们还需要从总线读取数据，所以从SDA读取数据也是对象的一个操作。还有如延时等操作与具体的平台关系很大，我们也将其作为操作以便在具体的平台初始化。

　　根据上述的分析，我们可以抽象得到GPIO模拟I2C的对象类型如下：

1 typedef struct SimuI2CObject{
2   uint32_t period;                              //确定速度为大于0K小于等于400K的整数，默认为100K
3   void (*SetSCLPin)(SimuI2CPinValue op);        //设置SCL引脚
4   void (*SetSDAPin)(SimuI2CPinValue op);        //设置SDA引脚
5   uint8_t (*ReadSDAPin)(void);                  //读取SDA引脚位
6   void (*Delayus)(volatile uint32_t period);    //速度延时函数
7 }SimuI2CObjectType;

2.1.2、对象的初始化

　　我们已经得到了GPIO模拟I2C的对象，但对象必须要初始化之后才可以操作，所以这里就需要考虑如何对对象进行初始化。一般来说，初始化函数需要处理几个方面的问题。一是检查输入参数是否合理；二是为对象的属性赋初值；三是对对象作必要的初始化配置。据此我们设计GPIO模拟I2C对象的初始化函数如下：

 1 /* GPIO模拟I2C通讯初始化 */
 2 void SimuI2CInitialization(SimuI2CObjectType *simuI2CInstance，
 3                                       uint32_t speed，
 4                                       SimuI2CSetPin setSCL，
 5                                       SimuI2CSetPin setSDA，
 6                                       SimuI2CReadSDAPin readSDA，
 7                                       SimuI2CDelayus delayus)
 8 {
 9   if((simuI2CInstance==NULL)||(setSCL==NULL)||(setSDA==NULL)||(readSDA==NULL)||(delayus==NULL))
10   {
11      return;
12   }
13       
14   simuI2CInstance->SetSCLPin=setSCL;
15   simuI2CInstance->SetSDAPin=setSDA;
16   simuI2CInstance->ReadSDAPin=readSDA;
17   simuI2CInstance->Delayus=delayus;
18       
19   /*初始化速度，默认100K*/
20   if((speed>0)&&(speed<=400))
21   {
22     simuI2CInstance->period=500/speed;
23   }
24   else
25   {
26     simuI2CInstance->period=5;
27   }
28 
29   /*拉高总线，使处于空闲状态*/
30   simuI2CInstance->SetSDAPin(Set);
31   simuI2CInstance->SetSCLPin(Set);
32 }

2.2、对象操作

　　我们已经定义了对象类型，也实现了对象的初始化函数，接下来我们就需要考虑封装对象的操作了。根据前面我们对I2C协议的了解，需要实现的操作主要有：向从站写数据、从从站读数据、先向从站写而后接着读数据以及基于这三种模式的组合操作。

2.2.1、向从站写数据操作

　　向从站写数据包括向从站写命令、地址以及设定数据等。如向一个或多个存储地址写数据，需要先写存储起始地址再写需要保存的数据。所有的数据都是从主站发往从站，包括启动通讯、下发数据、停止通讯这一过程。具体的实现如下：

 1 /* 通过模拟I2C向从站写数据 */
 2 SimuI2CStatus WriteDataBySimuI2C(SimuI2CObjectType *simuI2CInstance，uint8_t deviceAddress，uint8_t *wData，uint16_t wSize)
 3 {
 4   //启动通讯
 5   SimuI2CStart(simuI2CInstance);
 6   //发送从站地址（写）
 7   SendByteBySimuI2C(simuI2CInstance，deviceAddress);
 8   if(SimuI2CWaitAck(simuI2CInstance，5000))
 9   {
10     return I2C_ERROR;
11   }
12  
13   while(wSize--)
14   {
15     SendByteBySimuI2C(simuI2CInstance，*wData);
16     if(SimuI2CWaitAck(simuI2CInstance，5000))
17     {
18       return I2C_ERROR;
19     }
20     wData++;
21     simuI2CInstance->Delayus(10);
22   }
23       
24   SimuI2CStop(simuI2CInstance);
25   return I2C_OK;
26 }

2.2.2、自从站读数据操作

　　读从站数据操作其实就是先向从站发送站地址（读），然后接收数据。一般存储器不会使用到这种模式，而对于向一些设备获取数据会有这种模式，如MS5803压力触感器。其过程是先启动通讯，再从主站发送包含读的从站地址，然后主站接收自从站返回的数据，然后停止通讯。具体的实现过程如下：

 1 /* 通过模拟I2C自从站读数据 */
 2 SimuI2CStatus ReadDataBySimuI2C(SimuI2CObjectType *simuI2CInstance，uint8_t deviceAddress，uint8_t *rData， uint16_t rSize)
 3 {
 4   //启动通讯
 5   SimuI2CStart(simuI2CInstance);
 6  
 7   //发送从站地址（读）
 8   SendByteBySimuI2C(simuI2CInstance，deviceAddress+1);
 9   if(SimuI2CWaitAck(simuI2CInstance，5000))
10   {
11     return I2C_ERROR;
12   }
13  
14   simuI2CInstance->Delayus(1000);
15  
16   while(rSize--)
17   {
18     *rData=RecieveByteBySimuI2C(simuI2CInstance);
19     rData++;
20     if(rData==0)
21     {
22       IIC_NAck(simuI2CInstance);
23     }
24     else
25     {
26       IIC_Ack(simuI2CInstance);
27       simuI2CInstance->Delayus(1000);
28     }
29   }
30  
31   //结束通讯
32   SimuI2CStop(simuI2CInstance);
33   return I2C_OK;
34 }

2.2.3、先写后读组合操作

　　对于组合操作则是写数据并读数据连续进行。这就像从某一存储地址读数据一样，先发送要读的其实地址，然后接收读出来的数据。其一般过程是：先启动通讯，然后写数据，接着重启通讯，然后读数据，最后停止通讯。具体的实现过程如下：

 1 /* 通过模拟I2C实现对从站先写数据紧接读数据组合操作 */
 2 SimuI2CStatus WriteReadDataBySimuI2C(SimuI2CObjectType *simuI2CInstance，uint8_t deviceAddress， uint8_t *wData，uint16_t wSize，uint8_t *rData， uint16_t rSize)
 3 {
 4   //启动通讯
 5   SimuI2CStart(simuI2CInstance);
 6   //发送从站地址（写）
 7   SendByteBySimuI2C(simuI2CInstance，deviceAddress);
 8   if(SimuI2CWaitAck(simuI2CInstance，5000))
 9   {
10     return I2C_ERROR;
11   }
12  
13   while(wSize--)
14   {
15     SendByteBySimuI2C(simuI2CInstance，*wData);
16     if(SimuI2CWaitAck(simuI2CInstance，5000))
17     {
18       return I2C_ERROR;
19     }
20     wData++;
21     simuI2CInstance->Delayus(10);
22   }
23       
24   //再启动
25   SimuI2CStart(simuI2CInstance);
26   //发送从站地址（读）
27   SendByteBySimuI2C(simuI2CInstance，deviceAddress+1);
28   if(SimuI2CWaitAck(simuI2CInstance，5000))
29   {
30     return I2C_ERROR;
31   }
32  
33   while(rSize--)
34   {
35     *rData=RecieveByteBySimuI2C(simuI2CInstance);
36     rData++;
37     if(rSize==0)
38     {
39       IIC_NAck(simuI2CInstance);
40     }
41     else
42     {
43       IIC_Ack(simuI2CInstance);
44     }
45   }
46   //结束通讯
47   SimuI2CStop(simuI2CInstance);
48   return I2C_OK;
49 }

3、驱动的使用前面

　　前面已经设计并实现了GPIO模拟I2C通讯的驱动，下面我们还需要使用此驱动设计一个简单的应用以验证驱动设计的是否合理。

3.1、声明并初始化对象

　　在应用一个对象前，我们需要先得到这个对象。前面我们已经抽象了GPIO模拟I2C通讯的对象类型，这里我们将使用此对象类型声明一个对象变量。具体形式如下：

　　SimuI2CObjectType simuI2C;

　　声明了这个对象变量并不能立即使用，我们还需要使用驱动中定义的初始化函数对这个变量进行初始化。这个初始化函数所需要的输入参数如下：

　　SimuI2CObjectType *simuI2CInstance，

　　uint32_t speed，

　　SimuI2CSetPin setSCL，

　　SimuI2CSetPin setSDA，

　　SimuI2CReadSDAPin readSDA，

　　SimuI2CDelayus delayus，

　　对于这些参数，对象变量我们已经定义了。而通讯速度根据实际情况选择就好了，最大不超过500K，默认是100K。主要的是我们需要定义几个函数，并将函数指针作为参数。这几个函数的类型如下：

　　typedef void (*SimuI2CSetPin)(SimuI2CPinValue op);        //设置SDA引脚

　　typedef uint8_t (*SimuI2CReadSDAPin)(void);                  //读取SDA引脚位

　　typedef void (*SimuI2CDelayus)(volatile uint32_t period);    //速度延时函数

　　对于这几个函数我们根据样式定义就可以了，具体的操作可能与使用的硬件平台有关系。具体函数定义如下：

 1 //设置SCL引脚
 2 static void SetSCLPin(SimuI2CPinValue op)
 3 {
 4   if(op==Set)
 5   {
 6     HAL_GPIO_WritePin(GPIOB，GPIO_PIN_8，GPIO_PIN_SET);
 7   }
 8   else
 9   {
10     HAL_GPIO_WritePin(GPIOB，GPIO_PIN_8，GPIO_PIN_RESET);
11   }
12 }
13  
14 //设置SDA引脚
15 static void SetSDAPin(SimuI2CPinValue op)
16 {
17   if(op==Set)
18   {
19     HAL_GPIO_WritePin(GPIOB，GPIO_PIN_7，GPIO_PIN_SET);
20   }
21   else
22   {
23     HAL_GPIO_WritePin(GPIOB，GPIO_PIN_7，GPIO_PIN_RESET);
24   }
25 }
26  
27 //读取SDA引脚位
28 static uint8_t ReadSDAPin(void)
29 {
30   return (uint8_t)HAL_GPIO_ReadPin(GPIOB，GPIO_PIN_7);
31 }

　　对于延时函数我们可以采用各种方法实现。我们采用的STM32平台和HAL库则可以直接使用HAL_Delay()函数。于是我们可以调用初始化函数如下：

　　SimuI2CInitialization(&simuI2C，100，SetSCLPin，SetSDAPin，ReadSDAPin，HAL_Delay);

　　这里我们将其设为100的I2C通讯接口。

3.2、基于对象进行操作

　　我们定义了对象变量并使用初始化函数给其作了初始化。接着我们就来考虑操作这一对象获取我们想要的数据。我们在驱动中已经封装了读从站、写从站以及读写混合操作，接下来我们使用这一驱动开发我们的应用实例。

　　这里我们考虑使用驱动读写一个I2C接口的存储器，我们向某一个地址写入数据和读出数据，我们假定存储器较小地址是8位的。

 1 //从Memery中读取数据
 2 void ReadDataFromMem(uint8_t deviceAddress， uint8_t memAdd，uint8_t *rData， uint16_t rSize)
 3 {    
 4        WriteReadDataBySimuI2C(&simuI2C，deviceAddress，&memAdd，1，rData，rSize);
 5 }
 6  
 7 //向Memery中写数据
 8 void WriteDataToMem(uint8_t deviceAddress，uint8_t memAdd，uint8_t *wData，uint16_t wSize)
 9 {
10        uint8_t data[10];
11        uint16_t size=0;
12       
13        data[size++]=memAdd;
14       
15        for(int i=0;i<wSize;i++)
16        {
17               data[size++]=wData[i];
18        }
19       
20        WriteDataBySimuI2C(&simuI2C，deviceAddress，wData，size);
21 }

　　在这一例中，我们实现了对8位地址的存储器的数据写入和读出操作，根据封装的驱动函数很容易实现。

4、应用总结

　　我们使用GPIO模拟的I2C协议在STM32平台上与多个设备进行通讯，如SHT20温湿度传感器、TSEV01CL55红外温度传感器、MLX90614红外温度传感器等，等到的结果非常好，即使在长达1米的通讯线路上都没有问题。

　　使用本驱动是需要注意一点，因为在I2C总线中SDA是双向的，所以在模拟式需要将模拟SDA的引脚配置为开漏模式，否则就需要控制其方向。

　　说到I2C总线有几个相关的总线不能不提，系统管理总线SMBus、电源系统管理总线PMBus以及TWI Bus。这些总线与I2C总线有很多的共同点，在通讯速率一致的情况下是可以通用的。

 　　完整的源代码可在GitHub下载：https://github.com/foxclever/ExPeriphDriver

欢迎关注：

 

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/foxclever/p/13121097.html