feat(led): 添加LED按键淡入淡出效果并重构LED条模块

添加了完整的LED效果系统架构，包括：
- 新增主题颜色定义文件theme_color.h
- 实现key fade LED效果算法，支持按键触发的渐变效果
- 创建LED效果注册机制和通用接口
- 配置17个LED像素与按键映射关系
- 将原有简单的周期性效果替换为基于按键事件的动态效果

CMakeLists.txt中添加了新的源文件路径和实现文件。

BREAKING CHANGE: LED效果从固定的周期性变化改为响应按键事件的动态效果。

CMakeLists.txt

@@ -10,6 +10,7 @@ include(nanopb)
 zephyr_include_directories(
   inc
   inc/events
+  src
 )
 add_subdirectory(drivers)
 
@@ -29,6 +30,8 @@ target_sources(app PRIVATE
   src/encoder_module.c
   src/hid_flowctrl_module.c
   src/keyboard_core_module.c
+  src/led_effect/led_effect_registry.c
+  src/led_effect/effects/led_effect_key_fade.c
   src/led_strip_module.c
   src/ui/ui_main.c
   src/cdc_wrapper_module.c

inc/theme_color.h

@@ -0,0 +1,24 @@
+#ifndef BLINKY_THEME_COLOR_H_
+#define BLINKY_THEME_COLOR_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BLINKY_THEME_DEFAULT_R 0x4CU
+#define BLINKY_THEME_DEFAULT_G 0x9EU
+#define BLINKY_THEME_DEFAULT_B 0xF5U
+
+struct theme_rgb {
+	uint8_t r;
+	uint8_t g;
+	uint8_t b;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BLINKY_THEME_COLOR_H_ */

src/display_module.c

@@ -16,6 +16,7 @@
 #include "bat_state_event.h"
 #include "hid_led_event.h"
 #include "mode_switch_event.h"
+#include "theme_color.h"
 #include "ui/ui_main.h"
 
 LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF);
@@ -30,7 +31,9 @@ static const struct device *const backlight_dev =
 	DEVICE_DT_GET(DT_PARENT(DT_ALIAS(backlight)));
 static const uint32_t backlight_idx = DT_NODE_CHILD_IDX(DT_ALIAS(backlight));
 static struct ui_main_model ui_model = {
-	.theme_color = LV_COLOR_MAKE(0x4C, 0x9E, 0xF5),
+	.theme_color = LV_COLOR_MAKE(BLINKY_THEME_DEFAULT_R,
+				    BLINKY_THEME_DEFAULT_G,
+				    BLINKY_THEME_DEFAULT_B),
 	.inactive_border_color = LV_COLOR_MAKE(0x3A, 0x44, 0x52),
 	.mode = MODE_SWITCH_BLE,
 };

src/led_effect/effects/led_effect_key_fade.c

@@ -0,0 +1,155 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <zephyr/sys/util.h>
+
+#include "led_effect/led_effect.h"
+
+#define KEY_FADE_LEVEL_MAX 255U
+#define KEY_FADE_STEP_PER_TICK 12U
+
+struct led_effect_key_fade_state {
+	const struct led_key_map *key_map;
+	size_t key_map_len;
+	size_t pixel_count;
+	uint8_t default_brightness;
+	uint8_t level[17];
+	struct theme_rgb theme;
+};
+
+static struct led_effect_key_fade_state key_fade_state;
+
+static const struct led_key_map *find_key(const struct led_effect *effect,
+					  uint16_t key_id)
+{
+	const struct led_effect_key_fade_state *state = effect->state;
+
+	for (size_t i = 0; i < state->key_map_len; i++) {
+		if (state->key_map[i].key_id == key_id) {
+			return &state->key_map[i];
+		}
+	}
+
+	return NULL;
+}
+
+static int led_effect_key_fade_init(struct led_effect *effect,
+				    const struct led_effect_config *cfg)
+{
+	struct led_effect_key_fade_state *state = effect->state;
+
+	if ((effect == NULL) || (cfg == NULL) || (cfg->key_map == NULL) ||
+	    (cfg->pixel_count > ARRAY_SIZE(state->level))) {
+		return -EINVAL;
+	}
+
+	memset(state, 0, sizeof(*state));
+	state->key_map = cfg->key_map;
+	state->key_map_len = cfg->key_map_len;
+	state->pixel_count = cfg->pixel_count;
+	state->default_brightness = cfg->default_brightness;
+	state->theme.r = BLINKY_THEME_DEFAULT_R;
+	state->theme.g = BLINKY_THEME_DEFAULT_G;
+	state->theme.b = BLINKY_THEME_DEFAULT_B;
+
+	return 0;
+}
+
+static void led_effect_key_fade_reset(struct led_effect *effect)
+{
+	struct led_effect_key_fade_state *state = effect->state;
+
+	memset(state->level, 0, sizeof(state->level));
+}
+
+static void led_effect_key_fade_set_theme(struct led_effect *effect,
+					  const struct theme_rgb *theme)
+{
+	struct led_effect_key_fade_state *state = effect->state;
+
+	if (theme == NULL) {
+		return;
+	}
+
+	state->theme = *theme;
+}
+
+static void led_effect_key_fade_on_key_press(struct led_effect *effect,
+					     uint16_t key_id)
+{
+	struct led_effect_key_fade_state *state = effect->state;
+	const struct led_key_map *map = find_key(effect, key_id);
+
+	if ((map == NULL) || (map->led_idx >= state->pixel_count)) {
+		return;
+	}
+
+	state->level[map->led_idx] =
+		(state->default_brightness == 0U) ? KEY_FADE_LEVEL_MAX :
+						    state->default_brightness;
+}
+
+static bool led_effect_key_fade_tick(struct led_effect *effect, uint32_t dt_ms,
+				     struct led_rgb *pixels, size_t pixel_count)
+{
+	struct led_effect_key_fade_state *state = effect->state;
+	bool active = false;
+	bool visible = false;
+	uint8_t decay;
+
+	ARG_UNUSED(dt_ms);
+
+	if ((pixels == NULL) || (pixel_count < state->pixel_count)) {
+		return false;
+	}
+
+	memset(pixels, 0, sizeof(*pixels) * pixel_count);
+	decay = KEY_FADE_STEP_PER_TICK;
+
+	for (size_t i = 0; i < state->pixel_count; i++) {
+		uint8_t level = state->level[i];
+
+		if (level == 0U) {
+			continue;
+		}
+
+		visible = true;
+		pixels[i].r = (uint8_t)(((uint16_t)state->theme.r * level) / 255U);
+		pixels[i].g = (uint8_t)(((uint16_t)state->theme.g * level) / 255U);
+		pixels[i].b = (uint8_t)(((uint16_t)state->theme.b * level) / 255U);
+
+		state->level[i] = (level > decay) ? (uint8_t)(level - decay) : 0U;
+		active = active || (state->level[i] > 0U);
+	}
+
+	return visible || active;
+}
+
+static bool led_effect_key_fade_is_active(const struct led_effect *effect)
+{
+	const struct led_effect_key_fade_state *state = effect->state;
+
+	for (size_t i = 0; i < state->pixel_count; i++) {
+		if (state->level[i] > 0U) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+static const struct led_effect_ops key_fade_ops = {
+	.init = led_effect_key_fade_init,
+	.reset = led_effect_key_fade_reset,
+	.set_theme = led_effect_key_fade_set_theme,
+	.on_key_press = led_effect_key_fade_on_key_press,
+	.tick = led_effect_key_fade_tick,
+	.is_active = led_effect_key_fade_is_active,
+};
+
+struct led_effect led_effect_key_fade = {
+	.ops = &key_fade_ops,
+	.state = &key_fade_state,
+};

src/led_effect/led_effect.h

@@ -0,0 +1,50 @@
+#ifndef BLINKY_LED_EFFECT_H_
+#define BLINKY_LED_EFFECT_H_
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <zephyr/drivers/led_strip.h>
+
+#include "led_effect_types.h"
+#include "theme_color.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct led_effect;
+
+struct led_effect_config {
+	const struct led_key_map *key_map;
+	size_t key_map_len;
+	size_t pixel_count;
+	uint8_t default_brightness;
+};
+
+struct led_effect_ops {
+	int (*init)(struct led_effect *effect,
+		    const struct led_effect_config *cfg);
+	void (*reset)(struct led_effect *effect);
+	void (*set_theme)(struct led_effect *effect,
+			  const struct theme_rgb *theme);
+	void (*on_key_press)(struct led_effect *effect, uint16_t key_id);
+	bool (*tick)(struct led_effect *effect, uint32_t dt_ms,
+		     struct led_rgb *pixels, size_t pixel_count);
+	bool (*is_active)(const struct led_effect *effect);
+};
+
+struct led_effect {
+	const struct led_effect_ops *ops;
+	void *state;
+};
+
+const struct led_effect *led_effect_get(enum led_effect_id id);
+struct led_effect *led_effect_get_mutable(enum led_effect_id id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BLINKY_LED_EFFECT_H_ */

src/led_effect/led_effect_registry.c

@@ -0,0 +1,27 @@
+#include <stddef.h>
+
+#include "led_effect.h"
+
+extern struct led_effect led_effect_key_fade;
+
+static struct led_effect *const effect_registry[LED_EFFECT_ID_COUNT] = {
+	[LED_EFFECT_ID_KEY_FADE] = &led_effect_key_fade,
+};
+
+const struct led_effect *led_effect_get(enum led_effect_id id)
+{
+	if (id >= LED_EFFECT_ID_COUNT) {
+		return NULL;
+	}
+
+	return effect_registry[id];
+}
+
+struct led_effect *led_effect_get_mutable(enum led_effect_id id)
+{
+	if (id >= LED_EFFECT_ID_COUNT) {
+		return NULL;
+	}
+
+	return effect_registry[id];
+}

src/led_effect/led_effect_types.h

@@ -0,0 +1,24 @@
+#ifndef BLINKY_LED_EFFECT_TYPES_H_
+#define BLINKY_LED_EFFECT_TYPES_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct led_key_map {
+	uint16_t key_id;
+	uint8_t led_idx;
+};
+
+enum led_effect_id {
+	LED_EFFECT_ID_KEY_FADE = 0,
+	LED_EFFECT_ID_COUNT,
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BLINKY_LED_EFFECT_TYPES_H_ */

src/led_strip_module.c

@@ -5,8 +5,10 @@
 #include <app_event_manager.h>
 
 #define MODULE led_strip_module
+#include <caf/events/button_event.h>
 #include <caf/events/module_state_event.h>
 #include <caf/events/power_event.h>
+#include <caf/key_id.h>
 
 #include <zephyr/device.h>
 #include <zephyr/drivers/gpio.h>
@@ -14,44 +16,71 @@
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
 
+#include "led_effect/led_effect.h"
 #include "led_strip_en_event.h"
+#include "theme_color.h"
 
 LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF);
 
 #define LED_STRIP_NODE DT_CHOSEN(zephyr_led_strip)
 #define LED_STRIP_NUM_PIXELS DT_PROP(LED_STRIP_NODE, chain_length)
-#define LED_STRIP_EFFECT_INTERVAL K_MSEC(400)
+#define LED_STRIP_TICK_INTERVAL K_MSEC(20)
 
 BUILD_ASSERT(DT_NODE_HAS_STATUS(LED_STRIP_NODE, okay),
 	     "Missing zephyr,led-strip chosen node");
 BUILD_ASSERT(DT_NODE_HAS_PROP(LED_STRIP_NODE, supply_gpios),
 	     "Missing supply-gpios on zephyr,led-strip node");
+BUILD_ASSERT(LED_STRIP_NUM_PIXELS == 17U,
+	     "LED strip key map expects 17 pixels");
 
 static const struct device *const strip = DEVICE_DT_GET(LED_STRIP_NODE);
 static const struct gpio_dt_spec strip_en =
 	GPIO_DT_SPEC_GET(LED_STRIP_NODE, supply_gpios);
 
+static const struct led_key_map led_key_map[] = {
+	{ KEY_ID(0, 1), 0U },
+	{ KEY_ID(1, 1), 1U },
+	{ KEY_ID(2, 1), 2U },
+	{ KEY_ID(3, 1), 3U },
+	{ KEY_ID(0, 2), 4U },
+	{ KEY_ID(1, 2), 5U },
+	{ KEY_ID(2, 2), 6U },
+	{ KEY_ID(0, 3), 7U },
+	{ KEY_ID(1, 3), 8U },
+	{ KEY_ID(2, 3), 9U },
+	{ KEY_ID(3, 3), 10U },
+	{ KEY_ID(0, 4), 11U },
+	{ KEY_ID(1, 4), 12U },
+	{ KEY_ID(2, 4), 13U },
+	{ KEY_ID(0, 5), 14U },
+	{ KEY_ID(1, 5), 15U },
+	{ KEY_ID(3, 5), 16U },
+};
+
+static const struct led_effect_config effect_cfg = {
+	.key_map = led_key_map,
+	.key_map_len = ARRAY_SIZE(led_key_map),
+	.pixel_count = LED_STRIP_NUM_PIXELS,
+	.default_brightness = 0xFFU,
+};
+
 static struct led_rgb pixels[LED_STRIP_NUM_PIXELS];
 static struct k_work_delayable effect_work;
+static struct led_effect *effect;
+static struct theme_rgb current_theme = {
+	.r = BLINKY_THEME_DEFAULT_R,
+	.g = BLINKY_THEME_DEFAULT_G,
+	.b = BLINKY_THEME_DEFAULT_B,
+};
 static bool initialized;
 static bool running;
 static bool enabled = true;
-static uint8_t effect_step;
 
 static void clear_pixels(void)
 {
 	memset(pixels, 0, sizeof(pixels));
 }
 
-static void fill_pixels(uint8_t r, uint8_t g, uint8_t b)
-{
-	for (size_t i = 0; i < ARRAY_SIZE(pixels); i++) {
-		pixels[i].r = r;
-		pixels[i].g = g;
-		pixels[i].b = b;
-	}
-}
-
 static int submit_frame(void)
 {
 	int err;
@@ -76,38 +105,23 @@ static int set_strip_power(bool on)
 	return err;
 }
 
-static void render_effect_step(void)
+static int refresh_idle_frame(void)
 {
-	switch (effect_step) {
+	clear_pixels();
-	case 0U:
+	return submit_frame();
-		fill_pixels(0x40, 0x00, 0x00);
-		break;
-
-	case 1U:
-		fill_pixels(0x00, 0x40, 0x00);
-		break;
-
-	default:
-		fill_pixels(0x00, 0x00, 0x40);
-		break;
-	}
 }
 
-static void effect_work_handler(struct k_work *work)
+static void stop_effect_work(void)
 {
-	ARG_UNUSED(work);
+	k_work_cancel_delayable(&effect_work);
-
-	if (!running || !enabled) {
-		return;
 }
 
-	render_effect_step();
+static void schedule_effect_tick(k_timeout_t delay)
-	(void)submit_frame();
+{
-	effect_step = (uint8_t)((effect_step + 1U) % 3U);
+	k_work_reschedule(&effect_work, delay);
-	k_work_reschedule(&effect_work, LED_STRIP_EFFECT_INTERVAL);
 }
 
-static int enable_effect_output(void)
+static int enable_strip_output(void)
 {
 	int err;
 
@@ -116,24 +130,37 @@ static int enable_effect_output(void)
 		return err;
 	}
 
-	render_effect_step();
+	return refresh_idle_frame();
-	err = submit_frame();
-	if (err) {
-		return err;
 }
 
-	k_work_reschedule(&effect_work, LED_STRIP_EFFECT_INTERVAL);
+static void disable_strip_output(void)
-	return 0;
-}
-
-static void disable_effect_output(void)
 {
-	k_work_cancel_delayable(&effect_work);
+	stop_effect_work();
 	clear_pixels();
 	(void)submit_frame();
 	(void)set_strip_power(false);
 }
 
+static void effect_work_handler(struct k_work *work)
+{
+	bool keep_running;
+
+	ARG_UNUSED(work);
+
+	if (!running || !enabled || (effect == NULL)) {
+		return;
+	}
+
+	keep_running = effect->ops->tick(effect, k_ticks_to_ms_floor32(
+						 LED_STRIP_TICK_INTERVAL.ticks),
+					 pixels, ARRAY_SIZE(pixels));
+	(void)submit_frame();
+
+	if (keep_running) {
+		schedule_effect_tick(LED_STRIP_TICK_INTERVAL);
+	}
+}
+
 static int module_init(void)
 {
 	int err;
@@ -144,19 +171,32 @@ static int module_init(void)
 	}
 
 	if (!gpio_is_ready_dt(&strip_en)) {
-		LOG_ERR("LED strip EN GPIO not ready");
+		LOG_ERR("LED strip supply GPIO not ready");
 		return -ENODEV;
 	}
 
 	err = gpio_pin_configure_dt(&strip_en, GPIO_OUTPUT_INACTIVE);
 	if (err) {
-		LOG_ERR("Failed to configure LED strip EN (%d)", err);
+		LOG_ERR("Failed to configure LED strip supply GPIO (%d)", err);
 		return err;
 	}
 
 	k_work_init_delayable(&effect_work, effect_work_handler);
 	clear_pixels();
-	effect_step = 0U;
+
+	effect = led_effect_get_mutable(LED_EFFECT_ID_KEY_FADE);
+	if ((effect == NULL) || (effect->ops == NULL)) {
+		LOG_ERR("LED effect not available");
+		return -ENOENT;
+	}
+
+	err = effect->ops->init(effect, &effect_cfg);
+	if (err) {
+		LOG_ERR("LED effect init failed (%d)", err);
+		return err;
+	}
+
+	effect->ops->set_theme(effect, &current_theme);
 
 	LOG_INF("LED strip ready len:%u", (uint32_t)led_strip_length(strip));
 	return 0;
@@ -176,7 +216,7 @@ static int module_start(void)
 		return 0;
 	}
 
-	err = enable_effect_output();
+	err = enable_strip_output();
 	if (err) {
 		running = false;
 	}
@@ -190,10 +230,26 @@ static void module_pause(void)
 		return;
 	}
 
-	disable_effect_output();
+	if ((effect != NULL) && (effect->ops != NULL)) {
+		effect->ops->reset(effect);
+	}
+
+	disable_strip_output();
 	running = false;
 }
 
