Merge branch 'master' into develop

src/ButtonThread.cpp

@@ -238,7 +238,6 @@ int32_t ButtonThread::runOnce()
         btnEvent = BUTTON_EVENT_NONE;
     }
 
-    runASAP = false;
     return 50;
 }
 

src/input/ExpressLRSFiveWay.cpp

@@ -0,0 +1,260 @@
+
+#include "ExpressLRSFiveWay.h"
+
+#ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
+
+static const char inputSourceName[] = "ExpressLRS5Way"; // should match "allow input source" string
+
+/**
+ * @brief Calculate fuzz: half the distance to the next nearest neighbor for each joystick position.
+ *
+ * The goal is to avoid collisions between joystick positions while still maintaining
+ * the widest tolerance for the analog value.
+ *
+ * Example: {10,50,800,1000,300,1600}
+ * If we just choose the minimum difference for this array the value would
+ * be 40/2 = 20.
+ *
+ * 20 does not leave enough room for the joystick position using 1600 which
+ * could have a +-100 offset.
+ *
+ * Example Fuzz values: {20, 20, 100, 100, 125, 300} now the fuzz for the 1600
+ * position is 300 instead of 20
+ */
+void ExpressLRSFiveWay::calcFuzzValues()
+{
+    for (unsigned int i = 0; i < N_JOY_ADC_VALUES; i++) {
+        uint16_t closestDist = 0xffff;
+        uint16_t ival = joyAdcValues[i];
+        // Find the closest value to ival
+        for (unsigned int j = 0; j < N_JOY_ADC_VALUES; j++) {
+            // Don't compare value with itself
+            if (j == i)
+                continue;
+            uint16_t jval = joyAdcValues[j];
+            if (jval < ival && (ival - jval < closestDist))
+                closestDist = ival - jval;
+            if (jval > ival && (jval - ival < closestDist))
+                closestDist = jval - ival;
+        } // for j
+
+        // And the fuzz is half the distance to the closest value
+        fuzzValues[i] = closestDist / 2;
+        // DBG("joy%u=%u f=%u, ", i, ival, fuzzValues[i]);
+    } // for i
+}
+
+int ExpressLRSFiveWay::readKey()
+{
+    uint16_t value = analogRead(PIN_JOYSTICK);
+
+    constexpr uint8_t IDX_TO_INPUT[N_JOY_ADC_VALUES - 1] = {UP, DOWN, LEFT, RIGHT, OK};
+    for (unsigned int i = 0; i < N_JOY_ADC_VALUES - 1; ++i) {
+        if (value < (joyAdcValues[i] + fuzzValues[i]) && value > (joyAdcValues[i] - fuzzValues[i]))
+            return IDX_TO_INPUT[i];
+    }
+    return NO_PRESS;
+}
+
+ExpressLRSFiveWay::ExpressLRSFiveWay() : concurrency::OSThread(inputSourceName)
+{
+    // ExpressLRS: init values
+    isLongPressed = false;
+    keyInProcess = NO_PRESS;
+    keyDownStart = 0;
+
+    // Express LRS: calculate the threshold for interpreting ADC values as various buttons
+    calcFuzzValues();
+
+    // Meshtastic: register with canned messages
+    inputBroker->registerSource(this);
+}
+
+// ExpressLRS: interpret reading as key events
+void ExpressLRSFiveWay::update(int *keyValue, bool *keyLongPressed)
+{
+    *keyValue = NO_PRESS;
+
+    int newKey = readKey();
+    uint32_t now = millis();
+    if (keyInProcess == NO_PRESS) {
+        // New key down
+        if (newKey != NO_PRESS) {
+            keyDownStart = now;
+            // DBGLN("down=%u", newKey);
+        }
+    } else {
+        // if key released
+        if (newKey == NO_PRESS) {
+            // DBGLN("up=%u", keyInProcess);
+            if (!isLongPressed) {
+                if ((now - keyDownStart) > KEY_DEBOUNCE_MS) {
+                    *keyValue = keyInProcess;
+                    *keyLongPressed = false;
+                }
+            }
+            isLongPressed = false;
+        }
+        // else if the key has changed while down, reset state for next go-around
+        else if (newKey != keyInProcess) {
+            newKey = NO_PRESS;
+        }
+        // else still pressing, waiting for long if not already signaled
+        else if (!isLongPressed) {
+            if ((now - keyDownStart) > KEY_LONG_PRESS_MS) {
+                *keyValue = keyInProcess;
+                *keyLongPressed = true;
+                isLongPressed = true;
+            }
+        }
+    } // if keyInProcess != NO_PRESS
+
+    keyInProcess = newKey;
+}
+
+// Meshtastic: runs at regular intervals
+int32_t ExpressLRSFiveWay::runOnce()
+{
+    uint32_t now = millis();
+
+    // Dismiss any alert frames after 2 seconds
+    // Feedback for GPS toggle / adhoc ping
+    if (alerting && now > alertingSinceMs + 2000) {
+        alerting = false;
+        screen->endAlert();
+    }
+
+    // Get key events from ExpressLRS code
+    int keyValue;
+    bool longPressed;
+    update(&keyValue, &longPressed);
+
+    // Do something about this key press
+    determineAction((KeyType)keyValue, longPressed ? LONG : SHORT);
+
+    // If there has been recent key activity, poll the joystick slightly more frequently
+    if (now < keyDownStart + (20 * 1000UL)) // Within last 20 seconds
+        return 100;
+
+    // Otherwise, poll slightly less often
+    // Too many missed pressed if much slower than 250ms
+    return 250;
+}
+
+// Determine what action to take when a button press is detected
+// Written verbose for easier remapping by user
+void ExpressLRSFiveWay::determineAction(KeyType key, PressLength length)
+{
+    switch (key) {
+    case LEFT:
+        if (inCannedMessageMenu()) // If in canned message menu
+            sendKey(CANCEL);       // exit the menu (press imaginary cancel key)
+        else
+            sendKey(LEFT);
+        break;
+
+    case RIGHT:
+        if (inCannedMessageMenu()) // If in canned message menu:
+            sendKey(CANCEL);       // exit the menu (press imaginary cancel key)
+        else
+            sendKey(RIGHT);
+        break;
+
+    case UP:
+        if (length == LONG)
+            toggleGPS();
+        else
+            sendKey(UP);
+        break;
+
+    case DOWN:
+        if (length == LONG)
+            sendAdhocPing();
+        else
+            sendKey(DOWN);
+        break;
+
+    case OK:
+        if (length == LONG)
+            shutdown();
+        else
+            click(); // Use instead of sendKey(OK). Works better when canned message module disabled
+        break;
+
+    default:
+        break;
+    }
+}
+
+// Feed input to the canned messages module
+void ExpressLRSFiveWay::sendKey(KeyType key)
+{
+    InputEvent e;
+    e.source = inputSourceName;
+    e.inputEvent = key;
+    notifyObservers(&e);
+}
+
+// Enable or Disable a connected GPS
+// Contained as one method for easier remapping of buttons by user
+void ExpressLRSFiveWay::toggleGPS()
+{
+#if HAS_GPS && !MESHTASTIC_EXCLUDE_GPS
+    if (!config.device.disable_triple_click && (gps != nullptr)) {
+        gps->toggleGpsMode();
+        screen->startAlert("GPS Toggled");
+        alerting = true;
+        alertingSinceMs = millis();
+    }
+#endif
+}
+
+// Send either node-info or position, on demand
+// Contained as one method for easier remapping of buttons by user
+void ExpressLRSFiveWay::sendAdhocPing()
+{
+    service->refreshLocalMeshNode();
+    bool sentPosition = service->trySendPosition(NODENUM_BROADCAST, true);
+
+    // Show custom alert frame, with multi-line centering
+    screen->startAlert([sentPosition](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
+        uint16_t x_offset = display->width() / 2;
+        uint16_t y_offset = 26; // Same constant as the default startAlert frame
+        display->setTextAlignment(TEXT_ALIGN_CENTER);
+        display->setFont(FONT_MEDIUM);
+        display->drawString(x_offset + x, y_offset + y, "Sent ad-hoc");
+        display->drawString(x_offset + x, y_offset + FONT_HEIGHT_MEDIUM + y, sentPosition ? "position" : "nodeinfo");
+    });
+
+    alerting = true;
+    alertingSinceMs = millis();
+}
+
+// Shutdown the node (enter deep-sleep)
+// Contained as one method for easier remapping of buttons by user
+void ExpressLRSFiveWay::shutdown()
+{
+    LOG_INFO("Shutdown from long press\n");
+    powerFSM.trigger(EVENT_PRESS);
+    screen->startAlert("Shutting down...");
+    // Don't set alerting = true. We don't want to auto-dismiss this alert.
+
+    playShutdownMelody(); // In case user adds a buzzer
+
+    shutdownAtMsec = millis() + 3000;
+}
+
+// Emulate user button, or canned message SELECT
+// This is necessary as canned message module doesn't translate SELECT to user button presses if the module is disabled
+// Contained as one method for easier remapping of buttons by user
+void ExpressLRSFiveWay::click()
+{
+    if (!moduleConfig.canned_message.enabled)
+        powerFSM.trigger(EVENT_PRESS);
+    else
+        sendKey(OK);
+}
+
+ExpressLRSFiveWay *expressLRSFiveWayInput = nullptr;
+
+#endif

