CCpotentiometer to NRPN based controller

[fitzgreyve]

Looked for this in the documentation and the issues etc. but could not find anything ?

CCpotentiometer (including bankable and manyaddresses) uses the standard MIDI controllers (CC).

Is there a (simple?) way to define and use NRPN byte sequences instead of the standnrd CC's - i.e. with some potentiometers generating standard CC, some NRPN based.

Ideally with "manyadddresses" a potentiometer could generate a standard CC in one bank, but NRPN based in a different bank ?

[tttapa]

You could use something like this (untested):

#include <Control_Surface.h>

class MyCustomPot : public MIDIOutputElement {
  public:
    MyCustomPot(const Bank<2> &bank, pin_t analogPin, MIDIAddress ccAddr, uint16_t nrpn)
      : bank(bank), ccAddr(ccAddr), nrpn(nrpn), filteredAnalog(analogPin) {}

    void begin() final override {
      filteredAnalog.resetToCurrentValue();
    }

    void update() final override {
      if (filteredAnalog.update())
        forcedUpdate();
    }

    void forcedUpdate() {
      switch (bank.getSelection()) {
        case 0:
          Control_Surface.sendControlChange(ccAddr, filteredAnalog.getValue());
          break;
        case 1:
          Control_Surface.sendControlChange(MIDI_CC::NRPN_LSB, (nrpn >> 0) & 0x7F);
          Control_Surface.sendControlChange(MIDI_CC::NRPN_MSB, (nrpn >> 7) & 0x7F);
          Control_Surface.sendControlChange(MIDI_CC::Data_Entry_MSB, filteredAnalog.getValue());
          break;
        default:;
      }
    }

  private:
    const Bank<2> &bank;
    MIDIAddress ccAddr;
    uint16_t nrpn;
    AH::FilteredAnalog<7> filteredAnalog;
};

USBMIDI_Interface midi;

Bank<2> bank;
MyCustomPot pot {bank, A0, MIDI_CC::General_Purpose_Controller_1, 0x1234};
IncrementSelector<2> sel {bank, 2};

void setup() {
  Control_Surface.begin();
}

void loop() {
  Control_Surface.loop();
}

[fitzgreyve]

Many thanks for that, I can see how it works and the logic is close to what I envisaged.

The NRPNs that I want to use all have a non-zero MSB (I assume that ony RPNs have a zero MSB value?).

I was wondering if it was possible to:

1. define an "extended" version of the MIDIAddress class that handles a 14 bit "address" instead of a normal 7 bit one.
2. Switch between NRPN and CC handling (as in your example) but based on address MSB zero/non-zero. For CC (MSB=0) the "extended" MIDIAddress values are mapped onto a "standard" MIDIAddress class (ccAddr in the above example)

Do you think this approach would work ?

Many thanks.
Mark

[tttapa]

Sure, you could do that, but it's not clear to me what that would improve about the example above. Doesn't it already handle 14-bit (N)RPN addresses?

[fitzgreyve]

Yes, I agree with you on the simple example you gave (CC on one bank, NRPN on the other).

However, I'm ideally looking for something more flexible. Below is what I'm currently using: I'm looking to be able to Mix CC and NRPN in any combination (and on any MIDI channel) within banks. Sorry I didn't make this clearer at the start.

Bank<3> bank = 1;               // 3 banks of 1 track

// bank control, using callback to drive led indicators
GenericIncrementSelector<3, MySelectorCallback> BankSelector {
  bank,         // Bank to manage
  {11, 12},     // red, green LED pins 
  {A0},         // push button on pin A0 
};


CD74HC4051 mux {
  A7,       // Analog input pin
  {4, 5, 6} // data lines for mux address pins S0, S1, S2
};

constexpr auto no_address = MIDIAddress::invalid();

