set TCXO to 2.4V

* increase T-Deck PSRAM to avoid too early out-of-memory when messages fill up the storage

* fix SDCard for T-Deck; allow SPI frequency config

.gitmodules

@@ -1,6 +1,9 @@
 [submodule "protobufs"]
 	path = protobufs
 	url = https://github.com/meshtastic/protobufs.git
+[submodule "lib/device-ui"]
+	path = lib/device-ui
+	url = https://github.com/meshtastic/device-ui.git
 [submodule "meshtestic"]
 	path = meshtestic
 	url = https://github.com/meshtastic/meshTestic

arch/esp32/esp32.ini

@@ -37,6 +37,7 @@ build_flags =
   -DLIBPAX_ARDUINO
   -DLIBPAX_WIFI
   -DLIBPAX_BLE
+  -DHAS_UDP_MULTICAST=1
   ;-DDEBUG_HEAP
 
 lib_deps =

arch/rp2xx0/rp2040.ini

@@ -18,6 +18,7 @@ build_src_filter =
 
 lib_ignore =
   BluetoothOTA
+  lvgl
 
 lib_deps =
   ${arduino_base.lib_deps}

bin/build-esp32.sh

@@ -35,11 +35,11 @@ cp $SRCBIN $OUTDIR/$basename-update.bin
 
 echo "Building Filesystem for ESP32 targets"
 pio run --environment $1 -t buildfs
-cp .pio/build/$1/littlefs.bin $OUTDIR/littlefswebui-$VERSION.bin
+cp .pio/build/$1/littlefs.bin $OUTDIR/littlefswebui-$1-$VERSION.bin
 # Remove webserver files from the filesystem and rebuild
 ls -l data/static # Diagnostic list of files
 rm -rf data/static
 pio run --environment $1 -t buildfs
-cp .pio/build/$1/littlefs.bin $OUTDIR/littlefs-$VERSION.bin
+cp .pio/build/$1/littlefs.bin $OUTDIR/littlefs-$1-$VERSION.bin
 cp bin/device-install.* $OUTDIR
-cp bin/device-update.* $OUTDIR
+cp bin/device-update.* $OUTDIR

bin/config.d/MUI/X11_480x480.yaml

@@ -0,0 +1,4 @@
+Display:
+  Panel: X11
+  Width: 480
+  Height: 480

bin/generate_ci_matrix.py

@@ -35,6 +35,9 @@ for subdir, dirs, files in os.walk(rootdir):
                                     outlist.append(section)
                             else:
                                 outlist.append(section)
+                        # Add the TFT variants if the base variant is selected
+                        elif section.replace("-tft", "") in outlist and config[config[c].name].get("board_level") != "extra":
+                            outlist.append(section)
                     if "board_check" in config[config[c].name]:
                         if (config[config[c].name]["board_check"] == "true") & (
                             "check" in options
@@ -43,4 +46,4 @@ for subdir, dirs, files in os.walk(rootdir):
 if ("quick" in options) & (len(outlist) > 3):
     print(json.dumps(random.sample(outlist, 3)))
 else:
-    print(json.dumps(outlist))
+    print(json.dumps(outlist))

src/FSCommon.cpp

@@ -23,6 +23,10 @@ SPIClass SPI1(HSPI);
 #define SDHandler SPI
 #endif
 
+#ifndef SD_SPI_FREQUENCY
+#define SD_SPI_FREQUENCY 4000000U
+#endif
+
 #endif // HAS_SDCARD
 
 #if defined(ARCH_STM32WL)
@@ -361,8 +365,7 @@ void setupSDCard()
 #ifdef HAS_SDCARD
     concurrency::LockGuard g(spiLock);
     SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
-
-    if (!SD.begin(SDCARD_CS, SDHandler)) {
+    if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {
         LOG_DEBUG("No SD_MMC card detected");
         return;
     }

src/main.cpp

@@ -115,6 +115,27 @@ AccelerometerThread *accelerometerThread = nullptr;
 AudioThread *audioThread = nullptr;
 #endif
 
+#if HAS_TFT
+#include "api/PacketAPI.h"
+#include "comms/PacketClient.h"
+#include "comms/PacketServer.h"
+#include "graphics/DeviceScreen.h"
+#include "graphics/driver/DisplayDriverConfig.h"
+
+void tft_task_handler(void *);
+
+DeviceScreen *deviceScreen = nullptr;
+#endif
+
+#ifdef HAS_UDP_MULTICAST
+#include "mesh/udp/UdpMulticastThread.h"
+UdpMulticastThread *udpThread = nullptr;
+#endif
+
+#if defined(TCXO_OPTIONAL)
+float tcxoVoltage = SX126X_DIO3_TCXO_VOLTAGE; // if TCXO is optional, put this here so it can be changed further down.
+#endif
+
 using namespace concurrency;
 
 volatile static const char slipstreamTZString[] = USERPREFS_TZ_STRING;
@@ -249,6 +270,15 @@ void setup()
     // TF Card , Display backlight(AW9364DNR) , AN48841B(Trackball) , ES7210(Decoder)
     pinMode(KB_POWERON, OUTPUT);
     digitalWrite(KB_POWERON, HIGH);
+    // T-Deck has all three SPI peripherals (TFT, SD, LoRa) attached to the same SPI bus
+    // We need to initialize all CS pins in advance otherwise there will be SPI communication issues
+    // e.g. when detecting the SD card
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
     delay(100);
 #endif
 
@@ -644,9 +674,9 @@ void setup()
     // but we need to do this after main cpu init (esp32setup), because we need the random seed set
     nodeDB = new NodeDB;
 
-    // If we're taking on the repeater role, use flood router and turn off 3V3_S rail because peripherals are not needed
+    // If we're taking on the repeater role, use NextHopRouter and turn off 3V3_S rail because peripherals are not needed
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        router = new FloodingRouter();
+        router = new NextHopRouter();
 #ifdef PIN_3V3_EN
         digitalWrite(PIN_3V3_EN, LOW);
 #endif
@@ -728,11 +758,92 @@ void setup()
     SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
     LOG_DEBUG("SPI.begin(SCK=%d, MISO=%d, MOSI=%d, NSS=%d)", LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
     SPI.setFrequency(4000000);
+#endif
+#if HAS_TFT
+#ifdef PORTDUINO
+    if (settingsMap[displayPanel] != no_screen) {
+        DisplayDriverConfig displayConfig;
+        static char *panels[] = {"NOSCREEN", "X11",     "ST7789",  "ST7735",  "ST7735S", "ST7796",
+                                 "ILI9341",  "ILI9342", "ILI9486", "ILI9488", "HX8357D"};
+        static char *touch[] = {"NOTOUCH", "XPT2046", "STMPE610", "GT911", "FT5x06"};
+#ifdef USE_X11
+        if (settingsMap[displayPanel] == x11) {
+            if (settingsMap[displayWidth] && settingsMap[displayHeight])
+                displayConfig = DisplayDriverConfig(DisplayDriverConfig::device_t::X11, (uint16_t)settingsMap[displayWidth],
+                                                    (uint16_t)settingsMap[displayHeight]);
+            else
+                displayConfig.device(DisplayDriverConfig::device_t::X11);
+        } else
+#endif
+        {
+            displayConfig.device(DisplayDriverConfig::device_t::CUSTOM_TFT)
+                .panel(DisplayDriverConfig::panel_config_t{.type = panels[settingsMap[displayPanel]],
+                                                           .panel_width = (uint16_t)settingsMap[displayWidth],
+                                                           .panel_height = (uint16_t)settingsMap[displayHeight],
+                                                           .rotation = (bool)settingsMap[displayRotate],
+                                                           .pin_cs = (int16_t)settingsMap[displayCS],
+                                                           .pin_rst = (int16_t)settingsMap[displayReset],
+                                                           .offset_x = (uint16_t)settingsMap[displayOffsetX],
+                                                           .offset_y = (uint16_t)settingsMap[displayOffsetY],
+                                                           .offset_rotation = (uint8_t)settingsMap[displayOffsetRotate],
+                                                           .invert = settingsMap[displayInvert] ? true : false,
+                                                           .rgb_order = (bool)settingsMap[displayRGBOrder],
+                                                           .dlen_16bit = settingsMap[displayPanel] == ili9486 ||
+                                                                         settingsMap[displayPanel] == ili9488})
+                .bus(DisplayDriverConfig::bus_config_t{.freq_write = (uint32_t)settingsMap[displayBusFrequency],
+                                                       .freq_read = 16000000,
+                                                       .spi{.pin_dc = (int8_t)settingsMap[displayDC],
+                                                            .use_lock = true,
+                                                            .spi_host = (uint16_t)settingsMap[displayspidev]}})
+                .input(DisplayDriverConfig::input_config_t{.keyboardDevice = settingsStrings[keyboardDevice],
+                                                           .pointerDevice = settingsStrings[pointerDevice]})
+                .light(DisplayDriverConfig::light_config_t{.pin_bl = (int16_t)settingsMap[displayBacklight],
+                                                           .pwm_channel = (int8_t)settingsMap[displayBacklightPWMChannel],
+                                                           .invert = (bool)settingsMap[displayBacklightInvert]});
+            if (settingsMap[touchscreenI2CAddr] == -1) {
+                displayConfig.touch(
+                    DisplayDriverConfig::touch_config_t{.type = touch[settingsMap[touchscreenModule]],
+                                                        .freq = (uint32_t)settingsMap[touchscreenBusFrequency],
+                                                        .pin_int = (int16_t)settingsMap[touchscreenIRQ],
+                                                        .offset_rotation = (uint8_t)settingsMap[touchscreenRotate],
+                                                        .spi{
+                                                            .spi_host = (int8_t)settingsMap[touchscreenspidev],
+                                                        },
+                                                        .pin_cs = (int16_t)settingsMap[touchscreenCS]});
+            } else {
+                displayConfig.touch(DisplayDriverConfig::touch_config_t{
+                    .type = touch[settingsMap[touchscreenModule]],
+                    .freq = (uint32_t)settingsMap[touchscreenBusFrequency],
+                    .x_min = 0,
+                    .x_max =
+                        (int16_t)((settingsMap[touchscreenRotate] & 1 ? settingsMap[displayWidth] : settingsMap[displayHeight]) -
+                                  1),
+                    .y_min = 0,
+                    .y_max =
+                        (int16_t)((settingsMap[touchscreenRotate] & 1 ? settingsMap[displayHeight] : settingsMap[displayWidth]) -
+                                  1),
+                    .pin_int = (int16_t)settingsMap[touchscreenIRQ],
+                    .offset_rotation = (uint8_t)settingsMap[touchscreenRotate],
+                    .i2c{.i2c_addr = (uint8_t)settingsMap[touchscreenI2CAddr]}});
+            }
+        }
+        deviceScreen = &DeviceScreen::create(&displayConfig);
+        PacketAPI::create(PacketServer::init());
+        deviceScreen->init(new PacketClient);
+    } else {
+        LOG_INFO("Running without TFT display!");
+    }
+#else
+    deviceScreen = &DeviceScreen::create();
+    PacketAPI::create(PacketServer::init());
+    deviceScreen->init(new PacketClient);
+#endif
 #endif
 
     // Initialize the screen first so we can show the logo while we start up everything else.
+#if HAS_SCREEN
     screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
-
+#endif
     // setup TZ prior to time actions.
 #if !MESHTASTIC_EXCLUDE_TZ
     LOG_DEBUG("Use compiled/slipstreamed %s", slipstreamTZString); // important, removing this clobbers our magic string
@@ -781,6 +892,11 @@ void setup()
     LOG_DEBUG("Start audio thread");
     audioThread = new AudioThread();
 #endif
+
+#ifdef HAS_UDP_MULTICAST
+    LOG_DEBUG("Start multicast thread");
+    udpThread = new UdpMulticastThread();
+#endif
     service = new MeshService();
     service->init();
 
@@ -1122,7 +1238,19 @@ void setup()
     // This must be _after_ service.init because we need our preferences loaded from flash to have proper timeout values
     PowerFSM_setup(); // we will transition to ON in a couple of seconds, FIXME, only do this for cold boots, not waking from SDS
     powerFSMthread = new PowerFSMThread();
+
+#if HAS_TFT
+#ifdef HAS_FREE_RTOS
+    xTaskCreatePinnedToCore(tft_task_handler, "tft", 8192, NULL, 1, NULL, 0);
+#endif
+#else
     setCPUFast(false); // 80MHz is fine for our slow peripherals
+#endif
+
+#ifdef ARDUINO_ARCH_ESP32
+    LOG_DEBUG("Free heap  : %7d bytes", ESP.getFreeHeap());
+    LOG_DEBUG("Free PSRAM : %7d bytes", ESP.getFreePsram());
+#endif
 }
 #endif
 uint32_t rebootAtMsec;   // If not zero we will reboot at this time (used to reboot shortly after the update completes)
@@ -1219,4 +1347,22 @@ void loop()
         mainDelay.delay(delayMsec);
     }
 }
+
+#if HAS_TFT
+void tft_task_handler(void *param = nullptr)
+{
+    while (true) {
+        if (deviceScreen) {
+            spiLock->lock();
+            deviceScreen->task_handler();
+            spiLock->unlock();
+        }
+#ifdef HAS_FREE_RTOS
+        vTaskDelay(5 / portTICK_PERIOD_MS);
+#else
+        delay(5);
 #endif
+    }
+}
+#endif
+#endif

src/main.h

@@ -49,6 +49,11 @@ extern Adafruit_DRV2605 drv;
 extern AudioThread *audioThread;
 #endif
 
+#ifdef HAS_UDP_MULTICAST
+#include "mesh/udp/UdpMulticastThread.h"
+extern UdpMulticastThread *udpThread;
+#endif
+
 // Global Screen singleton.
 extern graphics::Screen *screen;
 

src/mesh/FloodingRouter.cpp

@@ -13,7 +13,8 @@ FloodingRouter::FloodingRouter() {}
 ErrorCode FloodingRouter::send(meshtastic_MeshPacket *p)
 {
     // Add any messages _we_ send to the seen message list (so we will ignore all retransmissions we see)
-    wasSeenRecently(p); // FIXME, move this to a sniffSent method
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // First set the relayer to us
+    wasSeenRecently(p);                                         // FIXME, move this to a sniffSent method
 
     return Router::send(p);
 }
@@ -23,26 +24,17 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
     if (wasSeenRecently(p)) { // Note: this will also add a recent packet record
         printPacket("Ignore dupe incoming msg", p);
         rxDupe++;
-        if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
-            config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
-            config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
-            // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
-            if (Router::cancelSending(p->from, p->id))
-                txRelayCanceled++;
-        }
-        if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE && iface) {
-            iface->clampToLateRebroadcastWindow(getFrom(p), p->id);
-        }
 
         /* If the original transmitter is doing retransmissions (hopStart equals hopLimit) for a reliable transmission, e.g., when
-        the ACK got lost, we will handle the packet again to make sure it gets an ACK to its packet. */
+        the ACK got lost, we will handle the packet again to make sure it gets an implicit ACK. */
         bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
         if (isRepeated) {
             LOG_DEBUG("Repeated reliable tx");
-            if (!perhapsRebroadcast(p) && isToUs(p) && p->want_ack) {
-                // FIXME - channel index should be used, but the packet is still encrypted here
-                sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, 0, 0);
-            }
+            // Check if it's still in the Tx queue, if not, we have to relay it again
+            if (!findInTxQueue(p->from, p->id))
+                perhapsRebroadcast(p);
+        } else {
+            perhapsCancelDupe(p);
         }
 
         return true;
