VPotRing.hpp

Go to the documentation of this file.

#pragma once
 
#include <Banks/BankableMIDIInput.hpp>
#include <MIDI_Inputs/MIDIInputElementCC.hpp>
 
BEGIN_CS_NAMESPACE
 
namespace MCU {
 
constexpr static uint8_t VPotRingAddress = 0x30;
 
inline int8_t minimum(int8_t a, int8_t b) { return a > b ? b : a; }
inline int8_t maximum(int8_t a, int8_t b) { return a < b ? b : a; }
 
struct VPotEmptyCallback {
    VPotEmptyCallback() = default;
    template <class T>
    void begin(const T &) {}
    template <class T>
    void update(const T &) {}
};
 
class IVPotRing {
  protected:
    IVPotRing() = default;
 
  public:
    uint8_t getPosition() const { return getPosition(getValue()); }
    bool getCenterLed() const { return getCenterLed(getValue()); }
    uint8_t getMode() const { return getMode(getValue()); }
 
    uint8_t getStartOn() const {
        int8_t position = getPosition();
        if (position == 0)
            return 0;
        int8_t value = position - 1;
        switch (getMode()) {
            case 0: return value;
            case 1: return minimum(value, 5);
            case 2: return 0;
            case 3: return maximum(5 - value, 0);
            // Shouldn't happen, just keeps the compiler happy:
            default: return 0;
        }
    }
 
    uint8_t getStartOff() const {
        uint8_t value = getPosition();
        switch (getMode()) {
            case 0: return value;
            case 1: return maximum(value, 6);
            case 2: return value;
            case 3: return minimum(5 + value, 11);
            // Shouldn't happen, just keeps the compiler happy:
            default: return 0;
        }
    }
 
  private:
    virtual uint8_t getValue() const = 0;
 
    static uint8_t getPosition(uint8_t value) {
        uint8_t position = value & 0x0F;
        return position < 0x0C ? position : 0x0B;
    }
    static bool getCenterLed(uint8_t value) { return value & 0x40; }
    static uint8_t getMode(uint8_t value) { return (value & 0x30) >> 4; }
};
 
template <uint8_t NumValues, class Callback>
class VPotRing_Base : public MIDIInputElementCC, public IVPotRing {
  protected:
    VPotRing_Base(uint8_t track, const MIDIChannelCN &channelCN,
                  const Callback &callback)
        : MIDIInputElementCC{{track + VPotRingAddress - 1, channelCN}},
          callback(callback) {}
 
  public:
    void begin() override { callback.begin(*this); }
 
    void reset() override {
#ifdef VPOTRING_RESET
        values = {{}};
        callback.update(*this);
#endif
    }
 
  protected:
    static uint8_t sanitizeValue(uint8_t value) {
        return (value & 0x0F) < 0x0C ? value : ((value & 0xF0) | 0xB);
    }
 
  private:
    bool updateImpl(const ChannelMessageMatcher &midimsg,
                    const MIDIAddress &target) override {
        uint8_t index = getBankIndex(target);
        uint8_t value = sanitizeValue(midimsg.data2);
        values[index] = value;
        if (getSelection() == index)
            callback.update(*this);
        return true;
    }
 
    uint8_t getValue() const override { return values[getSelection()]; }
 
    virtual uint8_t getSelection() const { return 0; }
 
    virtual setting_t getBankIndex(const MIDIAddress &target) const {
        (void)target;
        return 0;
    }
 
    Array<uint8_t, NumValues> values = {{}};
 
  public:
    Callback callback;
};
 
// -------------------------------------------------------------------------- //
 
template <class Callback = VPotEmptyCallback>
class GenericVPotRing : public VPotRing_Base<1, Callback> {
  public:
    GenericVPotRing(uint8_t track, const MIDIChannelCN &channelCN,
                    const Callback &callback)
        : VPotRing_Base<1, Callback>{track, channelCN, callback} {}
};
 
class VPotRing : public GenericVPotRing<> {
  public:
    VPotRing(uint8_t track, const MIDIChannelCN &channelCN = CHANNEL_1)
        : GenericVPotRing{track, channelCN, {}} {}
};
 
// -------------------------------------------------------------------------- //
 
namespace Bankable {
 
template <uint8_t NumBanks, class Callback = VPotEmptyCallback>
class GenericVPotRing : public VPotRing_Base<NumBanks, Callback>,
                        public BankableMIDIInput<NumBanks> {
  public:
    GenericVPotRing(BankConfig<NumBanks> config, uint8_t track,
                    const MIDIChannelCN &channelCN, const Callback &callback)
        : VPotRing_Base<NumBanks, Callback>{track, channelCN, callback},
          BankableMIDIInput<NumBanks>{config} {}
 
  private:
    setting_t getSelection() const override {
        return BankableMIDIInput<NumBanks>::getSelection();
    };
 
    uint8_t getBankIndex(const MIDIAddress &target) const override {
        return BankableMIDIInput<NumBanks>::getBankIndex(target, this->address);
    }
 
    bool match(const MIDIAddress &target) const override {
        return BankableMIDIInput<NumBanks>::matchBankable(target,
                                                          this->address);
    }
 
    void onBankSettingChange() override { this->callback.update(*this); }
};
 
template <uint8_t NumBanks>
class VPotRing : public GenericVPotRing<NumBanks> {
  public:
    VPotRing(BankConfig<NumBanks> config, uint8_t track,
             MIDIChannelCN channelCN = CHANNEL_1)
        : GenericVPotRing<NumBanks>{config, track, channelCN, {}} {}
};
 
} // namespace Bankable
 
} // namespace MCU
 
END_CS_NAMESPACE