Refactor MatrixScanner to use enhanced Pins abstraction; add DEBUG_ENABLED to SAMD51 boards

kmk/common/abstract/matrix_scanner.py

@@ -1,9 +0,0 @@
-from kmk.common.consts import DiodeOrientation
-
-
-class AbstractMatrixScanner():
-    def __init__(self, cols, rows, active_layers, diode_orientation=DiodeOrientation.COLUMNS):
-        raise NotImplementedError('Abstract implementation')
-
-    def scan_for_pressed(self):
-        raise NotImplementedError('Abstract implementation')

kmk/common/consts.py

@@ -1,3 +1,7 @@
+CIRCUITPYTHON = 'CircuitPython'
+MICROPYTHON = 'MicroPython'
+
+
 class HIDReportTypes:
     KEYBOARD = 1
     MOUSE = 2

kmk/common/matrix.py

@@ -0,0 +1,57 @@
+import digitalio
+
+from kmk.common.consts import DiodeOrientation
+from kmk.common.event_defs import matrix_changed
+
+
+class MatrixScanner:
+    def __init__(self, cols, rows, diode_orientation=DiodeOrientation.COLUMNS):
+        # A pin cannot be both a row and column, detect this by combining the
+        # two tuples into a set and validating that the length did not drop
+        #
+        # repr() hackery is because CircuitPython Pin objects are not hashable
+        unique_pins = {repr(c) for c in cols} | {repr(r) for r in rows}
+        if len(unique_pins) != len(cols) + len(rows):
+            raise ValueError('Cannot use a pin as both a column and row')
+
+        self.cols = cols
+        self.rows = rows
+        self.diode_orientation = diode_orientation
+        self.last_pressed_len = 0
+
+        if self.diode_orientation == DiodeOrientation.COLUMNS:
+            self.outputs = self.cols
+            self.inputs = self.rows
+        elif self.diode_orientation == DiodeOrientation.ROWS:
+            self.outputs = self.rows
+            self.inputs = self.cols
+        else:
+            raise ValueError('Invalid DiodeOrientation: {}'.format(
+                self.diode_orientation,
+            ))
+
+        for pin in self.outputs:
+            pin.switch_to_output()
+
+        for pin in self.inputs:
+            pin.switch_to_input(pull=digitalio.Pull.DOWN)
+
+    def scan_for_pressed(self):
+        pressed = []
+
+        for oidx, opin in enumerate(self.outputs):
+            opin.value(True)
+
+            for iidx, ipin in enumerate(self.inputs):
+                if ipin.value():
+                    pressed.append(
+                        (oidx, iidx) if self.diode_orientation == DiodeOrientation.ROWS else (iidx, oidx)  # noqa
+                    )
+
+            opin.value(False)
+
+        if len(pressed) != self.last_pressed_len:
+            self.last_pressed_len = len(pressed)
+            return matrix_changed(pressed)
+
+        return None  # The default, but for explicitness

kmk/common/pins.py

@@ -1,18 +1,22 @@
+from micropython import const
+
+from kmk.common.consts import CIRCUITPYTHON, MICROPYTHON
+
+PULL_UP = const(1)
+PULL_DOWN = const(2)
+
+
 try:
     import board
+    import digitalio
 
-    PLATFORM = 'CircuitPython'
+    PLATFORM = CIRCUITPYTHON
     PIN_SOURCE = board
 except ImportError:
     import machine
 
-    PLATFORM = 'MicroPython'
+    PLATFORM = MICROPYTHON
     PIN_SOURCE = machine.Pin.board
-except ImportError:
-    from kmk.common.types import Passthrough
-
-    PLATFORM = 'Unit Testing'
-    PIN_SOURCE = Passthrough()
 
 
 def get_pin(pin):
@@ -32,9 +36,64 @@ def get_pin(pin):
     return getattr(PIN_SOURCE, pin)
 
 
+class AbstractedDigitalPin:
+    def __init__(self, pin):
+        self.raw_pin = pin
+
+        if PLATFORM == CIRCUITPYTHON:
+            self.pin = digitalio.DigitalInOut(pin)
+        elif PLATFORM == MICROPYTHON:
+            self.pin = machine.Pin(pin)
+        else:
+            self.pin = pin
+
+        self.call_value = callable(self.pin.value)
+
+    def __repr__(self):
+        return 'AbstractedPin({})'.format(repr(self.raw_pin))
+
+    def switch_to_input(self, pull=None):
+        if PLATFORM == CIRCUITPYTHON:
+            if pull == PULL_UP:
+                return self.pin.switch_to_input(pull=digitalio.Pull.UP)
+            elif pull == PULL_DOWN:
+                return self.pin.switch_to_input(pull=digitalio.Pull.DOWN)
+
+            return self.pin.switch_to_input(pull=pull)
+
+        elif PLATFORM == MICROPYTHON:
+            if pull == PULL_UP:
+                return self.pin.init(machine.Pin.IN, machine.Pin.PULL_UP)
+            elif pull == PULL_DOWN:
+                return self.pin.init(machine.Pin.IN, machine.Pin.PULL_DOWN)
+
+            raise ValueError('only PULL_UP and PULL_DOWN supported on MicroPython')
+
+        raise NotImplementedError('switch_to_input not supported on platform')
+
+    def switch_to_output(self):
+        if PLATFORM == CIRCUITPYTHON:
+            return self.pin.switch_to_output()
+        elif PLATFORM == MICROPYTHON:
+            return self.pin.init(machine.Pin.OUT)
+
+        raise NotImplementedError('switch_to_output not supported on platform')
+
+    def value(self, value=None):
+        if value is None:
+            if self.call_value:
+                return self.pin.value()
+            return self.pin.value
+
+        if self.call_value:
+            return self.pin.value(value)
+        self.pin.value = value
+        return value
+
+
 class PinLookup:
     def __getattr__(self, attr):
-        return get_pin(attr)
+        return AbstractedDigitalPin(get_pin(attr))
 
 
 Pin = PinLookup()