Add methods to adjust pads sensitivity

Author: ffont

README.md

@@ -140,15 +140,13 @@ to each pad as defined in [Push 2 MIDI and Display Interface Manual](https://git
 Pad and button colors can be set using methods provided by the `Push2` object. For example you can set pad colors using the following code:
 
 ```python
-push = push2_python.Push2() 
 pad_ij = (0, 3)  # Fourth pad of the top row
 push.pads.set_pad_color(pad_ij, 'green')
 ```
 
 You set button colors in a similar way:
 
 ```python
-push = push2_python.Push2() 
 push.buttons.set_button_color(push2_python.constants.BUTTON_PLAY, 'green')
 ```
 
@@ -158,6 +156,18 @@ All pads support RGB colors, and some buttons do as well. However, some buttons
 For a list of avilable RGB colors check the `DEFAULT_COLOR_PALETTE` dictionary in [push2_python/constants.py](https://github.com/ffont/push2-python/blob/master/push2_python/constants.py). First item of each color entry corresponds to the RGB color name while second item corresponds to the BW color name. The color palette can be customized using the `set_color_palette_entry`, `update_rgb_color_palette_entry` and `reapply_color_palette` of Push2 object. See the documentation of these methods for more details.
 
 
+### Adjust pad sensitivity
+
+`push2-python` implements methods to adjust Push2 pads sensitivity, in particualr it incorporates methods to adjust the velocity curve (which applies to
+note on velocities and to poolyphonic aftertouch sensistivity), and the channel aftertouch range. You can do that using the methods `set_channel_aftertouch_range` 
+and `set_velocity_curve` from the `pads` section. Below are two examples of adjusting sensitivity. Please check methods' documentation for more information.
+
+```python
+push.pads.set_channel_aftertouch_range(range_start=401, range_end=800)  # Configure channel after touch to be quite sensitive
+push.pads.set_velocity_curve(velocities=[int(i * 127/40) if i < 40 else 127 for i in range(0,128)])  # Map full velocity range to the first 40 pressure values
+```
+
+
 ### Interface with the display
 
 You interface with Push2's display by senidng frames to be display using the `push.display.display_frame` method as follows:

push2_python/pads.py

@@ -61,6 +61,36 @@ def set_channel_aftertouch(self):
         msg = mido.Message.from_bytes(PUSH2_SYSEX_PREFACE_BYTES + [0x1E, 0x00] + PUSH2_SYSEX_END_BYTES)
         self.push.send_midi_to_push(msg)
 
+
+    def set_channel_aftertouch_range(self, range_start=401, range_end=2048):
+        """Configures the sensitivity of channel aftertouch by defining at what "range start" pressure value the aftertouch messages
+        start to be triggered and what "range end" pressure value corresponds to the aftertouch value 127. I'm not sure about the meaning
+        of the pressure values, but according to the documentation must be between 400 and 2048.
+        See https://github.com/Ableton/push-interface/blob/master/doc/AbletonPush2MIDIDisplayInterface.asc#282-pad-parameters
+        """
+        assert type(range_start) == int and type(range_end) == int, "range_start and range_end must be int"
+        assert range_start < range_end, "range_start must be lower than range_end"
+        assert 400 < range_start < range_end, "wrong range_start value, must be in range [401, range_end]"
+        assert range_start < range_end <= 2048, "wrong range_end value, must be in range [range_start + 1, 2048]"
+        lower_range_bytes = [range_start % 2**7, range_start // 2**7]
+        upper_range_bytes = [range_end % 2**7, range_end // 2**7]
+        msg = mido.Message.from_bytes(PUSH2_SYSEX_PREFACE_BYTES + [0x1B, 0x00, 0x00, 0x00, 0x00] + lower_range_bytes + upper_range_bytes + PUSH2_SYSEX_END_BYTES)
+        self.push.send_midi_to_push(msg)
+
+
+    def set_velocity_curve(self, velocities):
+        """Configures Push pad's velocity curve which will determine i) the velocity values triggered when pressing pads; and ii) the
+        sensitivity of the aftertouch when in polyphonic aftertouch mode. Push uses a map of physical pressure values [0g..4095g]
+        to MIDI velocity values [0..127]. This map is quantized into 128 steps which Push then interpolates. This method expects a list of 
+        128 velocity values which will be assigned to each of the 128 quantized steps of the physical pressure range [0g..4095g].
+        See hhttps://github.com/Ableton/push-interface/blob/master/doc/AbletonPush2MIDIDisplayInterface.asc#281-velocity-curve
+        """
+        assert type(velocities) == list and len(velocities) == 128 and type(velocities[0] == int), "velocities must be a list with 128 int values"
+        for start_index in range(0, 128, 16):
+            msg = mido.Message.from_bytes(PUSH2_SYSEX_PREFACE_BYTES + [0x20] + [start_index] + velocities[start_index:start_index + 16] + PUSH2_SYSEX_END_BYTES)
+            self.push.send_midi_to_push(msg)
+
+
     def pad_ij_to_pad_n(self, i, j):
         return pad_ij_to_pad_n(i, j)