@@ -51,13 +43,27 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
     return Router::shouldFilterReceived(p);
 }
 
+void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
+{
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
+        // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
+        if (Router::cancelSending(p->from, p->id))
+            txRelayCanceled++;
+    }
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE && iface) {
+        iface->clampToLateRebroadcastWindow(getFrom(p), p->id);
+    }
+}
+
 bool FloodingRouter::isRebroadcaster()
 {
     return config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE &&
            config.device.rebroadcast_mode != meshtastic_Config_DeviceConfig_RebroadcastMode_NONE;
 }
 
-bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
+void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
 {
     if (!isToUs(p) && (p->hop_limit > 0) && !isFromUs(p)) {
         if (p->id != 0) {
@@ -72,13 +78,12 @@ bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
                     tosend->hop_limit = 2;
                 }
 #endif
+                tosend->next_hop = NO_NEXT_HOP_PREFERENCE; // this should already be the case, but just in case
 
                 LOG_INFO("Rebroadcast received floodmsg");
                 // Note: we are careful to resend using the original senders node id
                 // We are careful not to call our hooked version of send() - because we don't want to check this again
                 Router::send(tosend);
-
-                return true;
             } else {
                 LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
             }
@@ -86,13 +91,12 @@ bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
             LOG_DEBUG("Ignore 0 id broadcast");
         }
     }
-
-    return false;
 }
 
 void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
 {
-    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) && (p->decoded.request_id != 0);
+    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
+                        (p->decoded.request_id != 0 || p->decoded.reply_id != 0);
     if (isAckorReply && !isToUs(p) && !isBroadcast(p->to)) {
         // do not flood direct message that is ACKed or replied to
         LOG_DEBUG("Rxd an ACK/reply not for me, cancel rebroadcast");

src/mesh/FloodingRouter.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "PacketHistory.h"
 #include "Router.h"
 
 /**
@@ -26,14 +25,11 @@
   Any entries in recentBroadcasts that are older than X seconds (longer than the
   max time a flood can take) will be discarded.
  */
-class FloodingRouter : public Router, protected PacketHistory
+class FloodingRouter : public Router
 {
   private:
-    bool isRebroadcaster();
-
-    /** Check if we should rebroadcast this packet, and do so if needed
-     * @return true if rebroadcasted */
-    bool perhapsRebroadcast(const meshtastic_MeshPacket *p);
+    /* Check if we should rebroadcast this packet, and do so if needed */
+    void perhapsRebroadcast(const meshtastic_MeshPacket *p);
 
   public:
     /**
@@ -62,4 +58,10 @@ class FloodingRouter : public Router, protected PacketHistory
      * Look for broadcasts we need to rebroadcast
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
+
+    /* Call when receiving a duplicate packet to check whether we should cancel a packet in the Tx queue */
+    void perhapsCancelDupe(const meshtastic_MeshPacket *p);
+
+    // Return true if we are a rebroadcaster
+    bool isRebroadcaster();
 };

src/mesh/LR11x0Interface.cpp

@@ -262,10 +262,17 @@ template <typename T> void LR11x0Interface<T>::startReceive()
 template <typename T> bool LR11x0Interface<T>::isChannelActive()
 {
     // check if we can detect a LoRa preamble on the current channel
+    ChannelScanConfig_t cfg = {.cad = {.symNum = NUM_SYM_CAD,
+                                       .detPeak = RADIOLIB_LR11X0_CAD_PARAM_DEFAULT,
+                                       .detMin = RADIOLIB_LR11X0_CAD_PARAM_DEFAULT,
+                                       .exitMode = RADIOLIB_LR11X0_CAD_PARAM_DEFAULT,
+                                       .timeout = 0,
+                                       .irqFlags = RADIOLIB_IRQ_CAD_DEFAULT_FLAGS,
+                                       .irqMask = RADIOLIB_IRQ_CAD_DEFAULT_MASK}};
     int16_t result;
 
     setStandby();
-    result = lora.scanChannel();
+    result = lora.scanChannel(cfg);
     if (result == RADIOLIB_LORA_DETECTED)
         return true;
 

src/mesh/MeshPacketQueue.cpp

@@ -117,6 +117,19 @@ meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id, bool t
     return NULL;
 }
 
+/* Attempt to find a packet from this queue. Return true if it was found. */
+bool MeshPacketQueue::find(NodeNum from, PacketId id)
+{
+    for (auto it = queue.begin(); it != queue.end(); it++) {
+        auto p = (*it);
+        if (getFrom(p) == from && p->id == id) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * Attempt to find a lower-priority packet in the queue and replace it with the provided one.
  * @return True if the replacement succeeded, false otherwise

src/mesh/MeshPacketQueue.h

@@ -37,4 +37,7 @@ class MeshPacketQueue
 
     /** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
     meshtastic_MeshPacket *remove(NodeNum from, PacketId id, bool tx_normal = true, bool tx_late = true);
+
+    /* Attempt to find a packet from this queue. Return true if it was found. */
+    bool find(NodeNum from, PacketId id);
 };

src/mesh/MeshService.cpp

@@ -173,7 +173,9 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
         return;
     }
 #endif
-    p.from = 0; // We don't let phones assign nodenums to their sent messages
+    p.from = 0;                          // We don't let clients assign nodenums to their sent messages
+    p.next_hop = NO_NEXT_HOP_PREFERENCE; // We don't let clients assign next_hop to their sent messages
+    p.relay_node = NO_RELAY_NODE;        // We don't let clients assign relay_node to their sent messages
 
     if (p.id == 0)
         p.id = generatePacketId(); // If the phone didn't supply one, then pick one

src/mesh/MeshTypes.h

@@ -40,6 +40,11 @@ enum RxSource {
 /// We normally just use max 3 hops for sending reliable messages
 #define HOP_RELIABLE 3
 
+// For old firmware or when falling back to flooding, there is no next-hop preference
+#define NO_NEXT_HOP_PREFERENCE 0
+// For old firmware there is no relay node set
+#define NO_RELAY_NODE 0
+
 typedef int ErrorCode;
 
 /// Alloc and free packets to our global, ISR safe pool

src/mesh/NextHopRouter.cpp

@@ -0,0 +1,272 @@
+#include "NextHopRouter.h"
+
+NextHopRouter::NextHopRouter() {}
+
+PendingPacket::PendingPacket(meshtastic_MeshPacket *p, uint8_t numRetransmissions)
+{
+    packet = p;
+    this->numRetransmissions = numRetransmissions - 1; // We subtract one, because we assume the user just did the first send
+}
+
+/**
+ * Send a packet
+ */
+ErrorCode NextHopRouter::send(meshtastic_MeshPacket *p)
+{
+    // Add any messages _we_ send to the seen message list (so we will ignore all retransmissions we see)
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // First set the relayer to us
+    wasSeenRecently(p);                                         // FIXME, move this to a sniffSent method
+
+    p->next_hop = getNextHop(p->to, p->relay_node); // set the next hop
+    LOG_DEBUG("Setting next hop for packet with dest %x to %x", p->to, p->next_hop);
+
+    // If it's from us, ReliableRouter already handles retransmissions if want_ack is set. If a next hop is set and hop limit is
+    // not 0 or want_ack is set, start retransmissions
+    if ((!isFromUs(p) || !p->want_ack) && p->next_hop != NO_NEXT_HOP_PREFERENCE && (p->hop_limit > 0 || p->want_ack))
+        startRetransmission(packetPool.allocCopy(*p)); // start retransmission for relayed packet
+
+    return Router::send(p);
+}
+
+bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
+{
+    bool wasFallback = false;
+    bool weWereNextHop = false;
+    if (wasSeenRecently(p, true, &wasFallback, &weWereNextHop)) { // Note: this will also add a recent packet record
+        printPacket("Ignore dupe incoming msg", p);
+        rxDupe++;
+        stopRetransmission(p->from, p->id);
+
+        // If it was a fallback to flooding, try to relay again
+        if (wasFallback) {
+            LOG_INFO("Fallback to flooding from relay_node=0x%x", p->relay_node);
+            // Check if it's still in the Tx queue, if not, we have to relay it again
+            if (!findInTxQueue(p->from, p->id))
+                perhapsRelay(p);
+        } else {
+            bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
+            // If repeated and not in Tx queue anymore, try relaying again, or if we are the destination, send the ACK again
+            if (isRepeated) {
+                if (!findInTxQueue(p->from, p->id) && !perhapsRelay(p) && isToUs(p) && p->want_ack)
+                    sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
+            } else if (!weWereNextHop) {
+                perhapsCancelDupe(p); // If it's a dupe, cancel relay if we were not explicitly asked to relay
+            }
+        }
+        return true;
+    }
+
+    return Router::shouldFilterReceived(p);
+}
+
+void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
+{
+    NodeNum ourNodeNum = getNodeNum();
+    uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(ourNodeNum);
+    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
+                        (p->decoded.request_id != 0 || p->decoded.reply_id != 0);
+    if (isAckorReply) {
+        // Update next-hop for the original transmitter of this successful transmission to the relay node, but ONLY if "from" is
+        // not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the 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 relayer and the ACK came directly from
+                // the destination
+                if (wasRelayer(p->relay_node, p->decoded.request_id, p->to) ||
+                    (wasRelayer(ourRelayID, p->decoded.request_id, p->to) && p->hop_start != 0 && p->hop_start == p->hop_limit)) {
+                    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", p->from, p->relay_node);
+                        origTx->next_hop = p->relay_node;
+                    }
+                }
+            }
+        }
+        if (!isToUs(p)) {
+            Router::cancelSending(p->to, p->decoded.request_id); // cancel rebroadcast for this DM
+            // stop retransmission for the original packet
+            stopRetransmission(p->to, p->decoded.request_id); // for original packet, from = to and id = request_id
+        }
+    }
+
+    perhapsRelay(p);
+
+    // handle the packet as normal
+    Router::sniffReceived(p, c);
+}
+
+/* Check if we should be relaying this packet if so, do so. */
+bool NextHopRouter::perhapsRelay(const meshtastic_MeshPacket *p)
+{
+    if (!isToUs(p) && !isFromUs(p) && p->hop_limit > 0) {
+        if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
+            if (isRebroadcaster()) {
+                meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+                LOG_INFO("Relaying received message coming from %x", p->relay_node);
+
+                tosend->hop_limit--; // bump down the hop count
+                NextHopRouter::send(tosend);
+
+                return true;
+            } else {
+                LOG_DEBUG("Not rebroadcasting: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
+            }
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Get the next hop for a destination, given the relay node
+ * @return the node number of the next hop, 0 if no preference (fallback to FloodingRouter)
+ */
+uint8_t NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
+{
+    // When we're a repeater router->sniffReceived will call NextHopRouter directly without checking for broadcast
+    if (isBroadcast(to))
+        return NO_NEXT_HOP_PREFERENCE;
+
+    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);
+            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);
+    }
+    return NO_NEXT_HOP_PREFERENCE;
+}
+
+PendingPacket *NextHopRouter::findPendingPacket(GlobalPacketId key)
+{
+    auto old = pending.find(key); // If we have an old record, someone messed up because id got reused
+    if (old != pending.end()) {
+        return &old->second;
+    } else
+        return NULL;
+}
+
+/**
+ * Stop any retransmissions we are doing of the specified node/packet ID pair
+ */
+bool NextHopRouter::stopRetransmission(NodeNum from, PacketId id)
+{
+    auto key = GlobalPacketId(from, id);
+    return stopRetransmission(key);
+}
+
+bool NextHopRouter::stopRetransmission(GlobalPacketId key)
+{
+    auto old = findPendingPacket(key);
+    if (old) {
+        auto p = old->packet;
+        /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
+          to avoid canceling a transmission if it was ACKed super fast via MQTT */
+        if (old->numRetransmissions < NUM_RELIABLE_RETX - 1) {
+            // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
+            cancelSending(getFrom(p), p->id);
+            // now free the pooled copy for retransmission too
+            packetPool.release(p);
+        }
+        auto numErased = pending.erase(key);
+        assert(numErased == 1);
+        return true;
+    } else
+        return false;
+}
+
+/**
+ * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
+ */
+PendingPacket *NextHopRouter::startRetransmission(meshtastic_MeshPacket *p, uint8_t numReTx)
+{
+    auto id = GlobalPacketId(p);
+    auto rec = PendingPacket(p, numReTx);
+
+    stopRetransmission(getFrom(p), p->id);
+
+    setNextTx(&rec);
+    pending[id] = rec;
+
+    return &pending[id];
+}
+
+/**
+ * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
+ */
+int32_t NextHopRouter::doRetransmissions()
+{
+    uint32_t now = millis();
+    int32_t d = INT32_MAX;
+
+    // FIXME, we should use a better datastructure rather than walking through this map.
+    // for(auto el: pending) {
+    for (auto it = pending.begin(), nextIt = it; it != pending.end(); it = nextIt) {
+        ++nextIt; // we use this odd pattern because we might be deleting it...
+        auto &p = it->second;
+
+        bool stillValid = true; // assume we'll keep this record around
+
+        // FIXME, handle 51 day rolloever here!!!
+        if (p.nextTxMsec <= now) {
+            if (p.numRetransmissions == 0) {
+                if (isFromUs(p.packet)) {
+                    LOG_DEBUG("Reliable send failed, returning a nak for fr=0x%x,to=0x%x,id=0x%x", p.packet->from, p.packet->to,
+                              p.packet->id);
+                    sendAckNak(meshtastic_Routing_Error_MAX_RETRANSMIT, getFrom(p.packet), p.packet->id, p.packet->channel);
+                }
+                // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived
+                stopRetransmission(it->first);
+                stillValid = false; // just deleted it
+            } else {
+                LOG_DEBUG("Sending retransmission fr=0x%x,to=0x%x,id=0x%x, tries left=%d", p.packet->from, p.packet->to,
+                          p.packet->id, p.numRetransmissions);
+
+                if (!isBroadcast(p.packet->to)) {
+                    if (p.numRetransmissions == 1) {
+                        // Last retransmission, reset next_hop (fallback to FloodingRouter)
+                        p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
+                        // Also reset it in the nodeDB
+                        meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to);
+                        if (sentTo) {
+                            LOG_INFO("Resetting next hop for packet with dest 0x%x\n", p.packet->to);
+                            sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
+                        }
+                        FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                    } else {
+                        NextHopRouter::send(packetPool.allocCopy(*p.packet));
+                    }
+                } else {
+                    // Note: we call the superclass version because we don't want to have our version of send() add a new
+                    // retransmission record
+                    FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                }
+
+                // Queue again
+                --p.numRetransmissions;
+                setNextTx(&p);
+            }
+        }
+
+        if (stillValid) {
+            // Update our desired sleep delay
+            int32_t t = p.nextTxMsec - now;
+
+            d = min(t, d);
+        }
+    }
+
+    return d;
+}
+
+void NextHopRouter::setNextTx(PendingPacket *pending)
+{
+    assert(iface);
+    auto d = iface->getRetransmissionMsec(pending->packet);
+    pending->nextTxMsec = millis() + d;
+    LOG_DEBUG("Setting next retransmission in %u msecs: ", d);
+    printPacket("", pending->packet);
+    setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
+}