src/input/ExpressLRSFiveWay.h

@@ -0,0 +1,85 @@
+/*
+    Input source for Radio Master Bandit Nano, and similar hardware.
+    Devices have a 5-button "resistor ladder" style joystick, read by ADC.
+    These devices do not use the ADC to monitor input voltage.
+
+    Much of this code taken directly from ExpressLRS FiveWayButton class:
+    https://github.com/ExpressLRS/ExpressLRS/tree/d9f56f8bd6f9f7144d5f01caaca766383e1e0950/src/lib/SCREEN/FiveWayButton
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
+
+#include <esp_adc_cal.h>
+#include <soc/adc_channel.h>
+
+#include "InputBroker.h"
+#include "MeshService.h" // For adhoc ping action
+#include "buzz.h"
+#include "concurrency/OSThread.h"
+#include "graphics/Screen.h" // Feedback for adhoc ping / toggle GPS
+#include "main.h"
+#include "modules/CannedMessageModule.h"
+
+#if HAS_GPS && !MESHTASTIC_EXCLUDE_GPS
+#include "GPS.h" // For toggle GPS action
+#endif
+
+class ExpressLRSFiveWay : public Observable<const InputEvent *>, public concurrency::OSThread
+{
+  private:
+    // Number of values in JOY_ADC_VALUES, if defined
+    // These must be ADC readings for {UP, DOWN, LEFT, RIGHT, ENTER, IDLE}
+    static constexpr size_t N_JOY_ADC_VALUES = 6;
+    static constexpr uint32_t KEY_DEBOUNCE_MS = 25;
+    static constexpr uint32_t KEY_LONG_PRESS_MS = 3000; // How many milliseconds to hold key for a long press
+
+    // This merged an enum used by the ExpressLRS code, with meshtastic canned message values
+    // Key names are kept simple, to allow user customizaton
+    typedef enum {
+        UP = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP,
+        DOWN = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN,
+        LEFT = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT,
+        RIGHT = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT,
+        OK = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_SELECT,
+        CANCEL = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL,
+        NO_PRESS = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE
+    } KeyType;
+
+    typedef enum { SHORT, LONG } PressLength;
+
+    // From ExpressLRS
+    int keyInProcess;
+    uint32_t keyDownStart;
+    bool isLongPressed;
+    const uint16_t joyAdcValues[N_JOY_ADC_VALUES] = {JOYSTICK_ADC_VALS};
+    uint16_t fuzzValues[N_JOY_ADC_VALUES];
+    void calcFuzzValues();
+    int readKey();
+    void update(int *keyValue, bool *keyLongPressed);
+
+    // Meshtastic code
+    void determineAction(KeyType key, PressLength length);
+    void sendKey(KeyType key);
+    inline bool inCannedMessageMenu() { return cannedMessageModule->shouldDraw(); }
+    int32_t runOnce() override;
+
+    // Simplified Meshtastic actions, for easier remapping by user
+    void toggleGPS();
+    void sendAdhocPing();
+    void shutdown();
+    void click();
+
+    bool alerting = false;        // Is the screen showing an alert frame? Feedback for GPS toggle / adhoc ping actions
+    uint32_t alertingSinceMs = 0; // When did screen begin showing an alert frame? Used to auto-dismiss
+
+  public:
+    ExpressLRSFiveWay();
+};
+
+extern ExpressLRSFiveWay *expressLRSFiveWayInput;
+
+#endif

src/mesh/Channels.cpp

@@ -97,7 +97,7 @@ void Channels::initDefaultChannel(ChannelIndex chIndex)
     channelSettings.psk.bytes[0] = defaultpskIndex;
     channelSettings.psk.size = 1;
     strncpy(channelSettings.name, "", sizeof(channelSettings.name));
-    channelSettings.module_settings.position_precision = 32; // default to sending location on the primary channel
+    channelSettings.module_settings.position_precision = 13; // default to sending location on the primary channel
     channelSettings.has_module_settings = true;
 
     ch.has_settings = true;

src/mesh/Default.h

@@ -13,7 +13,9 @@
 #define default_min_wake_secs 10
 #define default_screen_on_secs IF_ROUTER(1, 60 * 10)
 #define default_node_info_broadcast_secs 3 * 60 * 60
+#define default_neighbor_info_broadcast_secs 6 * 60 * 60
 #define min_node_info_broadcast_secs 60 * 60 // No regular broadcasts of more than once an hour
+#define min_neighbor_info_broadcast_secs 2 * 60 * 60
 
 #define default_mqtt_address "mqtt.meshtastic.org"
 #define default_mqtt_username "meshdev"

src/modules/AdminModule.cpp

@@ -557,6 +557,10 @@ void AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
     case meshtastic_ModuleConfig_neighbor_info_tag:
         LOG_INFO("Setting module config: Neighbor Info\n");
         moduleConfig.has_neighbor_info = true;
+        if (moduleConfig.neighbor_info.update_interval < min_neighbor_info_broadcast_secs) {
+            LOG_DEBUG("Tried to set update_interval too low, setting to %d\n", default_neighbor_info_broadcast_secs);
+            moduleConfig.neighbor_info.update_interval = default_neighbor_info_broadcast_secs;
+        }
         moduleConfig.neighbor_info = c.payload_variant.neighbor_info;
         break;
     case meshtastic_ModuleConfig_detection_sensor_tag:

src/modules/Modules.cpp

@@ -1,5 +1,6 @@
 #include "configuration.h"
 #if !MESHTASTIC_EXCLUDE_INPUTBROKER
+#include "input/ExpressLRSFiveWay.h"
 #include "input/InputBroker.h"
 #include "input/RotaryEncoderInterruptImpl1.h"
 #include "input/ScanAndSelect.h"
@@ -176,6 +177,9 @@ void setupModules()
         trackballInterruptImpl1 = new TrackballInterruptImpl1();
         trackballInterruptImpl1->init();
 #endif
+#ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
+        expressLRSFiveWayInput = new ExpressLRSFiveWay();
+#endif
 #if HAS_SCREEN && !MESHTASTIC_EXCLUDE_CANNEDMESSAGES
         cannedMessageModule = new CannedMessageModule();
 #endif

src/modules/NeighborInfoModule.cpp

@@ -120,8 +120,7 @@ int32_t NeighborInfoModule::runOnce()
     if (airTime->isTxAllowedChannelUtil(true) && airTime->isTxAllowedAirUtil()) {
         sendNeighborInfo(NODENUM_BROADCAST, false);
     }
-    return Default::getConfiguredOrDefaultMsScaled(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs,
+    return Default::getConfiguredOrDefault(moduleConfig.neighbor_info.update_interval, default_neighbor_info_broadcast_secs);
-                                                   numOnlineNodes);
 }
 
 /*

src/modules/PositionModule.cpp

@@ -140,7 +140,8 @@ void PositionModule::trySetRtc(meshtastic_Position p, bool isLocal, bool forceUp
 
 bool PositionModule::hasQualityTimesource()
 {
-    bool setFromPhoneOrNtpToday = (millis() - lastSetFromPhoneNtpOrGps) <= (SEC_PER_DAY * 1000UL);
+    bool setFromPhoneOrNtpToday =
+        lastSetFromPhoneNtpOrGps == 0 ? false : (millis() - lastSetFromPhoneNtpOrGps) <= (SEC_PER_DAY * 1000UL);
     bool hasGpsOrRtc = (gps && gps->isConnected()) || (rtc_found.address != ScanI2C::ADDRESS_NONE.address);
     return hasGpsOrRtc || setFromPhoneOrNtpToday;
 }
@@ -297,7 +298,8 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha
     if (channels.getByIndex(channel).settings.has_module_settings) {
         precision = channels.getByIndex(channel).settings.module_settings.position_precision;
     } else if (channels.getByIndex(channel).role == meshtastic_Channel_Role_PRIMARY) {
-        precision = 32;
+        // backwards compatibility for Primary channels created before position_precision was set by default
+        precision = 13;
     } else {
         precision = 0;
     }

src/platform/nrf52/architecture.h

@@ -62,6 +62,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_WIO_WM1110
 #elif defined(TRACKER_T1000_E)
 #define HW_VENDOR meshtastic_HardwareModel_TRACKER_T1000_E
+#elif defined(ME25LS01)
+#define HW_VENDOR meshtastic_HardwareModel_ME25LS01
 #elif defined(PRIVATE_HW) || defined(FEATHER_DIY)
 #define HW_VENDOR meshtastic_HardwareModel_PRIVATE_HW
 #else

userPrefs.h

@@ -17,7 +17,7 @@
     }
 */
 // #define CHANNEL_0_NAME_USERPREFS "DEFCONnect"
