Morse code telegraph decoder on an Arduino Uno

// Morse code telegraph decoder: one button, a piezo and an I2C LCD on an Uno.
//
//   key (button)   pin 2 to GND
//   piezo          pin 9 and GND (the sidetone, so you can hear yourself)
//   LCD 16x2       I2C on A4 and A5, address 0x27
//
// Tap the key. A short press is a dot, a long one a dash. Pause for a moment
// and the letter is finished; pause longer and the word is. The LCD shows the
// last 16 letters on the top line and the dots and dashes so far on the
// bottom line. Send ... --- ... (S O S) and the sketch says so.
//
// # Nobody taps at the same speed
//
// A dash is three times as long as a dot, but how long a dot is depends on
// the person. So nothing here is a fixed number of milliseconds. The sketch
// keeps `unit`, its idea of one dot, starting at 200 ms. A press shorter than
// two units is a dot, anything longer a dash, and after every press the unit
// is moved halfway to what was just tapped (a dot's length, or a third of a
// dash's). Tap faster and `unit` follows within a few presses. The pauses use
// it too: a gap over two units ends a letter, over five ends a word, halfway
// between the lengths a pause can be.
//
// # A letter is a walk down a tree
//
// E is a dot and T is a dash; A is dot-dash and N is dash-dot. Every letter
// is a path of dots and dashes from the start, and the alphabet makes a
// binary tree. Number the nodes so the start is 1, a dot goes from node n to
// 2n and a dash to 2n + 1, and the whole alphabet fits in one 64-letter
// string: index 1 is the start, 2 is E, 3 is T, 5 is A (dot, dash) and so on.
// Decoding is then just doubling a number, with no list of codes to search.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

const uint8_t KEY = 2;
const uint8_t PIEZO = 9;
const int SIDETONE = 650;

// the tree, indexed as described above; * marks a path that is not a letter
const char TREE[65] = "**ETIANMSURWDKGOHVF*L*PJBXCYZQ**54*3***2*******16*******7***8*90";

LiquidCrystal_I2C lcd(0x27, 16, 2);

unsigned long unit = 200;       // ms in one dot
uint8_t node = 1;               // where in the tree the current letter is
char symbols[8];                // the dots and dashes so far
uint8_t symbolCount = 0;
char text[17] = "";             // the last letters, newest at the end
uint8_t textLen = 0;
char lastThree[4] = "";

bool keyDown = false;
bool reading = false;
unsigned long changedAt = 0;    // when the stable state last changed
unsigned long pressedAt = 0;
unsigned long releasedAt = 0;
bool letterOpen = false;        // a letter is waiting for its gap
bool wordOpen = false;          // a word is waiting for its gap

void showLine() {
  lcd.setCursor(0, 0);
  lcd.print(text);
  for (int i = textLen; i < 16; i++) lcd.print(' ');
  lcd.setCursor(0, 1);
  for (int i = 0; i < symbolCount; i++) lcd.print(symbols[i]);
  for (int i = symbolCount; i < 16; i++) lcd.print(' ');
}

void addChar(char c) {
  if (textLen == 16) {
    for (int i = 0; i < 15; i++) text[i] = text[i + 1];
    textLen = 15;
  }
  text[textLen++] = c;
  text[textLen] = 0;
  // the last three characters, for spotting SOS
  lastThree[0] = lastThree[1];
  lastThree[1] = lastThree[2];
  lastThree[2] = c;
  lastThree[3] = 0;
}

void finishLetter() {
  char c = node < 64 ? TREE[node] : '*';
  if (c == '*') c = '?';
  addChar(c);
  Serial.print("letter: ");
  Serial.println(c);
  node = 1;
  symbolCount = 0;
  letterOpen = false;
  showLine();
  if (lastThree[0] == 'S' && lastThree[1] == 'O' && lastThree[2] == 'S') {
    Serial.println("SOS received: help is on the way");
    lcd.setCursor(0, 1);
    lcd.print("SOS! HELP COMING");
    lastThree[0] = 0;
  }
}

void finishWord() {
  addChar(' ');
  Serial.println("word end");
  wordOpen = false;
  showLine();
}

void pressEnded(unsigned long length) {
  bool dash = length >= 2 * unit;
  if (symbolCount < 6) symbols[symbolCount++] = dash ? '-' : '.';
  if (node < 32) node = node * 2 + (dash ? 1 : 0);
  else node = 64;  // too long to be a letter
  // move the unit halfway to this press, a dot's length or a third of a dash's
  unsigned long sample = dash ? length / 3 : length;
  unit = (unit + sample) / 2;
  unit = constrain(unit, 40UL, 600UL);
  Serial.print(dash ? "dash " : "dot ");
  Serial.print(length);
  Serial.print(" ms, unit ");
  Serial.println(unit);
  letterOpen = true;
  wordOpen = true;
  // Only the one new symbol is drawn: redrawing both rows takes the LCD tens
  // of milliseconds, and the loop must be back to watching the key by then.
  if (symbolCount > 0) {
    lcd.setCursor(symbolCount - 1, 1);
    lcd.print(symbols[symbolCount - 1]);
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(KEY, INPUT_PULLUP);
  pinMode(PIEZO, OUTPUT);
  Wire.setClock(400000);
  lcd.init();
  lcd.backlight();
  showLine();
  Serial.println("morse decoder ready: tap the key");
}

void loop() {
  unsigned long now = millis();

  // debounce: a new reading counts once it has held for 30 ms, long enough to ride out the contact bounce
  bool raw = digitalRead(KEY) == LOW;
  if (raw != reading) {
    reading = raw;
    changedAt = now;
  }
  if (reading != keyDown && now - changedAt >= 30) {
    keyDown = reading;
    if (keyDown) {
      pressedAt = now;
      tone(PIEZO, SIDETONE);
    } else {
      noTone(PIEZO);
      releasedAt = now;
      pressEnded(now - pressedAt);
    }
  }

  // the gaps: more than two units end a letter (a gap is one or three), more
  // than five end a word (three or seven): halfway between the lengths it can be
  if (!keyDown) {
    unsigned long quiet = now - releasedAt;
    if (letterOpen && quiet > 2 * unit) finishLetter();
    if (wordOpen && !letterOpen && quiet > 5 * unit) finishWord();
  }
}