Add graph/cores widgets, net rates, RAPL watts, backlight schedule, serial reconnect

Addressing recurring upstream asks from the open-issue tracker:
- graph widget: single/multi-series line history, right-anchored,
  sampled while the page is visible (mathoudebine#715)
- cores widget: per-core CPU mini-bars (mathoudebine#729)
- local values: net_down/net_up with auto-scaled human units (mathoudebine#447,
  mathoudebine#720, mathoudebine#152), cpu_watts via intel RAPL (mathoudebine#254; unit grants sysfs read
  via root ExecStartPre), fan_rpm (mathoudebine#192), nvme_temp (mathoudebine#182)
- screen.schedule in display.yaml: dim or switch off the backlight in
  time windows -- night/away mode (mathoudebine#531, mathoudebine#687)
- push_frame reopens the serial port and re-pushes on SerialException
  (mathoudebine#562-style wedges) instead of dying
- HOST page gains cores + net rates; new TRENDS page with 4 graphs

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Fumunchu

DISPLAY.md

@@ -40,11 +40,21 @@ Home Assistant, kubectl, etc. is one small class in `apps/common.py`
 ## Page schema
 
 See the comment block at the top of `pages.yaml` — widgets (`bar`, `metric`,
-`radial`, `text`), format strings over a value namespace (local psutil values
-+ per-page query results + derived expressions), threshold/conditional color
-specs, optional `background:` art from any stock theme (the shipped CYBERDECK
-page traces live radial gauges over the stock Cyberdeck theme art), and
-`type: netmap` pages that embed the netmap app in the rotation.
+`radial`, `text`, `graph`, `cores`), format strings over a value namespace
+(local psutil values + per-page query results + derived expressions),
+threshold/conditional color specs, optional `background:` art from any stock
+theme (the shipped CYBERDECK page traces live radial gauges over the stock
+Cyberdeck theme art), and `type: netmap` pages that embed the netmap app in
+the rotation.
+
+Local values include network rates with auto-scaled units (`net_down_h`),
+per-core CPU (`cpu_cores`), CPU package power via RAPL (`cpu_watts`),
+`fan_rpm` and `nvme_temp` where the platform exposes them.
+
+`screen.schedule` in `display.yaml` dims or switches the panel off during
+time windows (night/away mode). Serial hiccups are handled by reopening the
+port and re-pushing the frame (panels are known to wedge after long sessions,
+upstream #562).
 
 ## Preview without a screen
 

apps/carousel.py

@@ -92,9 +92,13 @@ def run(lcd, display_cfg):
     import psutil
     psutil.cpu_percent()  # prime the first reading
 
+    sched = c.ScreenScheduler(lcd, display_cfg.get("screen"))
     idx = 0
     prev = None  # last frame on the panel; every push is a diff against it
     while True:
+        if not sched.tick():  # night/away window: panel off, check back shortly
+            time.sleep(30)
+            continue
         try:
             cfg = load_pages_cfg(pages_file)  # live reload; keep last good on error
         except Exception:

apps/common.py

@@ -7,10 +7,12 @@
 import time
 import json
 import socket
+import collections
 import urllib.parse
 import urllib.request
 
 import psutil
+from serial import SerialException
 from PIL import Image, ImageChops, ImageDraw, ImageFont
 
 BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # repo root
@@ -112,10 +114,90 @@ def fmt_uptime():
     return f"{d}d {h}h" if d else f"{h}h {s // 60}m"
 
 
+_RATE_STATE = {}
+
+
+def _delta_rate(key, current, now):
+    """Per-second rate from a monotonically increasing counter; None on first call."""
+    prev = _RATE_STATE.get(key)
+    _RATE_STATE[key] = (current, now)
+    if prev is None:
+        return None
+    dv, dt = current - prev[0], now - prev[1]
+    return dv / dt if dt > 0 and dv >= 0 else None
+
+
+_NET_SKIP = ("lo", "veth", "docker", "br-", "cni", "flannel", "kube", "tailscale")
+
+
+def _net_counters():
+    """Aggregate rx/tx bytes over physical-ish NICs (skips loopback/bridge/CNI)."""
+    rx = tx = 0
+    for name, io in psutil.net_io_counters(pernic=True).items():
+        if any(name.startswith(p) for p in _NET_SKIP):
+            continue
+        rx += io.bytes_recv
+        tx += io.bytes_sent
+    return rx, tx
+
+
+def human_rate(bps):
+    if bps is None:
+        return "-"
+    for unit in ("B/s", "KB/s", "MB/s", "GB/s"):
+        if bps < 1000 or unit == "GB/s":
+            break
+        bps /= 1000.0
+    return f"{bps:.0f} {unit}" if unit == "B/s" else f"{bps:.1f} {unit}"
+
+
+def _cpu_watts(now):
+    """CPU package power from intel RAPL (None if unreadable/AMD without rapl)."""
+    try:
+        with open("/sys/class/powercap/intel-rapl:0/energy_uj") as f:
+            uj = int(f.read())
+    except Exception:
+        return None
+    rate = _delta_rate("rapl_uj", uj, now)
+    return rate / 1e6 if rate is not None else None
+
+
+def _fan_rpm():
+    try:
+        for entries in psutil.sensors_fans().values():
+            if entries:
+                return entries[0].current
+    except Exception:
+        pass
+    return None
+
+
+def _nvme_temp():
+    try:
+        t = psutil.sensors_temperatures().get("nvme")
+        if t:
+            return max(s.current for s in t)
+    except Exception:
+        pass
+    return None
+
+
 def local_values():
     vm = psutil.virtual_memory()
     du = psutil.disk_usage("/")
+    now = time.monotonic()
+    rx, tx = _net_counters()
+    net_down = _delta_rate("net_rx", rx, now)
+    net_up = _delta_rate("net_tx", tx, now)
     return {
+        "net_down": net_down,
+        "net_up": net_up,
+        "net_down_h": human_rate(net_down),
+        "net_up_h": human_rate(net_up),
+        "cpu_cores": psutil.cpu_percent(percpu=True),
+        "cpu_watts": _cpu_watts(now),
+        "fan_rpm": _fan_rpm(),
+        "nvme_temp": _nvme_temp(),
         "cpu_pct": psutil.cpu_percent(),
         "ram_pct": vm.percent,
         "ram_used_g": vm.used / 1e9,
@@ -232,16 +314,67 @@ def draw_text(d, w, vals):
            fill=resolve_color(w.get("color"), vals), anchor=w.get("anchor", "mm"))
 
 
-WIDGETS = {"bar": draw_bar, "metric": draw_metric, "radial": draw_radial, "text": draw_text}
+_HISTORY = {}
+_SERIES_COLORS = ("accent", "ok", "warn", "bad")
 
 
-def push_frame(lcd, new, old=None, band=20):
-    """Push only the horizontal bands of `new` that differ from `old`.
+def draw_graph(d, w, vals):
+    """Line graph over a value's recent history (sampled while the page shows).
+    Single series via `value:`, multiple via `values: [a, b]` (+ `colors:`)."""
+    x, y = w["x"], w["y"]
+    gw, gh = w.get("w", 200), w.get("h", 60)
+    samples = int(w.get("samples", 60))
+    series = w.get("values") or ([w["value"]] if w.get("value") else [])
+    colors = w.get("colors") or []
+    d.rectangle([x, y, x + gw, y + gh], outline=TRACK)
+    if w.get("label"):
+        d.text((x, y - 18), str(w["label"]), font=font(13, "Medium"),
+               fill=COLORS["dim"], anchor="la")
+    if w.get("text"):
+        d.text((x + gw, y - 18), fmt(w["text"], vals), font=font(13, "Medium"),
+               fill=COLORS["fg"], anchor="ra")
+    vmin = float(w.get("min", 0))
+    for si, name in enumerate(series):
+        key = f"{name}@{x},{y}"
+        hist = _HISTORY.get(key)
+        if hist is None or hist.maxlen != samples:
+            hist = _HISTORY[key] = collections.deque(hist or [], maxlen=samples)
+        v = vals.get(name)
+        if isinstance(v, (int, float)):
+            hist.append(float(v))
+        if len(hist) < 2:
+            continue
+        vmax = float(w["max"]) if w.get("max") is not None else (max(hist) or 1.0)
+        span = max(vmax - vmin, 1e-9)
+        pad = samples - len(hist)  # anchor newest sample to the right edge
+        pts = [(x + gw * (pad + i) / (samples - 1),
+                y + gh - gh * min(max((val - vmin) / span, 0.0), 1.0))
+               for i, val in enumerate(hist)]
+        cname = colors[si] if si < len(colors) else _SERIES_COLORS[si % len(_SERIES_COLORS)]
+        d.line(pts, fill=COLORS.get(cname, COLORS["accent"]), width=2)
+
+
+def draw_cores(d, w, vals):
+    """One mini vertical bar per CPU core."""
+    cores = vals.get("cpu_cores") or []
+    x, y, h = w["x"], w["y"], w.get("h", 40)
+    bw, gap = w.get("bar_w", 10), w.get("gap", 4)
+    if w.get("label"):
+        d.text((x, y - 18), str(w["label"]), font=font(13, "Medium"),
+               fill=COLORS["dim"], anchor="la")
+    for i, p in enumerate(cores):
+        cx = x + i * (bw + gap)
+        d.rectangle([cx, y, cx + bw, y + h], fill=TRACK)
+        fh = int(h * min(p, 100) / 100)
+        if fh:
+            d.rectangle([cx, y + h - fh, cx + bw, y + h], fill=threshold_color(p))
 
-    This is what keeps the screen wipe-free: value ticks push a few tiny
-    rectangles, and even page transitions skip unchanged chrome and blank
-    space. With old=None the full frame is pushed (first frame only).
-    """
+
+WIDGETS = {"bar": draw_bar, "metric": draw_metric, "radial": draw_radial,
+           "text": draw_text, "graph": draw_graph, "cores": draw_cores}
+
+
+def _push_bands(lcd, new, old, band):
     if old is None:
         lcd.DisplayPILImage(new, 0, 0)
         return
@@ -255,6 +388,72 @@ def push_frame(lcd, new, old=None, band=20):
             lcd.DisplayPILImage(new.crop((x0, y0 + by0, x1, y0 + by1)), x0, y0 + by0)
 
 
+def push_frame(lcd, new, old=None, band=20):
+    """Push only the horizontal bands of `new` that differ from `old`.
+
+    Value ticks push a few tiny rectangles; page transitions skip unchanged
+    chrome and blank space. With old=None the full frame is pushed.
+
+    On a serial hiccup (devices are known to wedge after hours, upstream #562)
+    the port is reopened once and the full frame re-pushed.
+    """
+    try:
+        _push_bands(lcd, new, old, band)
+    except (SerialException, OSError):
+        try:
+            lcd.closeSerial()
+        except Exception:
+            pass
+        time.sleep(2)
+        lcd.openSerial()
+        _push_bands(lcd, new, None, band)  # panel state unknown -> full redraw
+
+
+def _parse_hm(s):
+    hh, mm = str(s).split(":")
+    return int(hh) * 60 + int(mm)
+
+
+def _in_window(now_min, frm, to):
+    return frm <= now_min < to if frm <= to else (now_min >= frm or now_min < to)
+
+
+class ScreenScheduler:
+    """Applies `screen.schedule` windows from display.yaml: dim the backlight
+    or switch the panel off during time ranges (night/away mode)."""
+
+    def __init__(self, lcd, screen_cfg):
+        self.lcd = lcd
+        cfg = screen_cfg or {}
+        self.default = int(cfg.get("brightness", 20))
+        self.windows = cfg.get("schedule") or []
+        self.applied = ("on", self.default)
+
+    def tick(self):
+        """Apply the window for the current time; False while the panel is off."""
+        t = time.localtime()
+        now_min = t.tm_hour * 60 + t.tm_min
+        state = ("on", self.default)
+        for win in self.windows:
+            try:
+                if _in_window(now_min, _parse_hm(win.get("from", "00:00")),
+                              _parse_hm(win.get("to", "00:00"))):
+                    state = ("off", 0) if win.get("off") \
+                        else ("on", int(win.get("brightness", self.default)))
+                    break
+            except Exception:
+                continue
+        if state != self.applied:
+            if state[0] == "off":
+                self.lcd.ScreenOff()
+            else:
+                if self.applied[0] == "off":
+                    self.lcd.ScreenOn()
+                self.lcd.SetBrightness(state[1])
+            self.applied = state
+        return state[0] == "on"
+
+
 # ---------- lcd ----------
 def init_lcd(orientation="landscape", brightness=20):
     from library.lcd.lcd_comm_rev_a import LcdCommRevA, Orientation

apps/netmap.py

@@ -80,8 +80,12 @@ def run(lcd, display_cfg):
 
     signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
     signal.signal(signal.SIGINT, lambda *_: sys.exit(0))
+    sched = c.ScreenScheduler(lcd, display_cfg.get("screen"))
     prev = None
     while True:
+        if not sched.tick():
+            time.sleep(30)
+            continue
         frame = render(gather_hosts(src, nm_cfg), nm_cfg)
         c.push_frame(lcd, frame, prev)
         prev = frame

display.yaml

@@ -6,6 +6,11 @@ mode: carousel        # standard | carousel | netmap
 screen:
   orientation: landscape       # landscape | reverse_landscape
   brightness: 20
+  # Night/away mode: dim or switch the panel off during time windows.
+  # Windows are checked every loop tick; first match wins. Applied on restart.
+  # schedule:
+  #   - {from: "22:30", to: "06:30", brightness: 5}
+  #   - {from: "01:00", to: "06:00", off: true}
 
 # Named data sources. Apps reference these by name; `prom` is the default.
 # Add more prometheus endpoints (or future source types) here.

pages.yaml

@@ -11,6 +11,9 @@
 #   radial: {type: radial, x, y, r, width, pct: <value-name>, text, size, label, track: true}
 #           arc gauge from 12 o'clock; omit `track` to trace background ring art
 #   text:   {type: text, x, y, size, weight, family, anchor, text: "<format>", color: <spec>}
+#   graph:  {type: graph, x, y, w, h, value: <name> | values: [..], colors: [..],
+#            min, max, samples, label, text} -- history sampled while page is visible
+#   cores:  {type: cores, x, y, h, bar_w, gap, label} -- per-core CPU mini-bars
 #
 # Page types:
 #   (default)       widget page as below
@@ -26,7 +29,9 @@
 #
 # text format: python format string over the value namespace; unavailable -> "-".
 # Local values (always): cpu_pct ram_pct ram_used_g ram_total_g disk_pct
-#                        disk_used_g disk_total_g temp load1 uptime
+#                        disk_used_g disk_total_g temp load1 uptime time_hm
+#                        net_down net_up (B/s)  net_down_h net_up_h (auto-unit)
+#                        cpu_cores (list)  cpu_watts (RAPL)  fan_rpm  nvme_temp
 #
 # color spec:
 #   fg | dim | accent | ok | warn | bad      fixed color
@@ -45,6 +50,20 @@ pages:
       - {type: metric, x: 300, y: 58,  label: TEMP,   text: "{temp:.0f}°C", color: "auto:temp:75:90"}
       - {type: metric, x: 300, y: 138, label: LOAD,   text: "{load1:.2f}"}
       - {type: metric, x: 300, y: 218, label: UPTIME, text: "{uptime}"}
+      - {type: cores,  x: 16,  y: 248, h: 36, bar_w: 10, gap: 4, label: CORES}
+      - {type: text,   x: 150, y: 254, size: 13, anchor: lm, text: "DN {net_down_h}"}
+      - {type: text,   x: 150, y: 274, size: 13, anchor: lm, text: "UP {net_up_h}"}
+
+  - title: TRENDS
+    widgets:
+      - {type: graph, x: 16,  y: 84,  w: 215, h: 80, values: [cpu_pct, ram_pct], colors: [accent, ok],
+         max: 100, samples: 90, label: CPU / RAM, text: "{cpu_pct:.0f}% / {ram_pct:.0f}%"}
+      - {type: graph, x: 250, y: 84,  w: 215, h: 80, value: temp, min: 30, max: 90,
+         samples: 90, label: TEMP, text: "{temp:.0f}°C"}
+      - {type: graph, x: 16,  y: 205, w: 215, h: 80, value: net_down,
+         samples: 90, label: NET DOWN, text: "{net_down_h}"}
+      - {type: graph, x: 250, y: 205, w: 215, h: 80, value: net_up,
+         samples: 90, label: NET UP, text: "{net_up_h}"}
 
   - title: K3S CLUSTER
     queries:

systemd/turing-display.service

@@ -8,6 +8,9 @@ Type=simple
 User=jacquesb
 SupplementaryGroups=dialout
 WorkingDirectory=/home/jacquesb/turing-smart-screen
+# RAPL energy counters are root-only on recent kernels; grant read so the
+# cpu_watts value works (runs as root via the '+' prefix, harmless if absent)
+ExecStartPre=+-/usr/bin/chmod o+r /sys/class/powercap/intel-rapl:0/energy_uj
 ExecStart=/home/jacquesb/turing-smart-screen/venv/bin/python display.py
 Restart=always
 RestartSec=5