Continue split refactor

kmk/transports/ble.py

@@ -5,7 +5,7 @@ from kmk.kmktime import check_deadline
 
 
 class BLE_UART:
-    def __init__(self, is_target, uart_interval=20):
+    def __init__(self, is_target=True, uart_interval=20):
         try:
             from adafruit_ble import BLERadio
             from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
@@ -58,7 +58,7 @@ class BLE_UART:
     def check_connection(self, keyboard):
         self._check_all_connections(keyboard)
 
-    def enable_powersave(self, enable=True):
+    def powersave(self, enable=True):
         if enable:
             if self._uart_connection and not self._psave_enable:
                 self._uart_connection.connection_interval = self._uart_interval
@@ -171,3 +171,11 @@ class BLE_UART:
     def ble_time_reset(self):
         '''Resets the rescan timer'''
         self._ble_last_scan = ticks_ms()
+
+    def receive(self, keyboard):
+        if self._uart is not None and self._uart.in_waiting > 0 or self._uart_buffer:
+            while self._uart.in_waiting >= 2:
+                update = self._deserialize_update(self._uart.read(2))
+                self._uart_buffer.append(update)
+            if self._uart_buffer:
+                keyboard.secondary_matrix_update = self._uart_buffer.pop(0)

kmk/transports/uart.py

@@ -0,0 +1,51 @@
+class UART:
+    def __init__(self, tx=None, rx=None, is_target=True, uart_interval=20):
+        self._debug_enabled = True
+        self._uart_connection = None
+        self._uart = None
+        self._uart_interval = uart_interval
+        self._is_target = is_target
+
+    @property
+    def in_waiting(self):
+        return self._uart.in_waiting
+
+    def read(self, n):
+        return self._uart.read(n)
+
+    def readinto(self, buf):
+        return self._uart.readinto(buf)
+
+    def powersave(enable: bool):
+        return
+
+    def write(self, buffer, update):
+        if self._uart is not None:
+            if not self._is_target or self.data_pin2:
+                update = self._serialize_update(update)
+                self._uart.write(self.uart_header)
+                self._uart.write(update)
+                self._uart.write(self._checksum(update))
+
+    def receive(self, keyboard):
+        if self._transport.in_waiting > 0 or self._uart_buffer:
+            if self._transport.in_waiting >= 60:
+                # This is a dirty hack to prevent crashes in unrealistic cases
+                # TODO See if this hack is needed with checksum, and if not, use
+                # that to fix it.
+                import microcontroller
+
+                microcontroller.reset()
+
+            while self._transport.in_waiting >= 4:
+                # Check the header
+                if self._transport.read(1) == self.uart_header:
+                    update = self._transport.read(2)
+
+                    # check the checksum
+                    if self._checksum(update) == self._transport.read(1):
+                        self._uart_buffer.append(self._deserialize_update(update))
+            if self._uart_buffer:
+                return self._uart_buffer.pop(0)
+
+        return None