Merge branch 'develop' into InkHUD-Improvements

2026-01-03 00:20:43 +00:00 · 2026-01-01 17:38:48 -05:00 · 2025-12-28 00:24:03 -05:00 · 2025-12-25 22:30:27 -05:00 · 2025-12-21 01:37:27 -05:00 · 2025-12-21 00:33:29 -05:00
32 changed files with 1825 additions and 811 deletions
--- a/.github/workflows/test_native.yml
+++ b/.github/workflows/test_native.yml
@@ -143,7 +143,7 @@ jobs:
          merge-multiple: true

      - name: Test Report
-        uses: dorny/test-reporter@v2.4.0
+        uses: dorny/test-reporter@v2.3.0
        with:
          name: PlatformIO Tests
          path: testreport.xml
--- a/.trunk/trunk.yaml
+++ b/.trunk/trunk.yaml
@@ -8,8 +8,8 @@ plugins:
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.496
-    - renovate@42.66.14
+    - checkov@3.2.495
+    - renovate@42.66.8
    - prettier@3.7.4
    - trufflehog@3.92.4
    - yamllint@1.37.1
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -4,8 +4,8 @@

 | Firmware Version | Supported          |
 | ---------------- | ------------------ |
-| 2.7.x            | :white_check_mark: |
-| <= 2.6.x         | :x:                |
+| 2.6.x            | :white_check_mark: |
+| <= 2.5.x         | :x:                |

 ## Reporting a Vulnerability

--- a/bin/org.meshtastic.meshtasticd.metainfo.xml
+++ b/bin/org.meshtastic.meshtasticd.metainfo.xml
@@ -87,9 +87,6 @@
  </screenshots>

  <releases>
-    <release version="2.7.18" date="2026-01-02">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.18</url>
-    </release>
    <release version="2.7.17" date="2025-11-28">
      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.17</url>
    </release>
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,9 +1,3 @@
-meshtasticd (2.7.18.0) unstable; urgency=medium
-
-  * Version 2.7.18
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Fri, 02 Jan 2026 12:45:36 +0000
-
 meshtasticd (2.7.17.0) unstable; urgency=medium

  * Version 2.7.17
