1
UART 不是"协议"，而是"硬件接口"。
2
协议层面的东西(RS-232/RS-485/RS-422)才定义了电气标准。
3

4
层次关系:
5
  ┌─────────────────────────────────┐
6
  │  应用层: AT命令 / 自定义协议     │  ← printf, Modbus RTU
7
  ├─────────────────────────────────┤
8
  │  UART 帧: 起始位+数据+校验+停止  │  ← 8N1
9
  ├─────────────────────────────────┤
10
  │  电气标准: TTL / RS-232 / RS-485 │  ← 电压/差分/单端
11
  └─────────────────────────────────┘

1
            ┌─── 1帧(8N1) = 10位 ───────────────────────┐
2
            │                                           │
3
空闲(高) ───┐ ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──────── 空闲(高)
4
            │ │D0│  │D1│  │D2│  │D3│  │D4│  │D5│  │D6│  │D7│  │停止位
5
       ┌──┐ │ │  │  │  │  │  │  │  │  │  │  │  │  │  │  │  │  │
6
       │起│ │ └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  │
7
       │始│ │                                                    │
8
       │位│ │ ← LSB先发                              MSB后发 → │
9
       └──┘ │                                                    │
10
            │←── 1位时间 = 1/波特率 ──→│                        │
11
            ↓       8.68μs @115200                               │
12

13
  ★ 接收端的 16× 过采样示意:
14
    发送: ______|‾‾‾‾‾‾‾‾‾‾|__________
15
    采样:       ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ (16次采样)
1 collapsed line
16
                    ↑↑↑ (取中间3次做多数表决 → 抗噪声)

1
方式1: 独立CS(最常用)     方式2: 菊花链(Daisy-Chain)
2
┌────────┐                  ┌────────┐
3
│ Master │                  │ Master │
4
│ MOSI──→├──┬──┬──          │ MOSI──→├──→MOSI┐ ┌→MOSI┐
5
│ MISO──←├──┼──┼──          │ MISO──←├──────┼←┤MISO←┤
6
│ SCK ──→├──┼──┼──          │ SCK ──→├──→SCK│ └→SCK │
7
│ CS0 ──→│  │  │            │ CS  ──→├──→CS │  →CS  │
8
│ CS1 ──→│  │  │            └────────┘  Slave1   Slave2
9
│ CS2 ──→│  │  │            数据串行流过所有从机
10
└────────┘  │  │            优点:只需1个CS线
11
 Slave0  Slave1  Slave2     缺点:延迟大、配置复杂
12
每个从机独立CS线
13
优点:简单独立
14
缺点:CS线数=从机数
15

8 collapsed lines
16
方式3: QSPI(四线SPI)——Flash加速
17
┌──────┐   4根数据线    ┌───────┐
18
│ MCU  │══ D0/D1/D2/D3 ═│ Flash │
19
│ QSPI │── SCK ─────────│W25Q256│
20
│      │── CS  ─────────│       │
21
└──────┘                └───────┘
22
速率: 标准SPI的4倍(每个时钟传4位)
23
STM32 QSPI外设支持XIP(片上执行)

1
┌──────────────────────┬─────────────────┬───────────────────┐
2
│ 因素                  │ SPI              │ I2C               │
3
├──────────────────────┼─────────────────┼───────────────────┤
4
│ 输出类型             │ 推挽(Push-Pull)  │ 开漏(Open-Drain) │
5
│ 上升沿               │ 极快(ns级)      │ 受上拉电阻限制    │
6
│ 每帧开销             │ 0(纯数据)       │ 地址+ACK(9位起) │
7
│ 全双工               │ ✓(MOSI+MISO)   │ ✗(半双工)        │
8
│ 典型最高速率         │ 50MHz+          │ 3.4MHz            │
9
│ 总线线数             │ 3+N(N=从机数)   │ 2                 │
10
└──────────────────────┴─────────────────┴───────────────────┘
11
结论: SPI用"线的数量"换取"速度和简单性"

1
为什么I2C必须用开漏输出+上拉电阻？
2

3
推挽(Push-Pull):                开漏(Open-Drain):
4
  VDD         VDD                VDD
5
   │           │                  │
6
  [P-MOS]     [P-MOS]           [R] ← 上拉电阻
7
   │           │                  │
8
  ─┤out├─     ─┤out├─           ─┤out├──── 总线
