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

最新推荐文章于 2024-07-07 13:22:09 发布
置顶 最新推荐文章于 2024-07-07 13:22:09 发布
阅读量1.7w 收藏 237
点赞数 38
分类专栏： 怎么用 文章标签： I2C GPIO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaocaohuyang/article/details/90313636
版权

所谓模拟I2C是指使用普通GPIO口的输入输出功能来模拟I2C总线的时序，用来通过I2C总线进行通信。

I2C的基本知识：

1、I2C总线有两条线：SCL是时钟线，SDA是数据线；

2、I2C总线通信方式是主从模式，即由主设备发起通信，从设备响应通信；

3、I2C从设备具有I2C地址，从设备只有收到自己的地址信息后才会被唤醒；

4、具有不同地址的从设备可以挂载到同一个I2C总线上；

5、从设备地址的最后一个Bit表示读写，0表示写操作，1表示读操作；

6、I2C总线地址有7Bit表示方法和8Bit表示方法，7Bit表示方法是地址中不包含表示读写的最后一个Bit；

7、当SCL=1时，SDA产生下降沿来启动I2C；

8、当SCL=1时，SDA产生上升沿来停止I2C；

9、I2C启动后，当SCL=1时，SDA的电平不允许有变化；

10、I2C启动后，只有当SCL=0时，数据发送方才能在SDA上改变发送电平；

11、I2C总线上数据接收方在接收完一个字节数据（8Bit）后，要在下一个SCL的上升沿，通过SDA响应ACK(SDA=0)或NACK(SDA=1)信号；

12、I2C外部需根据传输速率匹配上拉电阻，速率越高，上拉电阻越小，否则会影响时序；

13、I2C引脚作为输出时需是开漏输出，作为输入时需是浮空输入，不能匹配内部上拉或下拉电阻；

 

话不多说，直接上代码：

一、基本接口定义

        为了提高代码的可移植性和使用方便性，我定义了一些宏和结构体，下面介绍一下这些宏和结构体。

1、结构体

        I2C总线有SDA和SCL两个引脚，所以我构造了一个结构体来定义表示这两个引脚的基本信息，我是在STM32平台做的例程，所以是这样定义的：

typedef struct {
    uint32_t SDA_RCC_APB2Periph;// SDA脚时钟
    GPIO_TypeDef* SDA_Port;//SDA脚Port
    uint16_t SDA_Pin;//SDA脚Pin
    
    uint32_t SCL_RCC_APB2Periph;//SCL脚时钟
    GPIO_TypeDef* SCL_Port;//SCL脚Port
    uint16_t SCL_Pin;//SCL脚Pin
} sw_i2c_gpio_t;

        当然如果你使用的是其他平台，可以对结构体进行重新构造。结构体的成员要能拿来直接控制两个引脚的输入和输出即可。

2、宏定义

#define I2C_USE_7BIT_ADDR //如果使用的从机地址是7Bit模式，则打开这个宏，否则注释掉这个宏
#define I2C_DELAY                50 // I2C每个Bit之间的延时时间，延时越小I2C的速率越高

 

下面这些宏要根据具体的平台进行调整。

#define SW_I2C_SCL_LOW          GPIO_ResetBits(gpio->SCL_Port,gpio->SCL_Pin) // I2C SCL脚输出0
#define SW_I2C_SCL_HIGH         GPIO_SetBits(gpio->SCL_Port,gpio->SCL_Pin) // I2C SCL脚输出1
#define SW_I2C_SDA_LOW          GPIO_ResetBits(gpio->SDA_Port,gpio->SDA_Pin) // I2C SDA脚输出0
#define SW_I2C_SDA_HIGH         GPIO_SetBits(gpio->SDA_Port,gpio->SDA_Pin) // I2C SDA脚输出1
#define SW_I2C_SDA_INPUT        sw_i2c_set_sda_input(gpio) // 将SDA脚方向设置为输入
#define SW_I2C_SDA_OUTPUT        sw_i2c_set_sda_output(gpio) // 将SDA脚方向设置为输出
#define SW_I2C_SDA_STATUS        sw_i2c_sda_status(gpio) // 获取SDA脚输入电平状态  
  