-// #define CHANNEL_0_PRECISION_USERPREFS 13
+// #define CHANNEL_0_PRECISION_USERPREFS 14
 
 // #define CONFIG_OWNER_LONG_NAME_USERPREFS "My Long Name"
 // #define CONFIG_OWNER_SHORT_NAME_USERPREFS "MLN"

variants/ME25LS01-4Y10TD/variant.h

@@ -126,7 +126,7 @@ extern "C" {
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
 
 // Buzzer
-#define BUZZER_EN_PIN -1
+#define PIN_BUZZER (0 + 25)
 
 #ifdef __cplusplus
 }

variants/ME25LS01-4Y10TD_e-ink/variant.h

@@ -149,7 +149,7 @@ static const uint8_t SCK = PIN_SPI_SCK;
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
 
 // Buzzer
-#define BUZZER_EN_PIN -1
+#define PIN_BUZZER (0 + 25)
 
 #ifdef __cplusplus
 }

variants/heltec_capsule_sensor_v3/variant.h

@@ -47,6 +47,7 @@
 #define SENSOR_POWER_CTRL_PIN 21
 #define SENSOR_POWER_ON 1
 
+#define PERIPHERAL_WARMUP_MS 100
 #define SENSOR_GPS_CONFLICT
 
 #define ESP32S3_WAKE_TYPE ESP_EXT1_WAKEUP_ANY_HIGH

