From bb8be051ffffa56a01093c9f3aaa80e84748568f Mon Sep 17 00:00:00 2001 From: Christian Kolset Date: Sun, 20 Sep 2026 11:31:07 -0600 Subject: Fix Signal name reset and orphaned references on device reconfigure Apply & Reconnect rebuilt a device's whole Signal list from hardware defaults on every call, silently discarding user/profile-set names, units, and colors even when pins hadn't changed. Add merge_signal_metadata() and call it from ArduinoDevice.remap_pins() and SerialDevice.reconfigure() to reapply the same fields ProfileManager already treats as user overrides, keyed by signal_id. Also close a related gap: removing a pin that a Channel/Plot/Control still referenced left it silently dangling, and SignalProcessor never pruned its latest-value cache, so a derived Channel kept computing off a permanently frozen stale reading. Add SignalProcessor. on_device_reconfigured() to purge that cache, reference_registry. find_references() for a console breadcrumb, and live "missing source" indicators on Plot traces and Channel blocks reusing ControlWidget's existing stale/QSS pattern. Also fixes ControlWidget._write() still enqueuing writes to a channel that no longer exists. Co-Authored-By: Claude Sonnet 5 --- core/reference_registry.py | 32 +++++++++++++++++++++++++++++++- core/signal_processor.py | 17 +++++++++++++++++ 2 files changed, 48 insertions(+), 1 deletion(-) (limited to 'core') diff --git a/core/reference_registry.py b/core/reference_registry.py index b6fcd0f..7ab9649 100644 --- a/core/reference_registry.py +++ b/core/reference_registry.py @@ -20,7 +20,7 @@ hold such a reference and rewrites it. It expects a MainWindow instance reachable from. """ -from typing import Tuple +from typing import List, Tuple Ref = Tuple[str, str] @@ -72,3 +72,33 @@ def propagate_rename(app, old_ref: Ref, new_ref: Ref) -> None: win.refresh_derived() if hasattr(win, "refresh_devices"): win.refresh_devices() + + +def find_references(app, ref: Ref) -> List[str]: + """Reverse lookup: human-readable names of everything currently holding + a (device_id, channel_id) reference — same 5 subsystems propagate_rename() + walks, but collecting instead of rewriting. Used to flag a signal_id an + Apply & Reconnect just dropped (still referenced elsewhere = orphaned), + without blocking the reconnect itself — see devices_window/channels_window/ + control_panel "missing source" indicators, which do the live per-widget + check; this is only for a one-line summary breadcrumb.""" + found: List[str] = [] + + for dc in app.processor.get_derived(): + if ref in dc.sources: + found.append(f"Channel '{dc.name}'") + + chart = getattr(app, "_chart", None) + if chart is not None and chart._cfg is not None: + for pane in chart._cfg.panes: + for tr in pane.traces: + if (tr.device_id, tr.channel_id) == ref: + found.append(f"Plot '{pane.title}' trace '{tr.label or tr.channel_id}'") + + ctrl = getattr(app, "_ctrl", None) + if ctrl is not None: + for spec in ctrl.get_specs(): + if (spec.device_id, spec.channel_id) == ref: + found.append(f"Control '{spec.title}'") + + return found diff --git a/core/signal_processor.py b/core/signal_processor.py index da615b6..c79ea87 100644 --- a/core/signal_processor.py +++ b/core/signal_processor.py @@ -492,6 +492,23 @@ class SignalProcessor(QObject): def all_virtual_channel_ids(self) -> List[str]: return list(self._derived_bufs.keys()) + def on_device_reconfigured(self, device_id: str, current_signal_ids: set) -> List[str]: + """Drop cached state for any signal_id a device's Apply & Reconnect + just removed — otherwise _latest keeps a stale frozen (timestamp, + value) forever (it's only ever written to, never pruned elsewhere), + and a derived Channel sourced from that id keeps silently computing + off that frozen value instead of skipping like a genuinely-missing + source would. Mirrors AcquisitionEngine.on_device_reconfigured(). + Returns the removed signal_ids (those with a cached entry keyed to + this device that's no longer in current_signal_ids), so the caller + can flag any still-dangling references without recomputing the diff.""" + removed = [] + with self._lock: + for key in [k for k in self._latest if k[0] == device_id and k[1] not in current_signal_ids]: + self._latest.pop(key, None) + removed.append(key[1]) + return removed + def clear_history(self): """Clear derived channel buffers and latest-value cache.""" with self._lock: -- cgit v1.2.3