feat(underglow): per-key/layer RGB underglow

app/CMakeLists.txt

@@ -88,6 +88,9 @@ if ((NOT CONFIG_ZMK_SPLIT) OR CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
 endif()
 
 target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/behaviors/behavior_rgb_underglow.c)
+target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/behaviors/behavior_underglow_color.c)
+target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/behaviors/behavior_underglow_indicators.c)
+target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/events/underglow_color_changed.c)
 target_sources_ifdef(CONFIG_ZMK_BACKLIGHT app PRIVATE src/behaviors/behavior_backlight.c)
 
 target_sources_ifdef(CONFIG_ZMK_BATTERY_REPORTING app PRIVATE src/events/battery_state_changed.c)
@@ -102,6 +105,7 @@ add_subdirectory(src/split)
 target_sources_ifdef(CONFIG_USB_DEVICE_STACK app PRIVATE src/usb.c)
 target_sources_ifdef(CONFIG_ZMK_USB app PRIVATE src/usb_hid.c)
 target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/rgb_underglow.c)
+target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/rgb_underglow_layer.c)
 target_sources_ifdef(CONFIG_ZMK_BACKLIGHT app PRIVATE src/backlight.c)
 target_sources_ifdef(CONFIG_ZMK_LOW_PRIORITY_WORK_QUEUE app PRIVATE src/workqueue.c)
 target_sources(app PRIVATE src/main.c)

app/Kconfig

@@ -334,6 +334,10 @@ config ZMK_RGB_UNDERGLOW_AUTO_OFF_USB
     bool "Turn off RGB underglow when USB is disconnected"
     depends on USB_DEVICE_STACK
 
+config EXPERIMENTAL_RGB_LAYER
+    bool "Experimental per-key per-layer RGB underglow"
+    default n
+
 endif # ZMK_RGB_UNDERGLOW
 
 menuconfig ZMK_BACKLIGHT

app/dts/behaviors.dtsi

@@ -28,3 +28,5 @@
 #include <behaviors/soft_off.dtsi>
 #include <behaviors/studio_unlock.dtsi>
 #include <behaviors/mouse_keys.dtsi>
+#include <behaviors/ug_color.dtsi>
+#include <behaviors/ug_indicators.dtsi>

app/dts/behaviors/ug_color.dtsi

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+/ {
+    behaviors {
+        ug: ugcolor {
+            compatible = "zmk,behavior-underglow-color";
+            #binding-cells = <1>;
+            display-name = "Underglow Color";
+        };
+    };
+};

app/dts/behaviors/ug_indicators.dtsi

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <dt-bindings/zmk/hid_indicators.h>
+
+/ {
+    behaviors {
+        ug_nl: ugnumlk {
+            compatible = "zmk,behavior-underglow-indicators";
+            indicator = <NUM_LOCK>;
+            #binding-cells = <2>;
+            display-name = "Underglow NumLock indicator";
+        };
+
+        ug_cl: ugcapslk {
+            compatible = "zmk,behavior-underglow-indicators";
+            indicator = <CAPS_LOCK>;
+            #binding-cells = <2>;
+            display-name = "Underglow CapsLock indicator";
+        };
+
+        ug_sl: ugscrllk {
+            compatible = "zmk,behavior-underglow-indicators";
+            indicator = <SCROLL_LOCK>;
+            #binding-cells = <2>;
+            display-name = "Underglow ScrollLock indicator";
+        };
+
+    };
+};

app/dts/bindings/behaviors/zmk,behavior-underglow-color.yaml

@@ -0,0 +1,8 @@
+# Copyright (c) 2024, The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+description: Set underglow to specified color
+
+compatible: "zmk,behavior-underglow-color"
+
+include: one_param.yaml

app/dts/bindings/behaviors/zmk,behavior-underglow-indicators.yaml

@@ -0,0 +1,13 @@
+# Copyright (c) 2024, The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+description: Set underglow color based on HID indicators
+
+compatible: "zmk,behavior-underglow-indicators"
+
+include: two_param.yaml
+
+properties:
+  indicator:
+    type: int
+    default: 0

app/dts/bindings/zmk,underglow-layer.yaml

@@ -0,0 +1,25 @@
+#
+# Copyright (c) 2024 The ZMK Contributors
+#
+# SPDX-License-Identifier: MIT
+
+description: |
+  Allows defining a rgbmap composed of multiple layers
+
+compatible: "zmk,underglow-layer"
+
+properties:
+  pixel-lookup:
+    type: array
+    required: true
+
+child-binding:
+  description: "A layer to be used in a rgbmap"
+
+  properties:
+    bindings:
+      type: phandle-array
+      required: true
+    layer-id:
+      type: int
+      required: true

app/include/dt-bindings/zmk/hid_indicators.h

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define NUM_LOCK 0
+#define CAPS_LOCK 1
+#define SCROLL_LOCK 2

app/include/dt-bindings/zmk/rgb_colors.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define GREEN 0x00ff00
+#define RED 0xff0000
+#define BLUE 0x0000ff
+#define TEAL 0x008080
+#define ORANGE 0xffa500
+#define YELLOW 0xffff00
+#define GOLD 0xffd700
+#define PURPLE 0x800080
+#define PINK 0xffc0cb
+#define WHITE 0xffffff
+#define ___ 0x000000
+#define BLACK 0x000000

app/include/zmk/events/underglow_color_changed.h

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <zmk/event_manager.h>
+
+struct zmk_underglow_color_changed {};
+
+ZMK_EVENT_DECLARE(zmk_underglow_color_changed);