variants/radiomaster_900_bandit_nano/variant.h

@@ -41,14 +41,11 @@
 
 /*
   Five way button when using ADC.
-  2.632V, 2.177V, 1.598V, 1.055V, 0V
+  https://github.com/ExpressLRS/targets/blob/f3215b5ec891108db1a13523e4163950cfcadaac/TX/Radiomaster%20Bandit.json#L41
-
-  Possible ADC Values:
-  { UP, DOWN, LEFT, RIGHT, ENTER, IDLE }
-  3227, 0 ,1961, 2668, 1290, 4095
 */
-#define BUTTON_PIN 39
+#define INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
-#define BUTTON_NEED_PULLUP
+#define PIN_JOYSTICK 39
+#define JOYSTICK_ADC_VALS /*UP*/ 3227, /*DOWN*/ 0, /*LEFT*/ 1961, /*RIGHT*/ 2668, /*OK*/ 1290, /*IDLE*/ 4095
 
 #define DISPLAY_FLIP_SCREEN
 

variants/rp2040-lora/variant.h

@@ -15,7 +15,7 @@
 // rxd = 9
 
 #define EXT_NOTIFY_OUT 22
-#define BUTTON_PIN 17
+#undef BUTTON_PIN // Pin 17 used for antenna switching via DIO4
 
 #define LED_PIN PIN_LED
 
