feat: Licht-Steuerung mit Fade-Regeln und Einschaltverhalten

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