Add more nodedb nodes on esp32 w/ psram to 3000, stored messages to 100

src/DebugConfiguration.h

@@ -53,12 +53,42 @@ extern MemGet memGet;
 #define LOG_TRACE(...) SEGGER_RTT_printf(0, __VA_ARGS__)
 #else
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
-#define LOG_DEBUG(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_DEBUG, __VA_ARGS__)
-#define LOG_INFO(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_INFO, __VA_ARGS__)
-#define LOG_WARN(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_WARN, __VA_ARGS__)
-#define LOG_ERROR(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_ERROR, __VA_ARGS__)
-#define LOG_CRIT(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_CRIT, __VA_ARGS__)
-#define LOG_TRACE(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_TRACE, __VA_ARGS__)
+#define LOG_DEBUG(...)                                                                                                           \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_DEBUG, __VA_ARGS__);                                                               \
+        }                                                                                                                        \
+    } while (0)
+#define LOG_INFO(...)                                                                                                            \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_INFO, __VA_ARGS__);                                                                \
+        }                                                                                                                        \
+    } while (0)
+#define LOG_WARN(...)                                                                                                            \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_WARN, __VA_ARGS__);                                                                \
+        }                                                                                                                        \
+    } while (0)
+#define LOG_ERROR(...)                                                                                                           \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_ERROR, __VA_ARGS__);                                                               \
+        }                                                                                                                        \
+    } while (0)
+#define LOG_CRIT(...)                                                                                                            \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_CRIT, __VA_ARGS__);                                                                \
+        }                                                                                                                        \
+    } while (0)
+#define LOG_TRACE(...)                                                                                                           \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_TRACE, __VA_ARGS__);                                                               \
+        }                                                                                                                        \
+    } while (0)
 #else
 #define LOG_DEBUG(...)
 #define LOG_INFO(...)
@@ -70,7 +100,12 @@ extern MemGet memGet;
 #endif
 
 #if defined(DEBUG_HEAP)
-#define LOG_HEAP(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_HEAP, __VA_ARGS__)
+#define LOG_HEAP(...)                                                                                                            \
+    do {                                                                                                                         \
+        if (console) {                                                                                                           \
+            console->log(MESHTASTIC_LOG_LEVEL_HEAP, __VA_ARGS__);                                                                \
+        }                                                                                                                        \
+    } while (0)
 
 // Macro-based heap debugging
 #define DEBUG_HEAP_BEFORE auto heapBefore = memGet.getFreeHeap();
@@ -195,4 +230,4 @@ class Syslog
     bool vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
 };
 
-#endif // HAS_NETWORKING
+#endif // HAS_NETWORKING

src/NodeStatus.h

@@ -14,16 +14,16 @@ class NodeStatus : public Status
     CallbackObserver<NodeStatus, const NodeStatus *> statusObserver =
         CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);
 
-    uint8_t numOnline = 0;
-    uint8_t numTotal = 0;
+    uint16_t numOnline = 0;
+    uint16_t numTotal = 0;
 
-    uint8_t lastNumTotal = 0;
+    uint16_t lastNumTotal = 0;
 
   public:
     bool forceUpdate = false;
 
     NodeStatus() { statusType = STATUS_TYPE_NODE; }
