LED Names changed

config.example.json

@@ -33,6 +33,8 @@
       "min": 0,
       "max": 7300,
       "max_steps": 4000,
+      "speed": 5000,
+      "acceleration": 6000,
       "unit": "W",
       "leds": {
         "ws2812_red":   [255, 0, 0],
@@ -45,6 +47,8 @@
       "min": 0,
       "max": 7300,
       "max_steps": 4000,
+      "speed": 5000,
+      "acceleration": 6000,
       "unit": "W",
       "leds": {
         "ws2812_red":   [255, 0, 0],

gauge.py

@@ -24,6 +24,7 @@ Additional config.json fields:
 import network
 import utime
 import ujson
+import gc
 from umqtt.robust import MQTTClient
 from machine import UART
 
@@ -114,6 +115,8 @@ if "gauges" in _cfg:
                 "min": float(g.get("min", 0)),
                 "max": float(g.get("max", 100)),
                 "max_steps": int(g.get("max_steps", 4000)),
+                "speed": float(g.get("speed", 5000.0)),
+                "acceleration": float(g.get("acceleration", 6000.0)),
                 "entity_name": g.get("entity_name", f"Gauge {i + 1}"),
                 "unit": g.get("unit", ""),
                 "ws2812_red": tuple(led_cfg.get("ws2812_red", [255, 0, 0])),
@@ -128,6 +131,8 @@ else:
             "min": float(_cfg.get("gauge_min", 0)),
             "max": float(_cfg.get("gauge_max", 7300)),
             "max_steps": int(_cfg.get("gauge_max_steps", 4000)),
+            "speed": float(_cfg.get("gauge_speed", 5000.0)),
+            "acceleration": float(_cfg.get("gauge_acceleration", 6000.0)),
             "entity_name": _cfg.get("gauge_entity_name", "Selsyn 1 Power"),
             "unit": _cfg.get("gauge_unit", "W"),
             "ws2812_red": tuple(_cfg.get("ws2812_red", [255, 0, 0])),
@@ -194,6 +199,14 @@ def gauge_zero(gauge_idx):
     arduino_send(f"ZERO {gauge_idx}")
 
 
+def gauge_set_speed(gauge_idx, speed):
+    arduino_send(f"SPEED {gauge_idx} {speed}")
+
+
+def gauge_set_acceleration(gauge_idx, acceleration):
+    arduino_send(f"ACCEL {gauge_idx} {acceleration}")
+
+
 def _set_led(gauge_idx, idx, r, g, b):
     arduino_send(f"LED {gauge_idx} {idx} {r} {g} {b}")
 
@@ -251,6 +264,8 @@ def _apply_blink_or_led(gauge_idx, led_idx, color, effect):
 
 gauge_targets = [g["min"] for g in gauges]
 gauge_last_rezero = [utime.ticks_ms() for _ in gauges]
+gauge_speeds = [g["speed"] for g in gauges]
+gauge_accelerations = [g["acceleration"] for g in gauges]
 
 backlight_color = [(0, 0, 0) for _ in range(num_gauges)]
 backlight_brightness = [100 for _ in range(num_gauges)]
@@ -378,6 +393,12 @@ def make_gauge_topics(prefix, gauge_id):
         "status": f"{prefix}/gauge{gauge_id}/status",
         "zero": f"{prefix}/gauge{gauge_id}/zero",
         "disc": f"homeassistant/number/{MQTT_CLIENT_ID}_g{gauge_id}/config",
+        "speed": f"{prefix}/gauge{gauge_id}/speed/set",
+        "speed_state": f"{prefix}/gauge{gauge_id}/speed/state",
+        "speed_disc": f"homeassistant/number/{MQTT_CLIENT_ID}_g{gauge_id}_speed/config",
+        "acceleration": f"{prefix}/gauge{gauge_id}/acceleration/set",
+        "acceleration_state": f"{prefix}/gauge{gauge_id}/acceleration/state",
+        "acceleration_disc": f"homeassistant/number/{MQTT_CLIENT_ID}_g{gauge_id}_acceleration/config",
         "led_red": f"{prefix}/gauge{gauge_id}/led/red/set",
         "led_green": f"{prefix}/gauge{gauge_id}/led/green/set",
         "led_bl": f"{prefix}/gauge{gauge_id}/led/backlight/set",
@@ -503,6 +524,32 @@ def on_message(topic, payload):
                 warn(f"Invalid set value for gauge {i}: '{payload}'")
             return
 
+        if topic == gt["speed"]:
+            try:
+                speed = float(payload)
+                if speed <= 0.0:
+                    raise ValueError
+                gauge_speeds[i] = speed
+                gauge_set_speed(i, speed)
+                _publish(gt["speed_state"], str(speed), retain=True)
+                info(f"Gauge {i} speed -> {speed}")
+            except ValueError:
+                warn(f"Invalid speed for gauge {i}: '{payload}'")
+            return
+
+        if topic == gt["acceleration"]:
+            try:
+                acceleration = float(payload)
+                if acceleration <= 0.0:
+                    raise ValueError
+                gauge_accelerations[i] = acceleration
+                gauge_set_acceleration(i, acceleration)
+                _publish(gt["acceleration_state"], str(acceleration), retain=True)
+                info(f"Gauge {i} acceleration -> {acceleration}")
+            except ValueError:
+                warn(f"Invalid acceleration for gauge {i}: '{payload}'")
+            return
+
         if topic == gt["led_red"]:
             try:
                 data = ujson.loads(payload)
@@ -680,6 +727,8 @@ def _subscribe_all(c):
         prefix = f"{MQTT_PREFIX}/gauge{i}"
         c.subscribe(f"{prefix}/set")
         c.subscribe(f"{prefix}/zero")
+        c.subscribe(f"{prefix}/speed/set")
+        c.subscribe(f"{prefix}/acceleration/set")
         c.subscribe(f"{prefix}/led/red/set")
         c.subscribe(f"{prefix}/led/green/set")
         c.subscribe(f"{prefix}/led/backlight/set")
@@ -707,6 +756,10 @@ def connect_mqtt():
 
 _mqtt_check_interval_ms = 30000
 _last_mqtt_check = 0
+_discovery_phases = ()
+_discovery_phase_idx = 0
+_last_discovery_ms = 0
+_DISCOVERY_INTERVAL_MS = 500
 
 
 def check_mqtt():
@@ -742,7 +795,7 @@ def check_mqtt():
             client_ref.connect()
             _mqtt_connected = True
             info("MQTT reconnected!")
-            publish_discovery(client_ref)
+            schedule_discovery()
             _subscribe_all(client_ref)
             publish_online(client_ref)
             publish_state(client_ref)
@@ -756,6 +809,199 @@ def check_mqtt():
     return False
 
 
+def _discovery_pause(client, count=5, delay_ms=25):
+    for _ in range(count):
+        client.check_msg()
+        utime.sleep_ms(delay_ms)
+    gc.collect()
+
+
+def _publish_discovery_entity(client, topic, payload, log_msg):
+    client.publish(topic, ujson.dumps(payload), retain=True)
+    info(log_msg)
+
+
+def _publish_gauge_discovery(client, dev_ref):
+    for i, g in enumerate(gauges):
+        gt = gauge_topics[i]
+        _publish_discovery_entity(
+            client,
+            gt["disc"],
+            {
+                "name": g["entity_name"],
+                "unique_id": f"{MQTT_CLIENT_ID}_g{i}",
+                "cmd_t": gt["set"],
+                "stat_t": gt["state"],
+                "avty_t": gt["status"],
+                "min": g["min"],
+                "max": g["max"],
+                "step": 1,
+                "unit_of_meas": g["unit"],
+                "icon": "mdi:gauge",
+                "dev": dev_ref,
+            },
+            f"Discovery: gauge {i} ({g['name']})",
+        )
+    _discovery_pause(client)
+
+
+def _publish_speed_discovery(client, dev_ref):
+    for i, g in enumerate(gauges):
+        gt = gauge_topics[i]
+        _publish_discovery_entity(
+            client,
+            gt["speed_disc"],
+            {
+                "name": f"{g['name']} Speed",
+                "unique_id": f"{MQTT_CLIENT_ID}_g{i}_speed",
+                "cmd_t": gt["speed"],
+                "stat_t": gt["speed_state"],
+                "avty_t": gt["status"],
+                "min": 1,
+                "max": 50000,
+                "step": 1,
+                "mode": "box",
+                "unit_of_meas": "steps/s",
+                "icon": "mdi:speedometer",
+                "entity_category": "config",
+                "dev": dev_ref,
+            },
+            f"Discovery: gauge {i} speed",
+        )
+    _discovery_pause(client)
+
+
+def _publish_acceleration_discovery(client, dev_ref):
+    for i, g in enumerate(gauges):
+        gt = gauge_topics[i]
+        _publish_discovery_entity(
+            client,
+            gt["acceleration_disc"],
+            {
+                "name": f"{g['name']} Acceleration",
+                "unique_id": f"{MQTT_CLIENT_ID}_g{i}_acceleration",
+                "cmd_t": gt["acceleration"],
+                "stat_t": gt["acceleration_state"],
+                "avty_t": gt["status"],
+                "min": 1,
+                "max": 100000,
+                "step": 1,
+                "mode": "box",
+                "unit_of_meas": "steps/s2",
+                "icon": "mdi:chart-bell-curve-cumulative",
+                "entity_category": "config",
+                "dev": dev_ref,
+            },
+            f"Discovery: gauge {i} acceleration",
+        )
+    _discovery_pause(client)
+
+
+def _publish_indicator_led_discovery(client, dev_ref):
+    for i, g in enumerate(gauges):
+        gt = gauge_topics[i]
+        _publish_discovery_entity(
+            client,
+            gt["led_red_disc"],
+            {
+                "name": f"{g['name']} Dial Red LED",
+                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_red",
+                "cmd_t": gt["led_red"],
+                "stat_t": gt["led_red_state"],
+                "schema": "json",
+                "supported_color_modes": ["onoff"],
+                "effect": True,
+                "effect_list": _EFFECT_LIST,
+                "icon": "mdi:led-on",
+                "dev": dev_ref,
+                "ret": True,
+            },
+            f"Discovery: gauge {i} red LED",
+        )
+
+        _publish_discovery_entity(
+            client,
+            gt["led_green_disc"],
+            {
+                "name": f"{g['name']} Dial Green LED",
+                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_green",
+                "cmd_t": gt["led_green"],
+                "stat_t": gt["led_green_state"],
+                "schema": "json",
+                "supported_color_modes": ["onoff"],
+                "effect": True,
+                "effect_list": _EFFECT_LIST,
+                "icon": "mdi:led-on",
+                "dev": dev_ref,
+                "ret": True,
+            },
+            f"Discovery: gauge {i} green LED",
+        )
+    _discovery_pause(client)
+
+
+def _publish_backlight_status_discovery(client, dev_ref):
+    for i, g in enumerate(gauges):
+        gt = gauge_topics[i]
+        _publish_discovery_entity(
+            client,
+            gt["led_bl_disc"],
+            {
+                "name": f"{g['name']} Backlight",
+                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_bl",
+                "cmd_t": gt["led_bl"],
+                "stat_t": gt["led_bl_state"],
+                "schema": "json",
+                "supported_color_modes": ["rgb"],
+                "effect": True,
+                "effect_list": _EFFECT_LIST,
+                "icon": "mdi:led-strip",
+                "dev": dev_ref,
+                "ret": True,
+            },
+            f"Discovery: gauge {i} backlight",
+        )
+
+        _publish_discovery_entity(
+            client,
+            gt["status_red_disc"],
+            {
+                "name": f"{g['name']} Channel Status Red",
+                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_status_red",
+                "cmd_t": gt["status_red"],
+                "stat_t": gt["status_red_state"],
+                "schema": "json",
+                "supported_color_modes": ["onoff"],
+                "effect": True,
+                "effect_list": _EFFECT_LIST,
+                "icon": "mdi:led-on",
+                "dev": dev_ref,
+                "ret": True,
+            },
+            f"Discovery: gauge {i} status red",
+        )
+
+        _publish_discovery_entity(
+            client,
+            gt["status_green_disc"],
+            {
+                "name": f"{g['name']} Channel Status Green",
+                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_status_green",
+                "cmd_t": gt["status_green"],
+                "stat_t": gt["status_green_state"],
+                "schema": "json",
+                "supported_color_modes": ["onoff"],
+                "effect": True,
+                "effect_list": _EFFECT_LIST,
+                "icon": "mdi:led-on",
+                "dev": dev_ref,
+                "ret": True,
+            },
+            f"Discovery: gauge {i} status green",
+        )
+    _discovery_pause(client)
+
+
 def publish_discovery(client):
     """Publish all HA MQTT discovery payloads for gauges and LEDs."""
     _dev_ref = _DEVICE
@@ -769,139 +1015,54 @@ def publish_discovery(client):
             f"homeassistant/switch/{MQTT_CLIENT_ID}_g{i}_status_green/config",
         ]:
             client.publish(old_t, b"", retain=True)
+        _discovery_pause(client, count=2, delay_ms=15)
 
-    for i, g in enumerate(gauges):
-        gt = gauge_topics[i]
+    _publish_gauge_discovery(client, _dev_ref)
+    _publish_speed_discovery(client, _dev_ref)
+    _publish_acceleration_discovery(client, _dev_ref)
+    _publish_indicator_led_discovery(client, _dev_ref)
+    _publish_backlight_status_discovery(client, _dev_ref)
 
-        client.publish(
-            gt["disc"],
-            ujson.dumps(
-                {
-                    "name": g["entity_name"],
-                    "unique_id": f"{MQTT_CLIENT_ID}_g{i}",
-                    "cmd_t": gt["set"],
-                    "stat_t": gt["state"],
-                    "avty_t": gt["status"],
-                    "min": g["min"],
-                    "max": g["max"],
-                    "step": 1,
-                    "unit_of_meas": g["unit"],
-                    "icon": "mdi:gauge",
-                    "dev": _dev_ref,
-                }
-            ),
-            retain=True,
+
+def schedule_discovery():
+    global _discovery_phases, _discovery_phase_idx, _last_discovery_ms
+    _dev_ref = _DEVICE
+    _discovery_phases = (
+        lambda client: _clear_legacy_discovery(client),
+        lambda client: _publish_gauge_discovery(client, _dev_ref),
+        lambda client: _publish_speed_discovery(client, _dev_ref),
+        lambda client: _publish_acceleration_discovery(client, _dev_ref),
+        lambda client: _publish_indicator_led_discovery(client, _dev_ref),
+        lambda client: _publish_backlight_status_discovery(client, _dev_ref),
     )
-        info(f"Discovery: gauge {i} ({g['name']})")
+    _discovery_phase_idx = 0
+    _last_discovery_ms = 0
 
-        for _ in range(5):
-            client.check_msg()
-            utime.sleep_ms(10)
 
-        client.publish(
-            gt["led_red_disc"],
-            ujson.dumps({
-                "name": f"{g['name']} Red LED",
-                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_red",
-                "cmd_t": gt["led_red"],
-                "stat_t": gt["led_red_state"],
-                "schema": "json",
-                "supported_color_modes": ["onoff"],
-                "effect": True,
-                "effect_list": _EFFECT_LIST,
-                "icon": "mdi:led-on",
-                "dev": _dev_ref,
-                "ret": True,
-            }),
-            retain=True,
-        )
-        info(f"Discovery: gauge {i} red LED")
+def _clear_legacy_discovery(client):
+    for i in range(num_gauges):
+        for old_t in [
+            f"homeassistant/switch/{MQTT_CLIENT_ID}_g{i}_red/config",
+            f"homeassistant/switch/{MQTT_CLIENT_ID}_g{i}_green/config",
+            f"homeassistant/switch/{MQTT_CLIENT_ID}_g{i}_status_red/config",
+            f"homeassistant/switch/{MQTT_CLIENT_ID}_g{i}_status_green/config",
+        ]:
+            client.publish(old_t, b"", retain=True)
+        _discovery_pause(client, count=2, delay_ms=15)
 
-        client.publish(
-            gt["led_green_disc"],
-            ujson.dumps({
-                "name": f"{g['name']} Green LED",
-                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_green",
-                "cmd_t": gt["led_green"],
-                "stat_t": gt["led_green_state"],
-                "schema": "json",
-                "supported_color_modes": ["onoff"],
-                "effect": True,
-                "effect_list": _EFFECT_LIST,
-                "icon": "mdi:led-on",
-                "dev": _dev_ref,
-                "ret": True,
-            }),
-            retain=True,
-        )
-        info(f"Discovery: gauge {i} green LED")
 
-        for _ in range(5):
-            client.check_msg()
-            utime.sleep_ms(10)
+def service_discovery():
+    global _discovery_phase_idx, _last_discovery_ms
+    if client_ref is None or _discovery_phase_idx >= len(_discovery_phases):
+        return
 
-        client.publish(
-            gt["led_bl_disc"],
-            ujson.dumps(
-                {
-                    "name": f"{g['name']} Backlight",
-                    "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_bl",
-                    "cmd_t": gt["led_bl"],
-                    "stat_t": gt["led_bl_state"],
-                    "schema": "json",
-                    "supported_color_modes": ["rgb"],
-                    "effect": True,
-                    "effect_list": _EFFECT_LIST,
-                    "icon": "mdi:led-strip",
-                    "dev": _dev_ref,
-                    "ret": True,
-                }
-            ),
-            retain=True,
-        )
-        info(f"Discovery: gauge {i} backlight")
+    now = utime.ticks_ms()
+    if _last_discovery_ms and utime.ticks_diff(now, _last_discovery_ms) < _DISCOVERY_INTERVAL_MS:
+        return
 
-        client.publish(
-            gt["status_red_disc"],
-            ujson.dumps({
-                "name": f"{g['name']} Status Red",
-                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_status_red",
-                "cmd_t": gt["status_red"],
-                "stat_t": gt["status_red_state"],
-                "schema": "json",
-                "supported_color_modes": ["onoff"],
-                "effect": True,
-                "effect_list": _EFFECT_LIST,
-                "icon": "mdi:led-on",
-                "dev": _dev_ref,
-                "ret": True,
-            }),
-            retain=True,
-        )
-        info(f"Discovery: gauge {i} status red")
-
-        client.publish(
-            gt["status_green_disc"],
-            ujson.dumps({
-                "name": f"{g['name']} Status Green",
-                "uniq_id": f"{MQTT_CLIENT_ID}_g{i}_status_green",
-                "cmd_t": gt["status_green"],
-                "stat_t": gt["status_green_state"],
-                "schema": "json",
-                "supported_color_modes": ["onoff"],
-                "effect": True,
-                "effect_list": _EFFECT_LIST,
-                "icon": "mdi:led-on",
-                "dev": _dev_ref,
-                "ret": True,
-            }),
-            retain=True,
-        )
-        info(f"Discovery: gauge {i} status green")
-
-        for _ in range(5):
-            client.check_msg()
-            utime.sleep_ms(10)
+    _discovery_phases[_discovery_phase_idx](client_ref)
+    _discovery_phase_idx += 1
+    _last_discovery_ms = utime.ticks_ms()
 
 
 def publish_online(client):
@@ -913,6 +1074,14 @@ def publish_state(client):
     for i in range(num_gauges):
         gt = gauge_topics[i]
         client.publish(gt["state"], str(gauge_targets[i]))
+        client.publish(gt["speed_state"], str(gauge_speeds[i]), retain=True)
+        client.publish(gt["acceleration_state"], str(gauge_accelerations[i]), retain=True)
+
+
+def apply_motion_defaults():
+    for i in range(num_gauges):
+        gauge_set_speed(i, gauge_speeds[i])
+        gauge_set_acceleration(i, gauge_accelerations[i])
 
 
 # ---------------------------------------------------------------------------
@@ -928,11 +1097,10 @@ def main():
     connect_wifi(WIFI_SSID, WIFI_PASSWORD)
 
     connect_mqtt()
-
-    info("Publishing discovery...")
-    publish_discovery(client_ref)
-
     _subscribe_all(client_ref)
+    schedule_discovery()
+
+    apply_motion_defaults()
     info("Draining initial retained messages...")
     for _ in range(50):
         client_ref.check_msg()
@@ -960,6 +1128,7 @@ def main():
         ota.mark_ok()
     except:
         pass
+    gc.collect()
 
     last_heartbeat = utime.ticks_ms()
 
@@ -968,14 +1137,17 @@ def main():
             now = utime.ticks_ms()
 
             check_wifi()
+            gc.collect()
 
             if not check_mqtt():
                 utime.sleep_ms(1000)
                 continue
 
             client_ref.check_msg()
+            service_discovery()
             arduino_recv()
             _flush_backlight_state()
+            gc.collect()
 
             # Periodic re-home
             for i in range(num_gauges):
@@ -988,6 +1160,8 @@ def main():
                 info(f"Heartbeat: {gauge_targets}")
                 publish_state(client_ref)
                 last_heartbeat = now
+                gc.collect()
+                info(f"Heap free: {gc.mem_free()} bytes")
 
             utime.sleep_ms(10)
 
@@ -995,6 +1169,7 @@ def main():
             import sys
             sys.print_exception(e)
             log_err(f"Main loop error: {e} — continuing")
+            gc.collect()
             utime.sleep_ms(100)