Retro Payphone Simulator

#include <Arduino.h>
#include <Keypad.h>
#include <DFRobotDFPlayerMini.h>
#include <SD.h>
#include <SPI.h>
#include <NewPing.h>


// Hoisted type definitions
enum PhoneState { ON_HOOK, CHOOSE_LANGUAGE, CHOOSE_QUESTION, WAIT_FOR_QUESTION, RECORDING, REPLAYING };


// Forward declarations
bool handsetLifted();
void playTrack(uint8_t track);
uint8_t questionTrack();
void writeLE16(File &file, uint16_t value);
void writeLE32(File &file, uint32_t value);
void writeWavHeader(File &file, uint32_t dataBytes);
void startSampler();
void stopSampler();
uint16_t bufferedSamples();
void flushAudio(bool all);
bool openAnswerFile();
void beginRecording();
void finishRecording();
void pauseForReplay();
void resetCall();
void handleTrackFinished();
void pollPlayer();

const uint8_t DFPLAYER_TX_PIN = 18;
const uint8_t DFPLAYER_RX_PIN = 19;
const uint8_t HOOK_PIN = 44;
const uint8_t RINGER_PIN = 45;
const uint8_t MIC_PIN = A0;
const uint8_t SD_CS_PIN = 53;
const uint8_t TRIG_PIN = 30;
const uint8_t ECHO_PIN = 31;

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {22, 23, 24, 25};
byte colPins[COLS] = {26, 27, 28, 29};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
NewPing distanceSensor(TRIG_PIN, ECHO_PIN, 200);
HardwareSerial &dfSerial = Serial1;
DFRobotDFPlayerMini player;

// DFPlayer card: 001.mp3 English menu, 002.mp3 Indonesian menu,
// 003.mp3 English digit prompt, 004.mp3 Indonesian digit prompt,
// 005-009 English questions 1-5, 010-014 Indonesian questions 1-5.
const uint8_t TRACK_ENGLISH_MENU = 1;
const uint8_t TRACK_INDONESIAN_MENU = 2;
const uint8_t TRACK_ENGLISH_DIGIT = 3;
const uint8_t TRACK_INDONESIAN_DIGIT = 4;
const uint8_t TRACK_ENGLISH_Q1 = 5;
const uint8_t TRACK_INDONESIAN_Q1 = 10;


PhoneState state = ON_HOOK;
bool indonesian = false;
uint8_t selectedQuestion = 0;
bool sdReady = false;
File answerFile;
uint32_t answerNumber = 0;

const uint16_t SAMPLE_RATE = 8000;
const uint16_t AUDIO_BUFFER_SIZE = 2048;
volatile uint8_t audioBuffer[AUDIO_BUFFER_SIZE];
volatile uint16_t writeIndex = 0;
volatile uint16_t readIndex = 0;
volatile bool samplerRunning = false;
volatile uint32_t sampleCount = 0;

bool handsetLifted() { return digitalRead(HOOK_PIN) == HIGH; }

void playTrack(uint8_t track) {
  player.play(track);
}

uint8_t questionTrack() {
  return (indonesian ? TRACK_INDONESIAN_Q1 : TRACK_ENGLISH_Q1) + selectedQuestion;
}

void writeLE16(File &file, uint16_t value) {
  file.write((uint8_t)(value & 0xFF));
  file.write((uint8_t)(value >> 8));
}

void writeLE32(File &file, uint32_t value) {
  file.write((uint8_t)(value & 0xFF));
  file.write((uint8_t)((value >> 8) & 0xFF));
  file.write((uint8_t)((value >> 16) & 0xFF));
  file.write((uint8_t)((value >> 24) & 0xFF));
}

void writeWavHeader(File &file, uint32_t dataBytes) {
  file.write("RIFF", 4); writeLE32(file, 36 + dataBytes); file.write("WAVE", 4);
  file.write("fmt ", 4); writeLE32(file, 16); writeLE16(file, 1); writeLE16(file, 1);
  writeLE32(file, SAMPLE_RATE); writeLE32(file, SAMPLE_RATE); writeLE16(file, 1); writeLE16(file, 8);
  file.write("data", 4); writeLE32(file, dataBytes);
}

ISR(ADC_vect) {
  if (!samplerRunning) return;
  uint16_t next = (writeIndex + 1) & (AUDIO_BUFFER_SIZE - 1);
  if (next != readIndex) {
    audioBuffer[writeIndex] = ADCH;
    writeIndex = next;
    sampleCount++;
  }
}

ISR(TIMER3_COMPA_vect) {
  if (samplerRunning) ADCSRA |= _BV(ADSC);
}