9
   │           │                  │
10
  [N-MOS]     [N-MOS]           [N-MOS]
11
   │           │                  │
12
  GND         GND               GND
13

14
问题: 如果A输出高、B输出低 → 短路!   解决: 开漏只能拉低,不能主动拉高
15
                                       释放时靠上拉电阻恢复高电平
20 collapsed lines
16
                                       → "线与"(AND): 任何设备拉低→总线低
17

18
"线与"逻辑真值表:
19
  设备A  设备B  总线
20
    释放   释放   高(上拉)  → 空闲
21
    释放   拉低   低        → B在通信
22
    拉低   释放   低        → A在通信
23
    拉低   拉低   低        → 都在通信
24

25
上拉电阻选择:
26
  太大: 上升沿慢 → 限制速率
27
  太小: 功耗大,低电平可能不够低(VOL超标)
28
  ┌──────────┬─────────┬──────────┐
29
  │ 速率模式  │ 推荐Rp   │ 计算依据  │
30
  ├──────────┼─────────┼──────────┤
31
  │ 100kHz   │ 10kΩ    │ tr<1μs   │
32
  │ 400kHz   │ 4.7kΩ   │ tr<300ns │
33
  │ 1MHz     │ 2.2kΩ   │ tr<120ns │
34
  └──────────┴─────────┴──────────┘
35
  tr(上升时间) = Rp × C_bus (RC时间常数)

1
死锁场景: 从机正在发数据,主机突然复位 → 从机不知道,继续拉低SDA
2
          主机重启后发START,但SDA被从机拉低 → 发不出START!
3

4
恢复方法: 主机在SCL上连续发9个时钟脉冲
5
  → 从机每收到一个时钟就移出1位数据
6
  → 最多8位后SDA释放(加1个ACK位=9个时钟)
7
  → 主机检测SDA恢复高电平后发STOP
8

9
代码实现:
10
  void i2c_bus_recovery(void) {
11
      SDA设为输入;  // 释放SDA
12
      for (int i = 0; i < 9; i++) {
13
          SCL_HIGH(); delay_us(5);
14
          if (SDA_READ() == 1) break;  // SDA释放了
15
          SCL_LOW();  delay_us(5);
5 collapsed lines
16
      }
17
      // 发STOP
18
      SDA_LOW(); SCL_HIGH(); delay_us(5);
19
      SDA_HIGH(); delay_us(5);
20
  }

1
CAN 物理层:
2

3
          显性(Dominant, 逻辑0)            隐性(Recessive, 逻辑1)
4
CANH ──── 3.5V ──────────────       CANH ──── 2.5V ─────────────
5
                ↕ 差分2V                            ↕ 差分0V
6
CANL ──── 1.5V ──────────────       CANL ──── 2.5V ─────────────
7

8
"显性覆盖隐性" → 线与逻辑(和I2C类似但用差分实现)
9

10
为什么用差分？
11
  ┌──────────┐              ┌──────────┐
12
  │  MCU     │   CAN收发器   │          │
13
  │ CAN_TX ──├──→ TJA1050 ──├──CANH──→ │
14
  │ CAN_RX ──├──← (差分→单端)├──CANL──→ │ → 总线
15
  └──────────┘              └──────────┘
5 collapsed lines
16

17
  干扰信号同时叠加在CANH和CANL上:
18
  CANH = 3.5V + 噪声
19
  CANL = 1.5V + 噪声
20
  CANH - CANL = 2V (噪声抵消!) → 这就是差分的优势

1
                    TEC<128 且 REC<128
2
        ┌───────────────────────────────────┐
3
        │                                   │
4
        ▼                                   │
5
  ┌──────────┐  TEC≥128或REC≥128  ┌─────────────┐
6
  │ 主动错误 │───────────────────→│  被动错误    │
7
  │ (正常)   │←───────────────────│ (可通信但慢) │
8
  │Error     │  TEC<128且REC<128  │Error        │
9
  │Active    │                     │Passive      │
10
  └──────────┘                     └──────┬──────┘
11
                                          │ TEC≥256
12
                                          ▼
13
                                   ┌──────────┐
14
                                   │ 总线关闭 │
15
                                   │ Bus Off  │
12 collapsed lines
16
                                   │(节点脱离)│
17
                                   └──────┬──┘
18
                                          │ 检测到128次
