supports changing hue, saturation and brightness for some backlight modes

Author: xiongyihui

keyboard/__init__.py

@@ -515,6 +515,20 @@ def run(self):
                         elif kind == ACT_BACKLIGHT:
                             if action_code == RGB_MOD:
                                 self.backlight.next()
+                            elif action_code == RGB_TOGGLE:
+                                self.backlight.toggle()
+                            elif action_code == RGB_HUE:
+                                self.backlight.hue += 8
+                            elif action_code == HUE_RGB:
+                                self.backlight.hue -= 8
+                            elif action_code == RGB_SAT:
+                                self.backlight.sat += 8
+                            elif action_code == SAT_RGB:
+                                self.backlight.sat -= 8
+                            elif action_code == RGB_VAL:
+                                self.backlight.val += 8
+                            elif action_code == VAL_RGB:
+                                self.backlight.val -= 8
                         elif kind == ACT_COMMAND:
                             if action_code == BOOTLOADER:
                                 reset_into_bootloader()

keyboard/model/backlight.py

@@ -1,6 +1,8 @@
 class Backlight:
     def __init__(self):
-        pass
+        self.hue = 0
+        self.sat = 255
+        self.val = 255
 
     def on(self, r=0xFF, g=0xFF, b=0xFF):
         pass
@@ -32,3 +34,5 @@ def next(self):
     def handle_key(self, key, pressed):
         pass
 
+    def toggle(self):
+        pass

keyboard/model/is32fl3733.py

@@ -60,21 +60,38 @@ def setup(self):
         self.set_brightness(255)
 
     def set_brightness(self, n):
+        n &= 0xFF
+        self._brightness = n
         if not self.power.value:
             self.power.value = 1
 
         # Global Current Control register (0x01) of page 3
         self.page(3)
         self.write(1, n)
 
+    @property
+    def brightness(self):
+        return self._brightness
+
+    @brightness.setter
+    def brightness(self, n):
+        self.set_brightness(n)
+
+    def clear(self):
+        pixels = self.pixels
+        for i in range(192):
+            pixels[i] = 0
+
     def pixel(self, i, r, g, b):
+        """Set the pixel. It takes effect after calling update()"""
         row = i >> 4  # i // 16
         col = i & 15  # i % 16
         self.pixels[row * 48 + col] = g
         self.pixels[row * 48 + 16 + col] = r
         self.pixels[row * 48 + 32 + col] = b
 
     def update_pixel(self, i, r, g, b):
+        """Set the pixel and update"""
         row = i >> 4  # i // 16
         col = i & 15  # i % 16
         self.pixels[row * 48 + col] = g

keyboard/model/m60.py

@@ -73,19 +73,46 @@ def battery_level():
     64, 64, 64, 64, 64, 64, 64, 64, 64, 64
 ))
 
+
+def hsv_to_rgb(h, s, v):
+    i = (h * 6) >> 8
+    f = (h * 6) & 0xFF
+
+    p = (v * (256 - s)) >> 8
+    q = (v * (65536 - s * f)) >> 16
+    t = (v * (65536 - s * (256 - f))) >> 16
+
+    if i == 0: return (v, t, p)
+    if i == 1: return (q, v, p)
+    if i == 2: return (p, v, t)
+    if i == 3: return (p, q, v)
+    if i == 4: return (t, p, v)
+    return (v, p, q)
+
 
-def to_rgb(h, s, v):
+def wheel(h):
+    i = (h * 3) >> 8
+    a = (h * 3) & 0xFF
+    b = 255 - a
+
+    if i == 0: return (b, a, 0)
+    if i == 1: return (0, b, a)
+
+    return (a, 0, b)
+
+
+def wheel2(h, v):
     i = (h * 3) >> 8
-    o = (h * 3) & 0xFF
+    a = (h * 3) & 0xFF
+    b = 255 - a
 
-    f = v * (255 - s) // 255
-    a = f + ((v - f) * o) >> 8
-    b = f + ((v - f) * (256 - o)) >> 8
+    a = a * v // 255
+    b = b * v // 255
 
-    if i == 0: return (b, a, f)
-    if i == 1: return (f, b, a)
+    if i == 0: return (b, a, 0)
+    if i == 1: return (0, b, a)
 
-    return (a, f, b)
+    return (a, 0, b)
 
 
 class Backlight:
@@ -95,6 +122,7 @@ def __init__(self):
         self._bt_led = None
         self.pixel = self.dev.pixel
 
+        self.enabled = True
         self.hsv = [0, 255, 255]
         self.keys = {}
         self.n = 0
