章节导航#

• 学习前后依赖
• 一、UART / I2C / SPI 三者对比
  • 双工模式说明
  • 同步 vs 异步
• 二、电平标准
  • TTL 电平（ESP32-S3 使用 3.3V TTL）
  • RS232 电平（负逻辑！）
  • RS485 电平（差分信号）
• 三、UART 数据帧结构
  • 帧格式
  • 校验位详解
  • 硬件流控（RTS / CTS）
• 四、数据帧分析实例
  • 发送数据：0x55（二进制 01010101）
  • 每位的持续时间
  • 帧时序图（逻辑分析仪视角）
  • 奇校验示例：发送 0x55 带奇校验
• 五、波特率计算
  • 一帧数据的总位数
  • 传输效率
  • 常用配置对比
• 六、ESP32-S3 UART 驱动代码
  • 项目结构
  • uart.c — UART 初始化模块
  • main.c — 主程序（串口回显）
  • 串口接收数据的两种显示模式
  • 其他常用 API
• 容易踩坑
• Tips
  • 波特率的本质——时钟同步的替代品
  • 中断接收 vs 轮询接收——如何选择
  • 踩坑实录
  • 知识衔接

双工模式说明#

• 单工（Simplex）：数据只能单向传输，如广播。只有一根数据线，一方只发、一方只收。
• 半双工（Half-Duplex）：数据可双向传输，但同一时刻只能一个方向。如 I2C，SDA 线分时复用。
• 全双工（Full-Duplex）：数据可同时双向传输，收发独立。如 UART（RX/TX 独立）、SPI（MOSI/MISO 独立）。

同步 vs 异步#

• 同步通信（I2C、SPI）：有独立的时钟线，收发双方按同一时钟节拍工作，速率高。
• 异步通信（UART）：没有时钟线，双方约定相同波特率，通过起始位/停止位同步，速率较低。

TTL 电平（ESP32-S3 使用 3.3V TTL）#

• 逻辑 1（高电平）：2.4V ~ VCC（3.3V 或 5V）
• 逻辑 0（低电平）：0V ~ 0.4V
• 温度特性：温度升高时，阈值可能漂移，但 TTL 一般使用场景温度范围较窄（0~70°C 商用级）
• 电压特性：对电源噪声敏感，适合板级短距离连接

RS232 电平（负逻辑！）#

• 逻辑 0（SPACE）：+3V ~ +15V（正电压表示 0！）
• 逻辑 1（MARK）：-3V ~ -15V（负电压表示 1！）
• 注意：RS232 是负逻辑，与 TTL 的电平逻辑相反，需要 MAX232 等芯片做电平转换
• 温度特性：工业级 -40°C ~ +85°C，电压范围宽，驱动能力强

RS485 电平（差分信号）#

• 逻辑 1：A 线电压 - B 线电压 > +200mV
• 逻辑 0：A 线电压 - B 线电压 < -200mV
• 差分传输优势：两根线同时受干扰，差值不变，共模抑制能力强
• 温度特性：工业级 -40°C ~ +85°C，适合恶劣环境
• 电压特性：共模电压范围 -7V ~ +12V，允许较大的地电位差

帧格式#

1
         ┌───┐  ┌───┐  ┌───┐  ┌───┐  ┌───┐  ┌───┐  ┌───┐  ┌───┐  ┌─────
2
─────────┘   └──┘   └──┘   └──┘   └──┘   └──┘   └──┘   └──┘   └──┘
3
 IDLE   St  D0   D1  D2   D3  D4   D5  D6   D7 [P]  Sp  IDLE / Next St
4
        起始位   ←──── 数据位 5~8 位 (LSB 先行) ────→ 校验  停止位
5
        =0                               (可选) =1 (1/1.5/2位 高电平)

校验位详解#

奇偶校验示例（数据 0x55 = 01010101B，含 4 个 1）：

• 奇校验：校验位 = 1（使 1 的总数为 5，奇数）
• 偶校验：校验位 = 0（使 1 的总数为 4，偶数）

注意：奇偶校验只能检测奇数个位的错误，无法纠错。

硬件流控（RTS / CTS）#

当接收方处理速度跟不上发送方时，若不加以控制，接收缓冲区会溢出导致数据丢失。硬件流控通过额外的 GPIO 线实现”发送许可”机制。

工作流程：

1
接收方准备好 ──→ RTS 拉低 ──→ 发送方 CTS 检测到低电平 ──→ 发送方开始发送
2
接收方缓冲区满 ──→ RTS 拉高 ──→ 发送方 CTS 检测到高电平 ──→ 发送方暂停发送
3
接收方处理完毕 ──→ RTS 拉低 ──→ 发送方继续发送

