硬件模块与通信协议基础

一句话结论

所有协议的本质都是"用电平变化表达比特"。吃透 GPIO / UART / I2C / SPI 这四条，90% 的模块都能接；剩下 10% 是 PWM（输出模拟量）、ADC（读模拟量）和 CAN（长距离抗干扰）。遇到模块先问三句：几根线、什么电平、有没有上拉——这三句话能解决大半接线问题。

一、GPIO：一切的基础

1.1 原理速览

GPIO（General Purpose Input/Output）是软件可控的数字引脚，只有两种状态：高电平（逻辑 1，约等于 VCC）与低电平（逻辑 0，约等于 0 V）。

⚠️ 注意：单个 GPIO 的输出电流典型为 8–20 mA，整片芯片所有 IO 的总电流也有限制（常见 100–200 mA 量级，以数据手册为准）。绝不能用 GPIO 直接驱动电机、继电器线圈、大功率灯珠——要么烧 IO，要么把整片拉复位。驱动大负载一律走三极管/MOS/驱动芯片，并且独立供电、只共地。

1.2 典型接线

LED 限流电阻计算：R = (VCC - Vf) / I。5 V 供电、红色 LED（Vf≈2.0 V）、想要 10 mA：R = (5 - 2.0) / 0.01 = 300 Ω，取标称 330 Ω。

1.3 代码示例

// Arduino C++：按键控制 LED（内部上拉 + 软件消抖）
const uint8_t PIN_LED = 2;    // ESP32 DevKitC 板载 LED
const uint8_t PIN_KEY = 4;

volatile bool keyPressed = false;
uint32_t lastMs = 0;

void IRAM_ATTR isrKey() {          // 中断服务函数要短，只做标记
  keyPressed = true;
}

void setup() {
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_KEY, INPUT_PULLUP);  // 内部上拉：未按下=HIGH，按下=LOW
  attachInterrupt(digitalPinToInterrupt(PIN_KEY), isrKey, FALLING);
  Serial.begin(115200);
}

void loop() {
  // 轮询消抖：连续两次读到低电平且间隔 > 20 ms 才认为按下
  static int lastStable = HIGH;
  int cur = digitalRead(PIN_KEY);
  if (cur != lastStable) {
    if (millis() - lastMs > 20) {  // 20 ms 消抖窗口，机械按键一般 5–20 ms
      lastStable = cur;
      if (cur == LOW) Serial.println("key pressed");
    }
    lastMs = millis();
  }

  if (keyPressed) {
    keyPressed = false;
    digitalWrite(PIN_LED, !digitalRead(PIN_LED));  // 翻转
  }
}

# MicroPython（ESP32 / RP2040 / 部分 STM32）
from machine import Pin
import time

led = Pin(2, Pin.OUT)
key = Pin(4, Pin.IN, Pin.PULL_UP)      # 内部上拉

last = 1
last_ms = 0

while True:
    cur = key.value()
    now = time.ticks_ms()
    if cur != last:
        if time.ticks_diff(now, last_ms) > 20:   # 20 ms 消抖
            last = cur
            if cur == 0:
                print("key pressed")
                led.value(not led.value())
        last_ms = now
    time.sleep_ms(5)

# 树莓派 / Linux（libgpiod v2.x，推荐）
import gpiod, time
from gpiod.line import Direction, Bias, Edge

chip = gpiod.Chip('/dev/gpiochip0')
req = chip.request_lines(
    consumer="key-led",
    config={
        17: gpiod.LineSettings(direction=Direction.OUTPUT),
        27: gpiod.LineSettings(direction=Direction.INPUT,
                               bias=Bias.PULL_UP,
                               edge_detection=Edge.FALLING),
    }
)

while True:
    # 阻塞等待边沿事件，超时 1 秒；比轮询省 CPU
    if req.wait_edge_events(timeout=1):
        for ev in req.read_edge_events():
            print("falling on line", ev.line_offset)
            req.set_values({17: gpiod.line.Value(1)})
            time.sleep(0.2)
            req.set_values({17: gpiod.line.Value(0)})

1.4 GPIO 故障排查

二、UART：最常用也最容易踩坑

2.1 原理速览

UART（Universal Asynchronous Receiver/Transmitter）是异步串行通信：没有时钟线，靠双方约定同样的波特率来采样数据。

一帧数据的格式：起始位（1 bit，低电平）+ 数据位（5–9 bit，通常 8）+ 校验位（0 或 1 bit）+ 停止位（1/1.5/2 bit，高电平）。

常见配置写法：115200 8N1 = 波特率 115200、8 数据位、无校验、1 停止位。

2.2 电平标准：TTL / RS232 / RS485 / RS422

为什么差分能抗干扰：TTL/RS232 用单端信号（对 GND 的电压），长线上 GND 压降和空间耦合的共模噪声会直接叠加到信号上；RS485/RS422 用两条线的电压差表示逻辑，干扰同时耦合到 A、B 两线上（共模），差值基本不变，接收器只认差值，于是噪声被抵消。这也是它能跑上千米的根本原因。

⚠️ 注意：RS232 的 ±12 V 直接接到 MCU 的 TTL 引脚会瞬间烧毁。RS485 的差分电平同样不能直连 MCU。必须经过 MAX232 / MAX485 这类**收发器（transceiver）**转换，且在 MCU 一侧测出来的是 TTL 电平。

2.3 典型接线

RS485 半双工方向控制：DE 和 RE（通常短接）拉高 = 发送，拉低 = 接收。发送前拉高，发完（等最后一个字节发完）再拉低。

2.4 代码示例

// Arduino C++：ESP32 使用 Serial2 与 GPS/蓝牙模块通信
// 硬件：Serial2 默认 RX=GPIO16, TX=GPIO17（ESP32）；ESP32-S3/C3 需显式指定引脚
#define RXD2 16
#define TXD2 17

void setup() {
  Serial.begin(115200);                       // USB 调试串口
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2); // 模块串口：9600 8N1
  Serial.println("UART bridge start");
}

void loop() {
  // USB 串口收到数据 → 转发给模块
  while (Serial.available()) {
    Serial2.write(Serial.read());
  }
  // 模块返回数据 → 转发到 USB 串口
  while (Serial2.available()) {
    Serial.write(Serial2.read());
  }
}

// Arduino C++：RS485 半双工发送（Modbus RTU 请求帧示例）
#define DE_PIN  5          // 控制 MAX485 的 DE/RE
#define RXD2   16
#define TXD2   17
HardwareSerial rs485(2);

// 读保持寄存器：从机地址 0x01，功能码 0x03，起始地址 0x0000，数量 0x0002
uint8_t req[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0xC4, 0x0B}; // CRC 需按实际计算

void setup() {
  pinMode(DE_PIN, OUTPUT);
  digitalWrite(DE_PIN, LOW);          // 默认接收
  rs485.begin(9600, SERIAL_8N1, RXD2, TXD2);
}

void sendRequest() {
  digitalWrite(DE_PIN, HIGH);         // 切到发送
  delayMicroseconds(10);
  rs485.write(req, sizeof(req));
  rs485.flush();                      // 等发送完成（等移位寄存器空）
  delayMicroseconds(500);             // 按波特率留足够时间，115200 可更短
  digitalWrite(DE_PIN, LOW);          // 切回接收
}

void loop() {
  sendRequest();
  uint32_t t0 = millis();
  while (millis() - t0 < 500) {
    if (rs485.available()) Serial.printf("%02X ", rs485.read());
  }
  Serial.println();
  delay(1000);
}

# MicroPython：UART 收发与 Modbus CRC16 计算
from machine import UART, Pin
import time

uart = UART(2, baudrate=9600, tx=17, rx=16, bits=8, parity=None, stop=1, timeout=100)
de = Pin(5, Pin.OUT, value=0)          # RS485 方向控制

def crc16(data: bytes) -> bytes:
    crc = 0xFFFF
    for b in data:
        crc ^= b
        for _ in range(8):
            if crc & 1:
                crc = (crc >> 1) ^ 0xA001
            else:
                crc >>= 1
    return crc.to_bytes(2, 'little')   # Modbus 是低字节在前

def modbus_read(addr, reg, count):
    pdu = bytes([addr, 0x03]) + reg.to_bytes(2, 'big') + count.to_bytes(2, 'big')
    frame = pdu + crc16(pdu)
    de.value(1)
    time.sleep_us(10)
    uart.write(frame)
    time.sleep_us(500)
    de.value(0)
    return uart.read()

while True:
    r = modbus_read(1, 0x0000, 2)
    print("resp:", r.hex() if r else "timeout")
    time.sleep(1)

# 树莓派 / Linux 上用 Python（pyserial）
# pip install pyserial
import serial, serial.tools.list_ports

# 列出所有串口（找设备最快的办法）
for p in serial.tools.list_ports.comports():
    print(f"{p.device}\t{p.description}\tVID:PID={p.vid:04X}:{p.pid:04X}" if p.vid else p.device)

ser = serial.Serial(
    port='/dev/ttyUSB0',
    baudrate=115200,
    bytesize=serial.EIGHTBITS,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    timeout=1,              # 读超时，避免 read() 永久阻塞
    rtscts=False,
    dsrdtr=False,
)
# ⚠️ pyserial 打开串口时 DTR 会拉低，导致 ESP32/Arduino 复位。不想要就：
# ser = serial.Serial(..., dsrdtr=False)
# 或在 open 后立即：ser.setDTR(False); ser.setRTS(False)

ser.write(b"AT\r\n")
line = ser.readline()
print("recv:", line)

# 非阻塞读 + 十六进制打印（调试二进制协议时用）
while True:
    if ser.in_waiting:
        data = ser.read(ser.in_waiting)
        print(data.hex(' '))
ser.close()

2.5 UART 故障排查

三、I2C：两根线挂一堆设备

3.1 原理速览

I2C（Inter-Integrated Circuit，读"I-squared-C"或"I-two-C"）是同步、半双工、多主多从的两线串行总线。

为什么必须开漏 + 上拉：如果多个设备用推挽输出，A 设备输出高（内部拉到 VCC）、B 设备输出低（内部拉到 GND），电源会直接通过两个 MOS 管短路。开漏只拉低不拉高，配合上拉电阻形成"线与"逻辑：任何一设备拉低，总线就是低——这正是多设备共享总线和仲裁的基础。

3.2 典型接线

⚠️ 注意：3.3 V 与 5 V 模块混挂时，上拉电阻接到哪一边要谨慎。上拉到 5 V 会把 3.3 V 设备的 IO 拉到 5 V，可能损坏。统一上拉到 3.3 V，并确认 5 V 设备能识别 3.3 V 为高电平（多数 5 V CMOS 可以，但裕量小），必要时用双向 MOS 电平转换模块。

3.3 代码：地址扫描 + 读写

