VPotRing.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/STL/algorithm>
#include <AH/Timing/MillisMicrosTimer.hpp>
#include <MIDI_Inputs/InterfaceMIDIInputElements.hpp>
#include <MIDI_Inputs/MIDIInputElementMatchers.hpp>
 
BEGIN_CS_NAMESPACE
 
namespace MCU {
 
struct VPotState {
    VPotState(uint8_t value = 0) : value(value) {}
 
    uint8_t value; 
 
    bool update(uint8_t data) {
        data = sanitizeData(data);
        bool changed = data != this->value;
        this->value = data;
        return changed;
    }
 
    enum Mode {
        SingleDot = 0, 
        BoostCut = 1,  
        Wrap = 2,      
        Spread = 3,    
    };
 
 
    uint8_t getPosition() const { return value & 0x0F; }
    bool getCenterLed() const { return value & 0x40; }
    Mode getMode() const { return static_cast<Mode>((value & 0x30) >> 4); }
 
    uint8_t getStartOn() const {
        int8_t position = getPosition();
        if (position == 0)
            return 0;
        int8_t value = position - 1;
        switch (getMode()) {
            case SingleDot: return value;
            case BoostCut: return std::min(+value, 5);
            case Wrap: return 0;
            case Spread: return std::max(5 - value, 0);
            default: return 0;
        }
    }
 
    uint8_t getStartOff() const {
        uint8_t value = getPosition();
        switch (getMode()) {
            case SingleDot: return value;
            case BoostCut: return std::max(+value, 6);
            case Wrap: return value;
            case Spread: return std::min(5 + value, 11);
            default: return 0;
        }
    }
 
 
    static uint8_t sanitizeData(uint8_t data) {
        // Maximum valid position value is 0xB.
        return (data & 0x0F) <= 0x0B ? data : ((data & 0xF0) | 0x0B);
    }
};
 
// -------------------------------------------------------------------------- //
 
struct VPotMatcher : public TwoByteMIDIMatcher {
    VPotMatcher(uint8_t track, MIDIChannelCable channelCN)
        : TwoByteMIDIMatcher({track + 0x30 - 1, channelCN}) {}
};
 
template <uint8_t BankSize>
struct BankableVPotMatcher : public BankableTwoByteMIDIMatcher<BankSize> {
    BankableVPotMatcher(BankConfig<BankSize> config, uint8_t track,
                        MIDIChannelCable channelCN)
        : BankableTwoByteMIDIMatcher<BankSize>(config,
                                               {track + 0x30 - 1, channelCN}) {}
};
 
// -------------------------------------------------------------------------- //
 
class VPotRing
    : public MatchingMIDIInputElement<MIDIMessageType::CONTROL_CHANGE,
                                      VPotMatcher>,
      public Interfaces::MCU::IVPot {
  public:
    using Matcher = VPotMatcher;
    using Parent 
        = MatchingMIDIInputElement<MIDIMessageType::CONTROL_CHANGE, Matcher>;
 
    VPotRing(uint8_t track, MIDIChannelCable channelCN = CHANNEL_1)
        : Parent({track, channelCN}) {}
 
  protected:
    bool handleUpdateImpl(typename Matcher::Result match) {
        return state.update(match.value);
    }
 
    void handleUpdate(typename Matcher::Result match) override {
        dirty |= handleUpdateImpl(match);
    }
 
  public:
 
    VPotState getState() const { return state; }
 
    uint8_t getPosition() const { return state.getPosition(); }
    bool getCenterLed() const override { return state.getCenterLed(); }
    VPotState::Mode getMode() const { return state.getMode(); }
 
    uint8_t getStartOn() const override { return state.getStartOn(); }
    uint8_t getStartOff() const override { return state.getStartOff(); }
 
 
    void reset() override {
        if (!ignoreReset) {
            state = {};
            dirty = true;
        }
    }
 
  private:
    VPotState state = {};
 
  public:
    bool ignoreReset = true;
};
 
// -------------------------------------------------------------------------- //
 
namespace Bankable {
 
template <uint8_t BankSize>
class VPotRing
    : public BankableMatchingMIDIInputElement<MIDIMessageType::CONTROL_CHANGE,
                                              BankableVPotMatcher<BankSize>>,
      public Interfaces::MCU::IVPot {
  public:
    using Matcher = BankableVPotMatcher<BankSize>;
    using Parent 
        = BankableMatchingMIDIInputElement<MIDIMessageType::CONTROL_CHANGE,
                                           Matcher>;
    VPotRing(BankConfig<BankSize> config, uint8_t track,
             MIDIChannelCable channelCN = CHANNEL_1)
        : Parent({config, track, channelCN}) {}
 
  protected:
    bool handleUpdateImpl(typename Matcher::Result match) {
        return states[match.bankIndex].update(match.value) &&
               match.bankIndex == this->getActiveBank();
        // Only mark dirty if the value of the active bank changed
    }
    
    void handleUpdate(typename Matcher::Result match) override {
        dirty |= handleUpdateImpl(match);
    }
 
  public:
 
    VPotState getState(uint8_t bank) const { return states[bank]; }
 
    uint8_t getPosition(uint8_t bank) const {
        return getState(bank).getPosition();
    }
    bool getCenterLed(uint8_t bank) const {
        return getState(bank).getCenterLed();
    }
    VPotState::Mode getMode(uint8_t bank) const {
        return getState(bank).getMode();
    }
 
    uint8_t getStartOn(uint8_t bank) const {
        return getState(bank).getStartOn();
    }
    uint8_t getStartOff(uint8_t bank) const {
        return getState(bank).getStartOff();
    }
 
    VPotState getState() const { return getState(this->getActiveBank()); }
 
    uint8_t getPosition() const { return getPosition(this->getActiveBank()); }
    bool getCenterLed() const override {
        return getCenterLed(this->getActiveBank());
    }
    VPotState::Mode getMode() const { return getMode(this->getActiveBank()); }
 
    uint8_t getStartOn() const override {
        return getStartOn(this->getActiveBank());
    }
    uint8_t getStartOff() const override {
        return getStartOff(this->getActiveBank());
    }
 
 
    void reset() override {
        if (!ignoreReset) {
            states = {{}};
            dirty = true;
        }
    }
 
  protected:
    void onBankSettingChange() override { dirty = true; }
 
  private:
    AH::Array<VPotState, BankSize> states = {{}};
 
  public:
    bool ignoreReset = true;
};
 
} // namespace Bankable
 
} // namespace MCU
 
END_CS_NAMESPACE