ModemStream.h

Go to the documentation of this file.

#pragma once
 
#include <string.h>
 
#include "AudioTools.h"
#include "AX25Decoder.h"
#include "AX25Encoder.h"
#include "CSSDecoder.h"
#include "CSSEncoder.h"
#include "DTMFDecoder.h"
#include "DTMFEncoder.h"
#include "FSKDecoder.h"
#include "FSKEncoder.h"
#include "GGWaveDecoder.h"
#include "GGWaveEncoder.h"
#include "MFSKDecoder.h"
#include "MFSKEncoder.h"
#include "MorseDecoder.h"
#include "MorseEncoder.h"
#include "PSKDecoder.h"
#include "PSKEncoder.h"
#include "OFDMDecoder.h"
#include "OFDMEncoder.h"
#include "OliviaDecoder.h"
#include "OliviaEncoder.h"
#include "ModemBase.h"
#include "ModemConfig.h"
 
namespace tinymodem {

template <class Encoder, class Decoder, class Config>
class BasicModemStream : public Stream {
 public:
  using ConfigType = Config;
 
  BasicModemStream() = default;
  BasicModemStream(Print& audio_out) { setOutput(audio_out); }
  BasicModemStream(Print& audio_out, Stream& audio_in) {
    setOutput(audio_out);
    setInput(audio_in);
  }

  BasicModemStream(Stream& audio, audio_tools::RxTxMode mode) {
    if (mode & audio_tools::TX_MODE) setOutput(audio);
    if (mode & audio_tools::RX_MODE) setInput(audio);
  }

  void setOutput(Print& audio_out) { p_audio_out = &audio_out; }
  void setInput(Stream& audio_in) { p_audio_in = &audio_in; }
  void setStatusOutput(Print& out) { decoder.setStatusOutput(out); }
 
  Config defaultConfig() { return encoder.defaultConfig(); }

  bool begin(Config cfg, int rx_buffer_size = 256) {
    bool ok = true;
    if (p_audio_out != nullptr) {
      encoder.setOutput(*p_audio_out);
      ok = encoder.begin(cfg) && ok;
    }
    if (p_audio_in != nullptr) {
      rx_limit = rx_buffer_size;
      rx_queue.clear();
      decoder.setOutput(rx_queue);
      ok = decoder.begin(cfg) && ok;
    }
    return ok;
  }
 
  void end() {
    encoder.end();
    decoder.end();
  }
 
  size_t write(uint8_t ch) override { return encoder.write(&ch, 1); }
 
  size_t write(const uint8_t* data, size_t len) override {
    return encoder.write(data, len);
  }

  void flush() override { encoder.endTransmission(); }
 
  int available() override {
    update();
    return rx_queue.available();
  }
 
  int read() override {
    update();
    return rx_queue.read();
  }
 
  int peek() override {
    update();
    return rx_queue.peek();
  }

  size_t readBytes(uint8_t* data, size_t len) {
    size_t n = 0;
    while (n < len) {
      int ch = read();
      if (ch < 0) break;
      data[n++] = ch;
    }
    return n;
  }
 
  size_t readBytes(char* data, size_t len) {
    return readBytes((uint8_t*)data, len);
  }

  size_t update() {
    if (p_audio_in == nullptr || !decoder) return 0;
    // stop reading the input while the received data is not consumed
    if (rx_queue.available() >= rx_limit) return 0;
    return readInput();
  }

  bool isCarrier() { return decoder.isCarrier(); }
 
  Encoder& getEncoder() { return encoder; }
  Decoder& getDecoder() { return decoder; }
 
 protected:
  using ReceiveQueue = ByteQueue;
 
  Print* p_audio_out = nullptr;
  Stream* p_audio_in = nullptr;
  Encoder encoder;
  Decoder decoder;
  ReceiveQueue rx_queue;
  int rx_limit = 256;
  uint8_t copy_buffer[256];

  size_t readInput() {
    int len = p_audio_in->available();
    if (len <= 0) return 0;
    if (len > (int)sizeof(copy_buffer)) len = sizeof(copy_buffer);
    len = p_audio_in->readBytes(copy_buffer, len);
    if (len <= 0) return 0;
    return decoder.write(copy_buffer, len);
  }
};

class ModemStream : public BasicModemStream<FSKEncoder, FSKDecoder, ModemConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class MFSKStream : public BasicModemStream<MFSKEncoder, MFSKDecoder, MFSKConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class AX25Stream : public BasicModemStream<AX25Encoder, AX25Decoder, AX25Config> {
 public:
  using BasicModemStream::BasicModemStream;
};

class PSKStream : public BasicModemStream<PSKEncoder, PSKDecoder, PSKConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class OFDMStream : public BasicModemStream<OFDMEncoder, OFDMDecoder, OFDMConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class GGWaveStream
    : public BasicModemStream<GGWaveEncoder, GGWaveDecoder, GGWaveConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class OliviaStream
    : public BasicModemStream<OliviaEncoder, OliviaDecoder, OliviaConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class CSSStream : public BasicModemStream<CSSEncoder, CSSDecoder, CSSConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class MorseStream
    : public BasicModemStream<MorseEncoder, MorseDecoder, MorseConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};

class DTMFStream : public BasicModemStream<DTMFEncoder, DTMFDecoder, DTMFConfig> {
 public:
  using BasicModemStream::BasicModemStream;
};
 
}  // namespace tinymodem