// Arduino C++：I2C 地址扫描（拿到任何 I2C 模块先跑这个）
#include <Wire.h>

#define SDA_PIN 21      // ESP32 默认；Uno 用 A4/A5，不用显式指定
#define SCL_PIN 22

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);      // AVR 上写 Wire.begin()
  Wire.setClock(100000);             // 100 kHz，扫不到就降速试
  Serial.println("\nI2C Scanner");
}

void loop() {
  int found = 0;
  Serial.println("Scanning...");
  for (uint8_t addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    uint8_t err = Wire.endTransmission();   // 0 = 有应答
    if (err == 0) {
      Serial.printf("  found 0x%02X (%u)\n", addr, addr);
      found++;
    } else if (err == 4) {
      Serial.printf("  error at 0x%02X\n", addr);
    }
  }
  Serial.printf("total: %d device(s)\n\n", found);
  delay(5000);
}

// Arduino C++：读写 I2C 设备寄存器（以 SSD1306 / 通用 EEPROM 为例）
#include <Wire.h>
#define DEV_ADDR 0x3C

// 写：设备地址 → 寄存器地址 → 数据
void i2cWriteReg(uint8_t addr, uint8_t reg, uint8_t val) {
  Wire.beginTransmission(addr);
  Wire.write(reg);
  Wire.write(val);
  uint8_t err = Wire.endTransmission();
  if (err) Serial.printf("write err %u\n", err);
}

// 读：先写寄存器地址（不停止），再重新起始并读 N 字节
uint8_t i2cReadReg(uint8_t addr, uint8_t reg) {
  Wire.beginTransmission(addr);
  Wire.write(reg);
  Wire.endTransmission(false);        // false = Repeated Start，不释放总线
  Wire.requestFrom(addr, (uint8_t)1);
  if (Wire.available()) return Wire.read();
  return 0xFF;
}

// 连续读多字节
void i2cReadBytes(uint8_t addr, uint8_t reg, uint8_t *buf, size_t len) {
  Wire.beginTransmission(addr);
  Wire.write(reg);
  Wire.endTransmission(false);
  Wire.requestFrom(addr, (uint8_t)len);
  for (size_t i = 0; i < len && Wire.available(); i++) buf[i] = Wire.read();
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  i2cWriteReg(DEV_ADDR, 0x00, 0xAE);   // SSD1306 关显示命令
  uint8_t v = i2cReadReg(DEV_ADDR, 0x00);
  Serial.printf("reg 0x00 = 0x%02X\n", v);
}
void loop() {}

# MicroPython：I2C 扫描 + 读写（machine.I2C 与软 I2C 都支持）
from machine import Pin, I2C
import time

# 硬件 I2C
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=100000)
# 软件 I2C（任意引脚，速率低但灵活）
# i2c = I2C(-1, scl=Pin(22), sda=Pin(21), freq=100000)

print("scan:", [hex(a) for a in i2c.scan()])   # 返回 7 位地址列表

ADDR = 0x3C
# 写
i2c.writeto(ADDR, bytes([0x00, 0xAE]))         # 控制字节 0x00 表示后续是命令
# 写寄存器再读（带 repeated start）
i2c.writeto(ADDR, bytes([0x00]), False)        # False = 不发送 STOP
data = i2c.readfrom(ADDR, 1)
print("read:", data.hex())
# 直接读/写内存地址（多数传感器用这个）
# data = i2c.readfrom_mem(ADDR, 0x75, 1)       # 读 WHO_AM_I
# i2c.writeto_mem(ADDR, 0x6B, bytes([0x00]))   # 唤醒 MPU6050

# 树莓派 / Linux：命令行工具（不用写代码就能验证）
# sudo apt install i2c-tools
i2cdetect -y 1              # 扫描总线 1（老 Pi 是 0）
i2cdetect -y 1 0x20 0x27    # 只扫一段地址
i2cdump  -y 1 0x68          # dump 整个设备的寄存器（MPU6050）
i2cget   -y 1 0x68 0x75     # 读单个寄存器（WHO_AM_I，应返回 0x68）
i2cset   -y 1 0x68 0x6B 0x00   # 写寄存器（唤醒 MPU6050）
i2cdetect -l                # 列出所有 I2C 总线

# 树莓派 / Linux：Python（smbus2，比老 smbus 好用）
# pip install smbus2
from smbus2 import SMBus, i2c_msg

with SMBus(1) as bus:                  # 1 = /dev/i2c-1
    # 扫地址
    found = []
    for addr in range(0x03, 0x78):
        try:
            bus.read_byte(addr)
            found.append(hex(addr))
        except OSError:
            pass
    print("found:", found)

    # 写寄存器
    bus.write_byte_data(0x68, 0x6B, 0x00)     # addr, reg, value
    # 读寄存器
    who = bus.read_byte_data(0x68, 0x75)
    print(f"WHO_AM_I = 0x{who:02X}")          # MPU6050 应为 0x68

    # 连续读（block read，注意部分设备需要 repeated start）
    msg_w = i2c_msg.write(0x68, [0x3B])
    msg_r = i2c_msg.read(0x68, 14)            # 加速度+温度+陀螺仪 14 字节
    bus.i2c_rdwr(msg_w, msg_r)
    print(list(msg_r))

3.4 I2C 故障排查

四、SPI：速度最快，线也最多

4.1 原理速览

SPI（Serial Peripheral Interface）是同步、全双工、主从结构的四线总线，由 Motorola 提出，速度远快于 I2C。

全双工意味着：主机每发一个字节，从机同时回一个字节。所以"读"操作本质上是"发一个哑元字节（通常 0x00 或 0xFF）换回一个真实字节"。这是 SPI 与 I2C 最大的思维差异。

多从机：所有从机共享 SCK/MOSI/MISO，各自独占一根 CS。同一时刻只能拉低一根 CS。被选中的从机才驱动 MISO，其他从机的 MISO 必须是高阻态（否则会打架）。

4.2 四种模式：CPOL 与 CPHA

⚠️ 注意：模式配错的典型症状不是"完全不通"，而是"数据整体错位一位"（比如读出来全差一半，或者最高位丢失）。这是 SPI 故障里最好认也最容易被误判为"模块坏了"的现象。不确定就四种模式全试一遍。

另外还有 MSB First / LSB First（位序）与 8 位 / 16 位数据帧 两个参数，错位时也要排查。

4.3 典型接线（以 ESP32 + SSD1306 或 W25Qxx 为例）

4.4 代码示例

// Arduino C++：SPI 读写（以 W25Qxx Flash 读 JEDEC ID 为例，Mode 0）
#include <SPI.h>
#include <Arduino.h>

#define PIN_CS   5
#define PIN_SCK  18
#define PIN_MISO 19
#define PIN_MOSI 23

SPISettings spiCfg(1000000, MSBFIRST, SPI_MODE0);   // 1 MHz, MSB 优先, Mode 0

void setup() {
  Serial.begin(115200);
  pinMode(PIN_CS, OUTPUT);
  digitalWrite(PIN_CS, HIGH);          // 片选默认拉高（不选中）
  SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI, PIN_CS);
}

// 通用传输：发一个字节换回一个字节
uint8_t spiXfer(uint8_t tx) {
  SPI.beginTransaction(spiCfg);
  digitalWrite(PIN_CS, LOW);
  uint8_t rx = SPI.transfer(tx);
  digitalWrite(PIN_CS, HIGH);
  SPI.endTransaction();
  return rx;
}

// 读 JEDEC ID：发 0x9F，接着读 3 字节（厂商 + 容量类型 + 容量）
void readJedec(uint8_t *id) {
  SPI.beginTransaction(spiCfg);
  digitalWrite(PIN_CS, LOW);
  SPI.transfer(0x9F);
  id[0] = SPI.transfer(0x00);          // 哑元字节换数据
  id[1] = SPI.transfer(0x00);
  id[2] = SPI.transfer(0x00);
  digitalWrite(PIN_CS, HIGH);
  SPI.endTransaction();
}

void loop() {
  uint8_t id[3];
  readJedec(id);
  Serial.printf("JEDEC: %02X %02X %02X  (容量约 %u MB)\n",
                id[0], id[1], id[2], 1UL << (id[2] - 20));   // 容量编码以数据手册为准
  delay(2000);
}

// Arduino C++：SPI 多从机（两个设备各一根 CS，切 CS 前必须 beginTransaction）
#include <SPI.h>
#define CS_FLASH 5
#define CS_DISP  15

SPISettings cfgFlash(4000000, MSBFIRST, SPI_MODE0);
SPISettings cfgDisp (8000000, MSBFIRST, SPI_MODE3);   // 不同设备可不同速率/模式

void selectDevice(uint8_t cs, SPISettings cfg) {
  SPI.beginTransaction(cfg);
  digitalWrite(cs, LOW);
}
void deselectDevice(uint8_t cs) {
  digitalWrite(cs, HIGH);
  SPI.endTransaction();     // 释放总线，允许下一个设备用不同配置
}

void setup() {
  pinMode(CS_FLASH, OUTPUT); digitalWrite(CS_FLASH, HIGH);
  pinMode(CS_DISP,  OUTPUT); digitalWrite(CS_DISP,  HIGH);
  SPI.begin(18, 19, 23);
}

void loop() {
  selectDevice(CS_FLASH, cfgFlash);
  SPI.transfer(0x9F);
  uint8_t mf = SPI.transfer(0x00);
  deselectDevice(CS_FLASH);

  selectDevice(CS_DISP, cfgDisp);
  SPI.transfer(0xAA);
  deselectDevice(CS_DISP);

  delay(1000);
}

# MicroPython：SPI 读写
from machine import Pin, SPI
import time

spi = SPI(2, baudrate=1_000_000, polarity=0, phase=0,
          bits=8, firstbit=SPI.MSB, sck=Pin(18), mosi=Pin(23), miso=Pin(19))
cs = Pin(5, Pin.OUT, value=1)

def xfer(tx: bytes) -> bytes:
    cs.value(0)
    rx = spi.read(len(tx), tx[0]) if len(tx) == 1 else bytearray(len(tx))
    cs.value(1)
    return rx

# 读写混合：write_readinto 是最常用的 API
def read_jedec():
    cs.value(0)
    out = bytearray(4)
    spi.write_readinto(b'\x9f\x00\x00\x00', out)
    cs.value(1)
    return out[1:4]

print("JEDEC:", read_jedec().hex())

# 树莓派 / Linux：spidev
# sudo raspi-config → Interface Options → SPI → Enable；确认 /dev/spidev0.0 存在
# pip install spidev
import spidev

spi = spidev.SpiDev()
spi.open(0, 0)                 # bus 0, device 0（CE0）
spi.max_speed_hz = 1_000_000
spi.mode = 0                   # CPOL=0, CPHA=0
spi.bits_per_word = 8
spi.lsbfirst = False

