Automated version bumps

* TwoButtonExtened mirrors TwoButton but added joystick functionality

* basic ui navigation with a joystick

settings->joystick.enabled setting added and SETTINGS_VERSION
incremented by one in InkHUD/Persistence.h

in seeed_wio_tracker_L1_eink/nicheGraphics.h enable joystick and
disable "Next Tile" menu item in

implement prevTile and prevApplet functions in
InkHUD/WindowManager.h,cpp and InkHUD/InkHUD.h,cpp

onStickCenterShort, onStickCenterLong, onStickUp, onStickDown,
onStickLeft, and onStickRight functions added to:
- InkHUD/InkHUD.h,cpp
- InkHUD/Events.h,cpp
- InkHUD/Applet.h

change navigation actions in InkHUD/Events.cpp events based on
whether the joystick is enabled or not

in seeed_wio_tracker_L1_eink/nicheGraphics.h connect joystick events to
the new joystick handler functions

* handle joystick input in NotificationApplet and TipsApplet

Both the joystick center short press and the user button short press can
be used to advance through the Tips applet.

dismiss notifications with any joystick input

* MenuApplet controls
allows menu navigation including a back button

* add AlignStickApplet for aligning the joystick with the screen

add joystick.aligned and joystick.alignment to InkHUD/Persistence.h for
storing alignment status and relative angle

create AlignStick applet that prompts the user for a joystick input and
rotates the controls to align with the screen

AlignStick applet is run after the tips applet if the joystick is
enabled and not aligned

add menu item for opening the AlignStick applet

* update tips applet with joystick controls

* format InkHUD additions

* fix stroke consistency when resizing joystick graphic

* tweak button tips for order consistency

* increase joystick debounce

* fix comments

* remove unnecessary '+'

* remap joystick controls to match standard inkHUD behavior

Input with a joystick now behaves as follows

User Button (joystick center):
- short press in applet -> opens menu
- long press in applet -> opens menu
- short press in menu -> selects
- long press in menu -> selects

Exit Button:
- short press in applet -> switches tile
- long press in applet -> nothing for now
- short press in menu -> closes menu
- long press in menu -> nothing for now

---------

Co-authored-by: scobert <scobert57@gmail.com>
Co-authored-by: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>

debian/changelog

@@ -2,7 +2,7 @@ meshtasticd (2.7.18.0) unstable; urgency=medium
 
   * Version 2.7.18
 
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 20 Dec 2025 15:47:25 +0000
+ -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 20 Dec 2025 22:23:21 +0000
 
 meshtasticd (2.7.17.0) unstable; urgency=medium
 

platformio.ini

@@ -94,7 +94,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=NonBlockingRTTTL packageName=end2endzone/library/NonBlockingRTTTL
 	end2endzone/NonBlockingRTTTL@1.4.0
 build_flags = ${env.build_flags} -Os
-build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/> -<modules/Native/>
+build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
 [networking_base]

src/graphics/niche/InkHUD/Applet.h

@@ -88,8 +88,14 @@ class Applet : public GFX
     virtual void onForeground() {}
     virtual void onBackground() {}
     virtual void onShutdown() {}
-    virtual void onButtonShortPress() {} // (System Applets only)
-    virtual void onButtonLongPress() {}  // (System Applets only)
+    virtual void onButtonShortPress() {}
+    virtual void onButtonLongPress() {}
+    virtual void onExitShort() {}
+    virtual void onExitLong() {}
+    virtual void onNavUp() {}
+    virtual void onNavDown() {}
+    virtual void onNavLeft() {}
+    virtual void onNavRight() {}
 
     virtual bool approveNotification(Notification &n); // Allow an applet to veto a notification
 

src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.cpp