@@ -104,29 +132,73 @@ def __init__(self):
         self.mode_function = self.modes[self.mode]
         self.dynamic = True
 
+    @property
+    def hue(self):
+        return self.hsv[0]
+
+    @hue.setter
+    def hue(self, h):
+        self.hsv[0] = h & 0xFF
+        if not self.dynamic:
+            self.mode_function()
+
+    @property
+    def sat(self):
+        return self.hsv[1]
+
+    @sat.setter
+    def sat(self, s):
+        self.hsv[1] = 0 if s < 0 else (255 if s > 255 else s)
+        if not self.dynamic:
+            self.mode_function()
+
+    @property
+    def val(self):
+        return self.dev.brightness
+
+    @val.setter
+    def val(self, v):
+        self.set_brightness(v)
+
+    def set_brightness(self, v):
+        if v <= 0:
+            self.enabled = False
+            self.off()
+        else:
+            self.enabled = True
+            self.dev.brightness = v if v < 0xFF else 0xFF
+            if not self.dynamic:
+                self.mode_function()
+
     def on(self, r=0xFF, g=0xFF, b=0xFF):
         for i in range(63):
             self.pixel(i, r, g, b)
         self.update()
 
     def off(self):
-        for i in range(64):
-            self.pixel(i, 0, 0, 0)
+        self.dev.clear()
         self.update()
 
+    def toggle(self):
+        self.enabled = not self.enabled
+        if self.enabled:
+            self.set_mode(self.mode)
+        else:
+            self.off()
+
     def mono(self):
-        self.on(*to_rgb(*self.hsv))
+        self.on(*hsv_to_rgb(*self.hsv))
 
     def gradient(self):
         h0, s0, v0 = self.hsv
         for i in range(63):
             h = (leds_y[i] + h0) & 0xFF
-            self.pixel(i, *to_rgb(h, s0, v0))
+            self.pixel(i, *hsv_to_rgb(h, s0, v0))
         self.update()
 
     def spectrum(self, offset=0):
         self.n = (self.n + 1) & 0xFF
-        r, g, b = to_rgb(self.n, 255, 255)
+        r, g, b = wheel(self.n)
         for i in range(63):
             self.pixel(i, r, g, b)
         self.update()
@@ -136,7 +208,7 @@ def spectrum_x(self):
         n = self.n
         for i in range(63):
             h = (leds_x[i] + n) & 0xFF
-            self.pixel(i, *to_rgb(h, 255, 255))
+            self.pixel(i, *wheel(h))
         self.update()
         self.n = (n + 1) & 0xFF
         return True
@@ -145,21 +217,21 @@ def spectrum_y(self):
         n = self.n
         for i in range(63):
             h = (leds_y[i] + n) & 0xFF
-            self.pixel(i, *to_rgb(h, 255, 255))
+            self.pixel(i, *wheel(h))
         self.update()
         self.n = (n + 1) & 0xFF
         return True
 
     def handle_key(self, key, pressed):
-        if self.mode == 6:
+        if self.enabled and self.mode == 6:
             self.keys[key] = 255
 
     def elapse(self):
         if 0 == len(self.keys):
             return False
         for i in self.keys.keys():
             t = self.keys[i]
-            self.pixel(i, *to_rgb(255 - t, 255, t))
+            self.pixel(i, *wheel2(255 - t, t))
             t -= 1
             if t < 0:
                 self.keys.pop(i)
@@ -168,9 +240,6 @@ def elapse(self):
         self.update()
         return True
 
-    def set_brightness(self, v):
-        self.dev.set_brightness(v)
-
     def set_hid_leds(self, v):
         self._hid_leds = v
         if self._hid_leds & 2:
@@ -205,13 +274,12 @@ def update(self):
             self.dev.power.value = 0
 
     def check(self):
-        if self.dynamic:
+        if self.enabled and self.dynamic:
             return self.mode_function()
         return False
 
     def next(self):
-        for i in range(63):
-            self.pixel(i, 0, 0, 0)
+        self.dev.clear()
         self.mode += 1
         if self.mode >= len(self.modes):
             self.mode = 0
@@ -223,3 +291,14 @@ def next(self):
         else:
             self.dynamic = False
             self.mode_function()
+
+    def set_mode(self, mode):
+        self.mode =  mode if mode < len(self.modes) else 0
+        self.mode_function = self.modes[self.mode]
+        if self.mode == 6:
+            self.keys.clear()
+        if self.mode >= 3:
+            self.dynamic = True 
+        else:
+            self.dynamic = False
+            self.mode_function()