# 全双工传输：发几个字节就收回几个字节
resp = spi.xfer2([0x9F, 0x00, 0x00, 0x00])
print("JEDEC:", bytes(resp[1:4]).hex())

spi.close()

# 命令行验证 SPI 是否启用
ls /dev/spidev*
lsmod | grep spi_bcm2835
dmesg | grep -i spi

4.5 SPI 故障排查

五、PWM：用数字引脚输出"模拟量"

5.1 原理速览

PWM（Pulse Width Modulation）靠快速开关来改变一个周期内高电平所占的比例。

5.2 两类典型参数的差异（最容易搞混的地方）

5.3 代码示例

// Arduino C++：ESP32 的 LEDC 硬件 PWM（舵机 + LED 调光各一路）
#define SERVO_PIN 18
#define LEDC_PIN  19

// ESP32 Arduino 3.x 新版 LEDC API
const int SERVO_FREQ = 50;        // 舵机必须 50 Hz
const int SERVO_RES  = 14;        // 14 位分辨率：(2^14 - 1) 对应 20 ms
const int LED_FREQ   = 5000;      // LED 调光 5 kHz
const int LED_RES    = 10;        // 10 位 = 1024 档

// 角度 → 占空比计数：脉宽 us → duty
uint32_t angleToDuty(int angle) {
  // 0.5 ms ~ 2.5 ms 映射 0° ~ 180°
  float us = 500.0 + (float)angle * (2000.0 / 180.0);
  return (uint32_t)(us * (1 << SERVO_RES) / (1000000.0 / SERVO_FREQ));
}

void setup() {
  Serial.begin(115200);
  ledcAttach(SERVO_PIN, SERVO_FREQ, SERVO_RES);
  ledcAttach(LEDC_PIN,  LED_FREQ,   LED_RES);
}

void loop() {
  // 舵机 0° → 90° → 180° 扫动
  for (int a = 0; a <= 180; a += 10) {
    ledcWrite(SERVO_PIN, angleToDuty(a));
    delay(200);
  }
  // LED 呼吸灯
  for (int d = 0; d < 1024; d += 8) { ledcWrite(LEDC_PIN, d); delay(5); }
  for (int d = 1023; d >= 0; d -= 8) { ledcWrite(LEDC_PIN, d); delay(5); }
}

// Arduino C++：Arduino Uno（AVR）的 Servo 库写法
#include <Servo.h>
Servo myservo;

void setup() {
  myservo.attach(9);        // D9/D10 支持 Servo 库（用 16 位定时器）
  myservo.write(90);        // 直接写角度，库内部处理 50 Hz 与脉宽
}

void loop() {
  myservo.write(0);   delay(1000);
  myservo.write(90);  delay(1000);
  myservo.write(180); delay(1000);
}

# MicroPython：PWM（舵机 + LED）
from machine import Pin, PWM
import time

servo = PWM(Pin(18), freq=50, duty_u16=0)
led   = PWM(Pin(19), freq=5000, duty_u16=0)

# duty_u16 是 0–65535 的 16 位值
def angle_to_duty(a):
    us = 500 + a * (2000 / 180)          # 0.5–2.5 ms
    return int(us * 65535 / 20000)       # 周期 20 ms = 20000 us

while True:
    for a in range(0, 181, 10):
        servo.duty_u16(angle_to_duty(a))
        time.sleep(0.2)

    for d in range(0, 65536, 1000):      # 呼吸灯
        led.duty_u16(d)
        time.sleep_ms(5)
    for d in range(65535, -1, -1000):
        led.duty_u16(d)
        time.sleep_ms(5)

# 树莓派：硬件 PWM 只有 GPIO12/13/18/19（PWM0/PWM1），
# gpiozero 的 PWMLED 是软件 PWM，舵机抖动大；精确舵机建议用 pigpio
from gpiozero import PWMLED, AngularServo
from time import sleep

led = PWMLED(17)
for i in range(100):
    led.value = i / 100
    sleep(0.02)

# Servo：min_pulse_width / max_pulse_width 单位是秒
s = AngularServo(18, min_angle=0, max_angle=180,
                 min_pulse_width=0.5/1000, max_pulse_width=2.5/1000)
s.angle = 0;   sleep(1)
s.angle = 90;  sleep(1)
s.angle = 180; sleep(1)
s.detach()          # 停止发脉冲，舵机不再维持力矩（省电、防抖动）

5.4 PWM 故障排查

六、ADC：把模拟世界读进数字系统

6.1 原理速览

换算公式：电压 = 读数 / (2^分辨率 - 1) × Vref（严格说是 读数 / 2^分辨率 × Vref，两者差异可忽略）。

6.2 用电阻分压测高于 VCC 的电压

V_in ── R1 ──┬── 到 ADC 引脚
             │
             R2
             │
            GND

V_adc = V_in × R2 / (R1 + R2)
V_in  = V_adc × (R1 + R2) / R2

例：测 0–12 V，R1 = 30 kΩ、R2 = 7.5 kΩ → 分压比 7.5/(30+7.5) = 1/5，12 V 输入时 ADC 看到 2.4 V（在 3.3 V 量程内）。反算：V_in = V_adc × 5。

实用要点：

⚠️ 注意：分压电阻一旦失效（虚焊、错值），高压会直接灌进 ADC 引脚。用于测动力电/电池组的分压电路，务必加钳位保护并留足功率余量。

6.3 ESP32 的 ADC 非线性（必知坑）

6.4 代码示例

// Arduino C++：ESP32 ADC 采样 + 分压换算 + 滑动平均
#define ADC_PIN   34          // ADC1 通道，仅输入
#define SAMPLES   64          // 多次平均降噪
#define R1        30000.0     // 分压上臂 30 kΩ
#define R2        7500.0      // 分压下臂 7.5 kΩ
#define VREF_MV   3300.0      // 参考电压（用万用表实测校准更准）

const float DIV = (R1 + R2) / R2;   // 分压倍数 = 5.0

void setup() {
  Serial.begin(115200);
  analogReadResolution(12);         // 12 位 → 0–4095
  analogSetAttenuation(ADC_11db);   // 扩展量程（约 0–3.3 V，以数据手册为准）
}

uint32_t readAvg(int pin, int n) {
  uint64_t sum = 0;
  for (int i = 0; i < n; i++) {
    sum += analogRead(pin);
    delayMicroseconds(100);
  }
  return sum / n;
}

void loop() {
  uint32_t raw = readAvg(ADC_PIN, SAMPLES);
  uint32_t mv  = analogReadMilliVolts(ADC_PIN);     // ESP32 提供的校准后电压(mV)
  float v_adc  = mv / 1000.0;
  float v_in   = v_adc * DIV;                       // 还原真实电压

  Serial.printf("raw=%u  ADC=%u mV (%.3f V)  Vin=%.3f V\n",
                raw, mv, v_adc, v_in);
  delay(500);
}

// Arduino C++：STM32（HAL）ADC 采样 + 内部温度传感器思路
// CubeMX 里把 ADC1 的通道配成对应引脚，生成代码后：
uint32_t readAdc(ADC_HandleTypeDef *hadc) {
  HAL_ADC_Start(hadc);
  if (HAL_ADC_PollForConversion(hadc, 100) == HAL_OK) {
    uint32_t v = HAL_ADC_GetValue(hadc);
    HAL_ADC_Stop(hadc);
    return v;
  }
  HAL_ADC_Stop(hadc);
  return 0xFFFFFFFF;
}

// 调用：float volt = readAdc(&hadc1) * 3.3f / 4095.0f;   // 12 位，Vref=3.3V

# MicroPython：ADC 采样（注意 ESP32 需配置衰减）
from machine import ADC, Pin, atten
import time

adc = ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)      # 扩展量程到约 3.3 V（具体范围以数据手册为准）
adc.width(ADC.WIDTH_12BIT)    # 0–4095

DIV = 5.0
while True:
    raw = adc.read()                 # 12 位原始值
    mv  = adc.read_uv() // 1000      # 微伏转毫伏（校准后的值）
    print(f"raw={raw}  {mv} mV  Vin={mv/1000*DIV:.3f} V")
    time.sleep(0.5)

# 树莓派：外接 ADS1115（16 位 I2C ADC），树莓派本身没有 ADC
# pip install adafruit-circuitpython-ads1x15
import board, busio, time
import adafruit_ads1x15.ads1115 as ADS
from adafruit_ads1x15.analog_in import AnalogIn

i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c, address=0x48)
ads.gain = 1            # ±4.096 V 量程；gain=2/3 → ±6.144 V
chan = AnalogIn(ads, ADS.P0)     # A0 通道

while True:
    print(f"raw={chan.value:6d}  {chan.voltage:.4f} V")
    time.sleep(0.5)

6.5 ADC 故障排查

七、CAN：车载与工业的总线

7.1 原理速览

CAN（Controller Area Network）由 Bosch 为汽车设计，是差分、多主、带仲裁与错误检测的串行总线。

7.2 接线

节点A                                        节点B
MCU ── CAN_TX ──> 收发器 TXD               收发器 TXD <── CAN_TX ── MCU
     <── CAN_RX ──     RXD                      RXD ──> CAN_RX
                        CAN_H ───────────────────── CAN_H
                        CAN_L ───────────────────── CAN_L
                         ├─ 120Ω（仅两端节点接）─┤

⚠️ 注意：CAN 收发器的 CAN_H/CAN_L 不能直接接 MCU 引脚（差分电平不兼容且电压可能超出 IO 耐压）。MCU 侧永远是 TTL 的 CAN_TX/CAN_RX，经收发器转成差分。

7.3 代码示例

// Arduino C++：ESP32 TWAI（内置 CAN 控制器）发送 + 接收
#include <driver/twai.h>
#include <Arduino.h>

#define CAN_TX 5        // 接收发器 TXD
#define CAN_RX 4        // 接收发器 RXD

void setup() {
  Serial.begin(115200);

  twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(
      (gpio_num_t)CAN_TX, (gpio_num_t)CAN_RX, TWAI_MODE_NORMAL);
  twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();  // 500 kbps
  twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();

  if (twai_driver_install(&g_config, &t_config, &f_config) == ESP_OK) {
    Serial.println("TWAI driver installed");
  }
  if (twai_start() == ESP_OK) Serial.println("TWAI started");
}

void loop() {
  // —— 发送：标准帧 ID=0x123，数据 8 字节 ——
  twai_message_t tx;
  tx.identifier = 0x123;
  tx.extd       = 0;                 // 0 = 标准帧（11 位 ID）
  tx.rtr        = 0;                 // 0 = 数据帧
  tx.data_length_code = 8;
  for (int i = 0; i < 8; i++) tx.data[i] = i;

  if (twai_transmit(&tx, pdMS_TO_TICKS(100)) == ESP_OK) {
    Serial.println("TX ok");
  } else {
    Serial.println("TX fail / bus off?");
  }

  // —— 接收 ——
  twai_message_t rx;
  if (twai_receive(&rx, pdMS_TO_TICKS(100)) == ESP_OK) {
    Serial.printf("RX ID=0x%03X len=%d data=", rx.identifier, rx.data_length_code);
    for (int i = 0; i < rx.data_length_code; i++) Serial.printf("%02X ", rx.data[i]);
    Serial.println();
  }
  delay(1000);
}