void startSampler() {
  noInterrupts();
  writeIndex = 0;
  readIndex = 0;
  sampleCount = 0;
  ADMUX = _BV(REFS0) | _BV(ADLAR) | 0; // A0, 8-bit samples in ADCH
  ADCSRA = _BV(ADEN) | _BV(ADIE) | _BV(ADPS2) | _BV(ADPS0); // prescaler 32
  TCCR3A = 0;
  TCCR3B = _BV(WGM32) | _BV(CS31); // 2 MHz timer clock
  OCR3A = 249; // 8,000 sample triggers per second
  TCNT3 = 0;
  TIMSK3 = _BV(OCIE3A);
  samplerRunning = true;
  interrupts();
}

void stopSampler() {
  noInterrupts();
  samplerRunning = false;
  TIMSK3 &= ~_BV(OCIE3A);
  ADCSRA &= ~_BV(ADIE);
  interrupts();
}

uint16_t bufferedSamples() {
  noInterrupts();
  uint16_t amount = (writeIndex - readIndex) & (AUDIO_BUFFER_SIZE - 1);
  interrupts();
  return amount;
}

void flushAudio(bool all) {
  uint8_t block[128];
  while (answerFile && (all ? bufferedSamples() > 0 : bufferedSamples() >= sizeof(block))) {
    uint16_t count = min((uint16_t)sizeof(block), bufferedSamples());
    noInterrupts();
    for (uint16_t i = 0; i < count; i++) {
      block[i] = audioBuffer[readIndex];
      readIndex = (readIndex + 1) & (AUDIO_BUFFER_SIZE - 1);
    }
    interrupts();
    answerFile.write(block, count);
  }
}

bool openAnswerFile() {
  char name[13];
  for (uint32_t n = 1; n < 100000; n++) {
    snprintf(name, sizeof(name), "A%05lu.WAV", (unsigned long)n);
    if (!SD.exists(name)) {
      answerFile = SD.open(name, FILE_WRITE);
      answerNumber = n;
      if (answerFile) writeWavHeader(answerFile, 0);
      return (bool)answerFile;
    }
  }
  return false;
}

void beginRecording() {
  if (!sdReady || !openAnswerFile()) {
    tone(RINGER_PIN, 180, 600);
    state = CHOOSE_QUESTION;
    return;
  }
  startSampler();
  state = RECORDING;
}

void finishRecording() {
  stopSampler();
  flushAudio(true);
  if (answerFile) {
    uint32_t dataBytes = answerFile.size() - 44;
    answerFile.seek(0);
    writeWavHeader(answerFile, dataBytes);
    answerFile.close();
  }
  tone(RINGER_PIN, 1200, 120);
  state = ON_HOOK;
}

void pauseForReplay() {
  stopSampler();
  flushAudio(true);
  playTrack(questionTrack());
  state = REPLAYING;
}

void resetCall() {
  if (answerFile) finishRecording();
  else {
    stopSampler();
    state = ON_HOOK;
  }
}

void handleTrackFinished() {
  if (state == WAIT_FOR_QUESTION) beginRecording();
  else if (state == REPLAYING) {
    startSampler();
    state = RECORDING;
  }
}

void pollPlayer() {
  if (!player.available()) return;
  uint8_t event = player.readType();
  int value = player.read();
  (void)value;
  if (event == DFPlayerPlayFinished) handleTrackFinished();
}

void setup() {
  pinMode(HOOK_PIN, INPUT_PULLUP);
  pinMode(RINGER_PIN, OUTPUT);
  pinMode(SD_CS_PIN, OUTPUT);
  digitalWrite(SD_CS_PIN, HIGH);
  dfSerial.begin(9600);
  player.begin(dfSerial, true, true);
  player.volume(23); // 0 to 30
  sdReady = SD.begin(SD_CS_PIN);
  noTone(RINGER_PIN);
}

void loop() {
  pollPlayer();
  if (!handsetLifted()) {
    if (state != ON_HOOK) resetCall();
    delay(20);
    return;
  }

  if (state == ON_HOOK) {
    tone(RINGER_PIN, 850, 140);
    playTrack(TRACK_ENGLISH_MENU);
    state = CHOOSE_LANGUAGE;
  }

  if (state == RECORDING) flushAudio(false);
  char key = keypad.getKey();
  if (!key) return;

  if (state == CHOOSE_LANGUAGE) {
    if (key == '*') {
      indonesian = false;
      playTrack(TRACK_ENGLISH_DIGIT);
      state = CHOOSE_QUESTION;
    } else if (key == '#') {
      indonesian = true;
      playTrack(TRACK_INDONESIAN_MENU);
      state = CHOOSE_QUESTION;
    }
  } else if (state == CHOOSE_QUESTION && key >= '0' && key <= '9') {
    selectedQuestion = (key - '0') % 5; // 0/5, 1/6, 2/7, 3/8, 4/9
    playTrack(questionTrack());
    state = WAIT_FOR_QUESTION;
  } else if (state == RECORDING) {
    if (key == '*') finishRecording();
    else if (key == '#') pauseForReplay();
  }
}