--- a/platformio.ini
+++ b/platformio.ini
@@ -119,7 +119,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/a8e2f947f7abaf0c5ac8e6dd189a22156335beaa.zip
+	https://github.com/meshtastic/device-ui/archive/862ed040c4ab44f0dfbbe492691f144886102588.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
--- a/src/graphics/draw/MenuHandler.cpp
+++ b/src/graphics/draw/MenuHandler.cpp
@@ -107,60 +107,50 @@ void menuHandler::OnboardMessage()

 void menuHandler::LoraRegionPicker(uint32_t duration)
 {
-    static const LoraRegionOption regionOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"US", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_US},
-        {"EU_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_EU_433},
-        {"EU_868", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_EU_868},
-        {"CN", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_CN},
-        {"JP", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_JP},
-        {"ANZ", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ANZ},
-        {"KR", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_KR},
-        {"TW", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_TW},
-        {"RU", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_RU},
-        {"IN", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_IN},
-        {"NZ_865", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_NZ_865},
-        {"TH", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_TH},
-        {"LORA_24", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_LORA_24},
-        {"UA_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_UA_433},
-        {"UA_868", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_UA_868},
-        {"MY_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_MY_433},
-        {"MY_919", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_MY_919},
-        {"SG_923", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_SG_923},
-        {"PH_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_PH_433},
-        {"PH_868", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_PH_868},
-        {"PH_915", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_PH_915},
-        {"ANZ_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ANZ_433},
-        {"KZ_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_KZ_433},
-        {"KZ_863", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_KZ_863},
-        {"NP_865", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_NP_865},
-        {"BR_902", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_BR_902},
-    };
-
-    constexpr size_t regionCount = sizeof(regionOptions) / sizeof(regionOptions[0]);
-    static std::array<const char *, regionCount> regionLabels{};
-
-    const char *bannerMessage = "Set the LoRa region";
+    static const char *optionsArray[] = {"Back",
+                                         "US",
+                                         "EU_433",
+                                         "EU_868",
+                                         "CN",
+                                         "JP",
+                                         "ANZ",
+                                         "KR",
+                                         "TW",
+                                         "RU",
+                                         "IN",
+                                         "NZ_865",
+                                         "TH",
+                                         "LORA_24",
+                                         "UA_433",
+                                         "UA_868",
+                                         "MY_433",
+                                         "MY_"
+                                         "919",
+                                         "SG_"
+                                         "923",
+                                         "PH_433",
+                                         "PH_868",
+                                         "PH_915",
+                                         "ANZ_433",
+                                         "KZ_433",
+                                         "KZ_863",
+                                         "NP_865",
+                                         "BR_902"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Set the LoRa region";
    if (currentResolution == ScreenResolution::UltraLow) {
-        bannerMessage = "LoRa Region";
+        bannerOptions.message = "LoRa Region";
    }
-
-    auto bannerOptions =
-        createStaticBannerOptions(bannerMessage, regionOptions, regionLabels, [](const LoraRegionOption &option, int) -> void {
-            if (!option.hasValue) {
-                return;
-            }
-
-            auto selectedRegion = option.value;
-            if (config.lora.region == selectedRegion) {
-                return;
-            }
-
-            config.lora.region = selectedRegion;
+    bannerOptions.durationMs = duration;
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 27;
+    bannerOptions.InitialSelected = 0;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected != 0 && config.lora.region != _meshtastic_Config_LoRaConfig_RegionCode(selected)) {
+            config.lora.region = _meshtastic_Config_LoRaConfig_RegionCode(selected);
            auto changes = SEGMENT_CONFIG;

-        // FIXME: This should be a method consolidated with the same logic in the admin message as well
-        // This is needed as we wait til picking the LoRa region to generate keys for the first time.
+            // This is needed as we wait til picking the LoRa region to generate keys for the first time.
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
            if (!owner.is_licensed) {
                bool keygenSuccess = false;
@@ -197,19 +187,8 @@ void menuHandler::LoraRegionPicker(uint32_t duration)

            service->reloadConfig(changes);
            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
-        });
-
-    bannerOptions.durationMs = duration;
-
-    int initialSelection = 0;
-    for (size_t i = 0; i < regionCount; ++i) {
-        if (regionOptions[i].hasValue && regionOptions[i].value == config.lora.region) {
-            initialSelection = static_cast<int>(i);
-            break;
        }
-    }
-    bannerOptions.InitialSelected = initialSelection;
-
+    };
    screen->showOverlayBanner(bannerOptions);
 }

@@ -324,100 +303,102 @@ void menuHandler::showConfirmationBanner(const char *message, std::function<void

 void menuHandler::ClockFacePicker()
 {
-    static const ClockFaceOption clockFaceOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"Digital", OptionsAction::Select, false},
-        {"Analog", OptionsAction::Select, true},
+    static const char *optionsArray[] = {"Back", "Digital", "Analog"};
+    enum optionsNumbers { Back = 0, Digital = 1, Analog = 2 };
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Which Face?";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 3;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == Back) {
+            menuHandler::menuQueue = menuHandler::clock_menu;
+            screen->runNow();
+        } else if (selected == Digital) {
+            uiconfig.is_clockface_analog = false;
+            saveUIConfig();
+            screen->setFrames(Screen::FOCUS_CLOCK);
+        } else {
+            uiconfig.is_clockface_analog = true;
+            saveUIConfig();
+            screen->setFrames(Screen::FOCUS_CLOCK);
+        }
    };
-
-    constexpr size_t clockFaceCount = sizeof(clockFaceOptions) / sizeof(clockFaceOptions[0]);
-    static std::array<const char *, clockFaceCount> clockFaceLabels{};
-
-    auto bannerOptions = createStaticBannerOptions("Which Face?", clockFaceOptions, clockFaceLabels,
-                                                   [](const ClockFaceOption &option, int) -> void {
-                                                       if (option.action == OptionsAction::Back) {
-                                                           menuHandler::menuQueue = menuHandler::clock_menu;
-                                                           screen->runNow();
-                                                           return;
-                                                       }
-
-                                                       if (!option.hasValue) {
-                                                           return;
-                                                       }
-
-                                                       if (uiconfig.is_clockface_analog == option.value) {
-                                                           return;
-                                                       }
-
-                                                       uiconfig.is_clockface_analog = option.value;
-                                                       saveUIConfig();
-                                                       screen->setFrames(Screen::FOCUS_CLOCK);
-                                                   });
-
    bannerOptions.InitialSelected = uiconfig.is_clockface_analog ? 2 : 1;
    screen->showOverlayBanner(bannerOptions);
 }

 void menuHandler::TZPicker()
 {
-    static const TimezoneOption timezoneOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"US/Hawaii", OptionsAction::Select, "HST10"},
-        {"US/Alaska", OptionsAction::Select, "AKST9AKDT,M3.2.0,M11.1.0"},
-        {"US/Pacific", OptionsAction::Select, "PST8PDT,M3.2.0,M11.1.0"},
-        {"US/Arizona", OptionsAction::Select, "MST7"},
-        {"US/Mountain", OptionsAction::Select, "MST7MDT,M3.2.0,M11.1.0"},
-        {"US/Central", OptionsAction::Select, "CST6CDT,M3.2.0,M11.1.0"},
-        {"US/Eastern", OptionsAction::Select, "EST5EDT,M3.2.0,M11.1.0"},
-        {"BR/Brasilia", OptionsAction::Select, "BRT3"},
-        {"UTC", OptionsAction::Select, "UTC0"},
-        {"EU/Western", OptionsAction::Select, "GMT0BST,M3.5.0/1,M10.5.0"},
-        {"EU/Central", OptionsAction::Select, "CET-1CEST,M3.5.0,M10.5.0/3"},
-        {"EU/Eastern", OptionsAction::Select, "EET-2EEST,M3.5.0/3,M10.5.0/4"},
-        {"Asia/Kolkata", OptionsAction::Select, "IST-5:30"},
-        {"Asia/Hong_Kong", OptionsAction::Select, "HKT-8"},
-        {"AU/AWST", OptionsAction::Select, "AWST-8"},
-        {"AU/ACST", OptionsAction::Select, "ACST-9:30ACDT,M10.1.0,M4.1.0/3"},
-        {"AU/AEST", OptionsAction::Select, "AEST-10AEDT,M10.1.0,M4.1.0/3"},
-        {"Pacific/NZ", OptionsAction::Select, "NZST-12NZDT,M9.5.0,M4.1.0/3"},
-    };
-
-    constexpr size_t timezoneCount = sizeof(timezoneOptions) / sizeof(timezoneOptions[0]);
-    static std::array<const char *, timezoneCount> timezoneLabels{};
-
-    auto bannerOptions = createStaticBannerOptions(
-        "Pick Timezone", timezoneOptions, timezoneLabels, [](const TimezoneOption &option, int) -> void {
-            if (option.action == OptionsAction::Back) {
-                menuHandler::menuQueue = menuHandler::clock_menu;
-                screen->runNow();
-                return;
-            }
-
-            if (!option.hasValue) {
-                return;
-            }
-
-            if (strncmp(config.device.tzdef, option.value, sizeof(config.device.tzdef)) == 0) {
-                return;
-            }
-
-            strncpy(config.device.tzdef, option.value, sizeof(config.device.tzdef));
-            config.device.tzdef[sizeof(config.device.tzdef) - 1] = '\0';
-
+    static const char *optionsArray[] = {"Back",
+                                         "US/Hawaii",
+                                         "US/Alaska",
+                                         "US/Pacific",
+                                         "US/Arizona",
+                                         "US/Mountain",
+                                         "US/Central",
+                                         "US/Eastern",
+                                         "BR/Brasilia",
+                                         "UTC",
+                                         "EU/Western",
+                                         "EU/"
+                                         "Central",
+                                         "EU/Eastern",
+                                         "Asia/Kolkata",
+                                         "Asia/Hong_Kong",
+                                         "AU/AWST",
+                                         "AU/ACST",
+                                         "AU/AEST",
+                                         "Pacific/NZ"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Pick Timezone";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 19;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == 0) {
+            menuHandler::menuQueue = menuHandler::clock_menu;
+            screen->runNow();
+        } else if (selected == 1) { // Hawaii
+            strncpy(config.device.tzdef, "HST10", sizeof(config.device.tzdef));
+        } else if (selected == 2) { // Alaska
+            strncpy(config.device.tzdef, "AKST9AKDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
+        } else if (selected == 3) { // Pacific
+            strncpy(config.device.tzdef, "PST8PDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
+        } else if (selected == 4) { // Arizona
+            strncpy(config.device.tzdef, "MST7", sizeof(config.device.tzdef));
+        } else if (selected == 5) { // Mountain
+            strncpy(config.device.tzdef, "MST7MDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
+        } else if (selected == 6) { // Central
+            strncpy(config.device.tzdef, "CST6CDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
+        } else if (selected == 7) { // Eastern
+            strncpy(config.device.tzdef, "EST5EDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
+        } else if (selected == 8) { // Brazil
+            strncpy(config.device.tzdef, "BRT3", sizeof(config.device.tzdef));
+        } else if (selected == 9) { // UTC
+            strncpy(config.device.tzdef, "UTC0", sizeof(config.device.tzdef));
+        } else if (selected == 10) { // EU/Western
+            strncpy(config.device.tzdef, "GMT0BST,M3.5.0/1,M10.5.0", sizeof(config.device.tzdef));
+        } else if (selected == 11) { // EU/Central
+            strncpy(config.device.tzdef, "CET-1CEST,M3.5.0,M10.5.0/3", sizeof(config.device.tzdef));
+        } else if (selected == 12) { // EU/Eastern
+            strncpy(config.device.tzdef, "EET-2EEST,M3.5.0/3,M10.5.0/4", sizeof(config.device.tzdef));
+        } else if (selected == 13) { // Asia/Kolkata
+            strncpy(config.device.tzdef, "IST-5:30", sizeof(config.device.tzdef));
+        } else if (selected == 14) { // China
+            strncpy(config.device.tzdef, "HKT-8", sizeof(config.device.tzdef));
+        } else if (selected == 15) { // AU/AWST
+            strncpy(config.device.tzdef, "AWST-8", sizeof(config.device.tzdef));
+        } else if (selected == 16) { // AU/ACST
+            strncpy(config.device.tzdef, "ACST-9:30ACDT,M10.1.0,M4.1.0/3", sizeof(config.device.tzdef));
+        } else if (selected == 17) { // AU/AEST
+            strncpy(config.device.tzdef, "AEST-10AEDT,M10.1.0,M4.1.0/3", sizeof(config.device.tzdef));
+        } else if (selected == 18) { // NZ
+            strncpy(config.device.tzdef, "NZST-12NZDT,M9.5.0,M4.1.0/3", sizeof(config.device.tzdef));
+        }
+        if (selected != 0) {
            setenv("TZ", config.device.tzdef, 1);
            service->reloadConfig(SEGMENT_CONFIG);
-        });
-
-    int initialSelection = 0;
-    for (size_t i = 0; i < timezoneCount; ++i) {
-        if (timezoneOptions[i].hasValue &&
-            strncmp(config.device.tzdef, timezoneOptions[i].value, sizeof(config.device.tzdef)) == 0) {
-            initialSelection = static_cast<int>(i);
-            break;
        }
-    }
-    bannerOptions.InitialSelected = initialSelection;
-
+    };
    screen->showOverlayBanner(bannerOptions);
 }

@@ -477,9 +458,10 @@ void menuHandler::messageResponseMenu()
 #endif

    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Message Action";
    if (currentResolution == ScreenResolution::UltraLow) {
        bannerOptions.message = "Message";
+    } else {
+        bannerOptions.message = "Message Action";
    }
    bannerOptions.optionsArrayPtr = optionsArray;
    bannerOptions.optionsEnumPtr = optionsEnumArray;
@@ -928,12 +910,8 @@ void menuHandler::homeBaseMenu()
        } else if (selected == Sleep) {
            screen->setOn(false);
        } else if (selected == Position) {
-            service->refreshLocalMeshNode();
-            if (service->trySendPosition(NODENUM_BROADCAST, true)) {
-                IF_SCREEN(screen->showSimpleBanner("Position\nSent", 3000));
-            } else {
-                IF_SCREEN(screen->showSimpleBanner("Node Info\nSent", 3000));
-            }
+            InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_SEND_PING, .kbchar = 0, .touchX = 0, .touchY = 0};
+            inputBroker->injectInputEvent(&event);
        } else if (selected == Preset) {
            cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
        } else if (selected == Freetext) {
@@ -1130,92 +1108,57 @@ void menuHandler::favoriteBaseMenu()

 void menuHandler::positionBaseMenu()
 {
-    enum class PositionAction {
-        GpsToggle,
-        GpsFormat,
+    enum optionsNumbers {
+        Back,
+        GPSToggle,
+        GPSFormat,
        CompassMenu,
        CompassCalibrate,
        GPSSmartPosition,
        GPSUpdateInterval,
-        GPSPositionBroadcast
+        GPSPositionBroadcast,
+        enumEnd
    };

-    static const PositionMenuOption baseOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"On/Off Toggle", OptionsAction::Select, static_cast<int>(PositionAction::GpsToggle)},
-        {"Format", OptionsAction::Select, static_cast<int>(PositionAction::GpsFormat)},
-        {"Smart Position", OptionsAction::Select, static_cast<int>(PositionAction::GPSSmartPosition)},
-        {"Update Interval", OptionsAction::Select, static_cast<int>(PositionAction::GPSUpdateInterval)},
-        {"Broadcast Interval", OptionsAction::Select, static_cast<int>(PositionAction::GPSPositionBroadcast)},
-        {"Compass", OptionsAction::Select, static_cast<int>(PositionAction::CompassMenu)},
-    };
+    static const char *optionsArray[enumEnd] = {
+        "Back", "On/Off Toggle", "Format", "Smart Position", "Update Interval", "Broadcast Interval", "Compass"};
+    static int optionsEnumArray[enumEnd] = {
+        Back, GPSToggle, GPSFormat, GPSSmartPosition, GPSUpdateInterval, GPSPositionBroadcast, CompassMenu};
+    int options = 7;

-    static const PositionMenuOption calibrateOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"On/Off Toggle", OptionsAction::Select, static_cast<int>(PositionAction::GpsToggle)},
-        {"Format", OptionsAction::Select, static_cast<int>(PositionAction::GpsFormat)},
-        {"Smart Position", OptionsAction::Select, static_cast<int>(PositionAction::GPSSmartPosition)},
-        {"Update Interval", OptionsAction::Select, static_cast<int>(PositionAction::GPSUpdateInterval)},
-        {"Broadcast Interval", OptionsAction::Select, static_cast<int>(PositionAction::GPSPositionBroadcast)},
-        {"Compass", OptionsAction::Select, static_cast<int>(PositionAction::CompassMenu)},
-        {"Compass Calibrate", OptionsAction::Select, static_cast<int>(PositionAction::CompassCalibrate)},
-    };
-
-    constexpr size_t baseCount = sizeof(baseOptions) / sizeof(baseOptions[0]);
-    constexpr size_t calibrateCount = sizeof(calibrateOptions) / sizeof(calibrateOptions[0]);
-    static std::array<const char *, baseCount> baseLabels{};
-    static std::array<const char *, calibrateCount> calibrateLabels{};
-
-    auto onSelection = [](const PositionMenuOption &option, int) -> void {
-        if (option.action == OptionsAction::Back) {
-            return;
-        }
-
-        if (!option.hasValue) {
-            return;
-        }
-
-        auto action = static_cast<PositionAction>(option.value);
-        switch (action) {
-        case PositionAction::GpsToggle:
-            menuQueue = gps_toggle_menu;
-            screen->runNow();
-            break;
-        case PositionAction::GpsFormat:
-            menuQueue = gps_format_menu;
-            screen->runNow();
-            break;
-        case PositionAction::CompassMenu:
-            menuQueue = compass_point_north_menu;
-            screen->runNow();
-            break;
-        case PositionAction::CompassCalibrate:
-            if (accelerometerThread) {
-                accelerometerThread->calibrate(30);
-            }
-            break;
-        case PositionAction::GPSSmartPosition:
-            menuQueue = gps_smart_position_menu;
-            screen->runNow();
-            break;
-        case PositionAction::GPSUpdateInterval:
-            menuQueue = gps_update_interval_menu;
-            screen->runNow();
-            break;
-        case PositionAction::GPSPositionBroadcast:
-            menuQueue = gps_position_broadcast_menu;
-            screen->runNow();
-            break;
-        }
-    };
-
-    BannerOverlayOptions bannerOptions;
    if (accelerometerThread) {
-        bannerOptions = createStaticBannerOptions("GPS Action", calibrateOptions, calibrateLabels, onSelection);
-    } else {
-        bannerOptions = createStaticBannerOptions("GPS Action", baseOptions, baseLabels, onSelection);
+        optionsArray[options] = "Compass Calibrate";
+        optionsEnumArray[options++] = CompassCalibrate;
    }

+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "GPS Action";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsEnumPtr = optionsEnumArray;
+    bannerOptions.optionsCount = options;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == GPSToggle) {
+            menuQueue = gps_toggle_menu;
+            screen->runNow();
+        } else if (selected == GPSFormat) {
+            menuQueue = gps_format_menu;
+            screen->runNow();
+        } else if (selected == CompassMenu) {
+            menuQueue = compass_point_north_menu;
+            screen->runNow();
+        } else if (selected == CompassCalibrate) {
+            accelerometerThread->calibrate(30);
+        } else if (selected == GPSSmartPosition) {
+            menuQueue = gps_smart_position_menu;
+            screen->runNow();
+        } else if (selected == GPSUpdateInterval) {
+            menuQueue = gps_update_interval_menu;
+            screen->runNow();
+        } else if (selected == GPSPositionBroadcast) {
+            menuQueue = gps_position_broadcast_menu;
+            screen->runNow();
+        }
+    };
    screen->showOverlayBanner(bannerOptions);
 }

