Pitchbend - Unipolar mapping

[thereisthe]

Hello, I am relatively new to programming - I've dug through some of the questions here, and made some progress but I seem to have a math issue.

I have a footpedal pot to be sent via USBMIDI to use as CC or PB.
The CC example with the mapping works well - as I want the full 0 - 127

For PB, I want the minimum to be 0 and the maximum to be 8191 (signed 14bit?) - for pitchbend UP only
From what I understand - mappingFunction()'s map()'s min-out should be 8192 and max-out should be 16383 (unsigned 14bit?)

When hooked-up to a MIDI program, the 100% wiper position is correctly 16383
The 0% position is 8200 (msb/lsb 64 8)
I've tried setting the min-out to 8192 and also using FilteredAnalog<>::getMaxRawValue(); / 2
both have the same result, though I may be using it incorrectly

I have also tried manually subtracting - 9 from the min-out like this but no change
return map(raw, minimumValue, maximumValue, (maxRawValue / 2) - 9, maxRawValue);

If I subtract "16 or more"ish from the min-out, it completely skips 8192 and it becomes 8183 (msb/lsb 63 119)
I am unable to get fine changes even if I subtracted. the min-out of map() seems to always jump by 16 at a time
This makes any instrument that receives the pitchbend be slightly detuned when at 0%

#include <Control_Surface.h> // Include the Control Surface library
USBMIDI_Interface midi; // Instantiate a MIDI over USB interface.

// Instantiate a PBPotentiometer object
PBPotentiometer potentiometer {
  A0,        // Analog pin connected to potentiometer
  Channel_1, // MIDI Channel 1
};

//Mapping
constexpr unsigned long maxRawValue = FilteredAnalog<>::getMaxRawValue();
constexpr analog_t minimumValue = 4450 * maxRawValue / 16383; // The filtered value read when potentiometer is at the 0% position
constexpr analog_t maximumValue = 16383 * maxRawValue / 16383; // The filtered value read when potentiometer is at the 100% position

analog_t mappingFunction(analog_t raw) {
  raw = constrain(raw, minimumValue, maximumValue);
  return map(raw, minimumValue, maximumValue, maxRawValue / 2 , maxRawValue); 
}

void setup() {
  potentiometer.map(mappingFunction); // Add the mapping function to the potentiometer
  Control_Surface.begin(); // Initialize Control Surface
 //Serial.begin(115200);
}

void loop() {
  Control_Surface.loop(); // Update the Control Surface
  //Serial.println(potentiometer.getRawValue());
}

To me, the problem seems to be a math issue because we're not calculating in floats?
I've run into similar things with 0-127 MIDI scaling to 0. - 1. Where the "middle" is 127 / 2 = 63.5
But if we're not calculating in floats, the "middle" rounds up or down to 63/64
I'm guessing that is what happens here but in 14-bit resolution.

Is there a way to get your mappingFunction() to calculate in floats just in the backend?
I think you could also do some more math in mappingFunction() to achieve the same result, but not sure how to approach it!

[tttapa]

A possible issue could be the resolution of the sender:

^{PBPotentiometer}
The actual precision is "only" 10 bits, because this is the resolution of the built-in ADC, and this is the default resolution used by the Mackie Control Universal protocol.

If you need more resolution, you can use MIDIFilteredAnalog<PitchBendSender<14>>. See https://tttapa.github.io/Control-Surface-doc/Doxygen/d3/d74/PBPotentiometer_8hpp_source.html for inspiration.

[thereisthe]

This likely is it, but I cant figure out where MIDIFilteredAnalog<PitchBendSender<14>> is supposed to go. I'm guessing PBPotentiometer<PitchBendSender<14>> potentiometer{};
to which I got Compilation error: 'cs::PBPotentiometer' is not a template

Just guessing, when you point me toward PBPotentiometer.hpp, are you suggesting I should create a copy of the class with the precision edited?

[thereisthe]

I tried this -
copied PBPotentiometer.hpp and .cpp and renamed to PBPot14bit
Inside .cpp, pointed it at .hpp
fixed class names in .hpp and set precision to 14
Added #include <MIDI_Outputs/PBPot14bit.hpp> in Control_Surface.h in the main directory
swapped over the classes in the main sketch, tried to compile, and....

In file included from \Arduino\libraries\Control_Surface\src/AH/Hardware/FilteredAnalog.hpp:7,
                 from \Arduino\libraries\Control_Surface\src/Control_Surface/Control_Surface_Class.hpp:6,
                 from \Arduino\libraries\Control_Surface\src/Control_Surface.h:16,
                 from \Pedal Pitchbend\Pitch_Bend_Potentiometer_example\Pitch_Bend_Potentiometer_example.ino:1:
\Arduino\libraries\Control_Surface\src/AH/Filters/Hysteresis.hpp: In instantiation of 'void Hysteresis<0, T_in, T_out>::setValue(T_in) const [with T_in = short unsigned int; T_out = short unsigned int]':
\Arduino\libraries\Control_Surface\src/AH/Hardware/FilteredAnalog.hpp:82:28:   required from 'void AH::GenericFilteredAnalog<MappingFunction, Precision, FilterShiftFactor, FilterType, AnalogType, IncRes>::resetToCurrentValue() [with MappingFunction = short unsigned int (*)(short unsigned int); unsigned char Precision = 14; unsigned char FilterShiftFactor = 2; FilterType = short unsigned int; AnalogType = short unsigned int; unsigned char IncRes = 2]'
\Arduino\libraries\Control_Surface\src/MIDI_Outputs/Abstract/MIDIFilteredAnalog.hpp:35:69:   required from 'void cs::MIDIFilteredAnalog<Sender>::begin() [with Sender = cs::PitchBendSender<14>]'
\Arduino\libraries\Control_Surface\src/MIDI_Outputs/Abstract/MIDIFilteredAnalog.hpp:35:10:   required from here
\Arduino\libraries\Control_Surface\src/AH/Filters/Hysteresis.hpp:90:54: error: assignment of member 'Hysteresis<0, short unsigned int, short unsigned int>::prevLevel' in read-only object
   90 |     void setValue(T_in inputLevel) const { prevLevel = inputLevel; }
      |                                            ~~~~~~~~~~^~~~~~~~~~~~

Edit: I tried setting the precision to 13 and it compiled without error. 3 bits closer to center!
Now it is 1 off center... instead of 8 off center
any idea why 14 bit resolution runs an error with the Hysteresis?

[tttapa]

any idea why 14 bit resolution runs an error with the Hysteresis?

This is indeed a bug in Control Surface, the const shouldn't be there, it's a copy-paste mistake from the line above it. (Usually this case doesn't happen, it's in the “no-op” version of the hysteresis class.) This should be fixed in the latest version.

Since you're interested in changing the output range (the MIDI values), and not the input range (the raw analog values), I think it makes most sense to do the mapping in the MIDI sender. You could try something like this:

#include <Control_Surface.h>

template <uint8_t InputPrecisionBits>
class PitchBendSenderMiddle {
  public:
    static void send(uint16_t value, MIDIAddress address) {
        value = AH::increaseBitDepth<13, precision(), uint16_t>(value);
        value |= uint16_t {1} << 13;
        MIDIChannelCable channelCN = address.getChannelCable();
        Control_Surface.sendPitchBend(channelCN, value);
    }

    constexpr static uint8_t precision() {
        static_assert(InputPrecisionBits <= 13, "");
        return InputPrecisionBits;
    }
};

class PBPotentiometerMiddle : public MIDIFilteredAnalog<PitchBendSenderMiddle<13>> {
  public:
    PBPotentiometerMiddle(pin_t analogPin, MIDIChannelCable address = Channel_1)
        : MIDIFilteredAnalog(analogPin, address, {}) {}
};

USBMIDI_Interface midi;
PBPotentiometerMiddle pot {A0, Channel_1};

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

This sends 8192 when the analog input is at 0V, and 16383 when the analog input is at Vcc. You can still combine it with a mapping function if necessary. Do keep in mind that the output may be very noisy, since the actual ADC resolution is most likely a lot lower than 13 bits.

I also added a new increaseBitDepthMiddle function, which may come in handy for similar purposes. The graph in its documentation also shows why you couldn't reach 8192 exactly.

[tttapa]

You may want to increase the filtering in the settings, and use a wider filter type (e.g. uint32_t):

Control-Surface/src/AH/Settings/Settings.hpp

Lines 57 to 73 in 095c992

	/**
	* The factor for the analog filter:
	* Difference equation:
	* @f$ y[n] = \alpha\cdot x[n] + (1-\alpha)\cdot y[n-1] @f$
	* where
	* @f$ \alpha = \left(\frac{1}{2}\right)^{ANALOG\_FILTER\_SHIFT\_FACTOR} @f$
	*
	* @see FilteredAnalog
	*/
	constexpr uint8_t ANALOG_FILTER_SHIFT_FACTOR = 2;
	/**
	* The unsigned integer type to use for analog inputs during filtering.
	*
	* @see FilteredAnalog
	*/
	using ANALOG_FILTER_TYPE = uint16_t;

[thereisthe]

It works! and mostly makes sense

increaseBitDepthMiddle Looks great. Would you swap this line to use?
value = AH::increaseBitDepth<13, precision(), uint16_t>(value);
value = AH::increaseBitDepthMiddle<13, precision(), uint16_t>(value);

one word of caution for others - seems like the map() needs the have the out-min set to 0 while using PBPotentiometerMiddle to get 8192-16838

analog_t mappingFunction(analog_t raw) {
    raw = constrain(raw, minimumValue, maximumValue);
    return map(raw, minimumValue, maximumValue, 0, 16383);
}

Is there a resource I can read about filters and your equation? I'm not sure I totally understand whats going on here.
I tried raising the shift value to 3-10 and all ran into an error

\libraries\Control_Surface\src/AH/Hardware/FilteredAnalog.hpp:220:19: error: static assertion failed: Error: Precision is larger than the increased ADC precision
  220 |         Precision <= ADC_BITS + IncRes,
      |         ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~

I can lower precision to 10 for now, but would love to try different filterings

[tttapa]

Would you swap this line to use?

Not in the current code, no, since it's used only for the upper half. increaseBitDepth is more accurate, and since you don't need any specific constraints on the middle value (12278 here), you don't need increaseBitDepthMiddle.

I tried raising the shift value to 3-10 and all ran into an error

You'll need to select a wider filter type first (see the bottom of the snippet in my previous post). The default is uint16_t, so if you have 14 bits of precision, that leaves only 2 bits for filtering. If you use uint32_t, you can set the filter shift factor much higher.