feat(gui): make SmartMTR's meter ballistics project canon. Principle XI. (#5847)

## Why

Follow-up to #5845. While fixing the TGXL peak marker, the TGXL gauge
and the TX Controls applet — sitting side by side, reading the same
transmission — visibly disagreed on how the needle and the peak behaved.
They disagreed because they were running different code.

SmartMTR (the VFO flag meter) is the one meter in the tree whose
ballistics were actually designed rather than tuned by eye. Everything
else had drifted:

- a `setBallistics({0.030f, 0.800f})` override copy-pasted across
**six** applets, silently replacing `MeterSmoother`'s defaults;
- **five** separate hand-rolled hold-then-decay peak markers (Tuner,
Amp, Acom, Spe, Vkamp/Tx), no two sharing a hold time or a decay rate.

Jeremy's call: SmartMTR's ballistics are canon.

## What

**One smoother.** `MeterSmoother`'s defaults are now SmartMTR's
d'Arsonval ballistic — 18.2 ms attack / 269 ms release, derived from its
k=0.60/0.06 at 60 Hz. All six `setBallistics()` overrides are
**deleted** rather than re-tuned; the point is that there is one answer,
not a better second one.

**One peak engine.** `MeterExtremes` — SmartMTR's sliding-window
envelope tracker — is generalised with `scaleMin`/`scaleMax` so it works
in watts as well as its own UNIT span, and `HGauge` now drives its peak
marker from it. The marker glides at constant velocity over a 3 s window
and retires because the window rolls past the peak; there is no hold
phase left to tune. Slew is scaled per gauge so a marker crosses any
range in the same ~3.7 s it takes to cross SmartMTR's.

**Device-reported peaks keep their own path.** The TGXL reports `peak`
and the radio reports MICPEAK — both are real measurements taken closer
to the signal than our polling can get. Those feed `setExternalPeak()`,
SmartMTR's external-peak mode: the marker *is* the device's number,
tracked at the fast peak slew, retiring when the device retires it. The
five applet-side hold/decay implementations are gone.

## Two integration bugs found while wiring this up

Both would have frozen the marker on screen, and both are worth knowing
about before touching this again:

1. The engine clamps the marker to sit at or above the needle. Hand it
the *raw* target and it drags the marker straight to the new reading —
no glide at all. It has to be handed the **painted** needle position.
2. The window's clock only advances inside the animation tick. Stop the
timer while a marker is still standing off the needle and the window can
never expire, so the marker stays stranded at the old peak forever.
`tick()`'s return value is now the sole keep-alive.

## Testing

- Full suite: **523/524**. The one failure is
`connection_panel_size_test`, which fails identically on `main`
(pre-existing, ConnectionPanel 150%-scaling, #4515 territory).
- `tgxl_docked_parity_test` and `amp_applet_test` peak tests rewritten.
They assert the **shape** — the marker glides rather than jumping,
stands off above the needle, and comes back down on its own — not the
constants, so the window can be retuned without rewriting them.
- The amp test discriminates: it failed against both integration bugs
above during development.

## Note for review

This changes how **every** meter in the app moves, not just the two that
prompted it. That is the intent, but it is worth eyes on: if some meter
was quietly depending on the slower 800 ms release to look right, this
will change it.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01AmTu3avSWtEovX1kuuZsWn

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: jensenpat <patjensen@gmail.com>

Author: 3 people

src/gui/AcomApplet.cpp

@@ -141,7 +141,7 @@ AcomApplet::AcomApplet(QWidget* parent)
     m_pwrLabel->setText("PWR");
     m_pwrGauge = new HGauge(0.0f, 700.0f, 600.0f, "", "",
         evenTicks(700.0f), this);
-    m_pwrGauge->setBallistics({0.030f, 0.800f});
+    m_pwrGauge->setWindowPeakEnabled(true);
     m_pwrGauge->setAccessibleName(tr("Forward power"));
     auto* pwrRow = new QHBoxLayout;
     pwrRow->setSpacing(4);
@@ -283,14 +283,6 @@ AcomApplet::AcomApplet(QWidget* parent)
     connect(&m_labelTimer, &QTimer::timeout, this, &AcomApplet::updateValueLabels);
     m_labelTimer.start();
 
-    m_peakTimer = new QTimer(this);
-    m_peakTimer->setSingleShot(true);
-    m_peakTimer->setInterval(2500);
-    connect(m_peakTimer, &QTimer::timeout, this, [this]() {
-        m_peakFwd = 0.0f;
-        m_pwrGauge->clearPeak();
-    });
-
     setConnected(false);
 }
 