#define i2c_delay_us(a)            SystemDelayUs(a) // 获取SDA脚输入电平状态

一、I2C基本操作实现

1、SDA脚输入输出切换及输入状态读取

/**************************************************************************
***                          读取SDA脚的状态                             ***
***************************************************************************/
static uint8_t sw_i2c_sda_status(sw_i2c_gpio_t *gpio)
{
    uint8_t sda_status;
    
    sda_status = GPIO_ReadInputDataBit(gpio->SDA_Port,gpio->SDA_Pin);    
    return sda_status?1:0;
}
/**************************************************************************
***                          设置SDA脚为输入                             ***
***************************************************************************/
static void sw_i2c_set_sda_input(sw_i2c_gpio_t *gpio)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    GPIO_InitStructure.GPIO_Pin = gpio->SDA_Pin;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入模式
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init (gpio->SDA_Port, & GPIO_InitStructure );
}
/**************************************************************************
***                          设置SDA脚为输出                             ***
***************************************************************************/
static void sw_i2c_set_sda_output(sw_i2c_gpio_t *gpio)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    GPIO_InitStructure.GPIO_Pin = gpio->SDA_Pin;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;   //开漏输出模式
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init (gpio->SDA_Port, & GPIO_InitStructure );
}

2、I2C启动

static void sw_i2c_start(sw_i2c_gpio_t *gpio)
{
    // I2C 开始时序：SCL=1时，SDA由1变成0.
    SW_I2C_SDA_HIGH;         
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_HIGH;           
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SDA_LOW;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_LOW;
    i2c_delay_us(I2C_DELAY);
}

3、I2C停止

static void sw_i2c_stop(sw_i2c_gpio_t *gpio)
{
    // I2C 开始时序：SCL=1时，SDA由0变成1.
    SW_I2C_SDA_LOW;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_HIGH;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SDA_HIGH;
}

4、等待数据接收方反馈ACK

static uint8_t sw_i2c_wait_ack(sw_i2c_gpio_t *gpio)
{
    uint8_t sda_status;
    uint8_t wait_time=0;
    uint8_t ack_nack = 1;
    
    //先设置SDA脚为输入
    SW_I2C_SDA_INPUT;
    //等待SDA脚被从机拉低
    while(SW_I2C_SDA_STATUS)
    {
        wait_time++;
        //如果等待时间过长，则退出等待
        if (wait_time>=200)
        {
            ack_nack = 0;
            break;
        }
    }
    // SCL由0变为1，读入ACK状态
    // 如果此时SDA=0，则是ACK
    // 如果此时SDA=1，则是NACK
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_HIGH;
    i2c_delay_us(I2C_DELAY);
    
    //再次将SCL=0，并且将SDA脚设置为输出
    SW_I2C_SCL_LOW;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SDA_OUTPUT;
    i2c_delay_us(I2C_DELAY);
    return ack_nack;
}

5、发送ACK给数据发送方

static void sw_i2c_send_ack(sw_i2c_gpio_t *gpio)
{
    // 发送ACK就是在SDA=0时，SCL由0变成1
    SW_I2C_SDA_LOW;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_HIGH;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_LOW;
    i2c_delay_us(I2C_DELAY);
}

6、发送NACK给数据发送方

static void sw_i2c_send_nack(sw_i2c_gpio_t *gpio)
{
    // 发送NACK就是在SDA=1时，SCL由0变成1
    SW_I2C_SDA_HIGH;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_HIGH;
    i2c_delay_us(I2C_DELAY);
    SW_I2C_SCL_LOW;
    i2c_delay_us(I2C_DELAY);
}

7、主设备向从设备写一个字节

