Retro Payphone Simulator

#include <Arduino.h>
#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>
#include <Keypad.h>


// Hoisted type definitions
enum PhoneState { WAITING, RINGING, CHOOSE_LANGUAGE, PLAYING_QUESTION, RECORDING_ANSWER, GOODBYE, WAIT_FOR_CLEAR };


// Forward declarations
bool handsetLifted();
long distanceCm();
void stopRinger();
void updateRinger();
void playTrack(uint8_t track);
void beginState(PhoneState next);

const byte KEYPAD_R1 = 2;
const byte KEYPAD_R2 = 3;
const byte KEYPAD_R3 = 4;
const byte KEYPAD_R4 = 5;
const byte KEYPAD_C1 = 6;
const byte KEYPAD_C2 = 7;
const byte KEYPAD_C3 = 8;
const byte KEYPAD_C4 = 9;
const byte ULTRASONIC_TRIG = 10;
const byte ULTRASONIC_ECHO = 11;
const byte DFPLAYER_TX_TO_UNO = 12;
const byte UNO_TX_TO_DFPLAYER = 13;
const byte HOOK_SWITCH_PIN = 14;
const byte RINGER_PIN = 15;
const byte RECORDER_REC_PIN = 16;

const unsigned int VISITOR_DISTANCE_CM = 80;
const unsigned long SENSOR_INTERVAL_MS = 120;
const unsigned long RING_TOGGLE_MS = 250;
const unsigned long QUESTION_DURATION_MS = 15000;
const unsigned long GOODBYE_DURATION_MS = 5000;

// microSD files: 0001=language menu, 0002=Indonesian question,
// 0003=English question, 0004=put handset back and leave.
const uint8_t TRACK_LANGUAGE_MENU = 1;
const uint8_t TRACK_QUESTION_ID = 2;
const uint8_t TRACK_QUESTION_EN = 3;
const uint8_t TRACK_GOODBYE = 4;

char keyMap[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[4] = {KEYPAD_R1, KEYPAD_R2, KEYPAD_R3, KEYPAD_R4};
byte colPins[4] = {KEYPAD_C1, KEYPAD_C2, KEYPAD_C3, KEYPAD_C4};
Keypad keypad = Keypad(makeKeymap(keyMap), rowPins, colPins, 4, 4);

SoftwareSerial dfSerial(DFPLAYER_TX_TO_UNO, UNO_TX_TO_DFPLAYER);
DFRobotDFPlayerMini dfPlayer;
bool dfPlayerReady = false;


PhoneState state = WAITING;
unsigned long stateStartedAt = 0;
unsigned long lastSensorAt = 0;
unsigned long lastRingToggleAt = 0;
bool ringerOn = false;

bool handsetLifted() {
  // The NO contact closes to GND only when the handset releases the switch.
  return digitalRead(HOOK_SWITCH_PIN) == LOW;
}

long distanceCm() {
  digitalWrite(ULTRASONIC_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(ULTRASONIC_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(ULTRASONIC_TRIG, LOW);
  unsigned long pulse = pulseIn(ULTRASONIC_ECHO, HIGH, 25000UL);
  if (pulse == 0) return 999;
  return pulse / 58UL;
}

void stopRinger() {
  noTone(RINGER_PIN);
  ringerOn = false;
}

void updateRinger() {
  if (millis() - lastRingToggleAt < RING_TOGGLE_MS) return;
  lastRingToggleAt = millis();
  ringerOn = !ringerOn;
  if (ringerOn) {
    tone(RINGER_PIN, 1200);
  } else {
    noTone(RINGER_PIN);
  }
}

void playTrack(uint8_t track) {
  if (dfPlayerReady) dfPlayer.play(track);
}

void beginState(PhoneState next) {
  stopRinger();
  digitalWrite(RECORDER_REC_PIN, LOW);
  state = next;
  stateStartedAt = millis();
}

void setup() {
  pinMode(ULTRASONIC_TRIG, OUTPUT);
  pinMode(ULTRASONIC_ECHO, INPUT);
  pinMode(HOOK_SWITCH_PIN, INPUT_PULLUP);
  pinMode(RINGER_PIN, OUTPUT);
  pinMode(RECORDER_REC_PIN, OUTPUT);
  digitalWrite(RECORDER_REC_PIN, LOW);

  dfSerial.begin(9600);
  if (dfPlayer.begin(dfSerial, true, true)) {
    dfPlayerReady = true;
    dfPlayer.volume(23); // 0 to 30
  }
}

void loop() {
  const unsigned long now = millis();
  char key = keypad.getKey();

  if (state == WAITING) {
    if (now - lastSensorAt >= SENSOR_INTERVAL_MS) {
      lastSensorAt = now;
      if (distanceCm() <= VISITOR_DISTANCE_CM) {
        beginState(RINGING);
      }
    }
    return;
  }

  if (state == RINGING) {
    updateRinger();
    if (handsetLifted()) {
      beginState(CHOOSE_LANGUAGE);
      playTrack(TRACK_LANGUAGE_MENU);
    }
    return;
  }

  if (state == CHOOSE_LANGUAGE) {
    if (!handsetLifted()) {
      beginState(WAIT_FOR_CLEAR);
      return;
    }
    if (key == '1' || key == '2') {
      beginState(PLAYING_QUESTION);
      playTrack(key == '1' ? TRACK_QUESTION_ID : TRACK_QUESTION_EN);
    }
    return;
  }

  if (state == PLAYING_QUESTION) {
    if (!handsetLifted()) {
      beginState(WAIT_FOR_CLEAR);
      return;
    }
    // Set QUESTION_DURATION_MS to the actual length of 0002/0003 plus 1 second.
    if (now - stateStartedAt >= QUESTION_DURATION_MS) {
      beginState(RECORDING_ANSWER);
      digitalWrite(RECORDER_REC_PIN, HIGH);
    }
    return;
  }

  if (state == RECORDING_ANSWER) {
    if (!handsetLifted()) {
      beginState(WAIT_FOR_CLEAR);
      return;
    }
    // The ISD1820 stops automatically at its memory limit (normally about 10 seconds).
    if (key == '*') {
      digitalWrite(RECORDER_REC_PIN, LOW);
      beginState(GOODBYE);
      playTrack(TRACK_GOODBYE);
    }
    return;
  }

  if (state == GOODBYE) {
    if (!handsetLifted() || now - stateStartedAt >= GOODBYE_DURATION_MS) {
      beginState(WAIT_FOR_CLEAR);
    }
    return;
  }

  if (state == WAIT_FOR_CLEAR) {
    if (now - lastSensorAt >= SENSOR_INTERVAL_MS) {
      lastSensorAt = now;
      if (distanceCm() > VISITOR_DISTANCE_CM) {
        beginState(WAITING);
      }
    }
  }
}