@@ -1271,38 +1214,27 @@ void menuHandler::nodeListMenu()

 void menuHandler::nodeNameLengthMenu()
 {
-    static const NodeNameOption nodeNameOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"Long", OptionsAction::Select, true},
-        {"Short", OptionsAction::Select, false},
+    enum OptionsNumbers { Back, Long, Short };
+    static const char *optionsArray[] = {"Back", "Long", "Short"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Node Name Length";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 3;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == Long) {
+            // Set names to long
+            LOG_INFO("Setting names to long");
+            config.display.use_long_node_name = true;
+        } else if (selected == Short) {
+            // Set names to short
+            LOG_INFO("Setting names to short");
+            config.display.use_long_node_name = false;
+        } else if (selected == Back) {
+            menuQueue = node_base_menu;
+            screen->runNow();
+        }
    };
-
-    constexpr size_t nodeNameCount = sizeof(nodeNameOptions) / sizeof(nodeNameOptions[0]);
-    static std::array<const char *, nodeNameCount> nodeNameLabels{};
-
-    auto bannerOptions = createStaticBannerOptions("Node Name Length", nodeNameOptions, nodeNameLabels,
-                                                   [](const NodeNameOption &option, int) -> void {
-                                                       if (option.action == OptionsAction::Back) {
-                                                           menuQueue = node_base_menu;
-                                                           screen->runNow();
-                                                           return;
-                                                       }
-
-                                                       if (!option.hasValue) {
-                                                           return;
-                                                       }
-
-                                                       if (config.display.use_long_node_name == option.value) {
-                                                           return;
-                                                       }
-
-                                                       config.display.use_long_node_name = option.value;
-                                                       LOG_INFO("Setting names to %s", option.value ? "long" : "short");
-                                                   });
-
-    int initialSelection = config.display.use_long_node_name ? 1 : 2;
-    bannerOptions.InitialSelected = initialSelection;
-
+    bannerOptions.InitialSelected = config.display.use_long_node_name == true ? 1 : 2;
    screen->showOverlayBanner(bannerOptions);
 }

@@ -1336,169 +1268,119 @@ void menuHandler::resetNodeDBMenu()

 void menuHandler::compassNorthMenu()
 {
-    static const CompassOption compassOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"Dynamic", OptionsAction::Select, meshtastic_CompassMode_DYNAMIC},
-        {"Fixed Ring", OptionsAction::Select, meshtastic_CompassMode_FIXED_RING},
-        {"Freeze Heading", OptionsAction::Select, meshtastic_CompassMode_FREEZE_HEADING},
-    };
-
-    constexpr size_t compassCount = sizeof(compassOptions) / sizeof(compassOptions[0]);
-    static std::array<const char *, compassCount> compassLabels{};
-
-    auto bannerOptions = createStaticBannerOptions("North Directions?", compassOptions, compassLabels,
-                                                   [](const CompassOption &option, int) -> void {
-                                                       if (option.action == OptionsAction::Back) {
-                                                           menuQueue = position_base_menu;
-                                                           screen->runNow();
-                                                           return;
-                                                       }
-
-                                                       if (!option.hasValue) {
-                                                           return;
-                                                       }
-
-                                                       if (uiconfig.compass_mode == option.value) {
-                                                           return;
-                                                       }
-
-                                                       uiconfig.compass_mode = option.value;
-                                                       saveUIConfig();
-                                                       screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
-                                                   });
-
-    int initialSelection = 0;
-    for (size_t i = 0; i < compassCount; ++i) {
-        if (compassOptions[i].hasValue && uiconfig.compass_mode == compassOptions[i].value) {
-            initialSelection = static_cast<int>(i);
-            break;
+    enum optionsNumbers { Back, Dynamic, Fixed, Freeze };
+    static const char *optionsArray[] = {"Back", "Dynamic", "Fixed Ring", "Freeze Heading"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "North Directions?";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 4;
+    bannerOptions.InitialSelected = uiconfig.compass_mode + 1;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == Dynamic) {
+            if (uiconfig.compass_mode != meshtastic_CompassMode_DYNAMIC) {
+                uiconfig.compass_mode = meshtastic_CompassMode_DYNAMIC;
+                saveUIConfig();
+                screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
+            }
+        } else if (selected == Fixed) {
+            if (uiconfig.compass_mode != meshtastic_CompassMode_FIXED_RING) {
+                uiconfig.compass_mode = meshtastic_CompassMode_FIXED_RING;
+                saveUIConfig();
+                screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
+            }
+        } else if (selected == Freeze) {
+            if (uiconfig.compass_mode != meshtastic_CompassMode_FREEZE_HEADING) {
+                uiconfig.compass_mode = meshtastic_CompassMode_FREEZE_HEADING;
+                saveUIConfig();
+                screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
+            }
+        } else if (selected == Back) {
+            menuQueue = position_base_menu;
+            screen->runNow();
        }
-    }
-    bannerOptions.InitialSelected = initialSelection;
-
+    };
    screen->showOverlayBanner(bannerOptions);
 }

 #if !MESHTASTIC_EXCLUDE_GPS
 void menuHandler::GPSToggleMenu()
 {
-    static const GPSToggleOption gpsToggleOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"Enabled", OptionsAction::Select, meshtastic_Config_PositionConfig_GpsMode_ENABLED},
-        {"Disabled", OptionsAction::Select, meshtastic_Config_PositionConfig_GpsMode_DISABLED},
-    };

-    constexpr size_t toggleCount = sizeof(gpsToggleOptions) / sizeof(gpsToggleOptions[0]);
-    static std::array<const char *, toggleCount> toggleLabels{};
-
-    auto bannerOptions =
-        createStaticBannerOptions("Toggle GPS", gpsToggleOptions, toggleLabels, [](const GPSToggleOption &option, int) -> void {
-            if (option.action == OptionsAction::Back) {
-                menuQueue = position_base_menu;
-                screen->runNow();
-                return;
-            }
-
-            if (!option.hasValue) {
-                return;
-            }
-
-            if (config.position.gps_mode == option.value) {
-                return;
-            }
-
-            config.position.gps_mode = option.value;
-            if (option.value == meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
-                playGPSEnableBeep();
-                gps->enable();
-            } else {
-                playGPSDisableBeep();
-                gps->disable();
-            }
+    static const char *optionsArray[] = {"Back", "Enabled", "Disabled"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Toggle GPS";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 3;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == 1) {
+            config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_ENABLED;
+            playGPSEnableBeep();
+            gps->enable();
            service->reloadConfig(SEGMENT_CONFIG);
-        });
-
-    int initialSelection = 0;
-    for (size_t i = 0; i < toggleCount; ++i) {
-        if (gpsToggleOptions[i].hasValue && config.position.gps_mode == gpsToggleOptions[i].value) {
-            initialSelection = static_cast<int>(i);
-            break;
+        } else if (selected == 2) {
+            config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_DISABLED;
+            playGPSDisableBeep();
+            gps->disable();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else {
+            menuQueue = position_base_menu;
+            screen->runNow();
        }
-    }
-    bannerOptions.InitialSelected = initialSelection;
-
+    };
+    bannerOptions.InitialSelected = config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED ? 1 : 2;
    screen->showOverlayBanner(bannerOptions);
 }
 void menuHandler::GPSFormatMenu()
 {
-    static const GPSFormatOption formatOptionsHigh[] = {
-        {"Back", OptionsAction::Back},
-        {"Decimal Degrees", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC},
-        {"Degrees Minutes Seconds", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS},
-        {"Universal Transverse Mercator", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM},
-        {"Military Grid Reference System", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS},
-        {"Open Location Code", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC},
-        {"Ordnance Survey Grid Ref", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR},
-        {"Maidenhead Locator", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS},
-    };

-    static const GPSFormatOption formatOptionsLow[] = {
-        {"Back", OptionsAction::Back},
-        {"DEC", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC},
-        {"DMS", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS},
-        {"UTM", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM},
-        {"MGRS", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS},
-        {"OLC", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC},
-        {"OSGR", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR},
-        {"MLS", OptionsAction::Select, meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS},
-    };
-
-    constexpr size_t formatCount = sizeof(formatOptionsHigh) / sizeof(formatOptionsHigh[0]);
-    static std::array<const char *, formatCount> formatLabelsHigh{};
-    static std::array<const char *, formatCount> formatLabelsLow{};
-
-    auto onSelection = [](const GPSFormatOption &option, int) -> void {
-        if (option.action == OptionsAction::Back) {
+    static const char *optionsArray[] = {"Back",
+                                         (currentResolution == ScreenResolution::High) ? "Decimal Degrees" : "DEC",
+                                         (currentResolution == ScreenResolution::High) ? "Degrees Minutes Seconds" : "DMS",
+                                         (currentResolution == ScreenResolution::High) ? "Universal Transverse Mercator" : "UTM",
+                                         (currentResolution == ScreenResolution::High) ? "Military Grid Reference System"
+                                                                                       : "MGRS",
+                                         (currentResolution == ScreenResolution::High) ? "Open Location Code" : "OLC",
+                                         (currentResolution == ScreenResolution::High) ? "Ordnance Survey Grid Ref" : "OSGR",
+                                         (currentResolution == ScreenResolution::High) ? "Maidenhead Locator" : "MLS"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "GPS Format";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 8;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == 1) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == 2) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == 3) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == 4) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == 5) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == 6) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == 7) {
+            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS;
+            saveUIConfig();
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else {
            menuQueue = position_base_menu;
            screen->runNow();
-            return;
        }
-
-        if (!option.hasValue) {
-            return;
-        }
-
-        if (uiconfig.gps_format == option.value) {
-            return;
-        }
-
-        uiconfig.gps_format = option.value;
-        saveUIConfig();
-        service->reloadConfig(SEGMENT_CONFIG);
    };
-
-    BannerOverlayOptions bannerOptions;
-    int initialSelection = 0;
-
-    if (currentResolution == ScreenResolution::High) {
-        bannerOptions = createStaticBannerOptions("GPS Format", formatOptionsHigh, formatLabelsHigh, onSelection);
-        for (size_t i = 0; i < formatCount; ++i) {
-            if (formatOptionsHigh[i].hasValue && uiconfig.gps_format == formatOptionsHigh[i].value) {
-                initialSelection = static_cast<int>(i);
-                break;
-            }
-        }
-    } else {
-        bannerOptions = createStaticBannerOptions("GPS Format", formatOptionsLow, formatLabelsLow, onSelection);
-        for (size_t i = 0; i < formatCount; ++i) {
-            if (formatOptionsLow[i].hasValue && uiconfig.gps_format == formatOptionsLow[i].value) {
-                initialSelection = static_cast<int>(i);
-                break;
-            }
-        }
-    }
-
-    bannerOptions.InitialSelected = initialSelection;
+    bannerOptions.InitialSelected = uiconfig.gps_format + 1;
    screen->showOverlayBanner(bannerOptions);
 }