连线方式（5 线 UART）：

1
  发送方                          接收方
2
  ┌──────┐                      ┌──────┐
3
  │  TX  ├─────────────────────→│  RX  │  数据发送
4
  │  RX  │←─────────────────────┤  TX  │  数据接收
5
  │ CTS  │←─────────────────────┤ RTS  │  流控输入
6
  │ RTS  ├─────────────────────→│ CTS  │  流控输出
7
  │ GND  ├─────────────────────→│ GND  │  共地
8
  └──────┘                      └──────┘

注意：RTS/CTS 是交叉连接的——己方 RTS 接对方 CTS，己方 CTS 接对方 RTS。

硬件流控 vs 软件流控：

ESP32-S3 配置：

1
// 仅启用 CTS（发送方检查 CTS 信号）
2
.flow_ctrl = UART_HW_FLOWCTRL_CTS,
3

4
// 仅启用 RTS（接收方控制 RTS 信号）
5
.flow_ctrl = UART_HW_FLOWCTRL_RTS,
6

7
// 同时启用 RTS 和 CTS
8
.flow_ctrl = UART_HW_FLOWCTRL_CTS_RTS,
9

10
// 禁用（默认）
11
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,

发送数据：0x55（二进制 01010101）#

1
参数：
2
  波特率：9600 bps
3
  起始位：1 位
4
  数据位：8 位
5
  校验位：无
6
  停止位：1 位

每位的持续时间#

波特率 9600 → 1 bit 时长 = 1/9600 ≈ 104.17 μs

帧时序图（逻辑分析仪视角）#

1
           ┌───┐    ┌───┐    ┌───┐    ┌───┐    ┌──────
2
───────────┘   └────┘   └────┘   └────┘   └────┘
3
  IDLE    St  D0   D1  D2   D3  D4   D5  D6   D7  Sp  IDLE
4
  HIGH    =0  =1   =0  =1   =0  =1   =0  =1   =0  =1  HIGH
5
           ←──────── 每 bit = 1/9600 ≈ 104.17 μs ────────→

分析：

• D0 (LSB) = 1 → 高电平
• D1 = 0 → 低电平
• D2 = 1 → 高电平
• D3 = 0 → 低电平
• D4 = 1 → 高电平
• D5 = 0 → 低电平
• D6 = 1 → 高电平
• D7 (MSB) = 0 → 低电平

波形呈现交替的 1/0 方波：1 0 1 0 1 0 1 0（LSB 先行）

奇校验示例：发送 0x55 带奇校验#

数据位 8 位 + 奇校验位 1 位：

1
           ┌───┐    ┌───┐    ┌───┐    ┌───┐        ┌──────
2
───────────┘   └────┘   └────┘   └────┘   └────────┘
3
  IDLE    St  D0   D1  D2   D3  D4   D5  D6   D7  P   Sp  IDLE
4
  HIGH    =0  =1   =0  =1   =0  =1   =0  =1   =0 =1  =1  HIGH
5
                             数据 0x55 (4个1)  →  校验位=1
6
                                         (使总 1 个数 = 5 → 奇数)

一帧数据的总位数#

以 9600-8-N-1（9600 波特率，8 数据位，无校验，1 停止位）为例：

传输效率#

• 实际数据比例：8/10 = 80%（20% 被帧开销占用）
• 每秒最多帧数：9600 / 10 = 960 帧/秒
• 每秒有效数据：960 × 8 = 7680 字节/秒 ≈ 7.5 KB/s

常用配置对比#

项目结构#

1
15_UART/
2
├── main/
3
│   └── main.c              ← 主程序：接收并回显数据
4
└── components/
5
    └── UART/
6
        ├── uart.h          ← 声明 uart_init()
7
        └── uart.c          ← UART 初始化的实现

uart.c — UART 初始化模块#

1
#include "uart.h"
2
#include "driver/uart.h"
3
#include "driver/gpio.h"
4

5

