Pitch Bend pots with individual map ranges?

[PuttyStudios]

I'm cutting/pasting bits and pieces from the various examples provided, but am a bit stuck figuring out the 'correct' way to have a few pots, each on their own Pitch Bend channel, each needing their own individually remapped ranges.
Is an array the way to go, or should I just duplicate whole blocks of the code for each individual pot? (Using an Arduino Leonardo.)

Once I've got that sorted, I'll be adding a multiplexer to up the total to about 15 pots per board. I wonder if that will throw in new challenges...

Any help very much appreciated!
Cheers,
Peter.

[PuttyStudios]

This is my current sketch:

#include <Control_Surface.h>

USBMIDI_Interface midi;

PBPotentiometer potentiometer01 = {
  A0,
  CHANNEL_1,
};
PBPotentiometer potentiometer02 = {
  A1,
  CHANNEL_2,
};

constexpr analog_t minimumValue01 = 10000;
constexpr analog_t maximumValue01 = 12000;
constexpr analog_t minimumValue02 = 8000;
constexpr analog_t maximumValue02 = 14000;
 
analog_t mappingFunction01(analog_t raw) {
    raw = constrain(raw, minimumValue01, maximumValue01);
    return map(raw, minimumValue01, maximumValue01, 0, 16383);
}
analog_t mappingFunction02(analog_t raw) {
    raw = constrain(raw, minimumValue02, maximumValue02);
    return map(raw, minimumValue02, maximumValue02, 0, 16383);
} 
void setup() {
  potentiometer01.map(mappingFunction01);
  potentiometer02.map(mappingFunction02);
  Control_Surface.begin();
}
 
void loop() {
  Control_Surface.loop();
  Serial.println(potentiometer01.getRawValue());
  Serial.println(potentiometer02.getRawValue());
}

It works, but is obviously going to get quite big as I add more potentiometers. Possible to make it more efficient?

[tttapa]

You could use something like this:

#include <Control_Surface.h>

USBMIDI_Interface midi;

PBPotentiometer potentiometers[] = {
  { A0, CHANNEL_1, },
  { A1, CHANNEL_2, },
};
 
template <analog_t MinVal, analog_t MaxVal>
analog_t mappingFunction(analog_t raw) {
    raw = constrain(raw, MinVal, MaxVal);
    return map(raw, MinVal, MaxVal, 0, FilteredAnalog<>::getMaxRawValue());
}

void setup() {
  potentiometers[0].map(mappingFunction<10000, 12000>);
  potentiometers[1].map(mappingFunction<8000, 14000>);
  Control_Surface.begin();
}
 
void loop() {
  Control_Surface.loop();
}

[klausnielsen]

This looks like exactly what I need for my sysex midi controller. I used @tttapa's example here to mux a number sysex pots which works great, but some of them need to go from 0-127, some from 0-63, and some from 0-20. When I try to add the example above to my sketch, the compiler says: 'class SysExPot' has no member named 'map'. Can I somehow add this to the SysExPot class definition?

#include <Control_Surface.h>

uint8_t sysex_data[] {
  0xF0, 0x10, 0x06, 0x06, 0x15, 0x00, 0xF7,
};

class SysExPot : public MIDIOutputElement {
 public:
  SysExPot(pin_t pin, uint8_t param_id)
    : pot(pin), param_id(param_id) {}

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

  void update() final override {
    if (pot.update())
     send(pot.getValue());
  }

  void send(uint8_t value) {
    sysex_data[4] = param_id;
    sysex_data[5] = value;
    Control_Surface.send(SysExMessage{sysex_data});
  }

 private:
  FilteredAnalog<7> pot;
  uint8_t param_id;
};

auto &serial = Serial;
SerialMIDI_Interface<decltype(serial)> midi {serial, MIDI_BAUD};

CD74HC4051 mux {A0, {2, 3, 4}};