@@ -1819,63 +1701,100 @@ void menuHandler::switchToMUIMenu()

 void menuHandler::TFTColorPickerMenu(OLEDDisplay *display)
 {
-    static const ScreenColorOption colorOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"Default", OptionsAction::Select, ScreenColor(0, 0, 0, true)},
-        {"Meshtastic Green", OptionsAction::Select, ScreenColor(103, 234, 148)},
-        {"Yellow", OptionsAction::Select, ScreenColor(255, 255, 128)},
-        {"Red", OptionsAction::Select, ScreenColor(255, 64, 64)},
-        {"Orange", OptionsAction::Select, ScreenColor(255, 160, 20)},
-        {"Purple", OptionsAction::Select, ScreenColor(204, 153, 255)},
-        {"Blue", OptionsAction::Select, ScreenColor(0, 0, 255)},
-        {"Teal", OptionsAction::Select, ScreenColor(16, 102, 102)},
-        {"Cyan", OptionsAction::Select, ScreenColor(0, 255, 255)},
-        {"Ice", OptionsAction::Select, ScreenColor(173, 216, 230)},
-        {"Pink", OptionsAction::Select, ScreenColor(255, 105, 180)},
-        {"White", OptionsAction::Select, ScreenColor(255, 255, 255)},
-        {"Gray", OptionsAction::Select, ScreenColor(128, 128, 128)},
-    };
-
-    constexpr size_t colorCount = sizeof(colorOptions) / sizeof(colorOptions[0]);
-    static std::array<const char *, colorCount> colorLabels{};
-
-    auto bannerOptions = createStaticBannerOptions(
-        "Select Screen Color", colorOptions, colorLabels, [display](const ScreenColorOption &option, int) -> void {
-            if (option.action == OptionsAction::Back) {
-                menuQueue = system_base_menu;
-                screen->runNow();
-                return;
-            }
-
-            if (!option.hasValue) {
-                return;
-            }
-
+    static const char *optionsArray[] = {
+        "Back",  "Default", "Meshtastic Green", "Yellow", "Red", "Orange", "Purple", "Blue", "Teal", "Cyan", "Ice", "Pink",
+        "White", "Gray"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Select Screen Color";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 14;
+    bannerOptions.bannerCallback = [display](int selected) -> void {
 #if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || defined(T_DECK) || defined(T_LORA_PAGER) ||          \
    HAS_TFT || defined(HACKADAY_COMMUNICATOR)
-            const ScreenColor &color = option.value;
-            if (color.useVariant) {
-                LOG_INFO("Setting color to system default or defined variant");
-            } else {
-                LOG_INFO("Setting color to %s", option.label);
-            }
-
-            uint8_t r = color.r;
-            uint8_t g = color.g;
-            uint8_t b = color.b;
+        uint8_t TFT_MESH_r = 0;
+        uint8_t TFT_MESH_g = 0;
+        uint8_t TFT_MESH_b = 0;
+        if (selected == 1) {
+            LOG_INFO("Setting color to system default or defined variant");
+            // Given just before we set all these to zero, we will allow this to go through
+        } else if (selected == 2) {
+            LOG_INFO("Setting color to Meshtastic Green");
+            TFT_MESH_r = 103;
+            TFT_MESH_g = 234;
+            TFT_MESH_b = 148;
+        } else if (selected == 3) {
+            LOG_INFO("Setting color to Yellow");
+            TFT_MESH_r = 255;
+            TFT_MESH_g = 255;
+            TFT_MESH_b = 128;
+        } else if (selected == 4) {
+            LOG_INFO("Setting color to Red");
+            TFT_MESH_r = 255;
+            TFT_MESH_g = 64;
+            TFT_MESH_b = 64;
+        } else if (selected == 5) {
+            LOG_INFO("Setting color to Orange");
+            TFT_MESH_r = 255;
+            TFT_MESH_g = 160;
+            TFT_MESH_b = 20;
+        } else if (selected == 6) {
+            LOG_INFO("Setting color to Purple");
+            TFT_MESH_r = 204;
+            TFT_MESH_g = 153;
+            TFT_MESH_b = 255;
+        } else if (selected == 7) {
+            LOG_INFO("Setting color to Blue");
+            TFT_MESH_r = 0;
+            TFT_MESH_g = 0;
+            TFT_MESH_b = 255;
+        } else if (selected == 8) {
+            LOG_INFO("Setting color to Teal");
+            TFT_MESH_r = 16;
+            TFT_MESH_g = 102;
+            TFT_MESH_b = 102;
+        } else if (selected == 9) {
+            LOG_INFO("Setting color to Cyan");
+            TFT_MESH_r = 0;
+            TFT_MESH_g = 255;
+            TFT_MESH_b = 255;
+        } else if (selected == 10) {
+            LOG_INFO("Setting color to Ice");
+            TFT_MESH_r = 173;
+            TFT_MESH_g = 216;
+            TFT_MESH_b = 230;
+        } else if (selected == 11) {
+            LOG_INFO("Setting color to Pink");
+            TFT_MESH_r = 255;
+            TFT_MESH_g = 105;
+            TFT_MESH_b = 180;
+        } else if (selected == 12) {
+            LOG_INFO("Setting color to White");
+            TFT_MESH_r = 255;
+            TFT_MESH_g = 255;
+            TFT_MESH_b = 255;
+        } else if (selected == 13) {
+            LOG_INFO("Setting color to Gray");
+            TFT_MESH_r = 128;
+            TFT_MESH_g = 128;
+            TFT_MESH_b = 128;
+        } else {
+            menuQueue = system_base_menu;
+            screen->runNow();
+        }

+        if (selected != 0) {
            display->setColor(BLACK);
            display->fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
            display->setColor(WHITE);

-            if (color.useVariant || (r == 0 && g == 0 && b == 0)) {
+            if (TFT_MESH_r == 0 && TFT_MESH_g == 0 && TFT_MESH_b == 0) {
 #ifdef TFT_MESH_OVERRIDE
                TFT_MESH = TFT_MESH_OVERRIDE;
 #else
                TFT_MESH = COLOR565(0x67, 0xEA, 0x94);
 #endif
            } else {
-                TFT_MESH = COLOR565(r, g, b);
+                TFT_MESH = COLOR565(TFT_MESH_r, TFT_MESH_g, TFT_MESH_b);
            }

 #if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190)
@@ -1883,40 +1802,16 @@ void menuHandler::TFTColorPickerMenu(OLEDDisplay *display)
 #endif

            screen->setFrames(graphics::Screen::FOCUS_SYSTEM);
-            if (color.useVariant || (r == 0 && g == 0 && b == 0)) {
+            if (TFT_MESH_r == 0 && TFT_MESH_g == 0 && TFT_MESH_b == 0) {
                uiconfig.screen_rgb_color = 0;
            } else {
-                uiconfig.screen_rgb_color =
-                    (static_cast<uint32_t>(r) << 16) | (static_cast<uint32_t>(g) << 8) | static_cast<uint32_t>(b);
+                uiconfig.screen_rgb_color = (TFT_MESH_r << 16) | (TFT_MESH_g << 8) | TFT_MESH_b;
            }
            LOG_INFO("Storing Value of %d to uiconfig.screen_rgb_color", uiconfig.screen_rgb_color);
            saveUIConfig();
-#endif
-        });
-
-    int initialSelection = 0;
-    if (uiconfig.screen_rgb_color == 0) {
-        initialSelection = 1;
-    } else {
-        uint32_t currentColor = uiconfig.screen_rgb_color;
-        for (size_t i = 0; i < colorCount; ++i) {
-            if (!colorOptions[i].hasValue) {
-                continue;
-            }
-            const ScreenColor &color = colorOptions[i].value;
-            if (color.useVariant) {
-                continue;
-            }
-            uint32_t encoded =
-                (static_cast<uint32_t>(color.r) << 16) | (static_cast<uint32_t>(color.g) << 8) | static_cast<uint32_t>(color.b);
-            if (encoded == currentColor) {
-                initialSelection = static_cast<int>(i);
-                break;
-            }
        }
-    }
-    bannerOptions.InitialSelected = initialSelection;
-
+#endif
+    };
    screen->showOverlayBanner(bannerOptions);
 }

--- a/src/graphics/draw/MenuHandler.h
+++ b/src/graphics/draw/MenuHandler.h
@@ -128,28 +128,7 @@ template <typename T> struct MenuOption {
    MenuOption(const char *labelIn, OptionsAction actionIn) : label(labelIn), action(actionIn), hasValue(false), value() {}
 };

-struct ScreenColor {
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-    bool useVariant;
-
-    ScreenColor(uint8_t rIn = 0, uint8_t gIn = 0, uint8_t bIn = 0, bool variantIn = false)
-        : r(rIn), g(gIn), b(bIn), useVariant(variantIn)
-    {
-    }
-};
-
 using RadioPresetOption = MenuOption<meshtastic_Config_LoRaConfig_ModemPreset>;
-using LoraRegionOption = MenuOption<meshtastic_Config_LoRaConfig_RegionCode>;
-using TimezoneOption = MenuOption<const char *>;
-using CompassOption = MenuOption<meshtastic_CompassMode>;
-using ScreenColorOption = MenuOption<ScreenColor>;
-using GPSToggleOption = MenuOption<meshtastic_Config_PositionConfig_GpsMode>;
-using GPSFormatOption = MenuOption<meshtastic_DeviceUIConfig_GpsCoordinateFormat>;
-using NodeNameOption = MenuOption<bool>;
-using PositionMenuOption = MenuOption<int>;
-using ClockFaceOption = MenuOption<bool>;

 } // namespace graphics
 #endif
--- a/src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.cpp
@@ -155,6 +155,18 @@ void InkHUD::LogoApplet::onShutdown()
    // This is then drawn by InkHUD::Events::onShutdown, with a blocking FULL update, after InkHUD's flash write is complete
 }

+void InkHUD::LogoApplet::onApplyingChanges()
+{
+    bringToForeground();
+
+    textLeft = "";
+    textRight = "";
+    textTitle = "Applying changes";
+    fontTitle = fontSmall;
+
+    inkhud->forceUpdate(Drivers::EInk::FAST, false);
+}
+
 void InkHUD::LogoApplet::onReboot()
 {
    bringToForeground();
--- a/src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.h
@@ -26,6 +26,7 @@ class LogoApplet : public SystemApplet, public concurrency::OSThread
    void onBackground() override;
    void onShutdown() override;
    void onReboot() override;
+    void onApplyingChanges();

  protected:
    int32_t runOnce() override;
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h
@@ -22,6 +22,7 @@ enum MenuAction {
    STORE_CANNEDMESSAGE_SELECTION,
    SEND_CANNEDMESSAGE,
    SHUTDOWN,
+    BACK,
    NEXT_TILE,
    TOGGLE_BACKLIGHT,
    TOGGLE_GPS,
@@ -36,6 +37,84 @@ enum MenuAction {
    TOGGLE_NOTIFICATIONS,
    TOGGLE_INVERT_COLOR,
    TOGGLE_12H_CLOCK,
+    // Regions
+    SET_REGION_US,
+    SET_REGION_EU_868,
+    SET_REGION_EU_433,
+    SET_REGION_CN,
+    SET_REGION_JP,
+    SET_REGION_ANZ,
+    SET_REGION_KR,
+    SET_REGION_TW,
+    SET_REGION_RU,
+    SET_REGION_IN,
+    SET_REGION_NZ_865,
+    SET_REGION_TH,
+    SET_REGION_LORA_24,
+    SET_REGION_UA_433,
+    SET_REGION_UA_868,
+    SET_REGION_MY_433,
+    SET_REGION_MY_919,
+    SET_REGION_SG_923,
+    SET_REGION_PH_433,
+    SET_REGION_PH_868,
+    SET_REGION_PH_915,
+    SET_REGION_ANZ_433,
+    SET_REGION_KZ_433,
+    SET_REGION_KZ_863,
+    SET_REGION_NP_865,
+    SET_REGION_BR_902,
+    // Device Roles
+    SET_ROLE_CLIENT,
+    SET_ROLE_CLIENT_MUTE,
+    SET_ROLE_ROUTER,
+    SET_ROLE_REPEATER,
+    // Presets
+    SET_PRESET_LONG_SLOW,
+    SET_PRESET_LONG_MODERATE,
+    SET_PRESET_LONG_FAST,
+    SET_PRESET_MEDIUM_SLOW,
+    SET_PRESET_MEDIUM_FAST,
+    SET_PRESET_SHORT_SLOW,
+    SET_PRESET_SHORT_FAST,
+    SET_PRESET_SHORT_TURBO,
+    // Timezones
+    SET_TZ_US_HAWAII,
+    SET_TZ_US_ALASKA,
+    SET_TZ_US_PACIFIC,
+    SET_TZ_US_ARIZONA,
+    SET_TZ_US_MOUNTAIN,
+    SET_TZ_US_CENTRAL,
+    SET_TZ_US_EASTERN,
+    SET_TZ_BR_BRAZILIA,
+    SET_TZ_UTC,
+    SET_TZ_EU_WESTERN,
+    SET_TZ_EU_CENTRAL,
+    SET_TZ_EU_EASTERN,
+    SET_TZ_ASIA_KOLKATA,
+    SET_TZ_ASIA_HONG_KONG,
+    SET_TZ_AU_AWST,
+    SET_TZ_AU_ACST,
+    SET_TZ_AU_AEST,
+    SET_TZ_PACIFIC_NZ,
+    // Power
+    TOGGLE_POWER_SAVE,
+    CALIBRATE_ADC,
+    // Bluetooth
+    TOGGLE_BLUETOOTH,
+    TOGGLE_BLUETOOTH_PAIR_MODE,
+    // Channel
+    TOGGLE_CHANNEL_UPLINK,
+    TOGGLE_CHANNEL_DOWNLINK,
+    TOGGLE_CHANNEL_POSITION,
+    SET_CHANNEL_PRECISION,
+    // Display
+    TOGGLE_DISPLAY_UNITS,
+    // Network
+    TOGGLE_WIFI,
+    // Administration
+    RESET_NODEDB_ALL,
+    RESET_NODEDB_KEEP_FAVORITES,
 };

 } // namespace NicheGraphics::InkHUD
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h
@@ -35,6 +35,7 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
    void onRender() override;

    void show(Tile *t); // Open the menu, onto a user tile
+    void setStartPage(MenuPage page);

  protected:
    Drivers::LatchingBacklight *backlight = nullptr; // Convenient access to the backlight singleton
@@ -56,6 +57,7 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
    void sendText(NodeNum dest, ChannelIndex channel, const char *message); // Send a text message to mesh
    void freeCannedMessageResources();                                      // Clear MenuApplet's canned message processing data

+    MenuPage startPageOverride = MenuPage::ROOT;
    MenuPage currentPage = MenuPage::ROOT;
    MenuPage previousPage = MenuPage::EXIT;
    uint8_t cursor = 0;       // Which menu item is currently highlighted
@@ -63,7 +65,14 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread

    uint16_t systemInfoPanelHeight = 0; // Need to know before we render

-    std::vector<MenuItem> items; // MenuItems for the current page. Filled by ShowPage
+    std::vector<MenuItem> items;               // MenuItems for the current page. Filled by ShowPage
+    std::vector<std::string> nodeConfigLabels; // Persistent labels for Node Config pages
+    uint8_t selectedChannelIndex = 0;          // Currently selected LoRa channel (Node Config → Radio → Channel)
+    bool channelPositionEnabled = false;
+
+    // Recents menu checkbox state (derived from settings.recentlyActiveSeconds)
+    static constexpr uint8_t RECENTS_COUNT = 6;
+    bool recentsSelected[RECENTS_COUNT] = {};

    // Data for selecting and sending canned messages via the menu
    // Placed into a sub-class for organization only
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuItem.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuItem.h
@@ -30,6 +30,7 @@ class MenuItem
    MenuAction action = NO_ACTION;
    MenuPage nextPage = EXIT;
    bool *checkState = nullptr;
+    bool isHeader = false; // Non-selectable section label

    // Various constructors, depending on the intended function of the item

@@ -40,6 +41,12 @@ class MenuItem
        : label(label), action(action), nextPage(nextPage), checkState(checkState)
    {
    }
+    static MenuItem Header(const char *label)
+    {
+        MenuItem item(label, NO_ACTION, EXIT);
+        item.isHeader = true;
+        return item;
+    }
 };

 } // namespace NicheGraphics::InkHUD
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuPage.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuPage.h
@@ -20,10 +20,27 @@ enum MenuPage : uint8_t {
    SEND,
    CANNEDMESSAGE_RECIPIENT, // Select destination for a canned message
    OPTIONS,
+    NODE_CONFIG,
+    NODE_CONFIG_LORA,
+    NODE_CONFIG_CHANNELS,       // List of channels
+    NODE_CONFIG_CHANNEL_DETAIL, // Per-channel options
+    NODE_CONFIG_CHANNEL_PRECISION,
+    NODE_CONFIG_PRESET,
+    NODE_CONFIG_DEVICE,
+    NODE_CONFIG_DEVICE_ROLE,
+    NODE_CONFIG_POWER,
+    NODE_CONFIG_POWER_ADC_CAL,
+    NODE_CONFIG_NETWORK,
+    NODE_CONFIG_DISPLAY,
+    NODE_CONFIG_BLUETOOTH,
+    NODE_CONFIG_POSITION,
+    NODE_CONFIG_ADMIN_RESET,
+    TIMEZONE,
    APPLETS,
    AUTOSHOW,
    RECENTS, // Select length of "recentlyActiveSeconds"
-    EXIT,    // Dismiss the menu applet
+    REGION,
+    EXIT, // Dismiss the menu applet
 };

 } // namespace NicheGraphics::InkHUD