# MicroPython：ESP32 的 TWAI 支持取决于固件版本；
# RP2040 / STM32 常用 MicroPython 的 pyb.CAN 或 machine.CAN（看端口实现）
# 下面以 STM32（pyb）为例
import pyb
can = pyb.CAN(1, pyb.CAN.NORMAL, baudrate=500000,
              extframe=False, prescaler=1)
can.setfilter(0, pyb.CAN.MASK16, 0, (0, 0, 0, 0))     # 接收所有

can.send([1, 2, 3, 4, 5, 6, 7, 8], id=0x123, timeout=100)

if can.any(0):
    data = can.recv(0)
    print("id=%03X  data=%s" % (data[0], bytes(data[3]).hex()))

# Linux（树莓派 + MCP2515 或 USB-CAN 适配器）：SocketCAN 工具链
# sudo apt install can-utils

# 1) 配置 MCP2515（在 /boot/firmware/config.txt 加 dtoverlay，重启）
#    dtoverlay=mcp2515-can0,oscillator=8000000,interrupt=25
#    dtoverlay=spi-bcm2835
sudo ip link set can0 up type can bitrate 500000
ifconfig can0

# 2) 抓包（等同于 tcpdump）
candump can0
candump can0,123:7FF          # 只显示 ID 0x123
candump -l can0               # 记录到文件（candump-*.log）

# 3) 发送
cansend can0 123#1122334455667788
cansend can0 123#R             # 远程帧

# 4) 生成随机负载（压力测试）
cangen can0 -g 10 -I 123 -L 8

# 5) 回放
canplayer -I candump-*.log

# 6) 状态与错误统计（排查总线问题必看）
ip -details -statistics link show can0
# 关注：state ERROR-ACTIVE / bus-error / restart-ms / rx-over-errors

# Python（Linux SocketCAN）
# pip install python-can
import can

bus = can.interface.Bus(channel='can0', interface='socketcan', bitrate=500000)
msg = can.Message(arbitration_id=0x123, data=[1,2,3,4,5,6,7,8], is_extended_id=False)
bus.send(msg)

for m in bus:
    print(f"ID=0x{m.arbitration_id:X} len={m.dlc} data={m.data.hex(' ')}")

7.4 CAN 故障排查

八、1-Wire：一根线传数据与供电

8.1 原理与接线

1-Wire（Dallas/Maxim）用单根数据线 + 地线通信，靠严格的时隙（time slot）时序区分 0 和 1。

8.2 代码示例

// Arduino C++：多个 DS18B20 按 ROM 地址读取
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 4
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(115200);
  sensors.begin();
  Serial.printf("found %d device(s)\n", sensors.getDeviceCount());

  // 打印每个器件的 64 位地址（做固定编号时很有用）
  DeviceAddress addr;
  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {
    if (sensors.getAddress(addr, i)) {
      Serial.printf("dev %d: ", i);
      for (uint8_t j = 0; j < 8; j++) Serial.printf("%02X", addr[j]);
      Serial.println();
    }
  }
  sensors.setResolution(12);       // 9–12 位，12 位对应 0.0625°C，转换约 750 ms
  sensors.setWaitForConversion(false);   // 非阻塞：发命令后自己等
}

void loop() {
  sensors.requestTemperatures();
  delay(800);                      // 12 位分辨率需约 750 ms 转换时间
  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {
    float t = sensors.getTempCByIndex(i);
    Serial.printf("sensor %d = %.2f C\n", i, t);
  }
  delay(2000);
}

# MicroPython：DS18B20（内置驱动）
import time, onewire, ds18x20
from machine import Pin

ow  = ds18x20.DS18X20(onewire.OneWire(Pin(4)))
roms = ow.scan()
print("devices:", [r.hex() for r in roms])

while True:
    ow.convert_temp()
    time.sleep_ms(750)             # 等转换完成
    for rom in roms:
        print(rom.hex(), ow.read_temp(rom))
    time.sleep(2)

# 树莓派：1-Wire 走内核模块（DS18B20 最省事的用法）
sudo raspi-config nonint do_onewire 0 && sudo reboot
# 或在 /boot/firmware/config.txt 加：dtoverlay=w1-gpio,gpiopin=4
# 加载模块
sudo modprobe w1-gpio
sudo modprobe w1-therm

ls /sys/bus/w1/devices/                     # 28-xxxxxxxxxxxx 就是 DS18B20
cat /sys/bus/w1/devices/28-*/w1_slave
# 输出里 t=25312 表示 25.312 °C

8.3 1-Wire 故障排查

九、USB 设备类：让 MCU 变成"某种 USB 设备"

9.1 三种常见设备类

其他常见类：DFU（Device Firmware Upgrade，固件升级）、MIDI、Audio、WebUSB（浏览器直接访问）、RNDIS/ECM/NCM（USB 网卡）。

9.2 平台能力对照

9.3 代码示例

// Arduino C++：ESP32-S3 用 TinyUSB 做 HID 键盘（会自动敲字，谨慎运行）
#include <Arduino.h>
#if ARDUINO_USB_CDC_ON_BOOT
  #define USBSerial Serial
#else
  #define USBSerial Serial
#endif

#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_TINYUSB_HID_ENABLED)
#include <USB.h>
#include <USBHIDKeyboard.h>
USBHIDKeyboard Keyboard;
#endif

void setup() {
  USBSerial.begin(115200);
#if defined(CONFIG_TINYUSB_HID_ENABLED)
  Keyboard.begin();
  USBSerial.println("HID keyboard ready, typing in 5s...");
  delay(5000);
  Keyboard.println("hello from esp32-s3");
#endif
}

void loop() {
  USBSerial.println("cdc tick");
  delay(1000);
}

// Arduino C++：RP2040（Pico）HID 键盘 —— 需在 Tools → USB Stack 选 "Adafruit TinyUSB"
#include <Keyboard.h>

void setup() {
  Keyboard.begin();
  pinMode(0, INPUT_PULLUP);          // GP0 接按键到 GND
}

void loop() {
  if (digitalRead(0) == LOW) {
    Keyboard.print("pico says hi");
    delay(500);                       // 防止按一次输出一串
  }
}

// MSC 虚拟 U 盘（Pico）：Tools → Flash Size 里选带 "with FATFS" 或 "2MB (Sketch, 1MB FS)"
// #include <Adafruit_TinyUSB.h>
// #include <Adafruit_USBD_MSC.h>
// #include <FatFS.h>

# CircuitPython：把 Pico 变成 HID + CDC 同时工作（配置文件 boot.py）
# boot.py
import usb_hid, usb_cdc
usb_cdc.enable(console=True, data=True)     # 开 CDC（控制台 + 数据通道）
usb_hid.enable((usb_hid.Device.KEYBOARD, usb_hid.Device.MOUSE))

# CircuitPython：code.py —— 读按键发键盘事件
import time, board, digitalio, usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode

kbd = Keyboard(usb_hid.devices)
btn = digitalio.DigitalInOut(board.GP0)
btn.switch_to_input(pull=digitalio.Pull.UP)

while True:
    if not btn.value:
        kbd.send(Keycode.A)
        time.sleep(0.3)

# 主机侧验证 USB 设备类
lsusb                                     # 列出设备与 VID:PID
lsusb -v -d 303a:8001 2>/dev/null | head -40   # 看描述符（Class 字段）
dmesg | tail -20                          # 插入时的内核日志
ls -la /dev/ttyACM*                       # CDC 是否出现
ls /dev/input/by-id/                      # HID 是否出现
udevadm info -q property -n /dev/ttyACM0 | grep -i id_

9.4 USB 故障排查

十、协议横向对比与选型

选型口诀：

调试与人机 → UART（串口）
板上多传感器，引脚紧张 → I2C
要速度、要屏幕、要存储 → SPI
输出连续量（亮度/角度/转速）→ PWM
读连续量（电压/温度/光强）→ ADC
长距离、抗干扰、多节点 → CAN（或 RS485）
一根线多点测温 → 1-Wire
连电脑且要免驱 → USB HID / CDC

十一、常用模块速查表

11.1 基础执行器与输入器件

⚠️ 注意：继电器控制 220 V 市电时，强电部分必须做绝缘处理（热缩管/电工胶带/专用外壳），接线前确认断电，通电后不要用身体任何部位触碰。新手建议先用低压直流（12 V 灯带）练手。

11.2 温湿度与环境传感器

// Arduino C++：DHT22 读取（Adafruit 库）
#include <DHT.h>
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup() { Serial.begin(115200); dht.begin(); }
void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  if (isnan(h) || isnan(t)) { Serial.println("read fail"); }
  else Serial.printf("T=%.1fC  H=%.1f%%\n", t, h);
  delay(2000);      // DHT22 至少 2 秒
}

# MicroPython：SHT30（I2C，比 DHT 稳得多）
from machine import Pin, I2C
import time

i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=100000)
ADDR = 0x44

def read_sht30():
    i2c.writeto(ADDR, b'\x2C\x06')     # 高重复性单次测量，clock stretching 关闭
    time.sleep_ms(20)
    d = i2c.readfrom(ADDR, 6)
    # 数据格式：temp_MSB temp_LSB temp_CRC hum_MSB hum_LSB hum_CRC
    t_raw = (d[0] << 8) | d[1]
    h_raw = (d[3] << 8) | d[4]
    t = -45 + 175 * t_raw / 65535.0
    h = 100 * h_raw / 65535.0
    return t, h

while True:
    t, h = read_sht30()
    print(f"T={t:.1f}C  H={h:.1f}%")
    time.sleep(2)

11.3 显示模块

// Arduino C++：SSD1306 I2C 显示（先跑 I2C 扫描确认地址）
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_W 128
#define SCREEN_H 64
Adafruit_SSD1306 oled(SCREEN_W, SCREEN_H, &Wire, -1);

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {   // 地址不对改 0x3D
    Serial.println("SSD1306 alloc fail");
    for (;;);
  }
  oled.clearDisplay();
  oled.setTextSize(1);
  oled.setTextColor(SSD1306_WHITE);
  oled.setCursor(0, 0);
  oled.println("Hello OLED!");
  oled.setTextSize(2);
  oled.println("128x64");
  oled.display();          // 必须调用 display() 才会真正刷新到屏幕
}

void loop() {}

# MicroPython：SSD1306（I2C）
from machine import Pin, I2C
import ssd1306