19
                                          │ 11个连续隐性位
20
                                          ▼
21
                                   恢复为主动错误状态
22

23
发送/接收错误计数规则:
24
  发送1帧成功    → TEC-1
25
  发送1帧失败    → TEC+8
26
  接收1帧成功    → REC-1(如果REC>0)
27
  接收1帧校验错误 → REC+1~+8(视错误类型)

1
                     120Ω终端电阻
2
  ┌──────┐      ┌───┤          ├───┐       ┌──────┐
3
  │Master│      │   └──────────┘   │       │Slave1│
4
  │ ID=0 │──┐  ──── A(+) ──────── ──── ┌──│ ID=1 │
5
  │MAX485│  ├──┤                       ├──│MAX485│
6
  │ DE RE│  │  ──── B(-) ──────── ──── │  │ DE RE│
7
  └──┬─┬─┘  │  │   ┌──────────┐   │   │  └──┬─┬─┘
8
     │ │    │  └───┤  120Ω    ├───┘   │     │ │
9
     └─┘    │      └──────────┘       │     └─┘
10
  方向控制:  │                          │
11
  发(DE=1)   │      ┌──────┐           │
12
  收(DE=0)   └──────┤Slave2├───────────┘
13
                    │ ID=2 │
14
                    └──────┘
15

5 collapsed lines
16
总线要求:
17
  - 两端各120Ω终端电阻(匹配阻抗,消除反射)
18
  - 最长1200m(低速率时), 最多32个标准节点(高驱动收发器可256+)
19
  - 总线空闲加偏置电阻(防浮空导致误触发)
20
    A端上拉390Ω到VCC, B端下拉390Ω到GND → 空闲时A>B=隐性

1
┌──────────┬────────┬─────────┬─────────┬─────────┬─────────┬────────┐
2
│          │ UART   │ SPI     │ I2C     │ CAN     │ RS-485  │ 1-Wire │
3
├──────────┼────────┼─────────┼─────────┼─────────┼─────────┼────────┤
4
│ 线数     │ 2(+GND)│ 3+N     │ 2(+GND) │ 2(差分) │ 2(差分) │ 1(+GND)│
5
│ 时钟     │ 异步   │ 同步    │ 同步    │ 异步    │ 异步    │ 异步   │
6
│ 双工     │ 全双工 │ 全双工  │ 半双工  │ 半双工  │ 半双工  │ 半双工 │
7
│ 拓扑     │ 点对点 │ 一主多从│ 多主多从│ 多主多从│ 一主多从│ 一主多从│
8
│ 寻址     │ 无     │ CS线    │ 地址    │ 消息ID  │ 地址    │ ROM码  │
9
│ 速率     │ ≤1M   │ ≤50M+  │ ≤3.4M  │ ≤1M    │ ≤10M   │ 15kbps │
10
│ 距离     │ <1m    │ <1m     │ <1m     │ <1km    │ <1.2km  │ <300m  │
11
│ 硬件复杂 │ 低     │ 低      │ 中      │ 高      │ 低      │ 低     │
12
│ 主要场景 │ 调试   │ Flash   │ 传感器  │ 汽车    │ 工业    │ 温度   │
13
│          │ GPS    │ 显示屏  │ EEPROM  │ 工业    │ Modbus  │ iButton│
14
│ 抗干扰   │ 弱     │ 弱      │ 中      │ ★强    │ ★强    │ 中     │
15
│ 错误检测 │ 奇偶校验│ 无(需软件)│ ACK/NACK│ CRC+5种│ 依赖Modbus│ CRC   │
1 collapsed line
16
└──────────┴────────┴─────────┴─────────┴─────────┴─────────┴────────┘

1
空闲(高) ┐
2
         │  ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐
3
         └──┤起│D0│D1│D2│D3│D4│D5│D6│D7│校│停│── 空闲(高)
4
            │始│  │  │  │  │  │  │  │  │验│止│
5
            │位│  │    数据位(5~9位)     │位│位│
6
            │0 │  │    LSBFirst         │  │1 │
7
            └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
8

9
起始位: 1位, 低电平
10
数据位: 5/6/7/8/9 位 (通常 8 位)
11
校验位: 无/奇/偶 (可选)
12
停止位: 1/1.5/2 位, 高电平
13

14
常见配置: 8N1 = 8数据位 + 无校验 + 1停止位

