skiinder
ceebaaa600
添加了模块生命周期管理头文件 module_lifecycle.h，定义了完整的生命周期状态机， 包括初始化、运行、停止、挂起和错误状态。同时将电池模块、BLE BAS模块、BLE HID 模块和BLE NUS模块重构为使用新的生命周期框架进行状态管理。 提升日志缓冲区大小以支持更详细的调试信息记录。
371 lines
8.0 KiB
C
371 lines
8.0 KiB
C
#include <errno.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
|
|
#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>
|
|
#include <zephyr/drivers/led_strip.h>
|
|
#include <zephyr/kernel.h>
|
|
#include <zephyr/logging/log.h>
|
|
|
|
#include "led_effect/led_effect.h"
|
|
#include "led_strip_en_event.h"
|
|
#include "module_lifecycle.h"
|
|
#include "theme_rgb_update_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_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");
|
|
|
|
struct led_strip_module_ctx {
|
|
struct module_lifecycle_ctx lc;
|
|
const struct device *strip;
|
|
struct gpio_dt_spec strip_en;
|
|
struct led_rgb pixels[LED_STRIP_NUM_PIXELS];
|
|
struct k_work_delayable effect_work;
|
|
struct led_effect *effect;
|
|
struct theme_rgb current_theme;
|
|
bool enabled;
|
|
};
|
|
|
|
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 int do_init(void);
|
|
static int do_start(void);
|
|
static int do_stop(void);
|
|
|
|
static const struct module_lifecycle_cfg lifecycle_cfg = {
|
|
.mode = ML_MODE_POWER,
|
|
.stopped_state = MODULE_STATE_STANDBY,
|
|
};
|
|
|
|
static const struct module_lifecycle_ops lifecycle_ops = {
|
|
.do_init = do_init,
|
|
.do_start = do_start,
|
|
.do_stop = do_stop,
|
|
};
|
|
|
|
static struct led_strip_module_ctx ctx = {
|
|
.lc = {
|
|
.state = LC_UNINIT,
|
|
.cfg = &lifecycle_cfg,
|
|
.ops = &lifecycle_ops,
|
|
},
|
|
.strip = DEVICE_DT_GET(LED_STRIP_NODE),
|
|
.strip_en = GPIO_DT_SPEC_GET(LED_STRIP_NODE, supply_gpios),
|
|
.current_theme = {
|
|
.r = BLINKY_THEME_DEFAULT_R,
|
|
.g = BLINKY_THEME_DEFAULT_G,
|
|
.b = BLINKY_THEME_DEFAULT_B,
|
|
},
|
|
.enabled = true,
|
|
};
|
|
|
|
static void clear_pixels(void)
|
|
{
|
|
memset(ctx.pixels, 0, sizeof(ctx.pixels));
|
|
}
|
|
|
|
static int submit_frame(void)
|
|
{
|
|
int err;
|
|
|
|
err = led_strip_update_rgb(ctx.strip, ctx.pixels, ARRAY_SIZE(ctx.pixels));
|
|
if (err) {
|
|
LOG_WRN("led_strip_update_rgb failed (%d)", err);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int set_strip_power(bool on)
|
|
{
|
|
int err;
|
|
|
|
err = gpio_pin_set_dt(&ctx.strip_en, on ? 1 : 0);
|
|
if (err) {
|
|
LOG_WRN("LED strip EN set failed (%d)", err);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int refresh_idle_frame(void)
|
|
{
|
|
clear_pixels();
|
|
return submit_frame();
|
|
}
|
|
|
|
static void stop_effect_work(void)
|
|
{
|
|
k_work_cancel_delayable(&ctx.effect_work);
|
|
}
|
|
|
|
static void schedule_effect_tick(k_timeout_t delay)
|
|
{
|
|
k_work_reschedule(&ctx.effect_work, delay);
|
|
}
|
|
|
|
static int enable_strip_output(void)
|
|
{
|
|
int err;
|
|
|
|
err = set_strip_power(true);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
return refresh_idle_frame();
|
|
}
|
|
|
|
static void disable_strip_output(void)
|
|
{
|
|
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 (!module_lifecycle_is_running(&ctx.lc) || !ctx.enabled ||
|
|
(ctx.effect == NULL)) {
|
|
return;
|
|
}
|
|
|
|
keep_running = ctx.effect->ops->tick(ctx.effect,
|
|
k_ticks_to_ms_floor32(
|
|
LED_STRIP_TICK_INTERVAL.ticks),
|
|
ctx.pixels, ARRAY_SIZE(ctx.pixels));
|
|
(void)submit_frame();
|
|
|
|
if (keep_running) {
|
|
schedule_effect_tick(LED_STRIP_TICK_INTERVAL);
|
|
}
|
|
}
|
|
|
|
static int do_init(void)
|
|
{
|
|
int err;
|
|
|
|
if (!device_is_ready(ctx.strip)) {
|
|
LOG_ERR("LED strip device %s not ready", ctx.strip->name);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (!gpio_is_ready_dt(&ctx.strip_en)) {
|
|
LOG_ERR("LED strip supply GPIO not ready");
|
|
return -ENODEV;
|
|
}
|
|
|
|
err = gpio_pin_configure_dt(&ctx.strip_en, GPIO_OUTPUT_INACTIVE);
|
|
if (err) {
|
|
LOG_ERR("Failed to configure LED strip supply GPIO (%d)", err);
|
|
return err;
|
|
}
|
|
|
|
k_work_init_delayable(&ctx.effect_work, effect_work_handler);
|
|
clear_pixels();
|
|
|
|
ctx.effect = led_effect_get_mutable(LED_EFFECT_ID_KEY_FADE);
|
|
if ((ctx.effect == NULL) || (ctx.effect->ops == NULL)) {
|
|
LOG_ERR("LED effect not available");
|
|
return -ENOENT;
|
|
}
|
|
|
|
err = ctx.effect->ops->init(ctx.effect, &effect_cfg);
|
|
if (err) {
|
|
LOG_ERR("LED effect init failed (%d)", err);
|
|
return err;
|
|
}
|
|
|
|
ctx.effect->ops->set_theme(ctx.effect, &ctx.current_theme);
|
|
|
|
LOG_INF("LED strip ready len:%u", (uint32_t)led_strip_length(ctx.strip));
|
|
return 0;
|
|
}
|
|
|
|
static int do_start(void)
|
|
{
|
|
int err;
|
|
|
|
if (module_lifecycle_is_running(&ctx.lc)) {
|
|
return 0;
|
|
}
|
|
|
|
if (!ctx.enabled) {
|
|
return 0;
|
|
}
|
|
|
|
err = enable_strip_output();
|
|
return err;
|
|
}
|
|
|
|
static int do_stop(void)
|
|
{
|
|
if (!module_lifecycle_is_running(&ctx.lc)) {
|
|
return 0;
|
|
}
|
|
|
|
if ((ctx.effect != NULL) && (ctx.effect->ops != NULL)) {
|
|
ctx.effect->ops->reset(ctx.effect);
|
|
}
|
|
|
|
disable_strip_output();
|
|
return 0;
|
|
}
|
|
|
|
static bool handle_button_event(const struct button_event *event)
|
|
{
|
|
if (!module_lifecycle_is_running(&ctx.lc) || !ctx.enabled ||
|
|
(ctx.effect == NULL) || !event->pressed) {
|
|
return false;
|
|
}
|
|
|
|
ctx.effect->ops->on_key_press(ctx.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)
|
|
{
|
|
ctx.enabled = event->enabled;
|
|
|
|
if (!module_lifecycle_is_running(&ctx.lc)) {
|
|
return false;
|
|
}
|
|
|
|
if (ctx.enabled) {
|
|
int err = enable_strip_output();
|
|
|
|
if (err) {
|
|
LOG_WRN("LED strip enable request failed (%d)", err);
|
|
ctx.enabled = false;
|
|
return false;
|
|
}
|
|
} else {
|
|
if ((ctx.effect != NULL) && (ctx.effect->ops != NULL)) {
|
|
ctx.effect->ops->reset(ctx.effect);
|
|
}
|
|
|
|
disable_strip_output();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool handle_theme_rgb_update_event(const struct theme_rgb_update_event *event)
|
|
{
|
|
ctx.current_theme = event->theme;
|
|
|
|
if ((ctx.effect != NULL) && (ctx.effect->ops != NULL)) {
|
|
ctx.effect->ops->set_theme(ctx.effect, &ctx.current_theme);
|
|
}
|
|
|
|
if (module_lifecycle_is_running(&ctx.lc) && ctx.enabled &&
|
|
(ctx.effect != NULL) && ctx.effect->ops->is_active(ctx.effect)) {
|
|
schedule_effect_tick(K_NO_WAIT);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
if (is_theme_rgb_update_event(aeh)) {
|
|
return handle_theme_rgb_update_event(cast_theme_rgb_update_event(aeh));
|
|
}
|
|
|
|
if (is_module_state_event(aeh)) {
|
|
const struct module_state_event *event = cast_module_state_event(aeh);
|
|
|
|
if (check_state(event, MODULE_ID(main), MODULE_STATE_READY)) {
|
|
(void)module_set_lifecycle(&ctx.lc, LC_RUNNING);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (is_power_down_event(aeh)) {
|
|
if (module_lifecycle_is_initialized(&ctx.lc)) {
|
|
(void)module_set_lifecycle(&ctx.lc, LC_STOPPED);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (is_wake_up_event(aeh)) {
|
|
if (module_lifecycle_is_initialized(&ctx.lc)) {
|
|
(void)module_set_lifecycle(&ctx.lc, LC_RUNNING);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
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(MODULE, theme_rgb_update_event);
|
|
APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event);
|
|
APP_EVENT_SUBSCRIBE(MODULE, wake_up_event);
|