diff --git a/CLAUDE.md b/CLAUDE.md index b3e24f8..54540d7 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -90,9 +90,11 @@ Commands arrive as newline-terminated ASCII lines. Each `parse*` function in `pr | `HOME` | `HOME ` / `HOMEALL` | Run homing sequence | | `SWEEP` | `SWEEP ` | Start sweep (0/0 stops) | | `POS?` | `POS?` | Query all gauges: `POS ` | -| `LED` | `LED ` | Set one LED (0-based index within gauge segment) to RGB colour (0–255 each); `` may be a range `N-M` to set LEDs N through M in one command; also stops any active blink on those LEDs | +| `LED` | `LED ` | Set one LED (0-based index within gauge segment) to RGB colour (0–255 each); `` may be a range `N-M` to set LEDs N through M in one command; also stops any active effect on those LEDs | | `LED?` | `LED?` | Query all LEDs: one `LED ` line per LED, then `OK` | -| `BLINK` | `BLINK ` | Blink LED(s) using their current colour as the on-colour; `` may be a range `N-M`; `on_ms`/`off_ms` must both be > 0, or both 0 to stop blinking | +| `BLINK` | `BLINK ` | Blink LED(s) at given colour; `` may be a range `N-M`; `on_ms`/`off_ms` both 0 stops blinking. 4-arg form (no colour) uses current LED colour | +| `BREATHE` | `BREATHE ` | Smooth triangle-wave fade between black and the given colour; `` may be a range `N-M` | +| `DFLASH` | `DFLASH ` | Two quick flashes (100 ms on/off each) followed by a 700 ms pause, then repeats; `` may be a range `N-M` | | `PING` | `PING` | Responds `PONG` | All commands reply `OK` or `ERR BAD_ID` / `ERR BAD_CMD` etc. diff --git a/Gaugecontroller/Gaugecontroller.ino b/Gaugecontroller/Gaugecontroller.ino index 58fe5c5..6a2f804 100644 --- a/Gaugecontroller/Gaugecontroller.ino +++ b/Gaugecontroller/Gaugecontroller.ino @@ -70,13 +70,22 @@ struct Gauge { bool sweepTowardMax = true; }; +enum LedFx : uint8_t { FX_BLINK = 0, FX_BREATHE = 1, FX_DFLASH = 2 }; + struct BlinkState { - bool active = false; - uint32_t onMs = 500; - uint32_t offMs = 500; - CRGB onColor; - bool currentlyOn = false; - unsigned long lastToggleMs = 0; + bool active = false; + LedFx fx = FX_BLINK; + CRGB onColor; + unsigned long lastMs = 0; + // FX_BLINK + uint16_t onMs = 500; + uint16_t offMs = 500; + bool currentlyOn = false; + // FX_BREATHE: smooth triangle-wave fade + uint16_t periodMs = 2000; + uint16_t cyclePos = 0; + // FX_DFLASH: two quick flashes then pause + uint8_t dphase = 0; }; Gauge gauges[GAUGE_COUNT]; @@ -587,11 +596,12 @@ bool parseBlink(const String& line) { for (int i = idxFirst; i <= idxLast; i++) { uint8_t globalIdx = gaugeLedOffset[id] + i; BlinkState& bs = blinkState[globalIdx]; + bs.fx = FX_BLINK; bs.onColor = (count == 7) ? color : leds[globalIdx]; - bs.onMs = (uint32_t)onMs; - bs.offMs = (uint32_t)offMs; - bs.currentlyOn = true; - bs.lastToggleMs = nowMs; + bs.onMs = (uint16_t)onMs; + bs.offMs = (uint16_t)offMs; + bs.currentlyOn = true; + bs.lastMs = nowMs; bs.active = true; leds[globalIdx] = bs.onColor; } @@ -600,22 +610,112 @@ bool parseBlink(const String& line) { return true; } +bool parseBreathe(const String& line) { + int id, periodMs, r, g, b; + char idxToken[16]; + if (sscanf(line.c_str(), "BREATHE %d %15s %d %d %d %d", + &id, idxToken, &periodMs, &r, &g, &b) != 6) return false; + if (id < 0 || id >= GAUGE_COUNT) { sendReply("ERR BAD_ID"); return true; } + char* dash = strchr(idxToken, '-'); + int idxFirst = atoi(idxToken); + int idxLast = dash ? atoi(dash + 1) : idxFirst; + if (idxFirst < 0 || idxLast >= gaugePins[id].ledCount || idxFirst > idxLast) { + sendReply("ERR BAD_IDX"); return true; + } + if (periodMs <= 0) { sendReply("ERR BAD_TIME"); return true; } + CRGB color(constrain(r, 0, 255), constrain(g, 0, 255), constrain(b, 0, 255)); + unsigned long nowMs = millis(); + for (int i = idxFirst; i <= idxLast; i++) { + uint8_t gi = gaugeLedOffset[id] + i; + BlinkState& bs = blinkState[gi]; + bs.fx = FX_BREATHE; + bs.onColor = color; + bs.periodMs = (uint16_t)constrain(periodMs, 100, 30000); + bs.cyclePos = 0; + bs.lastMs = nowMs; + bs.active = true; + leds[gi] = CRGB::Black; + } + ledsDirty = true; + sendReply("OK"); + return true; +} + +bool parseDflash(const String& line) { + int id, r, g, b; + char idxToken[16]; + if (sscanf(line.c_str(), "DFLASH %d %15s %d %d %d", + &id, idxToken, &r, &g, &b) != 5) return false; + if (id < 0 || id >= GAUGE_COUNT) { sendReply("ERR BAD_ID"); return true; } + char* dash = strchr(idxToken, '-'); + int idxFirst = atoi(idxToken); + int idxLast = dash ? atoi(dash + 1) : idxFirst; + if (idxFirst < 0 || idxLast >= gaugePins[id].ledCount || idxFirst > idxLast) { + sendReply("ERR BAD_IDX"); return true; + } + CRGB color(constrain(r, 0, 255), constrain(g, 0, 255), constrain(b, 0, 255)); + unsigned long nowMs = millis(); + for (int i = idxFirst; i <= idxLast; i++) { + uint8_t gi = gaugeLedOffset[id] + i; + BlinkState& bs = blinkState[gi]; + bs.fx = FX_DFLASH; + bs.onColor = color; + bs.dphase = 0; + bs.lastMs = nowMs; + bs.active = true; + leds[gi] = color; // phase 0 = on + } + ledsDirty = true; + sendReply("OK"); + return true; +} + void updateBlink() { unsigned long nowMs = millis(); bool changed = false; for (uint8_t i = 0; i < GAUGE_COUNT; i++) { for (uint8_t j = 0; j < gaugePins[i].ledCount; j++) { - uint8_t globalIdx = gaugeLedOffset[i] + j; - BlinkState& bs = blinkState[globalIdx]; + uint8_t gi = gaugeLedOffset[i] + j; + BlinkState& bs = blinkState[gi]; if (!bs.active) continue; - uint32_t period = bs.currentlyOn ? bs.onMs : bs.offMs; - if ((nowMs - bs.lastToggleMs) >= period) { - bs.currentlyOn = !bs.currentlyOn; - bs.lastToggleMs = nowMs; - leds[globalIdx] = bs.currentlyOn ? bs.onColor : CRGB::Black; - changed = true; + switch (bs.fx) { + case FX_BLINK: { + uint32_t period = bs.currentlyOn ? bs.onMs : bs.offMs; + if ((nowMs - bs.lastMs) >= period) { + bs.currentlyOn = !bs.currentlyOn; + bs.lastMs = nowMs; + leds[gi] = bs.currentlyOn ? bs.onColor : CRGB::Black; + changed = true; + } + break; + } + case FX_BREATHE: { + unsigned long dt = nowMs - bs.lastMs; + if (dt < 16) break; + uint32_t newPos = (uint32_t)bs.cyclePos + dt; + bs.cyclePos = (uint16_t)(newPos % bs.periodMs); + bs.lastMs = nowMs; + uint16_t half = bs.periodMs >> 1; + uint8_t bri = (bs.cyclePos < half) + ? (uint8_t)((uint32_t)bs.cyclePos * 255 / half) + : (uint8_t)((uint32_t)(bs.periodMs - bs.cyclePos) * 255 / half); + leds[gi] = bs.onColor; + leds[gi].nscale8(bri ? bri : 1); + changed = true; + break; + } + case FX_DFLASH: { + static const uint16_t dur[4] = {100, 100, 100, 700}; + if ((nowMs - bs.lastMs) >= dur[bs.dphase]) { + bs.lastMs = nowMs; + bs.dphase = (bs.dphase + 1) & 3; + leds[gi] = (bs.dphase == 0 || bs.dphase == 2) ? bs.onColor : CRGB::Black; + changed = true; + } + break; + } } } } @@ -635,6 +735,8 @@ void processLine(const String& line) { if (parseLedQuery(line)) return; if (parseLed(line)) return; if (parseBlink(line)) return; + if (parseBreathe(line)) return; + if (parseDflash(line)) return; if (parsePing(line)) return; sendReply("ERR BAD_CMD"); diff --git a/gauge.py b/gauge.py index 8c98bae..a1ae7f2 100644 --- a/gauge.py +++ b/gauge.py @@ -223,16 +223,26 @@ def set_status_led(gauge_idx, led_type, on): _set_led(gauge_idx, _LED_STATUS_GREEN, r, g, b) -def _apply_blink_or_led(gauge_idx, led_idx, color, effect): - """Set LED to color, optionally starting a blink effect. - When blinking, color is passed inside the BLINK command so only one - serial command is needed — avoids a FastLED.show() race on the Arduino.""" +def _send_effect(gauge_idx, led_ref, color, effect): + """Send a single Arduino command for the given effect (or plain LED if none). + Always embeds color in the command — no preceding LED command needed.""" r, g, b = color - if effect in _BLINK_PRESETS: - on_ms, off_ms = _BLINK_PRESETS[effect] - arduino_send(f"BLINK {gauge_idx} {led_idx} {on_ms} {off_ms} {r} {g} {b}") - else: - arduino_send(f"LED {gauge_idx} {led_idx} {r} {g} {b}") + if effect not in _EFFECTS: + arduino_send(f"LED {gauge_idx} {led_ref} {r} {g} {b}") + return + p = _EFFECTS[effect] + if p[0] == "blink": + arduino_send(f"BLINK {gauge_idx} {led_ref} {p[1]} {p[2]} {r} {g} {b}") + elif p[0] == "breathe": + arduino_send(f"BREATHE {gauge_idx} {led_ref} {p[1]} {r} {g} {b}") + elif p[0] == "dflash": + arduino_send(f"DFLASH {gauge_idx} {led_ref} {r} {g} {b}") + + +def _apply_blink_or_led(gauge_idx, led_idx, color, effect): + """Set LED to color, optionally starting an effect. + Color is always embedded in the command — avoids FastLED.show() race.""" + _send_effect(gauge_idx, led_idx, color, effect) # --------------------------------------------------------------------------- @@ -252,12 +262,15 @@ _BL_SAVE_DELAY_MS = 5000 client_ref = None _mqtt_connected = False -_BLINK_PRESETS = { - "Blink Slow": (800, 800), - "Blink Fast": (150, 150), - "Blink Alert": (100, 400), +_EFFECTS = { + "Blink Slow": ("blink", 800, 800), + "Blink Fast": ("blink", 150, 150), + "Blink Alert": ("blink", 100, 400), + "Breathe Slow": ("breathe", 3000), + "Breathe Fast": ("breathe", 1200), + "Double Flash": ("dflash",), } -_EFFECT_LIST = list(_BLINK_PRESETS.keys()) +_EFFECT_LIST = list(_EFFECTS.keys()) _red_effect = [None] * num_gauges _green_effect = [None] * num_gauges @@ -497,7 +510,7 @@ def on_message(topic, payload): data = {"state": payload} state_on = data.get("state", "ON").upper() != "OFF" effect = data.get("effect") if state_on else None - if effect not in _BLINK_PRESETS: + if effect not in _EFFECTS: effect = None _red_effect[i] = effect color = gauges[i]["ws2812_red"] if state_on else (0, 0, 0) @@ -516,7 +529,7 @@ def on_message(topic, payload): data = {"state": payload} state_on = data.get("state", "ON").upper() != "OFF" effect = data.get("effect") if state_on else None - if effect not in _BLINK_PRESETS: + if effect not in _EFFECTS: effect = None _green_effect[i] = effect color = gauges[i]["ws2812_green"] if state_on else (0, 0, 0) @@ -549,7 +562,7 @@ def on_message(topic, payload): else: brightness = 100 effect = data.get("effect") - if effect not in _BLINK_PRESETS: + if effect not in _EFFECTS: effect = None except Exception as e: warn(f"Invalid backlight payload for gauge {i}: '{payload}' ({e})") @@ -558,8 +571,7 @@ def on_message(topic, payload): if effect: scale = brightness / 100 rs = int(r * scale); gs = int(g * scale); bs_ = int(b * scale) - on_ms, off_ms = _BLINK_PRESETS[effect] - arduino_send(f"BLINK {i} {_LED_BACKLIGHT_RANGE} {on_ms} {off_ms} {rs} {gs} {bs_}") + _send_effect(i, _LED_BACKLIGHT_RANGE, (rs, gs, bs_), effect) backlight_color[i] = (r, g, b) backlight_brightness[i] = brightness backlight_on[i] = True @@ -585,7 +597,7 @@ def on_message(topic, payload): data = {"state": payload} state_on = data.get("state", "ON").upper() != "OFF" effect = data.get("effect") if state_on else None - if effect not in _BLINK_PRESETS: + if effect not in _EFFECTS: effect = None _status_red_effect[i] = effect color = gauges[i]["ws2812_red"] if state_on else (0, 0, 0) @@ -604,7 +616,7 @@ def on_message(topic, payload): data = {"state": payload} state_on = data.get("state", "ON").upper() != "OFF" effect = data.get("effect") if state_on else None - if effect not in _BLINK_PRESETS: + if effect not in _EFFECTS: effect = None _status_green_effect[i] = effect color = gauges[i]["ws2812_green"] if state_on else (0, 0, 0)