rungler.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/detail/modular_sequencing_common.hpp>
#include <pulp/signal/lfsr.hpp>
 
#include <algorithm>
#include <cstdint>
 
namespace pulp::signal {
 
// ── Rungler ───────────────────────────────────────────────────────────────

template <typename SampleType = float>
class RunglerT {
public:
    static constexpr int kMinBits = 4;
    static constexpr int kMaxBits = 16;
    static constexpr int kDefaultBits = 8;

    static constexpr int kMinDacBits = 1;
    static constexpr int kMaxDacBits = 4;
    static constexpr int kDefaultDacBits = 3;

    static constexpr std::uint32_t kSeedPattern = 0b10110100u;

    static constexpr int kFeedbackTap = 0;

    static constexpr double kRangeV = 2.0;

    static constexpr double kMaxRangeV = 1000.0;
 
    RunglerT() { load_seed(); }
 
    void prepare(double sample_rate) {
        sample_rate_ = sample_rate > 0.0 ? sample_rate : sample_rate_;
    }

    void set_reg_bits(int n) {
        bits_ = std::clamp(n, kMinBits, kMaxBits);
        clamp_config();
        load_seed();
    }
    int reg_bits() const { return bits_; }
 
    void set_dac_bits(int d) {
        dac_bits_ = std::clamp(d, kMinDacBits, kMaxDacBits);
        clamp_config();
        refresh_output();
    }
    int dac_bits() const { return dac_bits_; }
 
    void set_feedback_tap(int tap) {
        tap_ = tap;
        clamp_config();
        (void)register_.set_feedback_mask(feedback_mask());
    }
    int feedback_tap() const { return tap_; }
 
    void set_range_v(double volts) {
        range_v_ = seq_detail::clamp_finite(volts, 0.0, kMaxRangeV);
        refresh_output();
    }
    double range_v() const { return range_v_; }
 
    void set_external_data(bool on) { external_data_ = on; }
    bool external_data() const { return external_data_; }
 
    void set_seed_pattern(std::uint32_t pattern) {
        seed_pattern_ = pattern;
        load_seed();
    }
    std::uint32_t seed_pattern() const { return seed_pattern_; }

    void apply_reset_edge() { load_seed(); }
 
    void reset() { load_seed(); }
 
    static constexpr int latency_samples() { return 0; }

    std::uint32_t register_bits() const { return register_.state(); }
    int dac_code() const { return static_cast<int>(register_.state() & dac_mask()); }
    SampleType value() const { return out_; }

    SampleType process(bool run_high, bool reset_edge, bool clock_edge, bool data_in = false) {
        if (reset_edge) apply_reset_edge();
        if (!run_high) return out_;
        if (!clock_edge) return out_;
 
        register_.clock(external_data_ && data_in);
        refresh_output();
        return out_;
    }
 
private:
    std::uint32_t dac_mask() const { return (1u << dac_bits_) - 1u; }
 
    std::uint32_t feedback_mask() const {
        return (std::uint32_t{1} << (bits_ - 1)) | (std::uint32_t{1} << tap_);
    }
 
    void clamp_config() {
        if (dac_bits_ > bits_) dac_bits_ = bits_;
        tap_ = std::clamp(tap_, 0, std::max(bits_ - 2, 0));
    }
 
    void load_seed() {
        clamp_config();
        (void)register_.configure(bits_, feedback_mask(), seed_pattern_);
        refresh_output();
    }
 
    void refresh_output() {
        const double levels = static_cast<double>(dac_mask());
        const double k = static_cast<double>(register_.state() & dac_mask());
        const double unit = levels > 0.0 ? (2.0 * k / levels - 1.0) : 0.0;
        out_ = static_cast<SampleType>(range_v_ * unit);
    }
 
    double sample_rate_ = 44100.0;
    int bits_ = kDefaultBits;
    int dac_bits_ = kDefaultDacBits;
    int tap_ = kFeedbackTap;
    double range_v_ = kRangeV;
    bool external_data_ = false;
    std::uint32_t seed_pattern_ = kSeedPattern;
 
    LfsrT<SampleType> register_{};
    SampleType out_ = SampleType{0};
};
 
using Rungler = RunglerT<float>;
using Rungler64 = RunglerT<double>;
 
}  // namespace pulp::signal