i2c = I2C(0, scl=Pin(22), sda=Pin(21))
oled = ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C)
oled.fill(0)
oled.text("Hello", 0, 0)
oled.text("MicroPython", 0, 16)
oled.show()          # 同样需要 show()

# 树莓派：LCD1602 + PCF8574 I2C 转接板
# sudo raspi-config → 启用 I2C；pip install smbus2；i2cdetect -y 1 确认地址
import smbus2, time

BUS = smbus2.SMBus(1)
ADDR = 0x27          # 常见 0x27 或 0x3F
BL = 0x08            # 背光位
EN = 0x04
RS = 0x01

def write_nibble(bus, data):
    bus.write_byte(ADDR, data | BL | EN)
    time.sleep(0.0005)
    bus.write_byte(ADDR, (data | BL) & ~EN)
    time.sleep(0.0001)

def send_byte(bus, data, mode):
    write_nibble(bus, mode | (data & 0xF0))
    write_nibble(bus, mode | ((data << 4) & 0xF0))

def lcd_init(bus):
    for _ in range(3):
        write_nibble(bus, 0x30); time.sleep(0.005)
    write_nibble(bus, 0x20)
    for cmd in (0x28, 0x0C, 0x01, 0x06):   # 4bit/2行, 显示开, 清屏, 光标右移
        send_byte(bus, cmd, 0)
        time.sleep(0.002)

def lcd_text(bus, s, line):
    send_byte(bus, 0x80 if line == 0 else 0xC0, 0)
    for ch in s:
        send_byte(bus, ord(ch), RS)

lcd_init(BUS)
lcd_text(BUS, "Raspberry Pi", 0)
lcd_text(BUS, "LCD1602 I2C", 1)

11.4 测距与姿态

加速度计 / 陀螺仪 / 磁力计的区别（面试和选型都常问）：

// Arduino C++：MPU6050 读取原始六轴数据（不依赖库，直接读寄存器，最稳）
#include <Wire.h>
#define MPU 0x68

void writeReg(uint8_t r, uint8_t v) {
  Wire.beginTransmission(MPU); Wire.write(r); Wire.write(v); Wire.endTransmission(true);
}
void readBytes(uint8_t r, uint8_t n, uint8_t *buf) {
  Wire.beginTransmission(MPU); Wire.write(r); Wire.endTransmission(false);
  Wire.requestFrom(MPU, n);
  for (uint8_t i = 0; i < n && Wire.available(); i++) buf[i] = Wire.read();
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  writeReg(0x6B, 0x00);            // 退出睡眠（PWR_MGMT_1）
  writeReg(0x1B, 0x00);            // 陀螺 ±250 °/s
  writeReg(0x1C, 0x00);            // 加速度 ±2 g
  uint8_t who = 0;
  readBytes(0x75, 1, &who);
  Serial.printf("WHO_AM_I = 0x%02X (应为 0x68)\n", who);
}

void loop() {
  uint8_t b[14];
  readBytes(0x3B, 14, b);          // 0x3B 起连续 14 字节：accel/temp/gyro
  int16_t ax = (b[0] << 8) | b[1];
  int16_t ay = (b[2] << 8) | b[3];
  int16_t az = (b[4] << 8) | b[5];
  int16_t gx = (b[8] << 8) | b[9];
  int16_t gy = (b[10] << 8) | b[11];
  int16_t gz = (b[12] << 8) | b[13];
  Serial.printf("accel: %6d %6d %6d   gyro: %6d %6d %6d\n", ax, ay, az, gx, gy, gz);
  delay(200);
}

# MicroPython：MPU6050 最小读取
from machine import Pin, I2C
import time
from imu import MPU6050      # MicroPython 标准库（部分端口自带）

i2c = I2C(0, scl=Pin(22), sda=Pin(21))
imu = MPU6050(i2c)

while True:
    ax, ay, az = imu.accel.x, imu.accel.y, imu.accel.z
    gx, gy, gz = imu.gyro.x, imu.gyro.y, imu.gyro.z
    print(f"accel=({ax:+.2f},{ay:+.2f},{az:+.2f})g  gyro=({gx:+.1f},{gy:+.1f},{gz:+.1f})deg/s")
    time.sleep(0.2)

// Arduino C++：HC-SR04 超声波测距（ECHO 需分压到 3.3 V）
#define TRIG 5
#define ECHO 18
#define SOUND_SPEED 0.0343   // cm/us

void setup() {
  Serial.begin(115200);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  digitalWrite(TRIG, LOW);
}

void loop() {
  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);   // 至少 10 us 触发脉冲
  digitalWrite(TRIG, LOW);

  long dur = pulseIn(ECHO, HIGH, 30000L);   // 30 ms 超时 ≈ 5 m
  float cm = dur * SOUND_SPEED / 2.0;       // 往返所以要除以 2
  // 简化公式：cm ≈ dur / 58
  if (dur == 0) Serial.println("out of range");
  else Serial.printf("dist = %.1f cm\n", cm);
  delay(200);
}

11.5 GPS 模块与 NMEA 解析

GPS 模块统一通过 UART 输出 NMEA-0183 文本语句，波特率常见 9600（部分模块默认 38400 或 115200，以模块手册为准）。

坐标格式是"度分"：4807.038,N = 48°07.038′ = 48 + 7.038/60 = 48.1173°。这是新手最常踩的解析坑。

// Arduino C++：GPS NMEA 简易解析（只取 GGA 的时间/经纬度/卫星数）
#define RXD2 16
#define TXD2 17

void setup() {
  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);   // GPS 默认多为 9600
}

// NMEA 校验和：'$' 与 '*' 之间所有字符异或
bool nmeaCrc(const String &s) {
  int star = s.indexOf('*');
  if (star < 0) return false;
  uint8_t crc = 0;
  for (int i = 1; i < star; i++) crc ^= s[i];
  return strtoul(s.substring(star + 1).c_str(), NULL, 16) == crc;
}

// "4807.038" (度分) → 十进制度
float dmToDeg(const String &dm) {
  int dot = dm.indexOf('.');
  if (dot < 3) return 0;
  float mins = dm.substring(dot - 2).toFloat();   // 最后两位是分的小数部分
  float degs = dm.substring(0, dot - 2).toFloat();
  return degs + mins / 60.0;
}

void loop() {
  static String line;
  while (Serial2.available()) {
    char c = Serial2.read();
    if (c == '\n') {
      line.trim();
      if (line.startsWith("$GPGGA") || line.startsWith("$GNGGA")) {
        if (nmeaCrc(line)) {
          // $GNGGA,time,lat,N/S,lon,E/W,quality,sats,hdop,alt,...
          int p[12], n = 0;
          for (int i = 0; i < line.length() && n < 12; i++)
            if (line[i] == ',') p[n++] = i;
          if (n > 9) {
            String time = line.substring(p[0] + 1, p[1]);
            String lat  = line.substring(p[1] + 1, p[2]);
            String ns   = line.substring(p[2] + 1, p[3]);
            String lon  = line.substring(p[3] + 1, p[4]);
            String ew   = line.substring(p[4] + 1, p[5]);
            int    sats = line.substring(p[6] + 1, p[7]).toInt();
            Serial.printf("UTC %s  lat %.6f %s  lon %.6f %s  sats %d\n",
                          time.c_str(),
                          dmToDeg(lat) * (ns == "S" ? -1 : 1), ns.c_str(),
                          dmToDeg(lon) * (ew == "W" ? -1 : 1), ew.c_str(),
                          sats);
          }
        }
      }
      line = "";
    } else if (c != '\r') line += c;
  }
}

# 树莓派 / PC：GPS 解析（pynmea2）
# pip install pyserial pynmea2
import serial, pynmea2

ser = serial.Serial('/dev/ttyUSB0', baudrate=9600, timeout=1)

while True:
    line = ser.readline().decode('ascii', errors='replace').strip()
    if not line.startswith('$'):
        continue
    try:
        msg = pynmea2.parse(line)
    except pynmea2.ParseError:
        continue
    if isinstance(msg, pynmea2.GGA):
        # pynmea2 已把度分自动转成十进制度
        print(f"lat={msg.latitude:.6f}  lon={msg.longitude:.6f}  "
              f"alt={msg.altitude}m  sats={msg.num_sats}  hdop={msg.horizontal_dil}")

GPS 常见坑：

11.6 电机与驱动

⚠️ 注意：电机是感性负载，断电瞬间会产生反向高压。必须在驱动芯片按规定接续流路径（多数模块已内置），并在电机电源输入端并联大电容（100–470 µF 电解 + 0.1 µF 陶瓷）。电机电源与 MCU 逻辑电源必须分开、只共地，否则电机启动瞬间 MCU 必然复位。

// Arduino C++：A4988 驱动 42 步进电机（STEP/DIR 方式）
#define STEP_PIN 2
#define DIR_PIN  3
#define EN_PIN   4

void setup() {
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW);        // A4988 的 EN 是低电平使能
}

// 按步数转动。stepsPerRev 取决于细分设置：
//   1.8°/步 的电机 = 200 步/圈；1/16 细分 → 3200 步/圈
void rotate(long steps, uint16_t usDelay = 500) {
  digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW);
  for (long i = 0; i < abs(steps); i++) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(usDelay);     // 脉冲宽度决定转速
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(usDelay);
  }
}

void loop() {
  rotate(3200, 400);   // 1/16 细分下转一整圈
  delay(1000);
  rotate(-3200, 400);  // 反转一圈
  delay(1000);
}

# MicroPython：TB6612 驱动直流电机（PWM 调速 + 方向）
from machine import Pin, PWM
import time

pwma  = PWM(Pin(18), freq=10000)     # 10 kHz，避开人耳
ain1  = Pin(16, Pin.OUT)
ain2  = Pin(17, Pin.OUT)
stby  = Pin(19, Pin.OUT, value=1)    # TB6612 的 STBY 必须拉高

def run(speed):                       # speed: -1.0 ~ 1.0
    duty = int(abs(speed) * 65535)
    pwma.duty_u16(duty)
    if speed > 0:   ain1.value(1); ain2.value(0)
    elif speed < 0: ain1.value(0); ain2.value(1)
    else:           ain1.value(0); ain2.value(0)   # 短路刹车

for s in [0.3, 0.6, 1.0, 0, -0.5, -1.0, 0]:
    print("speed", s)
    run(s)
    time.sleep(1)

11.7 隔离、电平转换与存储

⚠️ 注意：AT24C 与 DS3231 的地址都是 0x68/0x50 这类固定值，多个同类器件挂同一条 I2C 总线必然冲突。AT24C 可通过 A0/A1/A2 引脚改地址（0x50–0x57）；DS3231 不能改地址，一条总线只能有一个。

// Arduino C++：AT24C32 EEPROM 页写与读取
#include <Wire.h>
#define EEPROM_ADDR 0x57        // A0/A1/A2 全接高时为 0x57
#define PAGE_SIZE   32          // AT24C32 页大小 32 字节（以数据手册为准）

