VU.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
#include <AH/Math/MinMaxFix.hpp>
#include <Banks/BankableMIDIInput.hpp>
#include <MIDI_Inputs/MIDIInputElementChannelPressure.hpp>
#include <string.h>
 
BEGIN_CS_NAMESPACE
 
class IVU {
  public:
    IVU(uint8_t max) : max(max) {}
    virtual uint8_t getValue() = 0;
    virtual bool getOverload() = 0;
    virtual float getFloatValue() { return (float)getValue() / getMax(); }
    uint8_t getMax() const { return max; }
 
  protected:
    const uint8_t max;
};
 
namespace MCU {
 
namespace VUDecay {
constexpr unsigned int Hold = 0;
constexpr unsigned int Default = 150;
} // namespace VUDecay
 
struct VUEmptyCallback {
    template <class T>
    void begin(const T &) {}
    template <class T>
    void update(const T &) {}
};
 
template <uint8_t NumValues, class Callback>
class VU_Base : public MIDIInputElementChannelPressure, public IVU {
  protected:
    VU_Base(uint8_t track, const MIDIChannelCN &channelCN,
            unsigned int decayTime, const Callback &callback)
        : MIDIInputElementChannelPressure{{track - 1, channelCN}}, IVU(12),
          decayTime(decayTime), callback(callback) {}
 
  public:
    void begin() override { callback.begin(*this); }
    void reset() override {
        values = {{}};
        callback.update(*this);
    }
 
    uint8_t getValue() override { return getValue(getSelection()); }
    bool getOverload() override { return getOverload(getSelection()); }
 
    void update() override {
        if (decayTime && (millis() - prevDecayTime >= decayTime)) {
            prevDecayTime += decayTime;
            decay();
            callback.update(*this);
        }
    }
 
  private:
    bool updateImpl(const ChannelMessageMatcher &midimsg,
                    const MIDIAddress &target) override {
        uint8_t data = midimsg.data1 & 0x0F;
        uint8_t index = getBankIndex(target);
        switch (data) {
            case 0xF: clearOverload(index); break;
            case 0xE: setOverload(index); break;
            case 0xD: break; // no meaning
            default: setValue(index, data); break;
        }
        callback.update(*this);
        return true;
    }
 
    MIDIAddress getTarget(const ChannelMessageMatcher &midimsg) const override {
        return {
            int8_t(midimsg.data1 >> 4),
            Channel(midimsg.channel),
            Cable(midimsg.CN),
        };
    }
 
    void decay() {
        for (uint8_t i = 0; i < NumValues; ++i)
            if (getValue(i) > 0)
                values[i]--;
    }
 
    virtual uint8_t getSelection() const { return 0; }
 
    virtual setting_t getBankIndex(const MIDIAddress &target) const {
        (void)target;
        return 0;
    }
 
    void setValue(uint8_t index, uint8_t newValue) {
        prevDecayTime = millis();
        values[index] = newValue | (values[index] & 0xF0);
    }
 
    void setOverload(uint8_t index) { values[index] |= 0xF0; }
    void clearOverload(uint8_t index) { values[index] &= 0x0F; }
    uint8_t getValue(uint8_t index) const { return values[index] & 0x0F; }
    bool getOverload(uint8_t index) const { return values[index] & 0xF0; }
 
  private:
    Array<uint8_t, NumValues> values = {{}};
    unsigned int decayTime;
    unsigned long prevDecayTime = 0;
 
  public:
    Callback callback;
};
 
// -------------------------------------------------------------------------- //
 
template <class Callback = VUEmptyCallback>
class GenericVU : public VU_Base<1, Callback> {
  public:
    GenericVU(uint8_t track, const MIDIChannelCN &channelCN,
              unsigned int decayTime, const Callback &callback)
        : VU_Base<1, Callback>{
              track,
              channelCN,
              decayTime,
              callback,
          } {}
};
 
class VU : public GenericVU<> {
  public:
    VU(uint8_t track, const MIDIChannelCN &channelCN,
       unsigned int decayTime = VUDecay::Default)
        : GenericVU<>{
              track,
              channelCN,
              decayTime,
              {},
          } {}
 
    VU(uint8_t track, unsigned int decayTime = VUDecay::Default)
        : GenericVU<>{
              track,
              CHANNEL_1,
              decayTime,
              {},
          } {}
};
 
// -------------------------------------------------------------------------- //
 
namespace Bankable {
 
template <uint8_t NumBanks, class Callback = VUEmptyCallback>
class GenericVU : public VU_Base<NumBanks, Callback>,
                  public BankableMIDIInput<NumBanks> {
  public:
    GenericVU(BankConfig<NumBanks> config, uint8_t track,
              const MIDIChannelCN &channelCN, unsigned int decayTime,
              const Callback &callback)
        : VU_Base<NumBanks, Callback>{
            track, 
            channelCN, 
            decayTime, 
            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 VU : public GenericVU<NumBanks> {
  public:
    VU(BankConfig<NumBanks> config, uint8_t track,
       const MIDIChannelCN &channelCN,
       unsigned int decayTime = VUDecay::Default)
        : GenericVU<NumBanks>{
              config, track, channelCN, decayTime, {},
          } {}
 
    VU(BankConfig<NumBanks> config, uint8_t track,
       unsigned int decayTime = VUDecay::Default)
        : GenericVU<NumBanks>{
              config, track, CHANNEL_1, decayTime, {},
          } {}
};
 
} // namespace Bankable
 
} // namespace MCU
 
END_CS_NAMESPACE