static void sw_i2c_write_byte(sw_i2c_gpio_t *gpio,uint8_t aByte)
{
    uint8_t i;
    for (i=0;i<8;i++)
    {
        //先将SCL拉低；
        SW_I2C_SCL_LOW;
        i2c_delay_us(I2C_DELAY);
        //然后在SDA输出数据
        if(aByte&0x80)
        {
            SW_I2C_SDA_HIGH;
        }
        else
        {
            SW_I2C_SDA_LOW;
        }
        i2c_delay_us(I2C_DELAY);
        //最后将SCL拉高，在SCL上升沿写入数据
        SW_I2C_SCL_HIGH;
        i2c_delay_us(I2C_DELAY);
        
        aByte = aByte<<1;//数据位移
    }
    //写完一个字节只后要将SCL拉低
    SW_I2C_SCL_LOW;
    i2c_delay_us(I2C_DELAY);
}

8、主设备从从设备读一个字节

static uint8_t sw_i2c_read_byte(sw_i2c_gpio_t *gpio)
{
    uint8_t i,aByte;
    
    //先将SDA脚设置为输入
    SW_I2C_SDA_INPUT;
    for (i=0;i<8;i++)
    {
        //数据位移
        aByte = aByte << 1;
        //延时等待SDA数据稳定
        i2c_delay_us(I2C_DELAY);
        //SCL=1，锁定SDA数据
        SW_I2C_SCL_HIGH;
        i2c_delay_us(I2C_DELAY);
        //读取SDA状态
        if(SW_I2C_SDA_STATUS)
        {
            aByte |= 0x01;
        }
        //SCL=0，解除锁定
        SW_I2C_SCL_LOW;
    }
    //读完一个字节，将SDA重新设置为输出
    SW_I2C_SDA_OUTPUT;
    return aByte;
}

二、I2C传输数据函数实现

1、模拟I2C初始化

void sw_i2c_init(sw_i2c_gpio_t *gpio)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd ( gpio->SCL_RCC_APB2Periph, ENABLE );                                                                
    GPIO_InitStructure.GPIO_Pin = gpio->SCL_Pin;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;   //开漏输出模式   
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init (gpio->SCL_Port, & GPIO_InitStructure );
    
    RCC_APB2PeriphClockCmd ( gpio->SDA_RCC_APB2Periph, ENABLE );                                                                
    GPIO_InitStructure.GPIO_Pin = gpio->SDA_Pin;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;   //开漏输出模式  
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init (gpio->SDA_Port, & GPIO_InitStructure );
    
    SW_I2C_SCL_HIGH;
    SW_I2C_SDA_HIGH;
}

2、主设备向从设备写N个字节数据

void sw_i2c_write_nBytes(sw_i2c_gpio_t *gpio,uint8_t i2c_addr,uint8_t *data,uint8_t len)
{
    uint8_t j;
    
    //如果使用的是7bit地址，需要左位移一位
#ifdef I2C_USE_7BIT_ADDR
    i2c_addr = i2c_addr<<1;
#endif
    
    //启动I2C
    sw_i2c_start(gpio);
    //写I2C从机地址，写操作
    sw_i2c_write_byte(gpio,i2c_addr);
    //如果从机响应ACC则继续，如果从机未响应ACK则停止
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    
    //开始写n个字节数据
    for (j=0;j<len;j++)
    {
        sw_i2c_write_byte(gpio,data[j]);
        // 每写一个字节数据后，都要等待从机回应ACK
        if (!sw_i2c_wait_ack(gpio))
            goto err;
    }
    
    //停止I2C
    err:
    sw_i2c_stop(gpio);
}

3、主设备从从设备读取N个字节数据

void sw_i2c_read_nBytes(sw_i2c_gpio_t *gpio,uint8_t i2c_addr,uint8_t *buf,uint8_t len)
{
    uint8_t j;
    
    //如果使用的是7bit地址，需要左位移一位
#ifdef I2C_USE_7BIT_ADDR
    i2c_addr = i2c_addr<<1;
#endif
    
    //启动I2C
    sw_i2c_start(gpio);
    //写I2C从机地址，读操作
    sw_i2c_write_byte(gpio,i2c_addr|0x01);
    //如果从机响应ACC则继续，如果从机未响应ACK则停止
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    //开始读n个字节数据
    for (j=0;j<len;j++)
    {
        buf[j]=sw_i2c_read_byte(gpio);
        // 每读一个字节数据后，都要发送ACK给从机
        sw_i2c_send_ack(gpio);
    }
    
    //停止I2C
    err:
    sw_i2c_stop(gpio);
}

