ESP32 串口通信：把另一台设备的数据读完整

// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
#include <stddef.h>

// Protocol: @ + 1..32 printable ASCII payload bytes (except @) + [CR] LF.
// Returned bits may combine TIMEOUT with an event for the new incoming byte.
class PacketParser {
 public:
  enum Event : uint8_t { NONE=0, FRAME=1, TIMEOUT=2, OVERLONG=4,
                        INVALID=8, EMPTY=16, RESYNC=32 };
  static constexpr size_t MAX_PAYLOAD=32;
  static constexpr uint32_t GAP_MS=250, FRAME_MS=1000;
  uint8_t tick(uint32_t now) {
    if (state_ != WAIT && (uint32_t(now-last_) >= GAP_MS ||
                           uint32_t(now-start_) >= FRAME_MS)) {
      reset(); return TIMEOUT;
    }
    return NONE;
  }
  uint8_t feed(uint8_t b, uint32_t now) {
    uint8_t events=tick(now);
    if (b=='@') {
      if (state_ != WAIT) events |= RESYNC;
      state_=READ; size_=0; cr_=false; start_=last_=now;
      return events;
    }
    if (state_==WAIT) return events;
    last_=now;
    if (state_==DROP) {
      if (b=='\n') reset();
      return events;
    }
    if (b=='\n') {
      if (size_==0) { reset(); return events | EMPTY; }
      payload_[size_]='\0'; state_=WAIT; cr_=false;
      return events | FRAME;
    }
    if (b=='\r' && !cr_) { cr_=true; return events; }
    if (cr_ || b<32 || b>126) {
      state_=DROP; return events | INVALID;
    }
    if (size_==MAX_PAYLOAD) {
      state_=DROP; return events | OVERLONG;
    }
    payload_[size_++]=char(b);
    return events;
  }
  const char* payload() const { return payload_; }
 private:
  enum State : uint8_t { WAIT, READ, DROP } state_=WAIT;
  char payload_[MAX_PAYLOAD+1]={};
  size_t size_=0;
  bool cr_=false;
  uint32_t start_=0,last_=0;
  void reset() { state_=WAIT; size_=0; cr_=false; }
};

// SPDX-License-Identifier: MIT
#include <Arduino.h>
#include "PacketParser.h"

constexpr int DATA_RX=17, DATA_TX=18;
HardwareSerial DataUart(1);
PacketParser parser;
uint32_t frames=0;
bool ready=false;

void report(uint8_t e) {
  if (!e) return;
  if (e & PacketParser::TIMEOUT) Serial.println("REJECT timeout");
  if (e & PacketParser::OVERLONG) Serial.println("REJECT overlong");
  if (e & PacketParser::INVALID) Serial.println("REJECT invalid");
  if (e & PacketParser::EMPTY) Serial.println("REJECT empty");
  if (e & PacketParser::RESYNC) Serial.println("RESYNC new @");
  if (e & PacketParser::FRAME) {
    Serial.printf("FRAME %lu [%s]\n", (unsigned long)++frames, parser.payload());
  }
}
void setup() {
  Serial.begin(115200);  // DevKitC-1 USB-to-UART bridge, not the data cable.
  if (DataUart.setRxBufferSize(256) != 256) {
    Serial.println("STOP rx buffer allocation failed"); return;
  }
  DataUart.begin(115200, SERIAL_8N1, DATA_RX, DATA_TX);
  if (!DataUart) { Serial.println("STOP UART init failed"); return; }
  ready=true;
  Serial.println("READY UART1 RX=17 TX=18 115200 8N1; @payload[CR]LF");
}
void loop() {
  if (ready) {
    report(parser.tick(millis()));
    // Bound each drain: other loop work gets a chance even with continuous input.
    for (unsigned n=0; n<64 && DataUart.available()>0; ++n) {
      int b=DataUart.read();
      if (b>=0) report(parser.feed(uint8_t(b), millis()));
    }
  }
  delay(1);
}

arduino-cli compile --fqbn 'esp32:esp32:esp32s3:FlashSize=8M,PSRAM=opi,FlashMode=qio,PartitionScheme=default_8MB,CDCOnBoot=default,USBMode=hwcdc' .
clang++ -std=c++17 -Wall -Wextra -Werror tests/parser_test.cpp -o /tmp/p07-test
/tmp/p07-test

python3 -m venv .venv
.venv/bin/python -m pip install -r requirements-fixture.txt
.venv/bin/python send-fixture.py --data-port YOUR_DATA_PORT