6
void uart_init(void)
7
{
8
    uart_config_t uart_structure = {
9
        .baud_rate = 9600,                        // 波特率 9600 bps
10
        .data_bits = UART_DATA_8_BITS,            // 数据位 8 位
11
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,    // 禁用硬件流控 (RTS/CTS)
12
        .parity    = UART_PARITY_DISABLE,         // 无校验位
13
        .source_clk = UART_SCLK_DEFAULT,          // 默认时钟源 (APB)
14
        .stop_bits = UART_STOP_BITS_1,            // 停止位 1 位
15
    };
16
    uart_param_config(UART_NUM_1, &uart_structure);           // 端口1, 应用配置
17
    uart_set_pin(UART_NUM_1, GPIO_NUM_17, GPIO_NUM_18,       // 端口1, TX=17, RX=18
18
                 UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);     // RTS/CTS 不使用
19
    uart_driver_install(UART_NUM_1, 1024, 1024, 0, NULL, 0);  // 端口1, RX缓冲1024B, TX缓冲1024B, 无事件队列
20
}

说明：

• 使用 UART_NUM_1（ESP32-S3 有 3 个 UART：0、1、2）
• TX→GPIO17，RX→GPIO18，其余引脚不使用
• 收发缓冲区各 1024 字节，不使用事件队列

main.c — 主程序（串口回显）#

1
#include <stdio.h>
2
#include <stdint.h>
3
#include "freertos/FreeRTOS.h"
4
#include "freertos/task.h"
5
#include "driver/uart.h"      // uart_read_bytes、uart_write_bytes、uart_flush
6
#include "driver/gpio.h"
7
#include "uart.h"             // 本项目的 uart_init()
8

9
void app_main(void)
10
{
11
    int len = 0;
12
    uint8_t uart_buf[1024] = {0};   // 接收缓冲区，初始化为 0
13
    uart_init();                     // 调用组件中的初始化函数
14

15
    while (1)
16
    {
17
        // 从 UART_NUM_1 读取数据，超时 100ms
18
        len = uart_read_bytes(UART_NUM_1, uart_buf, 1024, pdMS_TO_TICKS(100));
19
        if (len > 0)
20
        {
21
            // 将收到的数据原样发送回去（回显）
22
            uart_write_bytes(UART_NUM_1, uart_buf, len);
23
            uart_flush(UART_NUM_1);  // 等待发送完成，清空缓冲区
24
        }
25
        vTaskDelay(5);               // 延时 5 ticks，让出 CPU
26
    }
27
}

数据流：

1
PC TX -- ESP32 RX(GPIO18)
2
PC RX -- ESP32 TX(GPIO17)
3
GND   -- GND

1
RX 引脚
2
  |
3
  v
4
UART RX FIFO
5
  | 中断搬运
6
  v
7
驱动 RX 环形缓冲
8
  |
9
  v
10
uart_read_bytes()

1
PC 发送字节
2
    |
3
    v
4
ESP32 读到 len > 0
5
    |
6
    v
7
uart_write_bytes() 原样写回
8
    |
9
    v
10
PC 收到回显

串口接收数据的两种显示模式#

uart_read_bytes 读到的是原始字节数据（uint8_t 数组），显示方式决定了我们看到什么。

1
uint8_t rx_buf[128];
2
int len = uart_read_bytes(UART_NUM_0, rx_buf, sizeof(rx_buf), pdMS_TO_TICKS(500));
3
if (len > 0) {
4
    rx_buf[len] = '\0';                        // 添加字符串结束符
5
    printf("收到文本: %s\n", (char *)rx_buf);  // 直接按字符串打印
6
}

1
uint8_t rx_buf[128];
2
int len = uart_read_bytes(UART_NUM_0, rx_buf, sizeof(rx_buf), pdMS_TO_TICKS(500));
3
if (len > 0) {
4
    printf("收到 Hex (%d 字节): ", len);
5
    for (int i = 0; i < len; i++) {
6
        printf("%02X ", rx_buf[i]);            // 每字节显示为 2 位大写 Hex
7
    }
8
    printf("\n");
9
}

1
void uart_dump_hex(const uint8_t *data, int len)
2
{
3
    printf("--- Hex Dump (%d bytes) ---\n", len);
4
    for (int i = 0; i < len; i++) {
5
        // 换行：每 16 字节一行
6
        if (i % 16 == 0) printf("%04X: ", i);
7
        printf("%02X ", data[i]);
8
        if (i % 16 == 15) {
9
            printf(" |");                       // 右侧 ASCII 区
10
            for (int j = i - 15; j <= i; j++)
11
                printf("%c", (data[j] >= 0x20 && data[j] <= 0x7E) ? data[j] : '.');
12
            printf("|\n");
13
        }
14
    }
15
    // 最后一行不足 16 字节，补齐空格
16
    int rem = len % 16;
17
    if (rem > 0) {
18
        for (int i = 0; i < (16 - rem) * 3 + 2; i++) printf(" ");
19
        printf("|");
20
        for (int j = len - rem; j < len; j++)
21
            printf("%c", (data[j] >= 0x20 && data[j] <= 0x7E) ? data[j] : '.');
22
        printf("|\n");
23
    }
24
    printf("--- End ---\n");
25
}

