VWI.hh

Go to the documentation of this file.

#ifndef COSA_VWI_HH
#define COSA_VWI_HH

#include "Cosa/InputPin.hh"
#include "Cosa/OutputPin.hh"
#include "Cosa/Wireless.hh"

class VWI : public Wireless::Driver {
public:
  class Codec {
  public:
    const uint8_t BITS_PER_SYMBOL;

    const uint16_t START_SYMBOL;

    const uint8_t PREAMBLE_MAX;

    const uint8_t SYMBOL_MASK;

    const uint16_t BITS_MSB;

    Codec(uint8_t bits_per_symbol,
          uint16_t start_symbol,
          uint8_t preamble_max = VWI::Transmitter::PREAMBLE_MAX);

    virtual const uint8_t* preamble() = 0;

    virtual uint8_t encode4(uint8_t nibble) = 0;

    virtual uint8_t decode4(uint8_t symbol) = 0;

    virtual uint8_t decode8(uint16_t symbol)
    {
      return ((decode4(symbol) << 4) | (decode4(symbol >> BITS_PER_SYMBOL)));
    }
  };

protected:
  struct header_t {
    int16_t network;            
    uint8_t dest;               
    uint8_t src;                
    uint8_t port;               
  };

public:
  static const uint8_t PAYLOAD_MAX = 30 + sizeof(header_t);

protected:
  static const uint8_t MESSAGE_MAX = PAYLOAD_MAX + 3;

  static const uint8_t MESSAGE_MIN = sizeof(header_t);

  static const uint8_t SAMPLES_PER_BIT = 8;

public:
  class Receiver : private InputPin {
  public:
    Receiver(Board::DigitalPin pin, Codec* codec) :
      InputPin(pin),
      m_codec(codec)
    {
    }

    void begin()
    {
      m_enabled = true;
      m_active = false;
    }

    void end()
    {
      m_enabled = false;
    }

    bool available() const
    {
      return (m_done);
    }

    int recv(uint8_t& src, uint8_t& port, void* buf, size_t len,
             uint32_t ms = 0L);

    int link_quality_indicator();

  private:
    static const uint8_t RAMP_MAX = 160;

    static const uint8_t INTEGRATOR_THRESHOLD = 5;

    static const uint8_t RAMP_INC = RAMP_MAX / SAMPLES_PER_BIT;

    static const uint8_t RAMP_TRANSITION = RAMP_MAX / 2;

    static const uint8_t RAMP_ADJUST = 9;

    static const uint8_t RAMP_INC_RETARD = (RAMP_INC - RAMP_ADJUST);

    static const uint8_t RAMP_INC_ADVANCE = (RAMP_INC + RAMP_ADJUST);

    Codec* m_codec;

    uint8_t m_sample;

    uint8_t m_last_sample;

    uint8_t m_pll_ramp;

    uint8_t m_integrator;

    uint8_t m_active;

    volatile bool m_done;

    uint8_t m_enabled;

    uint16_t m_bits;

    uint8_t m_bit_count;

    uint8_t m_buffer[MESSAGE_MAX];

    uint8_t m_count;

    volatile uint8_t m_length;

    void PLL();

    friend void TIMER1_COMPA_vect(void);
  };

  class Transmitter : private OutputPin {
  public:
    Transmitter(Board::DigitalPin pin, Codec* codec) :
      OutputPin(pin),
      m_codec(codec)
    {
      memcpy_P(m_buffer, codec->preamble(), codec->PREAMBLE_MAX);
    }

    void begin()
    {
      TIMSK1 |= _BV(OCIE1A);
      m_index = 0;
      m_bit = 0;
      m_sample = 0;
      m_enabled = true;
    }

    void end()
    {
      clear();
      m_enabled = false;
    }

    bool is_active() const
    {
      return (m_enabled);
    }

    int send(uint8_t dest, uint8_t port, const iovec_t* vec);

    int send(uint8_t dest, uint8_t port, const void* buf, size_t len);

  private:
    static const uint8_t PREAMBLE_MAX = 8;

    uint8_t m_buffer[(MESSAGE_MAX * 2) + PREAMBLE_MAX];

    Codec* m_codec;

    uint8_t m_length;

    uint8_t m_index;

    uint8_t m_bit;

    uint8_t m_sample;

    volatile uint8_t m_enabled;

    friend void TIMER1_COMPA_vect(void);

    friend class Codec;
  };

  VWI(int16_t net, uint8_t dev, uint16_t speed, Receiver* rx) :
    Wireless::Driver(net, dev),
    m_rx(rx),
    m_tx(NULL),
    m_speed(speed)
  {
    s_rf = this;
  }

  VWI(int16_t net, uint8_t dev, uint16_t speed, Transmitter* tx) :
    Wireless::Driver(net, dev),
    m_rx(NULL),
    m_tx(tx),
    m_speed(speed)
  {
    s_rf = this;
  }

  VWI(int16_t net, uint8_t dev,
      uint16_t speed,
      Receiver* rx,
      Transmitter* tx) :
    Wireless::Driver(net, dev),
    m_rx(rx),
    m_tx(tx),
    m_speed(speed)
  {
    s_rf = this;
  }

  virtual bool begin(const void* config = NULL);

  virtual bool end();

  virtual void powerup();

  virtual void powerdown();

  virtual bool available()
  {
    if (m_rx == NULL) return (false);
    return (m_rx->available());
  }

  virtual int send(uint8_t dest, uint8_t port, const iovec_t* vec)
  {
    if (m_tx == NULL) return (-1);
    return (m_tx->send(dest, port, vec));
  }

  virtual int send(uint8_t dest, uint8_t port, const void* buf, size_t len)
  {
    if (m_tx == NULL) return (-1);
    return (m_tx->send(dest, port, buf, len));
  }

  virtual int recv(uint8_t& src, uint8_t& port,
                   void* buf, size_t len,
                   uint32_t ms = 0L)
  {
    if (m_rx == NULL) return (-1);
    return (m_rx->recv(src, port, buf, len, ms));
  }

  virtual int link_quality_indicator()
  {
    if (m_rx == NULL) return (0);
    return (m_rx->link_quality_indicator());
  }

private:
  static VWI* s_rf;

  Receiver* m_rx;

  Transmitter* m_tx;

  uint16_t m_speed;

  friend void TIMER1_COMPA_vect(void);
};
#endif