feat: Licht-Steuerung mit Fade-Regeln und Einschaltverhalten

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})

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;
+}

src/light/nl_boot_state.h

@@ -0,0 +1,17 @@
+#ifndef NL_BOOT_STATE_H
+#define NL_BOOT_STATE_H
+
+#include <stdbool.h>
+
+#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

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;
+}

src/light/nl_control.h

@@ -0,0 +1,48 @@
+#ifndef NL_CONTROL_H
+#define NL_CONTROL_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#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

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)

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();
+}

test/test_control.c

@@ -0,0 +1,213 @@
+#include <string.h>
+#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();
+}