@@ -308,11 +300,7 @@ void AcomApplet::setForwardPower(float watts)
 {
     m_fwdWatts = watts;
     m_pwrGauge->setValue(watts);
-    if (watts > m_peakFwd) {
-        m_peakFwd = watts;
-        m_pwrGauge->setPeakValue(watts);
-        m_peakTimer->start();
-    }
+    // Peak marker: HGauge's sliding window, fed by setValue (canon).
 }
 
 void AcomApplet::setReflectedPower(float watts)
@@ -455,12 +443,9 @@ void AcomApplet::setConnected(bool connected)
         m_fwdWatts = 0.0f;
         m_reflectedWatts = 0.0f;
         m_swrVal = 1.0f;
-        // Clear the forward-power peak hold too — otherwise a stale peak from
-        // the prior session survives (m_peakFwd is not otherwise reset), and a
-        // reconnect within the 2.5 s peak-hold window suppresses the new
-        // session's peak marker until a reading exceeds the old peak.
-        m_peakFwd = 0.0f;
-        if (m_peakTimer) m_peakTimer->stop();
+        // Clear the forward-power peak too — otherwise a stale marker from
+        // the prior session survives a reconnect. clearPeak() drops the
+        // gauge's sliding window as well, which is what retires it now.
         m_pwrGauge->setValueImmediate(0.0f);
         m_pwrGauge->clearPeak();
         m_refGauge->setValueImmediate(0.0f);

src/gui/AcomApplet.h

@@ -104,8 +104,6 @@ class AcomApplet : public QWidget {
     QPushButton* m_offBtn{nullptr};
 
     QTimer m_labelTimer;
-    QTimer* m_peakTimer{nullptr};
-    float m_peakFwd{0.0f};
 
     float m_fwdWatts{0.0f};
     float m_reflectedWatts{0.0f};

src/gui/AmpApplet.cpp

@@ -277,9 +277,7 @@ void AmpApplet::buildUI()
     m_fwdGauge = new HGauge(0.0f, 2000.0f, 1500.0f, "", "",
         {{0, "0"}, {500, "500"}, {1000, "1K"}, {1500, "1.5K"}, {2000, "2K"}},
         this, 1000.0f);
-    // Slow release: bar rises quickly on RF bursts but decays over ~800 ms
-    // so brief transmissions remain visible — matches S-meter peak-hold feel.
-    m_fwdGauge->setBallistics({0.030f, 0.800f});
+    m_fwdGauge->setWindowPeakEnabled(true);
     m_fwdGauge->setAccessibleName(tr("Forward power"));
     auto* pwrRow = new QHBoxLayout;
     // Zero margins, like every other nested layout here. A QLayout that is
@@ -311,7 +309,6 @@ void AmpApplet::buildUI()
     m_drvGauge = new HGauge(0.0f, 100.0f, 75.0f, "", "",
         {{0, "0"}, {25, "25"}, {50, "50"}, {75, "75"}, {100, "100"}},
         this, 50.0f);
-    m_drvGauge->setBallistics({0.030f, 0.800f});
     m_drvGauge->setAccessibleName(tr("Drive power"));
     auto* drvRow = new QHBoxLayout;
     drvRow->setContentsMargins(0, 0, 0, 0);
@@ -540,32 +537,6 @@ void AmpApplet::buildUI()
     connect(&m_labelTimer, &QTimer::timeout, this, &AmpApplet::updateValueLabels);
     m_labelTimer.start();
 
-    // Peak-hold ballistics matching TxApplet and TunerApplet (#2561): hold,
-    // then decay toward the live reading rather than snapping the marker
-    // away. Three power meters on one screen should behave alike.
-    m_peakTick = new QTimer(this);
-    m_peakTick->setInterval(50);
-    connect(m_peakTick, &QTimer::timeout, this, [this]() {
-        if (!m_peakHoldRunning) { m_peakTick->stop(); return; }
-        const qint64 elapsedMs = m_peakHoldTimer.elapsed();
-        if (elapsedMs <= kPeakHoldMs) return;
-        const float decaySecs = static_cast<float>(elapsedMs - kPeakHoldMs) / 1000.0f;
-        const float decayed = m_peakDecayStart - kPeakDecayWattsPerSec * decaySecs;
-        if (decayed <= m_fwdWatts) {
-            m_peakFwd = m_fwdWatts;
-            m_peakHoldRunning = false;
-            m_peakTick->stop();
-            // At the floor the marker goes away entirely, as it did before.
-            if (m_fwdWatts <= 0.05f) {
-                m_peakFwd = 0.0f;
-                m_fwdGauge->clearPeak();
-                return;
-            }
-        } else {
-            m_peakFwd = decayed;
-        }
-        m_fwdGauge->setPeakValue(m_peakFwd);
-    });
 
     applyDensityAtScale(1.0);
     updatePortRows();
@@ -1157,14 +1128,7 @@ void AmpApplet::setFwdPower(float watts)
         m_swrGauge->setValue(1.0f);   // clear bar — SWR is unmeasurable at idle
     else if (isPowered && !wasPowered)
         m_swrGauge->setValue(m_swrVal); // power resumed — restore cached value
-    if (watts > m_peakFwd) {
-        m_peakFwd = watts;
-        m_peakDecayStart = watts;
-        m_peakHoldTimer.restart();
-        m_peakHoldRunning = true;
-        if (!m_peakTick->isActive()) m_peakTick->start();
-        m_fwdGauge->setPeakValue(watts);
-    }
+    // Peak marker: HGauge's sliding window, fed by setValue above (canon).
     // Label text is updated by the 100 ms timer (updateValueLabels).
 }
 