@@ -0,0 +1,205 @@
+#ifdef MESHTASTIC_INCLUDE_INKHUD
+
+#include "./AlignStickApplet.h"
+
+using namespace NicheGraphics;
+
+InkHUD::AlignStickApplet::AlignStickApplet()
+{
+    if (!settings->joystick.aligned)
+        bringToForeground();
+}
+
+void InkHUD::AlignStickApplet::onRender()
+{
+    setFont(fontMedium);
+    printAt(0, 0, "Align Joystick:");
+    setFont(fontSmall);
+    std::string instructions = "Move joystick in the direction indicated";
+    printWrapped(0, fontMedium.lineHeight() * 1.5, width(), instructions);
+
+    // Size of the region in which the joystick graphic should fit
+    uint16_t joyXLimit = X(0.8);
+    uint16_t contentH = fontMedium.lineHeight() * 1.5 + fontSmall.lineHeight() * 1;
+    if (getTextWidth(instructions) > width())
+        contentH += fontSmall.lineHeight();
+    uint16_t freeY = height() - contentH - fontSmall.lineHeight() * 1.2;
+    uint16_t joyYLimit = freeY * 0.8;
+
+    // Use the shorter of the two
+    uint16_t joyWidth = joyXLimit < joyYLimit ? joyXLimit : joyYLimit;
+
+    // Center the joystick graphic
+    uint16_t centerX = X(0.5);
+    uint16_t centerY = contentH + freeY * 0.5;
+
+    // Draw joystick graphic
+    drawStick(centerX, centerY, joyWidth);
+
+    setFont(fontSmall);
+    printAt(X(0.5), Y(1.0) - fontSmall.lineHeight() * 0.2, "Long press to skip", CENTER, BOTTOM);
+}
+
+// Draw a scalable joystick graphic
+void InkHUD::AlignStickApplet::drawStick(uint16_t centerX, uint16_t centerY, uint16_t width)
+{
+    if (width < 9) // too small to draw
+        return;
+
+    else if (width < 40) { // only draw up arrow
+        uint16_t chamfer = width < 20 ? 1 : 2;
+
+        // Draw filled up arrow
+        drawDirection(centerX, centerY - width / 4, Direction::UP, width, chamfer, BLACK);
+
+    } else { // large enough to draw the full thing
+        uint16_t chamfer = width < 80 ? 1 : 2;
+        uint16_t stroke = 3; // pixels
+        uint16_t arrowW = width * 0.22;
+        uint16_t hollowW = arrowW - stroke * 2;
+
+        // Draw center circle
+        fillCircle((int16_t)centerX, (int16_t)centerY, (int16_t)(width * 0.2), BLACK);
+        fillCircle((int16_t)centerX, (int16_t)centerY, (int16_t)(width * 0.2) - stroke, WHITE);
+
+        // Draw filled up arrow
+        drawDirection(centerX, centerY - width / 2, Direction::UP, arrowW, chamfer, BLACK);
+
+        // Draw down arrow
+        drawDirection(centerX, centerY + width / 2, Direction::DOWN, arrowW, chamfer, BLACK);
+        drawDirection(centerX, centerY + width / 2 - stroke, Direction::DOWN, hollowW, 0, WHITE);
+
+        // Draw left arrow
+        drawDirection(centerX - width / 2, centerY, Direction::LEFT, arrowW, chamfer, BLACK);
+        drawDirection(centerX - width / 2 + stroke, centerY, Direction::LEFT, hollowW, 0, WHITE);
+
+        // Draw right arrow
+        drawDirection(centerX + width / 2, centerY, Direction::RIGHT, arrowW, chamfer, BLACK);
+        drawDirection(centerX + width / 2 - stroke, centerY, Direction::RIGHT, hollowW, 0, WHITE);
+    }
+}
+
+// Draw a scalable joystick direction arrow
+// a right-triangle with blunted tips
+/*
+            _ <--point
+    ^      / \
+    |     /   \
+   size  /     \
+    |   /       \
+    v  |_________|
+
+*/
+void InkHUD::AlignStickApplet::drawDirection(uint16_t pointX, uint16_t pointY, Direction direction, uint16_t size,
+                                             uint16_t chamfer, Color color)
+{
+    uint16_t chamferW = chamfer * 2 + 1;
+    uint16_t triangleW = size - chamferW;
+
+    // Draw arrow
+    switch (direction) {
+    case Direction::UP:
+        fillRect(pointX - chamfer, pointY, chamferW, triangleW, color);
+        fillRect(pointX - chamfer - triangleW, pointY + triangleW, chamferW + triangleW * 2, chamferW, color);
+        fillTriangle(pointX - chamfer, pointY, pointX - chamfer - triangleW, pointY + triangleW, pointX - chamfer,
+                     pointY + triangleW, color);
+        fillTriangle(pointX + chamfer, pointY, pointX + chamfer + triangleW, pointY + triangleW, pointX + chamfer,
+                     pointY + triangleW, color);
+        break;
+    case Direction::DOWN:
+        fillRect(pointX - chamfer, pointY - triangleW + 1, chamferW, triangleW, color);
+        fillRect(pointX - chamfer - triangleW, pointY - size + 1, chamferW + triangleW * 2, chamferW, color);
+        fillTriangle(pointX - chamfer, pointY, pointX - chamfer - triangleW, pointY - triangleW, pointX - chamfer,
+                     pointY - triangleW, color);
+        fillTriangle(pointX + chamfer, pointY, pointX + chamfer + triangleW, pointY - triangleW, pointX + chamfer,
+                     pointY - triangleW, color);
+        break;
+    case Direction::LEFT:
+        fillRect(pointX, pointY - chamfer, triangleW, chamferW, color);
+        fillRect(pointX + triangleW, pointY - chamfer - triangleW, chamferW, chamferW + triangleW * 2, color);
+        fillTriangle(pointX, pointY - chamfer, pointX + triangleW, pointY - chamfer - triangleW, pointX + triangleW,
+                     pointY - chamfer, color);
+        fillTriangle(pointX, pointY + chamfer, pointX + triangleW, pointY + chamfer + triangleW, pointX + triangleW,
+                     pointY + chamfer, color);
+        break;
+    case Direction::RIGHT:
+        fillRect(pointX - triangleW + 1, pointY - chamfer, triangleW, chamferW, color);
+        fillRect(pointX - size + 1, pointY - chamfer - triangleW, chamferW, chamferW + triangleW * 2, color);
+        fillTriangle(pointX, pointY - chamfer, pointX - triangleW, pointY - chamfer - triangleW, pointX - triangleW,
+                     pointY - chamfer, color);
+        fillTriangle(pointX, pointY + chamfer, pointX - triangleW, pointY + chamfer + triangleW, pointX - triangleW,
+                     pointY + chamfer, color);
+        break;
+    }
+}
+
+void InkHUD::AlignStickApplet::onForeground()
+{
+    // Prevent most other applets from requesting update, and skip their rendering entirely
+    // Another system applet with a higher precedence can potentially ignore this
+    SystemApplet::lockRendering = true;
+    SystemApplet::lockRequests = true;
+
+    handleInput = true; // Intercept the button input for our applet
+}
+
+void InkHUD::AlignStickApplet::onBackground()
+{
+    // Allow normal update behavior to resume
+    SystemApplet::lockRendering = false;
+    SystemApplet::lockRequests = false;
+    SystemApplet::handleInput = false;
+
+    // Need to force an update, as a polite request wouldn't be honored, seeing how we are now in the background
+    // Usually, onBackground is followed by another applet's onForeground (which requests update), but not in this case
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onButtonLongPress()
+{
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onExitLong()
+{
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavUp()
+{
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavDown()
+{
+    inkhud->rotateJoystick(2); // 180 deg
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavLeft()
+{
+    inkhud->rotateJoystick(3); // 270 deg
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavRight()
+{
+    inkhud->rotateJoystick(1); // 90 deg
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+#endif

src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.h

@@ -0,0 +1,50 @@
+#ifdef MESHTASTIC_INCLUDE_INKHUD
+
+/*
+
+System Applet for manually aligning the joystick with the screen
+
+should be run at startup if the joystick is enabled
+and not aligned to the screen
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#include "graphics/niche/InkHUD/SystemApplet.h"
+
+namespace NicheGraphics::InkHUD
+{
+
+class AlignStickApplet : public SystemApplet
+{
+  public:
+    AlignStickApplet();
+
+    void onRender() override;
+    void onForeground() override;
+    void onBackground() override;
+    void onButtonLongPress() override;
+    void onExitLong() override;
+    void onNavUp() override;
+    void onNavDown() override;
+    void onNavLeft() override;
+    void onNavRight() override;
+
+  protected:
+    enum Direction {
+        UP,
+        DOWN,
+        LEFT,
+        RIGHT,
+    };
+
+    void drawStick(uint16_t centerX, uint16_t centerY, uint16_t width);
+    void drawDirection(uint16_t pointX, uint16_t pointY, Direction direction, uint16_t size, uint16_t chamfer, Color color);
+};
+
+} // namespace NicheGraphics::InkHUD
+
+#endif

src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h

@@ -30,6 +30,7 @@ enum MenuAction {
     TOGGLE_AUTOSHOW_APPLET,
     SET_RECENTS,
     ROTATE,
+    ALIGN_JOYSTICK,
     LAYOUT,
     TOGGLE_BATTERY_ICON,
     TOGGLE_NOTIFICATIONS,

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp

@@ -178,6 +178,10 @@ void InkHUD::MenuApplet::execute(MenuItem item)
         inkhud->rotate();
         break;
 
+    case ALIGN_JOYSTICK:
+        inkhud->openAlignStick();
+        break;
+
     case LAYOUT:
         // Todo: smarter incrementing of tile count
         settings->userTiles.count++;
@@ -287,14 +291,17 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         // items.push_back(MenuItem("Display Off", MenuPage::EXIT)); // TODO
         items.push_back(MenuItem("Save & Shut Down", MenuAction::SHUTDOWN));
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::EXIT;
         break;
 
     case SEND:
         populateSendPage();
+        previousPage = MenuPage::ROOT;
         break;
 
     case CANNEDMESSAGE_RECIPIENT:
         populateRecipientPage();
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case OPTIONS:
@@ -321,6 +328,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         if (settings->userTiles.maxCount > 1)
             items.push_back(MenuItem("Layout", MenuAction::LAYOUT, MenuPage::OPTIONS));
         items.push_back(MenuItem("Rotate", MenuAction::ROTATE, MenuPage::OPTIONS));
+        if (settings->joystick.enabled)
+            items.push_back(MenuItem("Align Joystick", MenuAction::ALIGN_JOYSTICK, MenuPage::EXIT));
         items.push_back(MenuItem("Notifications", MenuAction::TOGGLE_NOTIFICATIONS, MenuPage::OPTIONS,
                                  &settings->optionalFeatures.notifications));
         items.push_back(MenuItem("Battery Icon", MenuAction::TOGGLE_BATTERY_ICON, MenuPage::OPTIONS,
@@ -332,20 +341,24 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         items.push_back(
             MenuItem("12-Hour Clock", MenuAction::TOGGLE_12H_CLOCK, MenuPage::OPTIONS, &config.display.use_12h_clock));
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::ROOT;
         break;
 
     case APPLETS:
         populateAppletPage();
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case AUTOSHOW:
         populateAutoshowPage();
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case RECENTS:
         populateRecentsPage();
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case EXIT:
@@ -479,12 +492,21 @@ void InkHUD::MenuApplet::onButtonShortPress()
     // Push the auto-close timer back
     OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
 
-    // Move menu cursor to next entry, then update
-    if (cursorShown)
-        cursor = (cursor + 1) % items.size();
-    else
-        cursorShown = true;
-    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    if (!settings->joystick.enabled) {
+        // Move menu cursor to next entry, then update
+        if (cursorShown)
+            cursor = (cursor + 1) % items.size();
+        else
+            cursorShown = true;
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    } else {
+        if (cursorShown)
+            execute(items.at(cursor));
+        else
+            showPage(MenuPage::EXIT);
+        if (!wantsToRender())
+            requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    }
 }
 
 void InkHUD::MenuApplet::onButtonLongPress()
@@ -504,6 +526,62 @@ void InkHUD::MenuApplet::onButtonLongPress()
         requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }
 
+void InkHUD::MenuApplet::onExitShort()
+{
+    // Exit the menu
+    showPage(MenuPage::EXIT);
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavUp()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    // Move menu cursor to previous entry, then update
+    if (cursor == 0)
+        cursor = items.size() - 1;
+    else
+        cursor--;
+
+    if (!cursorShown)
+        cursorShown = true;
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavDown()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    // Move menu cursor to next entry, then update
+    if (cursorShown)
+        cursor = (cursor + 1) % items.size();
+    else
+        cursorShown = true;
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavLeft()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    // Go to the previous menu page
+    showPage(previousPage);
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavRight()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    if (cursorShown)
+        execute(items.at(cursor));
+    if (!wantsToRender())
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
 // Dynamically create MenuItem entries for activating / deactivating Applets, for the "Applet Selection" submenu
 void InkHUD::MenuApplet::populateAppletPage()
 {
@@ -796,4 +874,4 @@ void InkHUD::MenuApplet::freeCannedMessageResources()
     cm.recipientItems.clear();
 }
 
-#endif
+#endif

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h

@@ -27,6 +27,11 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
     void onBackground() override;
     void onButtonShortPress() override;
     void onButtonLongPress() override;
+    void onExitShort() override;
+    void onNavUp() override;
+    void onNavDown() override;
+    void onNavLeft() override;
+    void onNavRight() override;
     void onRender() override;
 
     void show(Tile *t); // Open the menu, onto a user tile
@@ -52,6 +57,7 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
     void freeCannedMessageResources();                                      // Clear MenuApplet's canned message processing data
 
     MenuPage currentPage = MenuPage::ROOT;
+    MenuPage previousPage = MenuPage::EXIT;
     uint8_t cursor = 0;       // Which menu item is currently highlighted
     bool cursorShown = false; // Is *any* item highlighted? (Root menu: no initial selection)
 
@@ -97,4 +103,4 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
 
 } // namespace NicheGraphics::InkHUD
 
-#endif
+#endif

src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp

@@ -153,6 +153,42 @@ void InkHUD::NotificationApplet::onButtonLongPress()
     inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }
 
+void InkHUD::NotificationApplet::onExitShort()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onExitLong()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavUp()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavDown()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavLeft()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavRight()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
 // Ask the WindowManager to check whether any displayed applets are already displaying the info from this notification
 // Called internally when we first get a "notifiable event", and then again before render,
 // in case autoshow swapped which applet was displayed

src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.h

@@ -31,6 +31,12 @@ class NotificationApplet : public SystemApplet
     void onBackground() override;
     void onButtonShortPress() override;
     void onButtonLongPress() override;
+    void onExitShort() override;
+    void onExitLong() override;
+    void onNavUp() override;
+    void onNavDown() override;
+    void onNavLeft() override;
+    void onNavRight() override;
 
     int onReceiveTextMessage(const meshtastic_MeshPacket *p);
 

src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp

@@ -112,12 +112,21 @@ void InkHUD::TipsApplet::onRender()
         setFont(fontSmall);
         int16_t cursorY = fontMedium.lineHeight() * 1.5;
 
-        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");
-        cursorY += fontSmall.lineHeight() * 1.5;
+        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");
+        } 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");
+        }
 
         printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
     } break;
@@ -127,8 +136,13 @@ void InkHUD::TipsApplet::onRender()
         printAt(0, 0, "Tip: Rotation");
 
         setFont(fontSmall);
-        printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
-                     "To rotate the display, use the InkHUD menu. Long-press the user button > Options > Rotate.");
+        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.");
+        } else {
+            printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
+                         "To rotate the display, use the InkHUD menu. Press the user button > Options > Rotate.");
+        }
 
         printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
 
@@ -232,4 +246,10 @@ void InkHUD::TipsApplet::onButtonShortPress()
         requestUpdate();
 }
 
+// Functions the same as the user button in this instance
+void InkHUD::TipsApplet::onExitShort()
+{
+    onButtonShortPress();
+}
+
 #endif

src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h

@@ -36,6 +36,7 @@ class TipsApplet : public SystemApplet
     void onForeground() override;
     void onBackground() override;
     void onButtonShortPress() override;
+    void onExitShort() override;
 
   protected:
     void renderWelcome(); // Very first screen of tutorial

src/graphics/niche/InkHUD/Events.cpp

@@ -55,10 +55,15 @@ void InkHUD::Events::onButtonShort()
     }
 
     // If no system applet is handling input, default behavior instead is to cycle applets
-    if (consumer)
+    // or open menu if joystick is enabled
+    if (consumer) {
         consumer->onButtonShortPress();
-    else if (!dismissedExt) // Don't change applet if this button press silenced the external notification module
-        inkhud->nextApplet();
+    } else if (!dismissedExt) { // Don't change applet if this button press silenced the external notification module
+        if (!settings->joystick.enabled)
+            inkhud->nextApplet();
+        else
+            inkhud->openMenu();
+    }
 }
 
 void InkHUD::Events::onButtonLong()
@@ -83,6 +88,156 @@ void InkHUD::Events::onButtonLong()
         inkhud->openMenu();
 }
 
+void InkHUD::Events::onExitShort()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        // If no system applet is handling input, default behavior instead is change tiles
+        if (consumer)
+            consumer->onExitShort();
+        else if (!dismissedExt) // Don't change tile if this button press silenced the external notification module
+            inkhud->nextTile();
+    }
+}
+
+void InkHUD::Events::onExitLong()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Slightly longer than playChirp
+        playBoop();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        if (consumer)
+            consumer->onExitLong();
+    }
+}
+
+void InkHUD::Events::onNavUp()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        if (consumer)
+            consumer->onNavUp();
+    }
+}
+
+void InkHUD::Events::onNavDown()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        if (consumer)
+            consumer->onNavDown();
+    }
+}
+
+void InkHUD::Events::onNavLeft()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        // If no system applet is handling input, default behavior instead is to cycle applets
+        if (consumer)
+            consumer->onNavLeft();
+        else if (!dismissedExt) // Don't change applet if this button press silenced the external notification module
+            inkhud->prevApplet();
+    }
+}
+
+void InkHUD::Events::onNavRight()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        // If no system applet is handling input, default behavior instead is to cycle applets
+        if (consumer)
+            consumer->onNavRight();
+        else if (!dismissedExt) // Don't change applet if this button press silenced the external notification module
+            inkhud->nextApplet();
+    }
+}
+
 // Callback for deepSleepObserver
 // Returns 0 to signal that we agree to sleep now
 int InkHUD::Events::beforeDeepSleep(void *unused)

src/graphics/niche/InkHUD/Events.h

@@ -29,6 +29,12 @@ 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
 
     int beforeDeepSleep(void *unused);                             // Prepare for shutdown
     int beforeReboot(void *unused);                                // Prepare for reboot

src/graphics/niche/InkHUD/InkHUD.cpp

@@ -80,6 +80,94 @@ void InkHUD::InkHUD::longpress()
     events->onButtonLong();
 }
 
+// Call this when your exit button gets a short press
+void InkHUD::InkHUD::exitShort()
+{
+    events->onExitShort();
+}
+
+// Call this when your exit button gets a long press
+void InkHUD::InkHUD::exitLong()
+{
+    events->onExitLong();
+}
+
+// Call this when your joystick gets an up input
+void InkHUD::InkHUD::navUp()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavLeft();
+        break;
+    case 2: // 180 deg
+        events->onNavDown();
+        break;
+    case 3: // 270 deg
+        events->onNavRight();
+        break;
+    default: // 0 deg
+        events->onNavUp();
+        break;
+    }
+}
+
+// Call this when your joystick gets a down input
+void InkHUD::InkHUD::navDown()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavRight();
+        break;
+    case 2: // 180 deg
+        events->onNavUp();
+        break;
+    case 3: // 270 deg
+        events->onNavLeft();
+        break;
+    default: // 0 deg
+        events->onNavDown();
+        break;
+    }
+}
+
+// Call this when your joystick gets a left input
+void InkHUD::InkHUD::navLeft()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavDown();
+        break;
+    case 2: // 180 deg
+        events->onNavRight();
+        break;
+    case 3: // 270 deg
+        events->onNavUp();
+        break;
+    default: // 0 deg
+        events->onNavLeft();
+        break;
+    }
+}
+
+// Call this when your joystick gets a right input
+void InkHUD::InkHUD::navRight()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavUp();
+        break;
+    case 2: // 180 deg
+        events->onNavLeft();
+        break;
+    case 3: // 270 deg
+        events->onNavDown();
+        break;
+    default: // 0 deg
+        events->onNavRight();
+        break;
+    }
+}
+
 // Cycle the next user applet to the foreground
 // Only activated applets are cycled
 // If user has a multi-applet layout, the applets will cycle on the "focused tile"
@@ -88,6 +176,14 @@ void InkHUD::InkHUD::nextApplet()
     windowManager->nextApplet();
 }
 
+// Cycle the previous user applet to the foreground
+// Only activated applets are cycled
+// If user has a multi-applet layout, the applets will cycle on the "focused tile"
+void InkHUD::InkHUD::prevApplet()
+{
+    windowManager->prevApplet();
+}
+
 // Show the menu (on the the focused tile)
 // The applet previously displayed there will be restored once the menu closes
 void InkHUD::InkHUD::openMenu()
@@ -95,6 +191,12 @@ void InkHUD::InkHUD::openMenu()
     windowManager->openMenu();
 }
 
+// Bring AlignStick applet to the foreground
+void InkHUD::InkHUD::openAlignStick()
+{
+    windowManager->openAlignStick();
+}
+
 // In layouts where multiple applets are shown at once, change which tile is focused
 // The focused tile in the one which cycles applets on button short press, and displays menu on long press
 void InkHUD::InkHUD::nextTile()
@@ -102,12 +204,26 @@ void InkHUD::InkHUD::nextTile()
     windowManager->nextTile();
 }
 
+// In layouts where multiple applets are shown at once, change which tile is focused
+// The focused tile in the one which cycles applets on button short press, and displays menu on long press
+void InkHUD::InkHUD::prevTile()
+{
+    windowManager->prevTile();
+}
+
 // Rotate the display image by 90 degrees
 void InkHUD::InkHUD::rotate()
 {
     windowManager->rotate();
 }
 
+// rotate the joystick in 90 degree increments
+void InkHUD::InkHUD::rotateJoystick(uint8_t angle)
+{
+    persistence->settings.joystick.alignment += angle;
+    persistence->settings.joystick.alignment %= 4;
+}
+
 // Show / hide the battery indicator in top-right
 void InkHUD::InkHUD::toggleBatteryIcon()
 {

src/graphics/niche/InkHUD/InkHUD.h

@@ -55,15 +55,25 @@ class InkHUD
 
     void shortpress();
     void longpress();
+    void exitShort();
+    void exitLong();
+    void navUp();
+    void navDown();
+    void navLeft();
+    void navRight();
 
     // Trigger UI changes
     // - called by various InkHUD components
     // - suitable(?) for use by aux button, connected in variant nicheGraphics.h
 
     void nextApplet();
+    void prevApplet();
     void openMenu();
+    void openAlignStick();
     void nextTile();
+    void prevTile();
     void rotate();
+    void rotateJoystick(uint8_t angle = 1); // rotate 90 deg by default
     void toggleBatteryIcon();
 
     // Updating the display

src/graphics/niche/InkHUD/Persistence.h

@@ -29,7 +29,7 @@ class Persistence
 
     // Used to invalidate old settings, if needed
     // Version 0 is reserved for testing, and will always load defaults
-    static constexpr uint32_t SETTINGS_VERSION = 2;
+    static constexpr uint32_t SETTINGS_VERSION = 3;
 
     struct Settings {
         struct Meta {
@@ -96,6 +96,19 @@ class Persistence
             bool safeShutdownSeen = false;
         } tips;
 
+        // Joystick settings for enabling and aligning to the screen
+        struct Joystick {
+            // Modifies the UI for joystick use
+            bool enabled = false;
+
+            // gets set to true when AlignStick applet is completed
+            bool aligned = false;
+
+            // Rotation of the joystick
+            // Multiples of 90 degrees clockwise
+            uint8_t alignment = 0;
+        } joystick;
+
         // Rotation of the display
         // Multiples of 90 degrees clockwise
         // Most commonly: rotation is 0 when flex connector is oriented below display

src/graphics/niche/InkHUD/WindowManager.cpp

@@ -2,6 +2,7 @@
 
 #include "./WindowManager.h"
 
+#include "./Applets/System/AlignStick/AlignStickApplet.h"
 #include "./Applets/System/BatteryIcon/BatteryIconApplet.h"
 #include "./Applets/System/Logo/LogoApplet.h"
 #include "./Applets/System/Menu/MenuApplet.h"
@@ -98,6 +99,38 @@ void InkHUD::WindowManager::nextTile()
         userTiles.at(settings->userTiles.focused)->requestHighlight();
 }
 
+// Focus on a different tile but decrement index
+void InkHUD::WindowManager::prevTile()
+{
+    // Close the menu applet if open
+    // We don't *really* want to do this, but it simplifies handling *a lot*
+    MenuApplet *menu = (MenuApplet *)inkhud->getSystemApplet("Menu");
+    bool menuWasOpen = false;
+    if (menu->isForeground()) {
+        menu->sendToBackground();
+        menuWasOpen = true;
+    }
+
+    // Swap to next tile
+    if (settings->userTiles.focused == 0)
+        settings->userTiles.focused = settings->userTiles.count - 1;
+    else
+        settings->userTiles.focused--;
+
+    // Make sure that we don't get stuck on the placeholder tile
+    refocusTile();
+
+    if (menuWasOpen)
+        menu->show(userTiles.at(settings->userTiles.focused));
+
+    // Ask the tile to draw an indicator showing which tile is now focused
+    // Requests a render
+    // We only draw this indicator if the device uses an aux button to switch tiles.
+    // Assume aux button is used to switch tiles if the "next tile" menu item is hidden
+    if (!settings->optionalMenuItems.nextTile)
+        userTiles.at(settings->userTiles.focused)->requestHighlight();
+}
+
 // Show the menu (on the the focused tile)
 // The applet previously displayed there will be restored once the menu closes
 void InkHUD::WindowManager::openMenu()
@@ -106,6 +139,15 @@ void InkHUD::WindowManager::openMenu()
     menu->show(userTiles.at(settings->userTiles.focused));
 }
 
+// Bring the AlignStick applet to the foreground
+void InkHUD::WindowManager::openAlignStick()
+{
+    if (settings->joystick.enabled) {
+        AlignStickApplet *alignStick = (AlignStickApplet *)inkhud->getSystemApplet("AlignStick");
+        alignStick->bringToForeground();
+    }
+}
+
 // On the currently focussed tile: cycle to the next available user applet
 // Applets available for this must be activated, and not already displayed on another tile
 void InkHUD::WindowManager::nextApplet()
@@ -155,6 +197,59 @@ void InkHUD::WindowManager::nextApplet()
     inkhud->forceUpdate(EInk::UpdateTypes::FAST); // bringToForeground already requested, but we're manually forcing FAST
 }
 
+// On the currently focussed tile: cycle to the previous available user applet
+// Applets available for this must be activated, and not already displayed on another tile
+void InkHUD::WindowManager::prevApplet()
+{
+    Tile *t = userTiles.at(settings->userTiles.focused);
+
+    // Abort if zero applets available
+    // nullptr means WindowManager::refocusTile determined that there were no available applets
+    if (!t->getAssignedApplet())
+        return;
+
+    // Find the index of the applet currently shown on the tile
+    uint8_t appletIndex = -1;
+    for (uint8_t i = 0; i < inkhud->userApplets.size(); i++) {
+        if (inkhud->userApplets.at(i) == t->getAssignedApplet()) {
+            appletIndex = i;
+            break;
+        }
+    }
+
+    // Confirm that we did find the applet
+    assert(appletIndex != (uint8_t)-1);
+
+    // Iterate forward through the WindowManager::applets, looking for the previous valid applet
+    Applet *prevValidApplet = nullptr;
+    for (uint8_t i = 1; i < inkhud->userApplets.size(); i++) {
+        uint8_t newAppletIndex = 0;
+        if (i > appletIndex)
+            newAppletIndex = inkhud->userApplets.size() + appletIndex - i;
+        else
+            newAppletIndex = (appletIndex - i);
+        Applet *a = inkhud->userApplets.at(newAppletIndex);
+
+        // Looking for an applet which is active (enabled by user), but currently in background
+        if (a->isActive() && !a->isForeground()) {
+            prevValidApplet = a;
+            settings->userTiles.displayedUserApplet[settings->userTiles.focused] =
+                newAppletIndex; // Remember this setting between boots!
+            break;
+        }
+    }
+
+    // Confirm that we found another applet
+    if (!prevValidApplet)
+        return;
+
+    // Hide old applet, show new applet
+    t->getAssignedApplet()->sendToBackground();
+    t->assignApplet(prevValidApplet);
+    prevValidApplet->bringToForeground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FAST); // bringToForeground already requested, but we're manually forcing FAST
+}
+
 // Rotate the display image by 90 degrees
 void InkHUD::WindowManager::rotate()
 {
@@ -338,6 +433,8 @@ void InkHUD::WindowManager::createSystemApplets()
     addSystemApplet("Logo", new LogoApplet, new Tile);
     addSystemApplet("Pairing", new PairingApplet, new Tile);
     addSystemApplet("Tips", new TipsApplet, new Tile);
+    if (settings->joystick.enabled)
+        addSystemApplet("AlignStick", new AlignStickApplet, new Tile);
 
     addSystemApplet("Menu", new MenuApplet, nullptr);
 
@@ -360,6 +457,8 @@ void InkHUD::WindowManager::placeSystemTiles()
     inkhud->getSystemApplet("Logo")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
     inkhud->getSystemApplet("Pairing")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
     inkhud->getSystemApplet("Tips")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
+    if (settings->joystick.enabled)
+        inkhud->getSystemApplet("AlignStick")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
 
     inkhud->getSystemApplet("Notification")->getTile()->setRegion(0, 0, inkhud->width(), 20);
 

src/graphics/niche/InkHUD/WindowManager.h

@@ -28,8 +28,11 @@ class WindowManager
     // - call these to make stuff change
 
     void nextTile();
+    void prevTile();
     void openMenu();
+    void openAlignStick();
     void nextApplet();
+    void prevApplet();
     void rotate();
     void toggleBatteryIcon();
 

src/graphics/niche/Inputs/TwoButtonExtended.cpp

@@ -0,0 +1,523 @@
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "./TwoButtonExtended.h"
+
+#include "NodeDB.h" // For the helper function TwoButtonExtended::getUserButtonPin
+#include "PowerFSM.h"
+#include "sleep.h"
+
+using namespace NicheGraphics::Inputs;
+
+TwoButtonExtended::TwoButtonExtended() : concurrency::OSThread("TwoButtonExtended")
+{
+    // Don't start polling buttons for release immediately
+    // Assume they are in a "released" state at boot
+    OSThread::disable();
+
+#ifdef ARCH_ESP32
+    // Register callbacks for before and after lightsleep
+    lsObserver.observe(&notifyLightSleep);
+    lsEndObserver.observe(&notifyLightSleepEnd);
+#endif
+
+    // Explicitly initialize these, just to keep cppcheck quiet..
+    buttons[0] = Button();
+    buttons[1] = Button();
+    joystick[Direction::UP] = SimpleButton();
+    joystick[Direction::DOWN] = SimpleButton();
+    joystick[Direction::LEFT] = SimpleButton();
+    joystick[Direction::RIGHT] = SimpleButton();
+}
+
+// Get access to (or create) the singleton instance of this class
+// Accessible inside the ISRs, even though we maybe shouldn't
+TwoButtonExtended *TwoButtonExtended::getInstance()
+{
+    // Instantiate the class the first time this method is called
+    static TwoButtonExtended *const singletonInstance = new TwoButtonExtended;
+
+    return singletonInstance;
+}
+
+// Begin receiving button input
+// We probably need to do this after sleep, as well as at boot
+void TwoButtonExtended::start()
+{
+    if (buttons[0].pin != 0xFF)
+        attachInterrupt(buttons[0].pin, TwoButtonExtended::isrPrimary, buttons[0].activeLogic == LOW ? FALLING : RISING);
+
+    if (buttons[1].pin != 0xFF)
+        attachInterrupt(buttons[1].pin, TwoButtonExtended::isrSecondary, buttons[1].activeLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::UP].pin != 0xFF)
+        attachInterrupt(joystick[Direction::UP].pin, TwoButtonExtended::isrJoystickUp,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::DOWN].pin != 0xFF)
+        attachInterrupt(joystick[Direction::DOWN].pin, TwoButtonExtended::isrJoystickDown,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::LEFT].pin != 0xFF)
+        attachInterrupt(joystick[Direction::LEFT].pin, TwoButtonExtended::isrJoystickLeft,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::RIGHT].pin != 0xFF)
+        attachInterrupt(joystick[Direction::RIGHT].pin, TwoButtonExtended::isrJoystickRight,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+}
+
+// Stop receiving button input, and run custom sleep code
+// Called before device sleeps. This might be power-off, or just ESP32 light sleep
+// Some devices will want to attach interrupts here, for the user button to wake from sleep
+void TwoButtonExtended::stop()
+{
+    if (buttons[0].pin != 0xFF)
+        detachInterrupt(buttons[0].pin);
+
+    if (buttons[1].pin != 0xFF)
+        detachInterrupt(buttons[1].pin);
+
+    if (joystick[Direction::UP].pin != 0xFF)
+        detachInterrupt(joystick[Direction::UP].pin);
+
+    if (joystick[Direction::DOWN].pin != 0xFF)
+        detachInterrupt(joystick[Direction::DOWN].pin);
+
+    if (joystick[Direction::LEFT].pin != 0xFF)
+        detachInterrupt(joystick[Direction::LEFT].pin);
+
+    if (joystick[Direction::RIGHT].pin != 0xFF)
+        detachInterrupt(joystick[Direction::RIGHT].pin);
+}
+
+// Attempt to resolve a GPIO pin for the user button, honoring userPrefs.jsonc and device settings
+// This helper method isn't used by the TwoButtonExtended class itself, it could be moved elsewhere.
+// Intention is to pass this value to TwoButtonExtended::setWiring in the setupNicheGraphics method.
+uint8_t TwoButtonExtended::getUserButtonPin()
+{
+    uint8_t pin = 0xFF; // Unset
+
+    // Use default pin for variant, if no better source
+#ifdef BUTTON_PIN
+    pin = BUTTON_PIN;
+#endif
+
+    // From userPrefs.jsonc, if set
+#ifdef USERPREFS_BUTTON_PIN
+    pin = USERPREFS_BUTTON_PIN;
+#endif
+
+    // From user's override in device settings, if set
+    if (config.device.button_gpio)
+        pin = config.device.button_gpio;
+
+    return pin;
+}
+
+// Configures the wiring and logic of either button
+// Called when outlining your NicheGraphics implementation, in variant/nicheGraphics.cpp
+void TwoButtonExtended::setWiring(uint8_t whichButton, uint8_t pin, bool internalPullup)
+{
+    // Prevent the same GPIO being assigned to multiple buttons
+    // Allows an edge case when the user remaps hardware buttons using device settings, due to a broken user button
+    for (uint8_t i = 0; i < whichButton; i++) {
+        if (buttons[i].pin == pin) {
+            LOG_WARN("Attempted reuse of GPIO %d. Ignoring assignment whichButton=%d", pin, whichButton);
+            return;
+        }
+    }
+
+    assert(whichButton < 2);
+    buttons[whichButton].pin = pin;
+    buttons[whichButton].activeLogic = LOW;
+
+    pinMode(buttons[whichButton].pin, internalPullup ? INPUT_PULLUP : INPUT);
+}
+
+// Configures the wiring and logic of the joystick buttons
+// Called when outlining your NicheGraphics implementation, in variant/nicheGraphics.cpp
+void TwoButtonExtended::setJoystickWiring(uint8_t uPin, uint8_t dPin, uint8_t lPin, uint8_t rPin, bool internalPullup)
+{
+    if (joystick[Direction::UP].pin == uPin || joystick[Direction::DOWN].pin == dPin || joystick[Direction::LEFT].pin == lPin ||
+        joystick[Direction::RIGHT].pin == rPin) {
+        LOG_WARN("Attempted reuse of Joystick GPIO. Ignoring assignment");
+        return;
+    }
+
+    joystick[Direction::UP].pin = uPin;
+    joystick[Direction::DOWN].pin = dPin;
+    joystick[Direction::LEFT].pin = lPin;
+    joystick[Direction::RIGHT].pin = rPin;
+    joystickActiveLogic = LOW;
+
+    pinMode(joystick[Direction::UP].pin, internalPullup ? INPUT_PULLUP : INPUT);
+    pinMode(joystick[Direction::DOWN].pin, internalPullup ? INPUT_PULLUP : INPUT);
+    pinMode(joystick[Direction::LEFT].pin, internalPullup ? INPUT_PULLUP : INPUT);
+    pinMode(joystick[Direction::RIGHT].pin, internalPullup ? INPUT_PULLUP : INPUT);
+}
+
+void TwoButtonExtended::setTiming(uint8_t whichButton, uint32_t debounceMs, uint32_t longpressMs)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].debounceLength = debounceMs;
+    buttons[whichButton].longpressLength = longpressMs;
+}
+
+void TwoButtonExtended::setJoystickDebounce(uint32_t debounceMs)
+{
+    joystickDebounceLength = debounceMs;
+}
+
+// Set what should happen when a button becomes pressed
+// Use this to implement a "while held" behavior
+void TwoButtonExtended::setHandlerDown(uint8_t whichButton, Callback onDown)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onDown = onDown;
+}
+
+// Set what should happen when a button becomes unpressed
+// Use this to implement a "While held" behavior
+void TwoButtonExtended::setHandlerUp(uint8_t whichButton, Callback onUp)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onUp = onUp;
+}
+
+// Set what should happen when a "short press" event has occurred
+void TwoButtonExtended::setHandlerShortPress(uint8_t whichButton, Callback onPress)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onPress = onPress;
+}
+
+// Set what should happen when a "long press" event has fired
+// Note: this will occur while the button is still held
+void TwoButtonExtended::setHandlerLongPress(uint8_t whichButton, Callback onLongPress)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onLongPress = onLongPress;
+}
+
+// Set what should happen when a joystick button becomes pressed
+// Use this to implement a "while held" behavior
+void TwoButtonExtended::setJoystickDownHandlers(Callback uDown, Callback dDown, Callback lDown, Callback rDown)
+{
+    joystick[Direction::UP].onDown = uDown;
+    joystick[Direction::DOWN].onDown = dDown;
+    joystick[Direction::LEFT].onDown = lDown;
+    joystick[Direction::RIGHT].onDown = rDown;
+}
+
+// Set what should happen when a joystick button becomes unpressed
+// Use this to implement a "while held" behavior
+void TwoButtonExtended::setJoystickUpHandlers(Callback uUp, Callback dUp, Callback lUp, Callback rUp)
+{
+    joystick[Direction::UP].onUp = uUp;
+    joystick[Direction::DOWN].onUp = dUp;
+    joystick[Direction::LEFT].onUp = lUp;
+    joystick[Direction::RIGHT].onUp = rUp;
+}
+
+// Set what should happen when a "press" event has fired
+// Note: this will occur while the joystick button is still held
+void TwoButtonExtended::setJoystickPressHandlers(Callback uPress, Callback dPress, Callback lPress, Callback rPress)
+{
+    joystick[Direction::UP].onPress = uPress;
+    joystick[Direction::DOWN].onPress = dPress;
+    joystick[Direction::LEFT].onPress = lPress;
+    joystick[Direction::RIGHT].onPress = rPress;
+}
+
+// Handle the start of a press to the primary button
+// Wakes our button thread
+void TwoButtonExtended::isrPrimary()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->buttons[0].state == State::REST) {
+            b->buttons[0].state = State::IRQ;
+            b->buttons[0].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+// Handle the start of a press to the secondary button
+// Wakes our button thread
+void TwoButtonExtended::isrSecondary()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->buttons[1].state == State::REST) {
+            b->buttons[1].state = State::IRQ;
+            b->buttons[1].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+// Handle the start of a press to the joystick buttons
+// Also wakes our button thread
+void TwoButtonExtended::isrJoystickUp()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::UP].state == State::REST) {
+            b->joystick[Direction::UP].state = State::IRQ;
+            b->joystick[Direction::UP].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+void TwoButtonExtended::isrJoystickDown()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::DOWN].state == State::REST) {
+            b->joystick[Direction::DOWN].state = State::IRQ;
+            b->joystick[Direction::DOWN].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+void TwoButtonExtended::isrJoystickLeft()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::LEFT].state == State::REST) {
+            b->joystick[Direction::LEFT].state = State::IRQ;
+            b->joystick[Direction::LEFT].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+void TwoButtonExtended::isrJoystickRight()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::RIGHT].state == State::REST) {
+            b->joystick[Direction::RIGHT].state = State::IRQ;
+            b->joystick[Direction::RIGHT].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+// Concise method to start our button thread
+// Follows an ISR, listening for button release
+void TwoButtonExtended::startThread()
+{
+    if (!OSThread::enabled) {
+        OSThread::setInterval(10);
+        OSThread::enabled = true;
+    }
+}
+
+// Concise method to stop our button thread
+// Called when we no longer need to poll for button release
+void TwoButtonExtended::stopThread()
+{
+    if (OSThread::enabled) {
+        OSThread::disable();
+    }
+
+    // Reset both buttons manually
+    // Just in case an IRQ fires during the process of resetting the system
+    // Can occur with super rapid presses?
+    buttons[0].state = REST;
+    buttons[1].state = REST;
+    joystick[Direction::UP].state = REST;
+    joystick[Direction::DOWN].state = REST;
+    joystick[Direction::LEFT].state = REST;
+    joystick[Direction::RIGHT].state = REST;
+}
+
+// Our button thread
+// Started by an IRQ, on either button
+// Polls for button releases
+// Stops when both buttons released
+int32_t TwoButtonExtended::runOnce()
+{
+    constexpr uint8_t BUTTON_COUNT = sizeof(buttons) / sizeof(Button);
+    constexpr uint8_t JOYSTICK_COUNT = sizeof(joystick) / sizeof(SimpleButton);
+
+    // Allow either button to request that our thread should continue polling
+    bool awaitingRelease = false;
+
+    // Check both primary and secondary buttons
+    for (uint8_t i = 0; i < BUTTON_COUNT; i++) {
+        switch (buttons[i].state) {
+        // No action: button has not been pressed
+        case REST:
+            break;
+
+        // New press detected by interrupt
+        case IRQ:
+            powerFSM.trigger(EVENT_PRESS);             // Tell PowerFSM that press occurred (resets sleep timer)
+            buttons[i].onDown();                       // Run callback: press has begun (possible hold behavior)
+            buttons[i].state = State::POLLING_UNFIRED; // Mark that button-down has been handled
+            awaitingRelease = true;                    // Mark that polling-for-release should continue
+            break;
+
+        // An existing press continues
+        // Not held long enough to register as longpress
+        case POLLING_UNFIRED: {
+            uint32_t length = millis() - buttons[i].irqAtMillis;
+
+            // If button released since last thread tick,
+            if (digitalRead(buttons[i].pin) != buttons[i].activeLogic) {
+                buttons[i].onUp();              // Run callback: press has ended (possible release of a hold)
+                buttons[i].state = State::REST; // Mark that the button has reset
+                if (length > buttons[i].debounceLength && length < buttons[i].longpressLength) // If too short for longpress,
+                    buttons[i].onPress();                                                      // Run callback: press
+            }
+            // If button not yet released
+            else {
+                awaitingRelease = true; // Mark that polling-for-release should continue
+                if (length >= buttons[i].longpressLength) {
+                    // Run callback: long press (once)
+                    // Then continue waiting for release, to rearm
+                    buttons[i].state = State::POLLING_FIRED;
+                    buttons[i].onLongPress();
+                }
+            }
+            break;
+        }
+
+        // Button still held, but duration long enough that longpress event already fired
+        // Just waiting for release
+        case POLLING_FIRED:
+            // Release detected
+            if (digitalRead(buttons[i].pin) != buttons[i].activeLogic) {
+                buttons[i].state = State::REST;
+                buttons[i].onUp(); // Callback: release of hold (in this case: *after* longpress has fired)
+            }
+            // Not yet released, keep polling
+            else
+                awaitingRelease = true;
+            break;
+        }
+    }
+
+    // Check all the joystick directions
+    for (uint8_t i = 0; i < JOYSTICK_COUNT; i++) {
+        switch (joystick[i].state) {
+        // No action: button has not been pressed
+        case REST:
+            break;
+
+        // New press detected by interrupt
+        case IRQ:
+            powerFSM.trigger(EVENT_PRESS);              // Tell PowerFSM that press occurred (resets sleep timer)
+            joystick[i].onDown();                       // Run callback: press has begun (possible hold behavior)
+            joystick[i].state = State::POLLING_UNFIRED; // Mark that button-down has been handled
+            awaitingRelease = true;                     // Mark that polling-for-release should continue
+            break;
+
+        // An existing press continues
+        // Not held long enough to register as press
+        case POLLING_UNFIRED: {
+            uint32_t length = millis() - joystick[i].irqAtMillis;
+
+            // If button released since last thread tick,
+            if (digitalRead(joystick[i].pin) != joystickActiveLogic) {
+                joystick[i].onUp();              // Run callback: press has ended (possible release of a hold)
+                joystick[i].state = State::REST; // Mark that the button has reset
+            }
+            // If button not yet released
+            else {
+                awaitingRelease = true; // Mark that polling-for-release should continue
+                if (length >= joystickDebounceLength) {
+                    // Run callback: long press (once)
+                    // Then continue waiting for release, to rearm
+                    joystick[i].state = State::POLLING_FIRED;
+                    joystick[i].onPress();
+                }
+            }
+            break;
+        }
+
+        // Button still held after press
+        // Just waiting for release
+        case POLLING_FIRED:
+            // Release detected
+            if (digitalRead(joystick[i].pin) != joystickActiveLogic) {
+                joystick[i].state = State::REST;
+                joystick[i].onUp(); // Callback: release of hold
+            }
+            // Not yet released, keep polling
+            else
+                awaitingRelease = true;
+            break;
+        }
+    }
+
+    // If all buttons are now released
+    // we don't need to waste cpu resources polling
+    // IRQ will restart this thread when we next need it
+    if (!awaitingRelease)
+        stopThread();
+
+    // Run this method again, or don't..
+    // Use whatever behavior was previously set by stopThread() or startThread()
+    return OSThread::interval;
+}
+
+#ifdef ARCH_ESP32
+
+// Detach our class' interrupts before lightsleep
+// Allows sleep.cpp to configure its own interrupts, which wake the device on user-button press
+int TwoButtonExtended::beforeLightSleep(void *unused)
+{
+    stop();
+    return 0; // Indicates success
+}
+
+// Reconfigure our interrupts
+// Our class' interrupts were disconnected during sleep, to allow the user button to wake the device from sleep
+int TwoButtonExtended::afterLightSleep(esp_sleep_wakeup_cause_t cause)
+{
+    start();
+
+    // Manually trigger the button-down ISR
+    // - during light sleep, our ISR is disabled
+    // - if light sleep ends by button press, pretend our own ISR caught it
+    // - need to manually confirm by reading pin ourselves, to avoid occasional false positives
+    //   (false positive only when using internal pullup resistors?)
+    if (cause == ESP_SLEEP_WAKEUP_GPIO && digitalRead(buttons[0].pin) == buttons[0].activeLogic)
+        isrPrimary();
+
+    return 0; // Indicates success
+}
+
+#endif
+
+#endif

src/graphics/niche/Inputs/TwoButtonExtended.h

@@ -0,0 +1,136 @@
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+/*
+
+Re-usable NicheGraphics input source
+
+Short and Long press for up to two buttons
+Interrupt driven
+
+*/
+
+/*
+
+This expansion adds support for four more buttons
+These buttons are single-action only, no long press
+Interrupt driven
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#include "assert.h"
+#include "functional"
+
+#ifdef ARCH_ESP32
+#include "esp_sleep.h" // For light-sleep handling
+#endif
+
+#include "Observer.h"
+
+namespace NicheGraphics::Inputs
+{
+
+class TwoButtonExtended : protected concurrency::OSThread
+{
+  public:
+    typedef std::function<void()> Callback;
+
+    static uint8_t getUserButtonPin(); // Resolve the GPIO, considering the various possible source of definition
+
+    static TwoButtonExtended *getInstance(); // Create or get the singleton instance
+    void start();                            // Start handling button input
+    void stop();                             // Stop handling button input (disconnect ISRs for sleep)
+    void setWiring(uint8_t whichButton, uint8_t pin, bool internalPullup = false);
+    void setJoystickWiring(uint8_t uPin, uint8_t dPin, uint8_t lPin, uint8_t rPin, bool internalPullup = false);
+    void setTiming(uint8_t whichButton, uint32_t debounceMs, uint32_t longpressMs);
+    void setJoystickDebounce(uint32_t debounceMs);
+    void setHandlerDown(uint8_t whichButton, Callback onDown);
+    void setHandlerUp(uint8_t whichButton, Callback onUp);
+    void setHandlerShortPress(uint8_t whichButton, Callback onShortPress);
+    void setHandlerLongPress(uint8_t whichButton, Callback onLongPress);
+    void setJoystickDownHandlers(Callback uDown, Callback dDown, Callback ldown, Callback rDown);
+    void setJoystickUpHandlers(Callback uUp, Callback dUp, Callback lUp, Callback rUp);
+    void setJoystickPressHandlers(Callback uPress, Callback dPress, Callback lPress, Callback rPress);
+
+    // Disconnect and reconnect interrupts for light sleep
+#ifdef ARCH_ESP32
+    int beforeLightSleep(void *unused);
+    int afterLightSleep(esp_sleep_wakeup_cause_t cause);
+#endif
+
+  private:
+    // Internal state of a specific button
+    enum State {
+        REST,            // Up, no activity
+        IRQ,             // Down detected, not yet handled
+        POLLING_UNFIRED, // Down handled, polling for release
+        POLLING_FIRED,   // Longpress fired, button still held
+    };
+
+    // Joystick Directions
+    enum Direction { UP = 0, DOWN, LEFT, RIGHT };
+
+    // Data used for direction (single-action) buttons
+    class SimpleButton
+    {
+      public:
+        // Per-button config
+        uint8_t pin = 0xFF;                 // 0xFF: unset
+        volatile State state = State::REST; // Internal state
+        volatile uint32_t irqAtMillis;      // millis() when button went down
+
+        // Per-button event callbacks
+        static void noop(){};
+        std::function<void()> onDown = noop;
+        std::function<void()> onUp = noop;
+        std::function<void()> onPress = noop;
+    };
+
+    // Data used for double-action buttons
+    class Button : public SimpleButton
+    {
+      public:
+        // Per-button extended config
+        bool activeLogic = LOW;         // Active LOW by default.
+        uint32_t debounceLength = 50;   // Minimum length for shortpress in ms
+        uint32_t longpressLength = 500; // Time until longpress in ms
+
+        // Per-button event callbacks
+        std::function<void()> onLongPress = noop;
+    };
+
+#ifdef ARCH_ESP32
+    // Get notified when lightsleep begins and ends
+    CallbackObserver<TwoButtonExtended, void *> lsObserver =
+        CallbackObserver<TwoButtonExtended, void *>(this, &TwoButtonExtended::beforeLightSleep);
+    CallbackObserver<TwoButtonExtended, esp_sleep_wakeup_cause_t> lsEndObserver =
+        CallbackObserver<TwoButtonExtended, esp_sleep_wakeup_cause_t>(this, &TwoButtonExtended::afterLightSleep);
+#endif
+
+    int32_t runOnce() override; // Timer method. Polls for button release
+
+    void startThread(); // Start polling for release
+    void stopThread();  // Stop polling for release
+
+    static void isrPrimary();   // User Button ISR
+    static void isrSecondary(); // optional aux button or joystick center
+    static void isrJoystickUp();
+    static void isrJoystickDown();
+    static void isrJoystickLeft();
+    static void isrJoystickRight();
+
+    TwoButtonExtended(); // Constructor made private: force use of Button::instance()
+
+    // Info about both buttons
+    Button buttons[2];
+    bool joystickActiveLogic = LOW;       // Active LOW by default
+    uint32_t joystickDebounceLength = 50; // time until press in ms
+    SimpleButton joystick[4];
+};
+
+}; // namespace NicheGraphics::Inputs
+
+#endif

src/mesh/RadioInterface.cpp

@@ -323,9 +323,9 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(meshtastic_MeshPacket *p)
 void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
 {
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
-    std::string out = DEBUG_PORT.mt_sprintf(
-        "%s (id=0x%08x fr=0x%08x to=0x%08x, transport = %u, WantAck=%d, HopLim=%d HopStart=%d Ch=0x%x", prefix, p->id, p->from,
-        p->to, p->transport_mechanism, p->want_ack, p->hop_limit, p->hop_start, p->channel);
+    std::string out =
+        DEBUG_PORT.mt_sprintf("%s (id=0x%08x fr=0x%08x to=0x%08x, transport = %u, WantAck=%d, HopLim=%d Ch=0x%x", prefix, p->id,
+                              p->from, p->to, p->transport_mechanism, p->want_ack, p->hop_limit, p->channel);
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
         auto &s = p->decoded;
 

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

@@ -33,3 +33,5 @@ PB_BIND(meshtastic_KeyVerificationAdmin, meshtastic_KeyVerificationAdmin, AUTO)
 
 
 
+
+

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

@@ -16,6 +16,16 @@
 #endif
 
 /* Enum definitions */
+/* Firmware update mode for OTA updates */
+typedef enum _meshtastic_OTAMode {
+    /* Do not reboot into OTA mode */
+    meshtastic_OTAMode_NO_REBOOT_OTA = 0,
+    /* Reboot into OTA mode for BLE firmware update */
+    meshtastic_OTAMode_OTA_BLE = 1,
+    /* Reboot into OTA mode for WiFi firmware update */
+    meshtastic_OTAMode_OTA_WIFI = 2
+} meshtastic_OTAMode;
+
 /* TODO: REPLACE */
 typedef enum _meshtastic_AdminMessage_ConfigType {
     /* TODO: REPLACE */
@@ -258,10 +268,13 @@ typedef struct _meshtastic_AdminMessage {
         meshtastic_SharedContact add_contact;
         /* Initiate or respond to a key verification request */
         meshtastic_KeyVerificationAdmin key_verification;
+        /* Tell the node to reboot into OTA mode for firmware update via BLE or WiFi (ESP32 only for now) */
+        meshtastic_OTAMode reboot_ota_mode;
         /* Tell the node to factory reset config everything; all device state and configuration will be returned to factory defaults and BLE bonds will be cleared. */
         int32_t factory_reset_device;
         /* Tell the node to reboot into the OTA Firmware in this many seconds (or <0 to cancel reboot)
-     Only Implemented for ESP32 Devices. This needs to be issued to send a new main firmware via bluetooth. */
+     Only Implemented for ESP32 Devices. This needs to be issued to send a new main firmware via bluetooth.
+     Deprecated in favor of reboot_ota_mode in 2.7.17 */
         int32_t reboot_ota_seconds;
         /* This message is only supported for the simulator Portduino build.
      If received the simulator will exit successfully. */
@@ -288,6 +301,10 @@ extern "C" {
 #endif
 
 /* Helper constants for enums */
+#define _meshtastic_OTAMode_MIN meshtastic_OTAMode_NO_REBOOT_OTA
+#define _meshtastic_OTAMode_MAX meshtastic_OTAMode_OTA_WIFI
+#define _meshtastic_OTAMode_ARRAYSIZE ((meshtastic_OTAMode)(meshtastic_OTAMode_OTA_WIFI+1))
+
 #define _meshtastic_AdminMessage_ConfigType_MIN meshtastic_AdminMessage_ConfigType_DEVICE_CONFIG
 #define _meshtastic_AdminMessage_ConfigType_MAX meshtastic_AdminMessage_ConfigType_DEVICEUI_CONFIG
 #define _meshtastic_AdminMessage_ConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ConfigType)(meshtastic_AdminMessage_ConfigType_DEVICEUI_CONFIG+1))
@@ -309,6 +326,7 @@ extern "C" {
 #define meshtastic_AdminMessage_payload_variant_backup_preferences_ENUMTYPE meshtastic_AdminMessage_BackupLocation
 #define meshtastic_AdminMessage_payload_variant_restore_preferences_ENUMTYPE meshtastic_AdminMessage_BackupLocation
 #define meshtastic_AdminMessage_payload_variant_remove_backup_preferences_ENUMTYPE meshtastic_AdminMessage_BackupLocation
+#define meshtastic_AdminMessage_payload_variant_reboot_ota_mode_ENUMTYPE meshtastic_OTAMode
 
 
 
@@ -396,6 +414,7 @@ extern "C" {
 #define meshtastic_AdminMessage_commit_edit_settings_tag 65
 #define meshtastic_AdminMessage_add_contact_tag  66
 #define meshtastic_AdminMessage_key_verification_tag 67
+#define meshtastic_AdminMessage_reboot_ota_mode_tag 68
 #define meshtastic_AdminMessage_factory_reset_device_tag 94
 #define meshtastic_AdminMessage_reboot_ota_seconds_tag 95
 #define meshtastic_AdminMessage_exit_simulator_tag 96
@@ -454,6 +473,7 @@ X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,begin_edit_settings,begin_ed
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,commit_edit_settings,commit_edit_settings),  65) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,add_contact,add_contact),  66) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,key_verification,key_verification),  67) \
+X(a, STATIC,   ONEOF,    UENUM,    (payload_variant,reboot_ota_mode,reboot_ota_mode),  68) \
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,factory_reset_device,factory_reset_device),  94) \
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,reboot_ota_seconds,reboot_ota_seconds),  95) \
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,exit_simulator,exit_simulator),  96) \

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