void eepromWrite(uint16_t addr, uint8_t val) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(addr >> 8);        // 高字节地址
  Wire.write(addr & 0xFF);      // 低字节地址
  Wire.write(val);
  Wire.endTransmission();
  delay(5);                     // 写周期，约 5 ms（以数据手册为准）
}

uint8_t eepromRead(uint16_t addr) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(addr >> 8);
  Wire.write(addr & 0xFF);
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ADDR, (uint8_t)1);
  return Wire.available() ? Wire.read() : 0xFF;
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  eepromWrite(0x0010, 0xAB);
  Serial.printf("read back: 0x%02X\n", eepromRead(0x0010));
}
void loop() {}

// Arduino C++：DS3231 RTC 读时间（读寄存器，不依赖库）
#include <Wire.h>
#define DS3231 0x68

uint8_t bcd2dec(uint8_t v) { return ((v >> 4) * 10) + (v & 0x0F); }

void readTime() {
  Wire.beginTransmission(DS3231);
  Wire.write(0x00);                 // 秒寄存器地址
  Wire.endTransmission();
  Wire.requestFrom(DS3231, 7);      // 秒/分/时/星期/日/月/年
  if (Wire.available() < 7) { Serial.println("read fail"); return; }
  uint8_t sec = bcd2dec(Wire.read() & 0x7F);
  uint8_t min = bcd2dec(Wire.read());
  uint8_t hr  = bcd2dec(Wire.read() & 0x3F);
  Wire.read();                      // 跳过星期
  uint8_t day = bcd2dec(Wire.read());
  uint8_t mon = bcd2dec(Wire.read() & 0x1F);
  uint16_t yr = 2000 + bcd2dec(Wire.read());
  Serial.printf("%04u-%02u-%02u %02u:%02u:%02u\n", yr, mon, day, hr, min, sec);
}

void setup() { Serial.begin(115200); Wire.begin(21, 22); }
void loop() { readTime(); delay(1000); }

11.8 无线模块对比表

选型决策：

要上云 / 传数据量大 / 已有 WiFi  → ESP32 内置 WiFi
电池供电 + 手机交互             → BLE
多点自组网、设备间通信、成本敏感  → nRF24L01+
几公里距离、少量数据、电池       → LoRa
智能家居、需要自愈 Mesh、对接 HA → Zigbee（Zigbee2MQTT）
新项目做 Matter                → ESP32-C6 / H2（Thread）
户外无 WiFi、要上云             → 4G Cat.1（注意电源）

⚠️ 注意：无线电频段受各国法规管制。433 MHz、868 MHz、915 MHz 在不同地区允许的功率与用途不同，中国境内的民用微功率设备频段与发射功率限制以国家无线电管理机构的规定为准。使用 Sub-GHz 模块前务必确认所选频段与功率合法合规。

11.9 摄像头与其他

# 树莓派摄像头验证（Bookworm 起统一 libcamera）
libcamera-hello --list-cameras
libcamera-still -o test.jpg -t 2000
libcamera-vid -t 5000 -o test.h264 --width 1280 --height 720

# USB 摄像头验证
v4l2-ctl --list-devices
v4l2-ctl -d /dev/video0 --list-formats-ext
ffplay /dev/video0            # 或 ffplay -f v4l2 /dev/video0

十二、电源基础：90% 的玄学故障根源

12.1 LDO vs DC-DC

选型经验：

Vin - Vout < 1 V 且电流 < 300 mA      → LDO（简单、干净）
Vin - Vout 大（如 12 V → 3.3 V）       → 必须 DC-DC（LDO 会烫到不能摸）
电流 > 500 mA                          → DC-DC
给 ADC / 传感器 / 射频 / 音频供电       → LDO（或 DC-DC 后级再串 LDO）
电池供电、追求续航                      → DC-DC（效率就是续航）
空间极小、成本极敏感、电流很小           → LDO

压降计算实例：12 V 输入、AMS1117-3.3 输出、负载 300 mA → 耗散 (12-3.3) × 0.3 = 2.61 W。SOT-223 封装在无额外散热时很难扛住，会烫手甚至触发过热保护。这种情况必须换 DC-DC。

12.2 常用芯片速查

⚠️ 注意：以上电流/电压参数为常见规格的大致范围，不同厂家、不同批次存在差异。设计产品时以具体型号的最新数据手册为准，并留足 50% 以上的降额。

12.3 去耦电容：不是可选项

为什么 0.1 µF 要紧挨芯片：电容到芯片之间哪怕几厘米的走线也有寄生电感，高频下阻抗很大，电容"来不及"供电。ESL（等效串联电感）决定了电容的高频性能，这是小封装（0402/0603）比大封装在高频表现更好的原因。

布局要点：

1) 0.1 µF 陶瓷电容放在芯片 VCC 引脚旁，走线尽量短、直，先经过电容再到芯片引脚。
2) 电容的 GND 端直接就近打过孔接到地平面（不要绕远路）。
3) DC-DC 的电感下方不要走信号线（磁场干扰），反馈走线远离电感与开关节点。
4) 大电流路径（电源、电机、地）走线要宽；1 oz 铜厚下 1 mm 线宽约走 1 A（粗估，
   以 PCB 载流标准为准，最好用在线线宽计算器）。
5) 模拟与数字地分开走，在一点汇合（星型接地/单点接地）。
6) 大电容与小电容并联使用：大的管低频，小的管高频。

12.4 纹波测量

用示波器测纹波的正确姿势：
1) 探头打到 1×（不是 10×，10× 会放大噪声底）——或者用 10× 但接受噪底
2) 开启探头的带宽限制（20 MHz Bandwidth Limit），滤掉开关尖峰的辐射拾取
3) 用"探头尖端 + 接地弹簧"就近测量，
   ★ 绝对不要用示波器标配的长鳄鱼夹地线（会拾取大量开关噪声，测出来虚高数倍）
4) 示波器耦合方式设为 AC，垂直刻度调到 10–50 mV/div
5) 测量点选输出电容两端，不是远处的负载端
6) 在额定负载下测（空载纹波通常偏小，不具代表性）

判定参考（经验值，具体看后端器件要求）：
  LDO 输出        < 几 mV 级
  DC-DC 输出      < 50 mVpp 通常可接受；给 ADC/RF 供电要 < 20 mVpp
  给 ESP32 供电   < 100 mVpp 一般能稳定工作（以实际测试为准）

没有示波器时的替代判断：

1) 万用表交流电压档（AC mV）串一只 10 µF 电容测 DC-DC 输出端，
   能粗略看出纹波量级（读数是 RMS，不是峰峰值，但能比较大小）。
2) 听：DC-DC 电感在轻载时会"啸叫"（陶瓷电容压电效应 + 电感磁致伸缩），
   通常无害，但说明工作在轻载跳周期模式。
3) 最实用的验证：直接带满负载长时间运行，看系统是否重启/通信是否误码。

12.5 "莫名其妙重启"的电源排查清单

□ 1. 电源功率够吗？
     ESP32 峰值 300 mA+；WiFi 发射瞬间更高。树莓派 4B 要 3 A、5 要 5 A。
     → 换更大电流的电源，别用电脑 USB 口带大负载。

□ 2. 线缆压降？
     细长 USB 线内阻大，1 A 电流下能掉 0.3–0.5 V。
     → 换粗短线，或提高电源电压（对有 LDO 的板子有效）。

□ 3. 瞬时电流扛得住吗？
     电机启动、继电器吸合、WiFi 发射都是脉冲电流，电源响应速度不够就会跌落。
     → 在 MCU 的 VCC-GND 间加 100–470 µF 电解 + 0.1 µF 陶瓷。

□ 4. 大负载有没有和 MCU 抢电？
     舵机/电机/继电器绝对不能从 MCU 的 3.3 V 或 5 V 引脚取电。
     → 独立供电，只把 GND 连在一起（共地）。

□ 5. 地去干净了吗？
     多个模块串联接地（菊花链）会造成地电位差，形成"地弹"。
     → 星型接地，所有 GND 汇到一点。

□ 6. 有没有反电动势？
     电机、继电器线圈断电时的反向高压会串回电源。
     → 续流二极管（继电器/直流电机），RC 吸收（交流负载）。

□ 7. 看日志确认：
     ESP32  → 串口出现 "Brownout detector was triggered" 或 rst:0x1 / 0xF
     ESP-IDF→ rst:0x1 (POWERON), rst:0x7 (TG0WDT), rst:0xF (BROWNOUT)
     树莓派 → vcgencmd get_throttled 非 0x0；dmesg 有 under-voltage
     STM32  → 看 RCC_CSR 的复位标志位（POR/PIN/BOR 等）

□ 8. 实测：万用表电压档点住 MCU 的 VCC 引脚，触发负载的瞬间看跌到多少。
     跌到 3.0 V 以下（3.3 V 系统）基本就是电源问题。

十三、焊接与工具

13.1 电烙铁温度设定

实操要点：

1) 烙铁头先上锡（吃锡），看到亮银色的"锡帽"再焊，氧化发黑的头不导热。
2) 同时加热"焊盘 + 引脚"两个面，再把锡丝送到接触点，不要送到烙铁头上。
3) 单点加热时间 < 2–3 秒，焊不动就检查温度/助焊剂，不要死按（会烫掉焊盘）。
4) 助焊剂是灵魂：焊锡丝里的助焊剂往往不够，额外备一瓶松香/免洗助焊剂。
5) 焊完检查：好的焊点是圆锥形、表面光亮；灰暗粗糙 = 冷焊（虚焊），必须重焊。
6) 每次用完在湿海绵/铜丝球上擦净烙铁头，并重新上一层锡再断电（防氧化）。
7) 排针焊接技巧：先在面包板上把排针插正（借助面包板定位），再放板子焊。

⚠️ 注意：烙铁温度 300 °C 以上，烫伤只在一瞬间。必须使用烙铁架，不要随手放桌上。焊接时保持通风（助焊剂烟雾有害），FPGA/CMOS 芯片焊接时注意防静电（戴防静电手环或先摸一下接地金属）。

13.2 万用表实用技巧（补遗）

1) 快速判断杜邦线好坏：蜂鸣档测两端。这是面包板项目最常见的故障点，
   建议新买的线先全部测一遍（约 5–10% 的低价线是断的）。

2) 判断 IO 是否真的在输出：
   直流电压档测引脚对 GND。
     恒定 0 V 或 3.3 V → 电平没翻转（代码没跑 / 引脚配错）
     读数在 1~2 V 之间跳动 → 在输出 PWM 或在通信（对的）
     读数 0 V 但代码写了 HIGH → 引脚被配置为输入、或负载短路、或 IO 已烧

3) 找短路：断电 → 蜂鸣档测 VCC 与 GND。
   导通（响）说明有短路 → 逐个拔掉外围模块，拔到哪个不响了就是它的问题。

