massive cleanup

kmk/extensions/power.py

@@ -1,93 +1,144 @@
+import board
+import digitalio
+
 from kmk.extensions import Extension
+from kmk.handlers.stock import passthrough as handler_passthrough
+from kmk.keys import make_key
 from kmk.kmktime import sleep_ms, ticks_diff, ticks_ms
 
 
 class Power(Extension):
     def __init__(self, powersave_pin=None, enable=False, is_target=True):
         self.enable = enable
-        self.powersave_pin = powersave_pin
+        self.powersave_pin = powersave_pin  # Powersave pin board object
         self.is_target = is_target
         self._powersave_start = ticks_ms()
         self._usb_last_scan = ticks_ms() - 5000
-        self._psp = None
+        self._psp = None  # Powersave pin object
+        self._i2c = None
+
+        make_key(
+            names=('PS_TOG',), on_press=self._ps_tog, on_release=handler_passthrough
+        )
+        make_key(
+            names=('PS_ENB',), on_press=self._ps_enable, on_release=handler_passthrough
+        )
+        make_key(
+            names=('PS_DIS',), on_press=self._ps_disable, on_release=handler_passthrough
+        )
 
     def __repr__(self):
         return f'Power({self._to_dict()})'
 
     def _to_dict(self):
-        return f'Power( enable={self.enable} powersave_pin={self.powersave_pin} is_target={self.is_target} _powersave_start={self._powersave_start} _usb_last_scan={self._usb_last_scan} _psp={self._psp} )'
+        return f'''Power(
+        enable={self.enable}
+        powersave_pin={self.powersave_pin}
+        is_target={self.is_target}
+        _powersave_start={self._powersave_start}
+        _usb_last_scan={self._usb_last_scan}
+        _psp={self._psp} )
+        '''
+
+    def on_runtime_enable(self, keyboard):
+        return
+
+    def on_runtime_disable(self, keyboard):
+        self.disable_powersave
 
     def during_bootup(self, keyboard):
+        self._detect_i2c()
         self.enable = not bool(self.usb_scan)
 
-    def before_matrix_scan(self, keyboard_state):
+    def before_matrix_scan(self, keyboard):
         if self.usb_rescan_timer():
             self.enable = not bool(self.usb_scan)
 
-    def after_matrix_scan(self, keyboard_state, matrix_update):
+    def after_matrix_scan(self, keyboard, matrix_update):
         if matrix_update:
             self.psave_time_reset()
         else:
             self.psleep()
 
+    def before_hid_send(self, keyboard):
+        return
+
+    def after_hid_send(self, keyboard):
+        return
+
     def enable_powersave(self):
+        '''Enables power saving features'''
         print('Psave True')
         if self.powersave_pin:
-            import digitalio
-
             # Allows power save to prevent RGB drain.
             # Example here https://docs.nicekeyboards.com/#/nice!nano/pinout_schematic
+
             if not self._psp:
                 self._psp = digitalio.DigitalInOut(self.powersave_pin)
             self._psp.direction = digitalio.Direction.OUTPUT
             self._psp.value = True
-            # TODO Allow a hook to stop RGB/OLED to deinit or this causes a lockup
 
         self.enable = True
 
-        return self
-
     def disable_powersave(self):
+        '''Disables power saving features'''
         print('Psave False')
         if self.powersave_pin:
-            import digitalio
-
             # Allows power save to prevent RGB drain.
             # Example here https://docs.nicekeyboards.com/#/nice!nano/pinout_schematic
+
             if not self._psp:
                 self._psp = digitalio.DigitalInOut(self.powersave_pin)
             self._psp.direction = digitalio.Direction.OUTPUT
             self._psp.value = False
-            # TODO Allow a hook to stop RGB/OLED to reinit
 
         self.enable = False
 
-        return self
-
     def psleep(self):
         '''
         Sleeps longer and longer to save power the more time in between updates.
         '''
-        if ticks_diff(ticks_ms(), self.powersave_start) <= 20000 and self.is_target:
+        if ticks_diff(ticks_ms(), self._powersave_start) <= 20000 and self.is_target:
             sleep_ms(1)
-        elif ticks_diff(ticks_ms(), self.powersave_start) <= 40000 and self.is_target:
+        elif ticks_diff(ticks_ms(), self._powersave_start) <= 40000 and self.is_target:
             sleep_ms(4)
-        elif ticks_diff(ticks_ms(), self.powersave_start) <= 60000 and self.is_target:
+        elif ticks_diff(ticks_ms(), self._powersave_start) <= 60000 and self.is_target:
             sleep_ms(8)
-        elif ticks_diff(ticks_ms(), self.powersave_start) >= 240000:
+        elif ticks_diff(ticks_ms(), self._powersave_start) >= 240000:
             sleep_ms(250)
 
     def psave_time_reset(self):
-        self.powersave_start = ticks_ms()
-        return self
+        self._powersave_start = ticks_ms()
 
     def usb_rescan_timer(self):
-        return bool(ticks_diff(ticks_ms(), self.usb_last_scan) > 5000)
+        return bool(ticks_diff(ticks_ms(), self._usb_last_scan) > 5000)
 
     def usb_time_reset(self):
-        self.usb_last_scan = ticks_ms()
-        return self
+        self._usb_last_scan = ticks_ms()
 
     def usb_scan(self):
         # TODO Add USB detection here. Currently lies that it's connected
+        # https://github.com/adafruit/circuitpython/pull/3513
         return True
+
+    def _detect_i2c(self):
+        '''Detects i2c devices and disables cutting power to them'''
+        # TODO Figure out how this could deinit/reinit instead.
+        self._i2c = board.I2C()
+        devices = self._i2c.scan()
+        if devices != []:
+            self.powersave_pin = None
+
+    def _ps_tog(self):
+        if self.enable:
+            self.enable_powersave()
+        else:
+            self.disable_powersave()
+
+    def _ps_enable(self):
+        if not self.enable:
+            self.enable_powersave()
+
+    def _ps_disable(self):
+        if self.enable:
+            self.disable_powersave()