Set RAK boot lock voltage to 0V

Integration of upstrem PR #1338
Integration of upstrem PR #1297
2026-02-21 19:24:01 +01:00 · 2026-02-21 19:24:01 +01:00 · 2026-02-21 19:24:01 +01:00 · 2026-01-26 10:35:31 +01:00 · 2026-01-26 10:35:31 +01:00 · 2026-01-26 10:35:31 +01:00
55 changed files with 257 additions and 617 deletions
--- a/.github/workflows/pr-build-check.yml
+++ b/.github/workflows/pr-build-check.yml
@@ -1,43 +0,0 @@
-name: PR Build Check
-
-on:
-  pull_request:
-    branches: [main, dev]
-    paths:
-      - 'src/**'
-      - 'examples/**'
-      - 'variants/**'
-      - 'platformio.ini'
-      - '.github/workflows/pr-build-check.yml'
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        environment:
-          # ESP32-S3 (most common platform)
-          - Heltec_v3_companion_radio_ble
-          - Heltec_v3_repeater
-          - Heltec_v3_room_server
-          # nRF52
-          - RAK_4631_companion_radio_ble
-          - RAK_4631_repeater
-          - RAK_4631_room_server
-          # RP2040
-          - PicoW_repeater
-          # STM32
-          - wio-e5-mini_repeater
-          # ESP32-C6
-          - LilyGo_Tlora_C6_repeater_
-
-    steps:
-      - name: Clone Repo
-        uses: actions/checkout@v4
-
-      - name: Setup Build Environment
-        uses: ./.github/actions/setup-build-environment
-
-      - name: Build ${{ matrix.environment }}
-        run: pio run -e ${{ matrix.environment }}
--- a/boards/t_beams3_supreme.json
+++ b/boards/t_beams3_supreme.json
@@ -41,7 +41,7 @@
    "name": "LilyGo T-Beam supreme (8MB Flash 8MB PSRAM)",
    "upload": {
      "flash_size": "8MB",
-      "maximum_ram_size": 8388608,
+      "maximum_ram_size": 327680,
      "maximum_size": 8388608,
      "require_upload_port": true,
      "speed": 460800
--- a/examples/companion_radio/DataStore.cpp
+++ b/examples/companion_radio/DataStore.cpp
@@ -222,14 +222,12 @@ void DataStore::loadPrefsInt(const char *filename, NodePrefs& _prefs, double& no
    file.read((uint8_t *)&_prefs.rx_delay_base, sizeof(_prefs.rx_delay_base));             // 72
    file.read((uint8_t *)&_prefs.advert_loc_policy, sizeof(_prefs.advert_loc_policy));     // 76
    file.read((uint8_t *)&_prefs.multi_acks, sizeof(_prefs.multi_acks));                   // 77
-    file.read((uint8_t *)&_prefs.path_hash_mode, sizeof(_prefs.path_hash_mode));           // 78
-    file.read(pad, 1);                                                                     // 79
+    file.read(pad, 2);                                                                     // 78
    file.read((uint8_t *)&_prefs.ble_pin, sizeof(_prefs.ble_pin));                         // 80
    file.read((uint8_t *)&_prefs.buzzer_quiet, sizeof(_prefs.buzzer_quiet));               // 84
    file.read((uint8_t *)&_prefs.gps_enabled, sizeof(_prefs.gps_enabled));                 // 85
    file.read((uint8_t *)&_prefs.gps_interval, sizeof(_prefs.gps_interval));               // 86
    file.read((uint8_t *)&_prefs.autoadd_config, sizeof(_prefs.autoadd_config));           // 87
-    file.read((uint8_t *)&_prefs.autoadd_max_hops, sizeof(_prefs.autoadd_max_hops));       // 88

    file.close();
  }
@@ -259,14 +257,12 @@ void DataStore::savePrefs(const NodePrefs& _prefs, double node_lat, double node_
    file.write((uint8_t *)&_prefs.rx_delay_base, sizeof(_prefs.rx_delay_base));             // 72
    file.write((uint8_t *)&_prefs.advert_loc_policy, sizeof(_prefs.advert_loc_policy));     // 76
    file.write((uint8_t *)&_prefs.multi_acks, sizeof(_prefs.multi_acks));                   // 77
-    file.write((uint8_t *)&_prefs.path_hash_mode, sizeof(_prefs.path_hash_mode));           // 78
-    file.write(pad, 1);                                                                     // 79
+    file.write(pad, 2);                                                                     // 78
    file.write((uint8_t *)&_prefs.ble_pin, sizeof(_prefs.ble_pin));                         // 80
    file.write((uint8_t *)&_prefs.buzzer_quiet, sizeof(_prefs.buzzer_quiet));               // 84
    file.write((uint8_t *)&_prefs.gps_enabled, sizeof(_prefs.gps_enabled));                 // 85
    file.write((uint8_t *)&_prefs.gps_interval, sizeof(_prefs.gps_interval));               // 86
    file.write((uint8_t *)&_prefs.autoadd_config, sizeof(_prefs.autoadd_config));           // 87
-    file.write((uint8_t *)&_prefs.autoadd_max_hops, sizeof(_prefs.autoadd_max_hops));      // 88

    file.close();
  }
--- a/examples/companion_radio/MyMesh.cpp
+++ b/examples/companion_radio/MyMesh.cpp
@@ -57,7 +57,6 @@
 #define CMD_SET_AUTOADD_CONFIG        58
 #define CMD_GET_AUTOADD_CONFIG        59
 #define CMD_GET_ALLOWED_REPEAT_FREQ   60
-#define CMD_SET_PATH_HASH_MODE        61

 // Stats sub-types for CMD_GET_STATS
 #define STATS_TYPE_CORE               0
@@ -259,11 +258,11 @@ int MyMesh::calcRxDelay(float score, uint32_t air_time) const {
 }

 uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * 0.5f);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * 0.5f);
  return getRNG()->nextInt(0, 5*t + 1);
 }
 uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * 0.2f);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * 0.2f);
  return getRNG()->nextInt(0, 5*t + 1);
 }

@@ -318,10 +317,6 @@ bool MyMesh::shouldOverwriteWhenFull() const {
  return (_prefs.autoadd_config & AUTO_ADD_OVERWRITE_OLDEST) != 0;
 }

