Prepare things for the event loop, also abstract gross stuff from end users

kmk/circuitpython/matrix.py

@@ -1,9 +1,10 @@
 import digitalio
 
+from kmk.common.abstract.matrix_scanner import AbstractMatrixScanner
 from kmk.common.consts import DiodeOrientation
 
 
-class MatrixScanner:
+class MatrixScanner(AbstractMatrixScanner):
     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
@@ -35,20 +36,7 @@ class MatrixScanner:
             pin.switch_to_input(pull=digitalio.Pull.DOWN)
 
     def _normalize_matrix(self, matrix):
-        '''
-        We always want to internally look at a keyboard as a list of rows,
-        where a "row" is a list of keycodes (columns).
-
-        This will convert DiodeOrientation.COLUMNS matrix scans into a
-        ROWS scan, so we never have to think about these things again.
-        '''
-        if self.diode_orientation == DiodeOrientation.ROWS:
-            return matrix
-
-        return [
-            [col[col_entry] for col in matrix]
-            for col_entry in range(max(len(col) for col in matrix))
-        ]
+        return super()._normalize_matrix(matrix)
 
     def raw_scan(self):
         matrix = []

kmk/circuitpython/util.py

@@ -1,7 +1,8 @@
+import sys
+import time
+
 import board
 import digitalio
-import time
-import sys
 
 
 def feather_signal_error_with_led_flash(rate=0.5):

kmk/common/abstract/matrix_scanner.py

@@ -0,0 +1,25 @@
+from kmk.common.consts import DiodeOrientation
+
+
+class AbstractMatrixScanner():
+    def __init__(self, cols, rows, diode_orientation=DiodeOrientation.COLUMNS):
+        raise NotImplementedError('Abstract implementation')
+
+    def _normalize_matrix(self, matrix):
+        '''
+        We always want to internally look at a keyboard as a list of rows,
+        where a "row" is a list of keycodes (columns).
+
+        This will convert DiodeOrientation.COLUMNS matrix scans into a
+        ROWS scan, so we never have to think about these things again.
+        '''
+        if self.diode_orientation == DiodeOrientation.ROWS:
+            return matrix
+
+        return [
+            [col[col_entry] for col in matrix]
+            for col_entry in range(max(len(col) for col in matrix))
+        ]
+
+    def raw_scan(self):
+        raise NotImplementedError('Abstract implementation')

kmk/common/keymap.py

@@ -10,9 +10,9 @@ class Keymap:
         for ridx, row in enumerate(matrix):
             for cidx, col in enumerate(row):
                 if col != self.state[ridx][cidx]:
-                    print('{}: {}'.format(
+                    yield '{}: {}'.format(
                         'KEYDOWN' if col else 'KEYUP',
                         self.map[ridx][cidx],
-                    ))
+                    )
 
         self.state = matrix

kmk/firmware.py

@@ -0,0 +1,18 @@
+from kmk.common.keymap import Keymap
+
+try:
+    from kmk.circuitpython.matrix import MatrixScanner
+except ImportError:
+    from kmk.micropython.matrix import MatrixScanner
+
+
+class Firmware:
+    def __init__(self, keymap, row_pins, col_pins, diode_orientation):
+        self.raw_keymap = keymap
+        self.keymap = Keymap(keymap)
+        self.matrix = MatrixScanner(col_pins, row_pins, diode_orientation)
+
+    def go(self):
+        while True:
+            for event in self.keymap.parse(self.matrix.raw_scan()):
+                print(event)