src/mesh/NextHopRouter.h

@@ -0,0 +1,151 @@
+#pragma once
+
+#include "FloodingRouter.h"
+#include <unordered_map>
+
+/**
+ * An identifier for a globally unique message - a pair of the sending nodenum and the packet id assigned
+ * to that message
+ */
+struct GlobalPacketId {
+    NodeNum node;
+    PacketId id;
+
+    bool operator==(const GlobalPacketId &p) const { return node == p.node && id == p.id; }
+
+    explicit GlobalPacketId(const meshtastic_MeshPacket *p)
+    {
+        node = getFrom(p);
+        id = p->id;
+    }
+
+    GlobalPacketId(NodeNum _from, PacketId _id)
+    {
+        node = _from;
+        id = _id;
+    }
+};
+
+/**
+ * A packet queued for retransmission
+ */
+struct PendingPacket {
+    meshtastic_MeshPacket *packet;
+
+    /** The next time we should try to retransmit this packet */
+    uint32_t nextTxMsec = 0;
+
+    /** Starts at NUM_RETRANSMISSIONS -1 and counts down.  Once zero it will be removed from the list */
+    uint8_t numRetransmissions = 0;
+
+    PendingPacket() {}
+    explicit PendingPacket(meshtastic_MeshPacket *p, uint8_t numRetransmissions);
+};
+
+class GlobalPacketIdHashFunction
+{
+  public:
+    size_t operator()(const GlobalPacketId &p) const { return (std::hash<NodeNum>()(p.node)) ^ (std::hash<PacketId>()(p.id)); }
+};
+
+/*
+  Router for direct messages, which only relays if it is the next hop for a packet. The next hop is set by the current
+  relayer of a packet, which bases this on information from a previous successful delivery to the destination via flooding.
+  Namely, in the PacketHistory, we keep track of (up to 3) relayers of a packet. When the ACK is delivered back to us via a node
+  that also relayed the original packet, we use that node as next hop for the destination from then on. This makes sure that only
+  when there’s a two-way connection, we assign a next hop. Both the ReliableRouter and NextHopRouter will do retransmissions (the
+  NextHopRouter only 1 time). For the final retry, if no one actually relayed the packet, it will reset the next hop in order to
+  fall back to the FloodingRouter again. Note that thus also intermediate hops will do a single retransmission if the intended
+  next-hop didn’t relay, in order to fix changes in the middle of the route.
+*/
+class NextHopRouter : public FloodingRouter
+{
+  public:
+    /**
+     * Constructor
+     *
+     */
+    NextHopRouter();
+
+    /**
+     * Send a packet
+     * @return an error code
+     */
+    virtual ErrorCode send(meshtastic_MeshPacket *p) override;
+
+    /** Do our retransmission handling */
+    virtual int32_t runOnce() override
+    {
+        // Note: We must doRetransmissions FIRST, because it might queue up work for the base class runOnce implementation
+        doRetransmissions();
+
+        int32_t r = FloodingRouter::runOnce();
+
+        // Also after calling runOnce there might be new packets to retransmit
+        auto d = doRetransmissions();
+        return min(d, r);
+    }
+
+    // The number of retransmissions intermediate nodes will do (actually 1 less than this)
+    constexpr static uint8_t NUM_INTERMEDIATE_RETX = 2;
+    // The number of retransmissions the original sender will do
+    constexpr static uint8_t NUM_RELIABLE_RETX = 3;
+
+  protected:
+    /**
+     * Pending retransmissions
+     */
+    std::unordered_map<GlobalPacketId, PendingPacket, GlobalPacketIdHashFunction> pending;
+
+    /**
+     * Should this incoming filter be dropped?
+     *
+     * Called immediately on reception, before any further processing.
+     * @return true to abandon the packet
+     */
+    virtual bool shouldFilterReceived(const meshtastic_MeshPacket *p) override;
+
+    /**
+     * Look for packets we need to relay
+     */
+    virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
+
+    /**
+     * Try to find the pending packet record for this ID (or NULL if not found)
+     */
+    PendingPacket *findPendingPacket(NodeNum from, PacketId id) { return findPendingPacket(GlobalPacketId(from, id)); }
+    PendingPacket *findPendingPacket(GlobalPacketId p);
+
+    /**
+     * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
+     */
+    PendingPacket *startRetransmission(meshtastic_MeshPacket *p, uint8_t numReTx = NUM_INTERMEDIATE_RETX);
+
+    /**
+     * Stop any retransmissions we are doing of the specified node/packet ID pair
+     *
+     * @return true if we found and removed a transmission with this ID
+     */
+    bool stopRetransmission(NodeNum from, PacketId id);
+    bool stopRetransmission(GlobalPacketId p);
+
+    /**
+     * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
+     *
+     * @return the number of msecs until our next retransmission or MAXINT if none scheduled
+     */
+    int32_t doRetransmissions();
+
+    void setNextTx(PendingPacket *pending);
+
+  private:
+    /**
+     * Get the next hop for a destination, given the relay node
+     * @return the node number of the next hop, 0 if no preference (fallback to FloodingRouter)
+     */
+    uint8_t getNextHop(NodeNum to, uint8_t relay_node);
+
+    /** Check if we should be relaying this packet if so, do so.
+     *  @return true if we did relay */
+    bool perhapsRelay(const meshtastic_MeshPacket *p);
+};

src/mesh/NodeDB.cpp

@@ -56,6 +56,7 @@ NodeDB *nodeDB = nullptr;
 // we have plenty of ram so statically alloc this tempbuf (for now)
 EXT_RAM_BSS_ATTR meshtastic_DeviceState devicestate;
 meshtastic_MyNodeInfo &myNodeInfo = devicestate.my_node;
+meshtastic_NodeDatabase nodeDatabase;
 meshtastic_LocalConfig config;
 meshtastic_DeviceUIConfig uiconfig{.screen_brightness = 153, .screen_timeout = 30};
 meshtastic_LocalModuleConfig moduleConfig;
@@ -143,7 +144,7 @@ uint32_t get_st7789_id(uint8_t cs, uint8_t sck, uint8_t mosi, uint8_t dc, uint8_
 
 #endif
 
-bool meshtastic_DeviceState_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field)
+bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field)
 {
     if (ostream) {
         std::vector<meshtastic_NodeInfoLite> const *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
@@ -192,6 +193,7 @@ NodeDB::NodeDB()
     cleanupMeshDB();
 
     uint32_t devicestateCRC = crc32Buffer(&devicestate, sizeof(devicestate));
+    uint32_t nodeDatabaseCRC = crc32Buffer(&nodeDatabase, sizeof(nodeDatabase));
     uint32_t configCRC = crc32Buffer(&config, sizeof(config));
     uint32_t channelFileCRC = crc32Buffer(&channelFile, sizeof(channelFile));
 
@@ -246,15 +248,15 @@ NodeDB::NodeDB()
     // Ensure macaddr is set to our macaddr as it will be copied in our info below
     memcpy(owner.macaddr, ourMacAddr, sizeof(owner.macaddr));
 
-    // Include our owner in the node db under our nodenum
-    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
     if (!config.has_security) {
         config.has_security = true;
+        config.security = meshtastic_Config_SecurityConfig_init_default;
         config.security.serial_enabled = config.device.serial_enabled;
         config.security.is_managed = config.device.is_managed;
     }
 
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
+
     if (!owner.is_licensed) {
         bool keygenSuccess = false;
         if (config.security.private_key.size == 32) {
@@ -281,10 +283,18 @@ NodeDB::NodeDB()
         crypto->setDHPrivateKey(config.security.private_key.bytes);
     }
 #endif
-
+    // Include our owner in the node db under our nodenum
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
     info->user = TypeConversions::ConvertToUserLite(owner);
     info->has_user = true;
 
+    // If node database has not been saved for the first time, save it now
+#ifdef FSCom
+    if (!FSCom.exists(nodeDatabaseFileName)) {
+        saveNodeDatabaseToDisk();
+    }
+#endif
+
 #ifdef ARCH_ESP32
     Preferences preferences;
     preferences.begin("meshtastic", false);
@@ -296,6 +306,9 @@ NodeDB::NodeDB()
     resetRadioConfig(); // If bogus settings got saved, then fix them
     // nodeDB->LOG_DEBUG("region=%d, NODENUM=0x%x, dbsize=%d", config.lora.region, myNodeInfo.my_node_num, numMeshNodes);
 
+    // Uncomment below to always enable UDP broadcasts
+    // config.network.enabled_protocols = meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST;
+
     // If we are setup to broadcast on the default channel, ensure that the telemetry intervals are coerced to the minimum value
     // of 30 minutes or more
     if (channels.isDefaultChannel(channels.getPrimaryIndex())) {
@@ -317,6 +330,8 @@ NodeDB::NodeDB()
 
     if (devicestateCRC != crc32Buffer(&devicestate, sizeof(devicestate)))
         saveWhat |= SEGMENT_DEVICESTATE;
+    if (nodeDatabaseCRC != crc32Buffer(&nodeDatabase, sizeof(nodeDatabase)))
+        saveWhat |= SEGMENT_NODEDATABASE;
     if (configCRC != crc32Buffer(&config, sizeof(config)))
         saveWhat |= SEGMENT_CONFIG;
     if (channelFileCRC != crc32Buffer(&channelFile, sizeof(channelFile)))
@@ -431,6 +446,7 @@ bool NodeDB::factoryReset(bool eraseBleBonds)
 #endif
     spiLock->unlock();
     // second, install default state (this will deal with the duplicate mac address issue)
+    installDefaultNodeDatabase();
     installDefaultDeviceState();
     installDefaultConfig(!eraseBleBonds); // Also preserve the private key if we're not erasing BLE bonds
     installDefaultModuleConfig();
@@ -455,6 +471,15 @@ bool NodeDB::factoryReset(bool eraseBleBonds)
     return true;
 }
 
+void NodeDB::installDefaultNodeDatabase()
+{
+    LOG_DEBUG("Install default NodeDatabase");
+    nodeDatabase.version = DEVICESTATE_CUR_VER;
+    nodeDatabase.nodes = std::vector<meshtastic_NodeInfoLite>(MAX_NUM_NODES);
+    numMeshNodes = 0;
+    meshNodes = &nodeDatabase.nodes;
+}
+
 void NodeDB::installDefaultConfig(bool preserveKey = false)
 {
     uint8_t private_key_temp[32];
@@ -782,9 +807,10 @@ void NodeDB::resetNodes()
     if (!config.position.fixed_position)
         clearLocalPosition();
     numMeshNodes = 1;
-    std::fill(devicestate.node_db_lite.begin() + 1, devicestate.node_db_lite.end(), meshtastic_NodeInfoLite());
+    std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
     devicestate.has_rx_text_message = false;
     devicestate.has_rx_waypoint = false;
+    saveNodeDatabaseToDisk();
     saveDeviceStateToDisk();
     if (neighborInfoModule && moduleConfig.neighbor_info.enabled)
         neighborInfoModule->resetNeighbors();
@@ -800,10 +826,10 @@ void NodeDB::removeNodeByNum(NodeNum nodeNum)
             removed++;
     }
     numMeshNodes -= removed;
-    std::fill(devicestate.node_db_lite.begin() + numMeshNodes, devicestate.node_db_lite.begin() + numMeshNodes + 1,
+    std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.begin() + numMeshNodes + 1,
               meshtastic_NodeInfoLite());
     LOG_DEBUG("NodeDB::removeNodeByNum purged %d entries. Save changes", removed);
-    saveDeviceStateToDisk();
+    saveNodeDatabaseToDisk();
 }
 
 void NodeDB::clearLocalPosition()
@@ -832,7 +858,7 @@ void NodeDB::cleanupMeshDB()
         }
     }
     numMeshNodes -= removed;
-    std::fill(devicestate.node_db_lite.begin() + numMeshNodes, devicestate.node_db_lite.begin() + numMeshNodes + removed,
+    std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.begin() + numMeshNodes + removed,
               meshtastic_NodeInfoLite());
     LOG_DEBUG("cleanupMeshDB purged %d entries", removed);
 }
@@ -842,13 +868,9 @@ void NodeDB::installDefaultDeviceState()
     LOG_INFO("Install default DeviceState");
     // memset(&devicestate, 0, sizeof(meshtastic_DeviceState));
 
-    numMeshNodes = 0;
-    meshNodes = &devicestate.node_db_lite;
-
     // init our devicestate with valid flags so protobuf writing/reading will work
     devicestate.has_my_node = true;
     devicestate.has_owner = true;
-    // devicestate.node_db_lite_count = 0;
     devicestate.version = DEVICESTATE_CUR_VER;
     devicestate.receive_queue_count = 0; // Not yet implemented FIXME
     devicestate.has_rx_waypoint = false;
@@ -902,12 +924,6 @@ void NodeDB::pickNewNodeNum()
     myNodeInfo.my_node_num = nodeNum;
 }
 
-static const char *prefFileName = "/prefs/db.proto";
-static const char *configFileName = "/prefs/config.proto";
-static const char *uiconfigFileName = "/prefs/uiconfig.proto";
-static const char *moduleConfigFileName = "/prefs/module.proto";
-static const char *channelFileName = "/prefs/channels.proto";
-
 /** Load a protobuf from a file, return LoadFileResult */
 LoadFileResult NodeDB::loadProto(const char *filename, size_t protoSize, size_t objSize, const pb_msgdesc_t *fields,
                                  void *dest_struct)
