Transceiver.h

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "Stream.h"
#include "TransceiverConfig.h"
#include "pulse/tools/Logger.h"
#include "pulse/tools/RingBuffer.h"
#include "pulse/RxDriver.h"
#include "pulse/TxDriver.h"
 
namespace pulsewire {
 
class Transceiver : public Stream {
 public:
  Transceiver() = default;
 
  Transceiver(RxDriver& rx, TxDriver& tx) : _rxDriver(&rx), _txDriver(&tx) {}
 
  Transceiver(RxDriver& rx) : _rxDriver(&rx) {}
 
  Transceiver(TxDriver& tx) : _txDriver(&tx) {}
 
  Transceiver(RxDriver& rx, TxDriver& tx, FramingMode mode, size_t frameSize)
      : _rxDriver(&rx), _txDriver(&tx) {
    setFrameSize(frameSize);
    setFramingMode(mode);
  }
 
  Transceiver(RxDriver& rx, FramingMode mode, size_t frameSize)
      : _rxDriver(&rx) {
    setFrameSize(frameSize);
    setFramingMode(mode);
  }
 
  Transceiver(TxDriver& tx, FramingMode mode, size_t frameSize)
      : _txDriver(&tx) {
    setFrameSize(frameSize);
    setFramingMode(mode);
  }
 
  void setRxDriver(RxDriver* driver) { _rxDriver = driver; }
 
  void setTxDriver(TxDriver* driver) { _txDriver = driver; }
 
  void setFrameSize(uint16_t size) {
    Logger::debug("Setting frame size to %d", size);
    _frameSize = size;
    _singleCharRxBuffer.resize(size);
    if (_rxDriver) {
      _rxDriver->setFrameSize(size);
    }
    if (_txDriver) {
      _txDriver->setFrameSize(size);
    }
  }
 
  bool setFramingMode(FramingMode mode) {
    if (_txDriver) {
      _txDriver->setFramingMode(mode);
      return true;
    }
    return false;
  }
 
  void setTimeout(uint32_t timeoutUs) {
    if (_rxDriver) {
      _rxDriver->setTimeout(timeoutUs);
    }
  }
 
  bool begin(uint32_t bitFrequencyHz = DEFAULT_BIT_FREQ_HZ) {
    TRACE();
    bool success = true;
    // intialize frame size if not set
    if (_frameSize == 0) setFrameSize(DEFAULT_FRAME_SIZE);
 
    if (_rxDriver) {
      success = _rxDriver->begin(bitFrequencyHz);
      if (!success) {
        Logger::error("Failed to initialize RX driver");
      }
    }
    if (_txDriver) {
      success = _txDriver->begin(bitFrequencyHz);
      if (!success) {
        Logger::error("Failed to initialize TX driver");
      }
    }
    return success;
    ;
  }
 
  void end() {
    if (_txDriver) _txDriver->end();
    if (_rxDriver) _rxDriver->end();
  }
 
 
  size_t write(uint8_t byte) override { return _txDriver->write(byte); }
 
  size_t write(const uint8_t* buffer, size_t size) override {
    if (_txDriver) {
      return _txDriver->write(buffer, size);
    }
    return 0;
  }
  void flush() override {
    if (_txDriver) {
      _txDriver->flush();
    }
  }
 
  int availableForWrite() override { return 1024; }
 
  int available() override {
    return _singleCharRxBuffer.available() + _rxDriver->available();
  }
 
  int read() override {
    refillSingleCharBuffer();
    return _singleCharRxBuffer.read();
  }
 
  virtual size_t readBytes(uint8_t* buffer, size_t length) {
    int c1 = _singleCharRxBuffer.readArray(buffer, length);
    int open = length - c1;
    int c2 = 0;
    if (open > 0) {
      c2 = _rxDriver->readBytes((uint8_t*)buffer + c1, open);
    }
    return c1 + c2;
  }
 
  int peek() override {
    refillSingleCharBuffer();
    return _singleCharRxBuffer.peek();
  }
 
 protected:
  RxDriver* _rxDriver = nullptr;
  TxDriver* _txDriver = nullptr;
  RingBuffer<uint8_t> _singleCharRxBuffer{64};
  int _frameSize = 0;
 
  void refillSingleCharBuffer() {
    if (_singleCharRxBuffer.isEmpty() && _rxDriver) {
      int len = _singleCharRxBuffer.size();
      uint8_t tmp[len];
      int read = _rxDriver->readBytes(tmp, len);
      _singleCharRxBuffer.writeArray(tmp, read);
    }
  }
};
 
class Trasmitter : public Transceiver {
 public:
  Trasmitter(TxDriver& tx) : Transceiver(tx) {}
};
 
class Receiver : public Transceiver {
 public:
  Receiver(RxDriver& rx) : Transceiver(rx) {}
};
 
}  // namespace pulsewire