4、主设备向从设备16Bit长度的寄存器地址读取N个字节

void sw_i2c_send2read_16bit(sw_i2c_gpio_t *gpio,uint8_t i2c_addr,uint16_t reg,uint8_t *buf,uint8_t len)
{
    uint8_t j;
    
    //如果使用的是7bit地址，需要左位移一位
#ifdef I2C_USE_7BIT_ADDR
    i2c_addr = i2c_addr<<1;
#endif
    //启动I2C
    sw_i2c_start(gpio);
    //写I2C从机地址，写操作
    sw_i2c_write_byte(gpio,i2c_addr);
    //如果从机响应ACC则继续，如果从机未响应ACK则停止
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    
    //写寄存器地址高8位
    sw_i2c_write_byte(gpio,(reg>>8)&0xff);
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    //写寄存器地址低8位
    sw_i2c_write_byte(gpio,reg&0xff);
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    
    //重新启动I2C
    sw_i2c_start(gpio);
    //写I2C从机地址，读操作
    sw_i2c_write_byte(gpio,i2c_addr|0x01);
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    //开始读n个字节数据
    for (j=0;j<len;j++)
    {
        buf[j]=sw_i2c_read_byte(gpio);
        // 每读一个字节数据后，都要发送ACK给从机
        sw_i2c_send_ack(gpio);
    }
    //停止I2C
    err:
    sw_i2c_stop(gpio);
}

5、主设备向从设备8Bit长度的寄存器地址读取N个字节

void sw_i2c_send2read_8bit(sw_i2c_gpio_t *gpio,uint8_t i2c_addr,uint8_t reg,uint8_t *buf,uint8_t len)
{
    uint8_t j;
    
    //如果使用的是7bit地址，需要左位移一位
#ifdef I2C_USE_7BIT_ADDR
    i2c_addr = i2c_addr<<1;
#endif
    //启动I2C
    sw_i2c_start(gpio);
    //写I2C从机地址，写操作
    sw_i2c_write_byte(gpio,i2c_addr);
    //如果从机响应ACC则继续，如果从机未响应ACK则停止
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    
    //写寄存器地址
    sw_i2c_write_byte(gpio,reg);
        if (!sw_i2c_wait_ack(gpio))
            goto err;
    
    //重新启动I2C
    sw_i2c_start(gpio);
    //写I2C从机地址，读操作
    sw_i2c_write_byte(gpio,i2c_addr|0x01);
    if (!sw_i2c_wait_ack(gpio))
        goto err;
    //开始读n个字节数据
    for (j=0;j<len;j++)
    {
        buf[j]=sw_i2c_read_byte(gpio);
        // 每读一个字节数据后，都要发送ACK给从机
        sw_i2c_send_ack(gpio);
    }
    //停止I2C
    err:
    sw_i2c_stop(gpio);
}

三、应用举例

我们使用这一份驱动代码，定义两组I2C，来读写MCP4725的寄存器

