11. SPI

11.1 什么是SPI

SPI（Serial Peripheral Interface）是一种同步串行通信协议，用于在微控制器和外部设备之间进行数据传输。它由一个主设备（通常是微控制器MCU）和一个或多个从设备组成，即一主多从模式。它通常用于短距离、高速、全双工的通信，它在许多嵌入式系统和电子设备中被广泛应用。

11.2 SPI的硬件接口

SPI主要使用4根线，时钟线（SCLK），主输出从输入线（MOSI），主输入从输出线（MISO）和片选线（CS）。

主设备通过MOSI线向从设备发送数据。在每个时钟周期中，主设备将一个位发送到MOSI线上，从设备在下一个时钟周期中读取该位。
从设备通过MISO线向主设备发送数据。在每个时钟周期中，从设备将一个位发送到MISO线上，主设备在下一个时钟周期中读取该位。
数据传输可以是全双工的，即主设备和从设备可以同时发送和接收数据。
数据传输的长度可以是可变的，通常以字节为单位。
数据传输可以是单向的，即主设备只发送数据或只接收数据。
数据传输可以是多主设备的，即多个主设备可以与多个从设备进行通信。

主设备是通过片选线选择要与之通信的从设备。每个从设备都有一个片选线，当片选线为低电平时，表示该从设备被选中。（也有一些设备以高电平有效，需要根据其数据手册确定）。主设备通过控制时钟线的电平来同步数据传输。时钟线的上升沿和下降沿用于控制数据的传输和采样。

SPI的主从接线方式与串口类似，需要发送与接收交叉连接。

11.3 SPI的模式选择

SPI协议定义了多种传输模式，也称为SPI模式或时序模式，用于控制数据在时钟信号下的传输顺序和数据采样方式。SPI的传输模式主要由两个参数决定：时钟极性 (CKPL) 和 时钟相位 (CKPH)。

时钟极性 (CKPL)：时钟极性定义了时钟信号在空闲状态时的电平。

CKPL = 0：时钟信号在空闲状态时为低电平。

CKPL = 1：时钟信号在空闲状态时为高电平。

时钟相位 (CKPH)：相位定义了数据采样和更新发生在时钟信号的哪个边沿上。

CKPH = 0：数据采样发生在时钟的第一个边沿，数据更新发生在第二个边沿。

CKPH = 1：数据采样发生在时钟的第二个边沿，数据更新发生在第一个边沿。

以下是常见的SPI模式：

模式0（CKPL=0，CKPH=0）：
- 时钟极性（Clock Polarity）为0，表示时钟空闲状态为低电平。
- 时钟相位（Clock Phase）为0，表示数据在时钟信号的第一个边沿（时钟上升沿）进行采样和稳定。
模式1（CKPL=0，CKPH=1）：
- 时钟极性为0，时钟空闲状态为低电平。
- 时钟相位为1，数据在时钟信号的第二个边沿（时钟下降沿）进行采样和稳定。
模式2（CKPL=1，CKPH=0）：
- 时钟极性为1，时钟空闲状态为高电平。
- 时钟相位为0，数据在时钟信号的第一个边沿（时钟下降沿）进行采样和稳定。
模式3（CKPL=1，CKPH=1）：
- 时钟极性为1，时钟空闲状态为高电平。
- 时钟相位为1，数据在时钟信号的第二个边沿（时钟上升沿）进行采样和稳定。

选择SPI模式的决策通常取决于从设备的规格要求和通信协议。不同的设备可能采用不同的模式，所以在与特定从设备通信之前，必须了解从设备所需的SPI模式。如果没有明确指定SPI模式，通常可以根据从设备的规格手册或通信协议选择最常见的模式0或模式3进行尝试。此外，还需要注意SPI模式时钟的频率限制，以确保主设备和从设备之间的时钟频率匹配。

11.4 SPI的基本参数

SPI协议定义了一组参数，这些参数对于正确设置通信参数并实现SPI通信非常重要。

SPI的基本参数包括：