--- a/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp
@@ -10,34 +10,37 @@ using namespace NicheGraphics;

 InkHUD::TipsApplet::TipsApplet()
 {
-    // Decide which tips (if any) should be shown to user after the boot screen
+    bool needsRegion = (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET);
+
+    bool showTutorialTips = (settings->tips.firstBoot || needsRegion);

    // Welcome screen
-    if (settings->tips.firstBoot)
+    if (showTutorialTips)
        tipQueue.push_back(Tip::WELCOME);

-    // Antenna, region, timezone
-    // Shown at boot if region not yet set
-    if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET)
+    // Finish setup
+    if (needsRegion)
        tipQueue.push_back(Tip::FINISH_SETUP);

+    // Using the UI
+    if (showTutorialTips) {
+        tipQueue.push_back(Tip::CUSTOMIZATION);
+        tipQueue.push_back(Tip::BUTTONS);
+    }
+
    // Shutdown info
    // Shown until user performs one valid shutdown
    if (!settings->tips.safeShutdownSeen)
        tipQueue.push_back(Tip::SAFE_SHUTDOWN);

-    // Using the UI
-    if (settings->tips.firstBoot) {
-        tipQueue.push_back(Tip::CUSTOMIZATION);
-        tipQueue.push_back(Tip::BUTTONS);
-    }
-
    // Catch an incorrect attempt at rotating display
    if (config.display.flip_screen)
        tipQueue.push_back(Tip::ROTATION);

-    // Applet is foreground immediately at boot, but is obscured by LogoApplet, which is also foreground
-    // LogoApplet can be considered to have a higher Z-index, because it is placed before TipsApplet in the systemApplets vector
+    // Region picker
+    if (needsRegion)
+        tipQueue.push_back(Tip::PICK_REGION);
+
    if (!tipQueue.empty())
        bringToForeground();
 }
@@ -51,81 +54,109 @@ void InkHUD::TipsApplet::onRender()

    case Tip::FINISH_SETUP: {
        setFont(fontMedium);
-        printAt(0, 0, "Tip: Finish Setup");
+        const char *title = "Tip: Finish Setup";
+        uint16_t h = getWrappedTextHeight(0, width(), title);
+        printWrapped(0, 0, width(), title);

        setFont(fontSmall);
-        int16_t cursorY = fontMedium.lineHeight() * 1.5;
-        printAt(0, cursorY, "- connect antenna");
+        int16_t cursorY = h + fontSmall.lineHeight();

-        cursorY += fontSmall.lineHeight() * 1.2;
-        printAt(0, cursorY, "- connect a client app");
+        auto drawBullet = [&](const char *text) {
+            uint16_t bh = getWrappedTextHeight(0, width(), text);
+            printWrapped(0, cursorY, width(), text);
+            cursorY += bh + (fontSmall.lineHeight() / 3);
+        };

-        // Only if region not set
-        if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-            cursorY += fontSmall.lineHeight() * 1.2;
-            printAt(0, cursorY, "- set region");
-        }
+        drawBullet("- connect antenna");
+        drawBullet("- connect a client app");

-        // Only if tz not set
-        if (!(*config.device.tzdef && config.device.tzdef[0] != 0)) {
-            cursorY += fontSmall.lineHeight() * 1.2;
-            printAt(0, cursorY, "- set timezone");
-        }
+        if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET)
+            drawBullet("- set region");

-        cursorY += fontSmall.lineHeight() * 1.5;
-        printAt(0, cursorY, "More info at meshtastic.org");
+        if (!(*config.device.tzdef && config.device.tzdef[0] != 0))
+            drawBullet("- set timezone");
+
+        cursorY += fontSmall.lineHeight() / 2;
+        drawBullet("More info at meshtastic.org");

-        setFont(fontSmall);
        printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
    } break;