1
--- Hex Dump (13 bytes) ---
2
0000: 48 65 6C 6C 6F 20 55 41 52 54 21 0D 0A          |Hello UART!..|
3
--- End ---

其他常用 API#

波特率的本质——时钟同步的替代品#

UART 是”异步”通信，没有单独的时钟线。那么接收方怎么知道每个 bit 从哪里开始、在哪里结束？答案就是波特率——双方事先约定好同一个速率，接收方用这个速率作为”隐式时钟”。

1
发送方 @ 9600 bps:
2
  ┌──┐  ┌──┐  ┌──┐
3
──┘  └──┘  └──┘  └──   每 bit = 1/9600 ≈ 104μs
4
  104μs
5

6
接收方 @ 9600 bps:
7
  1. 检测到起始位（下降沿）
8
  2. 等待 104/2 = 52μs（到 bit 中心，最佳采样点）
9
  3. 每间隔 104μs 采样一次，连续 8 次
10
  4. 检查停止位是否为高

波特率误差的容忍度：如果双方时钟偏差过大，到第 8 个数据位时采样点已经偏离到相邻 bit 的区域，就会读错。一般要求双方误差 < 3%~5%。ESP32-S3 使用 APB 时钟源（80 MHz）分频得到波特率，精度远高于外部晶振直接分频。

为什么 115200 是常用值？ 这是 9600 的 12 倍，可以整除常见晶体频率（如 1.8432 MHz），分频误差为零。自定义波特率（如 1000000）可能导致双方的分频系数不同，误差累积。

中断接收 vs 轮询接收——如何选择#

本项目 main.c 中的 uart_read_bytes() 是轮询方式——主循环每 5ms 来问一次”有数据吗？“。在数据量小、实时性要求不高时完全够用。

但如果数据量大（如每秒几千字节），轮询就可能丢数据：

1
轮询方式：
2
  main loop 每 5ms 读一次
3
  如果 5ms 内来了 512 字节 → 环形缓冲区可能溢出 → 丢数据
4

5
中断方式：
6
  每收到一个字节 → ISR 自动存到环形缓冲区
7
  main loop 只需从缓冲区读 → 不会丢数据

如何在 ESP-IDF 中启用 UART 中断：

1
// 安装驱动时启用事件队列
2
QueueHandle_t uart_queue;
3
uart_driver_install(UART_NUM_1, 1024, 1024, 10, &uart_queue, 0);
4
//                                  RX  TX 队列深度 ↑
5

6
// 在 FreeRTOS 任务中等待事件
7
void uart_event_task(void *pvParameters) {
8
    uart_event_t event;
9
    while (1) {
10
        if (xQueueReceive(uart_queue, &event, portMAX_DELAY)) {
11
            switch (event.type) {
12
                case UART_DATA:
13
                    // 有数据到达，现在去读
14
                    uart_read_bytes(UART_NUM_1, buf, event.size, 0);
15
                    break;
16
                case UART_FIFO_OVF:
17
                    // 缓冲区溢出！增大 rx_buffer_size
18
                    break;
19
            }
20
        }
21
    }
22
}

选择建议：

踩坑实录#

1. 波特率对了但数据错了：检查是否双方数据位/停止位/校验位完全一致。8-N-1 是最通用的配置，任何一方改了校验方式都会导致另一边收到乱码。

2. printf 和 UART 混用：ESP32-S3 的 printf 默认输出到 UART_NUM_0（USB 串口）。如果你在代码中同时用 printf 和 uart_write_bytes(UART_NUM_0, ...)，两者会竞争同一个 UART 的发送缓冲区。建议 printf 用 UART0（调试日志），自定协议用 UART1/UART2。

3. vTaskDelay(5) 太小：本项目的 5 ticks（约 50ms @100Hz）是合理的。但如果设为 vTaskDelay(1)，CPU 会几乎 100% 空转轮询 UART，导致其他任务饿死。

知识衔接#

• 下一章：02_IIC——从”异步无时钟”的 UART 过渡到”同步有时钟”的 I2C。UART 用波特率隐式同步，I2C 用 SCL 显式同步，这是两者最本质的区别。
• 高级用法：UART 的 DMA 模式（uart_write_bytes 内部超过阈值会自动使用 DMA）、RS485 方向控制（用 RTS 引脚自动切换收发方向）。