@@ -822,8 +822,6 @@ typedef struct _meshtastic_StoreForwardPlusPlus {
     uint32_t encapsulated_from;
     /* The receive time of the message in question */
     uint32_t encapsulated_rxtime;
-    /* Used in a LINK_REQUEST to specify the message X spots back from head */
-    uint32_t chain_count;
 } meshtastic_StoreForwardPlusPlus;
 
 /* Waypoint message, used to share arbitrary locations across the mesh */
@@ -1430,7 +1428,7 @@ extern "C" {
 #define meshtastic_Routing_init_default          {0, {meshtastic_RouteDiscovery_init_default}}
 #define meshtastic_Data_init_default             {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
 #define meshtastic_KeyVerification_init_default  {0, {0, {0}}, {0, {0}}}
-#define meshtastic_StoreForwardPlusPlus_init_default {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0, 0}
+#define meshtastic_StoreForwardPlusPlus_init_default {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0}
 #define meshtastic_Waypoint_init_default         {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_MqttClientProxyMessage_init_default {"", 0, {{0, {0}}}, 0}
 #define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
@@ -1462,7 +1460,7 @@ extern "C" {
 #define meshtastic_Routing_init_zero             {0, {meshtastic_RouteDiscovery_init_zero}}
 #define meshtastic_Data_init_zero                {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
 #define meshtastic_KeyVerification_init_zero     {0, {0, {0}}, {0, {0}}}
-#define meshtastic_StoreForwardPlusPlus_init_zero {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0, 0}
+#define meshtastic_StoreForwardPlusPlus_init_zero {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0}
 #define meshtastic_Waypoint_init_zero            {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_MqttClientProxyMessage_init_zero {"", 0, {{0, {0}}}, 0}
 #define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
@@ -1550,7 +1548,6 @@ extern "C" {
 #define meshtastic_StoreForwardPlusPlus_encapsulated_to_tag 7
 #define meshtastic_StoreForwardPlusPlus_encapsulated_from_tag 8
 #define meshtastic_StoreForwardPlusPlus_encapsulated_rxtime_tag 9
-#define meshtastic_StoreForwardPlusPlus_chain_count_tag 10
 #define meshtastic_Waypoint_id_tag               1
 #define meshtastic_Waypoint_latitude_i_tag       2
 #define meshtastic_Waypoint_longitude_i_tag      3
@@ -1776,8 +1773,7 @@ X(a, STATIC,   SINGULAR, BYTES,    message,           5) \
 X(a, STATIC,   SINGULAR, UINT32,   encapsulated_id,   6) \
 X(a, STATIC,   SINGULAR, UINT32,   encapsulated_to,   7) \
 X(a, STATIC,   SINGULAR, UINT32,   encapsulated_from,   8) \
-X(a, STATIC,   SINGULAR, UINT32,   encapsulated_rxtime,   9) \
-X(a, STATIC,   SINGULAR, UINT32,   chain_count,      10)
+X(a, STATIC,   SINGULAR, UINT32,   encapsulated_rxtime,   9)
 #define meshtastic_StoreForwardPlusPlus_CALLBACK NULL
 #define meshtastic_StoreForwardPlusPlus_DEFAULT NULL
 
@@ -2147,7 +2143,7 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_QueueStatus_size              23
 #define meshtastic_RouteDiscovery_size           256
 #define meshtastic_Routing_size                  259
-#define meshtastic_StoreForwardPlusPlus_size     377
+#define meshtastic_StoreForwardPlusPlus_size     371
 #define meshtastic_ToRadio_size                  504
 #define meshtastic_User_size                     115
 #define meshtastic_Waypoint_size                 165

src/modules/Modules.cpp

@@ -61,7 +61,6 @@
 #if ARCH_PORTDUINO
 #include "input/LinuxInputImpl.h"
 #include "input/SeesawRotary.h"
-#include "modules/Native/StoreForwardPlusPlus.h"
 #include "modules/Telemetry/HostMetrics.h"
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
 #include "modules/StoreForwardModule.h"
@@ -244,9 +243,6 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
     new HostMetricsModule();
-#if SFPP_ENABLED
-    new StoreForwardPlusPlusModule();
-#endif
 #endif
 #if HAS_TELEMETRY
     new DeviceTelemetryModule();

src/modules/Native/StoreForwardPlusPlus.h

@@ -1,221 +0,0 @@
-#pragma once
-#if __has_include("sqlite3.h")
-#define SFPP_ENABLED 1
-#include "Channels.h"
-#include "ProtobufModule.h"
-#include "Router.h"
-#include "SinglePortModule.h"
-#include "sqlite3.h"
-
-/**
- * Store and forward ++ module
- * There's an obvious need for a store-and-forward mechanism in Meshtastic.
- * This module takes heavy inspiration from Git, building a chain of messages that can be synced between nodes.
- * Each message is hashed, and the chain is built by hashing the previous commit hash and the current message hash.
- * Nodes can request missing messages by requesting the next message after a given commit hash.
- *
- * The current focus is text messages, limited to the primary channel.
- *
- * Each chain is identified by a root hash, which is derived from the channelHash, the local nodenum, and the timestamp when
- * created.
- *
- * Each message is also given a message hash, derived from the encrypted payload, the to, from, id.
- * Notably not the timestamp, as we want these to match across nodes, even if the timestamps differ.
- *
- * The authoritative node for the chain will generate a commit hash for each message when adding it to the chain.
- * The first message's commit hash is derived from the root hash and the message hash.
- * Subsequent messages' commit hashes are derived from the previous commit hash and the current message hash.
- * This allows a node to see only the last commit hash, and confirm it hasn't missed any messages.
- *
- * Nodes can request the next message in the chain by sending a LINK_REQUEST message with the root hash and the last known commit
- * hash. Any node that has the next message can respond with a LINK_PROVIDE message containing the next message.
- *
- * When a satellite node sees a new text message, it stores it in a scratch database.
- * These messages are periodically offered to the authoritative node for inclusion in the chain.
- *
- * The LINK_PROVIDE message does double-duty, sending both on-chain and off-chain messages.
- * The differentiator is whether the commit hash is set or left empty.
- *
- * When a satellite node receives a canonical link message, it checks if it has the message in scratch.
- * And evicts it when adding it to the canonical chain.
- *
- * This approach allows a node to know whether it has seen a given message before, or if it is new coming via SFPP.
- * If new, and the timestamp is within the rebroadcast timeout, it will process that message as if it were just received from the
- * mesh, allowing it to be decrypted, shown to the user, and rebroadcast.
- */
-class StoreForwardPlusPlusModule : public ProtobufModule<meshtastic_StoreForwardPlusPlus>, private concurrency::OSThread
-{
-    struct link_object {
-        uint32_t to;
-        uint32_t from;
-        uint32_t id;
-        uint32_t rx_time = 0;
-        ChannelHash channel_hash;
-        uint8_t encrypted_bytes[256] = {0};
-        size_t encrypted_len;
-        uint8_t message_hash[32] = {0};
-        size_t message_hash_len = 0;
-        uint8_t root_hash[32] = {0};
-        size_t root_hash_len = 0;
-        uint8_t commit_hash[32] = {0};
-        size_t commit_hash_len = 0;
-        uint32_t counter = 0;
-        std::string payload;
-        bool validObject = true; // set this false when a chain calulation fails, etc.
-    };
-
-  public:
-    /** Constructor
-     *
-     */
-    StoreForwardPlusPlusModule();
-
-    /*
-      -Override the wantPacket method.
-    */
-    virtual bool wantPacket(const meshtastic_MeshPacket *p) override
-    {
-        switch (p->decoded.portnum) {
-        case meshtastic_PortNum_TEXT_MESSAGE_APP:
-        case meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-  protected:
-    /** Called to handle a particular incoming message
-    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for
-    it
-    */
-    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
-    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_StoreForwardPlusPlus *t) override;
-
-    virtual int32_t runOnce() override;
-
-  private:
-    sqlite3 *ppDb;
-    sqlite3_stmt *chain_insert_stmt;
-    sqlite3_stmt *scratch_insert_stmt;
-    sqlite3_stmt *checkDup;
-    sqlite3_stmt *checkScratch;
-    sqlite3_stmt *removeScratch;
-    sqlite3_stmt *updatePayloadStmt;
-    sqlite3_stmt *getPayloadFromScratchStmt;
-    sqlite3_stmt *fromScratchStmt;
-    sqlite3_stmt *fromScratchByHashStmt;
-    sqlite3_stmt *getNextHashStmt;
-    sqlite3_stmt *getChainEndStmt;
-    sqlite3_stmt *getLinkStmt;
-    sqlite3_stmt *getHashFromRootStmt;
-    sqlite3_stmt *addRootToMappingsStmt;
-    sqlite3_stmt *getRootFromChannelHashStmt;
-    sqlite3_stmt *getFullRootHashStmt;
-    sqlite3_stmt *setChainCountStmt;
-    sqlite3_stmt *getChainCountStmt;
-
-    // For a given Meshtastic ChannelHash, fills the root_hash buffer with a 32-byte root hash
-    // returns true if the root hash was found
-    bool getRootFromChannelHash(ChannelHash, uint8_t *);
-
-    // For a given root hash, returns the ChannelHash
-    // can handle partial root hashes
-    ChannelHash getChannelHashFromRoot(uint8_t *_root_hash, size_t);
-
-    // given a root hash and commit hash, returns the next commit hash in the chain
-    // can handle partial root and commit hashes, always fills the buffer with 32 bytes
-    // returns true if a next hash was found
-    bool getNextHash(uint8_t *, size_t, uint8_t *, size_t, uint8_t *);
-
-    // For a given Meshtastic ChannelHash, fills the root_hash buffer with a 32-byte root hash
-    // but this function will add the root hash if it is not already present
-    // returns true if the hash is new
-    bool getOrAddRootFromChannelHash(ChannelHash, uint8_t *);
-
-    // adds the ChannelHash and root_hash to the mappings table
-    void addRootToMappings(ChannelHash, uint8_t *);
-
-    // requests the next message in the chain from the mesh network
-    // Sends a LINK_REQUEST message
-    void requestNextMessage(uint8_t *, size_t, uint8_t *, size_t);
-
-    // request the message X entries from the end.
-    // used to bootstrap a chain, without downloading all of the history
-    void requestMessageCount(uint8_t *, size_t, uint32_t);
-
-    // sends a LINK_PROVIDE message broadcasting the given link object
-    void broadcastLink(uint8_t *, size_t);
-
-    // sends a LINK_PROVIDE message broadcasting the given link object
-    void broadcastLink(link_object &, bool);
-
-    // sends a LINK_PROVIDE message broadcasting the given link object from scratch message store
-    bool sendFromScratch(uint8_t *);
-
-    // Adds the given link object to the canonical chain database
-    bool addToChain(link_object &);
-
-    // Adds an incoming text message to the scratch database
-    bool addToScratch(link_object &);
-
-    // sends a CANON_ANNOUNCE message, specifying the given root and commit hashes
-    void canonAnnounce(uint8_t *, uint8_t *, uint8_t *, uint32_t);
-
-    // checks if the message hash is present in the canonical chain database
-    bool isInDB(uint8_t *, size_t);
-
-    // checks if the message hash is present in the scratch database
-    bool isInScratch(uint8_t *, size_t);
-
-    // retrieves a link object from the scratch database
-    link_object getFromScratch(uint8_t *, size_t);
-
-    // removes a link object from the scratch database
-    void removeFromScratch(uint8_t *, size_t);
-
-    // fills the payload section with the decrypted data for the given message hash
-    // probably not needed for production, but useful for testing
-    void updatePayload(uint8_t *, size_t, std::string);
-
-    // Takes the decrypted MeshPacket and the encrypted packet copy, and builds a link_object
-    // Generates a message hash, but does not set the commit hash
-    link_object ingestTextPacket(const meshtastic_MeshPacket &, const meshtastic_MeshPacket *);
-
-    // ingests a LINK_PROVIDE message and builds a link_object
-    // confirms the root hash and commit hash
-    link_object ingestLinkMessage(meshtastic_StoreForwardPlusPlus *);
-
-    // retrieves a link object from the canonical chain database given a message hash
-    link_object getLink(uint8_t *, size_t);
-
-    // puts the encrypted payload back into the queue as if it were just received
-    void rebroadcastLinkObject(link_object &);
-
-    // Check if an incoming link object's commit hash matches the calculated commit hash
-    bool checkCommitHash(link_object &lo, uint8_t *commit_hash_bytes, size_t hash_len);
-
-    // given a partial root hash, looks up the full 32-byte root hash
-    // returns true if found
-    bool lookUpFullRootHash(uint8_t *partial_root_hash, size_t partial_root_hash_len, uint8_t *full_root_hash);
-
-    // update the mappings table to set the chain count for the given root hash
-    void setChainCount(uint8_t *, size_t, uint32_t);
-
-    // query the mappings table for the chain count for the given root hash
-    uint32_t getChainCount(uint8_t *, size_t);
-
-    link_object getLinkFromCount(uint32_t, uint8_t *, size_t);
-
-    // Track if we have a scheduled runOnce pending
-    // useful to not accudentally delay a scheduled runOnce
-    bool pendingRun = false;
-
-    // Once we have multiple chain types, we can extend this
-    enum chain_types {
-        channel_chain = 0,
-    };
-
-    uint32_t rebroadcastTimeout = 3600; // Messages older than this (in seconds) will not be rebroadcast
-};
-#endif

src/platform/portduino/PortduinoGlue.cpp

@@ -786,11 +786,6 @@ bool loadConfig(const char *configPath)
             }
         }
 
-        if (yamlConfig["StoreAndForward"]) {
-            portduino_config.sfpp_stratum0 = (yamlConfig["StoreAndForward"]["Stratum0"]).as<bool>(false);
-            portduino_config.initial_sync = (yamlConfig["StoreAndForward"]["InitialSync"]).as<int>(10);
-        }
-
         if (yamlConfig["General"]) {
             portduino_config.MaxNodes = (yamlConfig["General"]["MaxNodes"]).as<int>(200);
             portduino_config.maxtophone = (yamlConfig["General"]["MaxMessageQueue"]).as<int>(100);

src/platform/portduino/PortduinoGlue.h

@@ -169,10 +169,6 @@ extern struct portduino_config_struct {
     int configDisplayMode = 0;
     bool has_configDisplayMode = false;
 
-    // Store and Forward++
-    bool sfpp_stratum0 = false;
-    int initial_sync = 10;
-
     // General
     std::string mac_address = "";
     bool mac_address_explicit = false;
@@ -492,15 +488,6 @@ extern struct portduino_config_struct {
             out << YAML::EndMap; // Config
         }
 
-        // StoreAndForward
-        if (sfpp_stratum0 || initial_sync != 10) {
-            out << YAML::Key << "StoreAndForward" << YAML::Value << YAML::BeginMap;
-
-            out << YAML::Key << "Stratum0" << YAML::Value << sfpp_stratum0;
-            out << YAML::Key << "InitialSync" << YAML::Value << initial_sync;
-            out << YAML::EndMap; // StoreAndForward
-        }
-
         // General
         out << YAML::Key << "General" << YAML::Value << YAML::BeginMap;
         if (config_directory != "")

variants/native/portduino/platformio.ini

@@ -9,7 +9,7 @@ lib_deps =
   # renovate: datasource=custom.pio depName=Melopero RV3028 packageName=melopero/library/Melopero RV3028
   melopero/Melopero RV3028@1.2.0
 
-build_src_filter = ${portduino_base.build_src_filter} +<modules/Native/>
+build_src_filter = ${portduino_base.build_src_filter}
 
 [env:native]
 extends = native_base
@@ -20,7 +20,6 @@ build_flags = ${native_base.build_flags}
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs sdl2 --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 
 [env:native-tft]
 extends = native_base
@@ -47,7 +46,6 @@ build_flags = ${native_base.build_flags} -Os -lX11 -linput -lxkbcommon -ffunctio
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs sdl2 --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 build_src_filter =
   ${native_base.build_src_filter}
 
@@ -77,7 +75,6 @@ build_flags = ${native_base.build_flags} -Os -ffunction-sections -fdata-sections
   !pkg-config --libs libulfius --silence-errors || :
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 build_src_filter =
   ${native_base.build_src_filter}
 
@@ -111,7 +108,6 @@ build_flags = ${native_base.build_flags} -O0 -fsanitize=address -lX11 -linput -l
   !pkg-config --libs libulfius --silence-errors || :
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 build_src_filter = ${env:native-tft.build_src_filter}
 
 [env:coverage]

variants/nrf52840/seeed_wio_tracker_L1_eink/nicheGraphics.h

@@ -19,7 +19,7 @@
 // Shared NicheGraphics components
 // --------------------------------
 #include "graphics/niche/Drivers/EInk/ZJY122250_0213BAAMFGN.h"
-#include "graphics/niche/Inputs/TwoButton.h"
+#include "graphics/niche/Inputs/TwoButtonExtended.h"
 
 void setupNicheGraphics()
 {
@@ -54,7 +54,12 @@ void setupNicheGraphics()
     InkHUD::Applet::fontSmall = FREESANS_6PT_WIN1252;
 
     // Customize default settings
-    inkhud->persistence->settings.rotation = 1;                        // 90 degrees clockwise
+    inkhud->persistence->settings.rotation = 1; // 90 degrees clockwise
+#if HAS_TRACKBALL
+    inkhud->persistence->settings.joystick.enabled = true;            // Device uses a joystick
+    inkhud->persistence->settings.joystick.alignment = 3;             // 270 degrees
+    inkhud->persistence->settings.optionalMenuItems.nextTile = false; // Use joystick instead
+#endif
     inkhud->persistence->settings.optionalFeatures.batteryIcon = true; // Device definitely has a battery
     inkhud->persistence->settings.userTiles.count = 1;    // One tile only by default, keep things simple for new users
     inkhud->persistence->settings.userTiles.maxCount = 2; // Two applets side-by-side
@@ -75,16 +80,36 @@ void setupNicheGraphics()
     //  Buttons
     //  --------------------------
 
-    Inputs::TwoButton *buttons = Inputs::TwoButton::getInstance(); // Shared NicheGraphics component
+    Inputs::TwoButtonExtended *buttons = Inputs::TwoButtonExtended::getInstance(); // Shared NicheGraphics component
 
-    // #0: Main User Button
-    buttons->setWiring(0, Inputs::TwoButton::getUserButtonPin());
+#if HAS_TRACKBALL
+    // #0: Exit Button
+    buttons->setWiring(0, Inputs::TwoButtonExtended::getUserButtonPin());
+    buttons->setTiming(0, 75, 500);
+    buttons->setHandlerShortPress(0, [inkhud]() { inkhud->exitShort(); });
+    buttons->setHandlerLongPress(0, [inkhud]() { inkhud->exitLong(); });
+
+    // #1: Joystick Center
+    buttons->setWiring(1, TB_PRESS);
+    buttons->setTiming(1, 75, 500);
+    buttons->setHandlerShortPress(1, [inkhud]() { inkhud->shortpress(); });
+    buttons->setHandlerLongPress(1, [inkhud]() { inkhud->longpress(); });
+
+    // Joystick Directions
+    buttons->setJoystickWiring(TB_UP, TB_DOWN, TB_LEFT, TB_RIGHT);
+    buttons->setJoystickDebounce(50);
+    buttons->setJoystickPressHandlers([inkhud]() { inkhud->navUp(); }, [inkhud]() { inkhud->navDown(); },
+                                      [inkhud]() { inkhud->navLeft(); }, [inkhud]() { inkhud->navRight(); });
+#else
+    // #0: User Button
+    buttons->setWiring(0, Inputs::TwoButtonExtended::getUserButtonPin());
     buttons->setTiming(0, 75, 500);
     buttons->setHandlerShortPress(0, [inkhud]() { inkhud->shortpress(); });
     buttons->setHandlerLongPress(0, [inkhud]() { inkhud->longpress(); });
+#endif
 
     // Begin handling button events
     buttons->start();
 }
 
-#endif
+#endif