10. I2C

10.1 什么是I2C

IIC（Inter-Integrated Circuit）协议也称为I2C总线，是一种串行通信协议，通常用于连接低速外设。它由Philips（现在的NXP Semiconductors）公司于1980年代初开发，现在已经成为一个标准。IIC总线只需要两条数据线，分别是串行数据线（SDA）和串行时钟线（SCL），这使得它成为一种非常简单的接口。它适用基于芯片的通信，例如连接传感器、存储器或数字信号处理器等。

在IIC协议中，总线上有一个主设备和多个从设备。主设备掌控着总线上的通信过程，负责发起、控制、停止通信。而从设备则需要等待主设备的请求，接收或发送数据。主设备和从设备之间的数据交换采用帧格式，每个帧通常包含地址、数据和控制信息。主设备根据从设备的地址来选中要通信的设备，从设备则根据控制信息进行相应的操作。IIC协议可以支持多个从设备连接到同一个主设备，为系统设计提供了更大的灵活性。

10.2 I2C的硬件实现

I2C总线通常使用两种电压电平，即高电平（VH）和低电平（VL）。高电平为2.5V至5.5V，低电平为0V至0.3V；这些电压电平范围是根据I2C规范确定的。

I2C总线有不同的传输速率可选，包括标准模式（100 kbps）、快速模式（400 kbps）以及高速模式。传输速率的选择取决于应用的需求和设备的支持能力。

为避免信号冲突，微处理器(MCU）必须只能驱动SDA和SCL在低电平，即开漏输出。设置为开漏模式主要是为了保护器件和防止干扰。

防止干扰：多个器件共享同一条数据线（SDA）和同一条时钟线（SCL），如果采用推挽输出模式，多个器件的输出将会叠加在数据线上，造成信号干扰，严重时会损坏器件或导致通信错误。而采用开漏输出模式，则各个器件的输出只有拉低数据线的部分，不会干扰彼此，从而提高了总线的可靠性和抗干扰能力。
防止短路：在开漏输出模式下，由于器件的输出只有拉低数据线的部分，如果两个或多个器件同时输出，也不会造成短路。而如果采用推挽输出模式，两个或多个器件同时输出时，可能会形成短路。比如主设备输出高电平，从设备输出低电平。

因设置为开漏模式，需要连接一个外部的上拉电阻（例如:10k)将信号提拉至高电平。故I2C总线中的SDA（数据线）和SCL（时钟线）通常都连接了上拉电阻，以确保逻辑高电平的稳定性。上拉电阻的阻值通常在2.2kΩ至10kΩ之间，具体取决于总线的电容负载和通信距离。

I2C总线的最大线缆长度和传输容量受到一定限制。在标准模式下，最大线缆长度大约在1米左右，而在快速模式下，最大线缆长度约为0.3米。此外，线缆上的总线容量也会对传输速率产生影响。

10.3 I2C数据传输

I2C协议使用总线抢占制进行数据传输。它只有两根通信线，因此它数据传输是基于时钟信号的。时钟由主设备产生，并控制数据的传输速率。数据由主设备发送并接收，但其交换是通过从设备的应答来实现的。

下面是IIC总线的几个重要的时序：

起始信号：SCL在高电平的状态下，SDA的电平由高转低，表示开始一次通信。

void IIC_Start(void)
{
    SDA_OUT();//设置SDA为输出模式
    SDA(1);
    SCL(1);
    delay_us(5);
    SDA(0);
    delay_us(5);
    SCL(0);
    delay_us(5);
}

停止信号：SCL在高电平的状态下，SDA的电平由低转高，表示结束这次通信。主设备在发送停止信号后不能再向从设备发送任何数据，除非再次发送起始信号。

void IIC_Stop(void)
{
    SDA_OUT();
    SCL(0);
    SDA(0);

    SCL(1);
    delay_us(5);
    SDA(1);
    delay_us(5);
}

数据传输：主设备和从设备进行数据的传输，可以是一个或多个字节的数据，发送和接收都是基于地址选择的。

//发送一个字节
void IIC_Send_Byte(unsigned char dat)
{
    int i = 0;
    SDA_OUT();
    SCL(0);
    for( i = 0; i < 8; i++ )
    {
        SDA( (dat & 0x80) >> 7 );
        delay_us(1);
        SCL(1);
        delay_us(5);
        SCL(0);
        delay_us(5);
        dat<<=1;
    }
}

//接收一个字节
unsigned char IIC_Read_Byte(void)
{
    unsigned char i,receive=0;
    SDA_IN();//SDA设置为输入
    for(i=0;i<8;i++ )
    {
        SCL(0);
        delay_us(5);
        SCL(1);
        delay_us(5);
        receive<<=1;
        if( SDA_GET() == 1 )
        {
            receive |= 1;
        }
    }
    SCL(0);
    return receive;
}