@@ -943,20 +959,44 @@ LoadFileResult NodeDB::loadProto(const char *filename, size_t protoSize, size_t
 
 void NodeDB::loadFromDisk()
 {
-    devicestate.version =
-        0; // Mark the current device state as completely unusable, so that if we fail reading the entire file from
+    // Mark the current device state as completely unusable, so that if we fail reading the entire file from
     // disk we will still factoryReset to restore things.
+    devicestate.version = 0;
 
 #ifdef ARCH_ESP32
     spiLock->lock();
+    // If the legacy deviceState exists, start over with a factory reset
     if (FSCom.exists("/static/static"))
         rmDir("/static/static"); // Remove bad static web files bundle from initial 2.5.13 release
     spiLock->unlock();
 #endif
+#ifdef FSCom
+    spiLock->lock();
+    if (FSCom.exists(legacyPrefFileName)) {
+        rmDir("/prefs");
+    }
+    spiLock->unlock();
+#endif
+    auto state = loadProto(nodeDatabaseFileName, getMaxNodesAllocatedSize(), sizeof(meshtastic_NodeDatabase),
+                           &meshtastic_NodeDatabase_msg, &nodeDatabase);
+    if (nodeDatabase.version < DEVICESTATE_MIN_VER) {
+        LOG_WARN("NodeDatabase %d is old, discard", nodeDatabase.version);
+        installDefaultNodeDatabase();
+    } else {
+        meshNodes = &nodeDatabase.nodes;
+        numMeshNodes = nodeDatabase.nodes.size();
+        LOG_INFO("Loaded saved nodedatabase version %d, with nodes count: %d", nodeDatabase.version, nodeDatabase.nodes.size());
+    }
+
+    if (numMeshNodes > MAX_NUM_NODES) {
+        LOG_WARN("Node count %d exceeds MAX_NUM_NODES %d, truncating", numMeshNodes, MAX_NUM_NODES);
+        numMeshNodes = MAX_NUM_NODES;
+    }
+    meshNodes->resize(MAX_NUM_NODES);
 
     // static DeviceState scratch; We no longer read into a tempbuf because this structure is 15KB of valuable RAM
-    auto state = loadProto(prefFileName, sizeof(meshtastic_DeviceState) + MAX_NUM_NODES_FS * meshtastic_NodeInfoLite_size,
-                           sizeof(meshtastic_DeviceState), &meshtastic_DeviceState_msg, &devicestate);
+    state = loadProto(deviceStateFileName, meshtastic_DeviceState_size, sizeof(meshtastic_DeviceState),
+                      &meshtastic_DeviceState_msg, &devicestate);
 
     // See https://github.com/meshtastic/firmware/issues/4184#issuecomment-2269390786
     // It is very important to try and use the saved prefs even if we fail to read meshtastic_DeviceState.  Because most of our
@@ -970,15 +1010,8 @@ void NodeDB::loadFromDisk()
         LOG_WARN("Devicestate %d is old, discard", devicestate.version);
         installDefaultDeviceState();
     } else {
-        LOG_INFO("Loaded saved devicestate version %d, with nodecount: %d", devicestate.version, devicestate.node_db_lite.size());
-        meshNodes = &devicestate.node_db_lite;
-        numMeshNodes = devicestate.node_db_lite.size();
+        LOG_INFO("Loaded saved devicestate version %d", devicestate.version);
     }
-    if (numMeshNodes > MAX_NUM_NODES) {
-        LOG_WARN("Node count %d exceeds MAX_NUM_NODES %d, truncating", numMeshNodes, MAX_NUM_NODES);
-        numMeshNodes = MAX_NUM_NODES;
-    }
-    meshNodes->resize(MAX_NUM_NODES);
 
     state = loadProto(configFileName, meshtastic_LocalConfig_size, sizeof(meshtastic_LocalConfig), &meshtastic_LocalConfig_msg,
                       &config);
@@ -1144,15 +1177,24 @@ bool NodeDB::saveDeviceStateToDisk()
 #endif
     // Note: if MAX_NUM_NODES=100 and meshtastic_NodeInfoLite_size=166, so will be approximately 17KB
     // Because so huge we _must_ not use fullAtomic, because the filesystem is probably too small to hold two copies of this
-    size_t deviceStateSize;
-    pb_get_encoded_size(&deviceStateSize, meshtastic_DeviceState_fields, &devicestate);
-    return saveProto(prefFileName, deviceStateSize, &meshtastic_DeviceState_msg, &devicestate, false);
+    return saveProto(deviceStateFileName, meshtastic_DeviceState_size, &meshtastic_DeviceState_msg, &devicestate, true);
+}
+
+bool NodeDB::saveNodeDatabaseToDisk()
+{
+#ifdef FSCom
+    spiLock->lock();
+    FSCom.mkdir("/prefs");
+    spiLock->unlock();
+#endif
+    size_t nodeDatabaseSize;
+    pb_get_encoded_size(&nodeDatabaseSize, meshtastic_NodeDatabase_fields, &nodeDatabase);
+    return saveProto(nodeDatabaseFileName, nodeDatabaseSize, &meshtastic_NodeDatabase_msg, &nodeDatabase, false);
 }
 
 bool NodeDB::saveToDiskNoRetry(int saveWhat)
 {
     bool success = true;
-
 #ifdef FSCom
     spiLock->lock();
     FSCom.mkdir("/prefs");
@@ -1197,11 +1239,16 @@ bool NodeDB::saveToDiskNoRetry(int saveWhat)
         success &= saveDeviceStateToDisk();
     }
 
+    if (saveWhat & SEGMENT_NODEDATABASE) {
+        success &= saveNodeDatabaseToDisk();
+    }
+
     return success;
 }
 
 bool NodeDB::saveToDisk(int saveWhat)
 {
+    LOG_DEBUG("Save to disk %d", saveWhat);
     bool success = saveToDiskNoRetry(saveWhat);
 
     if (!success) {
@@ -1382,8 +1429,9 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
 
         // We just changed something about a User,
         // store our DB unless we just did so less than a minute ago
+
         if (!Throttle::isWithinTimespanMs(lastNodeDbSave, ONE_MINUTE_MS)) {
-            saveToDisk(SEGMENT_DEVICESTATE);
+            saveToDisk(SEGMENT_NODEDATABASE);
             lastNodeDbSave = millis();
         } else {
             LOG_DEBUG("Defer NodeDB saveToDisk for now");
@@ -1397,6 +1445,10 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
 /// we updateGUI and updateGUIforNode if we think our this change is big enough for a redraw
 void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
 {
+    // if (mp.from == getNodeNum()) {
+    //     LOG_DEBUG("Ignore update from self");
+    //     return;
+    // }
     if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.from) {
         LOG_DEBUG("Update DB node 0x%x, rx_time=%u", mp.from, mp.rx_time);
 
@@ -1528,4 +1580,4 @@ void recordCriticalError(meshtastic_CriticalErrorCode code, uint32_t address, co
     LOG_ERROR("A critical failure occurred, portduino is exiting");
     exit(2);
 #endif
-}
+}

src/mesh/NodeDB.h

@@ -4,6 +4,7 @@
 #include <Arduino.h>
 #include <algorithm>
 #include <assert.h>
+#include <pb_encode.h>
 #include <vector>
 
 #include "MeshTypes.h"
@@ -12,6 +13,10 @@
 #include "mesh-pb-constants.h"
 #include "mesh/generated/meshtastic/mesh.pb.h" // For CriticalErrorCode
 
+#if ARCH_PORTDUINO
+#include "PortduinoGlue.h"
+#endif
+
 /*
 DeviceState versions used to be defined in the .proto file but really only this function cares.  So changed to a
 #define here.
@@ -21,11 +26,13 @@ DeviceState versions used to be defined in the .proto file but really only this
 #define SEGMENT_MODULECONFIG 2
 #define SEGMENT_DEVICESTATE 4
 #define SEGMENT_CHANNELS 8
+#define SEGMENT_NODEDATABASE 16
 
-#define DEVICESTATE_CUR_VER 23
-#define DEVICESTATE_MIN_VER 22
+#define DEVICESTATE_CUR_VER 24
+#define DEVICESTATE_MIN_VER 24
 
 extern meshtastic_DeviceState devicestate;
+extern meshtastic_NodeDatabase nodeDatabase;
 extern meshtastic_ChannelFile channelFile;
 extern meshtastic_MyNodeInfo &myNodeInfo;
 extern meshtastic_LocalConfig config;
@@ -34,6 +41,14 @@ extern meshtastic_LocalModuleConfig moduleConfig;
 extern meshtastic_User &owner;
 extern meshtastic_Position localPosition;
 
+static constexpr const char *deviceStateFileName = "/prefs/device.proto";
+static constexpr const char *legacyPrefFileName = "/prefs/db.proto";
+static constexpr const char *nodeDatabaseFileName = "/prefs/nodes.proto";
+static constexpr const char *configFileName = "/prefs/config.proto";
+static constexpr const char *uiconfigFileName = "/prefs/uiconfig.proto";
+static constexpr const char *moduleConfigFileName = "/prefs/module.proto";
+static constexpr const char *channelFileName = "/prefs/channels.proto";
+
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
 uint32_t sinceLastSeen(const meshtastic_NodeInfoLite *n);
 
@@ -75,7 +90,8 @@ class NodeDB
 
     /// write to flash
     /// @return true if the save was successful
-    bool saveToDisk(int saveWhat = SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
+    bool saveToDisk(int saveWhat = SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS |
+                                   SEGMENT_NODEDATABASE);
 
     /** Reinit radio config if needed, because either:
      * a) sometimes a buggy android app might send us bogus settings or
@@ -104,6 +120,9 @@ class NodeDB
     /// @return our node number
     NodeNum getNodeNum() { return myNodeInfo.my_node_num; }
 
+    // @return last byte of a NodeNum, 0xFF if it ended at 0x00
+    uint8_t getLastByteOfNodeNum(NodeNum num) { return (uint8_t)((num & 0xFF) ? (num & 0xFF) : 0xFF); }
+
     /// if returns false, that means our node should send a DenyNodeNum response.  If true, we think the number is okay for use
     // bool handleWantNodeNum(NodeNum n);
 
@@ -148,6 +167,15 @@ class NodeDB
     virtual meshtastic_NodeInfoLite *getMeshNode(NodeNum n);
     size_t getNumMeshNodes() { return numMeshNodes; }
 
+    size_t getMaxNodesAllocatedSize()
+    {
+        meshtastic_NodeDatabase emptyNodeDatabase;
+        emptyNodeDatabase.version = DEVICESTATE_CUR_VER;
+        size_t nodeDatabaseSize;
+        pb_get_encoded_size(&nodeDatabaseSize, meshtastic_NodeDatabase_fields, &emptyNodeDatabase);
+        return nodeDatabaseSize + (MAX_NUM_NODES * meshtastic_NodeInfoLite_size);
+    }
+
     // returns true if the maximum number of nodes is reached or we are running low on memory
     bool isFull();
 
@@ -188,8 +216,8 @@ class NodeDB
     void cleanupMeshDB();
 
     /// Reinit device state from scratch (not loading from disk)
-    void installDefaultDeviceState(), installDefaultChannels(), installDefaultConfig(bool preserveKey),
-        installDefaultModuleConfig();
+    void installDefaultDeviceState(), installDefaultNodeDatabase(), installDefaultChannels(),
+        installDefaultConfig(bool preserveKey), installDefaultModuleConfig();
 
     /// write to flash
     /// @return true if the save was successful
@@ -197,6 +225,7 @@ class NodeDB
 
     bool saveChannelsToDisk();
     bool saveDeviceStateToDisk();
+    bool saveNodeDatabaseToDisk();
 };
 
 extern NodeDB *nodeDB;

src/mesh/PacketHistory.cpp

@@ -16,7 +16,7 @@ PacketHistory::PacketHistory()
 /**
  * Update recentBroadcasts and return true if we have already seen this packet
  */
-bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate)
+bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate, bool *wasFallback, bool *weWereNextHop)
 {
     if (p->id == 0) {
         LOG_DEBUG("Ignore message with zero id");
@@ -27,6 +27,9 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
     r.id = p->id;
     r.sender = getFrom(p);
     r.rxTimeMsec = millis();
+    r.next_hop = p->next_hop;
+    r.relayed_by[0] = p->relay_node;
+    // LOG_INFO("Add relayed_by 0x%x for id=0x%x", p->relay_node, r.id);
 
     auto found = recentPackets.find(r);
     bool seenRecently = (found != recentPackets.end()); // found not equal to .end() means packet was seen recently
@@ -40,14 +43,36 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
 
     if (seenRecently) {
         LOG_DEBUG("Found existing packet record for fr=0x%x,to=0x%x,id=0x%x", p->from, p->to, p->id);
+        uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(nodeDB->getNodeNum());
+        if (wasFallback) {
+            // If it was seen with a next-hop not set to us and now it's NO_NEXT_HOP_PREFERENCE, and the relayer relayed already
+            // before, it's a fallback to flooding. If we didn't already relay and the next-hop neither, we might need to handle
+            // it now.
+            if (found->sender != nodeDB->getNodeNum() && found->next_hop != NO_NEXT_HOP_PREFERENCE &&
+                found->next_hop != ourRelayID && p->next_hop == NO_NEXT_HOP_PREFERENCE && wasRelayer(p->relay_node, found) &&
+                !wasRelayer(ourRelayID, found) && !wasRelayer(found->next_hop, found)) {
+                *wasFallback = true;
+            }
+        }
+
+        // Check if we were the next hop for this packet
+        if (weWereNextHop) {
+            *weWereNextHop = found->next_hop == ourRelayID;
+        }
     }
 
     if (withUpdate) {
-        if (found != recentPackets.end()) { // delete existing to updated timestamp (re-insert)
-            recentPackets.erase(found);     // as unsorted_set::iterator is const (can't update timestamp - so re-insert..)
+        if (found != recentPackets.end()) { // delete existing to updated timestamp and relayed_by (re-insert)
+            // Add the existing relayed_by to the new record
+            for (uint8_t i = 0; i < NUM_RELAYERS - 1; i++) {
+                if (found->relayed_by[i])
+                    r.relayed_by[i + 1] = found->relayed_by[i];
+            }
+            r.next_hop = found->next_hop; // keep the original next_hop (such that we check whether we were originally asked)
+            recentPackets.erase(found);   // as unsorted_set::iterator is const (can't update - so re-insert..)
         }
         recentPackets.insert(r);
-        printPacket("Add packet record", p);
+        LOG_DEBUG("Add packet record fr=0x%x, id=0x%x", p->from, p->id);
     }
 
     // Capacity is reerved, so only purge expired packets if recentPackets fills past 90% capacity
@@ -75,4 +100,59 @@ void PacketHistory::clearExpiredRecentPackets()
     }
 
     LOG_DEBUG("recentPackets size=%ld (after clearing expired packets)", recentPackets.size());
+}
+
+/* Check if a certain node was a relayer of a packet in the history given an ID and sender
+ * @return true if node was indeed a relayer, false if not */
+bool PacketHistory::wasRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender)
+{
+    if (relayer == 0)
+        return false;
+
+    PacketRecord r = {.sender = sender, .id = id, .rxTimeMsec = 0, .next_hop = 0};
+    auto found = recentPackets.find(r);
+
+    if (found == recentPackets.end()) {
+        return false;
+    }
+
+    return wasRelayer(relayer, found);
+}
+
+/* Check if a certain node was a relayer of a packet in the history given iterator
+ * @return true if node was indeed a relayer, false if not */
+bool PacketHistory::wasRelayer(const uint8_t relayer, std::unordered_set<PacketRecord, PacketRecordHashFunction>::iterator r)
+{
+    for (uint8_t i = 0; i < NUM_RELAYERS; i++) {
+        if (r->relayed_by[i] == relayer) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Remove a relayer from the list of relayers of a packet in the history given an ID and sender
+void PacketHistory::removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender)
+{
+    PacketRecord r = {.sender = sender, .id = id, .rxTimeMsec = 0, .next_hop = 0};
+    auto found = recentPackets.find(r);
+
+    if (found == recentPackets.end()) {
+        return;
+    }
+    // Make a copy of the found record
+    r.next_hop = found->next_hop;
+    r.rxTimeMsec = found->rxTimeMsec;
+
+    // Only add the relayers that are not the one we want to remove
+    uint8_t j = 0;
+    for (uint8_t i = 0; i < NUM_RELAYERS; i++) {
+        if (found->relayed_by[i] != relayer) {
+            r.relayed_by[j] = found->relayed_by[i];
+            j++;
+        }
+    }
+
+    recentPackets.erase(found);
+    recentPackets.insert(r);
 }

src/mesh/PacketHistory.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Router.h"
+#include "NodeDB.h"
 #include <unordered_set>
 
 /// We clear our old flood record 10 minutes after we see the last of it
@@ -10,13 +10,18 @@
 #define FLOOD_EXPIRE_TIME (10 * 60 * 1000L)
 #endif
 
+#define NUM_RELAYERS                                                                                                             \
+    3 // Number of relayer we keep track of. Use 3 to be efficient with memory alignment of PacketRecord to 16 bytes
+
 /**
  * A record of a recent message broadcast
  */
 struct PacketRecord {
     NodeNum sender;
     PacketId id;
-    uint32_t rxTimeMsec; // Unix time in msecs - the time we received it
+    uint32_t rxTimeMsec;              // Unix time in msecs - the time we received it
+    uint8_t next_hop;                 // The next hop asked for this packet
+    uint8_t relayed_by[NUM_RELAYERS]; // Array of nodes that relayed this packet
 
     bool operator==(const PacketRecord &p) const { return sender == p.sender && id == p.id; }
 };
@@ -44,6 +49,20 @@ class PacketHistory
      * Update recentBroadcasts and return true if we have already seen this packet
      *
      * @param withUpdate if true and not found we add an entry to recentPackets
+     * @param wasFallback if not nullptr, packet will be checked for fallback to flooding and value will be set to true if so
+     * @param weWereNextHop if not nullptr, packet will be checked for us being the next hop and value will be set to true if so
      */
-    bool wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate = true);
-};
+    bool wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate = true, bool *wasFallback = nullptr,
+                         bool *weWereNextHop = nullptr);
+
+    /* Check if a certain node was a relayer of a packet in the history given an ID and sender
+     * @return true if node was indeed a relayer, false if not */
+    bool wasRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
+
+    /* Check if a certain node was a relayer of a packet in the history given iterator
+     * @return true if node was indeed a relayer, false if not */
+    bool wasRelayer(const uint8_t relayer, std::unordered_set<PacketRecord, PacketRecordHashFunction>::iterator r);
+
+    // Remove a relayer from the list of relayers of a packet in the history given an ID and sender
+    void removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
+};