SysExPot pots[] {
  {mux.pin(0), 0x00},
  {mux.pin(1), 0x15},
  {mux.pin(2), 0x21},
  {mux.pin(3), 0x18},
  {mux.pin(4), 0x58},
};

template <analog_t MinVal, analog_t MaxVal>
analog_t mappingFunction(analog_t raw) {
    raw = constrain(raw, MinVal, MaxVal);
    return map(raw, MinVal, MaxVal, 0, FilteredAnalog<7>::getMaxRawValue());
}

void setup() {
  pots[0].map(mappingFunction<0, 63>);
  pots[1].map(mappingFunction<0, 127>);
  Control_Surface.begin();
}

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

[tttapa]

Yes, you can simply add a map function to the class: simply call the FilteredAnalog::map function.

class SysExPot : ... {
  public:
    ...
    void map(MappingFunction fn) { pot.map(fn); }
    ...
};

[klausnielsen]

Thanks Pieter. Tried adding as you said. It compiles fine, but the effect is that the two pots for which I add a mapping pots[0] and pots[1] stop outputting sysex (checked with MidiOx) - the others still work (but without mapping)

#include <Control_Surface.h>

uint8_t sysex_data[] {
  0xF0, 0x10, 0x06, 0x06, 0x15, 0x00, 0xF7,
};

class SysExPot : public MIDIOutputElement {
 public:
  SysExPot(pin_t pin, uint8_t param_id)
    : pot(pin), param_id(param_id) {}

  void map(MappingFunction fn) { pot.map(fn); }

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

  void update() final override {
    if (pot.update())
     send(pot.getValue());
  }

  void send(uint8_t value) {
    sysex_data[4] = param_id;
    sysex_data[5] = value;
    Control_Surface.send(SysExMessage{sysex_data});
  }

 private:
  FilteredAnalog<7> pot;
  uint8_t param_id;
};

auto &serial = Serial;
SerialMIDI_Interface<decltype(serial)> midi {serial, MIDI_BAUD};

CD74HC4051 mux {A0, {2, 3, 4}};

SysExPot pots[] {
  {mux.pin(0), 0x00},
  {mux.pin(1), 0x15},
  {mux.pin(2), 0x21},
  {mux.pin(3), 0x18},
  {mux.pin(4), 0x58},
};

template <analog_t MinVal, analog_t MaxVal>
analog_t mappingFunction(analog_t raw) {
    raw = constrain(raw, MinVal, MaxVal);
    return map(raw, MinVal, MaxVal, 0, FilteredAnalog<7>::getMaxRawValue());
}

void setup() {
  pots[0].map(mappingFunction<0, 63>);
  pots[1].map(mappingFunction<0, 127>);
  Control_Surface.begin();
}

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

[tttapa]

The mapping ranges you specified are way too small: the full range is [0, 16384), so [0, 64) is going to be down in the noise and is probably filtered out.

It sounds like you want to map the output range, not the input, so you should use something like

analog_t mappingFunction(analog_t raw) {
    return map(raw, 0, FilteredAnalog<7>::getMaxRawValue(), 0, FilteredAnalog<7>::getMaxRawValue() / 2);
}