app/include/zmk/rgb_underglow_layer.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+#include <zmk/keymap.h>
+
+#define ZMK_RGB_CHILD_LEN_PLUS_ONE(node) 1 +
+
+#define ZMK_RGBMAP_LAYERS_LEN                                                                      \
+    (DT_FOREACH_CHILD(DT_INST(0, zmk_underglow_layer), ZMK_RGB_CHILD_LEN_PLUS_ONE) 0)
+
+#define ZMK_RGBMAP_EXTRACT_BINDING(idx, drv_inst)                                                  \
+    {                                                                                              \
+        .behavior_dev = DEVICE_DT_NAME(DT_PHANDLE_BY_IDX(drv_inst, bindings, idx)),                \
+        .param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(drv_inst, bindings, idx, param1), (0),        \
+                              (DT_PHA_BY_IDX(drv_inst, bindings, idx, param1))),                   \
+        .param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(drv_inst, bindings, idx, param2), (0),        \
+                              (DT_PHA_BY_IDX(drv_inst, bindings, idx, param2))),                   \
+    }
+
+const int rgb_pixel_lookup(int idx);
+const int zmk_rgbmap_id(uint8_t layer);
+const struct zmk_behavior_binding *rgb_underglow_get_bindings(uint8_t layer);
+
+uint8_t rgb_underglow_top_layer_with_state(uint32_t state_to_test);
+uint8_t rgb_underglow_top_layer(void);

app/src/behaviors/behavior_underglow_color.c

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_behavior_underglow_color
+
+// Dependencies
+#include <zephyr/device.h>
+#include <drivers/behavior.h>
+#include <zephyr/logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
+
+// Initialization Function
+static int underglow_color_init(const struct device *dev) { return 0; };
+
+static int underglow_color_process(struct zmk_behavior_binding *binding,
+                                   struct zmk_behavior_binding_event event) {
+    return binding->param1;
+}
+
+// API Structure
+static const struct behavior_driver_api underglow_color_driver_api = {
+    .binding_pressed = underglow_color_process,
+    .locality = BEHAVIOR_LOCALITY_GLOBAL,
+#if IS_ENABLED(CONFIG_ZMK_BEHAVIOR_METADATA)
+    .get_parameter_metadata = zmk_behavior_get_empty_param_metadata,
+#endif // IS_ENABLED(CONFIG_ZMK_BEHAVIOR_METADATA)
+
+};
+
+BEHAVIOR_DT_INST_DEFINE(0, underglow_color_init, NULL, NULL, NULL, POST_KERNEL,
+                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &underglow_color_driver_api);
+
+#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */

app/src/behaviors/behavior_underglow_indicators.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_behavior_underglow_indicators
+
+// Dependencies
+#include <zephyr/device.h>
+#include <drivers/behavior.h>
+#include <zephyr/logging/log.h>
+#include <zmk/hid_indicators.h>
+#include <zmk/event_manager.h>
+#include <zmk/events/hid_indicators_changed.h>
+#include <zmk/events/underglow_color_changed.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
+
+struct underglow_indicators_data {
+    zmk_hid_indicators_t indicators;
+};
+
+struct underglow_indicators_config {
+    int indicator;
+};
+
+static int underglow_indicators_init(const struct device *dev) { return 0; };
+
+static int underglow_indicators_process(struct zmk_behavior_binding *binding,
+                                        struct zmk_behavior_binding_event event) {
+    const struct device *dev = zmk_behavior_get_binding(binding->behavior_dev);
+    const struct underglow_indicators_data *data = dev->data;
+    const struct underglow_indicators_config *config = dev->config;
+
+    if (data->indicators & BIT(config->indicator))
+        return binding->param2;
+    else
+        return binding->param1;
+}
+
+static const struct behavior_driver_api underglow_indicators_driver_api = {
+    .binding_pressed = underglow_indicators_process,
+    .locality = BEHAVIOR_LOCALITY_GLOBAL,
+#if IS_ENABLED(CONFIG_ZMK_BEHAVIOR_METADATA)
+    .get_parameter_metadata = zmk_behavior_get_empty_param_metadata,
+#endif // IS_ENABLED(CONFIG_ZMK_BEHAVIOR_METADATA)
+};
+
+static int underglow_indicators_listener(const zmk_event_t *eh);
+
+ZMK_LISTENER(behavior_underglow_indicators, underglow_indicators_listener);
+ZMK_SUBSCRIPTION(behavior_underglow_indicators, zmk_hid_indicators_changed);
+
+static struct underglow_indicators_data underglow_indicators_data = {.indicators = 0};
+
+static int underglow_indicators_listener(const zmk_event_t *eh) {
+    const struct zmk_hid_indicators_changed *ev = as_zmk_hid_indicators_changed(eh);
+    underglow_indicators_data.indicators = ev->indicators;
+    raise_zmk_underglow_color_changed((struct zmk_underglow_color_changed){});
+
+    return ZMK_EV_EVENT_BUBBLE;
+}
+
+#define KP_INST(n)                                                                                 \
+    static struct underglow_indicators_config underglow_indicators_config_##n = {                  \
+        .indicator = DT_INST_PROP(n, indicator)};                                                  \
+    BEHAVIOR_DT_INST_DEFINE(n, underglow_indicators_init, NULL, &underglow_indicators_data,        \
+                            &underglow_indicators_config_##n, POST_KERNEL,                         \
+                            CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,                                   \
+                            &underglow_indicators_driver_api);
+
+DT_INST_FOREACH_STATUS_OKAY(KP_INST)
+
+#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */

app/src/events/underglow_color_changed.c

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <zephyr/kernel.h>
+#include <zmk/events/underglow_color_changed.h>
+
+ZMK_EVENT_IMPL(zmk_underglow_color_changed);