src/mesh/PhoneAPI.cpp

@@ -12,6 +12,7 @@
 #include "PhoneAPI.h"
 #include "PowerFSM.h"
 #include "RadioInterface.h"
+#include "Router.h"
 #include "SPILock.h"
 #include "TypeConversions.h"
 #include "main.h"

src/mesh/RadioInterface.cpp

@@ -261,7 +261,7 @@ uint8_t RadioInterface::getCWsize(float snr)
     const uint32_t SNR_MIN = -20;
 
     // The maximum value for a LoRa SNR
-    const uint32_t SNR_MAX = 15;
+    const uint32_t SNR_MAX = 10;
 
     return map(snr, SNR_MIN, SNR_MAX, CWmin, CWmax);
 }
@@ -340,6 +340,10 @@ void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
         out += DEBUG_PORT.mt_sprintf(" via MQTT");
     if (p->hop_start != 0)
         out += DEBUG_PORT.mt_sprintf(" hopStart=%d", p->hop_start);
+    if (p->next_hop != 0)
+        out += DEBUG_PORT.mt_sprintf(" nextHop=0x%x", p->next_hop);
+    if (p->relay_node != 0)
+        out += DEBUG_PORT.mt_sprintf(" relay=0x%x", p->relay_node);
     if (p->priority != 0)
         out += DEBUG_PORT.mt_sprintf(" priority=%d", p->priority);
 
@@ -566,7 +570,7 @@ void RadioInterface::applyModemConfig()
     saveChannelNum(channel_num);
     saveFreq(freq + loraConfig.frequency_offset);
 
-    slotTimeMsec = computeSlotTimeMsec(bw, sf);
+    slotTimeMsec = computeSlotTimeMsec();
     preambleTimeMsec = getPacketTime((uint32_t)0);
     maxPacketTimeMsec = getPacketTime(meshtastic_Constants_DATA_PAYLOAD_LEN + sizeof(PacketHeader));
 
@@ -581,6 +585,25 @@ void RadioInterface::applyModemConfig()
     LOG_INFO("Slot time: %u msec", slotTimeMsec);
 }
 
+/** Slottime is the time to detect a transmission has started, consisting of:
+  - CAD duration;
+  - roundtrip air propagation time (assuming max. 30km between nodes);
+  - Tx/Rx turnaround time (maximum of SX126x and SX127x);
+  - MAC processing time (measured on T-beam) */
+uint32_t RadioInterface::computeSlotTimeMsec()
+{
+    float sumPropagationTurnaroundMACTime = 0.2 + 0.4 + 7; // in milliseconds
+    float symbolTime = pow(2, sf) / bw;                    // in milliseconds
+
+    if (myRegion->wideLora) {
+        // CAD duration derived from AN1200.22 of SX1280
+        return (NUM_SYM_CAD_24GHZ + (2 * sf + 3) / 32) * symbolTime + sumPropagationTurnaroundMACTime;
+    } else {
+        // CAD duration for SX127x is max. 2.25 symbols, for SX126x it is number of symbols + 0.5 symbol
+        return max(2.25, NUM_SYM_CAD + 0.5) * symbolTime + sumPropagationTurnaroundMACTime;
+    }
+}
+
 /**
  * Some regulatory regions limit xmit power.
  * This function should be called by subclasses after setting their desired power.  It might lower it
@@ -620,8 +643,8 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
     radioBuffer.header.to = p->to;
     radioBuffer.header.id = p->id;
     radioBuffer.header.channel = p->channel;
-    radioBuffer.header.next_hop = 0;   // *** For future use ***
-    radioBuffer.header.relay_node = 0; // *** For future use ***
+    radioBuffer.header.next_hop = p->next_hop;
+    radioBuffer.header.relay_node = p->relay_node;
     if (p->hop_limit > HOP_MAX) {
         LOG_WARN("hop limit %d is too high, setting to %d", p->hop_limit, HOP_RELIABLE);
         p->hop_limit = HOP_RELIABLE;

src/mesh/RadioInterface.h

@@ -38,10 +38,10 @@ typedef struct {
     /** The channel hash - used as a hint for the decoder to limit which channels we consider */
     uint8_t channel;
 
-    // ***For future use*** Last byte of the NodeNum of the next-hop for this packet
+    // Last byte of the NodeNum of the next-hop for this packet
     uint8_t next_hop;
 
-    // ***For future use*** Last byte of the NodeNum of the node that will relay/relayed this packet
+    // Last byte of the NodeNum of the node that will relay/relayed this packet
     uint8_t relay_node;
 } PacketHeader;
 
@@ -83,24 +83,22 @@ class RadioInterface
     float bw = 125;
     uint8_t sf = 9;
     uint8_t cr = 5;
-    /** Slottime is the minimum time to wait, consisting of:
-      - CAD duration (maximum of SX126x and SX127x);
-      - roundtrip air propagation time (assuming max. 30km between nodes);
-      - Tx/Rx turnaround time (maximum of SX126x and SX127x);
-      - MAC processing time (measured on T-beam) */
-    uint32_t slotTimeMsec = computeSlotTimeMsec(bw, sf);
+
+    const uint8_t NUM_SYM_CAD = 2;       // Number of symbols used for CAD, 2 is the default since RadioLib 6.3.0 as per AN1200.48
+    const uint8_t NUM_SYM_CAD_24GHZ = 4; // Number of symbols used for CAD in 2.4 GHz, 4 is recommended in AN1200.22 of SX1280
+    uint32_t slotTimeMsec = computeSlotTimeMsec();
     uint16_t preambleLength = 16;      // 8 is default, but we use longer to increase the amount of sleep time when receiving
     uint32_t preambleTimeMsec = 165;   // calculated on startup, this is the default for LongFast
     uint32_t maxPacketTimeMsec = 3246; // calculated on startup, this is the default for LongFast
     const uint32_t PROCESSING_TIME_MSEC =
         4500;                // time to construct, process and construct a packet again (empirically determined)
-    const uint8_t CWmin = 2; // minimum CWsize
-    const uint8_t CWmax = 7; // maximum CWsize
+    const uint8_t CWmin = 3; // minimum CWsize
+    const uint8_t CWmax = 8; // maximum CWsize
 
     meshtastic_MeshPacket *sendingPacket = NULL; // The packet we are currently sending
     uint32_t lastTxStart = 0L;
 
-    uint32_t computeSlotTimeMsec(float bw, float sf) { return 8.5 * pow(2, sf) / bw + 0.2 + 0.4 + 7; }
+    uint32_t computeSlotTimeMsec();
 
     /**
      * A temporary buffer used for sending/receiving packets, sized to hold the biggest buffer we might need
@@ -155,6 +153,9 @@ class RadioInterface
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     virtual bool cancelSending(NodeNum from, PacketId id) { return false; }
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    virtual bool findInTxQueue(NodeNum from, PacketId id) { return false; }
+
     // methods from radiohead
 
     /// Initialise the Driver transport hardware and software.

src/mesh/RadioLibInterface.cpp

@@ -222,6 +222,12 @@ bool RadioLibInterface::cancelSending(NodeNum from, PacketId id)
     return result;
 }
 
+/** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+bool RadioLibInterface::findInTxQueue(NodeNum from, PacketId id)
+{
+    return txQueue.find(from, id);
+}
+
 /** radio helper thread callback.
 We never immediately transmit after any operation (either Rx or Tx). Instead we should wait a random multiple of
 'slotTimes' (see definition in RadioInterface.h) taken from a contention window (CW) to lower the chance of collision.
@@ -445,6 +451,9 @@ void RadioLibInterface::handleReceiveInterrupt()
             mp->hop_start = (radioBuffer.header.flags & PACKET_FLAGS_HOP_START_MASK) >> PACKET_FLAGS_HOP_START_SHIFT;
             mp->want_ack = !!(radioBuffer.header.flags & PACKET_FLAGS_WANT_ACK_MASK);
             mp->via_mqtt = !!(radioBuffer.header.flags & PACKET_FLAGS_VIA_MQTT_MASK);
+            // If hop_start is not set, next_hop and relay_node are invalid (firmware <2.3)
+            mp->next_hop = mp->hop_start == 0 ? NO_NEXT_HOP_PREFERENCE : radioBuffer.header.next_hop;
+            mp->relay_node = mp->hop_start == 0 ? NO_RELAY_NODE : radioBuffer.header.relay_node;
 
             addReceiveMetadata(mp);
 

src/mesh/RadioLibInterface.h

@@ -135,6 +135,9 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     virtual bool cancelSending(NodeNum from, PacketId id) override;
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    virtual bool findInTxQueue(NodeNum from, PacketId id) override;
+
   private:
     /** if we have something waiting to send, start a short (random) timer so we can come check for collision before actually
      * doing the transmit */

src/mesh/ReliableRouter.cpp

@@ -23,7 +23,7 @@ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p)
         }
 
         auto copy = packetPool.allocCopy(*p);
-        startRetransmission(copy);
+        startRetransmission(copy, NUM_RELIABLE_RETX);
     }
 
     /* If we have pending retransmissions, add the airtime of this packet to it, because during that time we cannot receive an
@@ -35,7 +35,7 @@ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p)
         }
     }
 
-    return FloodingRouter::send(p);
+    return isBroadcast(p->to) ? FloodingRouter::send(p) : NextHopRouter::send(p);
 }
 
 bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
@@ -73,7 +73,7 @@ bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         i->second.nextTxMsec += iface->getPacketTime(p);
     }
 
-    return FloodingRouter::shouldFilterReceived(p);
+    return isBroadcast(p->to) ? FloodingRouter::shouldFilterReceived(p) : NextHopRouter::shouldFilterReceived(p);
 }
 
 /**
@@ -138,126 +138,5 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
     }
 
     // handle the packet as normal
-    FloodingRouter::sniffReceived(p, c);
-}
-
-#define NUM_RETRANSMISSIONS 3
-
-PendingPacket::PendingPacket(meshtastic_MeshPacket *p)
-{
-    packet = p;
-    numRetransmissions = NUM_RETRANSMISSIONS - 1; // We subtract one, because we assume the user just did the first send
-}
-
-PendingPacket *ReliableRouter::findPendingPacket(GlobalPacketId key)
-{
-    auto old = pending.find(key); // If we have an old record, someone messed up because id got reused
-    if (old != pending.end()) {
-        return &old->second;
-    } else
-        return NULL;
-}
-/**
- * Stop any retransmissions we are doing of the specified node/packet ID pair
- */
-bool ReliableRouter::stopRetransmission(NodeNum from, PacketId id)
-{
-    auto key = GlobalPacketId(from, id);
-    return stopRetransmission(key);
-}
-
-bool ReliableRouter::stopRetransmission(GlobalPacketId key)
-{
-    auto old = findPendingPacket(key);
-    if (old) {
-        auto p = old->packet;
-        /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
-          to avoid canceling a transmission if it was ACKed super fast via MQTT */
-        if (old->numRetransmissions < NUM_RETRANSMISSIONS - 1) {
-            // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
-            cancelSending(getFrom(p), p->id);
-        }
-        // now free the pooled copy for retransmission too
-        packetPool.release(p);
-        auto numErased = pending.erase(key);
-        assert(numErased == 1);
-        return true;
-    } else
-        return false;
-}
-
-/**
- * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
- */
-PendingPacket *ReliableRouter::startRetransmission(meshtastic_MeshPacket *p)
-{
-    auto id = GlobalPacketId(p);
-    auto rec = PendingPacket(p);
-
-    stopRetransmission(getFrom(p), p->id);
-
-    setNextTx(&rec);
-    pending[id] = rec;
-
-    return &pending[id];
-}
-
-/**
- * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
- */
-int32_t ReliableRouter::doRetransmissions()
-{
-    uint32_t now = millis();
-    int32_t d = INT32_MAX;
-
-    // FIXME, we should use a better datastructure rather than walking through this map.
-    // for(auto el: pending) {
-    for (auto it = pending.begin(), nextIt = it; it != pending.end(); it = nextIt) {
-        ++nextIt; // we use this odd pattern because we might be deleting it...
-        auto &p = it->second;
-
-        bool stillValid = true; // assume we'll keep this record around
-
-        // FIXME, handle 51 day rollover here!!!
-        if (p.nextTxMsec <= now) {
-            if (p.numRetransmissions == 0) {
-                LOG_DEBUG("Reliable send failed, return a nak for fr=0x%x,to=0x%x,id=0x%x", p.packet->from, p.packet->to,
-                          p.packet->id);
-                sendAckNak(meshtastic_Routing_Error_MAX_RETRANSMIT, getFrom(p.packet), p.packet->id, p.packet->channel);
-                // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived
-                stopRetransmission(it->first);
-                stillValid = false; // just deleted it
-            } else {
-                LOG_DEBUG("Send reliable retransmission fr=0x%x,to=0x%x,id=0x%x, tries left=%d", p.packet->from, p.packet->to,
-                          p.packet->id, p.numRetransmissions);
-
-                // Note: we call the superclass version because we don't want to have our version of send() add a new
-                // retransmission record
-                FloodingRouter::send(packetPool.allocCopy(*p.packet));
-
-                // Queue again
-                --p.numRetransmissions;
-                setNextTx(&p);
-            }
-        }
-
-        if (stillValid) {
-            // Update our desired sleep delay
-            int32_t t = p.nextTxMsec - now;
-
-            d = min(t, d);
-        }
-    }
-
-    return d;
-}
-
-void ReliableRouter::setNextTx(PendingPacket *pending)
-{
-    assert(iface);
-    auto d = iface->getRetransmissionMsec(pending->packet);
-    pending->nextTxMsec = millis() + d;
-    LOG_DEBUG("Set next retransmission in %u msecs: ", d);
-    printPacket("", pending->packet);
-    setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
+    isBroadcast(p->to) ? FloodingRouter::sniffReceived(p, c) : NextHopRouter::sniffReceived(p, c);
 }