Note that the mapping function only deals with raw analog values in the range [0, 16384), the actual mapping to midi values in the range [0, 128) happens after filtering. A raw value of 0 results in a MIDI value of 0, and a raw value of FilteredAnalog<7>::getMaxRawValue() results in a MIDI value of 127. So if you want a maximum MIDI value of 63, your mapping function needs to return a value of at most FilteredAnalog<7>::getMaxRawValue() / 2 (or even FilteredAnalog<7>::getMaxRawValue() / 2 - 1, I don't know by heart, but you can try it if you get 64 instead of 63).

[klausnielsen]

Thanks for clearing this up for me. Yes, indeed - I want to map the output range. Using your example of divide by 2 I got the code below working exactly like I wanted. Thanks :)
I needed to make two different mappingFunctions and then refer to these (1 and 2) in void setup(). I will play around with this to see if can avoid specifying the constrain <0, 16384> on each pot that needs to be mapped. (Luckily pots that need to go from 0 to 127 don't need mapping.)

template <analog_t MinVal, analog_t MaxVal>
analog_t mappingFunction1(analog_t raw) {
    raw = constrain(raw, MinVal, MaxVal);
    return map(raw, MinVal, MaxVal, 0, FilteredAnalog<7>::getMaxRawValue() / 2);
}

template <analog_t MinVal, analog_t MaxVal>
analog_t mappingFunction2(analog_t raw) {
    raw = constrain(raw, MinVal, MaxVal);
    return map(raw, MinVal, MaxVal, 0, FilteredAnalog<7>::getMaxRawValue() / 6.35);
}

void setup() {
  pots[0].map(mappingFunction1<0, 16384>);
  pots[1].map(mappingFunction2<0, 16384>);
  pots[4].map(mappingFunction2<0, 16384>);
  Control_Surface.begin();
}

[mattibatti]

Agreed.

Wondering - can the values passed to the mappingFunction be variables? I am having trouble doing this, getting the error message:
"" parse error in template argument list
sensors[k].map(mappingFunction <analog_t mininum,analog_t maximum); ""

analog_t maximums[] = {0, 0, 0, 0, 0};
analog_t minimums[] = {16383, 16383, 16383, 16383, 16383};

for(int k =0 ; k< numSensors; k++){
  analog_t minimum = minimums[k];
  analog_t maximum = maximums[k];
  sensors[k].map(mappingFunction <minimum,maximum>);

[tttapa]

The template arguments you pass to the mappingFunction have to be compile-time constants, you can't use a for loop like that.

You'll have to use the approach illustrated above:

  potentiometers[0].map(mappingFunction<10000, 12000>);
  potentiometers[1].map(mappingFunction<8000, 14000>);

[mattibatti]

Just so I make sure I understand, the parameters of the mappingFunction can only be set at the time of compiling and can't be updated at any later point. Is that right?

Thanks for your response!

[tttapa]

If you use the approach in this thread, then yes, they are fixed at compile time.

If you want to be able to change them at run time, you could do something like this:

analog_t minimum_values[] {0, 1, 2};
analog_t maximum_values[] {100, 101, 102};

template <size_t I>
analog_t mappingFunction(analog_t raw) {
    raw = constrain(raw, minimum_values[I], maximum_values[I]);
    return map(raw, minimum_values[I], maximum_values[I], 0, 16383);
}

CCPotentiometer pots[3];

void setup() {
    pots[0].map(mappingFunction<0>);
    pots[1].map(mappingFunction<1>);
    pots[2].map(mappingFunction<2>);
}

Or if you enjoy some metaprogramming voodoo (and your compiler is new enough), you could even do something like:

analog_t minimum_values[] {0, 1, 2};
analog_t maximum_values[] {100, 101, 102};

[[gnu::noinline]] analog_t customMappingFunction(analog_t raw, size_t index) {
    raw = constrain(raw, minimum_values[index], maximum_values[index]);
    return map(raw, minimum_values[index], maximum_values[index], 0, 16383);
}

CCPotentiometer pots[3];

void setup() {
    mapAll<customMappingFunction>(pots);
}

Where the mapAll function is defined as follows:

#include <utility>

using custom_map_fn_t = analog_t (*)(analog_t, size_t);
template <custom_map_fn_t Func, class T, size_t... I>
void mapAllImpl(T *array, std::index_sequence<I...>) {
    (array[I].map(+[](analog_t raw) { return Func(raw, I); }), ...);
}
template <custom_map_fn_t Func, class T, size_t N>
void mapAll(T (&array)[N]) {
    mapAllImpl<Func>(+array, std::make_index_sequence<N>());
}

[mattibatti]

Wow thanks so much, this is awesome!

I am asking because I am using a wearabale accelerometer systems that has slightly changing mins and maxs from use to use, so I want to include a calibration method at startup which determines the mins and maxs of the sensor.

I echo the post from above, is there a tip jar?!?