1
RTS(Request To Send): 接收方控制(告诉发送方"我能不能收")
2
  拉低: "我准备好了,可以发"
3
  拉高: "我缓冲区快满了,别发了"
4

5
CTS(Clear To Send): 发送方检测(看接收方让不让发)
6
  检测到CTS低: 可以发送
7
  检测到CTS高: 暂停发送
8

9
连接方式(注意交叉连接!):
10
  设备A.RTS ──→ 设备B.CTS    (A告诉B: 我能不能收)
11
  设备A.CTS ←── 设备B.RTS    (B告诉A: 它能不能收)

1
START条件: SCL高电平期间, SDA产生下降沿(从高→低)
2
STOP条件:  SCL高电平期间, SDA产生上升沿(从低→高)
3

4
正常数据传输: SCL低电平时SDA可以变化(准备数据)
5
             SCL高电平时SDA必须稳定(采样数据)
6

7
时序示意图:
8
     SDA ──┐          ┌──
9
            \_________/
10
     SCL ─────┐   ┌─────
11
              └───┘
12
         START data STOP
13

14
重复START(Sr): 不发STOP直接发新START → 用于读操作(写地址后转读)

1
死锁原因:
2
  1. 通信中途复位主机 → 从机仍在驱动SDA(等待剩余时钟)
3
  2. SDA被从机拉低无法释放
4

5
表现: SDA一直为低, 主机无法发START条件
6

7
恢复方法:
8
  1. 主机发送9个SCL时钟脉冲 → 让从机移位完成释放SDA
9
  2. 如果SDA仍低 → 硬件复位从机
10
  3. 代码实现:

1
void i2c_bus_recovery(GPIO_TypeDef *port, uint16_t scl, uint16_t sda) {
2
    // 检查SDA是否被拉低
3
    if (HAL_GPIO_ReadPin(port, sda) == GPIO_PIN_RESET) {
4
        // 发送9个时钟脉冲
5
        for (int i = 0; i < 9; i++) {
6
            HAL_GPIO_WritePin(port, scl, GPIO_PIN_RESET);
7
            HAL_Delay(1);
8
            HAL_GPIO_WritePin(port, scl, GPIO_PIN_SET);
9
            HAL_Delay(1);
10
            if (HAL_GPIO_ReadPin(port, sda) == GPIO_PIN_SET)
11
                break;  // SDA释放了
12
        }
13
        // 发送STOP条件
14
        HAL_GPIO_WritePin(port, sda, GPIO_PIN_RESET);
15
        HAL_Delay(1);
5 collapsed lines
16
        HAL_GPIO_WritePin(port, scl, GPIO_PIN_SET);
17
        HAL_Delay(1);
18
        HAL_GPIO_WritePin(port, sda, GPIO_PIN_SET);
19
    }
20
}

1
方式1: 独立CS(最常用)
2
  Master ─── MOSI ──→ Slave1, Slave2, Slave3 (共享)
3
         ─── MISO ←── (共享,三态)
4
         ─── CLK  ──→ (共享)
5
         ─── CS1  ──→ Slave1 (独立)
6
         ─── CS2  ──→ Slave2 (独立)
7
         ─── CS3  ──→ Slave3 (独立)
8

9
方式2: 菊花链(Daisy Chain)
10
  Master → Slave1.MOSI → Slave1.MISO → Slave2.MOSI → ...
11
  (所有数据串行通过每个从机,适合同类设备如LED驱动链)

1
CAN总线: 显性(0)覆盖隐性(1)
2

3
  节点A发送ID: 0x123 = 001 0010 0011
4
  节点B发送ID: 0x125 = 001 0010 0101
5

6
  同时开始发送:
7
  bit位:  0  0  1  0  0  1  0  0...
8
  节点A:  0  0  1  0  0  1  0  0  1  1  ← 第9位发0(显性)
9
  节点B:  0  0  1  0  0  1  0  1  ← 第8位发1但读回0 → 仲裁失败!
10

11
  节点B检测到发出1但总线是0 → 自己退出!
12
  节点A继续发送(ID小=优先级高)
13

14
这就是为什么CAN ID越小优先级越高!

1
标准帧(11位ID):
2
  SOF(1) + ID(11) + RTR(1) + IDE(0) + r0(1) + DLC(4) + Data(0~8B) + CRC(15) + ACK(2) + EOF(7)
