手把手教你用GPIO模拟I2C通信(附STM32代码示例)
在嵌入式开发的世界里,I2C总线因其简洁的两线制(SDA和SCL)和强大的多主从能力,成为了连接各类传感器、存储器和外设的“血管”。然而,并非所有微控制器都配备了足够的硬件I2C外设,有时项目成本控制严格,选用的MCU恰好没有硬件I2C;有时硬件I2C引脚被其他功能占用,或者你需要同时与多个地址冲突的设备通信。这时,掌握用GPIO“软模拟”I2C协议的能力,就从一项备选技能变成了解决问题的关键钥匙。
这篇文章就是为你准备的,无论你是刚接触嵌入式的新手,还是需要在资源受限项目中寻找灵活方案的开发者。我们将彻底抛开对硬件外设的依赖,从最底层的时序逻辑开始,用两个普通的GPIO引脚,亲手搭建一个完整的I2C通信引擎。我会结合在STM32平台上的实战经验,提供可直接移植、易于调试的代码模块,并深入探讨单次读取与连续读取这两种核心操作模式的实现细节与适用场景。你会发现,模拟I2C不仅仅是“能用”,通过精心优化,它完全可以变得稳定、高效,满足大多数中低速应用的需求。
1. 理解I2C协议:模拟的基石
在动手写代码之前,我们必须像建筑师理解力学原理一样,吃透I2C协议的精髓。模拟实现本质上就是用软件精确地“演奏”出协议规定的时序乐章。任何时序上的偏差都可能导致通信失败,因此这一节是后续所有工作的基础。
I2C通信由主机(Master)发起和控制,它通过操纵时钟线(SCL) 和数据线(SDA) 的高低电平变化来传递信息。这两条线都是开源漏极(Open-Drain) 结构,这意味着它们只能被主动拉低到低电平,而依靠外部上拉电阻回到高电平。这种设计天然支持了“线与”功能,即多个设备可以同时驱动总线而不损坏硬件。在软件模拟时,我们通常将GPIO配置为推挽输出模式来模拟低电平,配置为高阻输入(或开漏输出且内部不拉高)模式来模拟释放总线(即高电平),以此契合开漏总线的特性。
一次完整的I2C数据传输包含以下几个基本信号单元:
- 起始条件(S):当SCL为高电平时,SDA出现一个从高到低的下降沿。这是通信开始的号角。
- 停止条件(P):当SCL为高电平时,SDA出现一个从低到高的上升沿。这标志着通信的终结。
- 数据位传输:在SCL为低电平期间,发送方可以改变SDA的数据位(准备数据)。在SCL为高电平期间,SDA的数据必须保持稳定,此时接收方采样数据位(读取数据)。数据按高位(MSB)在前的顺序传输。
- 应答(ACK)与非应答(NACK):每传输完一个字节(8位数据)后,会跟一个应答时钟脉冲。在这个脉冲期间,发送方会释放SDA线(变为输入模式),而接收方需要将SDA线拉低,以此表示成功接收(ACK)。如果接收方没有拉低SDA(保持高电平),则表示非应答(NACK),可能意味着接收失败或不再需要数据。
注意:模拟I2C时,最关键的挑战在于精确控制SCL高低电平的持续时间(即时钟周期)以及信号边沿之间的时序关系。不同的I2C设备对建立时间、保持时间有微妙的要求,这往往是调试的难点。
为了更清晰地对比硬件I2C与模拟I2C的核心差异,请看下表:
| 特性维度 | 硬件I2C外设 | 软件模拟I2C (GPIO) |
|---|---|---|
| 实现核心 | 专用硬件电路,由状态机自动处理 | CPU通过软件指令控制GPIO电平变化 |
| 开发复杂度 | 低,通常配置寄存器即可 | 高,需手动实现所有时序和状态逻辑 |
| 通信速率 | 高,通常可达400kHz (Fast Mode) 甚至更高 | 较低,受CPU速度和软件开销限制,几十到几百kHz |
| CPU占用率 | 低,数据传输由硬件完成,CPU可处理其他任务 | 高,通信期间CPU需持续参与控制 |
| 灵活性 | 较低,受硬件设计限制(如引脚固定) | 极高,任意GPIO引脚均可使用 |
| 可靠性 | 高,硬件处理抗干扰能力强 | 相对较低,易受软件中断、任务调度干扰 |
| 适用场景 | 高速、稳定、多任务并发的场景 | 低速、引脚资源受限、需要引脚复用的场景 |
理解了这些底层原理和差异,我们就能有的放矢地进行设计:在代码中,我们需要用延时函数来保证时序,用GPIO模式切换来模拟开漏行为,用循环和位操作来拼装数据帧。
2. 搭建你的模拟I2C驱动层:从引脚初始化到基本信号
现在,我们进入实战环节,以流行的STM32系列微控制器为例,构建一个稳健的模拟I2C驱动层。我将使用STM32CubeIDE的HAL库风格进行演示,但代码逻辑通用,可以轻松移植到其他平台或标准库。
首先,我们需要定义用于模拟I2C的两个GPIO引脚。选择两个具有外部上拉电阻(通常4.7kΩ)的普通IO口。
// i2c_gpio.h
#ifndef I2C_GPIO_H
#define I2C_GPIO_H
#include "stm32f1xx_hal.h" // 根据你的芯片型号包含对应的HAL头文件
// 定义模拟I2C使用的GPIO端口和引脚,请根据实际电路修改
#define I2Cx_SDA_GPIO_PORT GPIOB
#define I2Cx_SDA_GPIO_PIN GPIO_PIN_7
#define I2Cx_SCL_GPIO_PORT GPIOB
#define I2Cx_SCL_GPIO_PIN GPIO_PIN_6
// 引脚操作宏定义,提高代码可读性和执行效率
#define I2C_SDA_HIGH() HAL_GPIO_WritePin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_GPIO_PIN, GPIO_PIN_SET)
#define I2C_SDA_LOW() HAL_GPIO_WritePin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_GPIO_PIN, GPIO_PIN_RESET)
#define I2C_SCL_HIGH() HAL_GPIO_WritePin(I2Cx_SCL_GPIO_PORT, I2Cx_SCL_GPIO_PIN, GPIO_PIN_SET)
#define I2C_SCL_LOW() HAL_GPIO_WritePin(I2Cx_SCL_GPIO_PORT, I2Cx_SCL_GPIO_PIN, GPIO_PIN_RESET)
#define I2C_SDA_READ() HAL_GPIO_ReadPin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_GPIO_PIN)
// 设置SDA为输入模式(释放总线,读取外部电平)
#define I2C_SDA_IN() do{ GPIO_InitTypeDef gpio_init = {0}; \
gpio_init.Pin = I2Cx_SDA_GPIO_PIN; \
gpio_init.Mode = GPIO_MODE_INPUT; \
gpio_init.Pull = GPIO_NOPULL; \
HAL_GPIO_Init(I2Cx_SDA_GPIO_PORT, &gpio_init); } while(0)
// 设置SDA为输出模式(驱动总线)
#define I2C_SDA_OUT() do{ GPIO_InitTypeDef gpio_init = {0}; \
gpio_init.Pin = I2Cx_SDA_GPIO_PIN; \
gpio_init.Mode = GPIO_MODE_OUTPUT_OD; \
gpio_init.Pull = GPIO_NOPULL; \
gpio_init.Speed = GPIO_SPEED_FREQ_HIGH; \
HAL_GPIO_Init(I2Cx_SDA_GPIO_PORT, &gpio_init); } while(0)
// 基本延时函数,用于产生时序。需要根据你的系统时钟频率调整。
void I2C_Delay(void);
// 模拟I2C基础信号函数
void I2C_Start(void);
void I2C_Stop(void);
void I2C_Ack(void);
void I2C_NAck(void);
uint8_t I2C_Wait_Ack(void);
// 数据读写函数
void I2C_SendByte(uint8_t txd);
uint8_t I2C_ReadByte(void);
#endif
接下来,在源文件中实现最核心的时序控制和基本信号。这里的I2C_Delay函数是时序的灵魂,你需要通过示波器或逻辑分析仪来校准它,以确保满足目标速率(例如100kHz)的时序要求。
// i2c_gpio.c
#include "i2c_gpio.h"
// 简单的微秒级延时,实际项目中建议使用定时器或系统滴答定时器实现更精确的延时
void I2C_Delay(void)
{
// 这里是一个基于循环的空操作延时,非常不精确,仅作示意。
// 你需要根据你的CPU主频来计算循环次数,或使用`__NOP()`指令。
// 例如:for(int i=0; i<10; i++);
// 更好的做法是使用DWT(数据观察点跟踪单元)或通用定时器。
uint32_t i = 5; // 这个值需要实际测试调整
while(i--);
}
// 产生起始信号:SCL高电平期间,SDA产生一个下降沿
void I2C_Start(void)
{
I2C_SDA_OUT(); // 设置SDA为输出
I2C_SDA_HIGH();
I2C_SCL_HIGH();
I2C_Delay();
I2C_SDA_LOW(); // 在SCL高时拉低SDA,产生起始条件
I2C_Delay();
I2C_SCL_LOW(); // 钳住总线,准备发送数据
I2C_Delay();
}
// 产生停止信号:SCL高电平期间,SDA产生一个上升沿
void I2C_Stop(void)
{
I2C_SDA_OUT(); // 设置SDA为输出
I2C_SDA_LOW();
I2C_Delay();
I2C_SCL_HIGH();
I2C_Delay();
I2C_SDA_HIGH(); // 在SCL高时拉高SDA,产生停止条件
I2C_Delay();
}
// 主机产生ACK信号(在读取数据后,如果还想继续读,则发送ACK)
void I2C_Ack(void)
{
I2C_SCL_LOW();
I2C_SDA_OUT();
I2C_SDA_LOW(); // 拉低SDA,表示ACK
I2C_Delay();
I2C_SCL_HIGH();
I2C_Delay();
I2C_SCL_LOW();
}
// 主机产生NACK信号(读取最后一个字节后,发送NACK)
void I2C_NAck(void)
{
I2C_SCL_LOW();
I2C_SDA_OUT();
I2C_SDA_HIGH(); // 保持SDA高,表示NACK
I2C_Delay();
I2C_SCL_HIGH();
I2C_Delay();
I2C_SCL_LOW();
}
// 主机等待从机应答,返回0表示收到ACK,返回1表示收到NACK或超时
uint8_t I2C_Wait_Ack(void)
{
uint8_t ucErrTime = 0;
I2C_SDA_IN(); // 设置SDA为输入,释放总线,等待从机拉低
I2C_SDA_HIGH(); // 确保内部上拉关闭(对于推挽模式,此操作无效,但遵循流程)
I2C_Delay();
I2C_SCL_HIGH();
I2C_Delay();
while(I2C_SDA_READ()) // 检测SDA是否被从机拉低
{
ucErrTime++;
if(ucErrTime > 250) // 超时判断
{
I2C_Stop(); // 超时则发送停止信号
return 1;
}
}
I2C_SCL_LOW(); // 收到ACK,拉低SCL结束应答周期
return 0;
}
有了这些基础信号函数,构建字节读写函数就水到渠成了。它们将8位数据的传输分解为8个时钟周期。
// 发送一个字节,返回从机是否应答(0:ACK, 1:NACK)
// 实际上,我们通常在外部调用I2C_Wait_Ack()来检查应答
void I2C_SendByte(uint8_t txd)
{
uint8_t t;
I2C_SDA_OUT(); // 设置为输出模式
I2C_SCL_LOW(); // 拉低时钟开始数据传输
for(t = 0; t < 8; t++)
{
// 在SCL低电平期间准备数据位
if((txd & 0x80) >> 7) // 判断最高位
I2C_SDA_HIGH();
else
I2C_SDA_LOW();
txd <<= 1; // 左移,准备下一位
I2C_Delay();
I2C_SCL_HIGH(); // 拉高SCL,从机在此时采样数据
I2C_Delay();
I2C_SCL_LOW(); // 拉低SCL,为下一位数据准备
I2C_Delay();
}
}
// 读取一个字节,参数ack_flag决定读取后主机是否发送ACK
// ack_flag=0: 发送ACK,表示还要继续读
// ack_flag=1: 发送NACK,表示这是最后一个字节
uint8_t I2C_ReadByte(uint8_t ack_flag)
{
uint8_t i, receive = 0;
I2C_SDA_IN(); // 设置SDA为输入,准备读取
for(i = 0; i < 8; i++)
{
receive <<= 1; // 左移接收字节
I2C_SCL_LOW();
I2C_Delay();
I2C_SCL_HIGH(); // 拉高SCL,主机在此时采样数据
I2C_Delay();
if(I2C_SDA_READ())
receive++;
I2C_SCL_LOW();
I2C_Delay();
}
// 读取完成后,主机发送ACK或NACK
if(!ack_flag)
I2C_Ack(); // 发送ACK
else
I2C_NAck(); // 发送NACK
return receive;
}
至此,一个最基础的、可用的模拟I2C驱动层就搭建完毕了。你可以用逻辑分析仪抓取I2C_Start()、I2C_SendByte(0xA0)等函数产生的波形,与标准I2C时序图进行比对,这是验证驱动是否正确的最直观方法。
3. 实现核心操作:单次读取与连续读取模式
驱动层准备好了,就像有了砖瓦和钢筋。现在我们要用它们来盖房子,实现两种最常用的“户型”:单次读取和连续读取。这两种模式的选择,直接影响到通信的效率和代码的逻辑。
单次读取模式,顾名思义,就是一次通信流程只读取一个(或少数几个)字节的数据。它的流程非常规整:启动->发送设备地址(写)->发送寄存器地址->重启->发送设备地址(读)->读取一个字节->发送NACK->停止。这种模式适合读取传感器的一个状态寄存器、EEPROM的一个地址单元等场景。优点是逻辑简单,每次操作独立,互不影响;缺点是如果读取大量连续数据,频繁的启动停止信号会带来大量开销,效率低下。
下面是一个读取某I2C温度传感器(假设地址0x48)当前温度值的单次读取示例:
/**
* @brief 从I2C设备单次读取一个字节
* @param dev_addr: 从机设备地址(7位)
* @param reg_addr: 要读取的寄存器地址
* @param p_data: 指向存储读取数据的变量的指针
* @retval 0: 成功, 1: 失败(设备无应答)
*/
uint8_t I2C_SingleReadByte(uint8_t dev_addr, uint8_t reg_addr, uint8_t *p_data)
{
uint8_t status = 0;
I2C_Start(); // 发送起始信号
// 第一阶段:发送设备地址(写操作),准备写入寄存器地址
I2C_SendByte(dev_addr << 1); // 左移一位,最低位为0表示写
if(I2C_Wait_Ack()) { status = 1; goto end; } // 等待从机应答
// 发送要读取的寄存器地址
I2C_SendByte(reg_addr);
if(I2C_Wait_Ack()) { status = 1; goto end; }
// 第二阶段:发送重复起始信号,切换为读操作
I2C_Start(); // 发送重复起始信号(和起始信号波形一样)
// 发送设备地址(读操作)
I2C_SendByte((dev_addr << 1) | 0x01); // 最低位为1表示读
if(I2C_Wait_Ack()) { status = 1; goto end; }
// 读取一个字节的数据,读取后发送NACK表示结束
*p_data = I2C_ReadByte(1); // 参数1表示发送NACK
end:
I2C_Stop(); // 无论成功与否,都发送停止信号释放总线
return status;
}
连续读取模式则高效得多。它适用于需要从设备连续地址读取多个字节的场景,比如从EEPROM读取一段数据,或者从传感器读取多通道的ADC值。其核心思想是,在主机发送完起始地址后,从机会自动递增内部地址指针,主机可以连续读取多个字节,只在最后一个字节后发送NACK和停止信号。
连续读取的流程如下:
- 启动 -> 发送设备地址(写) -> 发送起始寄存器地址 -> 重启 -> 发送设备地址(读)。
- 主机开始读取第一个字节,读取后发送ACK,告诉从机“请继续发送下一个字节”。
- 主机读取第二个字节,发送ACK。
- ... 重复此过程 ...
- 主机读取最后一个字节,读取后发送NACK,告诉从机“够了,停止发送”。
- 主机发送停止信号。
下面是一个从某I2C EEPROM(假设地址0xA0)连续读取多个字节的函数实现:
/**
* @brief 从I2C设备连续读取多个字节
* @param dev_addr: 从机设备地址(7位)
* @param reg_addr: 起始寄存器地址
* @param p_buffer: 指向存储读取数据缓冲区的指针
* @param length: 要读取的字节数
* @retval 0: 成功, 1: 失败(设备无应答)
*/
uint8_t I2C_SequentialRead(uint8_t dev_addr, uint8_t reg_addr, uint8_t *p_buffer, uint16_t length)
{
uint8_t status = 0;
uint16_t i = 0;
if(length == 0) return 0; // 无需读取
I2C_Start();
// 第一阶段:发送设备地址(写),并写入要读取的起始地址
I2C_SendByte(dev_addr << 1); // 写操作
if(I2C_Wait_Ack()) { status = 1; goto end; }
I2C_SendByte(reg_addr);
if(I2C_Wait_Ack()) { status = 1; goto end; }
// 第二阶段:发送重复起始信号,切换为读操作
I2C_Start();
I2C_SendByte((dev_addr << 1) | 0x01); // 读操作
if(I2C_Wait_Ack()) { status = 1; goto end; }
// 第三阶段:连续读取数据
for(i = 0; i < length; i++)
{
if(i == (length - 1))
{
// 读取最后一个字节,发送NACK
p_buffer[i] = I2C_ReadByte(1); // 发送NACK
}
else
{
// 读取非最后一个字节,发送ACK
p_buffer[i] = I2C_ReadByte(0); // 发送ACK
}
}
end:
I2C_Stop();
return status;
}
在实际项目中,我遇到过一些I2C设备(如某些OLED屏幕的驱动芯片)在连续读取时,对ACK/NACK的时序要求特别严格。如果I2C_ReadByte函数中发送ACK/NACK后拉低SCL的延时不够,可能会导致下一个字节的第一个位丢失。这时就需要用逻辑分析仪仔细捕捉波形,微调I2C_Delay的时长,或者检查ACK/NACK子函数中SCL高低电平的顺序是否完全符合数据手册的要求。
4. 进阶优化与实战调试技巧
一个能跑的模拟I2C驱动只是起点,要让它在实际产品中稳定可靠地工作,还需要进行一系列优化,并掌握有效的调试方法。这一节分享一些我踩过坑后总结的经验。
首先,优化时序和抗干扰能力。 前面提到的I2C_Delay函数是性能瓶颈。用空循环延时不仅不准,还会在CPU频率变化时(如切换低功耗模式)彻底失效。最优解是使用硬件定时器产生精确的微秒级延时。如果资源紧张,可以使用系统滴答定时器(SysTick)来构建一个更可靠的延时函数。此外,在关键信号(Start, Stop, 数据位变化)前后增加短暂延时,可以提高在长导线或干扰环境下的稳定性。
// 示例:使用SysTick实现微秒延时(假设系统时钟为72MHz)
void I2C_Delay_us(uint32_t us)
{
uint32_t ticks = us * (SystemCoreClock / 1000000);
uint32_t start_tick = SysTick->VAL;
uint32_t cur_tick;
do {
cur_tick = SysTick->VAL;
// 注意SysTick是向下计数的
if(cur_tick > start_tick) {
// 发生了重载
if((start_tick + ticks) > SysTick->LOAD) {
break;
}
}
} while((start_tick - cur_tick) < ticks);
}
其次,增加超时和错误重试机制。 工业环境中,总线可能受到瞬时干扰。一个健壮的驱动应该在I2C_Wait_Ack等关键环节加入超时判断(前面的示例代码已有),并在整个读写函数外层封装重试逻辑。例如,连续三次读写失败,再向上层报告错误,而不是一次失败就放弃。
#define I2C_MAX_RETRY 3
uint8_t I2C_WriteWithRetry(uint8_t dev_addr, uint8_t reg_addr, uint8_t data)
{
uint8_t retry = I2C_MAX_RETRY;
uint8_t status;
do {
status = I2C_SingleWriteByte(dev_addr, reg_addr, data); // 假设有这个写函数
if(status == 0) { // 成功
return 0;
}
retry--;
HAL_Delay(1); // 失败后短暂延时再重试
} while(retry > 0);
// 记录日志或触发错误处理
return 1; // 最终失败
}
调试是嵌入式开发的必修课。 对于模拟I2C,没有比逻辑分析仪更好用的工具了。连接逻辑分析仪的通道到SDA和SCL线,设置触发条件为起始信号,你可以清晰地看到:
- 起始信号和停止信号的波形是否标准。
- 设备地址和读写位是否正确。
- 每一个数据位和ACK/NACK位是否在正确的时钟沿出现。
- 时序间隔(如SCL高低电平时间、数据建立保持时间)是否满足从机设备数据手册的要求。
如果手头没有逻辑分析仪,也可以用两个GPIO模拟“软件逻辑分析仪”,将SDA和SCL的状态实时打印到串口,或者用另一个GPIO引脚在关键代码处产生脉冲,用示波器观察,这都是可行的土办法。
最后,注意多任务环境下的互斥访问。 如果你的系统运行了RTOS,模拟I2C总线作为一个共享资源,必须被保护起来。在I2C_Start()之前获取信号量或互斥锁,在I2C_Stop()之后释放,确保同一时刻只有一个任务在操作I2C总线,避免时序混乱。
// 伪代码,以FreeRTOS为例
SemaphoreHandle_t xI2CSemaphore;
uint8_t I2C_ReadProtected(...)
{
if(xSemaphoreTake(xI2CSemaphore, pdMS_TO_TICKS(100)) == pdTRUE)
{
// 执行实际的I2C读取操作
result = I2C_SequentialRead(...);
xSemaphoreGive(xI2CSemaphore);
return result;
}
else
{
// 获取信号量超时,处理错误
return ERROR_TIMEOUT;
}
}
模拟I2C的灵活性也带来了更多的责任。你需要仔细阅读你所用从机设备的数据手册,确认其是否支持标准模式(100kHz)、快速模式(400kHz)或更高速率。模拟实现通常很难达到400kHz,尤其是在主频不高的MCU上。这时,你可能需要在代码中为不同的设备提供不同的延时参数,实现一个可配置速率的模拟I2C驱动。
1661



被折叠的 条评论
为什么被折叠?