src/mesh/ReliableRouter.h

@@ -1,61 +1,12 @@
 #pragma once
 
-#include "FloodingRouter.h"
-#include <unordered_map>
-
-/**
- * An identifier for a globally unique message - a pair of the sending nodenum and the packet id assigned
- * to that message
- */
-struct GlobalPacketId {
-    NodeNum node;
-    PacketId id;
-
-    bool operator==(const GlobalPacketId &p) const { return node == p.node && id == p.id; }
-
-    explicit GlobalPacketId(const meshtastic_MeshPacket *p)
-    {
-        node = getFrom(p);
-        id = p->id;
-    }
-
-    GlobalPacketId(NodeNum _from, PacketId _id)
-    {
-        node = _from;
-        id = _id;
-    }
-};
-
-/**
- * A packet queued for retransmission
- */
-struct PendingPacket {
-    meshtastic_MeshPacket *packet;
-
-    /** The next time we should try to retransmit this packet */
-    uint32_t nextTxMsec = 0;
-
-    /** Starts at NUM_RETRANSMISSIONS -1(normally 3) and counts down.  Once zero it will be removed from the list */
-    uint8_t numRetransmissions = 0;
-
-    PendingPacket() {}
-    explicit PendingPacket(meshtastic_MeshPacket *p);
-};
-
-class GlobalPacketIdHashFunction
-{
-  public:
-    size_t operator()(const GlobalPacketId &p) const { return (std::hash<NodeNum>()(p.node)) ^ (std::hash<PacketId>()(p.id)); }
-};
+#include "NextHopRouter.h"
 
 /**
  * This is a mixin that extends Router with the ability to do (one hop only) reliable message sends.
  */
-class ReliableRouter : public FloodingRouter
+class ReliableRouter : public NextHopRouter
 {
-  private:
-    std::unordered_map<GlobalPacketId, PendingPacket, GlobalPacketIdHashFunction> pending;
-
   public:
     /**
      * Constructor
@@ -70,54 +21,14 @@ class ReliableRouter : public FloodingRouter
      */
     virtual ErrorCode send(meshtastic_MeshPacket *p) override;
 
-    /** Do our retransmission handling */
-    virtual int32_t runOnce() override
-    {
-        // Note: We must doRetransmissions FIRST, because it might queue up work for the base class runOnce implementation
-        auto d = doRetransmissions();
-
-        int32_t r = FloodingRouter::runOnce();
-
-        return min(d, r);
-    }
-
   protected:
     /**
      * Look for acks/naks or someone retransmitting us
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
 
-    /**
-     * Try to find the pending packet record for this ID (or NULL if not found)
-     */
-    PendingPacket *findPendingPacket(NodeNum from, PacketId id) { return findPendingPacket(GlobalPacketId(from, id)); }
-    PendingPacket *findPendingPacket(GlobalPacketId p);
-
     /**
      * We hook this method so we can see packets before FloodingRouter says they should be discarded
      */
     virtual bool shouldFilterReceived(const meshtastic_MeshPacket *p) override;
-
-    /**
-     * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
-     */
-    PendingPacket *startRetransmission(meshtastic_MeshPacket *p);
-
-  private:
-    /**
-     * Stop any retransmissions we are doing of the specified node/packet ID pair
-     *
-     * @return true if we found and removed a transmission with this ID
-     */
-    bool stopRetransmission(NodeNum from, PacketId id);
-    bool stopRetransmission(GlobalPacketId p);
-
-    /**
-     * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
-     *
-     * @return the number of msecs until our next retransmission or MAXINT if none scheduled
-     */
-    int32_t doRetransmissions();
-
-    void setNextTx(PendingPacket *pending);
-};
+};

src/mesh/Router.cpp

@@ -249,6 +249,7 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     // the lora we need to make sure we have replaced it with our local address
     p->from = getFrom(p);
 
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // set the relayer to us
     // If we are the original transmitter, set the hop limit with which we start
     if (isFromUs(p))
         p->hop_start = p->hop_limit;
@@ -274,6 +275,11 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
             abortSendAndNak(encodeResult, p);
             return encodeResult; // FIXME - this isn't a valid ErrorCode
         }