时钟极性(CPOL)：指定时钟空闲状态时信号线的电平，有两种状态：空闲时为高电平（CPOL=1）或空闲时为低电平（CPOL=0）；
时钟相位(CPHA)：指定数据采样的时刻，有两种状态：在时钟上升边沿之后采样数据（CPHA=0）或在时钟下降边沿之前采样数据（CPHA=1）；
数据位数：指定每个SPI数据包包含的位数（通常为8位），也可以设置为较小或较大的值；
传输模式：确定数据如何在SPI总线上传输（如全双工、半双工或单向模式）；
时钟速率：指定SPI总线的时钟速率，以bits per second (bps)为单位；
主/从模式：确定设备是SPI总线上的主机还是从机；
传输顺序：指定数据的 bit 传输顺序，MSB（most significant bit）优先或LSB（least significant bit）优先。

这些参数可以通过配置SPI控制寄存器来设置，以确保SPI设备之间的正确通信。在确定这些参数时，应该考虑实际硬件设置和通信需求。如果需要使用SPI进行通信，请确保正确设置这些参数。

11.5 软件SPI与硬件SPI

SPI与IIC类似，都分有软件SPI和硬件SPI，软件SPI部分不再讲解，本章节着重讲解硬件SP部分。

ESP32-S3芯片集成了四个 SPI 控制器：

SPI0
SPI1
通用 SPI2，即 GP-SPI2
和通用 SPI3，即 GP-SPI3

SPI0 和 SPI1 控制器主要供内部使用以访问外部 flash 及 PSRAM。我们只能使用SPI2和SPI3。

硬件SPI支持以下特性：

11.6 SPI的使用流程

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

导入相关的模块和库：

import machine

初始化 SPI 对象：

spi = machine.SPI(sck=machine.Pin(sck_pin_number), mosi=machine.Pin(mosi_pin_number), miso=machine.Pin(miso_pin_number))

其中 sck_pin_number、mosi_pin_number 和 miso_pin_number 分别是连接到 ESP32-S3 的时钟线、传输线和接收线的引脚编号。如果你不需要使用 MISO（主设备接收数据）功能，可以不指定 miso 引脚。

设置 SPI 时钟极性和相位：
c
```
spi.init(polarity=0, phase=0)
```
1

使用 init() 方法设置 SPI 时钟极性（polarity）和相位（phase）。默认的极性和相位都是 0。

4. 设置 SPI 模式和字长（可选步骤）：
spi.init(mode=machine.SPI.MODE_MASTER, bits=8)
使用 init() 方法设置 SPI 工作模式和字长。默认的工作模式是主设备模式，字长是 8 位。你可以根据需要设置适当的工作模式和字长。

5. 发送 SPI 指令（写入和读取）：
```
spi.write(data)
spi.read(nbytes)

使用 write() 方法向从设备发送数据。使用 read() 方法从从设备读取数据，并返回一个包含读取字节的 bytes 对象。如果你想仅仅发送数据而不接收数据，可以使用 write_readinto() 方法。

需要注意以下几点：

在使用 write() 和 read() 方法之前，确保从设备已正确连接到 SPI 总线。
如果你需要使用从设备模式而非主设备模式，可以使用 machine.SPI.MODE_SLAVE 常量来设置工作模式。
如果你需要使用硬件 SPI 总线而非软件 SPI 总线，可以使用 machine.SPI 类来初始化一个硬件 SPI 对象。这个对象可以直接使用硬件 SPI 总线而无需使用软件模拟。

11.7 SPI验证

使用0.96寸SPI屏幕作为案例；

将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()

ESP-IDF 入门手册

Arduino 入门手册

MicroPython 入门手册

模块移植手册【基于IDF】

显示类

传感器类

无线通信类

控制类

项目案例

训练营活动

11. SPI

11.1 什么是SPI

11.2 SPI的硬件接口

11.3 SPI的模式选择

11.4 SPI的基本参数

11.5 软件SPI与硬件SPI

11.6 SPI的使用流程

11.7 SPI验证

11.8 SPI效果

11. SPI ​

11.1 什么是SPI ​

11.2 SPI的硬件接口 ​

11.3 SPI的模式选择 ​

11.4 SPI的基本参数 ​

11.5 软件SPI与硬件SPI ​

11.6 SPI的使用流程 ​

11.7 SPI验证 ​

11.8 SPI效果 ​

11. SPI

11.1 什么是SPI

11.2 SPI的硬件接口

11.3 SPI的模式选择

11.4 SPI的基本参数

11.5 软件SPI与硬件SPI

11.6 SPI的使用流程

11.7 SPI验证

11.8 SPI效果