#define MCP4725_DAC1_I2C_ADDR       (0xC0>>1)//DAC1 的I2C地址（7Bit模式，要把驱动中宏I2C_USE_7BIT_ADDR打开）
#define MCP4725_DAC2_I2C_ADDR       (0xC0>>1)//DAC2 的I2C地址（7Bit模式，要把驱动中宏I2C_USE_7BIT_ADDR打开）
sw_i2c_gpio_t dac1_i2c_port; //定义DAC1的I2C引脚
sw_i2c_gpio_t dac2_i2c_port; //定义DAC2的I2C引脚
/**************************************************************************
***                           对DAC芯片进行初始化                         ***
***************************************************************************/
void dac_init(void)  
{      
    //对DAC1的I2C引脚进行负值
​
    dac1_i2c_port.SCL_RCC_APB2Periph = RCC_APB2Periph_GPIOD;
    dac1_i2c_port.SCL_Port=GPIOD;
    dac1_i2c_port.SCL_Pin=GPIO_Pin_2;
    dac1_i2c_port.SDA_RCC_APB2Periph = RCC_APB2Periph_GPIOC;
    dac1_i2c_port.SDA_Port=GPIOC;
    dac1_i2c_port.SDA_Pin=GPIO_Pin_12;
    
    //对DAC2的I2C引脚进行负值
    dac2_i2c_port.SCL_RCC_APB2Periph = RCC_APB2Periph_GPIOC;
    dac2_i2c_port.SCL_Port=GPIOC;
    dac2_i2c_port.SCL_Pin=GPIO_Pin_11;
    dac2_i2c_port.SDA_RCC_APB2Periph = RCC_APB2Periph_GPIOC;
    dac2_i2c_port.SDA_Port=GPIOC;
    dac2_i2c_port.SDA_Pin=GPIO_Pin_10;
​
    sw_i2c_init(&dac1_i2c_port);//对DAC1的I2C进行初始化
    sw_i2c_init(&dac2_i2c_port);//对DAC2的I2C进行初始化
}  
/**************************************************************************
***                       读取DAC芯片寄存器的值                           ***
***************************************************************************/
void mcp4725_read_reg(uint8_t ch,uint8_t *reg_data)
{
    if(ch == 1)//读取DAC1寄存器的值   
        sw_i2c_read_nBytes(&dac1_i2c_port,MCP4725_DAC1_I2C_ADDR,reg_data,5);
    else if(ch == 2)//读取DAC2寄存器的值  
        sw_i2c_read_nBytes(&dac2_i2c_port,MCP4725_DAC2_I2C_ADDR,reg_data,5);
}
/**************************************************************************
***                 写DAC芯片寄存器，实现DAC输出模拟电压                    ***
***************************************************************************/
void mcp4725_write_data_voltage(uint8_t ch,uint8_t mode,uint16_t voltage)   //电压单位mV
{
    uint8_t data_buf[3];
    uint16_t Dn;
    
    Dn = ( 4096 * voltage) / MCP4725_VREF;
    
    if(mode == 0) // 快速模式写dac 寄存器
    {
        data_buf[0] = ((Dn&0x0F00)>>8);// | 0x6F;
        data_buf[1] = Dn & 0x00FF;
​
        if(ch == 1)
            sw_i2c_write_nBytes(&dac1_i2c_port,MCP4725_DAC1_I2C_ADDR,data_buf,2);
        else if(ch == 2)
            sw_i2c_write_nBytes(&dac2_i2c_port,MCP4725_DAC2_I2C_ADDR,data_buf,2);
    }
    else if(mode == 1) // 写DAC寄存器
    {
        data_buf[0] = 0x40;
        data_buf[1] = (Dn&0x0FFF)>>4;// | 0x6F;
        data_buf[2] = ((Dn&0x0FFF)<<4) & 0x00F0;
        
        if(ch == 1)
            sw_i2c_write_nBytes(&dac1_i2c_port,MCP4725_DAC1_I2C_ADDR,data_buf,3);
        else if(ch == 2)
            sw_i2c_write_nBytes(&dac2_i2c_port,MCP4725_DAC2_I2C_ADDR,data_buf,3);
    }
    else if(mode == 2) // 写DAC寄存器和EEPROM
    {
        data_buf[0] = 0x60;
        data_buf[1] = (Dn&0x0FFF)>>4;// | 0x6F;
        data_buf[2] = ((Dn&0x0FFF)<<4) & 0x00F0;
        
        if(ch == 1)
            sw_i2c_write_nBytes(&dac1_i2c_port,MCP4725_DAC1_I2C_ADDR,data_buf,3);
        else if(ch == 2)
            sw_i2c_write_nBytes(&dac2_i2c_port,MCP4725_DAC2_I2C_ADDR,data_buf,3);
    }
           
}

 