src/gui/AmpApplet.h

@@ -283,17 +283,6 @@ class AmpApplet : public QWidget {
 
     // 100 ms timer — updates label text independently of gauge fill rate
     QTimer   m_labelTimer;
-    // Peak hold: white tick on fwd gauge, cleared 2.5 s after last new peak
-    // Peak-hold ballistics, the same shape TxApplet and TunerApplet use
-    // (#2561): hold, then decay at full-scale/2.5 s so the marker falls
-    // rather than vanishing. This gauge is fixed at 2 kW full scale.
-    QTimer*  m_peakTick{nullptr};
-    float    m_peakFwd{0.0f};
-    float    m_peakDecayStart{0.0f};
-    bool     m_peakHoldRunning{false};
-    QElapsedTimer m_peakHoldTimer;
-    static constexpr qint64 kPeakHoldMs = 2000;
-    static constexpr float  kPeakDecayWattsPerSec = 2000.0f / 2.5f;
 
     // When the radio relay last delivered a power/SWR sample. See
     // setDeviceMeters() for the rule it decides. Monotonic on purpose: an

src/gui/HGauge.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "DragValuePopup.h"
+#include "MeterExtremes.h"
 #include "MeterSmoother.h"
 
 #include <QAccessible>
@@ -51,12 +52,47 @@ class HGauge : public QWidget {
         setFixedHeight(24);
         setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
+        applyExtremesScale();
         m_smooth.setTarget(fractionFor(m_value));
         m_smooth.snapToTarget();
         m_animTimer.setTimerType(Qt::PreciseTimer);
         m_animTimer.setInterval(kMeterSmootherIntervalMs);
         connect(&m_animTimer, &QTimer::timeout, this, [this]() {
-            if (!m_smooth.tick(m_animElapsed.restart()))
+            const qint64 dt = m_animElapsed.restart();
+            const bool barMoving = m_smooth.tick(dt);
+            // The extremes engine keeps ticking after the bar settles: a
+            // window sample can expire and slide the marker with the needle
+            // already at rest.
+            bool markerMoving = false;
+            if (m_peakSource != PeakSource::Disabled) {
+                m_nowMs += dt;
+                // The PAINTED needle, not the raw target: the engine clamps
+                // the marker to sit at or above the needle, so handing it the
+                // unsmoothed value would drag the marker straight to the new
+                // reading and there would be no glide to see.
+                const double needleUnits =
+                    double(m_min) + double(m_smooth.value())
+                                        * (double(m_max) - double(m_min));
+                markerMoving = m_extremes.tick(
+                    m_nowMs, dt, needleUnits,
+                    [this](double raw) {
+                        return double(qBound(m_min, float(raw), m_max));
+                    });
+                // Publish the marker every tick, including after the window
+                // has emptied: that is exactly when it is gliding back down to
+                // the floor, and freezing the published value there would
+                // strand the marker at the last peak forever.
+                m_peakValue = static_cast<float>(m_extremes.maxPosUnits());
+                m_peakEnabled =
+                    m_extremes.hasData()
+                    || m_peakValue > float(needleUnits) + kMarkerCollapseEps;
+            }
+            // m_nowMs only advances in here, so the sliding window can only
+            // expire while the timer runs. tick() reports true whenever a
+            // marker is mid-slew or still standing off the needle — which is
+            // exactly the state in which pruning still has work to do — so its
+            // return value alone is a sufficient keep-alive.
+            if (!barMoving && !markerMoving)
                 m_animTimer.stop();
             // Republish so gaugeFraction tracks the bar through the sweep, not
             // just at the setValue/setRange call that started it — otherwise
@@ -109,6 +145,37 @@ class HGauge : public QWidget {
     // compression bar) the mapping is inverted at paint time — min means FULL —
     // so the painted width there is 1.0f - filledFraction(). Assert
     // accordingly; the fraction itself is always value-normalised.
+    // Opt into a sliding-window marker driven by the values passed to
+    // setValue(). Ordinary gauges remain marker-free; only readings for which
+    // an extremum is meaningful (forward power today) enable this mode.
+    void setWindowPeakEnabled(bool enabled) {
+        selectPeakSource(enabled ? PeakSource::Window : PeakSource::Disabled,
+                         enabled);
+        publishAutomationState();
+        update();
+    }
+
+    // Feed a separate raw sample into the sliding window without changing the
+    // bar. TxApplet uses this because its bar receives a smoothed reading while
+    // txPeakChanged carries the raw FWDPWR sample from which PEP is derived.
+    void recordWindowPeakSample(float v) {
+        selectPeakSource(PeakSource::Window, false);
+        m_extremes.record(double(qBound(m_min, v, m_max)), m_nowMs);
+        m_peakEnabled = true;
+        armPeakTimer();
+    }
+
+    // Drive the peak marker from a separately measured peak (TGXL `peak`)
+    // instead of this gauge's own sliding window. The marker then tracks that
+    // value at SmartMTR's fast peak slew. Switching source resets the old
+    // window so record() and external-peak mode can never coexist.
+    void setExternalPeak(float v) {
+        selectPeakSource(PeakSource::External, false);
+        m_extremes.setExternalPeak(double(qBound(m_min, v, m_max)));
+        m_peakEnabled = true;
+        armPeakTimer();
+    }
+
     float value() const { return m_value; }
     float filledFraction() const { return m_smooth.value(); }
     // The peak-hold marker. peakHeld() is separate from the value because
@@ -120,8 +187,11 @@ class HGauge : public QWidget {
     void setValue(float v) {
         if (qFuzzyCompare(m_value, v)) return;
         m_value = v;
+        if (m_peakSource == PeakSource::Window && m_recordGaugeValuesForPeak) {
+            m_extremes.record(double(v), m_nowMs);
+        }
         m_smooth.setTarget(fractionFor(v));
-        if (!m_smooth.needsAnimation()) {
+        if (!m_smooth.needsAnimation() && !m_peakEnabled) {
             if (m_animTimer.isActive()) m_animTimer.stop();
             update();
         } else if (!m_animTimer.isActive()) {
@@ -143,6 +213,10 @@ class HGauge : public QWidget {
     }
 
     void setPeakValue(float v) {
+        // Legacy/manual callers own the marker value directly. In particular,
+        // PhoneCwApplet supplies the radio's MICPEAK immediately after
+        // setValue(); a window tick must not overwrite that measurement.
+        selectPeakSource(PeakSource::Disabled, false);
         if (qFuzzyCompare(m_peakValue, v)) return;
         m_peakValue = v;
         m_peakEnabled = true;
@@ -151,6 +225,10 @@ class HGauge : public QWidget {
     }
 
     void clearPeak() {
+        // Park: drop the window too, or the engine keeps sliding a marker
+        // for a gauge the caller has just said has nothing to show.
+        m_extremes.reset();
+        m_peakValue = static_cast<float>(m_extremes.floorPos());
         if (!m_peakEnabled) return;
         m_peakEnabled = false;
         publishAutomationState();
@@ -168,6 +246,10 @@ class HGauge : public QWidget {
         MeterSmoother::Ballistics ballistics = m_smooth.ballistics();
         std::swap(ballistics.attackSeconds, ballistics.releaseSeconds);
         m_smooth.setBallistics(ballistics);
+        m_extremes.setReversed(rev);
+        m_extremes.reset();
+        m_peakValue = static_cast<float>(m_extremes.floorPos());
+        m_peakEnabled = false;
         update();
     }
     // Anchor the fill bar to the right edge instead of the left.  Unlike
@@ -211,6 +293,7 @@ class HGauge : public QWidget {
     void setRange(float min, float max, float redStart,
                   const QVector<Tick>& ticks, float yellowStart = std::numeric_limits<float>::quiet_NaN()) {
         m_min = min; m_max = max; m_redStart = redStart;
+        applyExtremesScale();
         m_yellowStart = std::isnan(yellowStart) ? redStart : yellowStart;
         m_ticks = ticks;
         // Re-map the CURRENT value onto the new axis. Without this the fill
@@ -432,6 +515,52 @@ class HGauge : public QWidget {
     }
 
 private:
+
+    enum class PeakSource {
+        Disabled,
+        Window,
+        External,
+    };
+
+    void selectPeakSource(PeakSource source, bool recordGaugeValues) {
+        const bool recordValues = source == PeakSource::Window && recordGaugeValues;
+        if (m_peakSource == source
+            && m_recordGaugeValuesForPeak == recordValues) {
+            return;
+        }
+        m_extremes.reset();
+        m_peakSource = source;
+        m_recordGaugeValuesForPeak = recordValues;
+        m_peakValue = static_cast<float>(m_extremes.floorPos());
+        m_peakEnabled = false;
+    }
+
+    void armPeakTimer() {
+        if (!m_animTimer.isActive()) {
+            m_animElapsed.restart();
+            m_animTimer.start();
+        }
+    }
+
+    // SmartMTR slews its markers at a constant 60 UNITS/s over a 220-UNIT bar
+    // -- a marker crosses the full scale in ~3.7 s, deliberately lazy against
+    // the bar's attack. Expressed as a fraction of span so every gauge range
+    // takes the same ~3.7 s, which is what makes them feel alike.
+    void applyExtremesScale() {
+        MeterExtremes::Tuning t;
+        t.windowSeconds   = SmartMtrExtremes::kWindowMediumSec;
+        t.scaleMin        = m_min;
+        t.scaleMax        = m_max;
+        const double span = double(m_max) - double(m_min);
+        t.slewUnitsPerSec = span > 0.0 ? span / kMarkerCrossSeconds : 1.0;
+        m_extremes.setTuning(t);
+    }
+    // Below this (in gauge units) the marker has effectively collapsed onto
+    // the needle and stops being drawn as a separate peak.
+    static constexpr float kMarkerCollapseEps = 0.001f;
+    static constexpr double kMarkerCrossSeconds =
+        (SmartMtrUnits::kScaleMax - SmartMtrUnits::kScaleMin)
+        / SmartMtrExtremes::kSlewUnitsPerSec;
     // Map a physical value onto the normalised [0,1] axis fraction the
     // smoother and paintEvent work in. Every site that moves the fill must
     // agree on this — the constructor, setValue, setValueImmediate and
@@ -612,6 +741,14 @@ class HGauge : public QWidget {
     float m_min, m_max, m_redStart, m_yellowStart;
     float m_value{0.0f};
     static constexpr int kPeakMarkerW = 2;   // pixels
+    // Peak marker, SmartMTR's engine (project canon): a sliding window over
+    // recent samples with a constant-velocity glide, rather than a latched
+    // peak on a hold-then-decay timer. The window expiring is what retires
+    // the marker, so there is no hold phase to tune.
+    MeterExtremes m_extremes;
+    PeakSource m_peakSource{PeakSource::Disabled};
+    bool   m_recordGaugeValuesForPeak{false};
+    qint64 m_nowMs{0};          // monotonic tick clock for the window
     float m_peakValue{0.0f};
     bool  m_peakEnabled{false};
     bool  m_reversed{false};