-uint8_t MyMesh::getAutoAddMaxHops() const {
-  return _prefs.autoadd_max_hops;
-}
-
 void MyMesh::onContactOverwrite(const uint8_t* pub_key) {
    _store->deleteBlobByKey(pub_key, PUB_KEY_SIZE); // delete from storage
  if (_serial->isConnected()) {
@@ -354,7 +349,7 @@ void MyMesh::onDiscoveredContact(ContactInfo &contact, bool is_new, uint8_t path
  }

  // add inbound-path to mem cache
-  if (path && mesh::Packet::isValidPathLen(path_len)) {  // check path is valid
+  if (path && path_len <= sizeof(AdvertPath::path)) {  // check path is valid
    AdvertPath* p = advert_paths;
    uint32_t oldest = 0xFFFFFFFF;
    for (int i = 0; i < ADVERT_PATH_TABLE_SIZE; i++) {   // check if already in table, otherwise evict oldest
@@ -371,7 +366,8 @@ void MyMesh::onDiscoveredContact(ContactInfo &contact, bool is_new, uint8_t path
    memcpy(p->pubkey_prefix, contact.id.pub_key, sizeof(p->pubkey_prefix));
    strcpy(p->name, contact.name);
    p->recv_timestamp = getRTCClock()->getCurrentTime();
-    p->path_len = mesh::Packet::copyPath(p->path, path, path_len);
+    p->path_len = path_len;
+    memcpy(p->path, path, p->path_len);
  }

  if (!is_new) dirty_contacts_expiry = futureMillis(LAZY_CONTACTS_WRITE_DELAY); // only schedule lazy write for contacts that are in contacts[]
@@ -477,23 +473,23 @@ bool MyMesh::allowPacketForward(const mesh::Packet* packet) {
 void MyMesh::sendFloodScoped(const ContactInfo& recipient, mesh::Packet* pkt, uint32_t delay_millis) {
  // TODO: dynamic send_scope, depending on recipient and current 'home' Region
  if (send_scope.isNull()) {
-    sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+    sendFlood(pkt, delay_millis);
  } else {
    uint16_t codes[2];
    codes[0] = send_scope.calcTransportCode(pkt);
    codes[1] = 0;  // REVISIT: set to 'home' Region, for sender/return region?
-    sendFlood(pkt, codes, delay_millis, _prefs.path_hash_mode + 1);
+    sendFlood(pkt, codes, delay_millis);
  }
 }
 void MyMesh::sendFloodScoped(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t delay_millis) {
  // TODO: have per-channel send_scope
  if (send_scope.isNull()) {
-    sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+    sendFlood(pkt, delay_millis);
  } else {
    uint16_t codes[2];
    codes[0] = send_scope.calcTransportCode(pkt);
    codes[1] = 0;  // REVISIT: set to 'home' Region, for sender/return region?
-    sendFlood(pkt, codes, delay_millis, _prefs.path_hash_mode + 1);
+    sendFlood(pkt, codes, delay_millis);
  }
 }

@@ -690,7 +686,7 @@ bool MyMesh::onContactPathRecv(ContactInfo& contact, uint8_t* in_path, uint8_t i
    if (tag == pending_discovery) {  // check for matching response tag)
      pending_discovery = 0;

-      if (!mesh::Packet::isValidPathLen(in_path_len) || !mesh::Packet::isValidPathLen(out_path_len)) {
+      if (in_path_len > MAX_PATH_SIZE || out_path_len > MAX_PATH_SIZE) {
        MESH_DEBUG_PRINTLN("onContactPathRecv, invalid path sizes: %d, %d", in_path_len, out_path_len);
      } else {
        int i = 0;
@@ -699,9 +695,11 @@ bool MyMesh::onContactPathRecv(ContactInfo& contact, uint8_t* in_path, uint8_t i
        memcpy(&out_frame[i], contact.id.pub_key, 6);
        i += 6; // pub_key_prefix
        out_frame[i++] = out_path_len;
-        i += mesh::Packet::writePath(&out_frame[i], out_path, out_path_len);
+        memcpy(&out_frame[i], out_path, out_path_len);
+        i += out_path_len;
        out_frame[i++] = in_path_len;
-        i += mesh::Packet::writePath(&out_frame[i], in_path, in_path_len);
+        memcpy(&out_frame[i], in_path, in_path_len);
+        i += in_path_len;
        // NOTE: telemetry data in 'extra' is discarded at present

        _serial->writeFrame(out_frame, i);
@@ -787,10 +785,9 @@ uint32_t MyMesh::calcFloodTimeoutMillisFor(uint32_t pkt_airtime_millis) const {
  return SEND_TIMEOUT_BASE_MILLIS + (FLOOD_SEND_TIMEOUT_FACTOR * pkt_airtime_millis);
 }
 uint32_t MyMesh::calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const {
-  uint8_t path_hash_count = path_len & 63;
  return SEND_TIMEOUT_BASE_MILLIS +
         ((pkt_airtime_millis * DIRECT_SEND_PERHOP_FACTOR + DIRECT_SEND_PERHOP_EXTRA_MILLIS) *
-          (path_hash_count + 1));
+          (path_len + 1));
 }

 void MyMesh::onSendTimeout() {}
@@ -941,7 +938,6 @@ void MyMesh::handleCmdFrame(size_t len) {
    StrHelper::strzcpy((char *)&out_frame[i], FIRMWARE_VERSION, 20);
    i += 20;
    out_frame[i++] = _prefs.client_repeat;   // v9+
-    out_frame[i++] = _prefs.path_hash_mode;  // v10+
    _serial->writeFrame(out_frame, i);
  } else if (cmd_frame[0] == CMD_APP_START &&
             len >= 8) { // sent when app establishes connection, respond with node ID
@@ -1119,8 +1115,7 @@ void MyMesh::handleCmdFrame(size_t len) {
    }
    if (pkt) {
      if (len >= 2 && cmd_frame[1] == 1) { // optional param (1 = flood, 0 = zero hop)
-        unsigned long delay_millis = 0;
-        sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+        sendFlood(pkt);
      } else {
        sendZeroHop(pkt);
      }
@@ -1132,7 +1127,7 @@ void MyMesh::handleCmdFrame(size_t len) {
    uint8_t *pub_key = &cmd_frame[1];
    ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
    if (recipient) {
-      recipient->out_path_len = OUT_PATH_UNKNOWN;
+      recipient->out_path_len = -1;
      // recipient->lastmod = ??   shouldn't be needed, app already has this version of contact
      dirty_contacts_expiry = futureMillis(LAZY_CONTACTS_WRITE_DELAY);
      writeOKFrame();
@@ -1317,14 +1312,6 @@ void MyMesh::handleCmdFrame(size_t len) {
    }
    savePrefs();
    writeOKFrame();
-  } else if (cmd_frame[0] == CMD_SET_PATH_HASH_MODE && cmd_frame[1] == 0 && len >= 3) {
-    if (cmd_frame[2] >= 3) {
-      writeErrFrame(ERR_CODE_ILLEGAL_ARG);
-    } else {
-      _prefs.path_hash_mode = cmd_frame[2];
-      savePrefs();
-      writeOKFrame();
-    }
  } else if (cmd_frame[0] == CMD_REBOOT && memcmp(&cmd_frame[1], "reboot", 6) == 0) {
    if (dirty_contacts_expiry) { // is there are pending dirty contacts write needed?
      saveContacts();
@@ -1462,7 +1449,7 @@ void MyMesh::handleCmdFrame(size_t len) {
      memset(&req_data[2], 0, 3);  // reserved
      getRNG()->random(&req_data[5], 4);   // random blob to help make packet-hash unique
      auto save = recipient->out_path_len;    // temporarily force sendRequest() to flood
-      recipient->out_path_len = OUT_PATH_UNKNOWN;
+      recipient->out_path_len = -1;
      int result = sendRequest(*recipient, req_data, sizeof(req_data), tag, est_timeout);
      recipient->out_path_len = save;
      if (result == MSG_SEND_FAILED) {
@@ -1699,12 +1686,11 @@ void MyMesh::handleCmdFrame(size_t len) {
      }
    }
    if (found) {
-      int i = 0;
-      out_frame[i++] = RESP_CODE_ADVERT_PATH;
-      memcpy(&out_frame[i], &found->recv_timestamp, 4); i += 4;
-      out_frame[i++] = found->path_len;
-      i += mesh::Packet::writePath(&out_frame[i], found->path, found->path_len);
-      _serial->writeFrame(out_frame, i);
+      out_frame[0] = RESP_CODE_ADVERT_PATH;
+      memcpy(&out_frame[1], &found->recv_timestamp, 4);
+      out_frame[5] = found->path_len;
+      memcpy(&out_frame[6], found->path, found->path_len);
+      _serial->writeFrame(out_frame, 6 + found->path_len);
    } else {
      writeErrFrame(ERR_CODE_NOT_FOUND);
    }
@@ -1789,16 +1775,12 @@ void MyMesh::handleCmdFrame(size_t len) {
    }
  } else if (cmd_frame[0] == CMD_SET_AUTOADD_CONFIG) {
    _prefs.autoadd_config = cmd_frame[1];
-    if (len >= 3) {
-      _prefs.autoadd_max_hops = min(cmd_frame[2], (uint8_t)64);
-    }
    savePrefs();
-    writeOKFrame();
+    writeOKFrame();  
  } else if (cmd_frame[0] == CMD_GET_AUTOADD_CONFIG) {
    int i = 0;
    out_frame[i++] = RESP_CODE_AUTOADD_CONFIG;
    out_frame[i++] = _prefs.autoadd_config;
-    out_frame[i++] = _prefs.autoadd_max_hops;
    _serial->writeFrame(out_frame, i);
  } else if (cmd_frame[0] == CMD_GET_ALLOWED_REPEAT_FREQ) {
    int i = 0;
--- a/examples/companion_radio/MyMesh.h
+++ b/examples/companion_radio/MyMesh.h
@@ -5,7 +5,7 @@
 #include "AbstractUITask.h"

 /*------------ Frame Protocol --------------*/
-#define FIRMWARE_VER_CODE 10
+#define FIRMWARE_VER_CODE 9

 #ifndef FIRMWARE_BUILD_DATE
 #define FIRMWARE_BUILD_DATE "15 Feb 2026"
@@ -119,7 +119,6 @@ protected:
  bool isAutoAddEnabled() const override;
  bool shouldAutoAddContactType(uint8_t type) const override;
  bool shouldOverwriteWhenFull() const override;
-  uint8_t getAutoAddMaxHops() const override;
  void onContactsFull() override;
  void onContactOverwrite(const uint8_t* pub_key) override;
  bool onContactPathRecv(ContactInfo& from, uint8_t* in_path, uint8_t in_path_len, uint8_t* out_path, uint8_t out_path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) override;
--- a/examples/companion_radio/NodePrefs.h
+++ b/examples/companion_radio/NodePrefs.h
@@ -29,6 +29,4 @@ struct NodePrefs {  // persisted to file
  uint32_t gps_interval;     // GPS read interval in seconds
  uint8_t autoadd_config;    // bitmask for auto-add contacts config
  uint8_t client_repeat;
-  uint8_t path_hash_mode;    // which path mode to use when sending
-  uint8_t autoadd_max_hops;  // 0 = no limit, 1 = direct (0 hops), N = up to N-1 hops (max 64)
 };
--- a/examples/simple_repeater/MyMesh.cpp
+++ b/examples/simple_repeater/MyMesh.cpp
@@ -129,7 +129,7 @@ uint8_t MyMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t* secr
  }

  if (is_flood) {
-    client->out_path_len = OUT_PATH_UNKNOWN;  // need to rediscover out_path
+    client->out_path_len = -1;  // need to rediscover out_path
  }

  uint32_t now = getRTCClock()->getCurrentTimeUnique();
@@ -147,12 +147,9 @@ uint8_t MyMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t* secr
 uint8_t MyMesh::handleAnonRegionsReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data) {
  if (anon_limiter.allow(rtc_clock.getCurrentTime())) {
    // request data has: {reply-path-len}{reply-path}
-    reply_path_len = *data & 63;
-    reply_path_hash_size = (*data >> 6) + 1;
-    data++;
-
-    memcpy(reply_path, data, ((uint8_t)reply_path_len) * reply_path_hash_size);
-    // data += (uint8_t)reply_path_len * reply_path_hash_size;
+    reply_path_len = *data++ & 0x3F;
+    memcpy(reply_path, data, reply_path_len);
+    // data += reply_path_len;

    memcpy(reply_data, &sender_timestamp, 4);   // prefix with sender_timestamp, like a tag
    uint32_t now = getRTCClock()->getCurrentTime();
@@ -166,12 +163,9 @@ uint8_t MyMesh::handleAnonRegionsReq(const mesh::Identity& sender, uint32_t send
 uint8_t MyMesh::handleAnonOwnerReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data) {
  if (anon_limiter.allow(rtc_clock.getCurrentTime())) {
    // request data has: {reply-path-len}{reply-path}
-    reply_path_len = *data & 63;
-    reply_path_hash_size = (*data >> 6) + 1;
-    data++;
-
-    memcpy(reply_path, data, ((uint8_t)reply_path_len) * reply_path_hash_size);
-    // data += (uint8_t)reply_path_len * reply_path_hash_size;
+    reply_path_len = *data++ & 0x3F;
+    memcpy(reply_path, data, reply_path_len);
+    // data += reply_path_len;

    memcpy(reply_data, &sender_timestamp, 4);   // prefix with sender_timestamp, like a tag
    uint32_t now = getRTCClock()->getCurrentTime();
@@ -186,12 +180,9 @@ uint8_t MyMesh::handleAnonOwnerReq(const mesh::Identity& sender, uint32_t sender
 uint8_t MyMesh::handleAnonClockReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data) {
  if (anon_limiter.allow(rtc_clock.getCurrentTime())) {
    // request data has: {reply-path-len}{reply-path}
-    reply_path_len = *data & 63;
-    reply_path_hash_size = (*data >> 6) + 1;
-    data++;
-
-    memcpy(reply_path, data, ((uint8_t)reply_path_len) * reply_path_hash_size);
-    // data += (uint8_t)reply_path_len * reply_path_hash_size;
+    reply_path_len = *data++ & 0x3F;
+    memcpy(reply_path, data, reply_path_len);
+    // data += reply_path_len;

    memcpy(reply_data, &sender_timestamp, 4);   // prefix with sender_timestamp, like a tag
    uint32_t now = getRTCClock()->getCurrentTime();
@@ -398,7 +389,7 @@ File MyMesh::openAppend(const char *fname) {

 bool MyMesh::allowPacketForward(const mesh::Packet *packet) {
  if (_prefs.disable_fwd) return false;
-  if (packet->isRouteFlood() && packet->getPathHashCount() >= _prefs.flood_max) return false;
+  if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false;
  if (packet->isRouteFlood() && recv_pkt_region == NULL) {
    MESH_DEBUG_PRINTLN("allowPacketForward: unknown transport code, or wildcard not allowed for FLOOD packet");
    return false;
@@ -501,11 +492,11 @@ int MyMesh::calcRxDelay(float score, uint32_t air_time) const {
 }

 uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.tx_delay_factor);
  return getRNG()->nextInt(0, 5*t + 1);
 }
 uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
  return getRNG()->nextInt(0, 5*t + 1);
 }

@@ -514,10 +505,7 @@ bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {
  if (pkt->getRouteType() == ROUTE_TYPE_TRANSPORT_FLOOD) {
    recv_pkt_region = region_map.findMatch(pkt, REGION_DENY_FLOOD);
  } else if (pkt->getRouteType() == ROUTE_TYPE_FLOOD) {
-      if ((pkt->getPayloadType() == PAYLOAD_TYPE_GRP_TXT ||
-           pkt->getPayloadType() == PAYLOAD_TYPE_GRP_DATA ||
-           pkt->getPayloadType() == PAYLOAD_TYPE_ADVERT) &&
-          region_map.getWildcard().flags & REGION_DENY_FLOOD) {
+    if (region_map.getWildcard().flags & REGION_DENY_FLOOD) {
      recv_pkt_region = NULL;
    } else {
      recv_pkt_region =  &region_map.getWildcard();
@@ -558,14 +546,13 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
      // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
      mesh::Packet* path = createPathReturn(sender, secret, packet->path, packet->path_len,
                                            PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
-      if (path) sendFlood(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+      if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
    } else if (reply_path_len < 0) {
      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len);
-      if (reply) sendFlood(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+      if (reply) sendFlood(reply, SERVER_RESPONSE_DELAY);
    } else {
      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len);
-      uint8_t path_len = ((reply_path_hash_size - 1) << 6) | (reply_path_len & 63);
-      if (reply) sendDirect(reply, reply_path,  path_len, SERVER_RESPONSE_DELAY);
+      if (reply) sendDirect(reply, reply_path, reply_path_len, SERVER_RESPONSE_DELAY);
    }
  }
 }
@@ -634,15 +621,15 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
        // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
        mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len,
                                              PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
-        if (path) sendFlood(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+        if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
      } else {
        mesh::Packet *reply =
            createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len);
        if (reply) {
-          if (client->out_path_len != OUT_PATH_UNKNOWN) { // we have an out_path, so send DIRECT
+          if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
            sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
          } else {
-            sendFlood(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+            sendFlood(reply, SERVER_RESPONSE_DELAY);
          }
        }
      }
@@ -672,8 +659,8 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,

        mesh::Packet *ack = createAck(ack_hash);
        if (ack) {
-          if (client->out_path_len == OUT_PATH_UNKNOWN) {
-            sendFlood(ack, TXT_ACK_DELAY, packet->getPathHashSize());
+          if (client->out_path_len < 0) {
+            sendFlood(ack, TXT_ACK_DELAY);
          } else {
            sendDirect(ack, client->out_path, client->out_path_len, TXT_ACK_DELAY);
          }
@@ -700,8 +687,8 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,

        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len);
        if (reply) {
-          if (client->out_path_len == OUT_PATH_UNKNOWN) {
-            sendFlood(reply, CLI_REPLY_DELAY_MILLIS, packet->getPathHashSize());
+          if (client->out_path_len < 0) {
+            sendFlood(reply, CLI_REPLY_DELAY_MILLIS);
          } else {
            sendDirect(reply, client->out_path, client->out_path_len, CLI_REPLY_DELAY_MILLIS);
          }
@@ -722,8 +709,7 @@ bool MyMesh::onPeerPathRecv(mesh::Packet *packet, int sender_idx, const uint8_t
    MESH_DEBUG_PRINTLN("PATH to client, path_len=%d", (uint32_t)path_len);
    auto client = acl.getClientByIdx(i);

-    // store a copy of path, for sendDirect()
-    client->out_path_len = mesh::Packet::copyPath(client->out_path, path, path_len);
+    memcpy(client->out_path, path, client->out_path_len = path_len); // store a copy of path, for sendDirect()
    client->last_activity = getRTCClock()->getCurrentTime();
  } else {
    MESH_DEBUG_PRINTLN("onPeerPathRecv: invalid peer idx: %d", i);
@@ -849,7 +835,7 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
  _prefs.cr = LORA_CR;
  _prefs.tx_power_dbm = LORA_TX_POWER;
  _prefs.advert_interval = 1;        // default to 2 minutes for NEW installs
-  _prefs.flood_advert_interval = 0; // 12 hours
+  _prefs.flood_advert_interval = 12; // 12 hours
  _prefs.flood_advert_base = 0.308f;
  _prefs.flood_max = 64;
  _prefs.interference_threshold = 0; // disabled
@@ -929,7 +915,7 @@ void MyMesh::sendSelfAdvertisement(int delay_millis, bool flood) {
  mesh::Packet *pkt = createSelfAdvert();
  if (pkt) {
    if (flood) {
-      sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+      sendFlood(pkt, delay_millis);
    } else {
      sendZeroHop(pkt, delay_millis);
    }
--- a/examples/simple_repeater/MyMesh.h
+++ b/examples/simple_repeater/MyMesh.h
@@ -92,7 +92,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
  uint8_t reply_data[MAX_PACKET_PAYLOAD];
  uint8_t reply_path[MAX_PATH_SIZE];
  int8_t  reply_path_len;
-  uint8_t reply_path_hash_size;
  TransportKeyStore key_store;
  RegionMap region_map, temp_map;
  RegionEntry* load_stack[8];
--- a/examples/simple_room_server/MyMesh.cpp
+++ b/examples/simple_room_server/MyMesh.cpp
@@ -73,15 +73,13 @@ void MyMesh::pushPostToClient(ClientInfo *client, PostInfo &post) {

  auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, client->shared_secret, reply_data, len);
  if (reply) {
-    if (client->out_path_len == OUT_PATH_UNKNOWN) {
-      unsigned long delay_millis = 0;
-      sendFlood(reply, delay_millis, _prefs.path_hash_mode + 1);
+    if (client->out_path_len < 0) {
+      sendFlood(reply);
      client->extra.room.ack_timeout = futureMillis(PUSH_ACK_TIMEOUT_FLOOD);
    } else {
      sendDirect(reply, client->out_path, client->out_path_len);
-
-      uint8_t path_hash_count = client->out_path_len & 63;
-      client->extra.room.ack_timeout = futureMillis(PUSH_TIMEOUT_BASE + PUSH_ACK_TIMEOUT_FACTOR * (path_hash_count + 1));
+      client->extra.room.ack_timeout =
+          futureMillis(PUSH_TIMEOUT_BASE + PUSH_ACK_TIMEOUT_FACTOR * (client->out_path_len + 1));
    }
    _num_post_pushes++; // stats
  } else {
@@ -266,17 +264,17 @@ const char *MyMesh::getLogDateTime() {
 }

 uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.tx_delay_factor);
  return getRNG()->nextInt(0, 5*t + 1);
 }
 uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
  return getRNG()->nextInt(0, 5*t + 1);
 }

 bool MyMesh::allowPacketForward(const mesh::Packet *packet) {
  if (_prefs.disable_fwd) return false;
-  if (packet->isRouteFlood() && packet->getPathHashCount() >= _prefs.flood_max) return false;
+  if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false;

  // Limit flood advert paket forwarding using a probabilistic reduction defined by P(h) = 0.308^(hops-1)
  // https://github.com/meshcore-dev/MeshCore/issues/1223
@@ -344,7 +342,7 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
    }

    if (packet->isRouteFlood()) {
-      client->out_path_len = OUT_PATH_UNKNOWN;  // need to rediscover out_path
+      client->out_path_len = -1;  // need to rediscover out_path
    }

    uint32_t now = getRTCClock()->getCurrentTimeUnique();
@@ -364,14 +362,14 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
      // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
      mesh::Packet *path = createPathReturn(sender, client->shared_secret, packet->path, packet->path_len,
                                            PAYLOAD_TYPE_RESPONSE, reply_data, 13);
-      if (path) sendFlood(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+      if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
    } else {
      mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->shared_secret, reply_data, 13);
      if (reply) {
-        if (client->out_path_len != OUT_PATH_UNKNOWN) { // we have an out_path, so send DIRECT
+        if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
          sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
        } else {
-          sendFlood(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+          sendFlood(reply, SERVER_RESPONSE_DELAY);
        }
      }
    }
@@ -459,9 +457,9 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,

      uint32_t delay_millis;
      if (send_ack) {
-        if (client->out_path_len == OUT_PATH_UNKNOWN) {
+        if (client->out_path_len < 0) {
          mesh::Packet *ack = createAck(ack_hash);
-          if (ack) sendFlood(ack, TXT_ACK_DELAY, packet->getPathHashSize());
+          if (ack) sendFlood(ack, TXT_ACK_DELAY);
          delay_millis = TXT_ACK_DELAY + REPLY_DELAY_MILLIS;
        } else {
          uint32_t d = TXT_ACK_DELAY;
@@ -493,8 +491,8 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,

        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len);
        if (reply) {
-          if (client->out_path_len == OUT_PATH_UNKNOWN) {
-            sendFlood(reply, delay_millis + SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+          if (client->out_path_len < 0) {
+            sendFlood(reply, delay_millis + SERVER_RESPONSE_DELAY);
          } else {
            sendDirect(reply, client->out_path, client->out_path_len, delay_millis + SERVER_RESPONSE_DELAY);
          }
@@ -532,7 +530,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
        // if client sends too quickly, evict()

        // RULE: only send keep_alive response DIRECT!
-        if (client->out_path_len != OUT_PATH_UNKNOWN) {
+        if (client->out_path_len >= 0) {
          uint32_t ack_hash; // calc ACK to prove to sender that we got request
          mesh::Utils::sha256((uint8_t *)&ack_hash, 4, data, 9, client->id.pub_key, PUB_KEY_SIZE);

@@ -549,14 +547,14 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
            // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
            mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len,
                                                  PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
-            if (path) sendFlood(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+            if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
          } else {
            mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len);
            if (reply) {
-              if (client->out_path_len != OUT_PATH_UNKNOWN) { // we have an out_path, so send DIRECT
+              if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
                sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
              } else {
-                sendFlood(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+                sendFlood(reply, SERVER_RESPONSE_DELAY);
              }
            }
          }
@@ -574,7 +572,7 @@ bool MyMesh::onPeerPathRecv(mesh::Packet *packet, int sender_idx, const uint8_t
  if (i >= 0 && i < acl.getNumClients()) { // get from our known_clients table (sender SHOULD already be known in this context)
    MESH_DEBUG_PRINTLN("PATH to client, path_len=%d", (uint32_t)path_len);
    auto client = acl.getClientByIdx(i);
-    client->out_path_len = mesh::Packet::copyPath(client->out_path, path, path_len); // store a copy of path, for sendDirect()
+    memcpy(client->out_path, path, client->out_path_len = path_len); // store a copy of path, for sendDirect()
    client->last_activity = getRTCClock()->getCurrentTime();
  } else {
    MESH_DEBUG_PRINTLN("onPeerPathRecv: invalid peer idx: %d", i);
@@ -623,7 +621,7 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
  _prefs.tx_power_dbm = LORA_TX_POWER;
  _prefs.disable_fwd = 1;
  _prefs.advert_interval = 1;        // default to 2 minutes for NEW installs
-  _prefs.flood_advert_interval = 0; // 12 hours
+  _prefs.flood_advert_interval = 12; // 12 hours
  _prefs.flood_advert_base = 0.308f;
  _prefs.flood_max = 64;
  _prefs.interference_threshold = 0; // disabled
@@ -691,7 +689,7 @@ void MyMesh::sendSelfAdvertisement(int delay_millis, bool flood) {
  mesh::Packet *pkt = createSelfAdvert();
  if (pkt) {
    if (flood) {
-      sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+      sendFlood(pkt, delay_millis);
    } else {
      sendZeroHop(pkt, delay_millis);
    }
--- a/examples/simple_secure_chat/main.cpp
+++ b/examples/simple_secure_chat/main.cpp
@@ -213,7 +213,7 @@ protected:
  }

  void onContactPathUpdated(const ContactInfo& contact) override {
-    Serial.printf("PATH to: %s, path_len=%d\n", contact.name, (uint32_t) contact.out_path_len);
+    Serial.printf("PATH to: %s, path_len=%d\n", contact.name, (int32_t) contact.out_path_len);
    saveContacts();
  }

@@ -266,9 +266,8 @@ protected:
    return SEND_TIMEOUT_BASE_MILLIS + (FLOOD_SEND_TIMEOUT_FACTOR * pkt_airtime_millis);
  }
  uint32_t calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const override {
-    uint8_t path_hash_count = path_len & 63;
    return SEND_TIMEOUT_BASE_MILLIS + 
-         ( (pkt_airtime_millis*DIRECT_SEND_PERHOP_FACTOR + DIRECT_SEND_PERHOP_EXTRA_MILLIS) * (path_hash_count + 1));
+         ( (pkt_airtime_millis*DIRECT_SEND_PERHOP_FACTOR + DIRECT_SEND_PERHOP_EXTRA_MILLIS) * (path_len + 1));
  }

  void onSendTimeout() override {
--- a/examples/simple_sensor/SensorMesh.cpp
+++ b/examples/simple_sensor/SensorMesh.cpp
@@ -258,11 +258,10 @@ void SensorMesh::sendAlert(const ClientInfo* c, Trigger* t) {

  auto pkt = createDatagram(PAYLOAD_TYPE_TXT_MSG, c->id, c->shared_secret, data, 5 + text_len);
  if (pkt) {
-    if (c->out_path_len != OUT_PATH_UNKNOWN) {  // we have an out_path, so send DIRECT
+    if (c->out_path_len >= 0) {  // we have an out_path, so send DIRECT
      sendDirect(pkt, c->out_path, c->out_path_len);
    } else {
-      unsigned long delay_millis = 0;
-      sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+      sendFlood(pkt);
    }
  }
  t->send_expiry = futureMillis(ALERT_ACK_EXPIRY_MILLIS);
@@ -303,7 +302,7 @@ float SensorMesh::getAirtimeBudgetFactor() const {

 bool SensorMesh::allowPacketForward(const mesh::Packet* packet) {
  if (_prefs.disable_fwd) return false;
-  if (packet->isRouteFlood() && packet->getPathHashCount() >= _prefs.flood_max) return false;
+  if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false;
  return true;
 }

@@ -313,11 +312,11 @@ int SensorMesh::calcRxDelay(float score, uint32_t air_time) const {
 }

 uint32_t SensorMesh::getRetransmitDelay(const mesh::Packet* packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.tx_delay_factor);
  return getRNG()->nextInt(0, 6)*t;
 }
 uint32_t SensorMesh::getDirectRetransmitDelay(const mesh::Packet* packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
+  uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
  return getRNG()->nextInt(0, 6)*t;
 }
 int SensorMesh::getInterferenceThreshold() const {
@@ -361,7 +360,7 @@ uint8_t SensorMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t*
  }

  if (is_flood) {
-    client->out_path_len = OUT_PATH_UNKNOWN;  // need to rediscover out_path
+    client->out_path_len = -1;  // need to rediscover out_path
  }

  uint32_t now = getRTCClock()->getCurrentTimeUnique();
@@ -469,10 +468,10 @@ void SensorMesh::onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, con
      // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
      mesh::Packet* path = createPathReturn(sender, secret, packet->path, packet->path_len,
                                            PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
-      if (path) sendFlood(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+      if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
    } else {
      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len);
-      if (reply) sendFlood(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+      if (reply) sendFlood(reply, SERVER_RESPONSE_DELAY);
    }
  }
 }
@@ -497,10 +496,10 @@ void SensorMesh::getPeerSharedSecret(uint8_t* dest_secret, int peer_idx) {
  }
 }

-void SensorMesh::sendAckTo(const ClientInfo& dest, uint32_t ack_hash, uint8_t path_hash_size) {
-  if (dest.out_path_len == OUT_PATH_UNKNOWN) {
+void SensorMesh::sendAckTo(const ClientInfo& dest, uint32_t ack_hash) {
+  if (dest.out_path_len < 0) {
    mesh::Packet* ack = createAck(ack_hash);
-    if (ack) sendFlood(ack, TXT_ACK_DELAY, path_hash_size);
+    if (ack) sendFlood(ack, TXT_ACK_DELAY);
  } else {
    uint32_t d = TXT_ACK_DELAY;
    if (getExtraAckTransmitCount() > 0) {
@@ -538,14 +537,14 @@ void SensorMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_i
        // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
        mesh::Packet* path = createPathReturn(from->id, secret, packet->path, packet->path_len,
                                              PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
-        if (path) sendFlood(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+        if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
      } else {
        mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, from->id, secret, reply_data, reply_len);
        if (reply) {
-          if (from->out_path_len != OUT_PATH_UNKNOWN) {  // we have an out_path, so send DIRECT
+          if (from->out_path_len >= 0) {  // we have an out_path, so send DIRECT
            sendDirect(reply, from->out_path, from->out_path_len, SERVER_RESPONSE_DELAY);
          } else {
-            sendFlood(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
+            sendFlood(reply, SERVER_RESPONSE_DELAY);
          }
        }
      }
@@ -568,9 +567,9 @@ void SensorMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_i
            // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the ACK
            mesh::Packet* path = createPathReturn(from->id, secret, packet->path, packet->path_len,
                                                  PAYLOAD_TYPE_ACK, (uint8_t *) &ack_hash, 4);
-            if (path) sendFlood(path, TXT_ACK_DELAY, packet->getPathHashSize());
+            if (path) sendFlood(path, TXT_ACK_DELAY);
          } else {
-            sendAckTo(*from, ack_hash, packet->getPathHashSize());
+            sendAckTo(*from, ack_hash);
          }
        }
      } else if (flags == TXT_TYPE_CLI_DATA) {  
@@ -597,8 +596,8 @@ void SensorMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_i

          auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, from->id, secret, temp, 5 + text_len);
          if (reply) {
-            if (from->out_path_len == OUT_PATH_UNKNOWN) {
-              sendFlood(reply, CLI_REPLY_DELAY_MILLIS, packet->getPathHashSize());
+            if (from->out_path_len < 0) {
+              sendFlood(reply, CLI_REPLY_DELAY_MILLIS);
            } else {
              sendDirect(reply, from->out_path, from->out_path_len, CLI_REPLY_DELAY_MILLIS);
            }
@@ -667,7 +666,7 @@ bool SensorMesh::onPeerPathRecv(mesh::Packet* packet, int sender_idx, const uint
  MESH_DEBUG_PRINTLN("PATH to contact, path_len=%d", (uint32_t) path_len);
  // NOTE: for this impl, we just replace the current 'out_path' regardless, whenever sender sends us a new out_path.
  // FUTURE: could store multiple out_paths per contact, and try to find which is the 'best'(?)
-  from->out_path_len = mesh::Packet::copyPath(from->out_path, path, path_len);  // store a copy of path, for sendDirect()
+  memcpy(from->out_path, path, from->out_path_len = path_len);  // store a copy of path, for sendDirect()
  from->last_activity = getRTCClock()->getCurrentTime();

  // REVISIT: maybe make ALL out_paths non-persisted to minimise flash writes??
@@ -792,7 +791,7 @@ void SensorMesh::sendSelfAdvertisement(int delay_millis, bool flood) {
  mesh::Packet* pkt = createSelfAdvert();
  if (pkt) {
    if (flood) {
-      sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+      sendFlood(pkt, delay_millis);
    } else {
      sendZeroHop(pkt, delay_millis);
    }
@@ -869,8 +868,7 @@ void SensorMesh::loop() {

  if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
    mesh::Packet* pkt = createSelfAdvert();
-    unsigned long delay_millis = 0;
-    if (pkt) sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
+    if (pkt) sendFlood(pkt);

    updateFloodAdvertTimer();   // schedule next flood advert
    updateAdvertTimer();   // also schedule local advert (so they don't overlap)
--- a/examples/simple_sensor/SensorMesh.h
+++ b/examples/simple_sensor/SensorMesh.h
@@ -128,7 +128,7 @@ protected:
  void onControlDataRecv(mesh::Packet* packet) override;
  void onAckRecv(mesh::Packet* packet, uint32_t ack_crc) override;
  virtual bool handleIncomingMsg(ClientInfo& from, uint32_t timestamp, uint8_t* data, uint8_t flags, size_t len);
-  void sendAckTo(const ClientInfo& dest, uint32_t ack_hash, uint8_t path_hash_size=1);
+  void sendAckTo(const ClientInfo& dest, uint32_t ack_hash);
 private:
  FILESYSTEM* _fs;
  unsigned long next_local_advert, next_flood_advert;
--- a/platformio.ini
+++ b/platformio.ini
@@ -24,9 +24,9 @@ lib_deps =
  melopero/Melopero RV3028 @ ^1.1.0
  electroniccats/CayenneLPP @ 1.6.1
 build_flags = -w -DNDEBUG -DRADIOLIB_STATIC_ONLY=1 -DRADIOLIB_GODMODE=1
-  -D LORA_FREQ=869.618
-  -D LORA_BW=62.5
-  -D LORA_SF=8
+  -D LORA_FREQ=869.525
+  -D LORA_BW=250
+  -D LORA_SF=11
  -D ENABLE_ADVERT_ON_BOOT=1
  -D ENABLE_PRIVATE_KEY_IMPORT=1   ; NOTE: comment these out for more secure firmware
  -D ENABLE_PRIVATE_KEY_EXPORT=1
--- a/src/Dispatcher.cpp
+++ b/src/Dispatcher.cpp
@@ -105,7 +105,7 @@ void Dispatcher::loop() {
      }

      _radio->onSendFinished();
-      logTx(outbound, 2 + outbound->getPathByteLen() + outbound->payload_len);
+      logTx(outbound, 2 + outbound->path_len + outbound->payload_len);
      if (outbound->isRouteFlood()) {
        n_sent_flood++;
      } else {
@@ -117,7 +117,7 @@ void Dispatcher::loop() {
      MESH_DEBUG_PRINTLN("%s Dispatcher::loop(): WARNING: outbound packed send timed out!", getLogDateTime());

      _radio->onSendFinished();
-      logTxFail(outbound, 2 + outbound->getPathByteLen() + outbound->payload_len);
+      logTxFail(outbound, 2 + outbound->path_len + outbound->payload_len);

      releasePacket(outbound);  // return to pool
      outbound = NULL;
@@ -145,48 +145,6 @@ void Dispatcher::loop() {
  checkSend();
 }

-bool Dispatcher::tryParsePacket(Packet* pkt, const uint8_t* raw, int len) {
-  int i = 0;
-
-  pkt->header = raw[i++];
-  if (pkt->getPayloadVer() > PAYLOAD_VER_1) {
-    MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): unsupported packet version", getLogDateTime());
-    return false;
-  }
-
-  if (pkt->hasTransportCodes()) {
-    memcpy(&pkt->transport_codes[0], &raw[i], 2); i += 2;
-    memcpy(&pkt->transport_codes[1], &raw[i], 2); i += 2;
-  } else {
-    pkt->transport_codes[0] = pkt->transport_codes[1] = 0;
-  }
-
-  pkt->path_len = raw[i++];
-  uint8_t path_mode = pkt->path_len >> 6;  // upper 2 bits (legacy firmware: 00)
-  if (path_mode == 3) {   // Reserved for future
-    MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): unsupported path mode: 3", getLogDateTime());
-    return false;
-  }
-
-  uint8_t path_byte_len = (pkt->path_len & 63) * pkt->getPathHashSize();
-  if (path_byte_len > MAX_PATH_SIZE || i + path_byte_len > len) {
-    MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): partial or corrupt packet received, len=%d", getLogDateTime(), len);
-    return false;
-  }
-
-  memcpy(pkt->path, &raw[i], path_byte_len); i += path_byte_len;
-
-  pkt->payload_len = len - i;  // payload is remainder
-  if (pkt->payload_len > sizeof(pkt->payload)) {
-    MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): packet payload too big, payload_len=%d", getLogDateTime(), (uint32_t)pkt->payload_len);
-    return false;
-  }
-
-  memcpy(pkt->payload, &raw[i], pkt->payload_len);
-
-  return true;  // success
-}
-
 void Dispatcher::checkRecv() {
  Packet* pkt;
  float score;
@@ -201,14 +159,45 @@ void Dispatcher::checkRecv() {
      if (pkt == NULL) {
        MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): WARNING: received data, no unused packets available!", getLogDateTime());
      } else {
-        if (tryParsePacket(pkt, raw, len)) {
-          pkt->_snr = _radio->getLastSNR() * 4.0f;
-          score = _radio->packetScore(_radio->getLastSNR(), len);
-          air_time = _radio->getEstAirtimeFor(len);
-          rx_air_time += air_time;
+        int i = 0;
+#ifdef NODE_ID
+        uint8_t sender_id = raw[i++];
+        if (sender_id == NODE_ID - 1 || sender_id == NODE_ID + 1) {  // simulate that NODE_ID can only hear NODE_ID-1 or NODE_ID+1, eg. 3 can't hear 1
        } else {
+          _mgr->free(pkt);  // put back into pool
+          return;
+        }
+#endif
+
+        pkt->header = raw[i++];
+        if (pkt->hasTransportCodes()) {
+          memcpy(&pkt->transport_codes[0], &raw[i], 2); i += 2;
+          memcpy(&pkt->transport_codes[1], &raw[i], 2); i += 2;
+        } else {
+          pkt->transport_codes[0] = pkt->transport_codes[1] = 0;
+        }
+        pkt->path_len = raw[i++];
+
+        if (pkt->path_len > MAX_PATH_SIZE || i + pkt->path_len > len) {
+          MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): partial or corrupt packet received, len=%d", getLogDateTime(), len);
          _mgr->free(pkt);  // put back into pool
          pkt = NULL;
+        } else {
+          memcpy(pkt->path, &raw[i], pkt->path_len); i += pkt->path_len;
+
+          pkt->payload_len = len - i;  // payload is remainder
+          if (pkt->payload_len > sizeof(pkt->payload)) {
+            MESH_DEBUG_PRINTLN("%s Dispatcher::checkRecv(): packet payload too big, payload_len=%d", getLogDateTime(), (uint32_t)pkt->payload_len);
+            _mgr->free(pkt);  // put back into pool
+            pkt = NULL;  
+          } else {
+            memcpy(pkt->payload, &raw[i], pkt->payload_len);
+
+            pkt->_snr = _radio->getLastSNR() * 4.0f;
+            score = _radio->packetScore(_radio->getLastSNR(), len);
+            air_time = _radio->getEstAirtimeFor(len);
+            rx_air_time += air_time;
+          }
        }
      }
    } else {
@@ -308,13 +297,16 @@ void Dispatcher::checkSend() {
    int len = 0;
    uint8_t raw[MAX_TRANS_UNIT];

+#ifdef NODE_ID
+    raw[len++] = NODE_ID;
+#endif
    raw[len++] = outbound->header;
    if (outbound->hasTransportCodes()) {
      memcpy(&raw[len], &outbound->transport_codes[0], 2); len += 2;
      memcpy(&raw[len], &outbound->transport_codes[1], 2); len += 2;
    }
    raw[len++] = outbound->path_len;
-    len += Packet::writePath(&raw[len], outbound->path, outbound->path_len);
+    memcpy(&raw[len], outbound->path, outbound->path_len); len += outbound->path_len;

    if (len + outbound->payload_len > MAX_TRANS_UNIT) {
      MESH_DEBUG_PRINTLN("%s Dispatcher::checkSend(): FATAL: Invalid packet queued... too long, len=%d", getLogDateTime(), len + outbound->payload_len);
@@ -368,7 +360,7 @@ void Dispatcher::releasePacket(Packet* packet) {
 }

 void Dispatcher::sendPacket(Packet* packet, uint8_t priority, uint32_t delay_millis) {
-  if (!Packet::isValidPathLen(packet->path_len) || packet->payload_len > MAX_PACKET_PAYLOAD) {
+  if (packet->path_len > MAX_PATH_SIZE || packet->payload_len > MAX_PACKET_PAYLOAD) {
    MESH_DEBUG_PRINTLN("%s Dispatcher::sendPacket(): ERROR: invalid packet... path_len=%d, payload_len=%d", getLogDateTime(), (uint32_t) packet->path_len, (uint32_t) packet->payload_len);
    _mgr->free(packet);
  } else {
--- a/src/Dispatcher.h
+++ b/src/Dispatcher.h
@@ -193,7 +193,6 @@ public:
  unsigned long futureMillis(int millis_from_now) const;

 private:
-  bool tryParsePacket(Packet* pkt, const uint8_t* raw, int len);
  void checkRecv();
  void checkSend();
 };
--- a/src/Identity.h
+++ b/src/Identity.h
@@ -20,10 +20,6 @@ public:
    memcpy(dest, pub_key, PATH_HASH_SIZE);    // hash is just prefix of pub_key
    return PATH_HASH_SIZE;
  }
-  int copyHashTo(uint8_t* dest, uint8_t len) const { 
-    memcpy(dest, pub_key, len);    // hash is just prefix of pub_key
-    return len;
-  }
  bool isHashMatch(const uint8_t* hash) const {
    return memcmp(hash, pub_key, PATH_HASH_SIZE) == 0;
  }
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -39,6 +39,11 @@ int Mesh::searchChannelsByHash(const uint8_t* hash, GroupChannel channels[], int
 }

 DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
+  if (pkt->getPayloadVer() > PAYLOAD_VER_1) {  // not supported in this firmware version
+    MESH_DEBUG_PRINTLN("%s Mesh::onRecvPacket(): unsupported packet version", getLogDateTime());
+    return ACTION_RELEASE;
+  }
+
  if (pkt->isRouteDirect() && pkt->getPayloadType() == PAYLOAD_TYPE_TRACE) {
    if (pkt->path_len < MAX_PATH_SIZE) {
      uint8_t i = 0;
@@ -65,14 +70,14 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
  }

  if (pkt->isRouteDirect() && pkt->getPayloadType() == PAYLOAD_TYPE_CONTROL && (pkt->payload[0] & 0x80) != 0) {
-    if (pkt->getPathHashCount() == 0) {
+    if (pkt->path_len == 0) {
      onControlDataRecv(pkt);
    }
    // just zero-hop control packets allowed (for this subset of payloads)
    return ACTION_RELEASE;
  }

-  if (pkt->isRouteDirect() && pkt->getPathHashCount() > 0) {
+  if (pkt->isRouteDirect() && pkt->path_len >= PATH_HASH_SIZE) {
    // check for 'early received' ACK
    if (pkt->getPayloadType() == PAYLOAD_TYPE_ACK) {
      int i = 0;
@@ -83,7 +88,7 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
      }
    }

-    if (self_id.isHashMatch(pkt->path, pkt->getPathHashSize()) && allowPacketForward(pkt)) {
+    if (self_id.isHashMatch(pkt->path) && allowPacketForward(pkt)) {
      if (pkt->getPayloadType() == PAYLOAD_TYPE_MULTIPART) {
        return forwardMultipartDirect(pkt);
      } else if (pkt->getPayloadType() == PAYLOAD_TYPE_ACK) {
@@ -153,9 +158,7 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
              if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH) {
                int k = 0;
                uint8_t path_len = data[k++];
-                uint8_t hash_size = (path_len >> 6) + 1;
-                uint8_t hash_count = path_len & 63;
-                uint8_t* path = &data[k]; k += hash_size*hash_count;
+                uint8_t* path = &data[k]; k += path_len;
                uint8_t extra_type = data[k++] & 0x0F;   // upper 4 bits reserved for future use
                uint8_t* extra = &data[k];
                uint8_t extra_len = len - k;   // remainder of packet (may be padded with zeroes!)
@@ -290,7 +293,8 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
        if (type == PAYLOAD_TYPE_ACK && pkt->payload_len >= 5) {    // a multipart ACK
          Packet tmp;
          tmp.header = pkt->header;
-          tmp.path_len = Packet::copyPath(tmp.path, pkt->path, pkt->path_len);
+          tmp.path_len = pkt->path_len;
+          memcpy(tmp.path, pkt->path, pkt->path_len);
          tmp.payload_len = pkt->payload_len - 1;
          memcpy(tmp.payload, &pkt->payload[1], tmp.payload_len);

@@ -317,25 +321,27 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {

 void Mesh::removeSelfFromPath(Packet* pkt) {
  // remove our hash from 'path'
-  pkt->setPathHashCount(pkt->getPathHashCount() - 1);  // decrement the count
-
-  uint8_t sz = pkt->getPathHashSize();
-  for (int k = 0; k < pkt->getPathHashCount()*sz; k += sz) {  // shuffle path by 1 'entry'
-    memcpy(&pkt->path[k], &pkt->path[k + sz], sz);
+  pkt->path_len -= PATH_HASH_SIZE;
+#if 0
+  memcpy(pkt->path, &pkt->path[PATH_HASH_SIZE], pkt->path_len);
+#elif PATH_HASH_SIZE == 1
+  for (int k = 0; k < pkt->path_len; k++) {  // shuffle bytes by 1
+    pkt->path[k] = pkt->path[k + 1];
  }
+#else
+  #error "need path remove impl"
+#endif
 }

 DispatcherAction Mesh::routeRecvPacket(Packet* packet) {
-  uint8_t n = packet->getPathHashCount();
  if (packet->isRouteFlood() && !packet->isMarkedDoNotRetransmit()
-    && (n + 1)*packet->getPathHashSize() <= MAX_PATH_SIZE && allowPacketForward(packet)) {
+    && packet->path_len + PATH_HASH_SIZE <= MAX_PATH_SIZE && allowPacketForward(packet)) {
    // append this node's hash to 'path'
-    self_id.copyHashTo(&packet->path[n * packet->getPathHashSize()], packet->getPathHashSize());
-    packet->setPathHashCount(n + 1);
+    packet->path_len += self_id.copyHashTo(&packet->path[packet->path_len]);

    uint32_t d = getRetransmitDelay(packet);
    // as this propagates outwards, give it lower and lower priority
-    return ACTION_RETRANSMIT_DELAYED(packet->getPathHashCount(), d);   // give priority to closer sources, than ones further away
+    return ACTION_RETRANSMIT_DELAYED(packet->path_len, d);   // give priority to closer sources, than ones further away
  }
  return ACTION_RELEASE;
 }
@@ -347,7 +353,8 @@ DispatcherAction Mesh::forwardMultipartDirect(Packet* pkt) {
  if (type == PAYLOAD_TYPE_ACK && pkt->payload_len >= 5) {    // a multipart ACK
    Packet tmp;
    tmp.header = pkt->header;
-    tmp.path_len = Packet::copyPath(tmp.path, pkt->path, pkt->path_len);
+    tmp.path_len = pkt->path_len;
+    memcpy(tmp.path, pkt->path, pkt->path_len);
    tmp.payload_len = pkt->payload_len - 1;
    memcpy(tmp.payload, &pkt->payload[1], tmp.payload_len);

@@ -369,7 +376,7 @@ void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {
      delay_millis += getDirectRetransmitDelay(packet) + 300;
      auto a1 = createMultiAck(crc, extra);
      if (a1) {
-        a1->path_len = Packet::copyPath(a1->path, packet->path, packet->path_len);
+        memcpy(a1->path, packet->path, a1->path_len = packet->path_len);
        a1->header &= ~PH_ROUTE_MASK;
        a1->header |= ROUTE_TYPE_DIRECT;
        sendPacket(a1, 0, delay_millis);
@@ -379,7 +386,7 @@ void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {

    auto a2 = createAck(crc);
    if (a2) {
-      a2->path_len = Packet::copyPath(a2->path, packet->path, packet->path_len);
+      memcpy(a2->path, packet->path, a2->path_len = packet->path_len);
      a2->header &= ~PH_ROUTE_MASK;
      a2->header |= ROUTE_TYPE_DIRECT;
      sendPacket(a2, 0, delay_millis);
@@ -432,10 +439,7 @@ Packet* Mesh::createPathReturn(const Identity& dest, const uint8_t* secret, cons
 }

 Packet* Mesh::createPathReturn(const uint8_t* dest_hash, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len) {
-  uint8_t path_hash_size = (path_len >> 6) + 1;
-  uint8_t path_hash_count = path_len & 63;
-
-  if (path_hash_count*path_hash_size + extra_len + 5 > MAX_COMBINED_PATH) return NULL;  // too long!!
+  if (path_len + extra_len + 5 > MAX_COMBINED_PATH) return NULL;  // too long!!

  Packet* packet = obtainNewPacket();
  if (packet == NULL) {
@@ -453,7 +457,7 @@ Packet* Mesh::createPathReturn(const uint8_t* dest_hash, const uint8_t* secret,
    uint8_t data[MAX_PACKET_PAYLOAD];

    data[data_len++] = path_len;
-    memcpy(&data[data_len], path, path_hash_count*path_hash_size); data_len += path_hash_count*path_hash_size;
+    memcpy(&data[data_len], path, path_len); data_len += path_len;
    if (extra_len > 0) {
      data[data_len++] = extra_type;
      memcpy(&data[data_len], extra, extra_len); data_len += extra_len;
@@ -620,19 +624,15 @@ Packet* Mesh::createControlData(const uint8_t* data, size_t len) {
  return packet;
 }

-void Mesh::sendFlood(Packet* packet, uint32_t delay_millis, uint8_t path_hash_size) {
+void Mesh::sendFlood(Packet* packet, uint32_t delay_millis) {
  if (packet->getPayloadType() == PAYLOAD_TYPE_TRACE) {
    MESH_DEBUG_PRINTLN("%s Mesh::sendFlood(): TRACE type not suspported", getLogDateTime());
    return;
  }
-  if (path_hash_size == 0 || path_hash_size > 3) {
-    MESH_DEBUG_PRINTLN("%s Mesh::sendFlood(): invalid path_hash_size", getLogDateTime());
-    return;
-  }

  packet->header &= ~PH_ROUTE_MASK;
  packet->header |= ROUTE_TYPE_FLOOD;
-  packet->setPathHashSizeAndCount(path_hash_size, 0);
+  packet->path_len = 0;

  _tables->hasSeen(packet); // mark this packet as already sent in case it is rebroadcast back to us

@@ -647,21 +647,17 @@ void Mesh::sendFlood(Packet* packet, uint32_t delay_millis, uint8_t path_hash_si
  sendPacket(packet, pri, delay_millis);
 }

-void Mesh::sendFlood(Packet* packet, uint16_t* transport_codes, uint32_t delay_millis, uint8_t path_hash_size) {
+void Mesh::sendFlood(Packet* packet, uint16_t* transport_codes, uint32_t delay_millis) {
  if (packet->getPayloadType() == PAYLOAD_TYPE_TRACE) {
    MESH_DEBUG_PRINTLN("%s Mesh::sendFlood(): TRACE type not suspported", getLogDateTime());
    return;
  }
-  if (path_hash_size == 0 || path_hash_size > 3) {
-    MESH_DEBUG_PRINTLN("%s Mesh::sendFlood(): invalid path_hash_size", getLogDateTime());
-    return;
-  }

  packet->header &= ~PH_ROUTE_MASK;
  packet->header |= ROUTE_TYPE_TRANSPORT_FLOOD;
  packet->transport_codes[0] = transport_codes[0];
  packet->transport_codes[1] = transport_codes[1];
-  packet->setPathHashSizeAndCount(path_hash_size, 0);
+  packet->path_len = 0;

  _tables->hasSeen(packet); // mark this packet as already sent in case it is rebroadcast back to us

@@ -683,13 +679,13 @@ void Mesh::sendDirect(Packet* packet, const uint8_t* path, uint8_t path_len, uin
  uint8_t pri;
  if (packet->getPayloadType() == PAYLOAD_TYPE_TRACE) {   // TRACE packets are different
    // for TRACE packets, path is appended to end of PAYLOAD. (path is used for SNR's)
-    memcpy(&packet->payload[packet->payload_len], path, path_len);  // NOTE: path_len here can be > 64, and NOT in the new scheme
+    memcpy(&packet->payload[packet->payload_len], path, path_len);
    packet->payload_len += path_len;

    packet->path_len = 0;
    pri = 5;   // maybe make this configurable
  } else {
-    packet->path_len = Packet::copyPath(packet->path, path, path_len);
+    memcpy(packet->path, path, packet->path_len = path_len);
    if (packet->getPayloadType() == PAYLOAD_TYPE_PATH) {
      pri = 1;   // slightly less priority
    } else {
--- a/src/Mesh.h
+++ b/src/Mesh.h
@@ -196,13 +196,13 @@ public:
  /**
   * \brief  send a locally-generated Packet with flood routing
  */
-  void sendFlood(Packet* packet, uint32_t delay_millis=0, uint8_t path_hash_size=1);
+  void sendFlood(Packet* packet, uint32_t delay_millis=0);

  /**
   * \brief  send a locally-generated Packet with flood routing
   * \param transport_codes   array of 2 codes to attach to packet
  */
-  void sendFlood(Packet* packet, uint16_t* transport_codes, uint32_t delay_millis=0, uint8_t path_hash_size=1);
+  void sendFlood(Packet* packet, uint16_t* transport_codes, uint32_t delay_millis=0);

  /**
   * \brief  send a locally-generated Packet with Direct routing
--- a/src/Packet.cpp
+++ b/src/Packet.cpp
@@ -10,32 +10,8 @@ Packet::Packet() {
  payload_len = 0;
 }

-bool Packet::isValidPathLen(uint8_t path_len) {
-  uint8_t hash_count = path_len & 63;
-  uint8_t hash_size = (path_len >> 6) + 1;
-  if (hash_size == 4) return false;  // Reserved for future
-  return hash_count*hash_size <= MAX_PATH_SIZE;
-}
-
-size_t Packet::writePath(uint8_t* dest, const uint8_t* src, uint8_t path_len) {
-  uint8_t hash_count = path_len & 63;
-  uint8_t hash_size = (path_len >> 6) + 1;
-  size_t len = hash_count*hash_size;
-  if (len > MAX_PATH_SIZE) {
-    MESH_DEBUG_PRINTLN("Packet::copyPath, invalid path_len=%d", (uint32_t)path_len);
-    return 0;   // Error
-  }
-  memcpy(dest, src, len);
-  return len;
-}
-
-uint8_t Packet::copyPath(uint8_t* dest, const uint8_t* src, uint8_t path_len) {
-  writePath(dest, src, path_len);
-  return path_len;
-}
-
 int Packet::getRawLength() const {
-  return 2 + getPathByteLen() + payload_len + (hasTransportCodes() ? 4 : 0);
+  return 2 + path_len + payload_len + (hasTransportCodes() ? 4 : 0);
 }

 void Packet::calculatePacketHash(uint8_t* hash) const {
@@ -57,7 +33,7 @@ uint8_t Packet::writeTo(uint8_t dest[]) const {
    memcpy(&dest[i], &transport_codes[1], 2); i += 2;
  }
  dest[i++] = path_len;
-  i += writePath(&dest[i], path, path_len);
+  memcpy(&dest[i], path, path_len); i += path_len;
  memcpy(&dest[i], payload, payload_len); i += payload_len;
  return i;
 }
@@ -72,11 +48,8 @@ bool Packet::readFrom(const uint8_t src[], uint8_t len) {
    transport_codes[0] = transport_codes[1] = 0;
  }
  path_len = src[i++];
-  if (!isValidPathLen(path_len)) return false;   // bad encoding
-
-  uint8_t bl = getPathByteLen();
-  memcpy(path, &src[i], bl); i += bl;
-
+  if (path_len > sizeof(path)) return false;   // bad encoding
+  memcpy(path, &src[i], path_len); i += path_len;
  if (i >= len) return false;   // bad encoding
  payload_len = len - i;
  if (payload_len > sizeof(payload)) return false;  // bad encoding
--- a/src/Packet.h
+++ b/src/Packet.h
@@ -76,16 +76,6 @@ public:
   */
  uint8_t getPayloadVer() const { return (header >> PH_VER_SHIFT) & PH_VER_MASK; }

-  uint8_t getPathHashSize() const { return (path_len >> 6) + 1; }
-  uint8_t getPathHashCount() const { return path_len & 63; }
-  uint8_t getPathByteLen() const { return getPathHashCount() * getPathHashSize(); }
-  void setPathHashCount(uint8_t n) { path_len &= ~63; path_len |= n; }
-  void setPathHashSizeAndCount(uint8_t sz, uint8_t n) { path_len = ((sz - 1) << 6) | (n & 63); }
-
-  static uint8_t copyPath(uint8_t* dest, const uint8_t* src, uint8_t path_len);  // returns path_len
-  static size_t writePath(uint8_t* dest, const uint8_t* src, uint8_t path_len);  // returns byte length written
-  static bool isValidPathLen(uint8_t path_len);
-
  void markDoNotRetransmit() { header = 0xFF; }
  bool isMarkedDoNotRetransmit() const { return header == 0xFF; }

--- a/src/helpers/BaseChatMesh.cpp
+++ b/src/helpers/BaseChatMesh.cpp
@@ -39,7 +39,7 @@ mesh::Packet* BaseChatMesh::createSelfAdvert(const char* name, double lat, doubl
 }

 void BaseChatMesh::sendAckTo(const ContactInfo& dest, uint32_t ack_hash) {
-  if (dest.out_path_len == OUT_PATH_UNKNOWN) {
+  if (dest.out_path_len < 0) {
    mesh::Packet* ack = createAck(ack_hash);
    if (ack) sendFloodScoped(dest, ack, TXT_ACK_DELAY);
  } else {
@@ -92,7 +92,7 @@ ContactInfo* BaseChatMesh::allocateContactSlot() {
 void BaseChatMesh::populateContactFromAdvert(ContactInfo& ci, const mesh::Identity& id, const AdvertDataParser& parser, uint32_t timestamp) {
  memset(&ci, 0, sizeof(ci));
  ci.id = id;
-  ci.out_path_len = OUT_PATH_UNKNOWN;
+  ci.out_path_len = -1;  // initially out_path is unknown
  StrHelper::strncpy(ci.name, parser.getName(), sizeof(ci.name));
  ci.type = parser.getType();
  if (parser.hasLatLon()) {
@@ -141,15 +141,6 @@ void BaseChatMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id,
      return;
    }

-    // check hop limit for new contacts (0 = no limit, 1 = direct (0 hops), N = up to N-1 hops)
-    uint8_t max_hops = getAutoAddMaxHops();
-    if (max_hops > 0 && packet->getPathHashCount() >= max_hops) {
-      ContactInfo ci;
-      populateContactFromAdvert(ci, id, parser, timestamp);
-      onDiscoveredContact(ci, true, packet->path_len, packet->path);       // let UI know
-      return;
-    }
-
    from = allocateContactSlot();
    if (from == NULL) {
      ContactInfo ci;
@@ -272,7 +263,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
      } else {
        mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, from.id, secret, temp_buf, reply_len);
        if (reply) {
-          if (from.out_path_len != OUT_PATH_UNKNOWN) {  // we have an out_path, so send DIRECT
+          if (from.out_path_len >= 0) {  // we have an out_path, so send DIRECT
            sendDirect(reply, from.out_path, from.out_path_len, SERVER_RESPONSE_DELAY);
          } else {
            sendFloodScoped(from, reply, SERVER_RESPONSE_DELAY);
@@ -282,7 +273,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
    }
  } else if (type == PAYLOAD_TYPE_RESPONSE && len > 0) {
    onContactResponse(from, data, len);
-    if (packet->isRouteFlood() && from.out_path_len != OUT_PATH_UNKNOWN) {
+    if (packet->isRouteFlood() && from.out_path_len >= 0) {
      // we have direct path, but other node is still sending flood response, so maybe they didn't receive reciprocal path properly(?)
      handleReturnPathRetry(from, packet->path, packet->path_len);
    }
@@ -304,7 +295,7 @@ bool BaseChatMesh::onPeerPathRecv(mesh::Packet* packet, int sender_idx, const ui
 bool BaseChatMesh::onContactPathRecv(ContactInfo& from, uint8_t* in_path, uint8_t in_path_len, uint8_t* out_path, uint8_t out_path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) {
  // NOTE: default impl, we just replace the current 'out_path' regardless, whenever sender sends us a new out_path.
  // FUTURE: could store multiple out_paths per contact, and try to find which is the 'best'(?)
-  from.out_path_len = mesh::Packet::copyPath(from.out_path, out_path, out_path_len);  // store a copy of path, for sendDirect()
+  memcpy(from.out_path, out_path, from.out_path_len = out_path_len);  // store a copy of path, for sendDirect()
  from.lastmod = getRTCClock()->getCurrentTime();

  onContactPathUpdated(from);
@@ -326,7 +317,7 @@ void BaseChatMesh::onAckRecv(mesh::Packet* packet, uint32_t ack_crc) {
    txt_send_timeout = 0;   // matched one we're waiting for, cancel timeout timer
    packet->markDoNotRetransmit();   // ACK was for this node, so don't retransmit

-    if (packet->isRouteFlood() && from->out_path_len != OUT_PATH_UNKNOWN) {
+    if (packet->isRouteFlood() && from->out_path_len >= 0) {
      // we have direct path, but other node is still sending flood, so maybe they didn't receive reciprocal path properly(?)
      handleReturnPathRetry(*from, packet->path, packet->path_len);
    }
@@ -395,7 +386,7 @@ int  BaseChatMesh::sendMessage(const ContactInfo& recipient, uint32_t timestamp,
  uint32_t t = _radio->getEstAirtimeFor(pkt->getRawLength());

  int rc;
-  if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
+  if (recipient.out_path_len < 0) {
    sendFloodScoped(recipient, pkt);
    txt_send_timeout = futureMillis(est_timeout = calcFloodTimeoutMillisFor(t));
    rc = MSG_SEND_SENT_FLOOD;
@@ -421,7 +412,7 @@ int  BaseChatMesh::sendCommandData(const ContactInfo& recipient, uint32_t timest

  uint32_t t = _radio->getEstAirtimeFor(pkt->getRawLength());
  int rc;
-  if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
+  if (recipient.out_path_len < 0) {
    sendFloodScoped(recipient, pkt);
    txt_send_timeout = futureMillis(est_timeout = calcFloodTimeoutMillisFor(t));
    rc = MSG_SEND_SENT_FLOOD;
@@ -509,7 +500,7 @@ int BaseChatMesh::sendLogin(const ContactInfo& recipient, const char* password,
  }
  if (pkt) {
    uint32_t t = _radio->getEstAirtimeFor(pkt->getRawLength());
-    if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
+    if (recipient.out_path_len < 0) {
      sendFloodScoped(recipient, pkt);
      est_timeout = calcFloodTimeoutMillisFor(t);
      return MSG_SEND_SENT_FLOOD;
@@ -534,7 +525,7 @@ int BaseChatMesh::sendAnonReq(const ContactInfo& recipient, const uint8_t* data,
  }
  if (pkt) {
    uint32_t t = _radio->getEstAirtimeFor(pkt->getRawLength());
-    if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
+    if (recipient.out_path_len < 0) {
      sendFloodScoped(recipient, pkt);
      est_timeout = calcFloodTimeoutMillisFor(t);
      return MSG_SEND_SENT_FLOOD;
@@ -561,7 +552,7 @@ int  BaseChatMesh::sendRequest(const ContactInfo& recipient, const uint8_t* req_
  }
  if (pkt) {
    uint32_t t = _radio->getEstAirtimeFor(pkt->getRawLength());
-    if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
+    if (recipient.out_path_len < 0) {
      sendFloodScoped(recipient, pkt);
      est_timeout = calcFloodTimeoutMillisFor(t);
      return MSG_SEND_SENT_FLOOD;
@@ -588,7 +579,7 @@ int  BaseChatMesh::sendRequest(const ContactInfo& recipient, uint8_t req_type, u
  }
  if (pkt) {
    uint32_t t = _radio->getEstAirtimeFor(pkt->getRawLength());
-    if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
+    if (recipient.out_path_len < 0) {
      sendFloodScoped(recipient, pkt);
      est_timeout = calcFloodTimeoutMillisFor(t);
      return MSG_SEND_SENT_FLOOD;
@@ -692,7 +683,7 @@ void BaseChatMesh::checkConnections() {
        MESH_DEBUG_PRINTLN("checkConnections(): Keep_alive contact not found!");
        continue;
      }
-      if (contact->out_path_len == OUT_PATH_UNKNOWN) {
+      if (contact->out_path_len < 0) {
        MESH_DEBUG_PRINTLN("checkConnections(): Keep_alive contact, no out_path!");
        continue;
      }
@@ -719,7 +710,7 @@ void BaseChatMesh::checkConnections() {
 }

 void BaseChatMesh::resetPathTo(ContactInfo& recipient) {
-  recipient.out_path_len = OUT_PATH_UNKNOWN;
+  recipient.out_path_len = -1;
 }

 static ContactInfo* table;  // pass via global :-(
--- a/src/helpers/BaseChatMesh.h
+++ b/src/helpers/BaseChatMesh.h
@@ -98,7 +98,6 @@ protected:
  virtual bool shouldAutoAddContactType(uint8_t type) const { return true; }
  virtual void onContactsFull() {};
  virtual bool shouldOverwriteWhenFull() const { return false; }
-  virtual uint8_t getAutoAddMaxHops() const { return 0; }  // 0 = no limit, 1 = direct (0 hops), N = up to N-1 hops
  virtual void onContactOverwrite(const uint8_t* pub_key) {};
  virtual void onDiscoveredContact(ContactInfo& contact, bool is_new, uint8_t path_len, const uint8_t* path) = 0;
  virtual ContactInfo* processAck(const uint8_t *data) = 0;
--- a/src/helpers/ClientACL.cpp
+++ b/src/helpers/ClientACL.cpp
@@ -114,7 +114,7 @@ ClientInfo* ClientACL::putClient(const mesh::Identity& id, uint8_t init_perms) {
  memset(c, 0, sizeof(*c));
  c->permissions = init_perms;
  c->id = id;
-  c->out_path_len = OUT_PATH_UNKNOWN;
+  c->out_path_len = -1;  // initially out_path is unknown
  return c;
 }

--- a/src/helpers/ClientACL.h
+++ b/src/helpers/ClientACL.h
@@ -10,12 +10,10 @@
 #define PERM_ACL_READ_WRITE    2
 #define PERM_ACL_ADMIN         3

-#define OUT_PATH_UNKNOWN  0xFF
-
 struct ClientInfo {
  mesh::Identity id;
  uint8_t permissions;
-  uint8_t out_path_len;
+  int8_t out_path_len;
  uint8_t out_path[MAX_PATH_SIZE];
  uint8_t shared_secret[PUB_KEY_SIZE];
  uint32_t last_timestamp;   // by THEIR clock  (transient)
--- a/src/helpers/CommonCLI.cpp
+++ b/src/helpers/CommonCLI.cpp
@@ -63,8 +63,7 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
    file.read((uint8_t *)&_prefs->multi_acks, sizeof(_prefs->multi_acks));                         // 115
    file.read((uint8_t *)&_prefs->bw, sizeof(_prefs->bw));                                         // 116
    file.read((uint8_t *)&_prefs->agc_reset_interval, sizeof(_prefs->agc_reset_interval));         // 120
-    file.read((uint8_t *)&_prefs->path_hash_mode, sizeof(_prefs->path_hash_mode));                 // 121
-    file.read(pad, 2);                                                                             // 122
+    file.read(pad, 3);                                                                             // 121
    file.read((uint8_t *)&_prefs->flood_max, sizeof(_prefs->flood_max));                           // 124
    file.read((uint8_t *)&_prefs->flood_advert_interval, sizeof(_prefs->flood_advert_interval));   // 125
    file.read((uint8_t *)&_prefs->interference_threshold, sizeof(_prefs->interference_threshold)); // 126
@@ -98,7 +97,6 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
    _prefs->tx_power_dbm = constrain(_prefs->tx_power_dbm, -9, 30);
    _prefs->multi_acks = constrain(_prefs->multi_acks, 0, 1);
    _prefs->adc_multiplier = constrain(_prefs->adc_multiplier, 0.0f, 10.0f);
-    _prefs->path_hash_mode = constrain(_prefs->path_hash_mode, 0, 2);   // NOTE: mode 3 reserved for future

    // sanitise bad bridge pref values
    _prefs->bridge_enabled = constrain(_prefs->bridge_enabled, 0, 1);
@@ -153,8 +151,7 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
    file.write((uint8_t *)&_prefs->multi_acks, sizeof(_prefs->multi_acks));                         // 115
    file.write((uint8_t *)&_prefs->bw, sizeof(_prefs->bw));                                         // 116
    file.write((uint8_t *)&_prefs->agc_reset_interval, sizeof(_prefs->agc_reset_interval));         // 120
-    file.write((uint8_t *)&_prefs->path_hash_mode, sizeof(_prefs->path_hash_mode));                 // 121
-    file.write(pad, 2);                                                                             // 122
+    file.write(pad, 3);                                                                             // 121
    file.write((uint8_t *)&_prefs->flood_max, sizeof(_prefs->flood_max));                           // 124
    file.write((uint8_t *)&_prefs->flood_advert_interval, sizeof(_prefs->flood_advert_interval));   // 125
    file.write((uint8_t *)&_prefs->interference_threshold, sizeof(_prefs->interference_threshold)); // 126
@@ -334,8 +331,6 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
          sp++;
        }
        *reply = 0;  // set null terminator
-      } else if (memcmp(config, "path.hash.mode", 14) == 0) {
-        sprintf(reply, "> %d", (uint32_t)_prefs->path_hash_mode);
      } else if (memcmp(config, "tx", 2) == 0 && (config[2] == 0 || config[2] == ' ')) {
        sprintf(reply, "> %d", (int32_t) _prefs->tx_power_dbm);
      } else if (memcmp(config, "freq", 4) == 0) {
@@ -569,16 +564,6 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
        *dp = 0;
        savePrefs();
        strcpy(reply, "OK");
-      } else if (memcmp(config, "path.hash.mode ", 15) == 0) {
-        config += 15;
-        uint8_t mode = atoi(config);
-        if (mode < 3) {
-          _prefs->path_hash_mode = mode;
-          savePrefs();
-          strcpy(reply, "OK");
-        } else {
-          strcpy(reply, "Error, must be 0,1, or 2");
-        }
      } else if (memcmp(config, "tx ", 3) == 0) {
        _prefs->tx_power_dbm = atoi(&config[3]);
        savePrefs();
@@ -734,9 +719,6 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
      LocationProvider * l = _sensors->getLocationProvider();
      if (l != NULL) {
        l->syncTime();
-        strcpy(reply, "ok");
-      } else {
-        strcpy(reply, "gps provider not found");
      }
    } else if (memcmp(command, "gps setloc", 10) == 0) {
      _prefs->node_lat = _sensors->node_lat;
@@ -766,7 +748,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
        _prefs->advert_loc_policy = ADVERT_LOC_SHARE;
        savePrefs();
        strcpy(reply, "ok");
-      } else if (memcmp(command+11, "prefs", 5) == 0) {
+      } else if (memcmp(command+11, "prefs", 4) == 0) {
        _prefs->advert_loc_policy = ADVERT_LOC_PREFS;
        savePrefs();
        strcpy(reply, "ok");
--- a/src/helpers/CommonCLI.h
+++ b/src/helpers/CommonCLI.h
@@ -53,7 +53,6 @@ struct NodePrefs { // persisted to file
  uint32_t discovery_mod_timestamp;
  float adc_multiplier;
  char owner_info[120];
-  uint8_t path_hash_mode;   // which path mode to use when sending
 };

 class CommonCLICallbacks {
--- a/src/helpers/ContactInfo.h
+++ b/src/helpers/ContactInfo.h
@@ -3,14 +3,12 @@
 #include <Arduino.h>
 #include <Mesh.h>

-#define OUT_PATH_UNKNOWN   0xFF
-
 struct ContactInfo {
  mesh::Identity id;
  char name[32];
  uint8_t type;   // on of ADV_TYPE_*
  uint8_t flags;
-  uint8_t out_path_len;
+  int8_t out_path_len;
  mutable bool shared_secret_valid; // flag to indicate if shared_secret has been calculated
  uint8_t out_path[MAX_PATH_SIZE];
  uint32_t last_advert_timestamp;   // by THEIR clock
--- a/src/helpers/RefCountedDigitalPin.h
+++ b/src/helpers/RefCountedDigitalPin.h
@@ -20,10 +20,7 @@ public:
      digitalWrite(_pin, _active);
    }
  }
-
  void release() {
-    if (_claims == 0) return; // avoid negative _claims
-
    _claims--;
    if (_claims == 0) {
      digitalWrite(_pin, !_active);
--- a/src/helpers/StaticPoolPacketManager.cpp
+++ b/src/helpers/StaticPoolPacketManager.cpp
@@ -11,7 +11,7 @@ PacketQueue::PacketQueue(int max_entries) {
 int PacketQueue::countBefore(uint32_t now) const {
  int n = 0;
  for (int j = 0; j < _num; j++) {
-    if ((int32_t)(_schedule_table[j] - now) > 0) continue;   // scheduled for future... ignore for now
+    if (_schedule_table[j] > now) continue;   // scheduled for future... ignore for now
    n++;
  }
  return n;
@@ -21,7 +21,7 @@ mesh::Packet* PacketQueue::get(uint32_t now) {
  uint8_t min_pri = 0xFF;
  int best_idx = -1;
  for (int j = 0; j < _num; j++) {
-    if ((int32_t)(_schedule_table[j] - now) > 0) continue;   // scheduled for future... ignore for now
+    if (_schedule_table[j] > now) continue;   // scheduled for future... ignore for now
    if (_pri_table[j] < min_pri) {  // select most important priority amongst non-future entries
      min_pri = _pri_table[j];
      best_idx = j;
--- a/src/helpers/radiolib/CustomLLCC68Wrapper.h
+++ b/src/helpers/radiolib/CustomLLCC68Wrapper.h
@@ -2,7 +2,6 @@

 #include "CustomLLCC68.h"
 #include "RadioLibWrappers.h"
-#include "SX126xReset.h"

 class CustomLLCC68Wrapper : public RadioLibWrapper {
 public:
@@ -20,6 +19,4 @@ public:
    int sf = ((CustomLLCC68 *)_radio)->spreadingFactor;
    return packetScoreInt(snr, sf, packet_len);
  }
-
-  void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
 };
--- a/src/helpers/radiolib/CustomLR1110.h
+++ b/src/helpers/radiolib/CustomLR1110.h
@@ -20,8 +20,6 @@ class CustomLR1110 : public LR1110 {
      return len;
    }
    
-    float getFreqMHz() const { return freqMHz; }
-
    bool isReceiving() {
      uint16_t irq = getIrqStatus();
      bool detected = ((irq & RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID) || (irq & RADIOLIB_LR11X0_IRQ_PREAMBLE_DETECTED));
--- a/src/helpers/radiolib/CustomLR1110Wrapper.h
+++ b/src/helpers/radiolib/CustomLR1110Wrapper.h
@@ -2,13 +2,11 @@

 #include "CustomLR1110.h"
 #include "RadioLibWrappers.h"
-#include "LR11x0Reset.h"

 class CustomLR1110Wrapper : public RadioLibWrapper {
 public:
  CustomLR1110Wrapper(CustomLR1110& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  void doResetAGC() override { lr11x0ResetAGC((LR11x0 *)_radio, ((CustomLR1110 *)_radio)->getFreqMHz()); }
-  bool isReceivingPacket() override {
+  bool isReceivingPacket() override { 
    return ((CustomLR1110 *)_radio)->isReceiving();
  }
  float getCurrentRSSI() override {
--- a/src/helpers/radiolib/CustomSTM32WLxWrapper.h
+++ b/src/helpers/radiolib/CustomSTM32WLxWrapper.h
@@ -2,7 +2,6 @@

 #include "CustomSTM32WLx.h"
 #include "RadioLibWrappers.h"
-#include "SX126xReset.h"
 #include <math.h>

 class CustomSTM32WLxWrapper : public RadioLibWrapper {
@@ -21,6 +20,4 @@ public:
    int sf = ((CustomSTM32WLx *)_radio)->spreadingFactor;
    return packetScoreInt(snr, sf, packet_len);
  }
-
-  void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
 };
--- a/src/helpers/radiolib/CustomSX1262Wrapper.h
+++ b/src/helpers/radiolib/CustomSX1262Wrapper.h
@@ -2,7 +2,6 @@

 #include "CustomSX1262.h"
 #include "RadioLibWrappers.h"
-#include "SX126xReset.h"

 class CustomSX1262Wrapper : public RadioLibWrapper {
 public:
@@ -23,6 +22,4 @@ public:
  virtual void powerOff() override {
    ((CustomSX1262 *)_radio)->sleep(false);
  }
-
-  void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
 };
--- a/src/helpers/radiolib/CustomSX1268Wrapper.h
+++ b/src/helpers/radiolib/CustomSX1268Wrapper.h
@@ -2,7 +2,6 @@

 #include "CustomSX1268.h"
 #include "RadioLibWrappers.h"
-#include "SX126xReset.h"

 class CustomSX1268Wrapper : public RadioLibWrapper {
 public:
@@ -20,6 +19,4 @@ public:
    int sf = ((CustomSX1268 *)_radio)->spreadingFactor;
    return packetScoreInt(snr, sf, packet_len);
  }
-
-  void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
 };
--- a/src/helpers/radiolib/LR11x0Reset.h
+++ b/src/helpers/radiolib/LR11x0Reset.h
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <RadioLib.h>
-
-// Full receiver reset for LR11x0-family chips (LR1110, LR1120, LR1121).
-// Warm sleep powers down analog, calibrate(0x3F) refreshes all calibration blocks,
-// then re-applies RX settings that calibration may reset.
-inline void lr11x0ResetAGC(LR11x0* radio, float freqMHz) {
-  radio->sleep(true, 0);
-  radio->standby(RADIOLIB_LR11X0_STANDBY_RC, true);
-
-  radio->calibrate(RADIOLIB_LR11X0_CALIBRATE_ALL);
-
-  // calibrate(0x3F) defaults image calibration to 902-928MHz band.
-  // Re-calibrate for the actual operating frequency (band=4MHz matches RadioLib default).
-  radio->calibrateImageRejection(freqMHz - 4.0f, freqMHz + 4.0f);
-
-#ifdef RX_BOOSTED_GAIN
-  radio->setRxBoostedGainMode(RX_BOOSTED_GAIN);
-#endif
-}
--- a/src/helpers/radiolib/RadioLibWrappers.cpp
+++ b/src/helpers/radiolib/RadioLibWrappers.cpp
@@ -53,24 +53,13 @@ void RadioLibWrapper::triggerNoiseFloorCalibrate(int threshold) {
  }
 }

-void RadioLibWrapper::doResetAGC() {
-  _radio->sleep();  // warm sleep to reset analog frontend
-}
-
 void RadioLibWrapper::resetAGC() {
  // make sure we're not mid-receive of packet!
  if ((state & STATE_INT_READY) != 0 || isReceivingPacket()) return;

-  doResetAGC();
+  // NOTE: according to higher powers, just issuing RadioLib's startReceive() will reset the AGC.
+  //      revisit this if a better impl is discovered.
  state = STATE_IDLE;   // trigger a startReceive()
-
-  // Reset noise floor sampling so it reconverges from scratch.
-  // Without this, a stuck _noise_floor of -120 makes the sampling threshold
-  // too low (-106) to accept normal samples (~-105), self-reinforcing the
-  // stuck value even after the receiver has recovered.
-  _noise_floor = 0;
-  _num_floor_samples = 0;
-  _floor_sample_sum = 0;
 }

 void RadioLibWrapper::loop() {
--- a/src/helpers/radiolib/RadioLibWrappers.h
+++ b/src/helpers/radiolib/RadioLibWrappers.h
@@ -16,7 +16,6 @@ protected:
  void startRecv();
  float packetScoreInt(float snr, int sf, int packet_len);
  virtual bool isReceivingPacket() =0;
-  virtual void doResetAGC();

 public:
  RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board) { n_recv = n_sent = 0; }
--- a/src/helpers/radiolib/SX126xReset.h
+++ b/src/helpers/radiolib/SX126xReset.h
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <RadioLib.h>
-
-// Full receiver reset for all SX126x-family chips (SX1262, SX1268, LLCC68, STM32WLx).
-// Warm sleep powers down analog, Calibrate(0x7F) refreshes ADC/PLL/image calibration,
-// then re-applies RX settings that calibration may reset.
-inline void sx126xResetAGC(SX126x* radio) {
-  radio->sleep(true);
-  radio->standby(RADIOLIB_SX126X_STANDBY_RC, true);
-
-  uint8_t calData = RADIOLIB_SX126X_CALIBRATE_ALL;
-  radio->mod->SPIwriteStream(RADIOLIB_SX126X_CMD_CALIBRATE, &calData, 1, true, false);
-  radio->mod->hal->delay(5);
-  uint32_t start = millis();
-  while (radio->mod->hal->digitalRead(radio->mod->getGpio())) {
-    if (millis() - start > 50) break;
-    radio->mod->hal->yield();
-  }
-
-  // Calibrate(0x7F) defaults image calibration to 902-928MHz band.
-  // Re-calibrate for the actual operating frequency.
-  radio->calibrateImage(radio->freqMHz);
-
-#ifdef SX126X_DIO2_AS_RF_SWITCH
-  radio->setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
-#endif
-#ifdef SX126X_RX_BOOSTED_GAIN
-  radio->setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
-#endif
-#ifdef SX126X_REGISTER_PATCH
-  uint8_t r_data = 0;
-  radio->readRegister(0x8B5, &r_data, 1);
-  r_data |= 0x01;
-  radio->writeRegister(0x8B5, &r_data, 1);
-#endif
-}
--- a/src/helpers/sensors/EnvironmentSensorManager.cpp
+++ b/src/helpers/sensors/EnvironmentSensorManager.cpp
@@ -707,9 +707,7 @@ void EnvironmentSensorManager::loop() {
  static long next_gps_update = 0;

  #if ENV_INCLUDE_GPS
-  if (gps_active) {
-    _location->loop();
-  }
+  _location->loop();
  if (millis() > next_gps_update) {

    if(gps_active){
--- a/src/helpers/sensors/MicroNMEALocationProvider.h
+++ b/src/helpers/sensors/MicroNMEALocationProvider.h
@@ -79,10 +79,7 @@ public :
        if (_pin_en != -1) {
            digitalWrite(_pin_en, !PIN_GPS_EN_ACTIVE);
        }
-        if (_pin_reset != -1) {
-            digitalWrite(_pin_reset, GPS_RESET_FORCE);
-        }
-        if (_peripher_power) _peripher_power->release();
+        if (_peripher_power) _peripher_power->release();  
    }

    bool isEnabled() override {
--- a/variants/heltec_tracker/platformio.ini
+++ b/variants/heltec_tracker/platformio.ini
@@ -32,11 +32,6 @@ build_flags =
  -D PIN_TFT_LEDA_CTL=21     ; LEDK (switches on/off via mosfet to create the ground)
  -D PIN_GPS_RX=33
  -D PIN_GPS_TX=34
-  -D PIN_GPS_EN=35              ; N-ch MOSFET Q2 drives P-ch high-side switch → active HIGH (default)
-  -D PIN_GPS_RESET=36
-  -D PIN_GPS_RESET_ACTIVE=LOW
-  -D GPS_BAUD_RATE=115200
-  -D ENV_INCLUDE_GPS=1
  -D SX126X_DIO2_AS_RF_SWITCH=true
  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
  -D SX126X_CURRENT_LIMIT=140
@@ -48,31 +43,6 @@ lib_deps =
  stevemarple/MicroNMEA @ ^2.0.6
  adafruit/Adafruit ST7735 and ST7789 Library @ ^1.11.0

-[env:Heltec_Wireless_Tracker_companion_radio_usb]
-extends = Heltec_tracker_base
-build_flags =
-  ${Heltec_tracker_base.build_flags}
-  -I src/helpers/ui
-  -I examples/companion_radio/ui-new
-  -D DISPLAY_ROTATION=1
-  -D DISPLAY_CLASS=ST7735Display
-  -D MAX_CONTACTS=350
-  -D MAX_GROUP_CHANNELS=40
-; -D BLE_PIN_CODE=123456 ; HWT will use display for pin
-; -D OFFLINE_QUEUE_SIZE=256
-;  -D BLE_DEBUG_LOGGING=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_tracker_base.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<helpers/ui/MomentaryButton.cpp>
-  +<../examples/companion_radio/*.cpp>
-  +<../examples/companion_radio/ui-new/*.cpp>
-  +<helpers/ui/ST7735Display.cpp>
-lib_deps =
-  ${Heltec_tracker_base.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
 [env:Heltec_Wireless_Tracker_companion_radio_ble]
 extends = Heltec_tracker_base
 build_flags =
--- a/variants/heltec_tracker/target.cpp
+++ b/variants/heltec_tracker/target.cpp
@@ -16,8 +16,7 @@ WRAPPER_CLASS radio_driver(radio, board);

 ESP32RTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
-// GPS_EN (GPIO35) drives N-ch MOSFET → P-ch high-side switch; GPS_RESET (GPIO36) active LOW
-MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1, &rtc_clock, GPS_RESET, GPS_EN, &board.periph_power);
+MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1);
 HWTSensorManager sensors = HWTSensorManager(nmea);

 #ifdef DISPLAY_CLASS
@@ -59,16 +58,18 @@ mesh::LocalIdentity radio_new_identity() {

 void HWTSensorManager::start_gps() {
  if (!gps_active) {
-    _location->begin();  // Claims periph_power via RefCountedDigitalPin
+    board.periph_power.claim();
+
    gps_active = true;
-    Serial1.println("$CFGSYS,h35155*68");  // Configure GPS for all constellations
+    Serial1.println("$CFGSYS,h35155*68");
  }
 }

 void HWTSensorManager::stop_gps() {
  if (gps_active) {
    gps_active = false;
-    _location->stop();  // Releases periph_power via RefCountedDigitalPin
+
+    board.periph_power.release();
  }
 }

--- a/variants/heltec_tracker/target.h
+++ b/variants/heltec_tracker/target.h
@@ -28,7 +28,6 @@ public:
  const char* getSettingName(int i) const override;
  const char* getSettingValue(int i) const override;
  bool setSettingValue(const char* name, const char* value) override;
-  LocationProvider* getLocationProvider() override { return _location; }
 };

 extern HeltecV3Board board;
--- a/variants/heltec_tracker_v2/HeltecTrackerV2Board.cpp
+++ b/variants/heltec_tracker_v2/HeltecTrackerV2Board.cpp
@@ -6,26 +6,18 @@ void HeltecTrackerV2Board::begin() {
    pinMode(PIN_ADC_CTRL, OUTPUT);
    digitalWrite(PIN_ADC_CTRL, LOW); // Initially inactive

-    // Set up digital GPIO registers before releasing RTC hold. The hold latches
-    // the pad state including function select, so register writes accumulate
-    // without affecting the pad. On hold release, all changes apply atomically
-    // (IO MUX switches to digital GPIO with output already HIGH — no glitch).
    pinMode(P_LORA_PA_POWER, OUTPUT);
    digitalWrite(P_LORA_PA_POWER,HIGH);
-    rtc_gpio_hold_dis((gpio_num_t)P_LORA_PA_POWER);

+    rtc_gpio_hold_dis((gpio_num_t)P_LORA_PA_EN);
    pinMode(P_LORA_PA_EN, OUTPUT);
    digitalWrite(P_LORA_PA_EN,HIGH);
-    rtc_gpio_hold_dis((gpio_num_t)P_LORA_PA_EN);
    pinMode(P_LORA_PA_TX_EN, OUTPUT);
    digitalWrite(P_LORA_PA_TX_EN,LOW);

-    esp_reset_reason_t reason = esp_reset_reason();
-    if (reason != ESP_RST_DEEPSLEEP) {
-      delay(1);  // GC1109 startup time after cold power-on
-    }
-
    periph_power.begin();
+
+    esp_reset_reason_t reason = esp_reset_reason();
    if (reason == ESP_RST_DEEPSLEEP) {
      long wakeup_source = esp_sleep_get_ext1_wakeup_status();
      if (wakeup_source & (1 << P_LORA_DIO_1)) {  // received a LoRa packet (while in deep sleep)
@@ -56,9 +48,7 @@ void HeltecTrackerV2Board::begin() {

    rtc_gpio_hold_en((gpio_num_t)P_LORA_NSS);

-    // Hold GC1109 FEM pins during sleep to keep LNA active for RX wake
-    rtc_gpio_hold_en((gpio_num_t)P_LORA_PA_POWER);
-    rtc_gpio_hold_en((gpio_num_t)P_LORA_PA_EN);
+    rtc_gpio_hold_en((gpio_num_t)P_LORA_PA_EN); //It also needs to be enabled in receive mode

    if (pin_wake_btn < 0) {
      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_1), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet
--- a/variants/heltec_tracker_v2/platformio.ini
+++ b/variants/heltec_tracker_v2/platformio.ini
@@ -17,11 +17,11 @@ build_flags =
  -D P_LORA_SCLK=9
  -D P_LORA_MISO=11
  -D P_LORA_MOSI=10
-  -D P_LORA_PA_POWER=7   ; VFEM_Ctrl - GC1109 LDO power enable
-  -D P_LORA_PA_EN=4      ; CSD - GC1109 chip enable (HIGH=on)
-  -D P_LORA_PA_TX_EN=46  ; CPS - GC1109 PA mode (HIGH=full PA, LOW=bypass)
-  -D LORA_TX_POWER=10    ; 10dBm + ~11dB GC1109 gain = ~21dBm output
-  -D MAX_LORA_TX_POWER=22 ; Max SX1262 output -> ~28dBm at antenna
+  -D P_LORA_PA_POWER=7 ;power en
+  -D P_LORA_PA_EN=4
+  -D P_LORA_PA_TX_EN=46  ;enable tx
+  -D LORA_TX_POWER=10 ;If it is configured as 10 here, the final output will be 22 dbm.
+  -D MAX_LORA_TX_POWER=22 ;Max SX1262 output
  -D SX126X_DIO2_AS_RF_SWITCH=true
  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
  -D SX126X_CURRENT_LIMIT=140
--- a/variants/heltec_v4/HeltecV4Board.cpp
+++ b/variants/heltec_v4/HeltecV4Board.cpp
@@ -7,26 +7,19 @@ void HeltecV4Board::begin() {
    pinMode(PIN_ADC_CTRL, OUTPUT);
    digitalWrite(PIN_ADC_CTRL, LOW); // Initially inactive

-    // Set up digital GPIO registers before releasing RTC hold. The hold latches
-    // the pad state including function select, so register writes accumulate
-    // without affecting the pad. On hold release, all changes apply atomically
-    // (IO MUX switches to digital GPIO with output already HIGH — no glitch).
    pinMode(P_LORA_PA_POWER, OUTPUT);
    digitalWrite(P_LORA_PA_POWER,HIGH);
-    rtc_gpio_hold_dis((gpio_num_t)P_LORA_PA_POWER);

+    rtc_gpio_hold_dis((gpio_num_t)P_LORA_PA_EN);
    pinMode(P_LORA_PA_EN, OUTPUT);
    digitalWrite(P_LORA_PA_EN,HIGH);
-    rtc_gpio_hold_dis((gpio_num_t)P_LORA_PA_EN);
    pinMode(P_LORA_PA_TX_EN, OUTPUT);
    digitalWrite(P_LORA_PA_TX_EN,LOW);

-    esp_reset_reason_t reason = esp_reset_reason();
-    if (reason != ESP_RST_DEEPSLEEP) {
-      delay(1);  // GC1109 startup time after cold power-on
-    }

    periph_power.begin();
+
+    esp_reset_reason_t reason = esp_reset_reason();
    if (reason == ESP_RST_DEEPSLEEP) {
      long wakeup_source = esp_sleep_get_ext1_wakeup_status();
      if (wakeup_source & (1 << P_LORA_DIO_1)) {  // received a LoRa packet (while in deep sleep)
@@ -57,9 +50,7 @@ void HeltecV4Board::begin() {

    rtc_gpio_hold_en((gpio_num_t)P_LORA_NSS);

-    // Hold GC1109 FEM pins during sleep to keep LNA active for RX wake
-    rtc_gpio_hold_en((gpio_num_t)P_LORA_PA_POWER);
-    rtc_gpio_hold_en((gpio_num_t)P_LORA_PA_EN);
+    rtc_gpio_hold_en((gpio_num_t)P_LORA_PA_EN); //It also needs to be enabled in receive mode

    if (pin_wake_btn < 0) {
      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_1), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet
--- a/variants/heltec_v4/platformio.ini
+++ b/variants/heltec_v4/platformio.ini
@@ -22,7 +22,7 @@ build_flags =
  -D P_LORA_PA_TX_EN=46  ; PA CPS - GC1109 TX PA full(High) / bypass(Low)
  -D PIN_USER_BTN=0
  -D PIN_VEXT_EN=36
-  -D PIN_VEXT_EN_ACTIVE=HIGH
+  -D PIN_VEXT_EN_ACTIVE=LOW
  -D LORA_TX_POWER=10 ;If it is configured as 10 here, the final output will be 22 dbm.
  -D MAX_LORA_TX_POWER=22 ; Max SX1262 output
  -D SX126X_REGISTER_PATCH=1       ; Patch register 0x8B5 for improved RX
@@ -54,6 +54,8 @@ build_flags =
  -D PIN_BOARD_SDA=17
  -D PIN_BOARD_SCL=18
  -D PIN_OLED_RESET=21
+  -D ENV_PIN_SDA=4
+  -D ENV_PIN_SCL=3
 build_src_filter= ${Heltec_lora32_v4.build_src_filter}
 lib_deps = ${Heltec_lora32_v4.lib_deps}

--- a/variants/heltec_v4/target.cpp
+++ b/variants/heltec_v4/target.cpp
@@ -24,7 +24,7 @@ AutoDiscoverRTCClock rtc_clock(fallback_clock);
 #endif

 #ifdef DISPLAY_CLASS
-  DISPLAY_CLASS display(NULL);
+  DISPLAY_CLASS display(&(board.periph_power));
  MomentaryButton user_btn(PIN_USER_BTN, 1000, true);
 #endif

--- a/variants/lilygo_tbeam_supreme_SX1262/platformio.ini
+++ b/variants/lilygo_tbeam_supreme_SX1262/platformio.ini
@@ -26,9 +26,7 @@ build_src_filter = ${esp32_base.build_src_filter}
  +<helpers/ui/SH1106Display.cpp>
  +<helpers/esp32/TBeamBoard.cpp>
  +<helpers/sensors>
-board_build.partitions = default_8MB.csv
-board_upload.flash_size = 8MB
-board_upload.maximum_size = 8388608
+board_build.partitions = min_spiffs.csv ; get around 4mb flash limit
 lib_deps =
  ${esp32_base.lib_deps}
  lewisxhe/XPowersLib @ ^0.2.7
@@ -133,27 +131,3 @@ build_src_filter = ${T_Beam_S3_Supreme_SX1262.build_src_filter}
 lib_deps =
  ${T_Beam_S3_Supreme_SX1262.lib_deps}
  densaugeo/base64 @ ~1.4.0
-
-[env:T_Beam_S3_Supreme_SX1262_companion_radio_wifi]
-extends = T_Beam_S3_Supreme_SX1262
-build_flags =
-  ${T_Beam_S3_Supreme_SX1262.build_flags}
-  -I examples/companion_radio/ui-new
-  -D MAX_CONTACTS=350
-  -D MAX_GROUP_CHANNELS=40
-  -D OFFLINE_QUEUE_SIZE=256
-  -D WIFI_SSID='"WIFI_SSID"'
-  -D WIFI_PWD='"Password"'
-;  -D WIFI_DEBUG_LOGGING=1
-;  -D MESH_PACKET_LOGGING=8
-;  -D MESH_DEBUG=1
-;  -D ARDUHAL_LOG_LEVEL=4
-;  -D CORE_DEBUG_LEVEL=4
-build_src_filter = ${T_Beam_S3_Supreme_SX1262.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<helpers/ui/MomentaryButton.cpp>
-  +<../examples/companion_radio/*.cpp>
-  +<../examples/companion_radio/ui-new/*.cpp>
-lib_deps =
-  ${T_Beam_S3_Supreme_SX1262.lib_deps}
-  densaugeo/base64 @ ~1.4.0
--- a/variants/m5stack_unit_c6l/platformio.ini
+++ b/variants/m5stack_unit_c6l/platformio.ini
@@ -94,8 +94,6 @@ build_flags = ${M5Stack_Unit_C6L.build_flags}
  -D MAX_CONTACTS=350
  -D MAX_GROUP_CHANNELS=40
  -D OFFLINE_QUEUE_SIZE=256
-  -D ARDUINO_USB_CDC_ON_BOOT=1
-  -D ARDUINO_USB_MODE=1
 build_src_filter = ${M5Stack_Unit_C6L.build_src_filter}
  +<helpers/esp32/*.cpp>
  -<helpers/esp32/ESPNOWRadio.cpp>
--- a/variants/rak3401/RAK3401Board.cpp
+++ b/variants/rak3401/RAK3401Board.cpp
@@ -20,29 +20,13 @@ void RAK3401Board::begin() {

  Wire.begin();

-  // PIN_3V3_EN (WB_IO2, P0.34) controls the 3V3_S switched peripheral rail
-  // AND the 5V boost regulator (U5) on the RAK13302 that powers the SKY66122 PA.
-  // Must stay HIGH during radio operation — do not toggle for power saving.
  pinMode(PIN_3V3_EN, OUTPUT);
  digitalWrite(PIN_3V3_EN, HIGH);

-  // Enable SKY66122-11 FEM on the RAK13302 module.
-  // CSD and CPS are tied together on the RAK13302 PCB, routed to IO3 (P0.21).
-  // HIGH = FEM active (LNA for RX, PA path available for TX).
-  // TX/RX switching (CTX) is handled by SX1262 DIO2 via SetDIO2AsRfSwitchCtrl.
-  pinMode(SX126X_POWER_EN, OUTPUT);
-  digitalWrite(SX126X_POWER_EN, HIGH);
-  delay(1);  // SKY66122 turn-on settling time (tON = 3us typ)
-}
-
-#ifdef NRF52_POWER_MANAGEMENT
-void RAK3401Board::initiateShutdown(uint8_t reason) {
-  // Disable SKY66122 FEM (CSD+CPS LOW = shutdown, <1 uA)
-  digitalWrite(SX126X_POWER_EN, LOW);
-
-  // Disable 3V3 switched peripherals and 5V boost
-  digitalWrite(PIN_3V3_EN, LOW);
-
-  enterSystemOff(reason);
-}
+#ifdef P_LORA_PA_EN
+  // Initialize RAK13302 1W LoRa transceiver module PA control pin
+  pinMode(P_LORA_PA_EN, OUTPUT);
+  digitalWrite(P_LORA_PA_EN, LOW);  // Start with PA disabled
+  delay(10);  // Allow PA module to initialize
 #endif
+}
--- a/variants/rak3401/RAK3401Board.h
+++ b/variants/rak3401/RAK3401Board.h
@@ -38,6 +38,13 @@ public:
    return "RAK 3401";
  }

-  // TX/RX switching is handled by SX1262 DIO2 -> SKY66122 CTX (hardware-timed).
-  // No onBeforeTransmit/onAfterTransmit overrides needed.
+#ifdef P_LORA_PA_EN
+  void onBeforeTransmit() override {
+    digitalWrite(P_LORA_PA_EN, HIGH);  // Enable PA before transmission
+  }
+
+  void onAfterTransmit() override {
+    digitalWrite(P_LORA_PA_EN, LOW);   // Disable PA after transmission to save power
+  }
+#endif
 };
--- a/variants/rak3401/platformio.ini
+++ b/variants/rak3401/platformio.ini
@@ -11,7 +11,6 @@ build_flags = ${nrf52_base.build_flags}
  -D LORA_TX_POWER=22
  -D SX126X_CURRENT_LIMIT=140
  -D SX126X_RX_BOOSTED_GAIN=1
-  -D SX126X_REGISTER_PATCH=1       ; Patch register 0x8B5 for improved RX with SKY66122 FEM
 build_src_filter = ${nrf52_base.build_src_filter}
  +<../variants/rak3401>
  +<helpers/sensors>
--- a/variants/rak3401/variant.h
+++ b/variants/rak3401/variant.h
@@ -147,15 +147,8 @@ static const uint8_t AREF = PIN_AREF;
 #define SX126X_BUSY (9)
 #define SX126X_RESET (4)

-// SKY66122-11 FEM control on the RAK13302 module:
-//   CSD + CPS are tied together on the PCB, routed to WisBlock IO3 (P0.21).
-//   Setting IO3 HIGH enables the FEM (LNA for RX, PA path for TX).
-//   CTX is connected to SX1262 DIO2 — the radio handles TX/RX switching
-//   in hardware via SetDIO2AsRfSwitchCtrl (microsecond-accurate, no GPIO needed).
-//   The 5V boost for the PA is enabled by WB_IO2 (P0.34 = PIN_3V3_EN).
-#define SX126X_POWER_EN (21)        // P0.21 = IO3 -> SKY66122 CSD+CPS (FEM enable)
-
-// CTX is driven by SX1262 DIO2, not a GPIO
+#define SX126X_POWER_EN (21)
+// DIO2 controlls an antenna switch and the TCXO voltage is controlled by DIO3
 #define SX126X_DIO2_AS_RF_SWITCH
 #define SX126X_DIO3_TCXO_VOLTAGE 1.8

@@ -166,6 +159,7 @@ static const uint8_t AREF = PIN_AREF;
 #define P_LORA_DIO_1 SX126X_DIO1
 #define P_LORA_BUSY SX126X_BUSY
 #define P_LORA_RESET SX126X_RESET
+#define P_LORA_PA_EN  31

 // enables 3.3V periphery like GPS or IO Module
 // Do not toggle this for GPS power savings
Author	SHA1	Message	Date
Matthias Wientapper	9e5dbf28b0	Set RAK boot lock voltage to 0V	2026-02-21 19:24:01 +01:00
Matthias Wientapper	b76cfcf0a0	Integration of upstrem PR #1338	2026-02-21 19:24:01 +01:00
Matthias Wientapper	b2304c005c	Integration of upstrem PR #1297	2026-02-21 19:24:01 +01:00
Matthias Wientapper	f9f177522b	Add cli config flood.advert.base 0 = forwarding flood adverts off 1 = forwarding flood adverts on (unrestricted) 0.308 (default) = prob. forwarding according to #1338	2026-01-26 10:35:31 +01:00
Matthias Wientapper	6d3345c50f	Limit flood advert packet forwarding for roomservers as well	2026-01-26 10:35:31 +01:00
Matthias Wientapper	bd4c4cf69d	Limit flood advert packet forwarding, implements #1223	2026-01-26 10:35:31 +01:00