cleanup

kmk/extensions/led.py

@@ -190,28 +190,28 @@ class LED(Extension):
         else:
             self.off()
 
-    def _key_led_tog(self, key, state, *args, **kwargs):
+    def _key_led_tog(self, *args, **kwargs):
         if self.animation_mode == AnimationModes.STATIC_STANDBY:
             self.animation_mode = AnimationModes.STATIC
 
         self._enabled = not self._enabled
 
-    def _key_led_inc(self, key, state, *args, **kwargs):
+    def _key_led_inc(self, *args, **kwargs):
         self.increase_brightness()
 
-    def _key_led_dec(self, key, state, *args, **kwargs):
+    def _key_led_dec(self, *args, **kwargs):
         self.decrease_brightness()
 
-    def _key_led_ani(self, key, state, *args, **kwargs):
+    def _key_led_ani(self, *args, **kwargs):
         self.increase_ani()
 
-    def _key_led_and(self, key, state, *args, **kwargs):
+    def _key_led_and(self, *args, **kwargs):
         self.decrease_ani()
 
-    def _key_led_mode_static(self, key, state, *args, **kwargs):
+    def _key_led_mode_static(self, *args, **kwargs):
         self._effect_init = True
         self.animation_mode = AnimationModes.STATIC
 
-    def _key_led_mode_breathe(self, key, state, *args, **kwargs):
+    def _key_led_mode_breathe(self, *args, **kwargs):
         self._effect_init = True
         self.animation_mode = AnimationModes.BREATHING

kmk/extensions/rgb.py

@@ -160,13 +160,7 @@ class RGB(Extension):
         return
 
     def after_hid_send(self, sandbox):
-        if self.animation_mode:
+        self.animate()
-            self.loopcounter += 1
-            if self.loopcounter >= 7:
-                self.animate()
-                self.loopcounter = 0
-
-        return
 
     def on_powersave_enable(self, sandbox):
         return
@@ -426,25 +420,30 @@ class RGB(Extension):
         if self.effect_init:
             self._init_effect()
 
-        if self.enable:
+        if self.animation_mode is not AnimationModes.STATIC_STANDBY:
-            if self.animation_mode == AnimationModes.BREATHING:
+            self.loopcounter += 1
-                return self.effect_breathing()
+            if self.loopcounter >= 7 and self.enable:
-            elif self.animation_mode == AnimationModes.RAINBOW:
+                self.loopcounter = 0
-                return self.effect_rainbow()
+                if self.animation_mode == AnimationModes.BREATHING:
-            elif self.animation_mode == AnimationModes.BREATHING_RAINBOW:
+                    self.effect_breathing()
-                return self.effect_breathing_rainbow()
+                elif self.animation_mode == AnimationModes.RAINBOW:
-            elif self.animation_mode == AnimationModes.STATIC:
+                    self.effect_rainbow()
-                return self.effect_static()
+                elif self.animation_mode == AnimationModes.BREATHING_RAINBOW:
-            elif self.animation_mode == AnimationModes.KNIGHT:
+                    self.effect_breathing_rainbow()
-                return self.effect_knight()
+                elif self.animation_mode == AnimationModes.STATIC:
-            elif self.animation_mode == AnimationModes.SWIRL:
+                    self.effect_static()
-                return self.effect_swirl()
+                elif self.animation_mode == AnimationModes.KNIGHT:
-            elif self.animation_mode == AnimationModes.USER:
+                    self.effect_knight()
-                return self.user_animation(self)
+                elif self.animation_mode == AnimationModes.SWIRL:
-            elif self.animation_mode == AnimationModes.STATIC_STANDBY:
+                    self.effect_swirl()
-                pass
+                elif self.animation_mode == AnimationModes.USER:
-        else:
+                    self.user_animation(self)
-            self.off()
+                elif self.animation_mode == AnimationModes.STATIC_STANDBY:
+                    pass
+                else:
+                    self.off()
+                if self.loopcounter >= 7:
+                    self.loopcounter = 0
 
     def _animation_step(self):
         interval = self.time_ms() - self.time
@@ -533,64 +532,66 @@ class RGB(Extension):
         self.disable_auto_write = False  # Resume showing changes
         self.show()
 
