Merge branch 'feature/flood-suppression' into ufo

Co-Authored-By: Claude <noreply@anthropic.com>

Author: usrflo

docs/README-flood-suppression.md

@@ -67,13 +67,11 @@ cancels reliably land before the redundant TX goes out.
 
 ## Configuration
 
-There is **one master switch** and five tuning parameters. The threshold **C**,
+There is **one master switch** and four tuning parameters. The threshold **C**,
 `snr.hi` and `snr.lo` are **not user-configurable** — they are derived from the
-neighbour table (adaptive) with static fallbacks (see *Adaptive mode*). The noise
-gate's threshold is also **not an absolute value**: it is measured relative to each
-site's own quiet baseline.
+neighbour table (adaptive) with static fallbacks (see *Adaptive mode*).
 
-`NodePrefs` fields (`src/helpers/CommonCLI.h`), persisted at file bytes 295–302
+`NodePrefs` fields (`src/helpers/CommonCLI.h`), persisted at file bytes 295–299
 (`src/helpers/CommonCLI.cpp`):
 
 | Field | Type | Default | Meaning |
@@ -83,7 +81,6 @@ site's own quiet baseline.
 | `flood_suppress_snr_lo` | `int8_t` (dB) | `0` | Near-membership threshold; overheard forward with SNR `<` this counts **0** (adaptive p25; configured value is the fallback). |
 | `flood_suppress_delay_x` | `uint8_t` | `3` | Extra TX-delay multiplier for central flood relays. |
 | `trace_tx_power_dbm` | `int8_t` (dBm) | `10` | TX power for coverage TRACE probes only (lower = less disturbance). |
-| `flood_suppress_noise_margin` | `int8_t` (dB) | `AUTO` (10) | Margin above the site's quiet baseline at which the channel counts as noisy; `AUTO` = firmware default. On a noisy channel only cheap (self-healing) payloads are suppressed. |
 
 The feature is **on by default**; `set flood.suppress off` (or YAML
 `flood_suppress: 0`) disables it completely.
@@ -100,34 +97,22 @@ The feature is **on by default**; `set flood.suppress off` (or YAML
 | `set flood.suppress.snr.hi <dB>` | `-30..30` (`get flood.suppress.snr.hi`) |
 | `set flood.suppress.snr.lo <dB>` | `-30..30` (`get flood.suppress.snr.lo`); adaptive p25 fallback |
 | `set flood.suppress.delay.factor <n>` | `0..8` (`get flood.suppress.delay.factor`) |
-| `set flood.suppress.noise.margin <dB>` | `auto` or `0..40` (`get flood.suppress.noise.margin`) |
 | `set trace.tx.power <dBm>` | `-9..30` (`get trace.tx.power`) |
 
-### Payload-class noise gate
-
-A repeater's retransmit **adds** airtime; on a congested channel every extra TX
-worsens the collision problem. The noise gate therefore applies a payload-class
-policy whenever the channel is noisy. "Noisy" is **relative**: the measured noise
-floor is `>=` this site's slowly-tracked quiet **baseline** plus
-`flood_suppress_noise_margin` dB (default `AUTO` = 10 dB) — so no absolute-dBm
-guess is needed:
-
-| Class | Payload types | On a noisy channel |
-|---|---|---|
-| **Cheap / self-healing** | `ADVERT` | may be suppressed (silence > repeat) |
-| **Confidence-only** | `TRACE`, `CONTROL`, `GRP_TXT`, `GRP_DATA`, `PATH`, `ANON_REQ` | forwarded (only suppressed on a quiet channel) |
-| **Payload-critical** | `REQ`, `RESPONSE`, `TXT_MSG`, `ACK`, `MULTIPART` | never suppressed by the gate |
-
-The gate is fixed ON. The margin defaults to `AUTO` (the firmware derives the
-threshold from the baseline); an explicit `0..40` dB override only makes it more
-or less sensitive.
-
-`TRACE` and `CONTROL` are deliberately **not** in the cheap class: `TRACE` feeds the
-coverage graph this suppressor depends on, and `CONTROL` drives neighbour discovery, so
-dropping them on a noisy channel would starve the very data the gate relies on and risk
-a self-reinforcing collapse of the reach graph. They are still suppressible on a *quiet*
-channel (redundant copies cost airtime for no benefit); only the noisy-channel drop is
-withheld.
+### Channel-state policy: deliberately none
+
+An earlier revision gated suppression on the measured noise floor (a per-site
+quiet baseline plus a configurable margin) with a payload-class policy on top.
+It was **removed** on purpose. On an active mesh the measured floor mostly
+reflects the mesh's **own** redundant traffic, so the gate closed exactly when
+suppression was most valuable — a self-reinforcing loop (little suppression →
+more forwards → "noisy" → even less suppression). Channel state therefore does
+not enter the suppression decision at all: under load a redundant rebroadcast
+is itself the load, and cancelling it is the right move even at some residual
+delivery risk. The only content-based gate is the always-on 3-tier **client
+protection** (`MyMesh::clientProtectionAllowsSuppress`: TRACE/CONTROL free,
+addressed types iff the destination is not an attached client, broadcasts that
+clients may need are always forwarded).
 
 ### SNR-repeat fallback
 
@@ -139,7 +124,9 @@ applies: each overheard forward of the same hash increments a per-flood weighted
 counter (`SNR >= snr.hi` → +2, `< snr.lo` → 0, else +1). Once the weighted count
 reaches the effective **C**, the rebroadcast is cancelled even without graph
 proof. The graph result always wins; the fallback only widens the suppression
-set. It is fixed ON and not configurable.
+set. The same 3-tier client protection applies as on the graph path; channel
+state and payload class gate neither path (see *Channel-state policy:
+deliberately none*). The fallback is fixed ON and not configurable.
 
 ---
 
@@ -149,14 +136,13 @@ With the master switch **on**, the threshold **C**, `snr.hi` **and `snr.lo`** ar
 **derived from the repeater's neighbour table** (`simple_repeater`'s `neighbours[]`,
 seeded from zero-hop repeater adverts / node-discovery and kept fresh by overheard
 forwards), with safe **static fallbacks** when no neighbour data is available. No
