Preamble.h

#pragma once
#include <stdint.h>
 
#include "TransceiverConfig.h"
#include "pulse/tools/Logger.h"
#include "pulse/tools/Vector.h"
 
namespace pulsewire {
 
struct OutputEdge {
  bool level =
      false;  // Logic level during the pulse (true = HIGH, false = LOW)
  uint32_t pulseUs = 0;  // Duration of the pulse in microseconds
  OutputEdge() = default;
  OutputEdge(bool l, uint32_t p) : level(l), pulseUs(p) {}
};
 
class Preamble {
 public:
  virtual ~Preamble() = default;
 
  virtual bool begin(uint16_t bitFrequencyHz) {
    _history.reserve(preambleLength());
    return true;
  }
 
  void reset() { _history.clear(); }
 
  virtual bool detect(const OutputEdge& edge) {
    Logger::debug("Preamble Detecting edge: level=%s, pulseUs=%d", edge.level ? "HIGH" : "LOW",
                  edge.pulseUs);
    size_t N = preambleLength();
    if (N == 0) return true;
    _history.push_back(edge);
    if (_history.size() > N) _history.erase(_history.begin());
    if (_history.size() < N) {
      Logger::debug("Not enough edges for preamble detection: %d/%d",
                    _history.size(), N);
      return false;
    }
 
    for (size_t i = 0; i < N; ++i) {
      if (_history[i].level != _expected[i].level) {
        Logger::debug("Invalid level idx %d: expected %s, got %s - %d us", i,
                      _expected[i].level ? "HIGH" : "LOW",
                      _history[i].level ? "HIGH" : "LOW   ",
                      _history[i].pulseUs);
        return false;
      }
      // Use 20% tolerance or 50us minimum
      uint32_t tol = 0.2 * _expected[i].pulseUs;
      if (tol < 50) tol = 50;
      if (!inRange(_history[i].pulseUs, _expected[i].pulseUs, tol)) {
        Logger::debug("Invalid pulse duration: expected %d us, got %d us",
                      _expected[i].pulseUs, _history[i].pulseUs);
        return false;
      }
    }
    Logger::debug("Preamble detected");
    _history.clear();
    return true;
  }
 
  virtual int getEdges(
      pulsewire::Vector<pulsewire::OutputEdge>& output) const = 0;
 
  virtual size_t preambleLength() const = 0;
 
  bool inRange(uint32_t value, uint32_t target, uint32_t tolerance) const {
    return (value >= target - tolerance) && (value <= target + tolerance);
  }
 
 protected:
  // Default history buffer for edge detection
  pulsewire::Vector<pulsewire::OutputEdge> _history;
  pulsewire::Vector<pulsewire::OutputEdge> _expected;
};
 
class NoPreamble : public Preamble {
 public:
  bool begin(uint16_t bitFrequencyHz) override { return true; }
  bool detect(const pulsewire::OutputEdge& edge) override { return true; }
  int getEdges(
      pulsewire::Vector<pulsewire::OutputEdge>& output) const override {
    return 0;
  }
  size_t preambleLength() const override { return 0; }
};
class CustomPreambleUs : public Preamble {
 public:
  CustomPreambleUs() = default;
  CustomPreambleUs(const pulsewire::Vector<pulsewire::OutputEdge>& edges) {
    _expected = edges;
  }
  // Uses default detect()
  void setEdges(const pulsewire::Vector<pulsewire::OutputEdge>& edges) {
    _expected = edges;
  }
  void addEdge(const pulsewire::OutputEdge& edge) { _expected.push_back(edge); }
  void addEdge(bool level, uint32_t pulseUs) {
    OutputEdge edge{level, pulseUs};
    _expected.push_back(edge);
  }
  void addEdge(bool level, uint16_t pulseCount, uint32_t frequencyHz) {
    uint32_t pulseUs = (1000000 / frequencyHz) * pulseCount;
    OutputEdge edge{level, pulseUs};
    _expected.push_back(edge);
  }
  void clear() { _expected.clear(); }
  int getEdges(Vector<OutputEdge>& output) const override {
    for (const auto& edge : _expected) {
      output.push_back(edge);
    }
    return _expected.size();
  }
  size_t preambleLength() const override { return _expected.size(); }
};
 
class CustomPreamble : public CustomPreambleUs {
 public:
  CustomPreamble() = default;
  CustomPreamble(const pulsewire::Vector<pulsewire::OutputEdge>& edges) {
    _expected = edges;
  }
  virtual bool begin(uint16_t bitFrequencyHz) {
    bool rc = Preamble::begin(bitFrequencyHz);
    uint32_t us = 1000000 / bitFrequencyHz;
    for (auto& edge : _expected) {
      edge.pulseUs = edge.pulseUs * us;
    }
 
    return rc;
  }
};
 
class ManchesterPreamble : public CustomPreambleUs {
 public:
  ManchesterPreamble(uint8_t runInCycles = 2) : _runInCycles(runInCycles) {}
 
  bool begin(uint16_t bitFrequencyHz) override {
    // double the frequency for Manchester since each bit is two edges
    _history.clear();
    _history.reserve(_runInCycles * 2 + 1);  // run-in edges + start pulse
    _expected.reserve(_runInCycles * 2 + 1);
    _freqHz = bitFrequencyHz * 2;
    _bitPeriod = 1000000 / _freqHz;
 
    // Generate the expected edges for the Manchester preamble
    _expected.clear();
    bool level = true;
    // Run-in: alternating edges for clock recovery
    for (uint8_t i = 0; i < _runInCycles * 2; ++i) {
      addEdge(level, _bitPeriod);
      level = !level;
    }
 
    return true;
  }
 
 private:
  uint8_t _runInCycles = 0;
  uint32_t _freqHz = 0;
  uint32_t _bitPeriod = 0;
};
 
class NRZPreamble : public CustomPreambleUs {
 public:
  NRZPreamble() = default;
 
  bool begin(uint16_t bitFrequencyHz) override {
    _history.clear();
    _history.reserve(4);
    _expected.clear();
    uint32_t bp = 1000000 / bitFrequencyHz;
    addEdge(false, bp);  // LOW
    addEdge(true, bp);   // HIGH
    addEdge(false, bp);  // LOW
    addEdge(true, bp);   // HIGH — ends HIGH, matching NRZ idle
    return true;
  }
};
 
}  // namespace pulsewire