Morse.h

Go to the documentation of this file.

#pragma once
 
#include <ctype.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
#include "AudioTools.h"
 
namespace tinymodem {

enum class MorseAlphabet {
  INTERNATIONAL,
  AMERICAN,
};

struct MorseConfig : public audio_tools::AudioInfo {
  MorseConfig() {
    sample_rate = 48000;
    channels = 1;
    bits_per_sample = 16;
  }

  MorseAlphabet alphabet = MorseAlphabet::INTERNATIONAL;
  float wpm = 20.0f;
  float frequency = 700.0f;
  float volume = 1.0f;
  float ramp_ms = 5.0f;
  bool adaptive_speed = true;
  float min_amplitude = 0.01f;
  int rx_timeout_units = 20;
  bool rx_one = false;
  uint8_t channel = 0;
  float rx_noise = 0.0f;

  bool setMode(const char* mode) {
    MorseAlphabet a;
    float speed;
    if (!parseMode(mode, a, speed)) return false;
    alphabet = a;
    if (speed > 0) wpm = speed;
    return true;
  }

  static bool isMode(const char* mode) {
    MorseAlphabet a;
    float speed;
    return parseMode(mode, a, speed);
  }

  float unitTime() const { return 1.2f / wpm; }

  bool isValid() const {
    if (wpm < 1 || wpm > 100) {
      LOGE("Morse: the speed must be 1 - 100 wpm");
      return false;
    }
    if (frequency <= 0 || frequency >= 0.45f * sample_rate) {
      LOGE("Morse: invalid frequency %.1f Hz", (double)frequency);
      return false;
    }
    if (ramp_ms < 0 || rx_timeout_units < 8) {
      LOGE("Morse: invalid ramp_ms or rx_timeout_units");
      return false;
    }
    return true;
  }
 
 protected:
  static bool parseMode(const char* mode, MorseAlphabet& alphabet,
                        float& speed) {
    if (mode == nullptr) return false;
    alphabet = MorseAlphabet::INTERNATIONAL;
    speed = 0;
    const char* rest;
    if (startsWith(mode, "morse")) {
      rest = mode + 5;
    } else if (startsWith(mode, "cw")) {
      rest = mode + 2;
    } else {
      return false;
    }
    if (*rest == '-') rest++;
    if (startsWith(rest, "american")) {
      alphabet = MorseAlphabet::AMERICAN;
      rest += 8;
      if (*rest == '-') rest++;
    } else if (startsWith(rest, "international")) {
      rest += 13;
      if (*rest == '-') rest++;
    }
    if (*rest == 0) return true;
    char* end;
    speed = strtol(rest, &end, 10);
    return end != rest && *end == 0 && speed >= 1 && speed <= 100;
  }
 
  static bool startsWith(const char* str, const char* prefix) {
    while (*prefix) {
      if (tolower(*str++) != *prefix++) return false;
    }
    return true;
  }
};

class MorseCode {
 public:
  struct Timing {
    float dot, dash, long_dash, extra_long_dash;
    float element_gap, inner_gap, letter_gap, word_gap;
  };

  static const Timing& timing(MorseAlphabet alphabet) {
    static const Timing international = {1, 3, 3, 3, 1, 1, 3, 7};
    static const Timing american = {1, 2, 4, 5, 1, 2, 3, 6};
    return alphabet == MorseAlphabet::AMERICAN ? american : international;
  }

  static const char* encode(MorseAlphabet alphabet, char ch) {
    ch = toupper((unsigned char)ch);
    for (const Entry* e = table(alphabet); e->ch; e++)
      if (e->ch == ch) return e->code;
    return nullptr;
  }

  static char decode(MorseAlphabet alphabet, const char* code) {
    for (const Entry* e = table(alphabet); e->ch; e++)
      if (strcmp(e->code, code) == 0) return e->ch;
    return 0;
  }
 
 protected:
  struct Entry {
    char ch;
    const char* code;
  };
 
  static const Entry* table(MorseAlphabet alphabet) {
    // ITU-R M.1677 (and the common '!'); a line break is sent as AA
    static const Entry international[] = {
        {'A', ".-"},      {'B', "-..."},    {'C', "-.-."},    {'D', "-.."},
        {'E', "."},       {'F', "..-."},    {'G', "--."},     {'H', "...."},
        {'I', ".."},      {'J', ".---"},    {'K', "-.-"},     {'L', ".-.."},
        {'M', "--"},      {'N', "-."},      {'O', "---"},     {'P', ".--."},
        {'Q', "--.-"},    {'R', ".-."},     {'S', "..."},     {'T', "-"},
        {'U', "..-"},     {'V', "...-"},    {'W', ".--"},     {'X', "-..-"},
        {'Y', "-.--"},    {'Z', "--.."},    {'0', "-----"},   {'1', ".----"},
        {'2', "..---"},   {'3', "...--"},   {'4', "....-"},   {'5', "....."},
        {'6', "-...."},   {'7', "--..."},   {'8', "---.."},   {'9', "----."},
        {'.', ".-.-.-"},  {',', "--..--"},  {'?', "..--.."},  {'\'', ".----."},
        {'!', "-.-.--"},  {'/', "-..-."},   {'(', "-.--."},   {')', "-.--.-"},
        {'&', ".-..."},   {':', "---..."},  {';', "-.-.-."},  {'=', "-...-"},
        {'+', ".-.-."},   {'-', "-....-"},  {'_', "..--.-"},  {'"', ".-..-."},
        {'$', "...-..-"}, {'@', ".--.-."},  {'\n', ".-.-"},   {0, nullptr}};
    // American (railroad) Morse code
    static const Entry american[] = {
        {'A', ".-"},     {'B', "-..."},   {'C', ".. ."},   {'D', "-.."},
        {'E', "."},      {'F', ".-."},    {'G', "--."},    {'H', "...."},
        {'I', ".."},     {'J', "-.-."},   {'K', "-.-"},    {'L', "_"},
        {'M', "--"},     {'N', "-."},     {'O', ". ."},    {'P', "....."},
        {'Q', "..-."},   {'R', ". .."},   {'S', "..."},    {'T', "-"},
        {'U', "..-"},    {'V', "...-"},   {'W', ".--"},    {'X', ".-.."},
        {'Y', ".. .."},  {'Z', "... ."},  {'0', "="},      {'1', ".--."},
        {'2', "..-.."},  {'3', "...-."},  {'4', "....-"},  {'5', "---"},
        {'6', "......"}, {'7', "--.."},   {'8', "-...."},  {'9', "-..-"},
        {'.', "..--.."}, {',', ".-.-"},   {'?', "-..-."},  {'!', "---."},
        {'&', ". ..."},  {0, nullptr}};
    return alphabet == MorseAlphabet::AMERICAN ? american : international;
  }
};
 
}  // namespace tinymodem