The UART and Start-Stop Framing

// A bit-banged UART transmitter and receiver, with the receiver's baud rate under your
// control so you can walk it off and watch WHICH bit fails first.
//
// The point of the exercise: there is no clock on the wire. The receiver guesses, using the
// start bit's falling edge as its only reference. Error accumulates across the frame, so the
// stop bit is always the first casualty -- and a framing error is exactly how a UART tells
// you the two clocks have drifted apart.
//
// Wiring: GPIO17 (TX) -> GPIO16 (RX), one jumper. Scope on GPIO17 to see the frame.

const int PIN_TX = 17;
const int PIN_RX = 16;

const float BAUD_TX = 9600.0;
float       BAUD_RX = 9600.0;      // walked off deliberately below

inline void bitDelay(float baud) { delayMicroseconds((unsigned)(1e6 / baud)); }

void txByte(uint8_t b) {
  digitalWrite(PIN_TX, LOW);                 // start bit: the line leaves its idle HIGH
  bitDelay(BAUD_TX);
  for (int i = 0; i < 8; i++) {              // 8 data bits, LSB FIRST
    digitalWrite(PIN_TX, (b >> i) & 1);
    bitDelay(BAUD_TX);
  }
  digitalWrite(PIN_TX, HIGH);                // stop bit: back to idle
  bitDelay(BAUD_TX);
}

// Returns the byte, or -1 on a FRAMING ERROR (the stop bit was not high).
int rxByte(unsigned long timeout_us) {
  unsigned long t0 = micros();
  while (digitalRead(PIN_RX) == HIGH)        // wait for the start bit's falling edge
    if (micros() - t0 > timeout_us) return -2;

  // Land in the MIDDLE of the start bit and confirm it is still low: half a bit time.
  delayMicroseconds((unsigned)(0.5e6 / BAUD_RX));
  if (digitalRead(PIN_RX) != LOW) return -3; // a glitch, not a start bit

  uint8_t b = 0;
  for (int i = 0; i < 8; i++) {
    bitDelay(BAUD_RX);                       // step to the middle of the next bit
    if (digitalRead(PIN_RX)) b |= (1 << i);
  }
  bitDelay(BAUD_RX);
  if (digitalRead(PIN_RX) != HIGH) return -1;  // FRAMING ERROR: stop bit was not a mark
  return b;
}

void setup() {
  Serial.begin(115200);
  delay(300);
  pinMode(PIN_TX, OUTPUT);
  digitalWrite(PIN_TX, HIGH);                // idle is MARK, so a break is detectable
  pinMode(PIN_RX, INPUT_PULLUP);

  const uint8_t msg[] = {0x55, 0xAA, 0x00, 0xFF, 0x41};
  Serial.println("# UART clock tolerance sweep");
  Serial.println("rx_error_pct,bytes_ok,framing_errors,wrong_data");

  for (int e = -10; e <= 10; e++) {
    BAUD_RX = BAUD_TX * (1.0 + e / 100.0);
    int ok = 0, framing = 0, wrong = 0;

    for (int r = 0; r < 20; r++) {
      for (unsigned i = 0; i < sizeof(msg); i++) {
        txByte(msg[i]);
        int got = rxByte(20000);
        if (got == -1)      framing++;
        else if (got < 0)   framing++;
        else if (got != msg[i]) wrong++;
        else                ok++;
      }
    }
    Serial.printf("%d,%d,%d,%d\n", e, ok, framing, wrong);
  }
  Serial.println("# note WHERE it breaks, and that framing errors appear before wrong data:");
  Serial.println("# the stop bit drifts out of position before the data bits do.");
}

void loop() {}