手把手教你用GPIO模拟I2C通信(附STM32代码示例)

手把手教你写gpio模拟i2c协议 最近,投影仪的项目上用到了三轴陀螺仪(G-sensor),通过获取陀螺仪X,Y,Z的坐标来实现梯形校正的功能,硬件上使用的通信接口是i2c接口。 阅读详情

手把手教你用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和停止信号。

连续读取的流程如下:

  1. 启动 -> 发送设备地址(写) -> 发送起始寄存器地址 -> 重启 -> 发送设备地址(读)。
  2. 主机开始读取第一个字节,读取后发送ACK,告诉从机“请继续发送下一个字节”。
  3. 主机读取第二个字节,发送ACK。
  4. ... 重复此过程 ...
  5. 主机读取最后一个字节,读取后发送NACK,告诉从机“够了,停止发送”。
  6. 主机发送停止信号。

下面是一个从某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驱动。

学习:GPIO口模拟I2C 什么是 GPIO口模拟I2C?     就是用一个GPIO pin(CLK pin)的高低电位切换来模拟出始终的high/low,用另外一根GPIO pin(DATA pin)的高低电位,传递数据。      IIC本来是一个硬件模块之间的通信协议,一般芯片都有专门的电路逻辑块来处理协议,并通过两根线路(时钟SCk、数据SDA)来跟其余同样有IIC模块的器件通信。      阅读详情

相关推荐

IIC通讯(软件模拟+硬件IIC)

并检查EV8事件。

weixin_58819477的博客 1661

I2C总线的深入理解与GPIO模拟I2C

学习I2C(Inter-Integrated Circuit)可以从以下步骤开始:1.1.了解I2C的基本原理和工作方式:I2C是一种串行通信协议,用于在集成电路之间传输数据。它使用两根线(数据线和时钟线)进行通信,支持多个设备通过总线连接。学习I2C的基本原理和信号传输过程是理解和应用它的关键。1.2.学习I2C的协议规范:深入研究I2C的协议规范,包括数据传输格式、起始和停止条件、地址分配、数据传输速率等。了解这些规范将帮助你正确地配置和操作I2C设备。

Vincent_Liang的博客 5861

STM32的I2C通信

STM32的两个GPIO引脚,分别用于SCL和SDA,按照I2C规约的时序,像控制LED灯那样控制引脚输出,若是接收数据时则读取SDA线上的电平,那就可以实现I2C通信了,这也是我们在51单片机上的“软件模拟协议”做法。但是STM32上还配有I2C控制器片上外设,只要配置好该外设,它就可以依据规约产生通讯信号。收/发数据置于缓存寄存器中,cpu只要检测该外设的状态和数据寄存器就能完成数据收发。但是利

echo_bright_的博客 3万+

【I2C】Linux使用GPIO模拟I2C

在Linux项目中,如果出现硬件硬件I2C不够用的情况下,我们就可以通过GPIO模拟I2C来解决。Lnux内核的i2c-gpio是使用GPIO模拟I2C协议的驱动,在内核中已经实现了,我们要做的只需要配置2个GPIO(SDA和SCL)即可。i2c-gpioi2c-gpio.c解析设备树中的引脚配置信息提供GPIO SDA和SCL引脚配置接口。向I2C Core注册一个adapter提供I2C通信时的算法,然后通过i2c-gpio.c提供GPIO配置接口来收发数据。注册成功后,

ZHONGCAI0901的博客 8317

[STM32]——软件模拟I2C

目录 软件模拟I2C概述 软件模拟I2C程序 I2C延时函数 I2C对应的GPIO配置和宏定义 I2C起始信号 I2C停止信号 I2C应答信号相关时序图 I2C等待应答信号 I2C应答信号 I2C非应答信号 I2C的GPIO初始化配置 I2C发送数据(根据数据有效性)​ I2C读取数据 检测I2C总线设备 I2C读写EEPROM实验 EEPROM宏定义 检测EEPROM外设是否正常 EEPROM读取数据 EEPROM写入数据 软件模拟I2C概述 很多人...

qq_43460068的博客 1万+

STM32——通过GPIO来模拟I2C

I2C总线是一种同步、双向、半双工的串行总线,通信双方只需要两条线就可以实现通信,非常方便。本文主要讲解如何通过IO口模拟的方式来实现I2C。

卜卜鸡的博客 4214

STM32硬件I2C与软件模拟I2C超详解

I2C协议时序详细解剖,硬件I2C的实现,已经软件模拟I2C的实现,以及EEPROM的详细介绍

k666499436的博客 8万+

STM32 通用GPIO模拟I2C实现

