Point-to-Point Communication System

int unit = 200;        // Morse timing base (ms)

void Play_Dot_Dash(char sign) {
  if (sign == '.') {
    Laser_On();
    delay(unit);       // dot duration
    Laser_Off();
    delay(unit);       // intra-symbol gap
  }
  else if (sign == '-') {
    Laser_On();
    delay(3 * unit);   // dash duration
    Laser_Off();
    delay(unit);       // intra-symbol gap
  }
}

void Play_Letter(char Letter) {
  if (Letter == ' ') {
    delay(7 * unit);   // word gap
  } else {
    for (int j = 0; j < 26; j++) {
      if (MorseCode[j][5] == Letter) {
        for (int k = 0; k < 5; k++) {
          if (MorseCode[j][k] != 'x') Play_Dot_Dash(MorseCode[j][k]);
        }
        break;
      }
    }
    delay(2 * unit);   // letter gap
  }
}

Each letter is looked up in a table that stores its dots and dashes (an x marks an unused slot), then played by switching the laser on for 1 unit for a dot or 3 for a dash, each followed by 1 unit off. The unit is 200 ms. After a letter the code waits 2 more units, so letters are 3 units apart, and a space waits 7 more on top of that, which makes the gap between words 10 units.

// T9 LETTER INPUT
if (key >= '2' && key <= '9') {
  int num = key - '0';
  if (lastKey == num && (now - lastKeyPress) < 800) {
    pressCount++;
    if (pressCount >= (int)strlen(T9Letters[num])) pressCount = 0;
  } else {
    pressCount = 0;
  }
  lastKey = num;
  lastKeyPress = now;
  // ...
}

// CONFIRM LETTER
if (key == '#') {
  // ...
  To_Transmit += letter;
  // ...
}

// TRANSMIT MESSAGE
if (key == '*') {
  for (int i = 0; i < To_Transmit.length(); i++) {
    Play_Letter(To_Transmit[i]);
  }
  To_Transmit = "";
}

The 16-key keypad works like an old phone. Keys 2 to 9 each carry three or four letters, and pressing the same key again within 0.8 seconds steps to the next one. # adds the chosen letter to the message and * sends it. Keys A and B turn the servo that aims the laser 10° at a time, within 0 to 180°, and D recentres it. In the later version of the code, 0 locks the laser on so it can be aimed at the receiver.

uint8_t SYMBOL_MAX_X10 = 25;     // 2.5× dot => symbol gap
uint8_t LETTER_MAX_X10 = 45;     // 4.5× dot => letter gap (else word)

// ON -> OFF : dot or dash
if (dur < (2UL*DOT_UNIT)) {
  if (curLen<6) { currentSymbols[curLen++]='.'; Serial.print('.'); }
} else {
  if (curLen<6) { currentSymbols[curLen++]='-'; Serial.print('-'); }
}

uint8_t classifyGap_x10(uint32_t offMs, uint16_t dot){
  uint32_t units_x10 = (offMs*10UL)/(uint32_t)dot;
  if (units_x10 < SYMBOL_MAX_X10) return 0;
  if (units_x10 < LETTER_MAX_X10) return 1;
  return 2;
}

The receiver times how long the light stays on: under 2 dot-lengths is a dot and anything longer is a dash. When the light comes back on, it measures how long it was off, in tenths of a dot-length: under 2.5 dots is only the gap between symbols, under 4.5 ends a letter, and longer ends a word. The collected dots and dashes are looked up and the letter is shown on the LCD, and a letter is also finished if the light stays off long enough.

emaRaw = emaRaw + (raw - emaRaw)/EMA_RAW_ALPHA;
if (abs(emaRaw - baseline) < (int)max(marginOn, marginOff)*2){
  baseline = baseline + (emaRaw - baseline)/BASELINE_ALPHA;
}

bool nowOn = computeOnHys(emaRaw, isOn);

bool computeOnHys(int smoothedRaw, bool prevOn){
  int thrOn, thrOff;
  if (!INVERT_ON_LOGIC){
    thrOn  = (FIXED_THRESHOLD>0) ? FIXED_THRESHOLD : (baseline + marginOn);
    thrOff = (FIXED_THRESHOLD>0) ? FIXED_THRESHOLD : (baseline + marginOff);
    if (!prevOn) return smoothedRaw > thrOn;
    else         return smoothedRaw > thrOff;
  }
  // ...
}

The photoresistor's readings are smoothed with a moving average. At start-up the receiver measures the ambient light with no signal (it asks you to cover the sensor) and uses that as a baseline, which then drifts slowly with the room's light. The light counts as on once the smoothed reading rises 25 above the baseline and stays on until it falls back to within 15 of it, so flicker near the threshold doesn't create false pulses. Pulses shorter than 60 ms are ignored.