digital.hpp

Go to the documentation of this file.

#pragma once
#include <dsp/common.hpp>
 
 
namespace rack {
namespace dsp {
 

struct BooleanTrigger {
    enum State : uint8_t {
        LOW,
        HIGH,
        UNINITIALIZED
    };
    enum State : uint8_t {…};
    union {
        State s = UNINITIALIZED;
        bool state;
    };
 
    void reset() {
        s = UNINITIALIZED;
    }
    void reset() {…}

    bool process(bool in) {
        bool triggered = (s == LOW) && in;
        s = in ? HIGH : LOW;
        return triggered;
    }
    bool process(bool in) {…}
 
    enum Event {
        NONE = 0,
        TRIGGERED = 1,
        UNTRIGGERED = -1
    };
    enum Event {…};

    Event processEvent(bool in) {
        Event event = NONE;
        if (s == LOW && in) {
            event = TRIGGERED;
        }
        else if (s == HIGH && !in) {
            event = UNTRIGGERED;
        }
        s = in ? HIGH : LOW;
        return event;
    }
    Event processEvent(bool in) {…}
 
    bool isHigh() {
        return s == HIGH;
    }
    bool isHigh() {…}
};
struct BooleanTrigger {…};
 

template <typename T = float>
struct TSchmittTrigger {
    T state;
    TSchmittTrigger() {
        reset();
    }
    TSchmittTrigger() {…}
    void reset() {
        state = T::mask();
    }
    void reset() {…}
    T process(T in, T lowThreshold = 0.f, T highThreshold = 1.f) {
        T on = (in >= highThreshold);
        T off = (in <= lowThreshold);
        T triggered = ~state & on;
        state = on | (state & ~off);
        return triggered;
    }
    T process(T in, T lowThreshold = 0.f, T highThreshold = 1.f) {…}
    T isHigh() {
        return state;
    }
    T isHigh() {…}
};
struct TSchmittTrigger {…};
 
 
template <>
struct TSchmittTrigger<float> {
    enum State : uint8_t {
        LOW,
        HIGH,
        UNINITIALIZED
    };
    enum State : uint8_t {…};
    union {
        State s = UNINITIALIZED;
        bool state;
    };
 
    void reset() {
        s = UNINITIALIZED;
    }
    void reset() {…}

    bool process(float in, float lowThreshold = 0.f, float highThreshold = 1.f) {
        if (s == LOW && in >= highThreshold) {
            // LOW to HIGH
            s = HIGH;
            return true;
        }
        else if (s == HIGH && in <= lowThreshold) {
            // HIGH to LOW
            s = LOW;
        }
        else if (s == UNINITIALIZED && in >= highThreshold) {
            // UNINITIALIZED to HIGH
            s = HIGH;
        }
        else if (s == UNINITIALIZED && in <= lowThreshold) {
            // UNINITIALIZED to LOW
            s = LOW;
        }
        return false;
    }
    bool process(float in, float lowThreshold = 0.f, float highThreshold = 1.f) {…}
 
    enum Event {
        NONE = 0,
        TRIGGERED = 1,
        UNTRIGGERED = -1
    };
    enum Event {…};

    Event processEvent(float in, float lowThreshold = 0.f, float highThreshold = 1.f) {
        Event event = NONE;
        if (s == LOW && in >= highThreshold) {
            // LOW to HIGH
            s = HIGH;
            event = TRIGGERED;
        }
        else if (s == HIGH && in <= lowThreshold) {
            // HIGH to LOW
            s = LOW;
            event = UNTRIGGERED;
        }
        else if (s == UNINITIALIZED && in >= highThreshold) {
            // UNINITIALIZED to HIGH
            s = HIGH;
        }
        else if (s == UNINITIALIZED && in <= lowThreshold) {
            // UNINITIALIZED to LOW
            s = LOW;
        }
        return event;
    }
    Event processEvent(float in, float lowThreshold = 0.f, float highThreshold = 1.f) {…}
 
    bool isHigh() {
        return s == HIGH;
    }
    bool isHigh() {…}
};
struct TSchmittTrigger<float> {…};
 
typedef TSchmittTrigger<> SchmittTrigger;
 

struct PulseGenerator {
    float remaining = 0.f;

    void reset() {
        remaining = 0.f;
    }
    void reset() {…}

    bool process(float deltaTime) {
        if (remaining > 0.f) {
            remaining -= deltaTime;
            return true;
        }
        return false;
    }
    bool process(float deltaTime) {…}
 
    bool isHigh() {
        return (remaining > 0.f);
    }
    bool isHigh() {…}

    void trigger(float duration = 1e-3f) {
        // Keep the previous pulse if the existing pulse will be held longer than the currently requested one.
        if (duration > remaining) {
            remaining = duration;
        }
    }
    void trigger(float duration = 1e-3f) {…}
};
struct PulseGenerator {…};
 

template <typename T = float>
struct TTimer {
    T time = 0.f;
 
    void reset() {
        time = 0.f;
    }
    void reset() {…}

    T process(T deltaTime) {
        time += deltaTime;
        return time;
    }
    T process(T deltaTime) {…}
 
    T getTime() {
        return time;
    }
    T getTime() {…}
};
struct TTimer {…};
 
typedef TTimer<> Timer;
 

struct ClockDivider {
    uint32_t clock = 0;
    uint32_t division = 1;
 
    void reset() {
        clock = 0;
    }
    void reset() {…}
 
    void setDivision(uint32_t division) {
        this->division = division;
    }
    void setDivision(uint32_t division) {…}
 
    uint32_t getDivision() {
        return division;
    }
    uint32_t getDivision() {…}
 
    uint32_t getClock() {
        return clock;
    }
    uint32_t getClock() {…}

    bool process() {
        clock++;
        if (clock >= division) {
            clock = 0;
            return true;
        }
        return false;
    }
    bool process() {…}
};
struct ClockDivider {…};
 
 
} // namespace dsp
} // namespace rack