3

4
扩展帧(29位ID):
5
  SOF(1) + ID_A(11) + SRR(1) + IDE(1) + ID_B(18) + RTR(1) + r1(1) + r0(1) + DLC(4) + Data...
6

7
关键字段:
8
  RTR: 远程帧标志(0=数据帧, 1=远程帧)
9
  DLC: 数据长度码(0~8字节)
10
  CRC: CRC-15校验
11
  ACK: 接收方应答

1
5种错误检测:
2
  1. 位错误: 发送的位和回读不同
3
  2. 填充错误: 连续6个相同位(违反位填充规则)
4
  3. CRC错误: CRC校验失败
5
  4. 格式错误: 固定位格式不对
6
  5. ACK错误: 无节点应答
7

8
错误状态机:
9
  主动错误(Error Active): TEC/REC < 128, 正常通信
10
    ↓ 错误累积(TEC/REC >= 128)
11
  被动错误(Error Passive): 仍可通信但发被动错误帧
12
    ↓ TEC >= 256
13
  总线关闭(Bus Off): 停止通信, 需要恢复

1
// DS18B20温度读取流程
2
void ds18b20_read_temp(float *temp) {
3
    // 1. 复位脉冲(480us低电平)
4
    onewire_reset();
5
    // 2. 发送跳过ROM命令(0xCC) - 只有一个设备时
6
    onewire_write_byte(0xCC);
7
    // 3. 发送温度转换命令(0x44)
8
    onewire_write_byte(0x44);
9
    // 4. 等待转换(最长750ms)
10
    delay_ms(750);
11
    // 5. 再次复位
12
    onewire_reset();
13
    onewire_write_byte(0xCC);
14
    // 6. 读暂存器命令(0xBE)
15
    onewire_write_byte(0xBE);
6 collapsed lines
16
    // 7. 读取2字节温度数据
17
    uint8_t lsb = onewire_read_byte();
18
    uint8_t msb = onewire_read_byte();
19
    int16_t raw = (msb << 8) | lsb;
20
    *temp = raw * 0.0625f;
21
}

1
// HAL库SPI DMA发送
2
HAL_SPI_Transmit_DMA(&hspi1, tx_buf, len);
3

4
// 完成回调
5
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
6
    spi_tx_done = 1;
7
}
8

9
// 寄存器级配置要点:
10
// 1. 配置DMA通道(源=内存,目标=SPI_DR)
11
// 2. 配置传输长度
12
// 3. 使能SPI的DMA请求(SPI_CR2_TXDMAEN)
13
// 4. 启动DMA传输

1
// 读取JEDEC ID
2
uint8_t cmd = 0x9F;
3
uint8_t id[3];
4
CS_LOW();
5
spi_write(&cmd, 1);
6
spi_read(id, 3);  // Manufacturer + Memory Type + Capacity
7
CS_HIGH();
8

9
// 页编程(写,最大256字节/页)
10
void flash_page_program(uint32_t addr, uint8_t *data, uint16_t len) {
11
    flash_write_enable();  // 发送0x06
12
    CS_LOW();
13
    uint8_t cmd[4] = {0x02, addr>>16, addr>>8, addr};
14
    spi_write(cmd, 4);
15
    spi_write(data, len);
13 collapsed lines
16
    CS_HIGH();
17
    flash_wait_busy();  // 等待编程完成
18
}
19

20
// 扇区擦除(4KB)
21
void flash_sector_erase(uint32_t addr) {
22
    flash_write_enable();
23
    CS_LOW();
24
    uint8_t cmd[4] = {0x20, addr>>16, addr>>8, addr};
25
    spi_write(cmd, 4);
26
    CS_HIGH();
27
    flash_wait_busy();  // 擦除需要几十~几百ms
28
}

1
正常: 主机始终控制SCL
2
时钟拉伸: 从机在ACK后拉住SCL(低电平) → 主机检测到SCL为低 → 等待
3

4
用途: 从机处理速度慢时请求主机等待
5
注意: 不是所有主机支持时钟拉伸(某些GPIO模拟I2C不支持)

1
CAN_FilterTypeDef filter;
2
filter.FilterBank = 0;
3
filter.FilterMode = CAN_FILTERMODE_IDMASK;  // ID+掩码模式
4
filter.FilterScale = CAN_FILTERSCALE_32BIT;
5

