justin
e7e04b740e
Diagnostics: removed the always-on right-side Diagnostics dock (it ate screen space on every view). Read Codes now opens a modal dialog listing codes grouped stored/pending/permanent with descriptions (no-start codes bold red); Clear Codes keeps its confirmation, and on re-read pops a dialog only if codes returned. Dropped the View > Show Diagnostics Panel toggle. Gauges: replaced the plain progress-arc with a proper automotive dial -- round face + bezel, major/minor tick marks, a numeric scale (rounded labels), a red needle + center hub, a colored rim arc for the value, and an amber peak tick. Digital readout + name/unit below. Validated headless: no Diagnostics dock; Read Codes opens the Trouble Codes dialog; gauge view renders. obdcore + diagnostics tests still pass. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016yT89n4zR4qbrySoSiEyZs
294 lines
10 KiB
Python
294 lines
10 KiB
Python
"""Custom widgets for the ford-obd GUI: a unit-grouped multi-axis plot, a
|
|
simple single-axis plot, and an arc gauge / gauge grid.
|
|
|
|
All three plot/gauge containers share a small interface so the main window can
|
|
swap between them: add_curve(key,name,unit,color) / set_data(key,xs,ys) /
|
|
remove_curve(key) / clear().
|
|
"""
|
|
import math
|
|
|
|
from PySide6 import QtCore, QtGui, QtWidgets
|
|
import pyqtgraph as pg
|
|
|
|
MAX_EXTRA_AXES = 4 # base left axis + up to 4 right axes (5 units shown)
|
|
|
|
|
|
class SinglePlot(QtWidgets.QWidget):
|
|
"""One shared Y axis. Used for the Normalize (% of range) mode."""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
lay = QtWidgets.QVBoxLayout(self)
|
|
lay.setContentsMargins(0, 0, 0, 0)
|
|
self.pw = pg.PlotWidget()
|
|
self.pw.addLegend(offset=(10, 10))
|
|
self.pw.showGrid(x=True, y=True, alpha=0.25)
|
|
self.pw.setLabel("bottom", "time", units="s")
|
|
lay.addWidget(self.pw)
|
|
self._curves = {}
|
|
|
|
def set_y_label(self, text):
|
|
self.pw.setLabel("left", text)
|
|
|
|
def add_curve(self, key, name, unit, color):
|
|
self._curves[key] = self.pw.plot([], [], name=name, pen=pg.mkPen(color, width=2))
|
|
|
|
def set_data(self, key, xs, ys):
|
|
c = self._curves.get(key)
|
|
if c is not None:
|
|
c.setData(xs, ys)
|
|
|
|
def remove_curve(self, key):
|
|
c = self._curves.pop(key, None)
|
|
if c is not None:
|
|
self.pw.removeItem(c)
|
|
leg = self.pw.plotItem.legend
|
|
if leg:
|
|
try:
|
|
leg.removeItem(c)
|
|
except Exception:
|
|
pass
|
|
|
|
def clear(self):
|
|
for key in list(self._curves):
|
|
self.remove_curve(key)
|
|
|
|
def set_background(self, bg):
|
|
self.pw.setBackground(bg)
|
|
|
|
|
|
class MultiAxisPlot(QtWidgets.QWidget):
|
|
"""Overlay with one Y axis PER UNIT (psi / V / rpm / C / %), so mixed-scale
|
|
signals are all readable at their true values. Curves are grouped by unit;
|
|
each extra unit gets its own right-hand axis + linked ViewBox."""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
lay = QtWidgets.QVBoxLayout(self)
|
|
lay.setContentsMargins(0, 0, 0, 0)
|
|
self.glw = pg.GraphicsLayoutWidget()
|
|
lay.addWidget(self.glw)
|
|
self.p = self.glw.addPlot()
|
|
self.p.showGrid(x=True, y=True, alpha=0.2)
|
|
self.p.setLabel("bottom", "time", units="s")
|
|
self.legend = self.p.addLegend(offset=(10, 10))
|
|
self.base_vb = self.p.vb
|
|
self._units = {} # unit -> {vb, ax, base}
|
|
self._curves = {} # key -> {curve, unit}
|
|
self._next_col = 3
|
|
self.base_vb.sigResized.connect(self._sync)
|
|
|
|
def _ensure_unit(self, unit):
|
|
e = self._units.get(unit)
|
|
if e is not None:
|
|
return e
|
|
if not self._units: # first unit -> base left axis
|
|
self.p.setLabel("left", unit)
|
|
e = {"vb": self.base_vb, "ax": self.p.getAxis("left"), "base": True}
|
|
elif len(self._units) - 1 < MAX_EXTRA_AXES: # add a right axis
|
|
vb = pg.ViewBox()
|
|
ax = pg.AxisItem("right")
|
|
self.p.layout.addItem(ax, 2, self._next_col)
|
|
self._next_col += 1
|
|
self.p.scene().addItem(vb)
|
|
ax.linkToView(vb)
|
|
vb.setXLink(self.p)
|
|
ax.setLabel(unit)
|
|
e = {"vb": vb, "ax": ax, "base": False}
|
|
self._sync()
|
|
else: # out of axes -> reuse base
|
|
e = self._units[next(iter(self._units))]
|
|
self._units[unit] = e
|
|
return e
|
|
|
|
def add_curve(self, key, name, unit, color):
|
|
e = self._ensure_unit(unit)
|
|
curve = pg.PlotCurveItem(pen=pg.mkPen(color, width=2), name=name)
|
|
e["vb"].addItem(curve)
|
|
self.legend.addItem(curve, name)
|
|
self._curves[key] = {"curve": curve, "unit": unit}
|
|
|
|
def set_data(self, key, xs, ys):
|
|
c = self._curves.get(key)
|
|
if c is not None:
|
|
c["curve"].setData(xs, ys)
|
|
|
|
def remove_curve(self, key):
|
|
c = self._curves.pop(key, None)
|
|
if not c:
|
|
return
|
|
e = self._units.get(c["unit"])
|
|
if e:
|
|
e["vb"].removeItem(c["curve"])
|
|
try:
|
|
self.legend.removeItem(c["curve"])
|
|
except Exception:
|
|
pass
|
|
|
|
def clear(self):
|
|
for key in list(self._curves):
|
|
self.remove_curve(key)
|
|
|
|
def set_y_label(self, _text):
|
|
pass # multi-axis labels itself per unit
|
|
|
|
def set_background(self, bg):
|
|
self.glw.setBackground(bg)
|
|
|
|
def _sync(self):
|
|
rect = self.base_vb.sceneBoundingRect()
|
|
for e in self._units.values():
|
|
if not e["base"]:
|
|
e["vb"].setGeometry(rect)
|
|
e["vb"].linkedViewChanged(self.base_vb, e["vb"].XAxis)
|
|
|
|
|
|
class ArcGauge(QtWidgets.QWidget):
|
|
"""A 270-degree arc gauge for a single signal: filled arc to the current
|
|
value, peak tick, big numeric readout, name + unit."""
|
|
|
|
def __init__(self, name, unit, vmin, vmax, accent="#3cb44b"):
|
|
super().__init__()
|
|
self.name = name
|
|
self.unit = unit
|
|
self.vmin = float(vmin)
|
|
self.vmax = float(vmax) if vmax != vmin else float(vmin) + 1.0
|
|
self.accent = QtGui.QColor(accent)
|
|
self.value = None
|
|
self.peak = None
|
|
self.setMinimumSize(172, 176)
|
|
|
|
def set_value(self, v, peak=None):
|
|
self.value = v
|
|
self.peak = peak
|
|
self.update()
|
|
|
|
def _frac(self, v):
|
|
return max(0.0, min(1.0, (v - self.vmin) / (self.vmax - self.vmin)))
|
|
|
|
# gauge geometry: a 270-degree dial, gap at the bottom (like a tach)
|
|
_START = 225.0 # value=min angle (math degrees, 0=3 o'clock, CCW+)
|
|
_SWEEP = 270.0 # clockwise as value rises
|
|
|
|
def _ang(self, frac):
|
|
return self._START - self._SWEEP * max(0.0, min(1.0, frac))
|
|
|
|
def paintEvent(self, _ev):
|
|
p = QtGui.QPainter(self)
|
|
p.setRenderHint(QtGui.QPainter.Antialiasing)
|
|
w, h = self.width(), self.height()
|
|
p.fillRect(self.rect(), QtGui.QColor("#141414"))
|
|
|
|
side = min(w, h - 14)
|
|
R = side / 2 - 6
|
|
cx, cy = w / 2.0, R + 8
|
|
|
|
def pt(ang_deg, r):
|
|
a = math.radians(ang_deg)
|
|
return QtCore.QPointF(cx + r * math.cos(a), cy - r * math.sin(a))
|
|
|
|
# dial face + bezel
|
|
p.setPen(QtGui.QPen(QtGui.QColor("#2a2a2a"), 3))
|
|
p.setBrush(QtGui.QColor("#0c0c0c"))
|
|
p.drawEllipse(QtCore.QPointF(cx, cy), R, R)
|
|
|
|
# value progress arc just inside the rim
|
|
rimrect = QtCore.QRectF(cx - R + 7, cy - R + 7, 2 * (R - 7), 2 * (R - 7))
|
|
if self.value is not None:
|
|
pen = QtGui.QPen(QtGui.QColor(self.accent), 4)
|
|
pen.setCapStyle(QtCore.Qt.FlatCap)
|
|
p.setPen(pen)
|
|
p.drawArc(rimrect, int(self._START * 16),
|
|
int(-self._SWEEP * self._frac(self.value) * 16))
|
|
|
|
# tick marks + numeric scale
|
|
majors = 6
|
|
fnt = p.font(); fnt.setPointSize(7); p.setFont(fnt)
|
|
for i in range(majors * 5 + 1):
|
|
frac = i / (majors * 5)
|
|
a = self._ang(frac)
|
|
major = (i % 5 == 0)
|
|
p.setPen(QtGui.QPen(QtGui.QColor("#ddd" if major else "#555"),
|
|
2 if major else 1))
|
|
p.drawLine(pt(a, R - 3), pt(a, R - (13 if major else 7)))
|
|
if major:
|
|
val = self.vmin + frac * (self.vmax - self.vmin)
|
|
span = abs(self.vmax - self.vmin)
|
|
lbl = f"{val:.0f}" if span >= 50 else f"{val:.1f}" if span >= 5 else f"{val:g}"
|
|
lp = pt(a, R - 25)
|
|
p.setPen(QtGui.QColor("#9a9a9a"))
|
|
p.drawText(QtCore.QRectF(lp.x() - 18, lp.y() - 7, 36, 14),
|
|
QtCore.Qt.AlignCenter, lbl)
|
|
|
|
# peak marker (thin amber tick)
|
|
if self.peak is not None and self.value is not None and self.peak != self.value:
|
|
a = self._ang(self._frac(self.peak))
|
|
p.setPen(QtGui.QPen(QtGui.QColor("#e6c84b"), 2))
|
|
p.drawLine(pt(a, R - 3), pt(a, R - 14))
|
|
|
|
# needle
|
|
if self.value is not None:
|
|
a = self._ang(self._frac(self.value))
|
|
tip = pt(a, R - 16)
|
|
b1 = pt(a + 90, 4.5)
|
|
b2 = pt(a - 90, 4.5)
|
|
tail = pt(a + 180, 10)
|
|
path = QtGui.QPainterPath()
|
|
path.moveTo(b1); path.lineTo(tip); path.lineTo(b2); path.lineTo(tail)
|
|
path.closeSubpath()
|
|
p.setPen(QtCore.Qt.NoPen)
|
|
p.setBrush(QtGui.QColor("#e6194B"))
|
|
p.drawPath(path)
|
|
# hub
|
|
p.setBrush(QtGui.QColor("#999")); p.setPen(QtCore.Qt.NoPen)
|
|
p.drawEllipse(QtCore.QPointF(cx, cy), 5, 5)
|
|
|
|
# digital readout (lower face)
|
|
p.setPen(QtGui.QColor("#fff"))
|
|
fnt.setPointSize(13); fnt.setBold(True); p.setFont(fnt)
|
|
val = "--" if self.value is None else f"{self.value:g}"
|
|
p.drawText(QtCore.QRectF(cx - 55, cy + R * 0.30, 110, 22),
|
|
QtCore.Qt.AlignCenter, val)
|
|
# name + unit
|
|
fnt.setPointSize(8); fnt.setBold(False); p.setFont(fnt)
|
|
p.setPen(QtGui.QColor("#9a9a9a"))
|
|
p.drawText(QtCore.QRectF(0, h - 15, w, 14), QtCore.Qt.AlignCenter,
|
|
f"{self.name} ({self.unit})" if self.unit else self.name)
|
|
p.end()
|
|
|
|
|
|
class GaugeGrid(QtWidgets.QScrollArea):
|
|
"""Scrollable grid of ArcGauges, one per signal."""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.setWidgetResizable(True)
|
|
self.setStyleSheet("QScrollArea, QWidget { background: #111; }")
|
|
self._inner = QtWidgets.QWidget()
|
|
self._grid = QtWidgets.QGridLayout(self._inner)
|
|
self._grid.setSpacing(8)
|
|
self.setWidget(self._inner)
|
|
self._gauges = {}
|
|
self._cols = 4
|
|
|
|
def rebuild(self, specs):
|
|
"""specs: list of (key, name, unit, vmin, vmax, accent)."""
|
|
while self._grid.count():
|
|
item = self._grid.takeAt(0)
|
|
wdg = item.widget()
|
|
if wdg:
|
|
wdg.deleteLater()
|
|
self._gauges = {}
|
|
for i, (key, name, unit, vmin, vmax, accent) in enumerate(specs):
|
|
g = ArcGauge(name, unit, vmin, vmax, accent)
|
|
self._gauges[key] = g
|
|
self._grid.addWidget(g, i // self._cols, i % self._cols)
|
|
|
|
def keys(self):
|
|
return set(self._gauges)
|
|
|
|
def set_value(self, key, v, peak=None):
|
|
g = self._gauges.get(key)
|
|
if g is not None:
|
|
g.set_value(v, peak)
|