+#if HAS_UDP_MULTICAST
+        if (udpThread && config.network.enabled_protocols & meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST) {
+            udpThread->onSend(const_cast<meshtastic_MeshPacket *>(p));
+        }
+#endif
 #if !MESHTASTIC_EXCLUDE_MQTT
         // Only publish to MQTT if we're the original transmitter of the packet
         if (moduleConfig.mqtt.enabled && isFromUs(p) && mqtt) {
@@ -290,7 +296,18 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
 /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
 bool Router::cancelSending(NodeNum from, PacketId id)
 {
-    return iface ? iface->cancelSending(from, id) : false;
+    if (iface && iface->cancelSending(from, id)) {
+        // We are not a relayer of this packet anymore
+        removeRelayer(nodeDB->getLastByteOfNodeNum(nodeDB->getNodeNum()), id, from);
+        return true;
+    }
+    return false;
+}
+
+/** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+bool Router::findInTxQueue(NodeNum from, PacketId id)
+{
+    return iface->findInTxQueue(from, id);
 }
 
 /**

src/mesh/Router.h

@@ -4,6 +4,7 @@
 #include "MemoryPool.h"
 #include "MeshTypes.h"
 #include "Observer.h"
+#include "PacketHistory.h"
 #include "PointerQueue.h"
 #include "RadioInterface.h"
 #include "concurrency/OSThread.h"
@@ -11,7 +12,7 @@
 /**
  * A mesh aware router that supports multiple interfaces.
  */
-class Router : protected concurrency::OSThread
+class Router : protected concurrency::OSThread, protected PacketHistory
 {
   private:
     /// Packets which have just arrived from the radio, ready to be processed by this service and possibly
@@ -50,6 +51,9 @@ class Router : protected concurrency::OSThread
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     bool cancelSending(NodeNum from, PacketId id);
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    bool findInTxQueue(NodeNum from, PacketId id);
+
     /** Allocate and return a meshpacket which defaults as send to broadcast from the current node.
      * The returned packet is guaranteed to have a unique packet ID already assigned
      */

src/mesh/SX126xInterface.cpp

@@ -294,10 +294,17 @@ template <typename T> void SX126xInterface<T>::startReceive()
 template <typename T> bool SX126xInterface<T>::isChannelActive()
 {
     // check if we can detect a LoRa preamble on the current channel
+    ChannelScanConfig_t cfg = {.cad = {.symNum = NUM_SYM_CAD,
+                                       .detPeak = RADIOLIB_SX126X_CAD_PARAM_DEFAULT,
+                                       .detMin = RADIOLIB_SX126X_CAD_PARAM_DEFAULT,
+                                       .exitMode = RADIOLIB_SX126X_CAD_PARAM_DEFAULT,
+                                       .timeout = 0,
+                                       .irqFlags = RADIOLIB_IRQ_CAD_DEFAULT_FLAGS,
+                                       .irqMask = RADIOLIB_IRQ_CAD_DEFAULT_MASK}};
     int16_t result;
 
     setStandby();
-    result = lora.scanChannel();
+    result = lora.scanChannel(cfg);
     if (result == RADIOLIB_LORA_DETECTED)
         return true;
     if (result != RADIOLIB_CHANNEL_FREE)

src/mesh/SX128xInterface.cpp

@@ -278,10 +278,17 @@ template <typename T> void SX128xInterface<T>::startReceive()
 template <typename T> bool SX128xInterface<T>::isChannelActive()
 {
     // check if we can detect a LoRa preamble on the current channel
+    ChannelScanConfig_t cfg = {.cad = {.symNum = NUM_SYM_CAD_24GHZ,
+                                       .detPeak = 0,
+                                       .detMin = 0,
+                                       .exitMode = 0,
+                                       .timeout = 0,
+                                       .irqFlags = RADIOLIB_IRQ_CAD_DEFAULT_FLAGS,
+                                       .irqMask = RADIOLIB_IRQ_CAD_DEFAULT_MASK}};
     int16_t result;
 
     setStandby();
-    result = lora.scanChannel();
+    result = lora.scanChannel(cfg);
     if (result == RADIOLIB_LORA_DETECTED)
         return true;
     if (result != RADIOLIB_CHANNEL_FREE)

src/mesh/api/PacketAPI.cpp

@@ -0,0 +1,104 @@
+#ifdef USE_PACKET_API
+
+#include "api/PacketAPI.h"
+#include "MeshService.h"
+#include "PowerFSM.h"
+#include "RadioInterface.h"
+#include "modules/NodeInfoModule.h"
+
+PacketAPI *packetAPI = nullptr;
+
+PacketAPI *PacketAPI::create(PacketServer *_server)
+{
+    if (!packetAPI) {
+        packetAPI = new PacketAPI(_server);
+    }
+    return packetAPI;
+}
+
+PacketAPI::PacketAPI(PacketServer *_server) : concurrency::OSThread("PacketAPI"), isConnected(false), server(_server) {}
+
+int32_t PacketAPI::runOnce()
+{
+    bool success = sendPacket();
+    success |= receivePacket();
+    return success ? 10 : 50;
+}
+
+bool PacketAPI::receivePacket(void)
+{
+    bool data_received = false;
+    while (server->hasData()) {
+        isConnected = true;
+        data_received = true;
+
+        powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
+        lastContactMsec = millis();
+
+        meshtastic_ToRadio *mr;
+        auto p = server->receivePacket()->move();
+        int id = p->getPacketId();
+        LOG_DEBUG("Received packet id=%u", id);
+        mr = (meshtastic_ToRadio *)&static_cast<DataPacket<meshtastic_ToRadio> *>(p.get())->getData();
+
+        switch (mr->which_payload_variant) {
+        case meshtastic_ToRadio_packet_tag: {
+            meshtastic_MeshPacket *mp = &mr->packet;
+            printPacket("PACKET FROM QUEUE", mp);
+            service->handleToRadio(*mp);
+            break;
+        }
+        case meshtastic_ToRadio_want_config_id_tag: {
+            uint32_t config_nonce = mr->want_config_id;
+            LOG_INFO("Screen wants config, nonce=%u", config_nonce);
+            handleStartConfig();
+            break;
+        }
+        case meshtastic_ToRadio_heartbeat_tag:
+            if (mr->heartbeat.dummy_field == 1) {
+                if (nodeInfoModule) {
+                    LOG_INFO("Broadcasting nodeinfo ping");
+                    nodeInfoModule->sendOurNodeInfo(NODENUM_BROADCAST, true, 0, true);
+                }
+            } else {
+                LOG_DEBUG("Got client heartbeat");
+            }
+            break;
+        default:
+            LOG_ERROR("Error: unhandled meshtastic_ToRadio variant: %d", mr->which_payload_variant);
+            break;
+        }
+    }
+    return data_received;
+}
+
+bool PacketAPI::sendPacket(void)
+{
+    // fill dummy buffer; we don't use it, we directly send the fromRadio structure
+    uint32_t len = getFromRadio(txBuf);
+    if (len != 0) {
+        static uint32_t id = 0;
+        fromRadioScratch.id = ++id;
+        // TODO: think about redesign or drop class MeshPacketServer
+        // if (typeid(*server) == typeid(MeshPacketServer))
+        //    return dynamic_cast<MeshPacketServer*>(server)->sendPacket(fromRadioScratch);
+        // else
+        bool result = server->sendPacket(DataPacket<meshtastic_FromRadio>(id, fromRadioScratch));
+        if (!result) {
+            LOG_ERROR("send queue full");
+        }
+        return result;
+    } else
+        return false;
+}
+
+/**
+ * return true if we got (once!) contact from our client and the server send queue is not full
+ */
+bool PacketAPI::checkIsConnected()
+{
+    isConnected |= server->hasData();
+    return isConnected && server->available();
+}
+
+#endif

src/mesh/api/PacketAPI.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "PhoneAPI.h"
+#include "comms/PacketServer.h"
+#include "concurrency/OSThread.h"
+
+/**
+ * A version of the phone API used for inter task communication based on protobuf packets, e.g.
+ * between two tasks running on CPU0 and CPU1, respectively.
+ *
+ */
+class PacketAPI : public PhoneAPI, public concurrency::OSThread
+{
+  public:
+    static PacketAPI *create(PacketServer *_server);
+    virtual ~PacketAPI(){};
+    virtual int32_t runOnce();
+
+  protected:
+    PacketAPI(PacketServer *_server);
+    // Check the current underlying physical queue to see if the client is fetching packets
+    bool checkIsConnected() override;
+
+    void onNowHasData(uint32_t fromRadioNum) override {}
+    void onConnectionChanged(bool connected) override {}
+
+  private:
+    bool receivePacket(void);
+    bool sendPacket(void);
+
+    bool isConnected;
+    PacketServer *server;
+    uint8_t txBuf[MAX_TO_FROM_RADIO_SIZE] = {0}; // dummy buf to obey PhoneAPI
+};
+
+extern PacketAPI *packetAPI;

src/mesh/generated/meshtastic/deviceonly.pb.cpp

@@ -18,6 +18,9 @@ PB_BIND(meshtastic_NodeInfoLite, meshtastic_NodeInfoLite, AUTO)
 PB_BIND(meshtastic_DeviceState, meshtastic_DeviceState, 2)
 
 
+PB_BIND(meshtastic_NodeDatabase, meshtastic_NodeDatabase, AUTO)
+
+
 PB_BIND(meshtastic_ChannelFile, meshtastic_ChannelFile, 2)
 
 

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -132,10 +132,17 @@ typedef struct _meshtastic_DeviceState {
     /* The mesh's nodes with their available gpio pins for RemoteHardware module */
     pb_size_t node_remote_hardware_pins_count;
     meshtastic_NodeRemoteHardwarePin node_remote_hardware_pins[12];
-    /* New lite version of NodeDB to decrease memory footprint */
-    std::vector<meshtastic_NodeInfoLite> node_db_lite;
 } meshtastic_DeviceState;
 
+typedef struct _meshtastic_NodeDatabase {
+    /* A version integer used to invalidate old save files when we make
+ incompatible changes This integer is set at build time and is private to
+ NodeDB.cpp in the device code. */
+    uint32_t version;
+    /* New lite version of NodeDB to decrease memory footprint */
+    std::vector<meshtastic_NodeInfoLite> nodes;
+} meshtastic_NodeDatabase;
+
 /* The on-disk saved channels */
 typedef struct _meshtastic_ChannelFile {
     /* The channels our node knows about */
@@ -156,12 +163,14 @@ extern "C" {
 #define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_UserLite_init_default         {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}}
 #define meshtastic_NodeInfoLite_init_default     {0, false, meshtastic_UserLite_init_default, false, meshtastic_PositionLite_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0}
-#define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}, {0}}
+#define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
+#define meshtastic_NodeDatabase_init_default     {0, {0}}
 #define meshtastic_ChannelFile_init_default      {0, {meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default}, 0}
 #define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_UserLite_init_zero            {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}}
 #define meshtastic_NodeInfoLite_init_zero        {0, false, meshtastic_UserLite_init_zero, false, meshtastic_PositionLite_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0}
-#define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}, {0}}
+#define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
+#define meshtastic_NodeDatabase_init_zero        {0, {0}}
 #define meshtastic_ChannelFile_init_zero         {0, {meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero}, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
@@ -198,7 +207,8 @@ extern "C" {
 #define meshtastic_DeviceState_did_gps_reset_tag 11
 #define meshtastic_DeviceState_rx_waypoint_tag   12
 #define meshtastic_DeviceState_node_remote_hardware_pins_tag 13
-#define meshtastic_DeviceState_node_db_lite_tag  14
+#define meshtastic_NodeDatabase_version_tag      1
+#define meshtastic_NodeDatabase_nodes_tag        2
 #define meshtastic_ChannelFile_channels_tag      1
 #define meshtastic_ChannelFile_version_tag       2
 
@@ -251,10 +261,8 @@ X(a, STATIC,   SINGULAR, UINT32,   version,           8) \
 X(a, STATIC,   SINGULAR, BOOL,     no_save,           9) \
 X(a, STATIC,   SINGULAR, BOOL,     did_gps_reset,    11) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  rx_waypoint,      12) \
-X(a, STATIC,   REPEATED, MESSAGE,  node_remote_hardware_pins,  13) \
-X(a, CALLBACK, REPEATED, MESSAGE,  node_db_lite,     14)
-extern bool meshtastic_DeviceState_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
-#define meshtastic_DeviceState_CALLBACK meshtastic_DeviceState_callback
+X(a, STATIC,   REPEATED, MESSAGE,  node_remote_hardware_pins,  13)
+#define meshtastic_DeviceState_CALLBACK NULL
 #define meshtastic_DeviceState_DEFAULT NULL
 #define meshtastic_DeviceState_my_node_MSGTYPE meshtastic_MyNodeInfo
 #define meshtastic_DeviceState_owner_MSGTYPE meshtastic_User
@@ -262,7 +270,14 @@ extern bool meshtastic_DeviceState_callback(pb_istream_t *istream, pb_ostream_t
 #define meshtastic_DeviceState_rx_text_message_MSGTYPE meshtastic_MeshPacket
 #define meshtastic_DeviceState_rx_waypoint_MSGTYPE meshtastic_MeshPacket
 #define meshtastic_DeviceState_node_remote_hardware_pins_MSGTYPE meshtastic_NodeRemoteHardwarePin
-#define meshtastic_DeviceState_node_db_lite_MSGTYPE meshtastic_NodeInfoLite
+
+#define meshtastic_NodeDatabase_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   version,           1) \
+X(a, CALLBACK, REPEATED, MESSAGE,  nodes,             2)
+extern bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
+#define meshtastic_NodeDatabase_CALLBACK meshtastic_NodeDatabase_callback
+#define meshtastic_NodeDatabase_DEFAULT NULL
+#define meshtastic_NodeDatabase_nodes_MSGTYPE meshtastic_NodeInfoLite
 
 #define meshtastic_ChannelFile_FIELDLIST(X, a) \
 X(a, STATIC,   REPEATED, MESSAGE,  channels,          1) \
@@ -275,6 +290,7 @@ extern const pb_msgdesc_t meshtastic_PositionLite_msg;
 extern const pb_msgdesc_t meshtastic_UserLite_msg;
 extern const pb_msgdesc_t meshtastic_NodeInfoLite_msg;
 extern const pb_msgdesc_t meshtastic_DeviceState_msg;
+extern const pb_msgdesc_t meshtastic_NodeDatabase_msg;
 extern const pb_msgdesc_t meshtastic_ChannelFile_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
@@ -282,12 +298,14 @@ extern const pb_msgdesc_t meshtastic_ChannelFile_msg;
 #define meshtastic_UserLite_fields &meshtastic_UserLite_msg
 #define meshtastic_NodeInfoLite_fields &meshtastic_NodeInfoLite_msg
 #define meshtastic_DeviceState_fields &meshtastic_DeviceState_msg
+#define meshtastic_NodeDatabase_fields &meshtastic_NodeDatabase_msg
 #define meshtastic_ChannelFile_fields &meshtastic_ChannelFile_msg
 
 /* Maximum encoded size of messages (where known) */
-/* meshtastic_DeviceState_size depends on runtime parameters */
-#define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_ChannelFile_size
+/* meshtastic_NodeDatabase_size depends on runtime parameters */
+#define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_DeviceState_size
 #define meshtastic_ChannelFile_size              718
+#define meshtastic_DeviceState_size              1720
 #define meshtastic_NodeInfoLite_size             188
 #define meshtastic_PositionLite_size             28
 #define meshtastic_UserLite_size                 96

src/mesh/generated/meshtastic/mesh.pb.h

@@ -1775,4 +1775,4 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 } /* extern "C" */
 #endif
 
-#endif
+#endif

src/mesh/mesh-pb-constants.h

@@ -23,8 +23,6 @@
 #define MAX_NUM_NODES 100
 #endif
 
-#define MAX_NUM_NODES_FS 100
-
 /// Max number of channels allowed
 #define MAX_NUM_CHANNELS (member_size(meshtastic_ChannelFile, channels) / member_size(meshtastic_ChannelFile, channels[0]))
 

src/mesh/udp/UdpMulticastThread.h

@@ -0,0 +1,70 @@
+#pragma once
+#if HAS_UDP_MULTICAST
+#include "configuration.h"
+#include "main.h"
+#include "mesh/Router.h"
+
+#include <AsyncUDP.h>
+#include <WiFi.h>
+
+#define UDP_MULTICAST_DEFAUL_PORT 4403 // Default port for UDP multicast is same as TCP api server
+#define UDP_MULTICAST_THREAD_INTERVAL_MS 15000
+
+class UdpMulticastThread : public concurrency::OSThread
+{
+  public:
+    UdpMulticastThread() : OSThread("UdpMulticast") { udpIpAddress = IPAddress(224, 0, 0, 69); }
+
+    void start()
+    {
+        if (udp.listenMulticast(udpIpAddress, UDP_MULTICAST_DEFAUL_PORT)) {
+            LOG_DEBUG("UDP Listening on IP: %s", WiFi.localIP().toString().c_str());
+            udp.onPacket([this](AsyncUDPPacket packet) { onReceive(packet); });
+        } else {
+            LOG_DEBUG("Failed to listen on UDP");
+        }
+    }
+
+    void onReceive(AsyncUDPPacket packet)
+    {
+        size_t packetLength = packet.length();
+        LOG_DEBUG("UDP broadcast from: %s, len=%u", packet.remoteIP().toString().c_str(), packetLength);
+        meshtastic_MeshPacket mp;
+        uint8_t bytes[meshtastic_MeshPacket_size]; // Allocate buffer for the data
+        size_t packetSize = packet.readBytes(bytes, packet.length());
+        LOG_DEBUG("Decoding MeshPacket from UDP len=%u", packetSize);
+        bool isPacketDecoded = pb_decode_from_bytes(bytes, packetLength, &meshtastic_MeshPacket_msg, &mp);
+        if (isPacketDecoded && router) {
+            UniquePacketPoolPacket p = packetPool.allocUniqueCopy(mp);
+            // Unset received SNR/RSSI
+            p->rx_snr = 0;
+            p->rx_rssi = 0;
+            router->enqueueReceivedMessage(p.release());
+        }
+    }
+
+    bool onSend(const meshtastic_MeshPacket *mp)
+    {
+        if (!mp || WiFi.status() != WL_CONNECTED) {
+            return false;
+        }
+        LOG_DEBUG("Broadcasting packet over UDP (id=%u)", mp->id);
+        uint8_t buffer[meshtastic_MeshPacket_size];
+        size_t encodedLength = pb_encode_to_bytes(buffer, sizeof(buffer), &meshtastic_MeshPacket_msg, mp);
+        udp.broadcastTo(buffer, encodedLength, UDP_MULTICAST_DEFAUL_PORT);
+        return true;
+    }
+
+  protected:
+    int32_t runOnce() override
+    {
+        canSleep = true;
+        // TODO: Implement nodeinfo broadcast
+        return UDP_MULTICAST_THREAD_INTERVAL_MS;
+    }
+
+  private:
+    IPAddress udpIpAddress;
+    AsyncUDP udp;
+};
+#endif // ARCH_ESP32

src/mesh/wifi/WiFiAPClient.cpp

@@ -112,6 +112,12 @@ static void onNetworkConnected()
         APStartupComplete = true;
     }
 
+#if HAS_UDP_MULTICAST
+    if (udpThread) {
+        udpThread->start();
+    }
+#endif
+
     // FIXME this is kinda yucky, instead we should just have an observable for 'wifireconnected'
 #ifndef MESHTASTIC_EXCLUDE_MQTT
     if (mqtt)
@@ -437,4 +443,4 @@ uint8_t getWifiDisconnectReason()
 {
     return wifiDisconnectReason;
 }
-#endif
+#endif

src/modules/TraceRouteModule.cpp

@@ -109,7 +109,7 @@ void TraceRouteModule::appendMyIDandSNR(meshtastic_RouteDiscovery *updated, floa
 void TraceRouteModule::printRoute(meshtastic_RouteDiscovery *r, uint32_t origin, uint32_t dest, bool isTowardsDestination)
 {
 #ifdef DEBUG_PORT
-    std::string route = "Route traced:";
+    std::string route = "Route traced:\n";
     route += vformat("0x%x --> ", origin);
     for (uint8_t i = 0; i < r->route_count; i++) {
         if (i < r->snr_towards_count && r->snr_towards[i] != INT8_MIN)
@@ -129,6 +129,7 @@ void TraceRouteModule::printRoute(meshtastic_RouteDiscovery *r, uint32_t origin,
 
     // If there's a route back (or we are the destination as then the route is complete), print it
     if (r->route_back_count > 0 || origin == nodeDB->getNodeNum()) {
+        route += "\n";
         if (r->snr_towards_count > 0 && origin == nodeDB->getNodeNum())
             route += vformat("(%.2fdB) 0x%x <-- ", (float)r->snr_back[r->snr_back_count - 1] / 4, origin);
         else

src/platform/portduino/SimRadio.cpp

@@ -139,6 +139,12 @@ bool SimRadio::cancelSending(NodeNum from, PacketId id)
     return result;
 }
 
+/** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+bool SimRadio::findInTxQueue(NodeNum from, PacketId id)
+{
+    return txQueue.find(from, id);
+}
+
 void SimRadio::onNotify(uint32_t notification)
 {
     switch (notification) {

src/platform/portduino/SimRadio.h

@@ -33,6 +33,9 @@ class SimRadio : public RadioInterface, protected concurrency::NotifiedWorkerThr
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     virtual bool cancelSending(NodeNum from, PacketId id) override;
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    virtual bool findInTxQueue(NodeNum from, PacketId id) override;
+
     /**
      * Start waiting to receive a message
      *

variants/mesh-tab/platformio.ini

@@ -36,6 +36,7 @@ build_flags = ${esp32s3_base.build_flags}
   -D RAM_SIZE=1024
   -D LGFX_DRIVER_TEMPLATE
   -D LGFX_DRIVER=LGFX_GENERIC
+  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_GENERIC.h\"
   -D LGFX_PIN_SCK=12
   -D LGFX_PIN_MOSI=13
   -D LGFX_PIN_MISO=11

variants/picomputer-s3/platformio.ini

@@ -1,7 +1,7 @@
 [env:picomputer-s3]
 extends = esp32s3_base
 board = bpi_picow_esp32_s3
-
+board_check = true
 ;OpenOCD flash method
 ;upload_protocol = esp-builtin
 ;Normal method
@@ -15,3 +15,50 @@ build_flags =
 lib_deps = 
   ${esp32s3_base.lib_deps}
   lovyan03/LovyanGFX@^1.2.0
+
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+
+
+[env:picomputer-s3-tft]
+extends = env:picomputer-s3
+board_build.partitions = default_8MB.csv ; just for test
+
+build_flags =
+  ${env:picomputer-s3.build_flags}
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
+  -D MESHTASTIC_EXCLUDE_BLUETOOTH=1
+  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
+  -D MESHTASTIC_EXCLUDE_SERIAL=1
+  -D MESHTASTIC_EXCLUDE_SOCKETAPI=1
+  -D INPUTDRIVER_MATRIX_TYPE=1
+  -D USE_PIN_BUZZER=PIN_BUZZER
+  -D USE_SX127x
+  -D MAX_NUM_NODES=200
+  -D HAS_SCREEN=0
+  -D HAS_TFT=1
+  -D RAM_SIZE=1024
+	-D LV_LVGL_H_INCLUDE_SIMPLE
+	-D LV_CONF_INCLUDE_SIMPLE
+	-D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D LV_USE_SYSMON=0
+  -D LV_USE_PROFILER=0
+  -D LV_USE_PERF_MONITOR=0
+  -D LV_USE_MEM_MONITOR=0
+  -D LV_USE_LOG=0
+  -D USE_LOG_DEBUG
+  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
+  -D LGFX_DRIVER=LGFX_PICOMPUTER_S3
+  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_PICOMPUTER_S3.h\"
+  -D VIEW_320x240
+;	-D USE_DOUBLE_BUFFER
+  -D USE_PACKET_API
+	-I lib/device-ui/generated/ui_320x240
+
+build_src_filter =
+  ${env:picomputer-s3.build_src_filter}
+  +<../lib/device-ui/generated/ui_320x240>
+  +<../lib/device-ui/resources>
+  +<../lib/device-ui/locale>
+  +<../lib/device-ui/source>

variants/portduino/platformio.ini

@@ -1,15 +1,79 @@
-[env:native]
+[native_base]
 extends = portduino_base
-; The pkg-config commands below optionally add link flags.
-; the || : is just a "or run the null command" to avoid returning an error code
-build_flags = ${portduino_base.build_flags} -O0 -I variants/portduino
+build_flags = ${portduino_base.build_flags} -I variants/portduino
+  -D ARCH_PORTDUINO
   -I /usr/include
-  !pkg-config --libs libulfius --silence-errors || :
-  !pkg-config --libs openssl --silence-errors || :
 board = cross_platform
 lib_deps = ${portduino_base.lib_deps}
 build_src_filter = ${portduino_base.build_src_filter}
 
+[env:native]
+extends = native_base
+; The pkg-config commands below optionally add link flags.
+; the || : is just a "or run the null command" to avoid returning an error code
+build_flags = ${native_base.build_flags}
+  !pkg-config --libs libulfius --silence-errors || :
+  !pkg-config --libs openssl --silence-errors || :
+
+[env:native-tft]
+extends = native_base
+build_type = release
+build_flags = ${native_base.build_flags} -Os -lX11 -linput -lxkbcommon -ffunction-sections -fdata-sections -Wl,--gc-sections
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D RAM_SIZE=16384
+  -D USE_X11=1
+  -D HAS_TFT=1
+  -D HAS_SCREEN=0
+  -D LV_BUILD_TEST=0
+  -D LV_USE_LIBINPUT=1
+  -D LV_LVGL_H_INCLUDE_SIMPLE
+  -D LV_CONF_INCLUDE_SIMPLE
+  -D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D USE_LOG_DEBUG
+  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
+  -D USE_PACKET_API
+  -I lib/device-ui/generated/ui_320x240
+  !pkg-config --libs libulfius --silence-errors || :
+  !pkg-config --libs openssl --silence-errors || :
+build_src_filter = ${native_base.build_src_filter}
+  -<graphics/TFTDisplay.cpp>
+  +<../lib/device-ui/generated/ui_320x240>
+  +<../lib/device-ui/generated/ui_320x240/fonts>
+  +<../lib/device-ui/resources>
+  +<../lib/device-ui/portduino>
+  +<../lib/device-ui/locale>
+  +<../lib/device-ui/source>
+
+[env:native-tft-debug]
+extends = native_base
+build_type = debug
+board_level = extra
+build_flags = ${native_base.build_flags} -O0 -fsanitize=address -lX11 -linput -lxkbcommon
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D DEBUG_HEAP
+  -D RAM_SIZE=16384
+  -D USE_X11=1
+  -D HAS_TFT=1
+  -D HAS_SCREEN=0
+;  -D CALIBRATE_TOUCH=0
+  -D LV_BUILD_TEST=0
+  -D LV_USE_LOG=1
+  -D LV_USE_SYSMON=1
+  -D LV_USE_PERF_MONITOR=1
+  -D LV_USE_MEM_MONITOR=0
+  -D LV_USE_PROFILER=0
+  -D LV_USE_LIBINPUT=1
+  -D LV_LVGL_H_INCLUDE_SIMPLE
+  -D LV_CONF_INCLUDE_SIMPLE
+  -D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D USE_LOG_DEBUG
+  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
+  -D USE_PACKET_API
+  -I lib/device-ui/generated/ui_320x240
+  !pkg-config --libs libulfius --silence-errors || :
+  !pkg-config --libs openssl --silence-errors || :
+build_src_filter = ${env:native-tft.build_src_filter}
+
 [env:coverage]
 extends = env:native
 build_flags = -lgcov --coverage -fprofile-abs-path -fsanitize=address ${env:native.build_flags}

variants/portduino/variant.h

@@ -1,4 +1,6 @@
+#ifndef HAS_SCREEN
 #define HAS_SCREEN 1
+#endif
 #define CANNED_MESSAGE_MODULE_ENABLE 1
 #define HAS_GPS 1
 #define MAX_RX_TOPHONE settingsMap[maxtophone]

variants/seeed-sensecap-indicator/platformio.ini

@@ -26,3 +26,59 @@ lib_deps = ${esp32s3_base.lib_deps}
   https://github.com/mverch67/LovyanGFX#develop
   earlephilhower/ESP8266Audio@^1.9.9
   earlephilhower/ESP8266SAM@^1.0.1
+
+
+[env:seeed-sensecap-indicator-tft]
+extends = env:seeed-sensecap-indicator
+board_level = main
+upload_speed = 460800
+board_build.partitions = default_8MB.csv ; must be here for some reason, board.json is not enough !?
+
+build_flags =
+  ${env:seeed-sensecap-indicator.build_flags}
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
+  -D MESHTASTIC_EXCLUDE_BLUETOOTH=1
+  -D MESHTASTIC_EXCLUDE_SCREEN=1
+  -D MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR=1
+  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
+  -D MESHTASTIC_EXCLUDE_SERIAL=1
+  -D MESHTASTIC_EXCLUDE_SOCKETAPI=1
+  -D INPUTDRIVER_BUTTON_TYPE=38
+  -D HAS_TELEMETRY=0
+  -D CONFIG_DISABLE_HAL_LOCKS=1
+  -D MAX_NUM_NODES=250
+  -D HAS_SCREEN=0
+  -D HAS_TFT=1
+  -D DISPLAY_SET_RESOLUTION
+  -D USE_I2S_BUZZER
+  -D RAM_SIZE=3072
+	-D LV_LVGL_H_INCLUDE_SIMPLE
+	-D LV_CONF_INCLUDE_SIMPLE
+	-D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D LV_USE_SYSMON=0
+  -D LV_USE_PROFILER=0
+  -D LV_USE_PERF_MONITOR=0
+  -D LV_USE_MEM_MONITOR=0
+  -D LV_USE_LOG=0
+  -D USE_LOG_DEBUG
+  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
+  -D CUSTOM_TOUCH_DRIVER
+;  -D CALIBRATE_TOUCH=0
+  -D LGFX_DRIVER=LGFX_INDICATOR
+  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_INDICATOR.h\"
+  -D VIEW_320x240
+;	-D USE_DOUBLE_BUFFER
+  -D USE_PACKET_API
+	-I lib/device-ui/generated/ui_320x240
+
+build_src_filter =
+  ${env:seeed-sensecap-indicator.build_src_filter}
+  +<../lib/device-ui/generated/ui_320x240>
+  +<../lib/device-ui/resources>
+  +<../lib/device-ui/locale>
+  +<../lib/device-ui/source>
+
+lib_deps =
+  ${env:seeed-sensecap-indicator.lib_deps}
+  https://github.com/bitbank2/bb_captouch.git#8f2f06462ff597847921739376a299db93612417 ; alternative touch library supporting FT6x36

variants/seeed-sensecap-indicator/variant.h

@@ -71,7 +71,7 @@
 #define SX126X_DIO2_AS_RF_SWITCH
 
 #define TCXO_OPTIONAL // handle Indicator V1 and V2
-#define SX126X_DIO3_TCXO_VOLTAGE 1.8
+#define SX126X_DIO3_TCXO_VOLTAGE 2.4
 
 #define USE_VIRTUAL_KEYBOARD 1
 #define DISPLAY_CLOCK_FRAME 1

variants/t-deck/platformio.ini

@@ -4,7 +4,6 @@ extends = esp32s3_base
 board = t-deck
 board_check = true
 upload_protocol = esptool
-#upload_port = COM29
 
 build_flags = ${esp32s3_base.build_flags} 
   -DT_DECK 
@@ -17,3 +16,67 @@ lib_deps = ${esp32s3_base.lib_deps}
 	lovyan03/LovyanGFX@^1.2.0
   earlephilhower/ESP8266Audio@^1.9.9
   earlephilhower/ESP8266SAM@^1.0.1
+
+
+[env:t-deck-tft]
+extends = env:t-deck
+board_build.partitions = default_16MB.csv
+
+build_flags =
+  ${env:t-deck.build_flags}
+  -D CONFIG_DISABLE_HAL_LOCKS=1 ; "feels" to be a bit more stable without locks
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
+  -D MESHTASTIC_EXCLUDE_BLUETOOTH=1
+  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
+  -D MESHTASTIC_EXCLUDE_SERIAL=1
+  -D MESHTASTIC_EXCLUDE_SOCKETAPI=1
+  -D INPUTDRIVER_I2C_KBD_TYPE=0x55
+  -D INPUTDRIVER_ENCODER_TYPE=3
+  -D INPUTDRIVER_ENCODER_LEFT=1
+  -D INPUTDRIVER_ENCODER_RIGHT=2
+  -D INPUTDRIVER_ENCODER_UP=3
+  -D INPUTDRIVER_ENCODER_DOWN=15
+  -D INPUTDRIVER_ENCODER_BTN=0
+  -D INPUTDRIVER_BUTTON_TYPE=0
+  -D MAX_NUM_NODES=250
+  -D HAS_SCREEN=0
+  -D HAS_TFT=1
+  -D USE_I2S_BUZZER
+  -D RAM_SIZE=4096
+	-D LV_LVGL_H_INCLUDE_SIMPLE
+	-D LV_CONF_INCLUDE_SIMPLE
+	-D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D LV_USE_SYSMON=0
+  -D LV_USE_PROFILER=0
+  -D LV_USE_PERF_MONITOR=0
+  -D LV_USE_MEM_MONITOR=0
+  -D LV_USE_LOG=0
+  -D USE_LOG_DEBUG
+  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
+  -D RADIOLIB_DEBUG_BASIC=0
+  -D RADIOLIB_DEBUG_SPI=0
+  -D RADIOLIB_DEBUG_PROTOCOL=0
+  -D RADIOLIB_SPI_PARANOID=0
+;  -D CUSTOM_TOUCH_DRIVER
+  -D CALIBRATE_TOUCH=0
+  -D LGFX_DRIVER=LGFX_TDECK
+  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_T_DECK.h\"
+;  -D LVGL_DRIVER=LVGL_TDECK
+;  -D GFX_DRIVER_INC=\"graphics/LVGL/LVGL_T_DECK.h\"
+;  -D LV_USE_ST7789=1
+  -D VIEW_320x240
+;	-D USE_DOUBLE_BUFFER
+  -D USE_PACKET_API
+	-I lib/device-ui/generated/ui_320x240
+
+build_src_filter =
+  ${env:t-deck.build_src_filter}
+  +<../lib/device-ui/generated/ui_320x240>
+  +<../lib/device-ui/resources>
+  +<../lib/device-ui/locale>
+  +<../lib/device-ui/source>
+
+lib_deps =
+  ${env:t-deck.lib_deps}
+  bitbank2/bb_captouch@1.2.2 ; alternative touch library supporting GT911

variants/t-deck/variant.h

@@ -1,5 +1,10 @@
+
+#define TFT_CS 12
+#ifndef HAS_TFT // for TFT-UI the definitions are in device-ui
+#define BUTTON_PIN 0
+
 // ST7789 TFT LCD
-#define ST7789_CS 12
+#define ST7789_CS TFT_CS
 #define ST7789_RS 11  // DC
 #define ST7789_SDA 41 // MOSI
 #define ST7789_SCK 40
@@ -19,6 +24,7 @@
 #define SCREEN_ROTATE
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
+#endif
 
 #define HAS_TOUCHSCREEN 1
 #define SCREEN_TOUCH_INT 16
@@ -42,6 +48,7 @@
 #define SPI_MISO (38)
 #define SPI_CS (39)
 #define SDCARD_CS SPI_CS
+#define SD_SPI_FREQUENCY 75000000U
 
 #define BATTERY_PIN 4 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 // ratio of voltage divider = 2.0 (RD2=100k, RD3=100k)

variants/unphone/platformio.ini

@@ -1,18 +1,14 @@
 ; platformio.ini for unphone meshtastic
 
 [env:unphone]
-
 extends = esp32s3_base
-board = unphone9
+board = unphone
 upload_speed = 921600
 monitor_speed = 115200
 monitor_filters = esp32_exception_decoder
 
-build_unflags =
-  ${esp32s3_base.build_unflags}
-  -D ARDUINO_USB_MODE
-
-build_flags = ${esp32_base.build_flags}
+build_flags =
+  ${esp32s3_base.build_flags}
   -D UNPHONE
   -I variants/unphone
   -D ARDUINO_USB_MODE=0
@@ -22,8 +18,11 @@ build_flags = ${esp32_base.build_flags}
   -D UNPHONE_UI0=0
   -D UNPHONE_LORA=0
   -D UNPHONE_FACTORY_MODE=0
+  -D USE_SX127x
 
-build_src_filter = ${esp32_base.build_src_filter} +<../variants/unphone>
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/unphone>
 
 lib_deps = ${esp32s3_base.lib_deps}
   lovyan03/LovyanGFX@ 1.2.0
@@ -32,46 +31,44 @@ lib_deps = ${esp32s3_base.lib_deps}
 
 
 [env:unphone-tft]
-extends = esp32s3_base
+extends = env:unphone
 board_level = extra
-board = unphone
 board_build.partitions = default_8MB.csv
-monitor_speed = 115200
-monitor_filters = esp32_exception_decoder
-build_flags = ${esp32_base.build_flags}
-  -D UNPHONE
-  -D UNPHONE_ACCEL=0
-  -D UNPHONE_TOUCHS=0
-  -D UNPHONE_SDCARD=0
-  -D UNPHONE_UI0=0
-  -D UNPHONE_LORA=0
-  -D UNPHONE_FACTORY_MODE=0
+build_flags =
+  ${env:unphone.build_flags}
+  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
+  -D MESHTASTIC_EXCLUDE_BLUETOOTH=1
+  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
+  -D MESHTASTIC_EXCLUDE_SERIAL=1
+  -D MESHTASTIC_EXCLUDE_SOCKETAPI=1
+  -D INPUTDRIVER_BUTTON_TYPE=21
+  -D MAX_NUM_NODES=200
   -D MAX_THREADS=40
   -D HAS_SCREEN=0
   -D HAS_TFT=1
-  -D RAM_SIZE=512
+  -D DISPLAY_SET_RESOLUTION
+  -D RAM_SIZE=1024
 	-D LV_LVGL_H_INCLUDE_SIMPLE
 	-D LV_CONF_INCLUDE_SIMPLE
 	-D LV_COMP_CONF_INCLUDE_SIMPLE
   -D LV_BUILD_TEST=0
+  -D LV_USE_SYSMON=0
+  -D LV_USE_PROFILER=0
   -D LV_USE_PERF_MONITOR=0
   -D LV_USE_MEM_MONITOR=0
+  -D LV_USE_LOG=0
   -D USE_LOG_DEBUG
   -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
-;  -D CALIBRATE_TOUCH=0
   -D LGFX_DRIVER=LGFX_UNPHONE_V9
+  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_UNPHONE.h\"
   -D VIEW_320x240
-;	-D USE_DOUBLE_BUFFER
   -D USE_PACKET_API
 	-I lib/device-ui/generated/ui_320x240
-  -I variants/unphone
 
-build_src_filter = ${esp32_base.build_src_filter} +<../variants/unphone>
+build_src_filter =
+  ${env:unphone.build_src_filter}
   +<../lib/device-ui/generated/ui_320x240>
   +<../lib/device-ui/resources>
-  +<../lib/device-ui/source>
-
-lib_deps = ${esp32s3_base.lib_deps}
-  lovyan03/LovyanGFX@^1.2.0
-  https://gitlab.com/hamishcunningham/unphonelibrary#meshtastic@9.0.0
-  adafruit/Adafruit NeoPixel@1.12.0
+  +<../lib/device-ui/locale>
+  +<../lib/device-ui/source>

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
-minor = 5
-build = 22
+minor = 6
+build = 0