+    case Tip::PICK_REGION: {
+        setFont(fontMedium);
+        printAt(0, 0, "Set Region");
+
+        setFont(fontSmall);
+        printWrapped(0, fontMedium.lineHeight() * 1.5, width(), "Please select your LoRa region to complete setup.");
+
+        printAt(0, Y(1.0), "Press button to choose", LEFT, BOTTOM);
+    } break;
+
    case Tip::SAFE_SHUTDOWN: {
        setFont(fontMedium);
-        printAt(0, 0, "Tip: Shutdown");
+
+        const char *title = "Tip: Shutdown";
+        uint16_t h = getWrappedTextHeight(0, width(), title);
+        printWrapped(0, 0, width(), title);

        setFont(fontSmall);
-        std::string shutdown;
-        shutdown += "Before removing power, please shut down from InkHUD menu, or a client app. \n";
-        shutdown += "\n";
-        shutdown += "This ensures data is saved.";
-        printWrapped(0, fontMedium.lineHeight() * 1.5, width(), shutdown);
+        int16_t cursorY = h + fontSmall.lineHeight();
+
+        const char *body = "Before removing power, please shut down from InkHUD menu, or a client app.\n\n"
+                           "This ensures data is saved.";
+
+        uint16_t bodyH = getWrappedTextHeight(0, width(), body);
+        printWrapped(0, cursorY, width(), body);
+        cursorY += bodyH + (fontSmall.lineHeight() / 2);

        printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
-
    } break;

    case Tip::CUSTOMIZATION: {
        setFont(fontMedium);
-        printAt(0, 0, "Tip: Customization");
+
+        const char *title = "Tip: Customization";
+        uint16_t h = getWrappedTextHeight(0, width(), title);
+        printWrapped(0, 0, width(), title);

        setFont(fontSmall);
-        printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
-                     "Configure & control display with the InkHUD menu. Optional features, layout, rotation, and more.");
+        int16_t cursorY = h + fontSmall.lineHeight();
+
+        const char *body = "Configure & control display with the InkHUD menu. "
+                           "Optional features, layout, rotation, and more.";
+
+        uint16_t bodyH = getWrappedTextHeight(0, width(), body);
+        printWrapped(0, cursorY, width(), body);
+        cursorY += bodyH + (fontSmall.lineHeight() / 2);

        printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
    } break;

    case Tip::BUTTONS: {
        setFont(fontMedium);
-        printAt(0, 0, "Tip: Buttons");
+
+        const char *title = "Tip: Buttons";
+        uint16_t h = getWrappedTextHeight(0, width(), title);
+        printWrapped(0, 0, width(), title);

        setFont(fontSmall);
-        int16_t cursorY = fontMedium.lineHeight() * 1.5;
+        int16_t cursorY = h + fontSmall.lineHeight();
+
+        auto drawBullet = [&](const char *text) {
+            uint16_t bh = getWrappedTextHeight(0, width(), text);
+            printWrapped(0, cursorY, width(), text);
+            cursorY += bh + (fontSmall.lineHeight() / 3);
+        };

        if (!settings->joystick.enabled) {
-            printAt(0, cursorY, "User Button");
-            cursorY += fontSmall.lineHeight() * 1.2;
-            printAt(0, cursorY, "- short press: next");
-            cursorY += fontSmall.lineHeight() * 1.2;
-            printAt(0, cursorY, "- long press: select / open menu");
+            drawBullet("User Button");
+            drawBullet("- short press: next");
+            drawBullet("- long press: select or open menu");
        } else {
-            printAt(0, cursorY, "Joystick");
-            cursorY += fontSmall.lineHeight() * 1.2;
-            printAt(0, cursorY, "- open menu / select");
-            cursorY += fontSmall.lineHeight() * 1.5;
-            printAt(0, cursorY, "Exit Button");
-            cursorY += fontSmall.lineHeight() * 1.2;
-            printAt(0, cursorY, "- switch tile / close menu");
+            drawBullet("Joystick");
+            drawBullet("- press: open menu or select");
+            drawBullet("Exit Button");
+            drawBullet("- press: switch tile or close menu");
        }

        printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
@@ -133,12 +164,21 @@ void InkHUD::TipsApplet::onRender()

    case Tip::ROTATION: {
        setFont(fontMedium);
-        printAt(0, 0, "Tip: Rotation");
+
+        const char *title = "Tip: Rotation";
+        uint16_t h = getWrappedTextHeight(0, width(), title);
+        printWrapped(0, 0, width(), title);

        setFont(fontSmall);
        if (!settings->joystick.enabled) {
-            printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
-                         "To rotate the display, use the InkHUD menu. Long-press the user button > Options > Rotate.");
+            int16_t cursorY = h + fontSmall.lineHeight();
+
+            const char *body = "To rotate the display, use the InkHUD menu. "
+                               "Long-press the user button > Options > Rotate.";
+
+            uint16_t bh = getWrappedTextHeight(0, width(), body);
+            printWrapped(0, cursorY, width(), body);
+            cursorY += bh + (fontSmall.lineHeight() / 2);
        } else {
            printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
                         "To rotate the display, use the InkHUD menu. Press the user button > Options > Rotate.");
@@ -159,12 +199,15 @@ void InkHUD::TipsApplet::renderWelcome()
 {
    uint16_t padW = X(0.05);

+    // Detect portrait orientation
+    bool portrait = height() > width();
+
    // Block 1 - logo & title
    // ========================

    // Logo size
-    uint16_t logoWLimit = X(0.3);
-    uint16_t logoHLimit = Y(0.3);
+    uint16_t logoWLimit = portrait ? X(0.5) : X(0.3);
+    uint16_t logoHLimit = portrait ? Y(0.25) : Y(0.3);
    uint16_t logoW = getLogoWidth(logoWLimit, logoHLimit);
    uint16_t logoH = getLogoHeight(logoWLimit, logoHLimit);

@@ -177,7 +220,7 @@ void InkHUD::TipsApplet::renderWelcome()

    // Center the block
    // Desired effect: equal margin from display edge for logo left and title right
-    int16_t block1Y = Y(0.3);
+    int16_t block1Y = portrait ? Y(0.2) : Y(0.3);
    int16_t block1CX = X(0.5) + (logoW / 2) - (titleW / 2);
    int16_t logoCX = block1CX - (logoW / 2) - (padW / 2);
    int16_t titleCX = block1CX + (titleW / 2) + (padW / 2);
@@ -192,7 +235,7 @@ void InkHUD::TipsApplet::renderWelcome()
    std::string subtitle = "InkHUD";
    if (width() >= 200)
        subtitle += "  -  A Heads-Up Display"; // Future proofing: narrower for tiny display
-    printAt(X(0.5), Y(0.6), subtitle, CENTER, MIDDLE);
+    printAt(X(0.5), portrait ? Y(0.45) : Y(0.6), subtitle, CENTER, MIDDLE);

    // Block 3 - press to continue
    // ============================
@@ -224,26 +267,37 @@ void InkHUD::TipsApplet::onBackground()
 // While our SystemApplet::handleInput flag is true
 void InkHUD::TipsApplet::onButtonShortPress()
 {
+    bool needsRegion = (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET);
+    // If we're prompting the user to pick a region, hand off to the menu
+    if (!tipQueue.empty() && tipQueue.front() == Tip::PICK_REGION) {
+        tipQueue.pop_front();
+
+        // Signal InkHUD to open the menu on Region page
+        inkhud->forceRegionMenu = true;
+
+        // Close tips and open menu
+        sendToBackground();
+        inkhud->openMenu();
+        return;
+    }
+    // Consume current tip
    tipQueue.pop_front();

    // All tips done
    if (tipQueue.empty()) {
        // Record that user has now seen the "tutorial" set of tips
        // Don't show them on subsequent boots
-        if (settings->tips.firstBoot) {
+        if (settings->tips.firstBoot && !needsRegion) {
            settings->tips.firstBoot = false;
            inkhud->persistence->saveSettings();
        }

-        // Close applet, and full refresh to clean the screen
-        // Need to force update, because our request would be ignored otherwise, as we are now background
+        // Close applet and clean the screen
        sendToBackground();
        inkhud->forceUpdate(EInk::UpdateTypes::FULL);
-    }
-
-    // More tips left
-    else
+    } else {
        requestUpdate();
+    }
 }

 // Functions the same as the user button in this instance
--- a/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h
@@ -23,6 +23,7 @@ class TipsApplet : public SystemApplet
    enum class Tip {
        WELCOME,
        FINISH_SETUP,
+        PICK_REGION,
        SAFE_SHUTDOWN,
        CUSTOMIZATION,
        BUTTONS,
--- a/src/graphics/niche/InkHUD/Events.cpp
+++ b/src/graphics/niche/InkHUD/Events.cpp
@@ -276,6 +276,15 @@ int InkHUD::Events::beforeDeepSleep(void *unused)
    return 0; // We agree: deep sleep now
 }

+// Display an intermediate screen while configuration changes are applied
+void InkHUD::Events::applyingChanges()
+{
+    // Bring the logo applet forward with a temporary message
+    for (SystemApplet *sa : inkhud->systemApplets) {
+        sa->onApplyingChanges();
+    }
+}
+
 // Callback for rebootObserver
 // Same as shutdown, without drawing the logoApplet
 // Makes sure we don't lose message history / InkHUD config
--- a/src/graphics/niche/InkHUD/Events.h
+++ b/src/graphics/niche/InkHUD/Events.h
@@ -29,12 +29,13 @@ class Events

    void onButtonShort(); // User button: short press
    void onButtonLong();  // User button: long press
-    void onExitShort();   // Exit button: short press
-    void onExitLong();    // Exit button: long press
-    void onNavUp();       // Navigate up
-    void onNavDown();     // Navigate down
-    void onNavLeft();     // Navigate left
-    void onNavRight();    // Navigate right
+    void applyingChanges();
+    void onExitShort(); // Exit button: short press
+    void onExitLong();  // Exit button: long press
+    void onNavUp();     // Navigate up
+    void onNavDown();   // Navigate down
+    void onNavLeft();   // Navigate left
+    void onNavRight();  // Navigate right

    int beforeDeepSleep(void *unused);                             // Prepare for shutdown
    int beforeReboot(void *unused);                                // Prepare for reboot
--- a/src/graphics/niche/InkHUD/InkHUD.cpp
+++ b/src/graphics/niche/InkHUD/InkHUD.cpp
@@ -53,6 +53,13 @@ void InkHUD::InkHUD::addApplet(const char *name, Applet *a, bool defaultActive,
    windowManager->addApplet(name, a, defaultActive, defaultAutoshow, onTile);
 }

+void InkHUD::InkHUD::notifyApplyingChanges()
+{
+    if (events) {
+        events->applyingChanges();
+    }
+}
+
 // Start InkHUD!
 // Call this only after you have configured InkHUD
 void InkHUD::InkHUD::begin()
--- a/src/graphics/niche/InkHUD/InkHUD.h
+++ b/src/graphics/niche/InkHUD/InkHUD.h
@@ -47,6 +47,7 @@ class InkHUD
    void setDriver(Drivers::EInk *driver);
    void setDisplayResilience(uint8_t fastPerFull = 5, float stressMultiplier = 2.0);
    void addApplet(const char *name, Applet *a, bool defaultActive = false, bool defaultAutoshow = false, uint8_t onTile = -1);
+    void notifyApplyingChanges();

    void begin();

@@ -76,6 +77,9 @@ class InkHUD
    void rotateJoystick(uint8_t angle = 1); // rotate 90 deg by default
    void toggleBatteryIcon();

+    // Used by TipsApplet to force menu to start on Region selection
+    bool forceRegionMenu = false;
+
    // Updating the display
    // - called by various InkHUD components

--- a/src/graphics/niche/InkHUD/SystemApplet.h
+++ b/src/graphics/niche/InkHUD/SystemApplet.h
@@ -27,6 +27,7 @@ class SystemApplet : public Applet
    bool lockRequests = false;  // - prevent other applets from triggering display updates

    virtual void onReboot() { onShutdown(); } // - handle reboot specially
+    virtual void onApplyingChanges() {}

    // Other system applets may take precedence over our own system applet though
    // The order an applet is passed to WindowManager::addSystemApplet determines this hierarchy (added earlier = higher rank)
--- a/src/mesh/Router.cpp
+++ b/src/mesh/Router.cpp
@@ -745,19 +745,15 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
        MeshModule::callModules(*p, src);

 #if !MESHTASTIC_EXCLUDE_MQTT
-        if (p_encrypted == nullptr) {
-            LOG_WARN("p_encrypted is null, skipping MQTT publish");
-        } else {
-            // Mark as pki_encrypted if it is not yet decoded and MQTT encryption is also enabled, hash matches and it's a DM not
-            // to us (because we would be able to decrypt it)
-            if (decodedState == DecodeState::DECODE_FAILURE && moduleConfig.mqtt.encryption_enabled && p->channel == 0x00 &&
-                !isBroadcast(p->to) && !isToUs(p))
-                p_encrypted->pki_encrypted = true;
-            // After potentially altering it, publish received message to MQTT if we're not the original transmitter of the packet
-            if ((decodedState == DecodeState::DECODE_SUCCESS || p_encrypted->pki_encrypted) && moduleConfig.mqtt.enabled &&
-                !isFromUs(p) && mqtt)
-                mqtt->onSend(*p_encrypted, *p, p->channel);
-        }
+        // Mark as pki_encrypted if it is not yet decoded and MQTT encryption is also enabled, hash matches and it's a DM not to
+        // us (because we would be able to decrypt it)
+        if (decodedState == DecodeState::DECODE_FAILURE && moduleConfig.mqtt.encryption_enabled && p->channel == 0x00 &&
+            !isBroadcast(p->to) && !isToUs(p))
+            p_encrypted->pki_encrypted = true;
+        // After potentially altering it, publish received message to MQTT if we're not the original transmitter of the packet
+        if ((decodedState == DecodeState::DECODE_SUCCESS || p_encrypted->pki_encrypted) && moduleConfig.mqtt.enabled &&
+            !isFromUs(p) && mqtt)
+            mqtt->onSend(*p_encrypted, *p, p->channel);
 #endif
    }

--- a/src/nimble/NimbleBluetooth.cpp
+++ b/src/nimble/NimbleBluetooth.cpp
@@ -14,11 +14,11 @@
 #include <atomic>
 #include <mutex>

-#ifdef NIMBLE_TWO
 #include "NimBLEAdvertising.h"
+#ifdef CONFIG_BT_NIMBLE_EXT_ADV
 #include "NimBLEExtAdvertising.h"
-#include "PowerStatus.h"
 #endif
+#include "PowerStatus.h"

 #if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
@@ -26,15 +26,12 @@
 #include "nimble/nimble/host/include/host/ble_gap.h"
 #endif

-#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
-
 namespace
 {
 constexpr uint16_t kPreferredBleMtu = 517;
 constexpr uint16_t kPreferredBleTxOctets = 251;
 constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 } // namespace
-#endif

 // Debugging options: careful, they slow things down quite a bit!
 // #define DEBUG_NIMBLE_ON_READ_TIMING  // uncomment to time onRead duration
@@ -313,11 +310,9 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
    {
        PhoneAPI::onNowHasData(fromRadioNum);

-        int currentNotifyCount = notifyCount.fetch_add(1);
-
-        uint8_t cc = bleServer->getConnectedCount();
-
 #ifdef DEBUG_NIMBLE_NOTIFY
+        int currentNotifyCount = notifyCount.fetch_add(1);
+        uint8_t cc = bleServer->getConnectedCount();
        // This logging slows things down when there are lots of packets going to the phone, like initial connection:
        LOG_DEBUG("BLE notify(%d) fromNum: %d connections: %d", currentNotifyCount, fromRadioNum, cc);
 #endif
@@ -326,13 +321,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
        put_le32(val, fromRadioNum);

        fromNumCharacteristic->setValue(val, sizeof(val));
-#ifdef NIMBLE_TWO
-        // NOTE: I don't have any NIMBLE_TWO devices, but this line makes me suspicious, and I suspect it needs to just be
-        // notify().
        fromNumCharacteristic->notify(val, sizeof(val), BLE_HS_CONN_HANDLE_NONE);
-#else
-        fromNumCharacteristic->notify();
-#endif
    }

    /// Check the current underlying physical link to see if the client is currently connected
@@ -397,12 +386,7 @@ static uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE];

 class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
 {
-#ifdef NIMBLE_TWO
-    virtual void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo)
-#else
-    virtual void onWrite(NimBLECharacteristic *pCharacteristic)
-
-#endif
+    void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &) override
    {
        // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
        // Assumption: onWrite is serialized by NimBLE, so we don't need to lock here against multiple concurrent onWrite calls.
@@ -449,11 +433,7 @@ class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks

 class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
 {
-#ifdef NIMBLE_TWO
-    virtual void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo)
-#else
-    virtual void onRead(NimBLECharacteristic *pCharacteristic)
-#endif
+    void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &) override
    {
        // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.

@@ -561,32 +541,27 @@ class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks

 class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
 {
-#ifdef NIMBLE_TWO
  public:
-    NimbleBluetoothServerCallback(NimbleBluetooth *ble) { this->ble = ble; }
+    explicit NimbleBluetoothServerCallback(NimbleBluetooth *ble) : ble(ble) {}

  private:
    NimbleBluetooth *ble;

-    virtual uint32_t onPassKeyDisplay()
-#else
-    virtual uint32_t onPassKeyRequest()
-#endif
+    uint32_t onPassKeyDisplay() override
    {
        uint32_t passkey = config.bluetooth.fixed_pin;

        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
            LOG_INFO("Use random passkey");
-            // This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
            passkey = random(100000, 999999);
        }
-        LOG_INFO("*** Enter passkey %d on the peer side ***", passkey);
+        LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);

        powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
        meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
        bluetoothStatus->updateStatus(&newStatus);

-#if HAS_SCREEN // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
+#if HAS_SCREEN
        if (screen) {
            screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
                char btPIN[16] = "888888";
@@ -615,39 +590,29 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
            });
        }
 #endif