-    NodeStatus(uint8_t numOnline, uint8_t numTotal, bool forceUpdate = false) : Status()
+    NodeStatus(uint16_t numOnline, uint16_t numTotal, bool forceUpdate = false) : Status()
     {
         this->forceUpdate = forceUpdate;
         this->numOnline = numOnline;
@@ -34,11 +34,11 @@ class NodeStatus : public Status
 
     void observe(Observable<const NodeStatus *> *source) { statusObserver.observe(source); }
 
-    uint8_t getNumOnline() const { return numOnline; }
+    uint16_t getNumOnline() const { return numOnline; }
 
-    uint8_t getNumTotal() const { return numTotal; }
+    uint16_t getNumTotal() const { return numTotal; }
 
-    uint8_t getLastNumTotal() const { return lastNumTotal; }
+    uint16_t getLastNumTotal() const { return lastNumTotal; }
 
     bool matches(const NodeStatus *newStatus) const
     {
@@ -65,4 +65,4 @@ class NodeStatus : public Status
 
 } // namespace meshtastic
 
-extern meshtastic::NodeStatus *nodeStatus;
+extern meshtastic::NodeStatus *nodeStatus;

src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.cpp

@@ -287,7 +287,7 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
     float easternmost = lngCenter;
     float westernmost = lngCenter;
 
-    for (uint8_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
         // Skip if no position
@@ -475,7 +475,7 @@ void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
 bool InkHUD::MapApplet::enoughMarkers()
 {
     uint8_t count = 0;
-    for (uint8_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
         // Count nodes
@@ -555,4 +555,4 @@ void InkHUD::MapApplet::drawCross(int16_t x, int16_t y, uint8_t size)
     drawLine(x0, y1, x1, y0, BLACK);
 }
 
-#endif
+#endif

src/main.cpp

@@ -295,7 +295,7 @@ void printInfo()
 {
     LOG_INFO("S:B:%d,%s,%s,%s", HW_VENDOR, optstr(APP_VERSION), optstr(APP_ENV), optstr(APP_REPO));
 }
-#ifndef PIO_UNIT_TESTING
+#if !defined(PIO_UNIT_TESTING) || !(PIO_UNIT_TESTING)
 void setup()
 {
 #if defined(R1_NEO)
@@ -1573,7 +1573,7 @@ void scannerToSensorsMap(const std::unique_ptr<ScanI2CTwoWire> &i2cScanner, Scan
 }
 #endif
 
-#ifndef PIO_UNIT_TESTING
+#if !defined(PIO_UNIT_TESTING) || !(PIO_UNIT_TESTING)
 void loop()
 {
     runASAP = false;

src/mesh/MemoryPool.h

@@ -8,6 +8,10 @@
 #include "PointerQueue.h"
 #include "configuration.h" // For LOG_WARN, LOG_DEBUG, LOG_HEAP
 
+#if defined(ARCH_ESP32)
+#include <esp_heap_caps.h>
+#endif
+
 template <class T> class Allocator
 {
 
@@ -159,3 +163,92 @@ template <class T, int MaxSize> class MemoryPool : public Allocator<T>
         return nullptr;
     }
 };
+
+#if defined(ARCH_ESP32)
+// Simple fixed-size allocator that uses PSRAM. Used on ESP32-S3 builds so the
+// large MeshPacket pool can live off-chip and free internal RAM.
+template <class T, int MaxSize> class PsramMemoryPool : public Allocator<T>
+{
+  private:
+    T *pool;
+    bool used[MaxSize];
+
+  public:
+    PsramMemoryPool() : pool(nullptr), used{}
+    {
+        pool = static_cast<T *>(heap_caps_malloc(sizeof(T) * MaxSize, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
+        if (pool) {
+            memset(pool, 0, sizeof(T) * MaxSize);
+        } else {
+            LOG_WARN("Failed to allocate PSRAM pool of %d elements", MaxSize);
+        }
+    }
+
+    ~PsramMemoryPool() override
+    {
+        if (pool) {
+            heap_caps_free(pool);
+        }
+    }
+
+    bool isValid() const { return pool != nullptr; }
+
+    void release(T *p) override
+    {
+        if (!pool || !p) {
+            LOG_DEBUG("Failed to release PSRAM memory, pointer is null or pool unavailable");
+            return;
+        }
+
+        int index = static_cast<int>(p - pool);
+        if (index >= 0 && index < MaxSize) {
+            assert(used[index]);
+            used[index] = false;
+            LOG_HEAP("Released PSRAM pool item %d at 0x%x", index, p);
+        } else {
+            LOG_WARN("Pointer 0x%x not from PSRAM pool!", p);
+        }
+    }
+
+  protected:
+    T *alloc(TickType_t maxWait) override
+    {
+        if (!pool)
+            return nullptr;
+
+        for (int i = 0; i < MaxSize; i++) {
+            if (!used[i]) {
+                used[i] = true;
+                LOG_HEAP("Allocated PSRAM pool item %d at 0x%x", i, &pool[i]);
+                return &pool[i];
+            }
+        }
+
+        LOG_WARN("No free slots available in PSRAM memory pool!");
+        return nullptr;
+    }
+};
+
+// Utility helpers for PSRAM-backed array allocations on ESP32 targets.
+template <typename T> inline T *psramAllocArray(size_t count)
+{
+    return static_cast<T *>(heap_caps_malloc(sizeof(T) * count, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
+}
+
+template <typename T> inline void psramFreeArray(T *ptr)
+{
+    if (ptr)
+        heap_caps_free(ptr);
+}
+#else
+template <typename T> inline T *psramAllocArray(size_t count)
+{
+    (void)count;
+    return nullptr;
+}
+
+template <typename T> inline void psramFreeArray(T *ptr)
+{
+    (void)ptr;
+}
+#endif

src/mesh/MeshService.cpp

@@ -305,15 +305,21 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p)
 #endif
 #endif
 
-    if (toPhoneQueue.numFree() == 0) {
+    // MAX_RX_TOPHONE is sized for PSRAM-backed builds. Fall back to a smaller
+    // runtime limit if the helper detects <2MB of PSRAM at boot.
+    const int queueLimit = get_rx_tophone_limit();
+    const bool runtimeLimitReached = queueLimit > 0 && toPhoneQueue.numUsed() >= queueLimit;
+
+    if (toPhoneQueue.numFree() == 0 || runtimeLimitReached) {
+        const bool runtimeControlled = runtimeLimitReached && queueLimit < MAX_RX_TOPHONE;
         if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP ||
             p->decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP) {
-            LOG_WARN("ToPhone queue is full, discard oldest");
+            LOG_WARN("ToPhone queue %s, discard oldest", runtimeControlled ? "reached runtime limit" : "is full");
             meshtastic_MeshPacket *d = toPhoneQueue.dequeuePtr(0);
             if (d)
                 releaseToPool(d);
         } else {
-            LOG_WARN("ToPhone queue is full, drop packet");
+            LOG_WARN("ToPhone queue %s, drop packet", runtimeControlled ? "reached runtime limit" : "is full");
             releaseToPool(p);
             fromNum++; // Make sure to notify observers in case they are reconnected so they can get the packets
             return;