STM32 模拟I2C实现 #通用GPIO模拟I2C通信实现样例 1 GPIO初始化 `` #ifdef HW_I2C1 //硬件I2C初始化 //PA8-I2C1_SCL GPIO_StructInit(&GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; GPIO_InitStructure.GPIO_Speed...

u010361744的博客 7189

STM32通信模拟 I2C

19.1 关于I2C 19.1.1 I2C 协议 I²C(Inter-Integrated Circuit),常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计,用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议,常用于MPU/MCU与外部设备连接通信、数据传输。 I²C由两条线组成,一条双向串行数据线SDA,一条串行时钟线SCL。每个连接到总线的设备都有一个独立的地址,主机可以通过该地址来访问不同设备。因为I²C协议比较简单,常常用GPIO来模拟I

韦东山嵌入式专栏 8271

【STM32】软件I2C的使用 —— 看这一篇就够了(附代码)

欢迎来到我的博客。今天我想向大家介绍一下STM32软件I2C功能。首先,让我们来了解一下I2C(Inter-Integrated Circuit)总线。I2C是一种串行通信总线,最初由Philips公司开发。它允许多个设备使用同一条总线进行通信,并且每个设备都有唯一的地址。I2C通常用于连接微控制器、传感器和其他外设。在STM32中,I2C总线被实现为硬件和软件两种方式。硬件I2C功能可以直接使用STM32芯片上的I2C外设,而软件I2C需要通过编程实现。

soledade的博客 1万+

STM32 GPIO模拟实现I2C从机详细指南

STM32微控制器拥有一个高度灵活的中断系统,能够响应多个中断源。每个中断源都对应一个中断向量,它是中断服务程序(ISR)的入口地址。中断优先级决定了在多个中断同时发生时,哪个中断能够被首先处理。STM32允许中断优先级分组,可以设置抢占优先级和响应优先级,用以实现更精细的中断管理。// 中断优先级配置示例代码函数用于设置优先级分组,函数用于设置具体的中断优先级。参数指定了需要设置优先级的中断源。参数是抢占优先级,用于决定中断请求的紧急程度。

weixin_42097508的博客 1906

STM32软件模拟I2C从机的实现方法

本文基于STM32单片机详细讲解了软件模拟I2C从机的具体实现方法以及对应的代码实现例程。目前网络上模拟I2C一般都是模拟主机,这里补充了模拟I2C从机的具体实现思路。

goodrenze的专栏 1万+

STM32 GPIO端口模拟实现I2C通信协议

STM32微控制器是由STMicroelectronics(意法半导体)生产的一系列32位ARM Cortex-M微控制器。以其高性能、低功耗、丰富的外设和易于使用的特点,在工业控制、消费电子、医疗设备等领域广泛应用。本文将深入探讨STM32微控制器的特性,并带领读者理解如何使用GPIO端口模拟I2C通信,掌握STM32在实际应用中的高级技巧。为了充分利用STM32的强大功能,我们首先要了解其基本结构和工作原理。

weixin_29443363的博客 1076

硬件I2C与模拟I2C

硬件I2C对应芯片上的I2C外设,有相应I2C驱动电路,其所使用的I2C管脚也是专用的,因而效率要远高于软件模拟的I2C;一般也较为稳定,但是程序较为繁琐。硬件(固件)I2C是直接调用内部寄存器进行配置;而软件I2C是没有寄存器这个概念的。 软件I2C一般是使用GPIO管脚,用软件控制SCL,SDA线输出高低电平,模拟i2c协议的时序。 例如下面这段I2C的开始和结束信号,我们使用GPI...

Hsy的博客 1万+

RoboMaster机甲大师赛备赛:如何用STM32+CAN总线精准控制四个大疆3508电机?

本文详细介绍了在RoboMaster机甲大师赛中,如何利用STM32和CAN总线技术精准控制四台大疆3508电机。从硬件架构设计、多电机ID分配、数据解析到同步控制算法,全面解析了构建高响应、低延迟底盘驱动系统的关键技术,助力参赛队伍提升机器人运动性能。

weixin_28684825的博客 135

100多台物理GPU服务器,每台服务器上有8张GPU卡,组网

计算网用 IB/RoCEv2 保证低延迟高带宽,支撑 800+GPU 的分布式训练;管理网和存储网独立部署,避免干扰核心通信;全链路冗余和规范布线,确保集群稳定运行;搭配 Slurm/K8s 和监控工具,实现高效管理。该方案可支撑千亿参数大模型训练,且具备极强的扩展性,未来可平滑扩容至 200 + 台服务器。

weixin_42795092的博客 2023

模拟I2C怎么用--教你使用GPIO口模拟I2C总线协议