-    def _rgb_tog(self, key, state, *args, **kwargs):
+    def _rgb_tog(self, *args, **kwargs):
         if self.animation_mode == AnimationModes.STATIC:
             self.animation_mode = AnimationModes.STATIC_STANDBY
             self._do_update()
         if self.animation_mode == AnimationModes.STATIC_STANDBY:
             self.animation_mode = AnimationModes.STATIC
             self._do_update()
+        if self.enable:
+            self.off()
         self.enable = not self.enable
 
-    def _rgb_hui(self, key, state, *args, **kwargs):
+    def _rgb_hui(self, *args, **kwargs):
         self.increase_hue()
 
-    def _rgb_hud(self, key, state, *args, **kwargs):
+    def _rgb_hud(self, *args, **kwargs):
         self.decrease_hue()
 
-    def _rgb_sai(self, key, state, *args, **kwargs):
+    def _rgb_sai(self, *args, **kwargs):
         self.increase_sat()
 
-    def _rgb_sad(self, key, state, *args, **kwargs):
+    def _rgb_sad(self, *args, **kwargs):
         self.decrease_sat()
 
-    def _rgb_vai(self, key, state, *args, **kwargs):
+    def _rgb_vai(self, *args, **kwargs):
         self.increase_val()
 
-    def _rgb_vad(self, key, state, *args, **kwargs):
+    def _rgb_vad(self, *args, **kwargs):
         self.decrease_val()
 
-    def _rgb_ani(self, key, state, *args, **kwargs):
+    def _rgb_ani(self, *args, **kwargs):
         self.increase_ani()
 
-    def _rgb_and(self, key, state, *args, **kwargs):
+    def _rgb_and(self, *args, **kwargs):
         self.decrease_ani()
 
-    def _rgb_mode_static(self, key, state, *args, **kwargs):
+    def _rgb_mode_static(self, *args, **kwargs):
         self.effect_init = True
         self.animation_mode = AnimationModes.STATIC
 
-    def _rgb_mode_breathe(self, key, state, *args, **kwargs):
+    def _rgb_mode_breathe(self, *args, **kwargs):
         self.effect_init = True
         self.animation_mode = AnimationModes.BREATHING
 
-    def _rgb_mode_breathe_rainbow(self, key, state, *args, **kwargs):
+    def _rgb_mode_breathe_rainbow(self, *args, **kwargs):
         self.effect_init = True
         self.animation_mode = AnimationModes.BREATHING_RAINBOW
 
-    def _rgb_mode_rainbow(self, key, state, *args, **kwargs):
+    def _rgb_mode_rainbow(self, *args, **kwargs):
         self.effect_init = True
         self.animation_mode = AnimationModes.RAINBOW
 
-    def _rgb_mode_swirl(self, key, state, *args, **kwargs):
+    def _rgb_mode_swirl(self, *args, **kwargs):
         self.effect_init = True
         self.animation_mode = AnimationModes.SWIRL
 
-    def _rgb_mode_knight(self, key, state, *args, **kwargs):
+    def _rgb_mode_knight(self, *args, **kwargs):
         self.effect_init = True
         self.animation_mode = AnimationModes.KNIGHT
 
-    def _rgb_reset(self, key, state, *args, **kwargs):
+    def _rgb_reset(self, *args, **kwargs):
         self.hue = self.hue_default
         self.sat = self.sat_default
         self.val = self.val_default

kmk/hid.py

@@ -2,12 +2,12 @@ import usb_hid
 from micropython import const
 
 from kmk.keys import FIRST_KMK_INTERNAL_KEY, ConsumerKey, ModifierKey
+from storage import getmount
 
 try:
     from adafruit_ble import BLERadio
     from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
     from adafruit_ble.services.standard.hid import HIDService
-    from storage import getmount
 except ImportError:
     # BLE not supported on this platform
     pass

kmk/kmk_keyboard.py

@@ -1,5 +1,3 @@
-import gc
-
 from kmk.consts import KMK_RELEASE, UnicodeMode
 from kmk.hid import BLEHID, USBHID, AbstractHID, HIDModes
 from kmk.keys import KC
@@ -109,8 +107,6 @@ class KMKKeyboard:
         if self.debug_enabled:
             if init:
                 print('KMKInit(release={})'.format(KMK_RELEASE))
-                gc.collect()
-
             print(self)
 
     def _send_hid(self):

kmk/modules/layers.py

