The UART and Start-Stop Framing

// A UART receiver in software, with its baud rate under your control, so you can walk it off
// the transmitter's and watch which bit fails first.
//
// There is no clock on the wire. The receiver's only reference is the start bit's falling edge;
// it then samples each bit at (0.5 + k) of ITS OWN bit time. Error accumulates across the frame,
// so the stop bit is the first sample to land in the wrong place.
//
// The TRANSMITTER is the ESP32's hardware UART2, which sends in the background with exact timing
// while the CPU runs the software receiver. (A single-threaded bit-banged transmitter cannot work
// here: it finishes the byte before the receiver starts listening.)
//
// Wiring: GPIO17 (UART2 TX) -> GPIO16 (software RX), one jumper. Scope on GPIO17 to see the frame.

const int   PIN_TX      = 17;       // UART2 TX
const int   PIN_UNUSED  = 19;       // UART2 RX, not used: kept off GPIO16 so the software receiver owns it
const int   PIN_RX      = 16;       // software receiver input
const float BAUD_TX     = 9600.0;

// Returns the byte, -1 on a FRAMING ERROR (stop bit not high), -2 if nothing arrived, -3 on a glitch.
int rxByte(float baud_rx, unsigned long timeout_us) {
  const float bit_us = 1e6f / baud_rx;
  unsigned long t0 = micros();
  while (digitalRead(PIN_RX) == HIGH)          // wait for the start bit's falling edge
    if (micros() - t0 > timeout_us) return -2;
  const unsigned long te = micros();           // the edge, to within one polling pass
  auto waitUntil = [&](float t_us) { while ((float)(micros() - te) < t_us) { } };

  waitUntil(0.5f * bit_us);                    // middle of the start bit: must still be low
  if (digitalRead(PIN_RX) != LOW) return -3;
  uint8_t b = 0;
  for (int i = 0; i < 8; i++) {                // middle of each data bit, LSB first, timed from the edge
    waitUntil((1.5f + i) * bit_us);
    if (digitalRead(PIN_RX)) b |= (1 << i);
  }
  waitUntil(9.5f * bit_us);                    // middle of the stop bit
  if (digitalRead(PIN_RX) != HIGH) return -1;
  return b;
}

void setup() {
  Serial.begin(115200);
  delay(300);
  pinMode(PIN_RX, INPUT_PULLUP);
  Serial2.begin((unsigned long)BAUD_TX, SERIAL_8N1, PIN_UNUSED, PIN_TX);   // idle is MARK (high)

  const uint8_t msg[] = {0x55, 0xAA, 0x00, 0xFF, 0x41};
  Serial.println("# UART clock tolerance sweep, 8N1, one idle gap after each byte");
  Serial.println("rx_error_pct,bytes_ok,framing_errors,wrong_data,missed");

  for (int e = -10; e <= 10; e++) {
    const float baud_rx = BAUD_TX * (1.0f + e / 100.0f);   // positive e: receiver runs FAST
    int ok = 0, framing = 0, wrong = 0, missed = 0;
    for (int r = 0; r < 20; r++) {
      for (unsigned i = 0; i < sizeof(msg); i++) {
        Serial2.write(msg[i]);                 // starts sending at once; the receiver catches the edge
        int got = rxByte(baud_rx, 20000);
        Serial2.flush();                       // let the byte finish: leaves an idle gap before the next
        delay(2);
        if (got == -1)               framing++;
        else if (got < 0)            missed++;
        else if (got != msg[i])      wrong++;
        else                         ok++;
      }
    }
    Serial.printf("%d,%d,%d,%d,%d\n", e, ok, framing, wrong, missed);
  }
  Serial.println("# receiver fast: framing errors appear first (the stop sample lands on the last data bit);");
  Serial.println("# receiver slow: wrong data appears instead (the late stop sample lands on the idle mark).");
}

void loop() {}