4) 测静态功耗（排查电池续航）：
   电源正极 → [万用表电流档] → 板子 VCC 输入端。
   ⚠ 先插 "A" 大电流孔再上电，确认读数小后再换到 mA 档（否则烧保险丝）。

5) 判断芯片是否虚焊：
   蜂鸣档测芯片引脚与对应焊盘/走线端（不是测引脚之间）。
   不导通 = 虚焊或断线。

6) 判断电容是否失效：
   电容档测（需焊下一端）。容量严重偏小 = 失效；
   DC-DC 输出电容失效会导致纹波剧增、系统随机重启。

7) 测电阻分压中点电压：确认分压电路是否按预期比例工作。

13.3 杜邦线与面包板：接触不良的排查

杜邦线问题（面包板项目第一大故障源）：

面包板问题：

什么时候必须放弃面包板：

□ SPI 速率 > 几 MHz（尤其 > 8 MHz）
□ I2C 跑 400 kHz 且挂了多个设备、线又长
□ 涉及模拟小信号（mV 级、高阻抗）
□ 涉及射频（WiFi/BLE/LoRa 的 RF 部分绝不能走面包板）
□ 电机等大电流（面包板插孔过流能力有限，通常 < 1 A）
□ 需要长期可靠运行的设备
→ 改洞洞板焊接，或直接打样 PCB（现在打样 5 块 10×10 cm 双面板约 ¥20–50）

排查接触不良的系统方法：

1) 先不动程序，把所有杜邦线重新插拔一遍（约能解决 30% 的"时好时坏"）。
2) 用万用表蜂鸣档，从 MCU 引脚一路测到模块引脚，逐根确认导通。
3) 用逻辑分析仪看波形：如果 SCL 上升沿很缓（斜坡而不是直角），
   就是上拉太弱 + 总线电容太大 → 减小上拉电阻或缩短线。
4) 怀疑面包板孔位氧化：换个位置插，对比现象是否消失。
5) 终极办法：直接焊接（洞洞板或 PCB），排除一切接触问题。

十四、从安全视角看：硬件接口就是攻击面

⚠️ 注意：本节内容仅用于自己拥有或已明确授权测试的设备的安全加固与风险评估。对他人设备做未授权的调试口接入、固件提取、口令爆破属于违法行为。研究攻击面的目的是为了堵住它。

14.1 UART：IoT 设备最常见的 root shell 入口

为什么是 UART：厂商生产时需要调试、测试时需要日志，于是板子上留了 3–4 pin 的排针（VCC/GND/TX/RX）。量产后排针没拆、console 没关，攻击者接上 USB-TTL 就能看到完整启动日志，甚至直接拿到 root shell 且不需要任何认证。

找 UART 引脚：

1) 目视：找板边 3–4 pin 的排针或裸露焊盘，丝印可能标 VCC/GND/TX/RX/TXD/RXD/DEBUG/CONSOLE。
2) 万用表（断电）：
   - 蜂鸣档找 GND：与电源接口负极、USB 外壳、屏蔽罩导通的那个就是 GND。
   - 电压档（上电）：VCC 是恒定 3.3 V 或 5 V（对 GND）。
   - TX：上电瞬间电压会跳动（在发启动日志），静态时多为高电平（3.3 V 或 5 V）。
   - RX：通常也是高电平，但不动（不发数据）。
   - 判定技巧：TX 在上电 1–2 秒内会有明显的电平抖动，RX 相对安静。
3) 逻辑分析仪：多通道同时接候选引脚，直接看谁有规律的方波（最好配合解码器）。
4) 注意：找到 TX 和 GND 就能单向读日志，已经足够获取大量信息。
   ★ 只接 GND + TX 是最安全的做法（不会因为你发送字符而改变设备状态）。

未知波特率自动探测：

#!/usr/bin/env python3
"""
UART 波特率自动探测：逐个尝试常见波特率，用"可打印字符比例"判断哪个是对的。
用法：python3 baudscan.py /dev/ttyUSB0
"""
import sys, time, serial

CANDIDATES = [1200, 2400, 4800, 9600, 19200, 38400, 57600, 74880,
              115200, 230400, 460800, 500000, 921600, 1000000, 1500000, 2000000]

def score(data: bytes) -> float:
    """可打印 ASCII + 常见控制字符的比例，作为"像不像文本"的打分"""
    if not data:
        return 0.0
    good = sum(1 for b in data
               if 0x20 <= b < 0x7F or b in (0x0A, 0x0D, 0x09, 0x1B))
    return good / len(data)

def probe(port: str, baud: int, seconds: float = 2.5) -> float:
    try:
        s = serial.Serial(port, baudrate=baud, timeout=0.2,
                          bytesize=serial.EIGHTBITS,
                          parity=serial.PARITY_NONE,
                          stopbits=serial.STOPBITS_ONE)
    except Exception as e:
        print(f"  {baud:>8}: open failed ({e})")
        return 0.0
    # 关闭 DTR/RTS，避免把设备复位掉
    try:
        s.setDTR(False); s.setRTS(False)
    except Exception:
        pass
    buf = bytearray()
    end = time.time() + seconds
    try:
        while time.time() < end:
            chunk = s.read(256)
            if chunk:
                buf += chunk
            else:
                time.sleep(0.02)
    finally:
        s.close()
    sc = score(bytes(buf))
    preview = bytes(buf[:60]).decode('ascii', errors='replace').replace('\n', ' ')
    print(f"  {baud:>8}: score={sc:.2f}  len={len(buf):5d}  {preview!r}")
    return sc

def main():
    port = sys.argv[1] if len(sys.argv) > 1 else '/dev/ttyUSB0'
    print(f"scanning {port} ...  (若设备需重启才有输出，请在扫描期间重启它)")
    best, best_baud = 0.0, None
    for baud in CANDIDATES:
        sc = probe(port, baud)
        # 用"有数据 + 像文本"两个条件一起判断
        if sc > best:
            best, best_baud = sc, baud
        if sc > 0.85:
            print(f"\n[+] likely baud = {baud} (score {sc:.2f})")
            break
    print(f"\nbest: {best_baud} @ score {best:.2f}")
    print(f"下一步：picocom -b {best_baud} {port}")

if __name__ == '__main__':
    main()

# 使用方法
# pip install pyserial
python3 baudscan.py /dev/ttyUSB0
# 关键：脚本运行期间给设备重新上电，才能抓到 U-Boot / kernel 的启动日志

# 拿到波特率后连接（推荐 picocom，退出键 Ctrl+A Ctrl+X）
picocom -b 115200 /dev/ttyUSB0 --imap lfcrlf
# 或想保存完整日志
picocom -b 115200 /dev/ttyUSB0 --logfile boot.log

另一种思路（更精确）：用逻辑分析仪/示波器量单个位的时间宽度，波特率 = 1 / 位宽。抓启动日志时最短的那个脉冲宽度即 1 位的时间。115200 对应约 8.68 µs，9600 对应约 104 µs。

拿到 shell 后的常规动作（信息收集）：