Mr.How
关注
专栏目录
RK3568笔记四十二：OLED 屏幕驱动(模拟I2C)
07-21 1307
SSD1306是一款带控制器的用于OLED点阵图形显示系统的单片CMOS OLED/PLED驱动器。手上的屏幕使用的是I2C方式驱动，I2C总线包含从机地址位 SA0，由数据信号线（SDA）和时钟信号线（SCL）组成。SDA和SCL线都必须接上拉电阻。写入时序IIC写入时序如下所示：1、主机先发起开始（START）信号，然后发送1byte首字节，包括从机地址(7位)和读写数据位(1位，最低位，0为写模式)，驱动器识别从机地址为本机地址之后，将会发出 应答信号(ACK)。（首字节组成如下图所示）
GPIO模拟I2C接口
qq_32065823的博客
08-19 2329
最近在做滚动屏的项目涉及到存储芯片FM24CL16B，此芯片是I2C接口实现的，因此特地找了个GPIO模拟I2C接口来实现存储芯片的写入与读出。 **myi2c.c** static void delay(void) { for (u8 i=0; i&lt;5; i++); } /* I2C起始条件 */ void i2c_start(void) { //初始化GPIO口...
GPIO模拟I2C程序实现
05-25
GPIO模拟I2C的程序实现 #include #include #include #include #include #include #include #include #include #include #include #include #include "gpio_i2c.h"
【I2C】Linux使用GPIO模拟I2C
ZHONGCAI0901的博客
06-12 4911
在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配置接口来收发数据。注册成功后，
STM32 IIC详解（软件模拟）
最新发布
千千道的博客
07-07 2152
IIC也被称为I2C和I²C，硬件方面由于存在专利，所以日常中我们常以两个IO口用软件模拟IIC来使用。IIC串行总线有两根信号线：数据线SDA和时钟线SCL。IIC总线上的设备通过地址进行区分，不同种类的设备地址不同。只要不超过IIC总线上的电容限制（一般不超过400pf），就可以连接任意数量的从机，在通信时刻，只能有一个作为主机，其他的都为从机。高速IIC总线一般可达400kbps以上。
总线学习2--使用GPIO模拟I2C
fanged的专栏
02-26 494
这篇也是2月份就TODO了，但是一直没写。没动工的原因也是一直忙，有限的时间内不知道如何下手，最后搞定了micropython之后，这些内容才算能推进。只是把实现I2C改成直接操作GPIO。其实核心功能就是那么几个，start，stop，write，read。主设备在 SCL 保持高电平的情况下，将 SDA 线从低电平拉高。（所有的图都是上面是SDA，下面是SCL）发命令是没问题，但是发数据还有问题。最后是仿照I2C的接口，还有两个封装。SDA拉低，SCL维持高位。
使用GPIO 模拟出I2C控制器：
nihaoma95278的博客
12-21 768
2、devm_request_irq是内核设备模型中用于申请中断的函数，它的功能与request_irq类似，但申请的是内核“managed”的资源。它与request_irq的区别在于，devm_request_irq申请的中断号不需要在出错的地方处理，也不需要在remove()接口里面显式释放。6、接收数据：在SCL信号的上升沿读取SDA引脚上的数据，以接收一个字节的数据。需要注意的是，request_irq函数需要在设备驱动程序中调用，而且需要在设备初始化之前完成中断的注册。
gpio模拟I2C
weixin_33698043的博客
06-13 106
开发中经常与i2c打交道，芯片中自带的硬件i2c控制器使用起来并不是很灵活，而且要研究半天的寄存器。所以干脆搞一个软件模拟gpio的通用代码，移植起来也方便，使用灵活 具体代码如下：   #include &lt;linux/module.h&gt; #include &lt;linux/config.h&gt; #include &lt;linux/errno.h&gt; #incl...
模拟I2C
heanyu的专栏
10-27 1123
I2C是总线结构，1个Master，1个或多个Slave，各Slave设备以7位地址区分，地址后面再跟1位读写位，表示读（=1）或者写（=0），所以我们有时也可看到8位形式的设备地址，此时每个设备有读、写两个地址，高7位地址其实是相同的。      I2C数据格式如下：       无数据 SCL=1，SDA=1；       开始位（Start）：当SCL=1时，SDA由1向0跳变；
GPIO模拟I2C通信协议（一）
热门推荐
Chen_Tianyang的博客
11-07 3万+
本博客是GPIO模拟I2C通信协议系列的第1篇，本文将首先介绍I2C协议的基本时序，然后给出用GPIO模拟实现I2C功能的C代码，最后介绍驱动开发的一些思路。本文的主要内容包括I2C协议简介和I2C协议的C代码实现两个部分，每个部分中又包含很多细节内容，都有代码实现。
linux gpio 模拟I2C驱动
06-11
linux gpio 模拟I2C驱动
模拟I2C 从机
03-01
模拟I2C从机代码 主机代码 以及相对应的波形 时序要求 I2C最高时钟频率需要根据MCU性能调整 主频 指令执行时间 中断响应速度等
模拟I2C程序
07-20
STC单片机模拟I2C
ESP8266-01GPIO口模拟I2C LCD1602.rar
09-09
在本文中，我们将深入探讨如何使用ESP8266-01模块的GPIO口来模拟I2C通信，以便与LCD1602显示器进行交互。ESP8266-01是一款低成本、高性能的Wi-Fi芯片，常用于物联网(IoT)项目。通过模拟I2C协议，我们可以扩展其功能...
Software_i2c_gpio模拟i2c400K速率_
09-29
总之，GPIO模拟I2C是一种在没有硬件I2C接口的系统中实现I2C通信的方法，它需要对I2C协议有深入理解，并能精确控制GPIO的输出。在400Kbps的高速下，对时间和同步的把握尤为重要。通过分析`Software_i2c.c`文件，我们...
Linux I2C-GPIO.zip_LINUX 模拟I2C_i2c gpio_linux_linux GPIO I2C_lin
09-24
本文将深入探讨如何在Linux中利用GPIO模拟I2C总线，以及相关技术细节。 首先，了解Linux中的GPIO驱动。在Linux内核中，GPIO驱动提供了对硬件GPIO引脚的访问。通过sysfs文件系统，用户空间程序可以读写对应的GPIO...
i2c-driver.rar_LINUX 模拟I2C_Linux GPIO模拟i2c_海思 GPIO I2C_海思 gpio_海
09-22
I2C总线由一个主设备（Master）和一个或多个从设备（Slave）组成，主设备负责发起通信，从设备响应。 二、GPIO模拟I2C： 当硬件I2C接口不可用时，可以通过GPIO来模拟I2C协议的时序。在GPIO模拟I2C中，通常将两个...
通用MSP430—I2C程序.rar_ i2c _I2C EEPROM_I2C-LED_模拟I2C_通信 协议
09-23
"I2C-LED"标签可能意味着这个程序还包含了如何控制连接到I2C总线的LED设备的示例。I2C LED驱动器可以简化微控制器对LED的控制，通过I2C协议可以轻松地控制多个LED的状态，甚至实现复杂的颜色和亮度控制。 "模拟i2c...
mcu 模拟 i2c slave
12-26
MCU是微控制器单元的缩写，是一种用于嵌入式系统的微型计算机。而I2C是一种串行通信总线，可以连接多个设备进行通信。模拟I2C slave是指MCU可以模拟成I2C总线上的从设备。 在实际应用中，MCU模拟I2C slave可以充当各种外围设备，比如传感器、存储器、显示器等，来与其他主设备进行通信。通过模拟I2C slave，MCU可以接收来自主设备的读写请求，并根据请求来执行相应的操作。例如，当主设备需要读取传感器数据时，MCU作为I2C slave可以接收到读取命令，然后从传感器中读取数据并返回给主设备。 实现MCU模拟I2C slave需要在硬件层面连接I2C总线，同时在软件层面编写对应的驱动程序和通信协议。通过这样的方式，MCU可以和其他I2C设备进行通信，并且实现各种功能。模拟I2C slave的功能可以扩展MCU的应用范围，使其可以灵活地与其他设备进行交互，从而实现更加复杂的嵌入式系统应用。MCU模拟I2C slave的应用场景非常广泛，涵盖了许多领域，比如物联网、智能家居、工业自动化等。通过模拟I2C slave，MCU可以成为整个系统中的一个智能节点，为系统的功能增加了更多可能性。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值