6
// 只接收ID=0x123的帧
7
filter.FilterIdHigh = 0x123 << 5;     // 标准ID左移5位
8
filter.FilterIdLow = 0x0000;
9
filter.FilterMaskIdHigh = 0x7FF << 5; // 全部位都要匹配
10
filter.FilterMaskIdLow = 0x0000;
11

12
filter.FilterFIFOAssignment = CAN_RX_FIFO0;
13
filter.FilterActivation = ENABLE;
14
HAL_CAN_ConfigFilter(&hcan, &filter);

1
// RS-485方向引脚控制
2
#define RS485_TX_EN()  HAL_GPIO_WritePin(DE_GPIO, DE_PIN, GPIO_PIN_SET)
3
#define RS485_RX_EN()  HAL_GPIO_WritePin(DE_GPIO, DE_PIN, GPIO_PIN_RESET)
4

5
void rs485_send(uint8_t *data, uint16_t len) {
6
    RS485_TX_EN();               // 切换到发送模式
7
    HAL_UART_Transmit(&huart, data, len, 1000);
8
    while (__HAL_UART_GET_FLAG(&huart, UART_FLAG_TC) == RESET);  // 等发完
9
    RS485_RX_EN();               // 切回接收模式
10
}

1
uint16_t modbus_crc16(uint8_t *buf, uint16_t len) {
2
    uint16_t crc = 0xFFFF;
3
    for (uint16_t i = 0; i < len; i++) {
4
        crc ^= buf[i];
5
        for (uint8_t j = 0; j < 8; j++) {
6
            if (crc & 0x0001)
7
                crc = (crc >> 1) ^ 0xA001;
8
            else
9
                crc >>= 1;
10
        }
11
    }
12
    return crc;
13
}
14

15
// 验证:发送帧末尾2字节CRC
1 collapsed line
16
// 接收方重新计算整帧(含CRC)的CRC, 结果应为0

1
// 帧头: 0x7E, 转义: 0x7D
2
// 如果数据中出现0x7E → 替换为 0x7D 0x5E
3
// 如果数据中出现0x7D → 替换为 0x7D 0x5D
4

5
int stuff_byte(uint8_t *out, uint8_t byte) {
6
    if (byte == 0x7E) {
7
        out[0] = 0x7D; out[1] = 0x5E; return 2;
8
    } else if (byte == 0x7D) {
9
        out[0] = 0x7D; out[1] = 0x5D; return 2;
10
    }
11
    out[0] = byte; return 1;
12
}
13

14
// PPP/HDLC协议就使用这种方式

1
// 推荐: DMA + IDLE中断(STM32)
2
HAL_UARTEx_ReceiveToIdle_DMA(&huart, rx_buf, BUF_SIZE);
3

4
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {
5
    // Size = 本次接收的字节数
6
    process_data(rx_buf, Size);
7
    HAL_UARTEx_ReceiveToIdle_DMA(huart, rx_buf, BUF_SIZE);
8
}

1
typedef enum {  // 枚举定义
2
    STATE_IDLE,
3
    STATE_HEAD,
4
    STATE_LENGTH,
5
    STATE_DATA,
6
    STATE_CRC
7
} RxState;
8

9
static RxState state = STATE_IDLE;
10
static uint8_t frame[256];
11
static uint16_t pos = 0;
12
static uint16_t expected_len = 0;
13

14
void protocol_byte_input(uint8_t byte) {
15
    switch (state) {
25 collapsed lines
16
    case STATE_IDLE:
17
        if (byte == FRAME_HEAD) {
18
            frame[pos++] = byte;
19
            state = STATE_HEAD;
20
        }
21
        break;
22
    case STATE_HEAD:
23
        frame[pos++] = byte;  // 长度字段
24
        expected_len = byte;
25
        state = STATE_DATA;
26
        break;
27
    case STATE_DATA:
28
        frame[pos++] = byte;
29
        if (pos >= expected_len + 2)  // head + len + data
30
            state = STATE_CRC;
31
        break;
32
    case STATE_CRC:
33
        frame[pos++] = byte;
34
        if (verify_crc(frame, pos))
35
            dispatch_frame(frame, pos);
36
        pos = 0;
37
        state = STATE_IDLE;
38
        break;
39
    }
40
}