The FSK Modem

// An FSK modem in software: Bell 103 tones, generated and detected on an ESP32.
//
// Transmit by switching between two sine tables; receive with a pair of Goertzel filters,
// one tuned to mark and one to space, deciding whichever is louder over each bit period.
//
// This genuinely works. Feed the DAC output into another machine's microphone input, or
// join the two boards with an audio cable and a couple of capacitors, and you have a
// 300 baud link over anything that carries voice -- including, if you are feeling
// historical, a loudspeaker and a microphone across the room.
//
// Wiring: GPIO25 (DAC1) -> 1uF -> line out / speaker
//         GPIO34 (ADC1) <- 1uF <- line in / microphone preamp, biased to mid-rail

const int PIN_TX = 25;
const int PIN_RX = 34;

const float FS      = 9600.0;    // sample rate
const float BAUD    = 300.0;
const float F_MARK  = 1270.0;    // originate mark  (logic 1)
const float F_SPACE = 1070.0;    // originate space (logic 0)
const int   N       = (int)(FS / BAUD);   // 32 samples per bit

// ---- Goertzel: one DFT bin, two taps, no arrays
float goertzel(const int16_t *x, int n, float f) {
  float k = 2.0f * cosf(2.0f * PI * f / FS);
  float s1 = 0, s2 = 0;
  for (int i = 0; i < n; i++) {
    float s0 = (float)x[i] + k * s1 - s2;
    s2 = s1; s1 = s0;
  }
  return s1 * s1 + s2 * s2 - k * s1 * s2;
}

void txBit(int bit) {
  float f = bit ? F_MARK : F_SPACE;
  static float phase = 0.0f;                 // CONTINUOUS phase across bits: no clicks,
  for (int i = 0; i < N; i++) {              // and clicks are broadband energy that the
    phase += 2.0f * PI * f / FS;             // far end's filters would hear as both tones
    if (phase > 2.0f * PI) phase -= 2.0f * PI;
    dacWrite(PIN_TX, (int)(127.5f + 127.0f * sinf(phase)));
    delayMicroseconds((unsigned)(1e6 / FS));
  }
}

void txByte(uint8_t b) {
  txBit(0);                                  // start bit -- blueprint 1's framing, on tones
  for (int i = 0; i < 8; i++) txBit((b >> i) & 1);
  txBit(1);                                  // stop bit
}

int rxBit(int16_t *buf) {
  for (int i = 0; i < N; i++) {
    buf[i] = (int16_t)(analogRead(PIN_RX) - 2048);   // remove the mid-rail bias
    delayMicroseconds((unsigned)(1e6 / FS));
  }
  return goertzel(buf, N, F_MARK) > goertzel(buf, N, F_SPACE) ? 1 : 0;
}

void setup() {
  Serial.begin(115200);
  delay(300);
  analogReadResolution(12);
  analogSetPinAttenuation(PIN_RX, ADC_11db);

  static int16_t buf[64];

  Serial.println("# Bell 103 FSK, 300 baud");
  Serial.printf("# mark %.0f Hz, space %.0f Hz, %d samples per bit\n", F_MARK, F_SPACE, N);
  Serial.println("# transmitting 'YOUBLOB' continuously; also reporting the two filter outputs");

  const char *msg = "YOUBLOB";
  while (true) {
    for (const char *p = msg; *p; p++) txByte(*p);
    txBit(1); txBit(1);                      // idle at mark between messages

    // Report what the detector sees, so you can watch the margin rather than guess at it.
    rxBit(buf);
    float m = goertzel(buf, N, F_MARK), s = goertzel(buf, N, F_SPACE);
    Serial.printf("mark=%.0f space=%.0f ratio=%.2f\n", m, s, (m > s ? m / (s + 1) : s / (m + 1)));
    delay(200);
  }
}

void loop() {}