fsk.hh

#ifndef __SDR_FSK_HH__
#define __SDR_FSK_HH__

#include "node.hh"
#include "traits.hh"
#include "logger.hh"


namespace sdr {


class FSKDetector: public Sink<int16_t>, public Source
{
public:
  FSKDetector(float baud, float Fmark, float Fspace);

  void config(const Config &src_cfg);
  void process(const Buffer<int16_t> &buffer, bool allow_overwrite);

protected:
  uint8_t _process(int16_t sample);

protected:
  float _baud;
  size_t  _corrLen;
  size_t _lutIdx;
  float _Fmark;
  float _Fspace;
  Buffer< std::complex<float> > _markLUT;
  Buffer< std::complex<float> > _spaceLUT;
  Buffer< std::complex<float> > _markHist;
  Buffer< std::complex<float> > _spaceHist;
  Buffer<int8_t> _buffer;
};


template <class Scalar>
class ASKDetector: public Sink<Scalar>, public Source
{
public:
  ASKDetector(bool invert=false)
    : Sink<Scalar>(), Source(), _invert(invert)
  {
    // pass...
  }

  void config(const Config &src_cfg) {
    // Check if config is complete
    if (!src_cfg.hasType() || !src_cfg.hasSampleRate()) { return; }

    // Check if buffer type matches
    if (Config::typeId<int16_t>() != src_cfg.type()) {
      ConfigError err;
      err << "Can not configure ASKDetector: Invalid type " << src_cfg.type()
          << ", expected " << Config::typeId<int16_t>();
      throw err;
    }

    // Allocate output buffer
    _buffer = Buffer<uint8_t>(src_cfg.bufferSize());

    LogMessage msg(LOG_DEBUG);
    msg << "Config ASKDetector node: " << std::endl
        << " threshold:   " << 0 << std::endl
        << " invert:      " << ( _invert ? "yes" : "no" ) << std::endl
        << " symbol rate: " << src_cfg.sampleRate() << " Hz";
    Logger::get().log(msg);

    // Forward config.
    this->setConfig(Config(Traits<uint8_t>::scalarId, src_cfg.sampleRate(), _buffer.size(), 1));
  }

  void process(const Buffer<Scalar> &buffer, bool allow_overwrite) {
    for (size_t i=0; i<buffer.size(); i++) {
      _buffer[i] = ((buffer[i]>0)^_invert);
    }
    this->send(_buffer.head(buffer.size()), false);
  }

protected:
  bool _invert;
  Buffer<uint8_t> _buffer;
};


class BitStream: public Sink<uint8_t>, public Source
{
public:
  typedef enum {
    NORMAL,      
    TRANSITION   
  } Mode;

public:
  BitStream(float baud, Mode mode = TRANSITION);

  void config(const Config &src_cfg);
  void process(const Buffer<uint8_t> &buffer, bool allow_overwrite);

protected:
  float _baud;
  Mode  _mode;
  size_t _corrLen;
  Buffer<int8_t> _symbols;
  size_t _symIdx;
  int32_t _symSum;
  int32_t _lastSymSum;
  float _phase;
  float _omega;
  float _omegaMin;
  float _omegaMax;
  float _pllGain;
  uint8_t _lastBits;
  Buffer<uint8_t> _buffer;
};


class BitDump : public Sink<uint8_t>
{
public:
  BitDump(std::ostream &stream);

  void config(const Config &src_cfg);
  void process(const Buffer<uint8_t> &buffer, bool allow_overwrite);

protected:
  std::ostream &_stream;
};

}
#endif // __SDR_FSK_HH__