I2C还提供了一种称为“ACK/NACK”（应答/非应答）的确认机制。如果一个设备接收到数据，它将通过在SDA线上拉低电平来发送一个应答信号以通知发送方数据已被接收。相反，如果数据被损坏或未接收，接收设备将发送非应答信号。（在SDA上保持高电平）。

 void IIC_Send_Ack(void)
{
SDA_OUT();
SCL(0);
SDA(1);
SDA(0);
SCL(1);
delay_us(5);
SCL(0);
SDA(1);
}

void IIC_Send_Nack(void)
{
    SDA_OUT();
    SCL(0);
    SDA(0);
    SDA(1);
    SCL(1);
    delay_us(5);
    SCL(0);
    SDA(0);
}

在IIC总线中，时钟线由主设备控制，每个数据位在时钟边沿更新，传输的最高速率取决于总线上最慢的设备。一般来讲，IIC总线的通信速率比较慢，通常在几百kbps的范围内。如果需要更高的传输速率，可以采用其他通信协议，如SPI协议、CAN协议等。

10.4 I2C通信流程

I2C通信流程按照以下步骤进行：

主控向总线发送开始信号。
主控将要通信的设备地址和读写位（R/W）发送到总线上。
设备接收到地址后发送应答信号，主控接收到应答信号后发送数据或继续发送地址。
设备接收到数据后发送应答信号，主控接收到应答信号后可以继续发送数据或者停止通信。
主控向总线发送停止信号。

10.5 IIC基本参数

速率：I2C总线有标准模式（100 kbit/s）和快速模式（400 kbit/s）两种传输模式，还有更快的扩展模式和高速模式可供选择。
器件地址：每个设备都有唯一的7位或10位地址，可以通过地址选择来确定与谁进行通信。
总线状态：I2C总线有五种状态，分别是空闲状态、起始信号、结束信号、响应信号、数据传输。
数据格式：I2C总线有两种数据格式，标准格式和快速格式。标准格式是8位数据字节加上1位ack/nack（应答/非应答）位，快速格式允许两个字节同时传输。

由于SCL和SDA线是双向的，它们也可能会由于外部原因（比如线路中的电容等）出现电平误差，而从而导致通信出错。因此，在IIC总线中，通常使用上拉电阻来保证信号线在空闲状态下的电平为高电平。

10.6 软件I2C与硬件I2C

I2C协议可以通过软件实现或者硬件实现。这两种方式的区别在于实现的方法和所需的硬件资源。 10.6.1 软件I2C 软件I2C是指通过在程序中编写代码来实现I2C通信协议。它利用通用输入输出（GPIO）引脚来模拟I2C的数据线（SDA）和时钟线（SCL），通过软件控制引脚的电平变化来传输数据和生成时序信号。与硬件I2C相比，软件I2C的优势在于不需要特定的硬件支持，可以在任何支持GPIO功能的微控制器上实现。它利用了微控制器的通用IO引脚来实现I2C通信协议。

软件I2C的实现通过编程方式来模拟I2C的主机和从机设备。通过逐位地读取和写入GPIO引脚的状态，并根据I2C协议的时序要求进行相应的操作，实现数据的传输和通信。软件I2C的灵活性较高，可以根据应用需求进行定制和扩展。它可以处理多个从机设备，并支持多主机环境。因此，软件I2C广泛应用于资源受限的MCU系统，特别是那些需要与多个外部设备进行通信的应用。

尽管软件I2C的性能相对于硬件I2C较低，但在一些低速通信和简单通信需求的场景下，软件I2C是一种经济实用的解决方案。

10.6.2 硬件I2C

硬件I2C是指通过专门的硬件模块来处理I2C通信协议。大多数现代微控制器和一些外部设备已经集成了硬件I2C模块，这些硬件模块负责处理I2C通信的细节，包括生成正确的时序信号、自动处理信号冲突、数据传输和错误检测等。可以直接使用硬件引脚连接，无需编写时序的代码。

使用硬件I2C通常相对简单，开发者无需编写复杂的代码来处理通信协议的细节。硬件模块可以直接与外部设备连接，通过专用的引脚进行数据和时钟传输，从而实现高效且可靠的通信。

在选择软件I2C还是硬件I2C时，需要考虑应用需求和硬件资源。软件I2C适用于资源受限的系统，可以在任何支持GPIO的微控制器上实现，但相对性能较低。硬件I2C通常性能更好，但需要硬件支持，并且可能占据一些特定的引脚资源。

10.6.3 IIC优缺点

10.6.3.1 优点

双向传输：I2C总线支持双向传输，可以通过SDA线同时传输主设备和从设备之间的数据，节约了总线的资源。

系统集成：I2C总线可以快速集成到芯片中，减少系统实现的逻辑复杂性，提高了设计效率。多设备共享：I2C总线可以通过地址传输实现多个设备与主控器的通信，使得多个设备可以共享总线，并直接交互。