-        passkeyShowing = true;

+        passkeyShowing = true;
        return passkey;
    }

-#ifdef NIMBLE_TWO
-    virtual void onAuthenticationComplete(NimBLEConnInfo &connInfo)
-#else
-    virtual void onAuthenticationComplete(ble_gap_conn_desc *desc)
-#endif
+    void onAuthenticationComplete(NimBLEConnInfo &connInfo) override
    {
        LOG_INFO("BLE authentication complete");

        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
        bluetoothStatus->updateStatus(&newStatus);

-        // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
        if (passkeyShowing) {
            passkeyShowing = false;
-            if (screen)
+            if (screen) {
                screen->endAlert();
+            }
        }

-        // Store the connection handle for future use
-#ifdef NIMBLE_TWO
        nimbleBluetoothConnHandle = connInfo.getConnHandle();
-#else
-        nimbleBluetoothConnHandle = desc->conn_handle;
-#endif
    }

-#ifdef NIMBLE_TWO
-    virtual void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo)
+    void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo) override
    {
        LOG_INFO("BLE incoming connection %s", connInfo.getAddress().toString().c_str());

@@ -672,21 +637,12 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
        LOG_INFO("BLE conn %u initial MTU %u (target %u)", connHandle, connInfo.getMTU(), kPreferredBleMtu);
        pServer->updateConnParams(connHandle, 6, 12, 0, 200);
    }
-#endif

-#ifdef NIMBLE_TWO
-    virtual void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason)
+    void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason) override
    {
        LOG_INFO("BLE disconnect reason: %d", reason);
-#else
-    virtual void onDisconnect(NimBLEServer *pServer, ble_gap_conn_desc *desc)
-    {
-        LOG_INFO("BLE disconnect");
-#endif
-#ifdef NIMBLE_TWO
        if (ble->isDeInit)
            return;
-#endif

        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
        bluetoothStatus->updateStatus(&newStatus);
@@ -710,35 +666,69 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
            bluetoothPhoneAPI->writeCount = 0;
        }

-        // Clear the last ToRadio packet buffer to avoid rejecting first packet from new connection
        memset(lastToRadio, 0, sizeof(lastToRadio));

-        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE; // BLE_HS_CONN_HANDLE_NONE means "no connection"
+        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;

-#ifdef NIMBLE_TWO
-        // Restart Advertising
        ble->startAdvertising();
-#else
-        NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-        if (!pAdvertising->start(0)) {
-            if (pAdvertising->isAdvertising()) {
-                LOG_DEBUG("BLE advertising already running");
-            } else {
-                LOG_ERROR("BLE failed to restart advertising");
-            }
-        }
-#endif
    }
 };

 static NimbleBluetoothToRadioCallback *toRadioCallbacks;
 static NimbleBluetoothFromRadioCallback *fromRadioCallbacks;

+void NimbleBluetooth::startAdvertising()
+{
+#if defined(CONFIG_BT_NIMBLE_EXT_ADV)
+    NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    NimBLEExtAdvertisement legacyAdvertising;
+
+    legacyAdvertising.setLegacyAdvertising(true);
+    legacyAdvertising.setScannable(true);
+    legacyAdvertising.setConnectable(true);
+    legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
+    if (powerStatus->getHasBattery() == 1) {
+        legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
+    }
+    legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
+    legacyAdvertising.setMinInterval(500);
+    legacyAdvertising.setMaxInterval(1000);
+
+    NimBLEExtAdvertisement legacyScanResponse;
+    legacyScanResponse.setLegacyAdvertising(true);
+    legacyScanResponse.setConnectable(true);
+    legacyScanResponse.setName(getDeviceName());
+
+    if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
+        LOG_ERROR("BLE failed to set legacyAdvertising");
+    } else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
+        LOG_ERROR("BLE failed to set legacyScanResponse");
+    } else if (!pAdvertising->start(0, 0, 0)) {
+        LOG_ERROR("BLE failed to start legacyAdvertising");
+    }
+#else
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    pAdvertising->reset();
+    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
+    if (powerStatus->getHasBattery() == 1) {
+        pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f));
+    }
+
+    NimBLEAdvertisementData scan;
+    scan.setName(getDeviceName());
+    pAdvertising->setScanResponseData(scan);
+    pAdvertising->enableScanResponse(true);
+
+    if (!pAdvertising->start(0)) {
+        LOG_ERROR("BLE failed to start advertising");
+    }
+#endif
+    LOG_DEBUG("BLE Advertising started");
+}
+
 void NimbleBluetooth::shutdown()
 {
-    // No measurable power saving for ESP32 during light-sleep(?)
 #ifndef ARCH_ESP32
-    // Shutdown bluetooth for minimum power draw
    LOG_INFO("Disable bluetooth");
    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
    pAdvertising->reset();
@@ -746,7 +736,6 @@ void NimbleBluetooth::shutdown()
 #endif
 }

-// Proper shutdown for ESP32. Needs reboot to reverse.
 void NimbleBluetooth::deinit()
 {
 #ifdef ARCH_ESP32
@@ -760,21 +749,17 @@ void NimbleBluetooth::deinit()
    digitalWrite(BLE_LED, LOW);
 #endif
 #endif
-#ifndef NIMBLE_TWO
-    NimBLEDevice::deinit();
-#endif
 #endif
 }

-// Has initial setup been completed
 bool NimbleBluetooth::isActive()
 {
-    return bleServer;
+    return bleServer != nullptr;
 }

 bool NimbleBluetooth::isConnected()
 {
-    return bleServer->getConnectedCount() > 0;
+    return bleServer && bleServer->getConnectedCount() > 0;
 }

 int NimbleBluetooth::getRssi()