所谓模拟I2C是指使用普通GPIO口的输入输出功能来模拟I2C总线的时序,用来通过I2C总线进行通信。 I2C的基本知识: 1、I2C总线有两条线:SCL是时钟线,SDA是数据线; 2、I2C总线通信方式是主从模式,即由主设备发起通信,从设备响应通信; 3、I2C从设备具有I2C地址,从设备只有收到自己的地址信息后才会被唤醒; 4、具有不同地址的从设备可以挂载到同一个I2C总线上; 5...

Mr.How的专栏 2万+

基于stm32的数控恒压恒流电源设计方案

基于stm32的数控恒压恒流电源设计方案 基于stm32的数控恒压恒流电源设计方案 不包实物,可自己动手制作,可代做 本设计采用220V市电输入工频变压器,将220V交流电压降为24V交流电压,经过全桥整流加电容滤波,输出约32V直流电压.可调输出电压方案采用线性稳压调整器方案,即运放处于比较调整状态,运放输出驱动P型MOS管,电压输出端由电阻分压反馈至运放同相输入端,运放反相输入端由STM32单片机控制TLC5615数模转换器输入模拟电压,根据运放构成比较器原理,运放的同相端和反相端始终趋向于电压相等的特

m0_72265581的博客 7223

STM32基础回顾——详解I²C(GPIO模拟I2C)

文章目录前言IIC协议数据有效性开始信号和结束信号应答信号完整传输流程EEPROM介绍结构组成设备地址写AT24Cxx读AT24CxxIIC模拟硬件设计IIC模拟软件设计源码解析运行结果源码 前言 这一篇博客是根据自己的需要,以及为了面试岗位的需求,所以专门来再次学习一遍SPI和IIC两个常用的通信协议。这里使用的开发板是STM32F03_MIN 也希望这篇博客能对你有一定的帮助! IIC协议 I²C ,通常被读作“I方C”,它是一种多主从架构的串行通信总线。在1980年由飞利浦公司设计,用于让主板,嵌

m0_56145255的博客 9726

西安交通大学SQ轴承数据集(文末附数据)

西安交通大学SQ轴承数据集

qq_43271683的博客 1万+

钓鱼工具gophish史上最详细教程(附实例) —— 手把手教你成为“捕鱼人”

关于钓鱼工具 —— Gophish的超详细教程!

Ve99tr’s Blog 10万+

stm32 hal 模拟i2c

管脚配置(我是用的是PA9和PA10): //i2c.h #include "stm32f0xx_hal.h" #define GPIO_PORT_I2C GPIOA // GPIO端口 #define I2C_SCL_PIN SCL_Pin // 连接到SCL时钟线的GPIO #define I2C_SDA_PIN SDA_Pin // 连接到SD...

无聊达的博客 1万+

飞牛 NAS 部署 Hermes Agent 全指南:打造 24 小时在线、自我进化的 AI 智能体!

当大多数人还在把 AI 当聊天机器人使用时,我已经把它部署到了家里的飞牛 NAS 上,让它 24 小时在线工作、记忆我的习惯、自动执行任务,甚至还能不断学习新的技能。今天带你从零搭建这个真正属于自己的 AI Agent。🚀

XiaoqiangClub的博客 1235

STM32学习笔记-I2C通信协议

两根通信线SCL(时钟线)、SDA(数据线)同步半双工,支持总线挂载多设备。

八天一吨水的博客 5604

SAP SLT REODPS_REPL API 的使用介绍

本文聚焦 SAP 数据复制生态中的 RODPS_REPL(常被误写为 REODPS_REPL),解析其作为 ODP(Operational Data Provisioning)标准接口的核心功能与应用场景。RODPS_REPL 是 SAP 提供的 ABAP 接口集合,支持从 ODP 上下文(如 ODP_SAPI、ODP_CDS)执行初始化装载和增量捕获,被 SAP BW、Datasphere 及第三方工具(如 Azure Data Factory、Qlik Replicate)广泛调用。 关键要点: 核心对

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 231

基于嵌入式Linux设计的智能车库(GEC6818)

随着城市化进程的加快,传统停车管理方式存在效率低下、人工成本高、车主体验差等问题。为解决这些问题,本项目基于嵌入式Linux技术,设计并实现了一套智能车库管理系统。该系统采用GEC6818开发板作为核心控制器,运行Qt应用程序,并结合USB免驱摄像头进行车牌识别,RFID模块完成刷卡支付,SQLite数据库存储车主信息和停车记录。系统提供车主注册、用户管理、出入库管理、停车费结算、车辆查询等功能,并具备语音播报提示,提高用户体验。通过本系统,停车场管理更加高效、智能,有助于提升停车服务质量,减少人工干预,适

447
上一篇: Python实战:如何用ClickHouse高效存储通达信5分钟K线数据(附完整代码)
下一篇: 【网络】端口号分类与应用场景全解析
ruby5
博客等级 码龄15年 29粉丝 893原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值