feat: Licht-Engine mit Transitionen, Moduswechsel und Effekten

2026-09-11 13:11:23 +02:00
parent 42eeb0e0eb
commit 73a7f31cb6
5 changed files with 400 additions and 1 deletions
@@ -0,0 +1,178 @@
+#include "light/nl_engine.h"
+
+#include "light/nl_color.h"
+
+typedef struct {
+    nl_visual_t from;
+    nl_visual_t to;
+    uint32_t    dur;
+    uint32_t    elapsed;
+} seg_t;
+
+static nl_engine_cfg_t s_cfg;
+static nl_visual_t s_cur;
+static seg_t s_seg[2];
+static uint8_t s_nseg;
+static uint8_t s_iseg;
+static uint8_t s_blink_left; /* remaining blink phases; even = on, odd = off */
+static uint32_t s_blink_t;
+static bool s_pulse;
+static uint32_t s_pulse_t;
+
+static nl_visual_t to_visual(const nl_light_state_t *s)
+{
+    nl_visual_t v;
+    v.bri = s->on ? (uint16_t)(s->brightness * 100u) : 0;
+    v.mode = s->mode;
+    v.r = s->r;
+    v.g = s->g;
+    v.b = s->b;
+    v.ct = s->ct;
+    return v;
+}
+
+static int32_t lerp(int32_t a, int32_t b, uint32_t e, uint32_t d)
+{
+    return a + (int32_t)(((int64_t)(b - a) * (int64_t)e) / (int64_t)d);
+}
+
+static void push(const nl_visual_t *from, const nl_visual_t *to, uint32_t dur)
+{
+    seg_t *s = &s_seg[s_nseg++];
+    s->from = *from;
+    s->to = *to;
+    s->dur = dur;
+    s->elapsed = 0;
+}
+
+static void emit(void)
+{
+    uint8_t ch[NL_CH_COUNT];
+    nl_visual_t v;
+
+    if (s_blink_left) {
+        v.bri = (s_blink_left % 2 == 0) ? NL_BRI_SCALE : 0;
+        v.mode = NL_MODE_WHITE;
+        v.r = v.g = v.b = 0;
+        v.ct = s_cfg.ct_min;
+    } else if (s_pulse) {
+        uint32_t half = NL_PULSE_PERIOD_MS / 2;
+        uint32_t ph = s_pulse_t % NL_PULSE_PERIOD_MS;
+        uint32_t tri = ph < half ? ph : NL_PULSE_PERIOD_MS - ph;
+        v.bri = (uint16_t)(1000u + tri * 5000u / half); /* 10 % .. 60 % */
+        v.mode = NL_MODE_WHITE;
+        v.r = v.g = v.b = 0;
+        v.ct = s_cfg.ct_min;
+    } else {
+        v = s_cur;
+    }
+    nl_visual_to_channels(&v, s_cfg.ct_min, s_cfg.ct_max, ch);
+    s_cfg.output(ch, s_cfg.ctx);
+}
+
+void nl_engine_init(const nl_engine_cfg_t *cfg)
+{
+    s_cfg = *cfg;
+    s_cur.bri = 0;
+    s_cur.mode = NL_MODE_WHITE;
+    s_cur.r = s_cur.g = s_cur.b = 255;
+    s_cur.ct = cfg->ct_min;
+    s_nseg = s_iseg = 0;
+    s_blink_left = 0;
+    s_blink_t = 0;
+    s_pulse = false;
+    s_pulse_t = 0;
+    emit();
+}
+
+void nl_engine_set(const nl_light_state_t *target, uint32_t transition_ms)
+{
+    nl_visual_t tgt = to_visual(target);
+
+    s_nseg = 0;
+    s_iseg = 0;
+    if (transition_ms == 0) {
+        s_cur = tgt;
+        emit();
+        return;
+    }
+    if (s_cur.bri == 0) {
+        nl_visual_t start = tgt;
+        start.bri = 0;
+        push(&start, &tgt, transition_ms);
+    } else if (tgt.bri == 0) {
+        nl_visual_t dark = s_cur;
+        dark.bri = 0;
+        push(&s_cur, &dark, transition_ms);
+        push(&tgt, &tgt, 0);
+    } else if (tgt.mode != s_cur.mode) {
+        nl_visual_t a = s_cur;
+        nl_visual_t b = tgt;
+        a.bri = 0;
+        b.bri = 0;
+        push(&s_cur, &a, transition_ms / 2);
+        push(&b, &tgt, transition_ms - transition_ms / 2);
+    } else {
+        push(&s_cur, &tgt, transition_ms);
+    }
+}
+
+void nl_engine_tick(uint32_t elapsed_ms)
+{
+    uint32_t left = elapsed_ms;
+
+    while (s_iseg < s_nseg) {
+        seg_t *s = &s_seg[s_iseg];
+        if (s->elapsed + left >= s->dur) {
+            left -= s->dur - s->elapsed;
+            s->elapsed = s->dur;
+            s_cur = s->to;
+            s_iseg++;
+            continue;
+        }
+        s->elapsed += left;
+        left = 0;
+        s_cur.bri = (uint16_t)lerp(s->from.bri, s->to.bri, s->elapsed, s->dur);
+        s_cur.r = (uint8_t)lerp(s->from.r, s->to.r, s->elapsed, s->dur);
+        s_cur.g = (uint8_t)lerp(s->from.g, s->to.g, s->elapsed, s->dur);
+        s_cur.b = (uint8_t)lerp(s->from.b, s->to.b, s->elapsed, s->dur);
+        s_cur.ct = (uint16_t)lerp(s->from.ct, s->to.ct, s->elapsed, s->dur);
+        s_cur.mode = s->to.mode;
+        break;
+    }
+
+    if (s_blink_left) {
+        s_blink_t += elapsed_ms;
+        while (s_blink_left && s_blink_t >= NL_BLINK_PHASE_MS) {
+            s_blink_t -= NL_BLINK_PHASE_MS;
+            s_blink_left--;
+        }
+    }
+    if (s_pulse)
+        s_pulse_t += elapsed_ms;
+    emit();
+}
+
+bool nl_engine_idle(void)
+{
+    return s_iseg >= s_nseg && !s_blink_left && !s_pulse;
+}
+
+void nl_engine_current(nl_visual_t *out)
+{
+    *out = s_cur;
+}
+
+void nl_engine_blink(uint8_t count)
+{
+    s_blink_left = (uint8_t)(count * 2u);
+    s_blink_t = 0;
+    emit();
+}
+
+void nl_engine_pulse(bool enable)
+{
+    s_pulse = enable;
+    s_pulse_t = 0;
+    emit();
+}
@@ -0,0 +1,31 @@
+#ifndef NL_ENGINE_H
+#define NL_ENGINE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "board/nl_board.h"
+#include "light/nl_light_types.h"
+
+#define NL_BLINK_PHASE_MS  300u
+#define NL_PULSE_PERIOD_MS 3000u
+
+typedef void (*nl_output_fn)(const uint8_t ch[NL_CH_COUNT], void *ctx);
+
+typedef struct {
+    uint16_t     ct_min;
+    uint16_t     ct_max;
+    nl_output_fn output;
+    void        *ctx;
+} nl_engine_cfg_t;
+
+/* Not thread safe: callers serialise access. */
+void nl_engine_init(const nl_engine_cfg_t *cfg);
+void nl_engine_set(const nl_light_state_t *target, uint32_t transition_ms);
+void nl_engine_tick(uint32_t elapsed_ms);
+bool nl_engine_idle(void);
+void nl_engine_current(nl_visual_t *out);
+void nl_engine_blink(uint8_t count);
+void nl_engine_pulse(bool enable);
+
+#endif