Pr2 tmm basic

extra_scripts/nrf52_warm_region.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# trunk-ignore-all(ruff/F821)
+# trunk-ignore-all(flake8/F821): For SConstruct imports
+#
+# Post-link guard for the warm-node-store raw-flash region on nrf52840.
+#
+# The top 3 app-region flash pages below LittleFS (0xEA000-0xED000, reclaimed by
+# whole-image LTO; LittleFS itself stays stock at 0xED000) are reserved for the WarmNodeStore record-ring
+# (src/mesh/WarmNodeStore.h, 3-page record-ring). Our own linker script
+# (src/platform/nrf52/nrf52840_s140_v7.ld) already caps the image at 0xEA000,
+# but many boards (e.g. rak4631) link with the framework-default script whose
+# FLASH region still ends at 0xED000 -- those would silently place code in the
+# reserved pages if the image ever grew that large, and the first warm-store
+# save would then brick the firmware. This guard turns that into a red build.
+#
+# Image flash end = __etext (end of code/rodata in flash) + sizeof(.data)
+# (which is loaded at LMA __etext). Symbols come from the framework's
+# nrf52_common.ld.
+import os
+
+Import("env")
+
+WARM_REGION_BASE = 0xEA000  # keep in sync with WARM_FLASH_REGION_BASE in WarmNodeStore.h (3 x 4 KB record-ring)
+
+_tc = env.PioPlatform().get_package_dir("toolchain-gccarmnoneeabi") or ""
+_NM = os.path.join(_tc, "bin", "arm-none-eabi-nm")
+if not os.path.isfile(_NM):
+    _NM = "arm-none-eabi-nm"  # fall back to PATH
+
+
+def _assert_warm_region_clear(source, target, env):
+    import subprocess
+    import sys
+
+    try:
+        elf = env.subst("$BUILD_DIR/${PROGNAME}.elf")
+        out = subprocess.check_output([_NM, elf], universal_newlines=True)
+    except Exception as exc:  # tooling hiccup: warn loudly, don't wedge the build
+        print("nrf52_warm_region: WARNING - guard skipped (nm failed: %s)" % exc)
+        return
+
+    syms = {}
+    for line in out.split("\n"):
+        f = line.split()
+        if len(f) >= 3 and f[-1] in ("__etext", "__data_start__", "__data_end__"):
+            syms[f[-1]] = int(f[0], 16)
+    if len(syms) != 3:
+        print("nrf52_warm_region: WARNING - guard skipped (linker symbols not found)")
+        return
+
+    flash_end = syms["__etext"] + (syms["__data_end__"] - syms["__data_start__"])
+    if flash_end > WARM_REGION_BASE:
+        sys.stderr.write(
+            "\n*** nrf52 warm-region guard: image ends at 0x%X, past the reserved "
+            "warm-store region at 0x%X ***\n"
+            "The 12 KB region at 0xEA000 holds the WarmNodeStore record-ring; a warm-store\n"
+            "save would overwrite this firmware's tail. Shrink the image, or shrink/move\n"
+            "the region (WARM_FLASH_REGION_BASE in src/mesh/WarmNodeStore.h, the FLASH\n"
+            "LENGTH in src/platform/nrf52/nrf52840_s140_v7.ld, and this guard).\n\n"
+            % (flash_end, WARM_REGION_BASE)
+        )
+        from SCons.Script import Exit
+
+        Exit(1)
+    print(
+        "nrf52_warm_region: guard OK -- image ends at 0x%X, %d KB clear of the warm region"
+        % (flash_end, (WARM_REGION_BASE - flash_end) // 1024)
+    )
+
+
+# Attach to the phony "buildprog" alias (not the .elf node) so the guard runs
+# on incremental relinks too -- same reasoning as nrf52_lto.py's guard.
+env.AddPostAction("buildprog", _assert_warm_region_clear)

src/graphics/draw/MenuHandler.cpp

@@ -1572,7 +1572,8 @@ void menuHandler::manageNodeMenu()
                 nodeDB->set_favorite(false, menuHandler::pickedNodeNum);
             } else {
                 LOG_INFO("Adding node %08X to favorites", menuHandler::pickedNodeNum);
-                nodeDB->set_favorite(true, menuHandler::pickedNodeNum);
+                if (!nodeDB->set_favorite(true, menuHandler::pickedNodeNum))
+                    LOG_WARN(NodeDB::PROTECTED_CAP_WARN_FMT, "favorite", menuHandler::pickedNodeNum, MAX_NUM_NODES - 2);
             }
             screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
             return;
