FM and MFM: Making the Data Clock Itself

// MFM encoder and decoder on an ESP32, with a deliberately wobbly clock so you can
// watch the detection window close.
//
// The point of the exercise: encode a byte, transmit it as flux TRANSITIONS at a data
// rate you control, recover it with a software PLL, then walk the clock error up until
// the decoder fails. The error at which it fails is the detection window, and it is the
// number that decides how dense a drive can be.
//
// Wiring (optional, for the scope): GPIO18 outputs the flux waveform, GPIO19 pulses on
// each recovered transition. With no wiring at all the sketch still runs the loopback.

const int PIN_FLUX = 18;
const int PIN_TICK = 19;

// ---- MFM encode: clock bit is 1 only when previous and current data bits are both 0
int encodeMFM(const uint8_t *data, int nBytes, uint8_t *cells) {
  int n = 0, prev = 0;
  for (int i = 0; i < nBytes; i++) {
    for (int b = 7; b >= 0; b--) {
      int bit = (data[i] >> b) & 1;
      cells[n++] = (prev == 0 && bit == 0) ? 1 : 0;   // clock cell
      cells[n++] = bit;                                // data cell
      prev = bit;
    }
  }
  return n;
}

// ---- turn the cell stream into transition TIMES, with a clock error applied
int cellsToTimes(const uint8_t *cells, int nCells, float cellNs, float err, uint32_t *t) {
  int n = 0;
  float now = 0.0;
  for (int i = 0; i < nCells; i++) {
    now += cellNs * (1.0 + err);
    if (cells[i]) t[n++] = (uint32_t)now;
  }
  return n;
}

// ---- software PLL: nudge the window to each arriving transition, then bin it
int decodeMFM(const uint32_t *t, int nT, float cellNs, uint8_t *cells) {
  int n = 0;
  float window = cellNs, phase = 0.0;
  uint32_t last = 0;
  for (int i = 0; i < nT; i++) {
    float gap = (float)(t[i] - last);
    int nCells = (int)(gap / window + 0.5);            // how many cells since the last one
    if (nCells < 1) nCells = 1;
    for (int j = 1; j < nCells; j++) cells[n++] = 0;   // the silent cells
    cells[n++] = 1;                                    // this transition
    // PLL: pull the window towards the observed spacing, gently
    float measured = gap / nCells;
    window += 0.05 * (measured - window);
    last = t[i];
  }
  return n;
}

int cellsToBytes(const uint8_t *cells, int nCells, uint8_t *out) {
  int n = 0; uint8_t acc = 0; int nb = 0;
  for (int i = 1; i < nCells; i += 2) {                // data cells are the odd ones
    acc = (acc << 1) | cells[i];
    if (++nb == 8) { out[n++] = acc; acc = 0; nb = 0; }
  }
  return n;
}

void setup() {
  Serial.begin(115200);
  delay(300);
  pinMode(PIN_FLUX, OUTPUT);
  pinMode(PIN_TICK, OUTPUT);

  const uint8_t msg[] = {0xA3, 0x00, 0x00, 0xFF, 0x5A};
  const int nMsg = sizeof(msg);
  static uint8_t cells[512], back[512], outBytes[64];
  static uint32_t times[512];

  int nCells = encodeMFM(msg, nMsg, cells);
  int nTrans = 0;
  for (int i = 0; i < nCells; i++) nTrans += cells[i];
  Serial.printf("# %d data bits -> %d channel cells, %d flux transitions\n",
                nMsg * 8, nCells, nTrans);
  Serial.println("clock_error_pct,bytes_recovered,ok");

  // Walk the clock error up until the decoder gives up.
  for (int e = 0; e <= 30; e++) {
    float err = e / 100.0;
    int nT = cellsToTimes(cells, nCells, 1000.0, err, times);
    int nB = decodeMFM(times, nT, 1000.0, back);
    int nOut = cellsToBytes(back, nB, outBytes);

    bool ok = (nOut >= nMsg);
    for (int i = 0; ok && i < nMsg; i++) ok = (outBytes[i] == msg[i]);
    Serial.printf("%d,%d,%s\n", e, nOut, ok ? "OK" : "FAIL");
    if (!ok) {
      Serial.printf("# detection window closed at about %d %% clock error\n", e);
      break;
    }
  }
}

void loop() {}