高可靠性：I2C总线使用逻辑层次的代替电气信号来表示数据传输，具有更高的传输可靠性。

10.6.3.2 缺点

带宽不高：I2C总线的传输速度限制在400 kbps，相比较于SPI总线和CAN总线，带宽相对较低。

时序要求严格：I2C总线传输数据需要严格遵循时序要求，特别是在高速传输过程，时序容易受到干扰，造成通信失败。

最长电缆长度有限：虽然I2C总线可以通过中继器扩展总线长度，但是由于信号线受到干扰，信号衰减和时序要求等问题，电缆最长长度一般限制在1~2米之间。

总之，I2C总线具有双向传输、系统集成、多设备共享等优点，但传输速度相对较低，时序要求严格且最长电缆长度有限等缺点。

10.7 ESP32S3的I2C介绍

ESP32S3有两个硬件I2C控制器（也称为端口），负责处理两条I2C总线上的通信。每个I2C控制器都可以作为主机或从机运行。ESP32的I2C接口可以配置为主模式或从模式，可以通过简单的API来控制I2C总线上的设备。

10.8 使用I2C流程

ESP32-S3 的软件 I2C（串行外设接口）功能在 MicroPython 中的流程如下：

导入相关的模块和库：
c
```
import machine
```
1


2. 初始化软件 I2C 对象：
```c
i2c = machine.SoftI2C(scl=machine.Pin(scl_pin_number), sda=machine.Pin(sda_pin_number))

其中 scl_pin_number 和 sda_pin_number 是连接到 ESP32-S3 的 SCL（时钟线）和 SDA（数据线）引脚的编号。

classmachine.SoftI2C(scl, sda, *, freq=400000, timeout=255)

构造一个新的软件 I2C 对象。参数是：

scl应该是一个 pin 对象，指定用于 SCL 的 pin。
sda应该是一个 pin 对象，指定用于 SDA 的 pin。
freq应该是一个整数，用于设置 SCL 的最大频率。
timeout是等待时钟延长（SCL 被总线上的另一个设备保持为低电平）的最长时间（以微秒为单位），之后会引发OSError(ETIMEDOUT) 异常。

设置 I2C 时钟速度（可选步骤）：

i2c.init(scl_speed=100000)

使用 init() 方法设置 I2C 时钟速度。默认的时钟速度为 400KHz，可以根据需要设置一个合适的速度。4. 发送 I2C 指令（读取和写入）：

i2c.writeto(device_address, data)
i2c.readfrom_into(device_address, buffer)

使用 writeto() 方法向指定设备地址（device_address）发送数据（data）。使用 readfrom_into() 方法从指定设备地址（device_address）读取数据，并存储到指定缓冲区（buffer）中。

需要注意以下几点：

在使用 writeto() 和 readfrom_into() 方法之前，确保设备已正确连接到 I2C 总线，并且设备地址是正确的。
通常情况下，设备地址是 7 位的。你可以在扫描 I2C 总线时获得设备地址列表，并根据需要选择正确的设备地址。
如果你需要使用硬件 I2C 总线而非软件 I2C 总线，可以使用 machine.I2C 类来初始化一个硬件 I2C 对象。这个对象可以直接使用硬件 I2C 总线而无需使用软件模拟。

10.9 I2C验证

案例一：0.96寸I2C接口的OLED屏幕

ssd1306.py

import time
import framebuf

# register definitions
SET_CONTRAST        = const(0x81)
SET_ENTIRE_ON       = const(0xa4)
SET_NORM_INV        = const(0xa6)
SET_DISP            = const(0xae)
SET_MEM_ADDR        = const(0x20)
SET_COL_ADDR        = const(0x21)
SET_PAGE_ADDR       = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP       = const(0xa0)
SET_MUX_RATIO       = const(0xa8)
SET_COM_OUT_DIR     = const(0xc0)
SET_DISP_OFFSET     = const(0xd3)
SET_COM_PIN_CFG     = const(0xda)
SET_DISP_CLK_DIV    = const(0xd5)
SET_PRECHARGE       = const(0xd9)
SET_VCOM_DESEL      = const(0xdb)
SET_CHARGE_PUMP     = const(0x8d)


class SSD1306:
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        # Note the subclass must initialize self.framebuf to a framebuffer.
        # This is necessary because the underlying data buffer is different
        # between I2C and SPI implementations (I2C needs an extra byte).
        self.poweron()
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00, # off
            # address setting
            SET_MEM_ADDR, 0x00, # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
            SET_MUX_RATIO, self.height - 1,
            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
            SET_DISP_OFFSET, 0x00,
            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV, 0x80,
            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
            SET_VCOM_DESEL, 0x30, # 0.83*Vcc
            # display
            SET_CONTRAST, 0xff, # maximum
            SET_ENTIRE_ON, # output follows RAM contents
            SET_NORM_INV, # not inverted
            # charge pump
            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01): # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_framebuf()

    def fill(self, col):
        self.framebuf.fill(col)

    def pixel(self, x, y, col):
        self.framebuf.pixel(x, y, col)

    def scroll(self, dx, dy):
        self.framebuf.scroll(dx, dy)

    def text(self, string, x, y, col=1):
        self.framebuf.text(string, x, y, col)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        # Add an extra byte to the data buffer to hold an I2C data/command byte
        # to use hardware-compatible I2C transactions.  A memoryview of the
        # buffer is used to mask this byte from the framebuffer operations
        # (without a major memory hit as memoryview doesn't copy to a separate
        # buffer).
        self.buffer = bytearray(((height // 8) * width) + 1)
        self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1
        self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80 # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_framebuf(self):
        # Blast out the frame buffer using a single I2C transaction to support
        # hardware I2C interfaces.
        self.i2c.writeto(self.addr, self.buffer)

    def poweron(self):
        pass


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        self.buffer = bytearray((height // 8) * width)
        self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.on()
        self.dc.off()
        self.cs.off()
        self.spi.write(bytearray([cmd]))
        self.cs.on()

    def write_framebuf(self):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.on()
        self.dc.on()
        self.cs.off()
        self.spi.write(self.buffer)
        self.cs.on()

    def poweron(self):
        self.res.on()
        time.sleep_ms(1)
        self.res.off()
        time.sleep_ms(10)
        self.res.on()

将ssd1306.py上传到ESP32S3芯片上，编译才没有错误

main.py

#以0.91寸IIC屏幕为例
from machine import Pin, SoftI2C, I2C

#将ssd1306.py上传到ESP32S3芯片上，编译才没有错误
from ssd1306 import SSD1306_I2C

# 定义 SoftI2C 控制对象
i2c = SoftI2C(sda=Pin(13), scl=Pin(14), freq=100000)
 #创建oled对象
oled = SSD1306_I2C(128, 64, i2c)

#清屏
oled.fill(0)
#开始显示
oled.show()

#往屏幕加入显示字符
oled.text("Hello World!",0,0)
#开始显示
oled.show()

案例二：AT24C02读写

from machine import I2C, Pin
import time

# 定义I2C引脚
sda = Pin(40)
scl = Pin(21)

# 创建I2C对象
i2c = I2C(scl=scl, sda=sda)

#设备地址 80 = 0X50
at24c02_addr = 80

#寄存器地址
at24c02_reg_addr = 0

#往0地址写入 字符数据 a
i2c.writeto_mem(at24c02_addr, 0, 'a')

#等待1秒
time.sleep(1)

#从0地址读出一个数据
data = i2c.readfrom_mem(at24c02_addr, 0, 1)

#打印data列表的第一个数据
print(data[0])

ESP-IDF 入门手册

Arduino 入门手册

MicroPython 入门手册

模块移植手册【基于IDF】

显示类

传感器类

无线通信类

控制类

项目案例

训练营活动

10. I2C

10.1 什么是I2C

10.2 I2C的硬件实现

10.3 I2C数据传输

10.4 I2C通信流程

10.5 IIC基本参数

10.6 软件I2C与硬件I2C

10.6.2 硬件I2C

10.6.3 IIC优缺点

10.6.3.1 优点

10.6.3.2 缺点

10.7 ESP32S3的I2C介绍

10.8 使用I2C流程

10.9 I2C验证

案例一：0.96寸I2C接口的OLED屏幕

案例二：AT24C02读写

10. I2C ​

10.1 什么是I2C ​

10.2 I2C的硬件实现 ​

10.3 I2C数据传输 ​

10.4 I2C通信流程 ​

10.5 IIC基本参数 ​

10.6 软件I2C与硬件I2C ​

10.6.2 硬件I2C ​

10.6.3 IIC优缺点 ​

10.6.3.1 优点 ​

10.6.3.2 缺点 ​

10.7 ESP32S3的I2C介绍 ​

10.8 使用I2C流程 ​

10.9 I2C验证 ​

案例一：0.96寸I2C接口的OLED屏幕 ​

案例二：AT24C02读写 ​

10. I2C

10.1 什么是I2C

10.2 I2C的硬件实现

10.3 I2C数据传输

10.4 I2C通信流程

10.5 IIC基本参数

10.6 软件I2C与硬件I2C

10.6.2 硬件I2C

10.6.3 IIC优缺点

10.6.3.1 优点

10.6.3.2 缺点

10.7 ESP32S3的I2C介绍

10.8 使用I2C流程

10.9 I2C验证

案例一：0.96寸I2C接口的OLED屏幕

案例二：AT24C02读写