-per-topology tuning is required. The noise-floor **baseline** (for the relative
-noise gate) is learned here too.
+per-topology tuning is required.
 
 `MyMesh::updateAdaptiveFloodParams()` runs throttled (~every 1 min) from `loop()`
 and caches the **effective** values; the consumption sites read
 `effectiveFloodSuppressC()` / `effectiveFloodSuppressSnrHi()` /
 `effectiveFloodSuppressSnrLo()`. C/hi/lo are derived under `#if MAX_NEIGHBOURS`
-(the table is a build flag); the baseline tracker runs every cycle regardless.
+(the table is a build flag).
 
 **Derivation** (only **fresh** neighbours counted — `heard_timestamp` age ≤ 600 s,
 i.e. heard within the last 10 min):
@@ -179,9 +165,7 @@ identity, so seeding brand-new neighbours still needs an advert / node-discovery
 | `effective_snr_hi` | link-SNR **p75** of fresh neighbours | `clamp(p75, eff.lo+4, eff.lo+12)`; needs ≥ 4 samples, else the configured `snr.hi` |
 
 `snr.lo` does **not** feed back into the density count `n` (which is by timestamp
-only), so widening/narrowing the near set cannot oscillate `c`. The **noise-floor
-baseline** (fast follow down, slow 1/16 approach up so a permanent rise eventually
-re-baselines) makes the noise gate deployment-independent.
+only), so widening/narrowing the near set cannot oscillate `c`.
 
 A 2-cycle debounce on `c` prevents flapping when the neighbour count fluctuates (at
 a 1-min recompute cadence an adopted change lands within ~2 min; the recompute cost
@@ -233,7 +217,7 @@ static fallback. The refresh is a hardware-only improvement.
 | File | Change |
 |---|---|
 | `src/helpers/FloodSuppression.h` | **New.** Per-hash ring: `{hash, weighted_count, first_snr, strongest_overheard, first_seen, suppressed, active}` + `find` / `touch` / `purge`. |
-| `examples/simple_repeater/MyMesh.h` | Helper include; `_flood_supp` + adaptive state (`_fs_eff_c`, `_fs_eff_hi`, `_fs_eff_lo`, `_fs_adaptive_active`, `_fs_floor_baseline`, …); `cancelPendingFloodOutbound`, `updateAdaptiveFloodParams`, `effectiveFloodSuppressC/Hi/Lo`, `touchNeighbourByHash`; `sendNodeDiscoverReq(delay_millis)`. |
+| `examples/simple_repeater/MyMesh.h` | Helper include; `_flood_supp` + adaptive state (`_fs_eff_c`, `_fs_eff_hi`, `_fs_eff_lo`, `_fs_adaptive_active`, …); `cancelPendingFloodOutbound`, `updateAdaptiveFloodParams`, `effectiveFloodSuppressC/Hi/Lo`, `touchNeighbourByHash`; `sendNodeDiscoverReq(delay_millis)`. |
 | `examples/simple_repeater/MyMesh.cpp` | `logRx` (count + SNR-bias + cancel + neighbour-liveness refresh via `touchNeighbourByHash`), `allowPacketForward` (gate), `cancelPendingFloodOutbound`, `touchNeighbourByHash` (refresh known neighbour from an overheard forward's last path hash + smoothed SNR), `getRetransmitDelay` (delay bias), `loop()` (purge + adaptive recompute @ 1 min), `updateAdaptiveFloodParams` + effective accessors + `FLOOD_SUPPRESS_FALLBACK_C`, `sendNodeDiscoverReq(delay)`, constructor defaults. Consumption reads *effective* values. |
 | `examples/simple_repeater/main.cpp` | Boot discovery: `sendNodeDiscoverReq(…)` gated on `flood_suppress`. |
 | `src/helpers/CommonCLI.h` / `CommonCLI.cpp` | `NodePrefs` fields + persisted read/write + defaults + `set/get flood.suppress*` CLI handlers. |

examples/companion_radio/NodePrefs.h

@@ -54,8 +54,12 @@ class NodePrefs : public ConfigSerializer {  // persisted to file
       //def("cad", _parent->cad_enabled);
       //def("int_thr", _parent->interference_threshold);
       def("rxgain", _parent->rx_boosted_gain);
+    #if 0
+      // NOTE: these cannot be set (yet) so don't load/save until we can.
+      //       also, fem_rxgain WAS mapped to wrong JSON property previously
       def("fem_rxgain", _parent->radio_fem_rxgain);
       def("fem_txgain", _parent->radio_fem_txgain);
+    #endif
       def("tx", _parent->tx_power_dbm);
       def("af", _parent->airtime_factor);
       def("rxdelay", _parent->rx_delay_base);

examples/simple_repeater/MyMesh.cpp

@@ -282,54 +282,6 @@ bool MyMesh::clientProtectionAllowsSuppress(const mesh::Packet* pkt, uint32_t no
   return false;                                                                     // Tier B
 }
 
-// --- Payload-class suppression policy (noise-aware) -----------------------------
-// A repeater's retransmit ADDS airtime. On a congested/noisy channel every extra TX
-// worsens the collision problem, so "stay silent rather than repeat" applies to the
-// payload classes whose loss is cheap/self-healing. The class decides whether a
-// redundant rebroadcast may be cancelled on a busy channel:
-//   0 = NEVER (payload-critical): REQ, RESPONSE, TXT_MSG, ACK, MULTIPART -- always
-//       re-forward (subject to the normal dedup/coverage logic); noise never vetoes.
-//   1 = CONFIDENCE-ONLY (best-effort but not disposable): TRACE, CONTROL, GRP_TXT,
-//       GRP_DATA, PATH, ANON_REQ -- suppressible on a quiet channel, forwarded on a
-//       noisy one. TRACE/CONTROL live here (NOT in tier 2): they are measurement and
-//       discovery plumbing -- TRACE feeds the coverage graph this suppressor relies
-//       on, CONTROL drives neighbour discovery -- so dropping them on a noisy channel
-//       would starve that data and risk a self-reinforcing collapse of the reach graph.
-//   2 = CHEAP (self-healing): ADVERT (periodic re-send) -- suppressible even on a noisy
-//       channel (silence > repeat); adverts are rate-limited and re-sent periodically.
-uint8_t MyMesh::floodSuppressTier(const mesh::Packet* pkt) const {
-  switch (pkt->getPayloadType()) {
-  case PAYLOAD_TYPE_ADVERT:
-    return 2; // cheap: self-healing (periodic re-send) -- suppressible even when noisy
-  case PAYLOAD_TYPE_TRACE:
-  case PAYLOAD_TYPE_CONTROL:
-  case PAYLOAD_TYPE_GRP_TXT:
-  case PAYLOAD_TYPE_GRP_DATA:
-  case PAYLOAD_TYPE_PATH:
-  case PAYLOAD_TYPE_ANON_REQ:
-    return 1; // confidence-only: suppressible only on a quiet channel (forwarded when noisy)
-  default:
-    return 0; // never: REQ/RESPONSE/TXT_MSG/ACK/MULTIPART/RAW_CUSTOM
-  }
-}
-
-// Channel-state gate for suppression. On a busy/noisy channel an extra TX amplifies the
-// collision problem, so when the channel IS noisy we suppress only the cheap (self-healing)
-// class (silence > repeat) and keep the confidence-only classes forwarding. "Noisy" is relative:
-// the measured floor is at least `margin` dB above THIS SITE's slowly-tracked quiet baseline
-// (see updateAdaptiveFloodParams), so no expert absolute-dBm value is needed. Margin is AUTO
-// (firmware default) unless an explicit CLI override is set. Until the baseline is learned
-// (first cycle, ~60s) we assume noisy -- the safe direction (keep confidence classes forwarding).
-bool MyMesh::noiseGateAllowsSuppress(const mesh::Packet* pkt) const {
-  uint8_t tier = floodSuppressTier(pkt);
-  if (tier == 0) return false;                        // payload-critical: never suppress
-  int8_t margin = (_prefs.flood_suppress_noise_margin == FLOOD_SUPPRESS_NOISE_MARGIN_AUTO)
-                  ? FLOOD_SUPPRESS_NOISE_MARGIN_DEFAULT : _prefs.flood_suppress_noise_margin;
-  bool noisy = (_fs_floor_baseline <= -999) ||
-               ((int)_radio->getNoiseFloor() >= _fs_floor_baseline + (int)margin);
-  return noisy ? (tier == 2) : true;                  // noisy: only cheap; quiet: tier 1 or 2
-}
-
 // --- Active TRACE coverage measurement ----------------------------------------
 // Send one round-trip coverage TRACE: visit-list [a, b, self] with 2-byte hashes.
 // It walks self->a->b->self; the SNR measured at b of a's forward (path_snrs[1])
@@ -956,17 +908,6 @@ int8_t MyMesh::effectiveFloodSuppressSnrLo() const {
 // loop(); sets _fs_adaptive_active. Under #if MAX_NEIGHBOURS (else adaptive stays inactive and
 // effectiveFloodSuppressC falls back to FLOOD_SUPPRESS_FALLBACK_C).
 void MyMesh::updateAdaptiveFloodParams() {
-  // --- Noise-floor baseline (relative noise gate) ---
-  // getNoiseFloor() is the median-estimated ambient (RadioLibWrappers). We track its quiet
-  // minimum as THIS SITE's baseline: fast follow downward (got quieter), slow 1/16 approach
-  // upward (a persistent rise -- e.g. a new interferer -- slowly becomes the new baseline, so the
-  // gate eventually re-opens; mirrors the median estimator's bounded hold-release). "noisy" is
-  // then floor >= baseline + margin -- deployment-independent, no expert absolute-dBm. Runs every
-  // cycle (60s) when flood suppression is on, independent of MAX_NEIGHBOURS.
-  int cur_floor = _radio->getNoiseFloor();
-  if (_fs_floor_baseline <= -999) _fs_floor_baseline = cur_floor;            // first sample
-  else if (cur_floor < _fs_floor_baseline) _fs_floor_baseline = cur_floor;   // fast down
-  else _fs_floor_baseline += (cur_floor - _fs_floor_baseline) / 16;          // slow up
 #if MAX_NEIGHBOURS
   int n = 0;
   int8_t snr_x4[MAX_NEIGHBOURS];
@@ -1174,19 +1115,14 @@ void MyMesh::logRx(mesh::Packet *pkt, int len, float score) {
       }
 
       // (d) suppress iff no isolated-uncovered peer, every coverage peer covered, and
-      //     client-protection allows it (3-tier, always active). The noise gate then
-      //     decides by payload class: on a busy channel only cheap (self-healing)
-      //     payloads are suppressed (silence > repeat); payload-critical ones forward.
+      //     client-protection allows it (3-tier, always active). Channel state does not
+      //     enter the decision: under load the redundant TX itself IS the load.
       if (!e->must_cover_self && allNearNeighboursCovered(*e, now)
           && clientProtectionAllowsSuppress(pkt, now)) {
-        if (noiseGateAllowsSuppress(pkt)) {
-          e->suppressed = true;
-          _fs_suppressed++;                    // our rebroadcast was made redundant
-          _fs_supp_graph++;
-          cancelPendingFloodOutbound(hash);
-        } else {
-          _fs_noise_blocked++;                 // graph said redundant, noise gate vetoed
-        }
+        e->suppressed = true;
+        _fs_suppressed++;                    // our rebroadcast was made redundant
+        _fs_supp_graph++;
+        cancelPendingFloodOutbound(hash);
       }
 #endif
     }
@@ -1199,8 +1135,9 @@ void MyMesh::logRx(mesh::Packet *pkt, int len, float score) {
     // proof (e.g. the forwarders are rank >cap, so no TRACE edge covers them). The
     // graph result always wins: this only fires when the graph could not prove
     // coverage, and never overrides must_cover_self (an uncovered top-N neighbour M
-    // definitively owes coverage to -- only M's own TX can reach it). Same noise gate
-    // + client protection as the graph path.
+    // definitively owes coverage to -- only M's own TX can reach it). Same client
+    // protection as the graph path; channel state and payload class do not gate this
+    // (deliberate -- see README).
     if (e && !e->suppressed && !is_new) {
       uint8_t c = effectiveFloodSuppressC();
       if (c > 0 && e->snr_fallback_wcount < 255) {
@@ -1209,8 +1146,7 @@ void MyMesh::logRx(mesh::Packet *pkt, int len, float score) {
         int8_t lo = effectiveFloodSuppressSnrLo();
         e->snr_fallback_wcount += (snr >= hi) ? 2 : (snr < lo) ? 0 : 1;
         if (e->snr_fallback_wcount >= c && !e->snr_fallback_suppressed && !e->must_cover_self &&
-            clientProtectionAllowsSuppress(pkt, getRTCClock()->getCurrentTime()) &&
-            noiseGateAllowsSuppress(pkt)) {
+            clientProtectionAllowsSuppress(pkt, getRTCClock()->getCurrentTime())) {
           e->snr_fallback_suppressed = true;
           e->suppressed = true;
           _fs_suppressed++;
@@ -1696,10 +1632,9 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
   _fs_pending_c = 0;
   _fs_adaptive_active = false;       // until neighbour data is available -> static fallback
   _fs_next_recompute_ms = 0;
-  _fs_floor_baseline = -999;         // noise-floor baseline: not yet learned -> gate assumes noisy
   _fs_seen = 0;
   _fs_suppressed = 0;
-  _fs_supp_graph = _fs_supp_snr_fallback = _fs_noise_blocked = 0;
+  _fs_supp_graph = _fs_supp_snr_fallback = 0;
   next_local_advert = next_flood_advert = 0;
   dirty_contacts_expiry = 0;
   set_radio_at = revert_radio_at = 0;
@@ -1746,9 +1681,7 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
   _prefs.flood_suppress_snr_lo = 0;  // dB: weak overheard forward => ignored (preserve edge)
   _prefs.flood_suppress_delay_x = 3; // extra TX-delay multiplier for central flood relays (wider cancel window)
   _prefs.trace_tx_power_dbm = 10;    // TX power for coverage TRACE probes only (near links are strong; less disturbance)
-  // SNR-repeat fallback is fixed ON (not configurable). The noise gate's margin defaults to AUTO
-  // (firmware derives "noisy" relative to this site's baseline); an explicit override is optional.
-  _prefs.flood_suppress_noise_margin = FLOOD_SUPPRESS_NOISE_MARGIN_AUTO; // relative gate (auto margin)
+  // SNR-repeat fallback is fixed ON (not configurable).
 
   // bridge defaults
   _prefs.bridge_enabled = 1;    // enabled
@@ -2046,11 +1979,11 @@ void MyMesh::formatFloodSuppressRatioReply(char *reply) {
   if (!_prefs.flood_suppress) return;  // plain "> off" when the master switch is off
   StatsFormatHelper::formatFloodSuppressRatio(reply, _fs_suppressed, _fs_seen);
   // Append the suppression-path breakdown: graph=coverage-graph suppressions,
-  // snr_fallback=SNR-repeat fallback suppressions, nblk=graph-suppressions vetoed
-  // by the noise gate. Lets the operator see WHICH mechanism is doing the work.
+  // snr_fallback=SNR-repeat fallback suppressions. Lets the operator see WHICH
+  // mechanism is doing the work.
   char extra[64];
-  sprintf(extra, " (graph=%lu snr_fallback=%lu nblk=%lu)", (unsigned long)_fs_supp_graph,
-          (unsigned long)_fs_supp_snr_fallback, (unsigned long)_fs_noise_blocked);
+  sprintf(extra, " (graph=%lu snr_fallback=%lu)", (unsigned long)_fs_supp_graph,
+          (unsigned long)_fs_supp_snr_fallback);
   strcat(reply, extra);
 }
 
@@ -2205,7 +2138,7 @@ void MyMesh::clearStats() {
   ((SimpleMeshTables *)getTables())->resetStats();
   _fs_seen = 0;
   _fs_suppressed = 0;
-  _fs_supp_graph = _fs_supp_snr_fallback = _fs_noise_blocked = 0;
+  _fs_supp_graph = _fs_supp_snr_fallback = 0;
   _meas_sent = _meas_returned = _meas_edge = _meas_timeout = _meas_neg = 0;
   _meas_harvested = _meas_harvest_neg = 0;
 }