@@ -1615,15 +1616,23 @@ void menuHandler::manageNodeMenu()
                 return;
             }
 
+            bool changed = false;
             if (nodeInfoLiteIsIgnored(n)) {
                 nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, false);
                 LOG_INFO("Unignoring node %08X", menuHandler::pickedNodeNum);
-            } else {
-                nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, true);
+                changed = true;
+            } else if (nodeDB->setProtectedFlag(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, true)) {
                 LOG_INFO("Ignoring node %08X", menuHandler::pickedNodeNum);
+                changed = true;
+            } else {
+                LOG_WARN(NodeDB::PROTECTED_CAP_WARN_FMT, "ignore", menuHandler::pickedNodeNum, MAX_NUM_NODES - 2);
+            }
+            // Only persist/notify when the ignore bit actually moved; a cap
+            // refusal changed nothing and shouldn't trigger a prefs save.
+            if (changed) {
+                nodeDB->notifyObservers(true);
+                nodeDB->saveToDisk();
             }
-            nodeDB->notifyObservers(true);
-            nodeDB->saveToDisk();
             screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
             return;
         }

src/mesh/Channels.cpp

@@ -404,6 +404,24 @@ bool Channels::isDefaultChannel(ChannelIndex chIndex)
     return false;
 }
 
+bool Channels::isWellKnownChannel(ChannelIndex chIndex)
+{
+    const auto &ch = getByIndex(chIndex);
+    // Absent (unencrypted) or single-byte PSK — all the well-known key indexes
+    if (ch.settings.psk.size > 1)
+        return false;
+
+    const char *name = getName(chIndex);
+    for (int p = _meshtastic_Config_LoRaConfig_ModemPreset_MIN; p <= _meshtastic_Config_LoRaConfig_ModemPreset_MAX; p++) {
+        const char *presetName =
+            DisplayFormatters::getModemPresetDisplayName(static_cast<meshtastic_Config_LoRaConfig_ModemPreset>(p), false, true);
+        // Presets without a display name fall through to "Invalid" — never a match
+        if (strcmp(presetName, "Invalid") != 0 && strcmp(name, presetName) == 0)
+            return true;
+    }
+    return false;
+}
+
 bool Channels::hasDefaultChannel()
 {
     // If we don't use a preset or the default frequency slot, or we override the frequency, we don't have a default channel

src/mesh/Channels.h

@@ -86,6 +86,13 @@ class Channels
     // Returns true if the channel has the default name and PSK
     bool isDefaultChannel(ChannelIndex chIndex);
 
+    // Returns true if the channel is "well known": its PSK is absent or a
+    // single-byte well-known key index, AND its name is any modem-preset
+    // display name (e.g. a channel named "LongFast" counts even while the
+    // radio runs MediumFast). Broader than isDefaultChannel, which only
+    // matches the current preset's name and PSK byte 1.
+    bool isWellKnownChannel(ChannelIndex chIndex);
+
     // Returns true if we can be reached via a channel with the default settings given a region and modem preset
     bool hasDefaultChannel();
 

src/mesh/Default.h

@@ -34,8 +34,8 @@
 enum class TrafficType { POSITION, TELEMETRY };
 
 // Traffic management defaults
-#define default_traffic_mgmt_position_precision_bits 24               // ~10m grid cells
-#define default_traffic_mgmt_position_min_interval_secs (ONE_DAY / 2) // 12 hours between identical positions
+#define default_traffic_mgmt_position_precision_bits 19                // ~90m grid cells (±45m)
+#define default_traffic_mgmt_position_min_interval_secs (11 * 60 * 60) // 11 hours between identical positions
 
 // Hop scaling defaults
 #define default_hop_scaling_min_target_nodes 40          // walk threshold: first hop reaching this cumulative count

src/mesh/NextHopRouter.cpp

@@ -98,22 +98,27 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
         // destination
         if (p->from != 0) {
             meshtastic_NodeInfoLite *origTx = nodeDB->getMeshNode(p->from);
-            if (origTx) {
-                // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
-                // directly from the destination
-                // Single lookup for both relayer checks on the same (request_id, to) pair
-                bool wasAlreadyRelayer = false;
-                bool weWereSoleRelayer = false;
-                bool weWereRelayer = false;
-                checkRelayers(p->relay_node, ourRelayID, p->decoded.request_id, p->to, &wasAlreadyRelayer, &weWereRelayer,
-                              &weWereSoleRelayer);
-                if ((weWereRelayer && wasAlreadyRelayer) || (getHopsAway(*p) == 0 && weWereSoleRelayer)) {
-                    if (origTx->next_hop != p->relay_node) { // Not already set
-                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from,
-                                 p->relay_node, wasAlreadyRelayer, weWereSoleRelayer);
-                        origTx->next_hop = p->relay_node;
-                    }
+            // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
+            // directly from the destination. checkRelayers is read-only on PacketHistory and O(1), so we run it even
+            // when origTx is absent — that lets us still capture the confirmed hop into the TMM overflow cache below.
+            // Single lookup for both relayer checks on the same (request_id, to) pair
+            bool wasAlreadyRelayer = false;
+            bool weWereSoleRelayer = false;
+            bool weWereRelayer = false;
+            checkRelayers(p->relay_node, ourRelayID, p->decoded.request_id, p->to, &wasAlreadyRelayer, &weWereRelayer,
+                          &weWereSoleRelayer);
+            if ((weWereRelayer && wasAlreadyRelayer) || (getHopsAway(*p) == 0 && weWereSoleRelayer)) {
+                if (origTx && origTx->next_hop != p->relay_node) { // Not already set
+                    LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from,
+                             p->relay_node, wasAlreadyRelayer, weWereSoleRelayer);
+                    origTx->next_hop = p->relay_node;
                 }
+#if HAS_TRAFFIC_MANAGEMENT
+                // Mirror the confirmed hop into the TMM overflow cache so it survives even when the source
+                // isn't (or is no longer) in the hot NodeDB. Same bidirectional confirmation gate as above.
+                if (trafficManagementModule)
+                    trafficManagementModule->setNextHop(p->from, p->relay_node);
+#endif
             }
         }
         if (!isToUs(p)) {
@@ -194,15 +199,29 @@ std::optional<uint8_t> NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
     if (isBroadcast(to))
         return std::nullopt;
 
+    // Hot store first: a direct array hit on the live NodeDB entry.
     meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(to);
     if (node && node->next_hop) {
         // We are careful not to return the relay node as the next hop
         if (node->next_hop != relay_node) {
-            // LOG_DEBUG("Next hop for 0x%x is 0x%x", to, node->next_hop);
+            LOG_DEBUG("Next hop for 0x%x is 0x%x", to, node->next_hop);
             return node->next_hop;
         } else
             LOG_WARN("Next hop for 0x%x is 0x%x, same as relayer; set no pref", to, node->next_hop);
     }
+
+#if HAS_TRAFFIC_MANAGEMENT
+    // Fallback: TMM overflow cache holds confirmed hops for nodes that have aged
+    // out of the hot store. Same byte source/confidence as NodeInfoLite.next_hop.
+    if (trafficManagementModule) {
+        uint8_t hint = trafficManagementModule->getNextHopHint(to);
+        if (hint && hint != relay_node) {
+            LOG_DEBUG("Next hop for 0x%x is 0x%x (TMM cache)", to, hint);
+            return hint;
+        }
+    }
+#endif
+
     return std::nullopt;
 }