From e0bde7bee36aec5668393e8da9844170a0076a20 Mon Sep 17 00:00:00 2001 From: Michael Sauer Date: Fri, 11 Sep 2026 13:20:49 +0200 Subject: [PATCH] feat: Licht-Steuerung mit Fade-Regeln und Einschaltverhalten --- CMakeLists.txt | 4 +- src/light/nl_boot_state.c | 44 ++++++++ src/light/nl_boot_state.h | 17 +++ src/light/nl_control.c | 98 ++++++++++++++++++ src/light/nl_control.h | 48 +++++++++ test/CMakeLists.txt | 3 + test/test_boot_state.c | 75 ++++++++++++++ test/test_control.c | 213 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 501 insertions(+), 1 deletion(-) create mode 100644 src/light/nl_boot_state.c create mode 100644 src/light/nl_boot_state.h create mode 100644 src/light/nl_control.c create mode 100644 src/light/nl_control.h create mode 100644 test/test_boot_state.c create mode 100644 test/test_control.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 69711e4..cc7a368 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -32,7 +32,9 @@ set(NL_FW_SOURCES src/sys/sdk_stubs.c src/board/nl_board.c src/light/nl_color.c - src/light/nl_engine.c) + src/light/nl_engine.c + src/light/nl_control.c + src/light/nl_boot_state.c) set(NL_FW ninlight_${NINLIGHT_DEVICE}) add_executable(${NL_FW} ${NL_SDK_BOOT_SOURCES} ${NL_FW_SOURCES} ${NL_SDK_OBJECTS}) diff --git a/src/light/nl_boot_state.c b/src/light/nl_boot_state.c new file mode 100644 index 0000000..e9792d5 --- /dev/null +++ b/src/light/nl_boot_state.c @@ -0,0 +1,44 @@ +#include "light/nl_boot_state.h" + +static uint16_t clamp_ct(uint16_t ct, const nl_board_t *b) +{ + if (ct < b->ct_min) + return b->ct_min; + if (ct > b->ct_max) + return b->ct_max; + return ct; +} + +nl_light_state_t nl_boot_default_state(const nl_board_t *b) +{ + nl_light_state_t s; + s.on = true; + s.brightness = 100; + s.mode = NL_MODE_WHITE; + s.r = s.g = s.b = 255; + s.ct = clamp_ct(2700, b); + return s; +} + +nl_light_state_t nl_boot_state(nl_pob_t pob, const nl_light_state_t *last, const nl_board_t *b) +{ + nl_light_state_t s = last ? *last : nl_boot_default_state(b); + + if (s.brightness < 1 || s.brightness > 100) + s.brightness = 100; + if (!b->has_rgb || (s.mode != NL_MODE_COLOR && s.mode != NL_MODE_WHITE)) + s.mode = NL_MODE_WHITE; + s.ct = clamp_ct(s.ct, b); + + if (pob == NL_POB_ON) + s.on = true; + else if (pob == NL_POB_OFF) + s.on = false; + return s; +} + +bool nl_light_state_equal(const nl_light_state_t *a, const nl_light_state_t *b) +{ + return a->on == b->on && a->brightness == b->brightness && a->mode == b->mode && + a->r == b->r && a->g == b->g && a->b == b->b && a->ct == b->ct; +} diff --git a/src/light/nl_boot_state.h b/src/light/nl_boot_state.h new file mode 100644 index 0000000..b7686fa --- /dev/null +++ b/src/light/nl_boot_state.h @@ -0,0 +1,17 @@ +#ifndef NL_BOOT_STATE_H +#define NL_BOOT_STATE_H + +#include + +#include "board/nl_board.h" +#include "light/nl_light_types.h" + +/* Warm white, 100 %, on. */ +nl_light_state_t nl_boot_default_state(const nl_board_t *b); + +/* State to apply after power-up. last == NULL when nothing is stored. Stored values are sanitised. */ +nl_light_state_t nl_boot_state(nl_pob_t pob, const nl_light_state_t *last, const nl_board_t *b); + +bool nl_light_state_equal(const nl_light_state_t *a, const nl_light_state_t *b); + +#endif diff --git a/src/light/nl_control.c b/src/light/nl_control.c new file mode 100644 index 0000000..0ed78df --- /dev/null +++ b/src/light/nl_control.c @@ -0,0 +1,98 @@ +#include "light/nl_control.h" + +#include "light/nl_boot_state.h" +#include "light/nl_engine.h" + +static const nl_board_t *s_board; +static nl_light_state_t s_state; +static uint16_t s_fade_in; +static uint16_t s_fade_out; +static bool s_dirty; +static uint32_t s_changed_at; + +void nl_ctrl_init(const nl_board_t *board, uint16_t fade_in_ms, uint16_t fade_out_ms) +{ + s_board = board; + s_state = nl_boot_default_state(board); + s_state.on = false; + s_dirty = false; + s_changed_at = 0; + nl_ctrl_set_fades(fade_in_ms, fade_out_ms); +} + +void nl_ctrl_set_fades(uint16_t fade_in_ms, uint16_t fade_out_ms) +{ + s_fade_in = fade_in_ms > NL_MAX_FADE_MS ? NL_MAX_FADE_MS : fade_in_ms; + s_fade_out = fade_out_ms > NL_MAX_FADE_MS ? NL_MAX_FADE_MS : fade_out_ms; +} + +void nl_ctrl_boot(const nl_light_state_t *initial) +{ + s_state = *initial; + s_dirty = false; + nl_engine_set(&s_state, s_state.on ? s_fade_in : 0); +} + +nl_ctrl_err_t nl_ctrl_apply(const nl_light_change_t *c, uint32_t now_ms) +{ + nl_light_state_t n = s_state; + uint32_t dur; + + if (c->has_color && c->has_ct) + return NL_CTRL_ERR_COLOR_AND_CT; + if (c->has_color && !s_board->has_rgb) + return NL_CTRL_ERR_NO_RGB; + if (c->has_brightness && (c->brightness < 1 || c->brightness > 100)) + return NL_CTRL_ERR_BRIGHTNESS; + if (c->has_transition && c->transition_ms > NL_MAX_TRANSITION_MS) + return NL_CTRL_ERR_TRANSITION; + + if (c->has_on) + n.on = c->on; + if (c->has_brightness) + n.brightness = c->brightness; + if (c->has_color) { + n.r = c->r; + n.g = c->g; + n.b = c->b; + n.mode = NL_MODE_COLOR; + } + if (c->has_ct) { + n.ct = c->ct < s_board->ct_min ? s_board->ct_min : (c->ct > s_board->ct_max ? s_board->ct_max : c->ct); + n.mode = NL_MODE_WHITE; + } + + if (c->has_transition) + dur = c->transition_ms; + else if (!s_state.on && n.on) + dur = s_fade_in; + else if (s_state.on && !n.on) + dur = s_fade_out; + else + dur = 0; + + s_state = n; + nl_engine_set(&s_state, dur); + s_dirty = true; + s_changed_at = now_ms; + return NL_CTRL_OK; +} + +void nl_ctrl_get(nl_light_state_t *out) +{ + *out = s_state; +} + +bool nl_ctrl_persist_due(uint32_t now_ms, nl_light_state_t *out) +{ + if (!s_dirty || (uint32_t)(now_ms - s_changed_at) < NL_PERSIST_DELAY_MS) + return false; + *out = s_state; + return true; +} + +void nl_ctrl_persisted(const nl_light_state_t *written) +{ + if (nl_light_state_equal(written, &s_state)) + s_dirty = false; +} diff --git a/src/light/nl_control.h b/src/light/nl_control.h new file mode 100644 index 0000000..7dd2432 --- /dev/null +++ b/src/light/nl_control.h @@ -0,0 +1,48 @@ +#ifndef NL_CONTROL_H +#define NL_CONTROL_H + +#include +#include + +#include "board/nl_board.h" +#include "light/nl_light_types.h" + +#define NL_MAX_TRANSITION_MS 60000u +#define NL_MAX_FADE_MS 10000u +#define NL_PERSIST_DELAY_MS 3000u + +typedef struct { + bool has_on; + bool on; + bool has_brightness; + uint8_t brightness; + bool has_color; + uint8_t r, g, b; + bool has_ct; + uint16_t ct; + bool has_transition; + uint32_t transition_ms; +} nl_light_change_t; + +typedef enum { + NL_CTRL_OK = 0, + NL_CTRL_ERR_NO_RGB, + NL_CTRL_ERR_COLOR_AND_CT, + NL_CTRL_ERR_BRIGHTNESS, + NL_CTRL_ERR_TRANSITION +} nl_ctrl_err_t; + +/* The engine must be initialised before. Not thread safe: callers serialise access. */ +void nl_ctrl_init(const nl_board_t *board, uint16_t fade_in_ms, uint16_t fade_out_ms); +void nl_ctrl_set_fades(uint16_t fade_in_ms, uint16_t fade_out_ms); +void nl_ctrl_boot(const nl_light_state_t *initial); +nl_ctrl_err_t nl_ctrl_apply(const nl_light_change_t *c, uint32_t now_ms); +void nl_ctrl_get(nl_light_state_t *out); + +/* True once NL_PERSIST_DELAY_MS after the last change; out receives the state to store. */ +bool nl_ctrl_persist_due(uint32_t now_ms, nl_light_state_t *out); + +/* Clears the dirty flag only if nothing changed since `written` was taken. */ +void nl_ctrl_persisted(const nl_light_state_t *written); + +#endif diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 10dbdc5..b2bc48a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -27,3 +27,6 @@ nl_test(test_crc test_crc.c ${NL_SRC}/util/nl_crc.c) nl_test(test_board test_board.c ${NL_SRC}/board/nl_board.c) nl_test(test_color test_color.c ${NL_SRC}/light/nl_color.c) nl_test(test_engine test_engine.c ${NL_SRC}/light/nl_engine.c ${NL_SRC}/light/nl_color.c) +nl_test(test_boot_state test_boot_state.c ${NL_SRC}/light/nl_boot_state.c ${NL_SRC}/board/nl_board.c) +nl_test(test_control test_control.c ${NL_SRC}/light/nl_control.c ${NL_SRC}/light/nl_boot_state.c + ${NL_SRC}/light/nl_engine.c ${NL_SRC}/light/nl_color.c ${NL_SRC}/board/nl_board.c) diff --git a/test/test_boot_state.c b/test/test_boot_state.c new file mode 100644 index 0000000..df7ba2b --- /dev/null +++ b/test/test_boot_state.c @@ -0,0 +1,75 @@ +#include "unity.h" +#include "light/nl_boot_state.h" + +void setUp(void) {} +void tearDown(void) {} + +static nl_light_state_t red_off(void) +{ + nl_light_state_t s = {false, 40, NL_MODE_COLOR, 255, 0, 0, 3000}; + return s; +} + +static void test_default_state(void) +{ + nl_light_state_t d = nl_boot_default_state(nl_board_find("evk")); + TEST_ASSERT_TRUE(d.on); + TEST_ASSERT_EQUAL_UINT8(100, d.brightness); + TEST_ASSERT_EQUAL(NL_MODE_WHITE, d.mode); + TEST_ASSERT_EQUAL_UINT16(2700, d.ct); + TEST_ASSERT_EQUAL_UINT16(2700, nl_boot_default_state(nl_board_find("e27_cw")).ct); +} + +static void test_last_restores_everything(void) +{ + nl_light_state_t last = red_off(); + nl_light_state_t s = nl_boot_state(NL_POB_LAST, &last, nl_board_find("evk")); + TEST_ASSERT_TRUE(nl_light_state_equal(&last, &s)); +} + +static void test_last_without_saved_state_uses_default(void) +{ + const nl_board_t *b = nl_board_find("evk"); + nl_light_state_t s = nl_boot_state(NL_POB_LAST, NULL, b); + nl_light_state_t d = nl_boot_default_state(b); + TEST_ASSERT_TRUE(nl_light_state_equal(&d, &s)); +} + +static void test_on_forces_on_with_last_values(void) +{ + nl_light_state_t last = red_off(); + nl_light_state_t s = nl_boot_state(NL_POB_ON, &last, nl_board_find("evk")); + TEST_ASSERT_TRUE(s.on); + TEST_ASSERT_EQUAL_UINT8(40, s.brightness); + TEST_ASSERT_EQUAL(NL_MODE_COLOR, s.mode); +} + +static void test_off_forces_off(void) +{ + nl_light_state_t last = red_off(); + last.on = true; + nl_light_state_t s = nl_boot_state(NL_POB_OFF, &last, nl_board_find("evk")); + TEST_ASSERT_FALSE(s.on); + TEST_ASSERT_EQUAL_UINT8(40, s.brightness); +} + +static void test_sanitizes_stored_values(void) +{ + nl_light_state_t last = {true, 0, NL_MODE_COLOR, 1, 2, 3, 9000}; + nl_light_state_t s = nl_boot_state(NL_POB_LAST, &last, nl_board_find("e27_cw")); + TEST_ASSERT_EQUAL_UINT8(100, s.brightness); /* invalid 0 -> 100 */ + TEST_ASSERT_EQUAL(NL_MODE_WHITE, s.mode); /* no RGB on this board */ + TEST_ASSERT_EQUAL_UINT16(5000, s.ct); /* clamped */ +} + +int main(void) +{ + UNITY_BEGIN(); + RUN_TEST(test_default_state); + RUN_TEST(test_last_restores_everything); + RUN_TEST(test_last_without_saved_state_uses_default); + RUN_TEST(test_on_forces_on_with_last_values); + RUN_TEST(test_off_forces_off); + RUN_TEST(test_sanitizes_stored_values); + return UNITY_END(); +} diff --git a/test/test_control.c b/test/test_control.c new file mode 100644 index 0000000..9adb124 --- /dev/null +++ b/test/test_control.c @@ -0,0 +1,213 @@ +#include +#include "unity.h" +#include "light/nl_boot_state.h" +#include "light/nl_control.h" +#include "light/nl_engine.h" + +static void out(const uint8_t ch[NL_CH_COUNT], void *ctx) +{ + (void)ch; + (void)ctx; +} + +static void start(const char *board_id, bool on) +{ + const nl_board_t *b = nl_board_find(board_id); + nl_engine_cfg_t cfg = {b->ct_min, b->ct_max, out, NULL}; + nl_engine_init(&cfg); + nl_ctrl_init(b, 500, 800); + nl_light_state_t s = nl_boot_default_state(b); + s.on = on; + nl_ctrl_boot(&s); + nl_engine_tick(10000); /* finish a possible boot fade */ +} + +static uint16_t bri(void) +{ + nl_visual_t v; + nl_engine_current(&v); + return v.bri; +} + +static nl_light_change_t chg(void) +{ + nl_light_change_t c; + memset(&c, 0, sizeof c); + return c; +} + +void setUp(void) { start("evk", false); } +void tearDown(void) {} + +static void test_turn_on_uses_fade_in(void) +{ + nl_light_change_t c = chg(); + c.has_on = true; + c.on = true; + TEST_ASSERT_EQUAL(NL_CTRL_OK, nl_ctrl_apply(&c, 0)); + nl_engine_tick(250); + TEST_ASSERT_EQUAL_UINT16(5000, bri()); + nl_engine_tick(250); + TEST_ASSERT_EQUAL_UINT16(10000, bri()); +} + +static void test_turn_off_uses_fade_out(void) +{ + start("evk", true); + nl_light_change_t c = chg(); + c.has_on = true; + c.on = false; + nl_ctrl_apply(&c, 0); + nl_engine_tick(400); + TEST_ASSERT_EQUAL_UINT16(5000, bri()); +} + +static void test_explicit_transition_wins(void) +{ + nl_light_change_t c = chg(); + c.has_on = true; + c.on = true; + c.has_transition = true; + c.transition_ms = 100; + nl_ctrl_apply(&c, 0); + nl_engine_tick(100); + TEST_ASSERT_EQUAL_UINT16(10000, bri()); +} + +static void test_brightness_change_without_transition_is_instant(void) +{ + start("evk", true); + nl_light_change_t c = chg(); + c.has_brightness = true; + c.brightness = 50; + nl_ctrl_apply(&c, 0); + TEST_ASSERT_EQUAL_UINT16(5000, bri()); +} + +static void test_brightness_while_off_stays_off(void) +{ + nl_light_change_t c = chg(); + c.has_brightness = true; + c.brightness = 30; + TEST_ASSERT_EQUAL(NL_CTRL_OK, nl_ctrl_apply(&c, 0)); + nl_light_state_t s; + nl_ctrl_get(&s); + TEST_ASSERT_FALSE(s.on); + TEST_ASSERT_EQUAL_UINT8(30, s.brightness); + TEST_ASSERT_EQUAL_UINT16(0, bri()); +} + +static void test_validation(void) +{ + nl_light_change_t c = chg(); + c.has_brightness = true; + c.brightness = 0; + TEST_ASSERT_EQUAL(NL_CTRL_ERR_BRIGHTNESS, nl_ctrl_apply(&c, 0)); + c.brightness = 101; + TEST_ASSERT_EQUAL(NL_CTRL_ERR_BRIGHTNESS, nl_ctrl_apply(&c, 0)); + + c = chg(); + c.has_transition = true; + c.transition_ms = 60001; + TEST_ASSERT_EQUAL(NL_CTRL_ERR_TRANSITION, nl_ctrl_apply(&c, 0)); + + c = chg(); + c.has_color = true; + c.has_ct = true; + TEST_ASSERT_EQUAL(NL_CTRL_ERR_COLOR_AND_CT, nl_ctrl_apply(&c, 0)); +} + +static void test_color_rejected_on_white_board(void) +{ + start("e27_cw", true); + nl_light_change_t c = chg(); + c.has_color = true; + c.r = 255; + TEST_ASSERT_EQUAL(NL_CTRL_ERR_NO_RGB, nl_ctrl_apply(&c, 0)); + nl_light_state_t s; + nl_ctrl_get(&s); + TEST_ASSERT_EQUAL(NL_MODE_WHITE, s.mode); +} + +static void test_mode_follows_color_or_ct(void) +{ + nl_light_change_t c = chg(); + nl_light_state_t s; + c.has_color = true; + c.r = 10; + c.g = 20; + c.b = 30; + nl_ctrl_apply(&c, 0); + nl_ctrl_get(&s); + TEST_ASSERT_EQUAL(NL_MODE_COLOR, s.mode); + TEST_ASSERT_EQUAL_UINT8(20, s.g); + + c = chg(); + c.has_ct = true; + c.ct = 1000; + nl_ctrl_apply(&c, 0); + nl_ctrl_get(&s); + TEST_ASSERT_EQUAL(NL_MODE_WHITE, s.mode); + TEST_ASSERT_EQUAL_UINT16(2700, s.ct); /* clamped to ct_min */ +} + +static void test_persist_debounce(void) +{ + nl_light_state_t s; + nl_light_change_t c = chg(); + c.has_brightness = true; + c.brightness = 70; + + TEST_ASSERT_FALSE(nl_ctrl_persist_due(100000, &s)); /* boot is not dirty */ + nl_ctrl_apply(&c, 1000); + TEST_ASSERT_FALSE(nl_ctrl_persist_due(3999, &s)); + TEST_ASSERT_TRUE(nl_ctrl_persist_due(4000, &s)); + TEST_ASSERT_EQUAL_UINT8(70, s.brightness); + nl_ctrl_persisted(&s); + TEST_ASSERT_FALSE(nl_ctrl_persist_due(9000, &s)); +} + +static void test_change_during_write_stays_dirty(void) +{ + nl_light_state_t written; + nl_light_change_t c = chg(); + c.has_brightness = true; + c.brightness = 70; + nl_ctrl_apply(&c, 0); + TEST_ASSERT_TRUE(nl_ctrl_persist_due(3000, &written)); + c.brightness = 20; /* arrives while the flash write is running */ + nl_ctrl_apply(&c, 3001); + nl_ctrl_persisted(&written); /* old state written */ + TEST_ASSERT_FALSE(nl_ctrl_persist_due(3002, &written)); + TEST_ASSERT_TRUE(nl_ctrl_persist_due(6001, &written)); + TEST_ASSERT_EQUAL_UINT8(20, written.brightness); +} + +static void test_boot_fades_in_when_on(void) +{ + const nl_board_t *b = nl_board_find("evk"); + nl_engine_cfg_t cfg = {b->ct_min, b->ct_max, out, NULL}; + nl_engine_init(&cfg); + nl_ctrl_init(b, 500, 800); + nl_light_state_t s = nl_boot_default_state(b); + nl_ctrl_boot(&s); + nl_engine_tick(250); + TEST_ASSERT_EQUAL_UINT16(5000, bri()); +} + +int main(void) +{ + UNITY_BEGIN(); + RUN_TEST(test_turn_on_uses_fade_in); + RUN_TEST(test_turn_off_uses_fade_out); + RUN_TEST(test_explicit_transition_wins); + RUN_TEST(test_brightness_change_without_transition_is_instant); + RUN_TEST(test_brightness_while_off_stays_off); + RUN_TEST(test_validation); + RUN_TEST(test_color_rejected_on_white_board); + RUN_TEST(test_mode_follows_color_or_ct); + RUN_TEST(test_persist_debounce); + RUN_TEST(test_change_during_write_stays_dirty); + RUN_TEST(test_boot_fades_in_when_on); + return UNITY_END(); +}