Add dead zone to knobs

software/firmware/europi.py

@@ -128,42 +128,54 @@ class AnalogueReader:
     not need to be used by user scripts.
     """
 
-    def __init__(self, pin, samples=DEFAULT_SAMPLES):
+    def __init__(self, pin, samples=DEFAULT_SAMPLES, deadzone=0.0):
         self.pin_id = pin
         self.pin = ADC(Pin(pin))
         self.set_samples(samples)
+        self.set_deadzone(deadzone)
 
     def _sample_adc(self, samples=None):
         # Over-samples the ADC and returns the average.
-        values = []
+        value = 0
         for _ in range(samples or self._samples):
-            values.append(self.pin.read_u16())
-        return round(sum(values) / len(values))
+            value += self.pin.read_u16()
+        return round(value / (samples or self._samples))
 
     def set_samples(self, samples):
         """Override the default number of sample reads with the given value."""
         if not isinstance(samples, int):
             raise ValueError(f"set_samples expects an int value, got: {samples}")
         self._samples = samples
 
-    def percent(self, samples=None):
-        """Return the percentage of the component's current relative range."""
-        return self._sample_adc(samples) / MAX_UINT16
+    def set_deadzone(self, deadzone):
+        """Override the default deadzone with the given value."""
+        if not isinstance(deadzone, float):
+            raise ValueError(f"set_deadzone expects an float value, got: {deadzone}")
+        self._deadzone = deadzone
 
-    def range(self, steps=100, samples=None):
+    def percent(self, samples=None, deadzone=None):
+        """Return the percentage of the component's current relative range."""
+        dz = self._deadzone
+        if deadzone is not None:
+            dz = deadzone
+        value = self._sample_adc(samples) / MAX_UINT16
+        value = value * (1.0 + 2.0 * dz) - dz
+        return clamp(value, 0.0, 1.0)
+
+    def range(self, steps=100, samples=None, deadzone=None):
         """Return a value (upper bound excluded) chosen by the current voltage value."""
         if not isinstance(steps, int):
             raise ValueError(f"range expects an int value, got: {steps}")
-        percent = self.percent(samples)
+        percent = self.percent(samples, deadzone)
         if int(percent) == 1:
             return steps - 1
         return int(percent * steps)
 
-    def choice(self, values, samples=None):
+    def choice(self, values, samples=None, deadzone=None):
         """Return a value from a list chosen by the current voltage value."""
         if not isinstance(values, list):
             raise ValueError(f"choice expects a list, got: {values}")
-        percent = self.percent(samples)
+        percent = self.percent(samples, deadzone)
         if percent == 1.0:
             return values[-1]
         return values[int(percent * len(values))]
@@ -238,6 +250,11 @@ class Knob(AnalogueReader):
     method, which will then be used on all analogue read calls for that
     component.
 
+    An optional ``deadzone`` parameter can be used to place deadzones at both
+    positions (all the way left and right) of the knob to make sure the full range
+    is available on all builds. The default value is 0.01 (resulting in 1% of the
+    travel used as deadzone on each side). There is usually no need to change this.
+
     Additionally, the ``choice()`` method can be used to select a value from a
     list of values based on the knob's position::
 
@@ -254,17 +271,17 @@ def clock_division(self):
     would only return values which go up in steps of 2.
     """
 
-    def __init__(self, pin):
-        super().__init__(pin)
+    def __init__(self, pin, deadzone=0.01):
+        super().__init__(pin, deadzone=deadzone)
 
-    def percent(self, samples=None):
+    def percent(self, samples=None, deadzone=None):
         """Return the knob's position as relative percentage."""
         # Reverse range to provide increasing range.
-        return 1 - (self._sample_adc(samples) / MAX_UINT16)
+        return 1.0 - super().percent(samples, deadzone)
 
-    def read_position(self, steps=100, samples=None):
+    def read_position(self, steps=100, samples=None, deadzone=None):
         """Returns the position as a value between zero and provided integer."""
-        return self.range(steps, samples)
+        return self.range(steps, samples, deadzone)
 
 
 class DigitalReader:
@@ -298,7 +315,7 @@ def _bounce_wrapper(self, pin):
                 return
             self.last_rising_ms = time.ticks_ms()
             return self._rising_handler()
-        elif self.value() == LOW:
+        else:
             if time.ticks_diff(time.ticks_ms(), self.last_falling_ms) < self.debounce_delay:
                 return
             self.last_falling_ms = time.ticks_ms()