Bankable::ManyAddresses::CCPotentiometer<3> panelPotentiometers[] = {
  {bank, mux.pin(0), {no_address, no_address, no_address}},  					// manage this MIDI output manually
  {bank, mux.pin(1), {{{MIDI_CC::Modulation_Wheel, CHANNEL_1}, {MIDI_CC::Modulation_Wheel, CHANNEL_1}, {MIDI_CC::Modulation_Wheel, CHANNEL_10}, }}},
  {bank, mux.pin(2), {no_address, no_address, no_address}},   					// manage this MIDI output manually
  {bank, mux.pin(3), {{{MIDI_CC::Pan, CHANNEL_1}, {MIDI_CC::Pan, CHANNEL_1}, {MIDI_CC::Pan, CHANNEL_10}, }}},
  {bank, mux.pin(4), {{{MIDI_CC::Channel_Volume, CHANNEL_1}, {MIDI_CC::Channel_Volume, CHANNEL_1}, {MIDI_CC::Channel_Volume, CHANNEL_10}, }}},
  {bank, mux.pin(5), {{{MIDI_CC::General_Purpose_Controller_5, CHANNEL_1}, {MIDI_CC::General_Purpose_Controller_5, CHANNEL_1}, {MIDI_CC::General_Purpose_Controller_5, CHANNEL_10}, }}},
  {bank, mux.pin(6), {{{MIDI_CC::Effects_1, CHANNEL_1}, {MIDI_CC::Effects_1, CHANNEL_1}, {MIDI_CC::Effects_1, CHANNEL_10}, }}},
  {bank, mux.pin(7), {{{MIDI_CC::Effects_3, CHANNEL_1}, {MIDI_CC::Effects_3, CHANNEL_1}, {MIDI_CC::Effects_3, CHANNEL_10}, }}},
};

[fitzgreyve]

Thinking some more about this, I've taken a "sideways" approach by using undefined MIDI CC's and then mapping them to the correct NRPNs using a custom class (below)

This works fine.

Ideally I would like to use it with "manyaddresses", but I can't understand the required syntax. Can anyone advise on this ?

Many thanks.

class CCNRPNpotentiometer : public MIDIOutputElement {
  public:
    CCNRPNpotentiometer(pin_t analogPin, MIDIAddress ccAddr)
      : ccAddr(ccAddr), filteredAnalog(analogPin) {}

    void begin() final override {
      filteredAnalog.resetToCurrentValue();
    }

    void update() final override {
      if (filteredAnalog.update())
        forcedUpdate();
    }

    void invert() { filteredAnalog.invert() ;}

    void forcedUpdate() {
        controller = ccAddr.getAddress();
        Channel outchannel = ccAddr.getChannel();
	 switch (controller) {
        case 0x21:				// TVF cutoff CC 21 -> NRPN 01 20
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x20);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x01);
          Control_Surface.sendControlChange({MIDI_CC::Data_Entry_MSB,outchannel}, filteredAnalog.getValue());
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x7f);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x7f);
          break;
        case 0x22:				// TVF resonance CC 22 -> NRPN 01 21
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x21);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x01);
          Control_Surface.sendControlChange({MIDI_CC::Data_Entry_MSB,outchannel}, filteredAnalog.getValue());
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x7f);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x7f);
          break;
        case 0x23:				// Attack CC 23 -> NRPN 01 63
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x63);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x01);
          Control_Surface.sendControlChange({MIDI_CC::Data_Entry_MSB,outchannel}, filteredAnalog.getValue());
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x7f);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x7f);
          break;
        case 0x24:				// Decay CC 24 -> NRPN 01 64
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x64);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x01);
          Control_Surface.sendControlChange({MIDI_CC::Data_Entry_MSB,outchannel}, filteredAnalog.getValue());
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x7f);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x7f);
          break;
        case 0x25:				// Release CC 24 -> NRPN 01 66
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x66);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x01);
          Control_Surface.sendControlChange({MIDI_CC::Data_Entry_MSB,outchannel}, filteredAnalog.getValue());
          Control_Surface.sendControlChange({MIDI_CC::NRPN_LSB,outchannel}, 0x7f);
          Control_Surface.sendControlChange({MIDI_CC::NRPN_MSB,outchannel}, 0x7f);
          break;
        default:				// everything else, no change
	  Control_Surface.sendControlChange(ccAddr, filteredAnalog.getValue());	;
      }
    }

  private:
    MIDIAddress ccAddr;
    uint8_t controller;
    AH::FilteredAnalog<7> filteredAnalog;
};

[tttapa]

The difference is that you save a generic BankAddress member instead of MIDIAddress, and then use the BankAddress::getActiveAddress() to get the address that was selected by the user. This simply returns a MIDIAddress, so the remainder of the code is the same as you have now.

See

Control-Surface/src/MIDI_Outputs/Bankable/Abstract/MIDIFilteredAnalog.hpp

Line 49 in fe8bc16

sender.send(filteredAnalog.getValue(), address.getActiveAddress());

for inspiration.