+static bool handle_button_event(const struct button_event *event)
+{
+	if (!running || !enabled || (effect == NULL) || !event->pressed) {
+		return false;
+	}
+
+	effect->ops->on_key_press(effect, event->key_id);
+	schedule_effect_tick(K_NO_WAIT);
+
+	return false;
+}
+
 static bool handle_led_strip_en_event(const struct led_strip_en_event *event)
 {
 	enabled = event->enabled;
@@ -203,13 +259,18 @@ static bool handle_led_strip_en_event(const struct led_strip_en_event *event)
 	}
 
 	if (enabled) {
-		int err = enable_effect_output();
+		int err = enable_strip_output();
 
 		if (err) {
 			module_set_state(MODULE_STATE_ERROR);
+			return false;
 		}
 	} else {
-		disable_effect_output();
+		if ((effect != NULL) && (effect->ops != NULL)) {
+			effect->ops->reset(effect);
+		}
+
+		disable_strip_output();
 	}
 
 	return false;
@@ -217,6 +278,10 @@ static bool handle_led_strip_en_event(const struct led_strip_en_event *event)
 
 static bool app_event_handler(const struct app_event_header *aeh)
 {
+	if (is_button_event(aeh)) {
+		return handle_button_event(cast_button_event(aeh));
+	}
+
 	if (is_led_strip_en_event(aeh)) {
 		return handle_led_strip_en_event(cast_led_strip_en_event(aeh));
 	}
@@ -275,6 +340,7 @@ static bool app_event_handler(const struct app_event_header *aeh)
 }
 
 APP_EVENT_LISTENER(MODULE, app_event_handler);
+APP_EVENT_SUBSCRIBE_EARLY(MODULE, button_event);
 APP_EVENT_SUBSCRIBE(MODULE, led_strip_en_event);
 APP_EVENT_SUBSCRIBE(MODULE, module_state_event);
 APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event);