TxDriverCommon.h

#pragma once
#include <Arduino.h>
 
#include "TransceiverConfig.h"
#include "pulse/TxDriver.h"
#include "pulse/TxProtocol.h"
#include "pulse/codecs/Codec.h"
#include "pulse/tools/Logger.h"
#include "pulse/tools/RingBuffer.h"
#include "pulse/tools/Vector.h"
 
namespace pulsewire {
 
class TxDriverCommon : public TxDriver {
 public:
  TxDriverCommon() = default;
  TxDriverCommon(TxProtocol& protocol, Codec& codec, uint8_t pin,
 
                 bool useChecksum = false) {
    init(protocol, codec, pin, useChecksum);
  }
 
  virtual void init(TxProtocol& protocol, Codec& codec, uint8_t pin,
 
                    bool useChecksum = false) {
    TRACE();
    _codec = &codec;
    _protocol = &protocol;
    _useChecksum = useChecksum;
    _pin = pin;
  }
 
  bool begin(uint32_t bitFrequencyHz) override {
    // make sure that frame size is set before beginning
    TRACE();
    _bitFrequencyHz = bitFrequencyHz;
    setFrameSize(_frameSize);
    _protocol->begin(bitFrequencyHz, _codec, _pin);
    return _codec->begin(bitFrequencyHz);
  }
 
  void setFrameSize(uint16_t size) {
    TRACE();
    Logger::debug("Setting frame size to %d", size);
    _frameSize = size;
    _byteBuffer.resize(size);
    _protocol->setFrameSize(size);
  }
 
  void setFramingMode(FramingMode mode) override { _framingMode = mode; }
 
  int write(uint8_t byte) override {
    if (_byteBuffer.size() == 0) {
      return 0;  // No buffer space allocated
    }
    _byteBuffer.write(byte);
    if (_byteBuffer.isFull()) {
      // Handle full buffer (e.g., send frame)
      uint8_t frameData[_frameSize];
      for (int j = 0; j < _frameSize; j++) {
        frameData[j] = _byteBuffer.read();
      }
      sendData(frameData, _frameSize);
      sendEnd();
    }
    return 1;
  }
 
  size_t write(const uint8_t* data, size_t len) {
    switch (_framingMode) {
      case FramingMode::FixedSize:
        for (size_t i = 0; i < len; i++) {
          _byteBuffer.write(data[i]);
          if (_byteBuffer.isFull()) {
            // Handle full buffer (e.g., send frame)
            uint8_t frameData[_frameSize];
            for (int j = 0; j < _frameSize; j++) {
              frameData[j] = _byteBuffer.read();
            }
            sendData(data, len);
            sendEnd();
          }
        }
        break;
      case FramingMode::WriteBytes:
        sendPreamble();
        sendData(data, len);
        sendEnd();
        break;
      case FramingMode::Flush:
        if (_protocol->isFrameClosed()) {
          sendPreamble();
        }
        sendData(data, len);
        break;
    }
    return len;
  }
 
  void flush() override {
    if (_byteBuffer.available() > 0) {
      uint8_t frameData[_frameSize]{};
      _byteBuffer.readArray(frameData, _frameSize);
      sendData(frameData, _frameSize);
    }
    sendEnd();
  }
 
 protected:
  Codec* _codec = nullptr;
  TxProtocol* _protocol = nullptr;
  RingBuffer<uint8_t> _byteBuffer;
  uint16_t _frameSize = DEFAULT_FRAME_SIZE;
  FramingMode _framingMode = FramingMode::WriteBytes;
  uint16_t _bitFrequencyHz = DEFAULT_BIT_FREQ_HZ;
  bool _useChecksum = false;
  uint8_t check_sum = 0;
  uint8_t _pin = -1;
 
  void sendPreamble() {
    assert(_protocol != nullptr);
    _protocol->sendPreamble();
  }
 
  void sendData(const uint8_t* data, uint8_t len) {
    assert(_protocol != nullptr);
    _protocol->sendData(data, len);
  }
 
  void sendEnd() {
    assert(_protocol != nullptr);
    bool isDelayAfterFrame = (_framingMode != FramingMode::FixedSize);
    _protocol->sendEnd(_useChecksum, isDelayAfterFrame);
  }
};  // end of TxDriverArduino
 
}  // end of namespace pulsewire