@@ -32,23 +32,28 @@
 
 // https://www.waveshare.com/rp2040-lora.htm
 // https://www.waveshare.com/img/devkit/RP2040-LoRa-HF/RP2040-LoRa-HF-details-11.jpg
-#define LORA_SCK 14  // 10
+#define LORA_SCK 14  // GPIO14
-#define LORA_MISO 24 // 12
+#define LORA_MISO 24 // GPIO24
-#define LORA_MOSI 15 // 11
+#define LORA_MOSI 15 // GPIO15
-#define LORA_CS 13   // 3
+#define LORA_CS 13   // GPIO13
 
-#define LORA_DIO0 RADIOLIB_NC
+#define LORA_DIO0 RADIOLIB_NC // No GPIO connection
-#define LORA_RESET 23 // 15
+#define LORA_RESET 23         // GPIO23
-#define LORA_DIO1 16  // 20
+#define LORA_BUSY 18          // GPIO18
-#define LORA_DIO2 18  // 2
+#define LORA_DIO1 16          // GPIO16
-#define LORA_DIO3 RADIOLIB_NC
+#define LORA_DIO2 RADIOLIB_NC // Antenna switching, no GPIO connection
-#define LORA_DIO4 17
+#define LORA_DIO3 RADIOLIB_NC // No GPIO connection
+#define LORA_DIO4 17          // GPIO17
+
+// On rp2040-lora board the antenna switch is wired and works with complementary-pin control logic.
+// See PE4259 datasheet page 4
 
 #ifdef USE_SX1262
 #define SX126X_CS LORA_CS
 #define SX126X_DIO1 LORA_DIO1
-#define SX126X_BUSY LORA_DIO2
+#define SX126X_BUSY LORA_BUSY
 #define SX126X_RESET LORA_RESET
-#define SX126X_DIO2_AS_RF_SWITCH
+#define SX126X_DIO2_AS_RF_SWITCH // Antenna switch CTRL
+#define SX126X_RXEN LORA_DIO4    // Antenna switch !CTRL via GPIO17
 // #define SX126X_DIO3_TCXO_VOLTAGE 1.8
 #endif