# —— 系统指纹 ——
uname -a
cat /proc/version
cat /etc/os-release
cat /proc/cpuinfo
ls /etc/*release*

# —— 账号与权限 ——
id; whoami
cat /etc/passwd
cat /etc/shadow              # 拿到的话离线 john/hashcat 爆破
sudo -l                      # 可无密执行的命令 = 提权捷径
find / -perm -4000 -type f 2>/dev/null    # SUID 文件
cat /etc/sudoers

# —— 网络与配置 ——
ifconfig -a / ip a
cat /etc/resolv.conf
netstat -tulnp / ss -tulnp
ps aux
cat /proc/mounts
cat /etc/fstab

# —— 应用配置里找硬编码凭据 ——
ls -la /etc/ /etc/config/ /opt/ /usr/local/ 2>/dev/null
cat /etc/config/* 2>/dev/null              # OpenWrt 的 UCI 配置
find / -name "*.conf" -o -name "*.cfg" -o -name "*.ini" -o -name "*.yaml" 2>/dev/null | head -50
grep -rIl -E "password|passwd|secret|api[_-]?key|token|aws_|private_key" \
     /etc /opt /usr/local /root /home 2>/dev/null | head -40

# —— 固件与更新机制 ——
cat /proc/mtd                              # MTD 分区（SPI Flash 布局）
cat /proc/partitions
dmesg | head -60
ls -la /dev/mtd* /dev/mtdblock*
cat /etc/crontabs/* 2>/dev/null            # 定时任务（常见后门驻留点）
ls -la /etc/init.d/ /etc/rc.local 2>/dev/null

# —— 密钥与证书 ——
find / -name "*.pem" -o -name "*.key" -o -name "id_rsa*" 2>/dev/null | head -20
cat /etc/ssl/private/* 2>/dev/null
ls -la ~/.ssh/

# —— 外传（若已拿到网络）——
# nc / tftp / wget 上传 busybox 静态二进制（很多设备 busybox 是裁剪版，缺 nc/curl）

另一种常见场景：中断 U-Boot 拿到 bootloader shell。在启动日志出现 Hit any key to stop autoboot 时按任意键，进 U-Boot 命令行后可以：

printenv                 # 看环境变量（含 bootargs，可能有 console= 与 root=）
setenv bootargs ...      # 改启动参数，如加 init=/bin/sh 直接进 shell（绕过密码）
md.b 0x9f000000 0x10000  # 从内存 dump（配合 sf read 可提取 Flash 内容）
sf probe 0; sf read 0x82000000 0x0 0x400000   # 读 SPI Flash 到内存
help                     # 看支持哪些命令

⚠️ 注意：上述所有命令只应在你自己的设备或书面授权范围内执行。IoT 设备的 UART shell 往往是无认证的 root，这也是厂商应该在量产时关闭它的原因。

厂商侧的加固：

1) 物理移除：量产版本不焊接排针，或用灌胶/点漆覆盖测试点。
2) 软件禁用：内核命令行去掉 console=；禁用登录 shell（/etc/inittab 里注释掉
   对应 tty 的 getty）；U-Boot 设置 bootdelay=0 并锁定环境变量。
3) 完整性：Secure Boot + Flash/磁盘加密，阻止替换固件与离线读密钥。
4) 日志：生产版本关闭调试日志级别（日志泄露的路径信息、密钥片段都很有价值）。
5) 认证：即便保留串口，也要加口令，且口令不可硬编码在明文配置里。

14.2 SWD / JTAG：能读能写能绕过

暴露的风险：

常见调试接口：

RDP（Readout Protection，STM32 为例）：

绕过读保护的公开思路（概述，不展开细节）：

1) 故障注入（Glitching）：
   - 电压毛刺（Voltage Glitching）：在芯片校验读保护的瞬间注入短暂欠压，
     让校验指令执行失败或被跳过。
   - 时钟毛刺（Clock Glitching）：注入超短时钟脉冲，跳过某条指令。
   - 电磁故障注入（EMFI）：用线圈在芯片上方产生强脉冲磁场。
   → 这类攻击需要精确的时间窗口，通常需要先找到"校验发生的时刻"
     （用功耗/电磁侧信道定位），属于有门槛但公开可复现的方法。

2) 侧信道与功耗分析（DPA/CPA）：
   通过大量采集加密操作时的功耗曲线，统计推断出密钥位。
   → 对未做防护的 AES/SM4 软件实现有效。

3) 物理层：
   - 开盖（Decapsulation）+ 显微镜找到熔丝位，用激光/离子束改写。
   - 把 Flash 芯片拆下来放编程器读（绕过 MCU 内部的读保护，
     因为保护是在 MCU 内部，管不了外部 Flash）。
   → 成本最高，属于专业实验室级别。

4) 已知 SDK/协议漏洞：
   某些厂商的 bootloader / 下载协议存在越权读命令，可直接读出 Flash。

⚠️ 注意：以上仅为公开的攻击面概述，用于理解"为什么生产时要熔断调试口"。不要对未授权设备实施。

厂商为什么熔断调试口：

1) 阻止固件提取：固件里往往有硬编码密钥、私有算法、可被挖掘的漏洞。
   拿到固件 = 拿到完整的设计图纸。
2) 阻止固件篡改：可写 Flash 就意味着可以植入持久化后门。
3) 阻止绕过安全校验：调试器能改内存，任何软件层的认证都可被跳过。
4) 合规要求：金融、车规、支付类设备的安全认证（如 PCI、CC EAL）
   通常明确要求调试接口在量产后不可用。
5) 代价与权衡：熔断后无法返修、无法在线调试，产线必须保证一次烧录成功，
   且要保留"死片"的处理流程。因此常见做法是：
   - 开发阶段：Level 0，随便调试
   - 产线烧录后：设 Level 1
   - 出货前/安全敏感产品：Level 2 或熔断 eFuse
   - ESP32 侧：烧 eFuse 的 DIS_DOWNLOAD_MODE、JTAG_DISABLE（不可逆，务必先在小批量上验证）

14.3 固件提取：从 Flash 拿到完整镜像

方法一：在线夹取（不拆焊，首选）

适用：板上有 SOIC-8 / SOP-8 封装的 SPI Flash（25Qxx、W25Qxx、MX25Lxx 系列）
工具：
  - SOIC8 测试夹（Pomona 5250 或国产兼容，¥20–60）
  - 编程器：CH341A（¥15–30，最便宜） / FT2232H（更快更稳） / 树莓派 GPIO（用 flashrom 的 linux_spi）
  - 或者直接用树莓派/ESP32 的 SPI 接口（仅 3.3 V！）

步骤：
1) 断电，看清 Flash 芯片丝印（型号 + 容量，如 "25Q128" = 128 Mbit = 16 MB）。
2) 夹上测试夹，注意 1 脚方向（芯片上有个圆点/凹槽标记 1 脚）。
3) ★ 关键：给目标板断电，只由编程器给 Flash 供电；
   若目标板还在上电，MCU 会与编程器争抢 SPI 总线，导致读出来全是 0x00/0xFF 乱码。
   有些板子需要在读取时"按住复位"让 MCU 保持高阻态。
4) 读取 → 校验（读两遍比对）→ 分析。

# ===== CH341A 编程器（Linux）=====
# 安装工具（ch341a 支持已并入较新版本 flashrom）
sudo apt install flashrom
# 或用开源 ch341a 工具：sudo apt install ch341eeprom / pip install ch341a-...

# 探测芯片（这一步能识别就成功一半）
sudo flashrom -p ch341a_spi
# 期望输出：Found ... flash chip "W25Q128.V" (16384 kB, SPI)

# 读取（连读 3 次，比对 MD5 确认稳定）
for i in 1 2 3; do sudo flashrom -p ch341a_spi -r fw_$i.bin; done
md5sum fw_1.bin fw_2.bin fw_3.bin      # 三者一致才可信

# ===== 用树莓派 SPI 读（适合没有编程器时）=====
# sudo raspi-config → 启用 SPI
# 接线（务必确认是 3.3 V Flash！）：
#   Flash Pin1(CS)   → Pi CE0 (GPIO8)
#   Flash Pin2(MISO) → Pi MISO (GPIO9)
#   Flash Pin3(WP)   → 3.3V (或悬空，建议接到 VCC 避免写保护异常)
#   Flash Pin4(GND)  → Pi GND
#   Flash Pin5(MOSI) → Pi MOSI (GPIO10)
#   Flash Pin6(CLK)  → Pi SCLK (GPIO11)
#   Flash Pin7(HOLD) → 3.3V
#   Flash Pin8(VCC)  → Pi 3.3V   ★ 只用 3.3 V，接 5 V 会烧掉 Flash
sudo modprobe spi_bcm2835
sudo flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=1000 -r fw_pi.bin
# spispeed 单位 kHz，先慢后快；读不稳就降到 500 或 200

# ===== 读出后分析 =====
file fw.bin                            # 看文件类型
md5sum fw.bin; sha256sum fw.bin
binwalk -E fw.bin                      # 熵分析（区分压缩/加密段）
binwalk fw.bin                         # 识别文件系统、内核、压缩包等可识别块
binwalk -Me fw.bin                     # 递归提取（-M 递归，-e 自动提取）

# 手工查看
xxd fw.bin | head -50
strings -n 6 fw.bin | head -100        # ASCII 字符串
strings -el fw.bin | head -50          # UTF-16 小端（某些设备的配置是宽字符）

# 找文件系统
binwalk fw.bin | grep -iE "squashfs|jffs2|cramfs|ubifs|cpio|ext|lzma|gzip|xz"

# 提取 SquashFS
# 找到偏移量后（假设 0x100000）：
dd if=fw.bin of=rootfs.squashfs bs=1 skip=$((0x100000))
unsquashfs rootfs.squashfs             # 解出完整根文件系统

# 找硬编码密钥
grep -rEa "(BEGIN (RSA |EC |OPENSSH |)PRIVATE KEY)" .
grep -rEa "AKIA[0-9A-Z]{16}" .         # AWS Access Key 特征
grep -rEa "['\"][A-Za-z0-9/+]{32,}['\"]" . | head -40   # 长 base64 串
grep -rEia "password|secret|apikey|api_key|token|passwd" . 2>/dev/null | head -60
grep -rEa "[0-9a-fA-F]{32,}" . | head -40               # 长十六进制串

# 常用工具链安装
sudo apt install binwalk file xxd sleuthkit squashfs-tools unsquashfs \
                 jefferson cramfsprogs lzop lzma xz-utils \
                 firmware-mod-kit mtd-utils u-boot-tools
# 高级（可选）
pip install ubi_reader                 # 解 UBIFS
git clone https://github.com/ReFirmLabs/binwalk && cd binwalk && sudo ./deps.sh   # 完整版 binwalk（含各种解包器）
# 全功能固件分析平台：
#   https://github.com/fkie-cad/FACT_core    （Docker 部署，自动化分析）
#   https://github.com/EMBA-support/EMBA     （固件安全扫描）

方法二：拆焊读取（Flash 读不出来时的最后手段）

适用：
  - 在线读取被 MCU 干扰（一直抢总线）
  - 芯片是 BGA/WSON 封装，夹子夹不上
  - Flash 已被读保护（取出后放编程器仍读不出，但换成新片可以排除软件层干扰）

工具：热风枪（¥150–400）或加热台、镊子、助焊剂、吸锡带、植锡网（回焊时用）
步骤：
1) 芯片四周涂助焊剂，热风枪 320–350 °C，风量中等，均匀加热，
   用镊子轻推，锡熔化即可取下（不要硬撬，会扯掉焊盘）。
2) 清理焊盘与芯片引脚上的残锡（吸锡带 + 助焊剂）。
3) 放到 SOIC-8 测试座/编程器上读取。
4) 若想复原：植锡或直接用新片（Flash 很便宜），焊回去。

风险：热风会吹飞周围的小元件（用锡箔纸遮挡）、损坏塑料连接器、
     焊盘脱落、ESD 损伤芯片。非必要不拆焊。

其他提取路径（不用碰 Flash 芯片）：

14.4 硬件安全加固清单

生产层面：
□ 移除/不焊接调试排针；测试点放到 BGA 下方或灌胶
□ U-Boot：bootdelay=0，锁定环境变量，禁用串口 console
□ 内核：去掉 console= 或改为受控输出；关闭详细日志
□ 系统：删除 /etc/shadow 里的默认口令，禁用不必要的服务与端口
□ STM32：设 RDP Level 1（或 Level 2，但不可逆）
□ ESP32：烧 eFuse（Secure Boot V2 + Flash Encryption + JTAG_DISABLE）
   ★ 先在几片测试板上完整验证流程，eFuse 一旦烧写无法回退
□ Jetson / 高端 SoC：熔断 ODM fuse、启用 PKC/SBK 安全启动
□ 树莓派：全盘加密（LUKS）+ 安全启动 + 禁 USB 启动 + 物理封口

设计层面：
□ 固件里不要硬编码密钥（用芯片内安全存储/HSM/每设备唯一派生）
□ 串口/调试口在 PCB 上做焊盘而非排针，量产不焊接
□ 关键芯片（Flash）考虑用带加密的型号或 BGA 封装增加拆解难度
□ PCB 上不要有清晰的调试口丝印（VCC/GND/TX/RX 直接标出来等于指路）
□ 保留返修通道但做权限分级（如需要物理授权才能解锁调试口）

流程层面：
□ 出厂固件不含调试后门账号、不含测试用的 SSH 私钥
□ 升级包签名校验，且校验逻辑在 bootloader 里（不可被应用层绕过）
□ 建立漏洞响应与固件更新机制（能修 bug 比锁死更重要）

十五、本系列导航

• 本系列第 1 篇：《常见开发板选型与信息速查》——买什么板、各板规格与坑
• 本系列第 2 篇：《嵌入式开发环境配置实战》——Arduino IDE / PlatformIO / ESP-IDF / STM32Cube / 树莓派 / Jetson 环境搭建与排错

最后一条通用方法论：任何模块拿到手，按这个顺序走，能省掉大量无效调试时间——

1) 先查数据手册，确认：供电电压、接口类型、信号电平、典型时序
2) 供电，用万用表确认 VCC 引脚真的有电、GND 真的共地
3) 跑 I2C 地址扫描 / 读 WHO_AM_I / 读芯片 ID，确认通信链路
4) 跑厂商或社区提供的最小示例（不要自己先写）
5) 示例通了再改造成自己的代码
6) 出问题先怀疑：接线（40%）、电源（30%）、时序/配置（20%）、代码（10%）

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

分享文章