Creating a class which allows more bank settings than buttons

[talipscomb]

I am working on a project which requires bankable buttons whose function can be changed by holding down a modifier key. I would like the bank to revert to zero when nothing is pressed and change to 1, 2, 3, 4 etc depending on the button pressed. I modified the "ManyButtonsSelector" class to function as momentary rather than latching. However this means the number of banks N will be equal to the number of buttons plus one. When i tried to modify the class so that the for loop in update() sets the bank to i+1, the program will crash if I select the last button. Also if I change the number of banks to be greater than the number of buttons declared the code will not compile.

I sort of "cheated" to get it working, by declaring a button on a pin which doesnt exist on my Teensy, allowing my real buttons to start from 1. It didnt sit well with me that I couldnt figure out how to modify the class so this is not necessary. Is there a more proper way to modify my class so it doesnt require this fake button?

#include <Control_Surface.h>
USBMIDI_Interface usbmidi;

BEGIN_CS_NAMESPACE
 
template <setting_t N, class Callback = EmptySelectorCallback>
class GenericManySwitchesSelector : public GenericSelector<N, Callback> {
    using Parent = GenericSelector<N, Callback>;
 
  public:
    GenericManySwitchesSelector(Selectable<N> &selectable, const Callback &callback, const PinList<N> &buttonPins)
        : GenericSelector<N, Callback> {selectable, callback},
          buttons(AH::copyAs<AH::Button>(buttonPins)) {}
    int flag;
    void begin() override {
        Parent::begin();
        for (auto &btn : buttons)
            btn.begin();
    }
 
    void update() override {
        Parent::update();
        for (setting_t i = 0; i < N; i++){
          if (buttons[i].update() == AH::Button::Pressed ){
            this->set(i);
            flag = i;
          }
          else if (i == flag && buttons[i].update()  == AH::Button::Released){
            this->set(0);  
          }
        }
    }
 
    void invert() {
        for (auto &btn : buttons)
            btn.invert();
    }
 
  private:
    AH::Array<AH::Button, N> buttons;
};
 
// -------------------------------------------------------------------------- //
 
template <setting_t N>
class ManySwitchesSelector : public GenericManySwitchesSelector<N> {
  public:
    ManySwitchesSelector(Selectable<N> &selectable, const PinList<N> &buttonPins)
        : GenericManySwitchesSelector<N> {
              selectable,
              {},
              buttonPins,
          } {}
};
 
END_CS_NAMESPACE

// Begin Code
const int numBanks = 5;
Bank<numBanks> bank(8);

// Multiplexers
CD74HC4067 mux1 {
  A15,          
  {0, 1, 2, 3} // Address pins S0, S1, S2, S3
};

CD74HC4067 mux2 {
  40,          
  {0, 1, 2, 3} // Address pins S0, S1, S2, S3
};

CD74HC4067 mux3 {
  41,         
  {0, 1, 2, 3} // Address pins S0, S1, S2, S3
};

//Creating bunk pin 42 (Teensy pins go up to 41) to allow for bank 0 with no button
ManySwitchesSelector<numBanks> selector {
  bank, {42, mux3.pin(3), mux3.pin(2), mux3.pin(1), mux3.pin(0)},};

// Mapping function:
constexpr analog_t minimumValue = 4612;// 4548;
constexpr analog_t maximumValue = 63165;//63357;//63165;
 
analog_t mappingFunction(analog_t raw) {
  raw = constrain(raw, minimumValue, maximumValue);
  return map(raw, minimumValue, maximumValue, 0, 65534);
}

CCPotentiometer volumePotentiometers[] {
  { mux1.pin(0), { 0, Channel_1 } },
  { mux1.pin(1), { 0, Channel_2 } },
  { mux1.pin(2), { 0, Channel_3 } },
  { mux1.pin(3), { 0, Channel_4 } },
  { mux1.pin(4), { 0, Channel_5 } },
  { mux1.pin(5), { 0, Channel_6 } },
  { mux1.pin(6), { 0, Channel_7 } },
  { mux1.pin(7), { 0, Channel_8 } },
};

Bankable:ManyAddresses::CCButton<numBanks> trackButtons[] {
  {bank, mux2.pin(0), {1, 17, 33, 50} },
  {bank, mux2.pin(1), {2, 18, 34, 51} },
  {bank, mux2.pin(2), {3, 19, 35, 52} },
  {bank, mux2.pin(3), {4, 20, 36, 53} },
  {bank, mux2.pin(4), {5, 21, 37, 54} },
  {bank, mux2.pin(5), {6, 22, 38, 55} },
  {bank, mux2.pin(6), {7, 23, 39, 56} },
  {bank, mux2.pin(7), {8, 24, 40, 57} },
};

CCButton buttonPad[] {
 // {mux3.pin(3),  {MIDI_CC::General_Purpose_Controller_2, Channel_1} },
  // {mux3.pin(2),  {MIDI_CC::General_Purpose_Controller_2, Channel_2} },
  // {mux3.pin(1),  {MIDI_CC::General_Purpose_Controller_2, Channel_3} },
  // {mux3.pin(0),  {MIDI_CC::General_Purpose_Controller_2, Channel_4} },
  {mux3.pin(7),  {MIDI_CC::General_Purpose_Controller_2, Channel_5} },
  {mux3.pin(6),  {MIDI_CC::General_Purpose_Controller_2, Channel_6} },
  {mux3.pin(5),  {MIDI_CC::General_Purpose_Controller_2, Channel_7} },
  {mux3.pin(4),  {MIDI_CC::General_Purpose_Controller_2, Channel_8} },
  {mux3.pin(12),  {MIDI_CC::General_Purpose_Controller_2, Channel_9} },
  {mux3.pin(13),  {MIDI_CC::General_Purpose_Controller_2, Channel_10} },
  {mux3.pin(14),  {MIDI_CC::General_Purpose_Controller_2, Channel_11} },
  {mux3.pin(15),  {MIDI_CC::General_Purpose_Controller_2, Channel_12} },
  {mux3.pin(11),  {MIDI_CC::General_Purpose_Controller_2, Channel_13} },
  {mux3.pin(10),  {MIDI_CC::General_Purpose_Controller_2, Channel_14} },
  {mux3.pin(9),  {MIDI_CC::General_Purpose_Controller_2, Channel_15} },
  {mux3.pin(8),  {MIDI_CC::General_Purpose_Controller_2, Channel_16} },
};


void setup() {

for (int i = 0; i <= 7; i++) {
  volumePotentiometers[i].map(mappingFunction);
}

Control_Surface.begin();
Serial.begin(115200);

}

void loop() {
Control_Surface.loop();
Serial.println(bank.getSelection());
}

[tttapa]

When i tried to modify the class so that the for loop in update() sets the bank to i+1, the program will crash if I select the last button. Also if I change the number of banks to be greater than the number of buttons declared the code will not compile.

If you have N buttons that define N+1 possible banks, you should inherit from GenericSelector<N + 1, Callback> instead of GenericSelector<N, Callback>, and the same for Selectable<N + 1>.