@@ -818,7 +803,7 @@ void NimbleBluetooth::setup()
    LOG_INFO("Init the NimBLE bluetooth module");

    NimBLEDevice::init(getDeviceName());
-    NimBLEDevice::setPower(ESP_PWR_LVL_P9);
+    NimBLEDevice::setPower(9);

 #if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
    int mtuResult = NimBLEDevice::setMTU(kPreferredBleMtu);
@@ -851,11 +836,7 @@ void NimbleBluetooth::setup()
        NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
    }
    bleServer = NimBLEDevice::createServer();
-#ifdef NIMBLE_TWO
-    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback(this);
-#else
-    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback();
-#endif
+    auto *serverCallbacks = new NimbleBluetoothServerCallback(this);
    bleServer->setCallbacks(serverCallbacks, true);
    setupService();
    startAdvertising();
@@ -900,11 +881,7 @@ void NimbleBluetooth::setupService()
    NimBLEService *batteryService = bleServer->createService(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
    BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
        (uint16_t)0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY, 1);
-#ifdef NIMBLE_TWO
    NimBLE2904 *batteryLevelDescriptor = BatteryCharacteristic->create2904();
-#else
-    NimBLE2904 *batteryLevelDescriptor = (NimBLE2904 *)BatteryCharacteristic->createDescriptor((uint16_t)0x2904);
-#endif
    batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
    batteryLevelDescriptor->setNamespace(1);
    batteryLevelDescriptor->setUnit(0x27ad);
@@ -912,54 +889,12 @@ void NimbleBluetooth::setupService()
    batteryService->start();
 }

-void NimbleBluetooth::startAdvertising()
-{
-#ifdef NIMBLE_TWO
-    NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-    NimBLEExtAdvertisement legacyAdvertising;
-
-    legacyAdvertising.setLegacyAdvertising(true);
-    legacyAdvertising.setScannable(true);
-    legacyAdvertising.setConnectable(true);
-    legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
-    if (powerStatus->getHasBattery() == 1) {
-        legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
-    }
-    legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
-    legacyAdvertising.setMinInterval(500);
-    legacyAdvertising.setMaxInterval(1000);
-
-    NimBLEExtAdvertisement legacyScanResponse;
-    legacyScanResponse.setLegacyAdvertising(true);
-    legacyScanResponse.setConnectable(true);
-    legacyScanResponse.setName(getDeviceName());
-
-    if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
-        LOG_ERROR("BLE failed to set legacyAdvertising");
-    } else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
-        LOG_ERROR("BLE failed to set legacyScanResponse");
-    } else if (!pAdvertising->start(0, 0, 0)) {
-        LOG_ERROR("BLE failed to start legacyAdvertising");
-    }
-#else
-    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-    pAdvertising->reset();
-    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
-    pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
-    pAdvertising->start(0);
-#endif
-}
-
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level)
 {
    if ((config.bluetooth.enabled == true) && bleServer && nimbleBluetooth->isConnected()) {
        BatteryCharacteristic->setValue(&level, 1);
-#ifdef NIMBLE_TWO
        BatteryCharacteristic->notify(&level, 1, BLE_HS_CONN_HANDLE_NONE);
-#else
-        BatteryCharacteristic->notify();
-#endif
    }
 }

@@ -974,11 +909,7 @@ void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
    if (!bleServer || !isConnected() || length > 512) {
        return;
    }
-#ifdef NIMBLE_TWO
    logRadioCharacteristic->notify(logMessage, length, BLE_HS_CONN_HANDLE_NONE);
-#else
-    logRadioCharacteristic->notify(logMessage, length, true);
-#endif
 }

 void clearNVS()
--- a/src/nimble/NimbleBluetooth.h
+++ b/src/nimble/NimbleBluetooth.h
@@ -12,16 +12,11 @@ class NimbleBluetooth : BluetoothApi
    bool isConnected();
    int getRssi();
    void sendLog(const uint8_t *logMessage, size_t length);
-#if defined(NIMBLE_TWO)
    void startAdvertising();
-#endif
    bool isDeInit = false;

  private:
    void setupService();
-#if !defined(NIMBLE_TWO)
-    void startAdvertising();
-#endif
 };

 void setBluetoothEnable(bool enable);
--- a/variants/esp32/esp32-common.ini
+++ b/variants/esp32/esp32-common.ini
@@ -38,6 +38,7 @@ build_flags =
  -DAXP_DEBUG_PORT=Serial
  -DCONFIG_BT_NIMBLE_ENABLED
  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
+  -DCONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
@@ -60,11 +61,11 @@ lib_deps =
  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
-  h2zero/NimBLE-Arduino@^1.4.3
+  h2zero/NimBLE-Arduino@2.3.7
  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
-  # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
-  https://github.com/lewisxhe/XPowersLib/archive/v0.3.2.zip
+  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
+  lewisxhe/XPowersLib@0.3.2
  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
--- a/variants/esp32/esp32.ini
+++ b/variants/esp32/esp32.ini
@@ -5,4 +5,4 @@ extends = esp32_common
 custom_esp32_kind = esp32

 build_flags =
-  ${esp32_common.build_flags}
+  ${esp32_common.build_flags}
--- a/variants/esp32/tbeam/platformio.ini
+++ b/variants/esp32/tbeam/platformio.ini
@@ -2,7 +2,7 @@
 [env:tbeam]
 extends = esp32_base
 board = ttgo-t-beam
-
+board_level = extra
 board_check = true
 build_flags = ${esp32_base.build_flags}
  -D TBEAM_V10
@@ -13,7 +13,7 @@ upload_speed = 921600

 [env:tbeam-displayshield]
 extends = env:tbeam
-board_level = extra
+
 build_flags =
  ${env:tbeam.build_flags}
  -D USE_ST7796
--- a/variants/esp32c3/esp32c3.ini
+++ b/variants/esp32c3/esp32c3.ini
@@ -4,3 +4,8 @@ custom_esp32_kind = esp32c3

 monitor_speed = 115200
 monitor_filters = esp32_c3_exception_decoder
+
+build_flags =
+  ${esp32_common.build_flags}
+  -DCONFIG_BT_NIMBLE_EXT_ADV=1
+  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
--- a/variants/esp32c6/m5stack_unitc6l/platformio.ini
+++ b/variants/esp32c6/m5stack_unitc6l/platformio.ini
@@ -26,7 +26,6 @@ build_flags =
  -D HAS_BLUETOOTH=1
 	-DCONFIG_BT_NIMBLE_EXT_ADV=1
 	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
-  -D NIMBLE_TWO
 monitor_speed=115200
 lib_ignore =
  NonBlockingRTTTL
--- a/variants/esp32s3/esp32s3.ini
+++ b/variants/esp32s3/esp32s3.ini
@@ -3,3 +3,8 @@ extends = esp32_common
 custom_esp32_kind = esp32s3

 monitor_speed = 115200
+
+build_flags =
+  ${esp32_common.build_flags}
+  -DCONFIG_BT_NIMBLE_EXT_ADV=1
+  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
--- a/version.properties
+++ b/version.properties
@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 7
-build = 18
+build = 17
Author	SHA1	Message	Date
HarukiToreda	ef128a7883	Merge branch 'develop' into InkHUD-Improvements	2026-01-01 17:38:48 -05:00
HarukiToreda	d55bf66f25	Merge branch 'develop' into InkHUD-Improvements	2025-12-28 00:24:03 -05:00
HarukiToreda	1885a2beac	Merge branch 'develop' into InkHUD-Improvements	2025-12-25 22:30:27 -05:00
HarukiToreda	d5ef68314b	Fixed missing stray endiff	2025-12-21 01:37:27 -05:00
HarukiToreda	3baba4b1a1	Merge branch 'develop' into InkHUD-Improvements	2025-12-21 00:33:29 -05:00
HarukiToreda	791fb86c7c	added ADC calibration feature	2025-12-21 00:17:33 -05:00
HarukiToreda	c1c5d36e86	Added ADC multiplier value display on power config	2025-12-20 21:02:27 -05:00
HarukiToreda	050371adc5	Fix to tips to work with new joystick input	2025-12-20 17:00:00 -05:00
HarukiToreda	f409645ad3	Trunk Fix	2025-12-20 16:38:20 -05:00
HarukiToreda	25d7db65ea	quick fix to joystick	2025-12-20 16:29:51 -05:00
HarukiToreda	e0ceaaff38	Merge branch 'develop' into InkHUD-Improvements	2025-12-20 16:29:08 -05:00
HarukiToreda	6431c76aac	Merge branch 'develop' into InkHUD-Improvements	2025-12-19 09:49:26 -05:00
HarukiToreda	ac0b3613ec	Added ResetDB and keep only favorite commands	2025-12-19 04:41:36 -05:00
HarukiToreda	9ad7d39051	Make Tips show after first boot if the region is Unset	2025-12-19 03:54:10 -05:00
HarukiToreda	b3e6731c85	Trunk fix	2025-12-17 13:01:04 -05:00
HarukiToreda	ef36a5a24d	Added "Saving Changes" screen when reboot is needed	2025-12-17 12:38:04 -05:00
HarukiToreda	66d9c430d8	Trunk fix	2025-12-16 02:23:51 -05:00
HarukiToreda	ac05337e42	Timezone labels easier to understand	2025-12-16 02:23:04 -05:00
HarukiToreda	1d4e295471	Recent list with checkboxes	2025-12-16 01:38:03 -05:00
HarukiToreda	c761444bee	Reduce line spacing to fit more content	2025-12-16 01:01:40 -05:00
HarukiToreda	929aa5c968	Wifi details	2025-12-15 22:31:33 -05:00
HarukiToreda	cc6265e9b1	Network Config for ESP32	2025-12-15 21:48:17 -05:00
HarukiToreda	958e1f73ef	Position Toggle added	2025-12-15 21:07:04 -05:00
HarukiToreda	96e82f1ec1	Merge branch 'develop' into InkHUD-Improvements	2025-12-15 03:22:52 -05:00
HarukiToreda	83ec37113d	Display config added	2025-12-15 02:47:09 -05:00
HarukiToreda	5acf72243d	Add back to all Options	2025-12-15 01:38:22 -05:00
HarukiToreda	bd18a171d4	Cleaning some behavior	2025-12-15 01:00:54 -05:00
HarukiToreda	6e05c554b8	Channel Config	2025-12-15 00:40:01 -05:00
HarukiToreda	5f9a6a38e6	Config section Headers	2025-12-14 20:56:08 -05:00
HarukiToreda	a332ca978b	Power save mode and bluetooth configs	2025-12-14 20:06:24 -05:00
HarukiToreda	7b4315421b	Timezone picker added	2025-12-14 18:36:22 -05:00
HarukiToreda	60389e84e6	Preset Picker	2025-12-14 17:22:14 -05:00
HarukiToreda	cd0843c7db	Role picker	2025-12-14 16:54:10 -05:00
HarukiToreda	d9dab0cd6c	Added Node Config menu with Lora Region Picker	2025-12-14 15:53:44 -05:00
HarukiToreda	87114f4052	InkHUD: Region Picker on initial setup	2025-12-14 04:34:29 -05:00