TxProtocol.h

#pragma once
#include <Arduino.h>
 
#include "pulse/codecs/Codec.h"
#include "pulse/tools/RingBuffer.h"
#include "pulse/SignalBase.h"
#include "TransceiverConfig.h"
#include "pulse/TxDriver.h"
#include "pulse/tools/Logger.h"
#include "pulse/tools/Vector.h"
 
namespace pulsewire {
 
class DigitalSignal : public SignalBase {
 public:
  DigitalSignal() = default;
 
  void setTxPin(uint8_t pin) override {
    _pin = pin;
    pinMode(_pin, OUTPUT);
    digitalWrite(_pin, LOW);
  }
 
  void sendBit(bool bit) {
    if (bit) {
      digitalWrite(_pin, HIGH);
    } else {
      digitalWrite(_pin, LOW);
    }
  }
};
 
class ToneSignal : public SignalBase {
 public:
  ToneSignal(uint16_t freq = CARRIER_HZ) : _freq(freq) {}
 
  void setFrequency(uint16_t freq) { _freq = freq; }
  uint16_t getFrequency() const { return _freq; }
 
  void setTxPin(uint8_t pin) {
    _pin = pin;
    pinMode(_pin, OUTPUT);
    noTone(_pin);
  }
 
  void sendBit(bool bit) {
    if (bit) {
      tone(_pin, _freq);
    } else {
      noTone(_pin);
    }
  }
 
 protected:
  uint16_t _freq;
};
 
#if defined(HAS_SET_PMW_FREQUENCY1) || defined(HAS_SET_PMW_FREQUENCY2)
 
class PWMSignal : public SignalBase {
 public:
  PWMSignal(uint32_t freq = CARRIER_HZ, uint8_t duty = 128)
      : _freq(freq), _duty(duty) {}
  void setTxPin(uint8_t pin) {
    _pin = pin;
    pinMode(_pin, OUTPUT);
#if defined(HAS_SET_PMW_FREQUENCY1)
    analogWriteFreq(_freq);
#endif
#if defined(HAS_SET_PMW_FREQUENCY2)
    analogWriteFrequency(_pin, _freq);
#endif
    analogWrite(_pin, 0);  // Start with output LOW
  }
  void sendBit(bool bit) override {
    if (bit) {
      analogWrite(_pin, _duty);  // Enable PWM
    } else {
      analogWrite(_pin, 0);  // Disable PWM (LOW)
    }
  }
 
 protected:
  uint32_t _freq;
  uint8_t _duty;
};
 
#endif
 
class TxProtocol {
 public:
  virtual bool begin(uint16_t bitFrequencyHz, Codec* p_codec, uint8_t pin) = 0;
  virtual void setFrameSize(uint16_t size) = 0;
  virtual void sendPreamble() = 0;
  virtual void sendData(const uint8_t* data, uint8_t len) = 0;
  virtual void sendEnd(bool& _useChecksum, bool isDelayAfterFrame) = 0;
  virtual bool isFrameClosed() const = 0;
};
 
class TxProtocolGeneric : public TxProtocol {
 public:
  TxProtocolGeneric(SignalBase* p_signal) { this->p_signal = p_signal; }
 
  bool begin(uint16_t bitFrequencyHz, Codec* p_codec, uint8_t pin) {
    TRACE();
    _bitFrequencyHz = bitFrequencyHz;
    _bitPeriod = 1000000UL / bitFrequencyHz;  // Bit period in microseconds
    this->_codec = p_codec;
    this->_codec->begin(bitFrequencyHz);
    return true;
  }
 
  void setFrameSize(uint16_t size) {
    TRACE();
    Logger::debug("Setting frame size to %d", size);
    _output_buffer.reserve(size);
  }
 
  void sendPreamble() {
    if (_codec == nullptr) {
      Logger::error("Codec pointer is null");
      _output_buffer.clear();
      return;
    }
    if (p_signal == nullptr) {
      Logger::error("SignalBase pointer is null");
      _output_buffer.clear();
      return;
    }
    if (is_frame_closed) {
      check_sum = 0;  // Reset checksum at the start of a new frame
      _output_buffer.clear();
      _codec->encodePreamble(_output_buffer);
      // for (const auto& spec : _output_buffer) {
      //   p_signal->sendBit(spec.level);
      //   delayUs(spec.pulseUs);
      // }
      is_frame_closed = false;
    }
  }
 
  void sendData(const uint8_t* data, uint8_t len) {
    if (_codec == nullptr) {
      Logger::error("Codec pointer is null");
      _output_buffer.clear();
      return;
    }
    if (p_signal == nullptr) {
      Logger::error("SignalBase pointer is null");
      _output_buffer.clear();
      return;
    }
    for (uint8_t i = 0; i < len; i++) {
      check_sum += data[i];
      _codec->encode(data[i], _output_buffer);
    }
    for (const auto& spec : _output_buffer) {
      p_signal->sendBit(spec.level);
      delayUs(spec.pulseUs);
    }
  }
 
  void sendEnd(bool& _useChecksum, bool isDelayAfterFrame) {
    if (_codec == nullptr) {
      Logger::error("Codec pointer is null");
      _output_buffer.clear();
      return;
    }
    if (p_signal == nullptr) {
      Logger::error("SignalBase pointer is null");
      _output_buffer.clear();
      return;
    }
    if (!is_frame_closed) {
      // print checksum
      if (_useChecksum) {
        _output_buffer.clear();
        _codec->encode(check_sum, _output_buffer);
        for (const auto& spec : _output_buffer) {
          p_signal->sendBit(spec.level);
          delayUs(spec.pulseUs);
        }
      }
      check_sum = 0;
 
      // Add a final delay to ensure we can recoginse the end of frame
      if (isDelayAfterFrame) {
        // Ensure signal is in idle state
        p_signal->sendBit(_codec->getIdleLevel());  
        uint32_t period =_codec->getEndOfFrameDelayUs();
        delayUs(period);
      }
      is_frame_closed = true;
    }
  }
 
  bool isFrameClosed() const { return is_frame_closed; }
 
 protected:
  uint8_t check_sum = 0;           
  bool is_frame_closed = true;     
  SignalBase* p_signal = nullptr;  
  Vector<OutputEdge>
      _output_buffer;       
  Codec* _codec = nullptr;  
  uint16_t _bitFrequencyHz = 0;
  uint16_t _bitPeriod = 0;
 
  inline void delayUs(uint32_t us) {
#if USE_RAW_DELAY
    delayMicroseconds(us);
#else
    uint32_t ms = us / 1000;
    uint32_t microSeconds = micros();
    delay(ms);
    int32_t elapsedUs = micros() - microSeconds;
    uint32_t remainingUs = (elapsedUs < us) ? (us - elapsedUs) : 0;
    if (remainingUs > 0) delayMicroseconds(remainingUs);
#endif
  }
};  // end of TxDriverArduino
 
}  // end of namespace pulsewire