@@ -84,22 +84,20 @@ class Layers(Module):
     def on_powersave_disable(self, keyboard):
         return
 
-    @staticmethod
+    def _df_pressed(self, key, keyboard, *args, **kwargs):
-    def _df_pressed(key, keyboard, *args, **kwargs):
         '''
         Switches the default layer
         '''
         keyboard.active_layers[-1] = key.meta.layer
 
-    @staticmethod
+    def _mo_pressed(self, key, keyboard, *args, **kwargs):
-    def _mo_pressed(key, keyboard, *args, **kwargs):
         '''
         Momentarily activates layer, switches off when you let go
         '''
         keyboard.active_layers.insert(0, key.meta.layer)
 
     @staticmethod
-    def _mo_released(key, keyboard, KC, *args, **kwargs):
+    def _mo_released(key, keyboard, *args, **kwargs):
         # remove the first instance of the target layer
         # from the active list
         # under almost all normal use cases, this will
@@ -149,8 +147,7 @@ class Layers(Module):
         self._mo_released(key, keyboard, *args, **kwargs)
         self.start_time[LayerType.LT] = None
 
-    @staticmethod
+    def _tg_pressed(self, key, keyboard, *args, **kwargs):
-    def _tg_pressed(key, keyboard, *args, **kwargs):
         '''
         Toggles the layer (enables it if not active, and vise versa)
         '''
@@ -161,8 +158,7 @@ class Layers(Module):
         except ValueError:
             keyboard.active_layers.insert(0, key.meta.layer)
 
-    @staticmethod
+    def _to_pressed(self, key, keyboard, *args, **kwargs):
-    def _to_pressed(key, keyboard, *args, **kwargs):
         '''
         Activates layer and deactivates all other layers
         '''
@@ -177,14 +173,13 @@ class Layers(Module):
             # Sets the timer start and acts like MO otherwise
             self.start_time[LayerType.TT] = accurate_ticks()
             self._mo_pressed(key, keyboard, *args, **kwargs)
-            return
         elif accurate_ticks_diff(
             accurate_ticks(), self.start_time[LayerType.TT], keyboard.tap_time
         ):
             self.start_time[LayerType.TT] = None
             self._tg_pressed(key, keyboard, *args, **kwargs)
             return
-        return None
+        return
 
     def _tt_released(self, key, keyboard, *args, **kwargs):
         if self.start_time[LayerType.TT] is None or not accurate_ticks_diff(

kmk/modules/power.py

@@ -45,8 +45,8 @@ class Power(Module):
     def before_matrix_scan(self, keyboard):
         return
 
-    def after_matrix_scan(self, keyboard, matrix_update):
+    def after_matrix_scan(self, keyboard):
-        if matrix_update or keyboard.secondary_matrix_update:
+        if keyboard.matrix_update or keyboard.secondary_matrix_update:
             self.psave_time_reset()
 
     def before_hid_send(self, keyboard):

user_keymaps/kdb424/luddite.py

@@ -19,7 +19,7 @@ BASE = 0
 GAMING = 1
 FN1 = 2
 
-rgb_ext = RGB(pixel_pin=keyboard.rgb_pixel_pin, num_pixels=keyboard.rgb_num_pixels)
+rgb_ext = RGB(pixel_pin=keyboard.rgb_pixel_pin, num_pixels=16)
 layers_ext = Layers()
 modtap = ModTap()
 

user_keymaps/kdb424/nyquist_r2.py

@@ -6,6 +6,7 @@ from kmk.handlers.sequences import send_string, simple_key_sequence
 from kmk.keys import KC
 from kmk.modules.layers import Layers
 from kmk.modules.modtap import ModTap
+from kmk.modules.split import Split
 
 keyboard = KMKKeyboard()
 
@@ -15,8 +16,9 @@ keyboard.tap_time = 150
 layers = Layers()
 modtap = ModTap()
 rgb_ext = RGB(pixel_pin=keyboard.rgb_pixel_pin, num_pixels=27, val_limit=100, hue_default=190, sat_default=100, val_default=5)
+split = Split(data_pin=keyboard.data_pin)
 
-keyboard.modules = [modtap, layers]
+keyboard.modules = [modtap, layers, split]
 keyboard.extensions = [rgb_ext]
 
 _______ = KC.TRNS