ModemConfig.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 DataFormat {
  ASCII,       
  BAUDOT,      
  BINARY,      
  CALLERID,    
  UIC_TRAIN,   
  UIC_GROUND,  
};

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

  float baud_rate = 1200.0f;
  float mark_freq = 0.0f;
  float space_freq = 0.0f;
  float bandwidth = 0.0f;
  int data_bits = 0;
  int start_bits = -1;
  float stop_bits = -1.0f;
  bool invert_start_stop = false;
  bool inverted = false;
  bool msb_first = false;
  bool rx_sync = false;
  int tx_sync_bytes = 0;
  long long sync_byte = -1;
  float confidence = 1.5f;
  float search_limit = 2.3f;
  bool auto_carrier = false;
  float auto_carrier_threshold = 0.001f;
  float volume = 1.0f;
  int leader_bits = 2;
  int trailer_bits = 2;
  bool rx_one = false;
  bool binary_output = false;
  int binary_raw_bits = 0;
  bool baudot_usos = true;
  bool print_filter = false;
  DataFormat format = DataFormat::ASCII;
  const char* expect_bits = nullptr;
  uint8_t channel = 0;
  float rx_noise = 0.0f;
  int buffer_divisor = 12;
  int autodetect_shift = 0;

  bool setMode(const char* mode, bool keep_options = false) {
    if (mode == nullptr) return false;
    if (!keep_options) resetMode();
    is_resolved = false;
    if (equalsIgnoreCase(mode, "rtty")) {
      format = DataFormat::BAUDOT;
      baud_rate = 45.45f;
      if (data_bits == 0) data_bits = 5;
      if (stop_bits < 0) stop_bits = 1.5f;
    } else if (equalsIgnoreCase(mode, "tdd")) {
      format = DataFormat::BAUDOT;
      baud_rate = 45.45f;
      if (data_bits == 0) data_bits = 5;
      if (stop_bits < 0) stop_bits = 2.0f;
      mark_freq = 1400;
      space_freq = 1800;
    } else if (equalsIgnoreCase(mode, "same")) {
      // http://www.nws.noaa.gov/nwr/nwrsame.htm
      baud_rate = 520.0f + 5 / 6.0f;
      data_bits = 8;
      start_bits = 0;
      stop_bits = 0;
      rx_sync = true;
      tx_sync_bytes = 16;
      sync_byte = 0xAB;
      mark_freq = 2083.0f + 1 / 3.0f;
      space_freq = 1562.5f;
      bandwidth = baud_rate;
    } else if (startsWithIgnoreCase(mode, "caller")) {
      format = DataFormat::CALLERID;
      baud_rate = 1200;
      data_bits = 8;
    } else if (startsWithIgnoreCase(mode, "uic")) {
      format = strlen(mode) > 4 && tolower(mode[4]) == 't'
                   ? DataFormat::UIC_TRAIN
                   : DataFormat::UIC_GROUND;
      baud_rate = 600;
      data_bits = 39;
      mark_freq = 1300;
      space_freq = 1700;
      start_bits = 8;
      stop_bits = 0;
      expect_bits = "11110010ddddddddddddddddddddddddddddddddddddddd";
    } else if (startsWithIgnoreCase(mode, "V.21")) {
      baud_rate = 300;
      mark_freq = 980;
      space_freq = 1180;
      data_bits = 8;
    } else {
      baud_rate = atof(mode);
      if (data_bits == 0) data_bits = 8;
    }
    return baud_rate > 0.0f;
  }

  bool isTxSupported() const {
    return format == DataFormat::ASCII || format == DataFormat::BAUDOT;
  }

  bool resolve() {
    if (is_resolved) return true;
    if (baud_rate <= 0.0f) return false;
    if (data_bits == 0) data_bits = 8;
 
    if (binary_output || binary_raw_bits) format = DataFormat::BINARY;
    if (binary_raw_bits) {
      start_bits = 0;
      stop_bits = 0;
      data_bits = binary_raw_bits;
    }
 
    if (baud_rate >= 400) {
      // Bell 202: baud=1200 mark=1200 space=2200
      autodetect_shift = -(baud_rate * 5 / 6);
      if (mark_freq == 0) mark_freq = baud_rate / 2 + 600;
      if (space_freq == 0) space_freq = mark_freq - autodetect_shift;
      if (bandwidth == 0) bandwidth = 200;
    } else if (baud_rate >= 100) {
      // Bell 103: baud=300 mark=1270 space=1070
      autodetect_shift = 200;
      if (mark_freq == 0) mark_freq = 1270;
      if (space_freq == 0) space_freq = mark_freq - autodetect_shift;
      if (bandwidth == 0) bandwidth = 50;
    } else {
      // RTTY: baud=45.45 mark/space=variable shift=-170
      autodetect_shift = 170;
      if (mark_freq == 0) mark_freq = 1585;
      if (space_freq == 0) space_freq = mark_freq - autodetect_shift;
      if (bandwidth == 0) bandwidth = 10;
    }
 
    // defaults: 1 start bit, 1 stop bit
    if (start_bits < 0) start_bits = 1;
    if (stop_bits < 0) stop_bits = 1.0f;
 
    if (frameBits() > 64) return false;
    if (start_bits > 20) return false;
 
    // do not transmit any leader tone if no start bits
    if (start_bits == 0) leader_bits = 0;
 
    if (inverted) {
      float t = mark_freq;
      mark_freq = space_freq;
      space_freq = t;
    }
 
    // restrict bandwidth to <= data rate
    if (bandwidth > baud_rate) bandwidth = baud_rate;
 
    // sanitize confidence search limit
    if (search_limit < confidence) search_limit = confidence;
 
    is_resolved = true;
    return true;
  }

  unsigned frameBits() const {
    return data_bits + start_bits + stop_bits;
  }

  bool isResolved() const { return is_resolved; }
 
 protected:
  bool is_resolved = false;
 
  void resetMode() {
    baud_rate = 1200.0f;
    mark_freq = 0.0f;
    space_freq = 0.0f;
    bandwidth = 0.0f;
    data_bits = 0;
    start_bits = -1;
    stop_bits = -1.0f;
    rx_sync = false;
    tx_sync_bytes = 0;
    sync_byte = -1;
    format = DataFormat::ASCII;
    expect_bits = nullptr;
    autodetect_shift = 0;
  }
 
  static bool equalsIgnoreCase(const char* a, const char* b) {
    while (*a && *b) {
      if (tolower(*a++) != tolower(*b++)) return false;
    }
    return *a == *b;
  }
 
  static bool startsWithIgnoreCase(const char* str, const char* prefix) {
    while (*prefix) {
      if (tolower(*str++) != tolower(*prefix++)) return false;
    }
    return true;
  }
};
 
}  // namespace tinymodem