move STATE_SEND_METADATA to beginning of wantConfig (#2820)

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

arch/esp32/esp32.ini

@@ -1,7 +1,7 @@
 ; Common settings for ESP targes, mixin with extends = esp32_base
 [esp32_base]
 extends = arduino_base
-platform = platformio/espressif32@^6.4.0
+platform = platformio/espressif32@6.3.2 # This is a temporary fix to the S3-based devices bluetooth issues until we can determine what within ESP-IDF changed and can develop a suitable patch. 
 
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
@@ -57,4 +57,4 @@ lib_ignore =
 
 ; customize the partition table
 ; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
-board_build.partitions = partition-table.csv
+board_build.partitions = partition-table.csv

src/ButtonThread.h

@@ -164,15 +164,17 @@ class ButtonThread : public concurrency::OSThread
 
     static void userButtonMultiPressed()
     {
-#if defined(GPS_POWER_TOGGLE)
-        if (config.position.gps_enabled) {
-            LOG_DEBUG("Flag set to false for gps power\n");
-        } else {
-            LOG_DEBUG("Flag set to true to restore power\n");
+        if (!config.device.disable_triple_click && (gps != nullptr)) {
+            config.position.gps_enabled = !(config.position.gps_enabled);
+            if (config.position.gps_enabled) {
+                LOG_DEBUG("Flag set to true to restore power\n");
+                gps->enable();
+
+            } else {
+                LOG_DEBUG("Flag set to false for gps power\n");
+                gps->disable();
+            }
         }
-        config.position.gps_enabled = !(config.position.gps_enabled);
-        doGPSpowersave(config.position.gps_enabled);
-#endif
     }
 
     static void userButtonPressedLongStart()

src/PowerFSM.cpp

@@ -8,7 +8,6 @@
  * actions to be taken upon entering or exiting each state.
  */
 #include "PowerFSM.h"
-#include "GPS.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "configuration.h"
@@ -137,9 +136,6 @@ static void lsIdle()
 static void lsExit()
 {
     LOG_INFO("Exit state: LS\n");
-    // setGPSPower(true); // restore GPS power
-    if (gps)
-        gps->forceWake(true);
 }
 
 static void nbEnter()
@@ -374,10 +370,6 @@ void PowerFSM_setup()
                                       getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs),
                                       NULL, "Bluetooth timeout");
     }
-
-    if (config.power.sds_secs != UINT32_MAX)
-        powerFSM.add_timed_transition(lowPowerState, &stateSDS, getConfiguredOrDefaultMs(config.power.sds_secs), NULL,
-                                      "mesh timeout");
 #endif
 
     powerFSM.run_machine(); // run one iteration of the state machine, so we run our on enter tasks for the initial DARK state

src/concurrency/OSThread.h

@@ -53,7 +53,7 @@ class OSThread : public Thread
 
     static void setup();
 
-    int32_t disable();
+    virtual int32_t disable();
 
     /**
      * Wait a specified number msecs starting from the current time (rather than the last time we were run)
@@ -87,4 +87,4 @@ extern bool hasBeenSetup;
 
 void assertIsSetup();
 
-} // namespace concurrency
+} // namespace concurrency

src/configuration.h

@@ -145,7 +145,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define GPS_BAUDRATE 9600
 
 #ifndef GPS_THREAD_INTERVAL
-#define GPS_THREAD_INTERVAL 100
+#define GPS_THREAD_INTERVAL 200
 #endif
 
 // convert 24-bit color to 16-bit (56K)

src/gps/GPS.cpp

@@ -2,6 +2,7 @@
 #include "NodeDB.h"
 #include "RTC.h"
 #include "configuration.h"
+#include "main.h" // pmu_found
 #include "sleep.h"
 #include "ubx.h"
 
@@ -13,12 +14,7 @@
 #define GPS_RESET_MODE HIGH
 #endif
 
-// If we have a serial GPS port it will not be null
-#ifdef GPS_SERIAL_NUM
-HardwareSerial _serial_gps_real(GPS_SERIAL_NUM);
-HardwareSerial *GPS::_serial_gps = &_serial_gps_real;
-#elif defined(NRF52840_XXAA) || defined(NRF52833_XXAA)
-// Assume NRF52840
+#if defined(NRF52840_XXAA) || defined(NRF52833_XXAA) || defined(ARCH_ESP32)
 HardwareSerial *GPS::_serial_gps = &Serial1;
 #else
 HardwareSerial *GPS::_serial_gps = NULL;
@@ -32,6 +28,8 @@ static bool didSerialInit;
 
 struct uBloxGnssModelInfo info;
 uint8_t uBloxProtocolVersion;
+#define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
+#define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
 
 void GPS::UBXChecksum(uint8_t *message, size_t length)
 {
@@ -255,19 +253,23 @@ bool GPS::setup()
 {
     int msglen = 0;
 
-    if (_serial_gps && !didSerialInit) {
+    if (!didSerialInit) {
 #if !defined(GPS_UC6580)
-        LOG_DEBUG("Probing for GPS at %d \n", serialSpeeds[speedSelect]);
-        gnssModel = probe(serialSpeeds[speedSelect]);
-        if (gnssModel == GNSS_MODEL_UNKNOWN) {
-            if (++speedSelect == sizeof(serialSpeeds) / sizeof(int)) {
-                speedSelect = 0;
-                if (--probeTries == 0) {
-                    LOG_WARN("Giving up on GPS probe and setting to 9600.\n");
-                    return true;
+        if (tx_gpio) {
+            LOG_DEBUG("Probing for GPS at %d \n", serialSpeeds[speedSelect]);
+            gnssModel = probe(serialSpeeds[speedSelect]);
+            if (gnssModel == GNSS_MODEL_UNKNOWN) {
+                if (++speedSelect == sizeof(serialSpeeds) / sizeof(int)) {
+                    speedSelect = 0;
+                    if (--probeTries == 0) {
+                        LOG_WARN("Giving up on GPS probe and setting to 9600.\n");
+                        return true;
+                    }
                 }
+                return false;
             }
-            return false;
+        } else {
+            gnssModel = GNSS_MODEL_UNKNOWN;
         }
 #else
         gnssModel = GNSS_MODEL_UC6850;
@@ -419,53 +421,77 @@ bool GPS::setup()
         didSerialInit = true;
     }
 
-    notifySleepObserver.observe(&notifySleep);
     notifyDeepSleepObserver.observe(&notifyDeepSleep);
     notifyGPSSleepObserver.observe(&notifyGPSSleep);
-
-    if (config.position.gps_enabled == false && config.position.fixed_position == false) {
-        setAwake(false);
-    }
     return true;
 }
 
 GPS::~GPS()
 {
     // we really should unregister our sleep observer
-    notifySleepObserver.unobserve(&notifySleep);
     notifyDeepSleepObserver.unobserve(&notifyDeepSleep);
     notifyGPSSleepObserver.observe(&notifyGPSSleep);
 }
 
-bool GPS::hasLock()
+void GPS::setGPSPower(bool on, bool standbyOnly)
 {
-    return hasValidLocation;
-}
-
-bool GPS::hasFlow()
-{
-    return hasGPS;
-}
-
-// Allow defining the polarity of the WAKE output.  default is active high
-#ifndef GPS_WAKE_ACTIVE
-#define GPS_WAKE_ACTIVE 1
+    LOG_INFO("Setting GPS power=%d\n", on);
+    if (on) {
+        clearBuffer(); // drop any old data waiting in the buffer before re-enabling
+        if (en_gpio)
+            digitalWrite(en_gpio, on ? GPS_EN_ACTIVE : !GPS_EN_ACTIVE); // turn this on if defined, every time
+    }
+    isInPowersave = !on;
+    if (!standbyOnly && en_gpio != 0 &&
+        !(HW_VENDOR == meshtastic_HardwareModel_RAK4631 && (rotaryEncoderInterruptImpl1 || upDownInterruptImpl1))) {
+        LOG_DEBUG("GPS powerdown using GPS_EN_ACTIVE\n");
+        digitalWrite(en_gpio, on ? GPS_EN_ACTIVE : !GPS_EN_ACTIVE);
+        return;
+    }
+#ifdef HAS_PMU // We only have PMUs on the T-Beam, and that board has a tiny battery to save GPS ephemera, so treat as a standby.
+    if (pmu_found && PMU) {
+        uint8_t model = PMU->getChipModel();
+        if (model == XPOWERS_AXP2101) {
+            if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
+                // t-beam v1.2 GNSS power channel
+                on ? PMU->enablePowerOutput(XPOWERS_ALDO3) : PMU->disablePowerOutput(XPOWERS_ALDO3);
+            } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
+                // t-beam-s3-core GNSS  power channel
+                on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
+            }
+        } else if (model == XPOWERS_AXP192) {
+            // t-beam v1.1 GNSS  power channel
+            on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3);
+        }
+        return;
+    }
 #endif
-
-void GPS::wake()
-{
-#ifdef PIN_GPS_WAKE
-    digitalWrite(PIN_GPS_WAKE, GPS_WAKE_ACTIVE);
-    pinMode(PIN_GPS_WAKE, OUTPUT);
-#endif
-}
-
-void GPS::sleep()
-{
-#ifdef PIN_GPS_WAKE
-    digitalWrite(PIN_GPS_WAKE, GPS_WAKE_ACTIVE ? 0 : 1);
-    pinMode(PIN_GPS_WAKE, OUTPUT);
+#ifdef PIN_GPS_STANDBY // Specifically the standby pin for L76K and clones
+    if (on) {
+        LOG_INFO("Waking GPS");
+        digitalWrite(PIN_GPS_STANDBY, 1);
+        pinMode(PIN_GPS_STANDBY, OUTPUT);
+        return;
+    } else {
+        LOG_INFO("GPS entering sleep");
+        // notifyGPSSleep.notifyObservers(NULL);
+        digitalWrite(PIN_GPS_STANDBY, 0);
+        pinMode(PIN_GPS_STANDBY, OUTPUT);
+        return;
+    }
 #endif
+    if (!on) {
+        if (gnssModel == GNSS_MODEL_UBLOX) {
+            uint8_t msglen;
+            msglen = gps->makeUBXPacket(0x02, 0x41, 0x08, gps->_message_PMREQ);
+            gps->_serial_gps->write(gps->UBXscratch, msglen);
+        }
+    } else {
+        if (gnssModel == GNSS_MODEL_UBLOX) {
+            gps->_serial_gps->write(0xFF);
+            clearBuffer(); // This often returns old data, so drop it
+        }
+    }
 }
 
 /// Record that we have a GPS
@@ -477,14 +503,6 @@ void GPS::setConnected()
     }
 }
 
-void GPS::setNumSatellites(uint8_t n)
-{
-    if (n != numSatellites) {
-        numSatellites = n;
-        shouldPublish = true;
-    }
-}
-
 /**
  * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
  *
@@ -492,23 +510,38 @@ void GPS::setNumSatellites(uint8_t n)
  */
 void GPS::setAwake(bool on)
 {
-    if (!wakeAllowed && on) {
-        LOG_WARN("Inhibiting because !wakeAllowed\n");
-        on = false;
-    }
-
     if (isAwake != on) {
         LOG_DEBUG("WANT GPS=%d\n", on);
-        if (on) {
-            clearBuffer(); // drop any old data waiting in the buffer
-            lastWakeStartMsec = millis();
-            wake();
-        } else {
-            lastSleepStartMsec = millis();
-            sleep();
+        isAwake = on;
+        if (!enabled) { // short circuit if the user has disabled GPS
+            setGPSPower(false, false);
+            return;
         }
 
-        isAwake = on;
+        if (on) {
+            lastWakeStartMsec = millis();
+        } else {
+            lastSleepStartMsec = millis();
+            if (GPSCycles == 1) { // Skipping initial lock time, as it will likely be much longer than average
+                averageLockTime = lastSleepStartMsec - lastWakeStartMsec;
+            } else if (GPSCycles > 1) {
+                averageLockTime += ((int32_t)(lastSleepStartMsec - lastWakeStartMsec) - averageLockTime) / (int32_t)GPSCycles;
+            }
+            GPSCycles++;
+            LOG_DEBUG("GPS Lock took %d, average %d\n", (lastSleepStartMsec - lastWakeStartMsec) / 1000, averageLockTime / 1000);
+        }
+        if ((int32_t)getSleepTime() - averageLockTime >
+            15 * 60 * 1000) { // 15 minutes is probably long enough to make a complete poweroff worth it.
+            setGPSPower(on, false);
+        } else if ((int32_t)getSleepTime() - averageLockTime > 10000) { // 10 seconds is enough for standby
+#ifdef GPS_UC6580
+            setGPSPower(on, false);
+#else
+            setGPSPower(on, true);
+#endif
+        } else if (averageLockTime > 20000) {
+            averageLockTime -= 1000; // eventually want to sleep again.
+        }
     }
 }
 
@@ -528,10 +561,9 @@ uint32_t GPS::getWakeTime() const
 uint32_t GPS::getSleepTime() const
 {
     uint32_t t = config.position.gps_update_interval;
-    bool gps_enabled = config.position.gps_enabled;
 
     // We'll not need the GPS thread to wake up again after first acq. with fixed position.
-    if (!gps_enabled || config.position.fixed_position)
+    if (!config.position.gps_enabled || config.position.fixed_position)
         t = UINT32_MAX; // Sleep forever now
 
     if (t == UINT32_MAX)
@@ -546,24 +578,31 @@ void GPS::publishUpdate()
         shouldPublish = false;
 
         // In debug logs, identify position by @timestamp:stage (stage 2 = publish)
-        LOG_DEBUG("publishing pos@%x:2, hasVal=%d, GPSlock=%d\n", p.timestamp, hasValidLocation, hasLock());
+        LOG_DEBUG("publishing pos@%x:2, hasVal=%d, Sats=%d, GPSlock=%d\n", p.timestamp, hasValidLocation, p.sats_in_view,
+                  hasLock());
 
         // Notify any status instances that are observing us
         const meshtastic::GPSStatus status = meshtastic::GPSStatus(hasValidLocation, isConnected(), isPowerSaving(), p);
         newStatus.notifyObservers(&status);
+        if (config.position.gps_enabled)
+            positionModule->handleNewPosition();
     }
 }
 
 int32_t GPS::runOnce()
 {
     if (!GPSInitFinished) {
+        if (!_serial_gps)
+            return disable();
         if (!setup())
             return 2000; // Setup failed, re-run in two seconds
 
         // We have now loaded our saved preferences from flash
-
+        if (config.position.gps_enabled == false && config.position.fixed_position == false) {
+            return disable();
+        }
         // ONCE we will factory reset the GPS for bug #327
-        if (gps && !devicestate.did_gps_reset) {
+        if (!devicestate.did_gps_reset) {
             LOG_WARN("GPS FactoryReset requested\n");
             if (gps->factoryReset()) { // If we don't succeed try again next time
                 devicestate.did_gps_reset = true;
@@ -571,15 +610,12 @@ int32_t GPS::runOnce()
             }
         }
         GPSInitFinished = true;
-        if (config.position.gps_enabled == false) {
-            doGPSpowersave(false);
-            return 0;
-        }
     }
 
     // Repeaters have no need for GPS
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER)
-        disable();
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
+        return disable();
+    }
 
     if (whileIdle()) {
         // if we have received valid NMEA claim we are connected
@@ -587,20 +623,22 @@ int32_t GPS::runOnce()
     } else {
         if ((config.position.gps_enabled == 1) && (gnssModel == GNSS_MODEL_UBLOX)) {
             // reset the GPS on next bootup
-            if (devicestate.did_gps_reset && (millis() > 60000) && !hasFlow()) {
+            if (devicestate.did_gps_reset && (millis() - lastWakeStartMsec > 60000) && !hasFlow()) {
                 LOG_DEBUG("GPS is not communicating, trying factory reset on next bootup.\n");
                 devicestate.did_gps_reset = false;
                 nodeDB.saveDeviceStateToDisk();
-                disable(); // Stop the GPS thread as it can do nothing useful until next reboot.
+                return disable(); // Stop the GPS thread as it can do nothing useful until next reboot.
             }
         }
     }
 
     // If we are overdue for an update, turn on the GPS and at least publish the current status
     uint32_t now = millis();
+    uint32_t timeAsleep = now - lastSleepStartMsec;
 
     auto sleepTime = getSleepTime();
-    if (!isAwake && sleepTime != UINT32_MAX && (now - lastSleepStartMsec) > sleepTime) {
+    if (!isAwake && (sleepTime != UINT32_MAX) &&
+        ((timeAsleep > sleepTime) || (isInPowersave && timeAsleep > (sleepTime - averageLockTime)))) {
         // We now want to be awake - so wake up the GPS
         setAwake(true);
     }
@@ -608,11 +646,6 @@ int32_t GPS::runOnce()
     // While we are awake
     if (isAwake) {
         // LOG_DEBUG("looking for location\n");
-        if ((now - lastWhileActiveMsec) > 5000) {
-            lastWhileActiveMsec = now;
-            whileActive();
-        }
-
         // If we've already set time from the GPS, no need to ask the GPS
         bool gotTime = (getRTCQuality() >= RTCQualityGPS);
         if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
@@ -627,7 +660,6 @@ int32_t GPS::runOnce()
             shouldPublish = true;
         }
 
-        // We've been awake too long - force sleep
         now = millis();
         auto wakeTime = getWakeTime();
         bool tooLong = wakeTime != UINT32_MAX && (now - lastWakeStartMsec) > wakeTime;
@@ -652,26 +684,15 @@ int32_t GPS::runOnce()
 
     // If state has changed do a publish
     publishUpdate();
+
+    if (config.position.gps_enabled == false) // This should trigger if GPS is disabled but fixed_position is true
+        return disable();
+
     // 9600bps is approx 1 byte per msec, so considering our buffer size we never need to wake more often than 200ms
     // if not awake we can run super infrquently (once every 5 secs?) to see if we need to wake.
     return isAwake ? GPS_THREAD_INTERVAL : 5000;
 }
 
-void GPS::forceWake(bool on)
-{
-    if (on) {
-        LOG_DEBUG("Allowing GPS lock\n");
-        // lastSleepStartMsec = 0; // Force an update ASAP
-        wakeAllowed = true;
-    } else {
-        wakeAllowed = false;
-
-        // Note: if the gps was already awake, we DO NOT shut it down, because we want to allow it to complete its lock
-        // attempt even if we are in light sleep.  Once the attempt succeeds (or times out) we'll then shut it down.
-        // setAwake(false);
-    }
-}
-
 // clear the GPS rx buffer as quickly as possible
 void GPS::clearBuffer()
 {
@@ -680,22 +701,11 @@ void GPS::clearBuffer()
         _serial_gps->read();
 }
 
-/// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
-int GPS::prepareSleep(void *unused)
-{
-    LOG_INFO("GPS prepare sleep!\n");
-    forceWake(false);
-
-    return 0;
-}
-
 /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
 int GPS::prepareDeepSleep(void *unused)
 {
     LOG_INFO("GPS deep sleep!\n");
 
-    // For deep sleep we also want abandon any lock attempts (because we want minimum power)
-    getSleepTime();
     setAwake(false);
 
     return 0;
@@ -840,18 +850,41 @@ GnssModel_t GPS::probe(int serialSpeed)
     return GNSS_MODEL_UBLOX;
 }
 
-#if HAS_GPS
-#include "NMEAGPS.h"
-#endif
-
-GPS *createGps()
+GPS *GPS::createGps()
 {
+    int8_t _rx_gpio = config.position.rx_gpio;
+    int8_t _tx_gpio = config.position.tx_gpio;
+    int8_t _en_gpio = config.position.gps_en_gpio;
+#if defined(HAS_GPS) && !defined(ARCH_ESP32)
+    _rx_gpio = 1; // We only specify GPS serial ports on ESP32. Otherwise, these are just flags.
+    _tx_gpio = 1;
+#endif
+#if defined(GPS_RX_PIN)
+    if (!_rx_gpio)
+        _rx_gpio = GPS_RX_PIN;
+#endif
+#if defined(GPS_TX_PIN)
+    if (!_tx_gpio)
+        _tx_gpio = GPS_TX_PIN;
+#endif
+#if defined(PIN_GPS_EN)
+    if (!_en_gpio)
+        _en_gpio = PIN_GPS_EN;
+#endif
+    if (!_rx_gpio || !_serial_gps) // Configured to have no GPS at all
+        return nullptr;
+
+    GPS *new_gps = new GPS;
+    new_gps->rx_gpio = _rx_gpio;
+    new_gps->tx_gpio = _tx_gpio;
+    new_gps->en_gpio = _en_gpio;
+
+    if (_en_gpio != 0) {
+        LOG_DEBUG("Setting %d to output.\n", _en_gpio);
+        digitalWrite(_en_gpio, !GPS_EN_ACTIVE);
+        pinMode(_en_gpio, OUTPUT);
+    }
 
-#if !HAS_GPS
-    return nullptr;
-#else
-    GPS *new_gps = new NMEAGPS();
-    // Master power for the GPS
 #ifdef PIN_GPS_PPS
     // pulse per second
     pinMode(PIN_GPS_PPS, INPUT);
@@ -866,14 +899,9 @@ GPS *createGps()
     LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
 #endif
 
-#if defined(HAS_PMU) || defined(PIN_GPS_EN)
     if (config.position.gps_enabled) {
-#ifdef PIN_GPS_EN
-        pinMode(PIN_GPS_EN, OUTPUT);
-#endif
-        setGPSPower(true);
+        new_gps->setGPSPower(true, false);
     }
-#endif
 
 #ifdef PIN_GPS_RESET
     digitalWrite(PIN_GPS_RESET, GPS_RESET_MODE); // assert for 10ms
@@ -883,42 +911,286 @@ GPS *createGps()
 #endif
     new_gps->setAwake(true); // Wake GPS power before doing any init
 
-    if (new_gps->_serial_gps) {
+    if (_serial_gps) {
 #ifdef ARCH_ESP32
         // In esp32 framework, setRxBufferSize needs to be initialized before Serial
-        new_gps->_serial_gps->setRxBufferSize(SERIAL_BUFFER_SIZE); // the default is 256
+        _serial_gps->setRxBufferSize(SERIAL_BUFFER_SIZE); // the default is 256
 #endif
 
-        // if the overrides are not dialled in, set them from the board definitions, if they exist
-
-#if defined(GPS_RX_PIN)
-        if (!config.position.rx_gpio)
-            config.position.rx_gpio = GPS_RX_PIN;
-#endif
-#if defined(GPS_TX_PIN)
-        if (!config.position.tx_gpio)
-            config.position.tx_gpio = GPS_TX_PIN;
-#endif
-
-// #define BAUD_RATE 115200
 //  ESP32 has a special set of parameters vs other arduino ports
 #if defined(ARCH_ESP32)
-        if (config.position.rx_gpio) {
-            LOG_DEBUG("Using GPIO%d for GPS RX\n", config.position.rx_gpio);
-            LOG_DEBUG("Using GPIO%d for GPS TX\n", config.position.tx_gpio);
-            new_gps->_serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, config.position.rx_gpio, config.position.tx_gpio);
-        }
+        LOG_DEBUG("Using GPIO%d for GPS RX\n", new_gps->rx_gpio);
+        LOG_DEBUG("Using GPIO%d for GPS TX\n", new_gps->tx_gpio);
+        _serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, new_gps->rx_gpio, new_gps->tx_gpio);
+
 #else
-        new_gps->_serial_gps->begin(GPS_BAUDRATE);
+        _serial_gps->begin(GPS_BAUDRATE);
 #endif
 
         /*
          * T-Beam-S3-Core will be preset to use gps Probe here, and other boards will not be changed first
          */
 #if defined(GPS_UC6580)
-        new_gps->_serial_gps->updateBaudRate(115200);
+        _serial_gps->updateBaudRate(115200);
 #endif
     }
     return new_gps;
+}
+
+static int32_t toDegInt(RawDegrees d)
+{
+    int32_t degMult = 10000000; // 1e7
+    int32_t r = d.deg * degMult + d.billionths / 100;
+    if (d.negative)
+        r *= -1;
+    return r;
+}
+
+bool GPS::factoryReset()
+{
+#ifdef PIN_GPS_REINIT
+    // The L76K GNSS on the T-Echo requires the RESET pin to be pulled LOW
+    digitalWrite(PIN_GPS_REINIT, 0);
+    pinMode(PIN_GPS_REINIT, OUTPUT);
+    delay(150); // The L76K datasheet calls for at least 100MS delay
+    digitalWrite(PIN_GPS_REINIT, 1);
 #endif
+
+    // send the UBLOX Factory Reset Command regardless of detect state, something is very wrong, just assume it's UBLOX.
+    // Factory Reset
+    byte _message_reset[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF, 0xFB, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x17, 0x2B, 0x7E};
+    _serial_gps->write(_message_reset, sizeof(_message_reset));
+    delay(1000);
+    return true;
+}
+
+/**
+ * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+ * Override this method to check for new locations
+ *
+ * @return true if we've acquired a new location
+ */
+bool GPS::lookForTime()
+{
+    auto ti = reader.time;
+    auto d = reader.date;
+    if (ti.isValid() && d.isValid()) { // Note: we don't check for updated, because we'll only be called if needed
+        /* Convert to unix time
+The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
+(midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
+*/
+        struct tm t;
+        t.tm_sec = ti.second();
+        t.tm_min = ti.minute();
+        t.tm_hour = ti.hour();
+        t.tm_mday = d.day();
+        t.tm_mon = d.month() - 1;
+        t.tm_year = d.year() - 1900;
+        t.tm_isdst = false;
+        if (t.tm_mon > -1) {
+            LOG_DEBUG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min,
+                      t.tm_sec);
+            perhapsSetRTC(RTCQualityGPS, t);
+            return true;
+        } else
+            return false;
+    } else
+        return false;
+}
+
+/**
+ * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+ * Override this method to check for new locations
+ *
+ * @return true if we've acquired a new location
+ */
+bool GPS::lookForLocation()
+{
+    // By default, TinyGPS++ does not parse GPGSA lines, which give us
+    //   the 2D/3D fixType (see NMEAGPS.h)
+    // At a minimum, use the fixQuality indicator in GPGGA (FIXME?)
+    fixQual = reader.fixQuality();
+
+#ifndef TINYGPS_OPTION_NO_STATISTICS
+    if (reader.failedChecksum() > lastChecksumFailCount) {
+        LOG_WARN("Warning, %u new GPS checksum failures, for a total of %u.\n", reader.failedChecksum() - lastChecksumFailCount,
+                 reader.failedChecksum());
+        lastChecksumFailCount = reader.failedChecksum();
+    }
+#endif
+
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    fixType = atoi(gsafixtype.value()); // will set to zero if no data
+    // LOG_DEBUG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
+#endif
+
+    // check if GPS has an acceptable lock
+    if (!hasLock())
+        return false;
+
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("AGE: LOC=%d FIX=%d DATE=%d TIME=%d\n", reader.location.age(),
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+              gsafixtype.age(),
+#else
+              0,
+#endif
+              reader.date.age(), reader.time.age());
+#endif // GPS_EXTRAVERBOSE
+
+    // check if a complete GPS solution set is available for reading
+    //   tinyGPSDatum::age() also includes isValid() test
+    // FIXME
+    if (!((reader.location.age() < GPS_SOL_EXPIRY_MS) &&
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+          (gsafixtype.age() < GPS_SOL_EXPIRY_MS) &&
+#endif
+          (reader.time.age() < GPS_SOL_EXPIRY_MS) && (reader.date.age() < GPS_SOL_EXPIRY_MS))) {
+        LOG_WARN("SOME data is TOO OLD: LOC %u, TIME %u, DATE %u\n", reader.location.age(), reader.time.age(), reader.date.age());
+        return false;
+    }
+
+    // Is this a new point or are we re-reading the previous one?
+    if (!reader.location.isUpdated())
+        return false;
+
+    // We know the solution is fresh and valid, so just read the data
+    auto loc = reader.location.value();
+
+    // Bail out EARLY to avoid overwriting previous good data (like #857)
+    if (toDegInt(loc.lat) > 900000000) {
+#ifdef GPS_EXTRAVERBOSE
+        LOG_DEBUG("Bail out EARLY on LAT %i\n", toDegInt(loc.lat));
+#endif
+        return false;
+    }
+    if (toDegInt(loc.lng) > 1800000000) {
+#ifdef GPS_EXTRAVERBOSE
+        LOG_DEBUG("Bail out EARLY on LNG %i\n", toDegInt(loc.lng));
+#endif
+        return false;
+    }
+
+    p.location_source = meshtastic_Position_LocSource_LOC_INTERNAL;
+
+    // Dilution of precision (an accuracy metric) is reported in 10^2 units, so we need to scale down when we use it
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    p.HDOP = reader.hdop.value();
+    p.PDOP = TinyGPSPlus::parseDecimal(gsapdop.value());
+    // LOG_DEBUG("PDOP=%d, HDOP=%d\n", p.PDOP, p.HDOP);
+#else
+    // FIXME! naive PDOP emulation (assumes VDOP==HDOP)
+    // correct formula is PDOP = SQRT(HDOP^2 + VDOP^2)
+    p.HDOP = reader.hdop.value();
+    p.PDOP = 1.41 * reader.hdop.value();
+#endif
+
+    // Discard incomplete or erroneous readings
+    if (reader.hdop.value() == 0) {
+        LOG_WARN("BOGUS hdop.value() REJECTED: %d\n", reader.hdop.value());
+        return false;
+    }
+
+    p.latitude_i = toDegInt(loc.lat);
+    p.longitude_i = toDegInt(loc.lng);
+
+    p.altitude_geoidal_separation = reader.geoidHeight.meters();
+    p.altitude_hae = reader.altitude.meters() + p.altitude_geoidal_separation;
+    p.altitude = reader.altitude.meters();
+
+    p.fix_quality = fixQual;
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    p.fix_type = fixType;
+#endif
+
+    // positional timestamp
+    struct tm t;
+    t.tm_sec = reader.time.second();
+    t.tm_min = reader.time.minute();
+    t.tm_hour = reader.time.hour();
+    t.tm_mday = reader.date.day();
+    t.tm_mon = reader.date.month() - 1;
+    t.tm_year = reader.date.year() - 1900;
+    t.tm_isdst = false;
+    p.timestamp = mktime(&t);
+
+    // Nice to have, if available
+    if (reader.satellites.isUpdated()) {
+        p.sats_in_view = reader.satellites.value();
+    }
+
+    if (reader.course.isUpdated() && reader.course.isValid()) {
+        if (reader.course.value() < 36000) { // sanity check
+            p.ground_track =
+                reader.course.value() * 1e3; // Scale the heading (in degrees * 10^-2) to match the expected degrees * 10^-5
+        } else {
+            LOG_WARN("BOGUS course.value() REJECTED: %d\n", reader.course.value());
+        }
+    }
+
+    if (reader.speed.isUpdated() && reader.speed.isValid()) {
+        p.ground_speed = reader.speed.kmph();
+    }
+
+    return true;
+}
+
+bool GPS::hasLock()
+{
+    // Using GPGGA fix quality indicator
+    if (fixQual >= 1 && fixQual <= 5) {
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+        // Use GPGSA fix type 2D/3D (better) if available
+        if (fixType == 3 || fixType == 0) // zero means "no data received"
+#endif
+            return true;
+    }
+
+    return false;
+}
+
+bool GPS::hasFlow()
+{
+    return reader.passedChecksum() > 0;
+}
+
+bool GPS::whileIdle()
+{
+    bool isValid = false;
+    if (!isAwake) {
+        clearBuffer();
+        return isAwake;
+    }
+#ifdef SERIAL_BUFFER_SIZE
+    if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) {
+        LOG_WARN("GPS Buffer full with %u bytes waiting. Flushing to avoid corruption.\n", _serial_gps->available());
+        clearBuffer();
+    }
+#endif
+    // if (_serial_gps->available() > 0)
+    // LOG_DEBUG("GPS Bytes Waiting: %u\n", _serial_gps->available());
+    // First consume any chars that have piled up at the receiver
+    while (_serial_gps->available() > 0) {
+        int c = _serial_gps->read();
+        // LOG_DEBUG("%c", c);
+        isValid |= reader.encode(c);
+    }
+
+    return isValid;
+}
+void GPS::enable()
+{
+    enabled = true;
+    setInterval(GPS_THREAD_INTERVAL);
+    setAwake(true);
+}
+
+int32_t GPS::disable()
+{
+    enabled = false;
+    setInterval(INT32_MAX);
+    setAwake(false);
+
+    return INT32_MAX;
 }

src/gps/GPS.h

@@ -2,7 +2,16 @@
 
 #include "GPSStatus.h"
 #include "Observer.h"
+#include "TinyGPS++.h"
 #include "concurrency/OSThread.h"
+#include "input/RotaryEncoderInterruptImpl1.h"
+#include "input/UpDownInterruptImpl1.h"
+#include "modules/PositionModule.h"
+
+// Allow defining the polarity of the ENABLE output.  default is active high
+#ifndef GPS_EN_ACTIVE
+#define GPS_EN_ACTIVE 1
+#endif
 
 struct uBloxGnssModelInfo {
     char swVersion[30];
@@ -35,10 +44,27 @@ const char *getDOPString(uint32_t dop);
  */
 class GPS : private concurrency::OSThread
 {
+    TinyGPSPlus reader;
+    uint8_t fixQual = 0; // fix quality from GPGGA
+    uint32_t lastChecksumFailCount = 0;
+
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
+    // via optional feature "custom fields", currently disabled (bug #525)
+    TinyGPSCustom gsafixtype; // custom extract fix type from GPGSA
+    TinyGPSCustom gsapdop;    // custom extract PDOP from GPGSA
+    uint8_t fixType = 0;      // fix type from GPGSA
+#endif
   private:
-    uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0, lastWhileActiveMsec = 0;
+    uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0;
     const int serialSpeeds[6] = {9600, 4800, 38400, 57600, 115200, 9600};
 
+    uint32_t rx_gpio = 0;
+    uint32_t tx_gpio = 0;
+    uint32_t en_gpio = 0;
+    int32_t averageLockTime = 0;
+    uint32_t GPSCycles = 0;
+
     int speedSelect = 0;
     int probeTries = 2;
 
@@ -50,7 +76,7 @@ class GPS : private concurrency::OSThread
 
     bool isAwake = false; // true if we want a location right now
 
-    bool wakeAllowed = true; // false if gps must be forced to sleep regardless of what time it is
+    bool isInPowersave = false;
 
     bool shouldPublish = false; // If we've changed GPS state, this will force a publish the next loop()
 
@@ -61,7 +87,6 @@ class GPS : private concurrency::OSThread
 
     uint8_t numSatellites = 0;
 
-    CallbackObserver<GPS, void *> notifySleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareSleep);
     CallbackObserver<GPS, void *> notifyDeepSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
     CallbackObserver<GPS, void *> notifyGPSSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
 
@@ -101,6 +126,14 @@ class GPS : private concurrency::OSThread
      */
     virtual bool setup();
 
+    // re-enable the thread
+    void enable();
+
+    // Disable the thread
+    int32_t disable() override;
+
+    void setGPSPower(bool on, bool standbyOnly);
+
     /// Returns true if we have acquired GPS lock.
     virtual bool hasLock();
 
@@ -112,17 +145,6 @@ class GPS : private concurrency::OSThread
 
     bool isPowerSaving() const { return !config.position.gps_enabled; }
 
-    /**
-     * Restart our lock attempt - try to get and broadcast a GPS reading ASAP
-     * called after the CPU wakes from light-sleep state
-     *
-     * Or set to false, to disallow any sort of waking
-     * */
-    void forceWake(bool on);
-
-    // Some GPS modules (ublock) require factory reset
-    virtual bool factoryReset() { return true; }
-
     // Empty the input buffer as quickly as possible
     void clearBuffer();
 
@@ -142,30 +164,19 @@ class GPS : private concurrency::OSThread
      * calls sleep/wake
      */
     void setAwake(bool on);
+    virtual bool factoryReset();
+
+    // Creates an instance of the GPS class.
+    // Returns the new instance or null if the GPS is not present.
+    static GPS *createGps();
 
   protected:
-    /// If possible force the GPS into sleep/low power mode
-    virtual void sleep();
-
-    /// wake the GPS into normal operation mode
-    virtual void wake();
-
-    /** Subclasses should look for serial rx characters here and feed it to their GPS parser
-     *
-     * Return true if we received a valid message from the GPS
-     */
-    virtual bool whileIdle() = 0;
-
-    /** Idle processing while GPS is looking for lock, called once per secondish */
-    virtual void whileActive() {}
-
     /**
      * Perform any processing that should be done only while the GPS is awake and looking for a fix.
      * Override this method to check for new locations
      *
      * @return true if we've acquired a time
      */
-    virtual bool lookForTime() = 0;
 
     /**
      * Perform any processing that should be done only while the GPS is awake and looking for a fix.
@@ -173,18 +184,33 @@ class GPS : private concurrency::OSThread
      *
      * @return true if we've acquired a new location
      */
-    virtual bool lookForLocation() = 0;
 
     /// Record that we have a GPS
     void setConnected();
 
-    void setNumSatellites(uint8_t n);
+    /** Subclasses should look for serial rx characters here and feed it to their GPS parser
+     *
+     * Return true if we received a valid message from the GPS
+     */
+    virtual bool whileIdle();
+
+    /**
+     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+     * Override this method to check for new locations
+     *
+     * @return true if we've acquired a time
+     */
+    virtual bool lookForTime();
+
+    /**
+     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
+     * Override this method to check for new locations
+     *
+     * @return true if we've acquired a new location
+     */
+    virtual bool lookForLocation();
 
   private:
-    /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
-    /// always returns 0 to indicate okay to sleep
-    int prepareSleep(void *unused);
-
     /// Prepare the GPS for the cpu entering deep sleep, expect to be gone for at least 100s of msecs
     /// always returns 0 to indicate okay to sleep
     int prepareDeepSleep(void *unused);
@@ -218,8 +244,4 @@ class GPS : private concurrency::OSThread
     GnssModel_t gnssModel = GNSS_MODEL_UNKNOWN;
 };
 
-// Creates an instance of the GPS class.
-// Returns the new instance or null if the GPS is not present.
-GPS *createGps();
-
 extern GPS *gps;

src/gps/NMEAGPS.cpp

@@ -1,248 +0,0 @@
-#include "NMEAGPS.h"
-#include "RTC.h"
-#include "configuration.h"
-
-#include <TinyGPS++.h>
-
-// GPS solutions older than this will be rejected - see TinyGPSDatum::age()
-#define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
-#define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
-
-static int32_t toDegInt(RawDegrees d)
-{
-    int32_t degMult = 10000000; // 1e7
-    int32_t r = d.deg * degMult + d.billionths / 100;
-    if (d.negative)
-        r *= -1;
-    return r;
-}
-
-bool NMEAGPS::factoryReset()
-{
-#ifdef PIN_GPS_REINIT
-    // The L76K GNSS on the T-Echo requires the RESET pin to be pulled LOW
-    digitalWrite(PIN_GPS_REINIT, 0);
-    pinMode(PIN_GPS_REINIT, OUTPUT);
-    delay(150); // The L76K datasheet calls for at least 100MS delay
-    digitalWrite(PIN_GPS_REINIT, 1);
-#endif
-
-    // send the UBLOX Factory Reset Command regardless of detect state, something is very wrong, just assume it's UBLOX.
-    // Factory Reset
-    byte _message_reset[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF, 0xFB, 0x00, 0x00, 0x00,
-                             0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x17, 0x2B, 0x7E};
-    _serial_gps->write(_message_reset, sizeof(_message_reset));
-    delay(1000);
-    return true;
-}
-
-/**
- * Perform any processing that should be done only while the GPS is awake and looking for a fix.
- * Override this method to check for new locations
- *
- * @return true if we've acquired a new location
- */
-bool NMEAGPS::lookForTime()
-{
-    auto ti = reader.time;
-    auto d = reader.date;
-    if (ti.isValid() && d.isValid()) { // Note: we don't check for updated, because we'll only be called if needed
-        /* Convert to unix time
-The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
-(midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
-*/
-        struct tm t;
-        t.tm_sec = ti.second();
-        t.tm_min = ti.minute();
-        t.tm_hour = ti.hour();
-        t.tm_mday = d.day();
-        t.tm_mon = d.month() - 1;
-        t.tm_year = d.year() - 1900;
-        t.tm_isdst = false;
-        if (t.tm_mon > -1) {
-            LOG_DEBUG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min,
-                      t.tm_sec);
-            perhapsSetRTC(RTCQualityGPS, t);
-            return true;
-        } else
-            return false;
-    } else
-        return false;
-}
-
-/**
- * Perform any processing that should be done only while the GPS is awake and looking for a fix.
- * Override this method to check for new locations
- *
- * @return true if we've acquired a new location
- */
-bool NMEAGPS::lookForLocation()
-{
-    // By default, TinyGPS++ does not parse GPGSA lines, which give us
-    //   the 2D/3D fixType (see NMEAGPS.h)
-    // At a minimum, use the fixQuality indicator in GPGGA (FIXME?)
-    fixQual = reader.fixQuality();
-
-#ifndef TINYGPS_OPTION_NO_STATISTICS
-    if (reader.failedChecksum() > lastChecksumFailCount) {
-        LOG_WARN("Warning, %u new GPS checksum failures, for a total of %u.\n", reader.failedChecksum() - lastChecksumFailCount,
-                 reader.failedChecksum());
-        lastChecksumFailCount = reader.failedChecksum();
-    }
-#endif
-
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    fixType = atoi(gsafixtype.value()); // will set to zero if no data
-    // LOG_DEBUG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
-#endif
-
-    // check if GPS has an acceptable lock
-    if (!hasLock())
-        return false;
-
-#ifdef GPS_EXTRAVERBOSE
-    LOG_DEBUG("AGE: LOC=%d FIX=%d DATE=%d TIME=%d\n", reader.location.age(),
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-              gsafixtype.age(),
-#else
-              0,
-#endif
-              reader.date.age(), reader.time.age());
-#endif // GPS_EXTRAVERBOSE
-
-    // check if a complete GPS solution set is available for reading
-    //   tinyGPSDatum::age() also includes isValid() test
-    // FIXME
-    if (!((reader.location.age() < GPS_SOL_EXPIRY_MS) &&
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-          (gsafixtype.age() < GPS_SOL_EXPIRY_MS) &&
-#endif
-          (reader.time.age() < GPS_SOL_EXPIRY_MS) && (reader.date.age() < GPS_SOL_EXPIRY_MS))) {
-        LOG_WARN("SOME data is TOO OLD: LOC %u, TIME %u, DATE %u\n", reader.location.age(), reader.time.age(), reader.date.age());
-        return false;
-    }
-
-    // Is this a new point or are we re-reading the previous one?
-    if (!reader.location.isUpdated())
-        return false;
-
-    // We know the solution is fresh and valid, so just read the data
-    auto loc = reader.location.value();
-
-    // Bail out EARLY to avoid overwriting previous good data (like #857)
-    if (toDegInt(loc.lat) > 900000000) {
-#ifdef GPS_EXTRAVERBOSE
-        LOG_DEBUG("Bail out EARLY on LAT %i\n", toDegInt(loc.lat));
-#endif
-        return false;
-    }
-    if (toDegInt(loc.lng) > 1800000000) {
-#ifdef GPS_EXTRAVERBOSE
-        LOG_DEBUG("Bail out EARLY on LNG %i\n", toDegInt(loc.lng));
-#endif
-        return false;
-    }
-
-    p.location_source = meshtastic_Position_LocSource_LOC_INTERNAL;
-
-    // Dilution of precision (an accuracy metric) is reported in 10^2 units, so we need to scale down when we use it
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    p.HDOP = reader.hdop.value();
-    p.PDOP = TinyGPSPlus::parseDecimal(gsapdop.value());
-    // LOG_DEBUG("PDOP=%d, HDOP=%d\n", p.PDOP, p.HDOP);
-#else
-    // FIXME! naive PDOP emulation (assumes VDOP==HDOP)
-    // correct formula is PDOP = SQRT(HDOP^2 + VDOP^2)
-    p.HDOP = reader.hdop.value();
-    p.PDOP = 1.41 * reader.hdop.value();
-#endif
-
-    // Discard incomplete or erroneous readings
-    if (reader.hdop.value() == 0) {
-        LOG_WARN("BOGUS hdop.value() REJECTED: %d\n", reader.hdop.value());
-        return false;
-    }
-
-    p.latitude_i = toDegInt(loc.lat);
-    p.longitude_i = toDegInt(loc.lng);
-
-    p.altitude_geoidal_separation = reader.geoidHeight.meters();
-    p.altitude_hae = reader.altitude.meters() + p.altitude_geoidal_separation;
-    p.altitude = reader.altitude.meters();
-
-    p.fix_quality = fixQual;
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    p.fix_type = fixType;
-#endif
-
-    // positional timestamp
-    struct tm t;
-    t.tm_sec = reader.time.second();
-    t.tm_min = reader.time.minute();
-    t.tm_hour = reader.time.hour();
-    t.tm_mday = reader.date.day();
-    t.tm_mon = reader.date.month() - 1;
-    t.tm_year = reader.date.year() - 1900;
-    t.tm_isdst = false;
-    p.timestamp = mktime(&t);
-
-    // Nice to have, if available
-    if (reader.satellites.isUpdated()) {
-        p.sats_in_view = reader.satellites.value();
-    }
-
-    if (reader.course.isUpdated() && reader.course.isValid()) {
-        if (reader.course.value() < 36000) { // sanity check
-            p.ground_track =
-                reader.course.value() * 1e3; // Scale the heading (in degrees * 10^-2) to match the expected degrees * 10^-5
-        } else {
-            LOG_WARN("BOGUS course.value() REJECTED: %d\n", reader.course.value());
-        }
-    }
-
-    if (reader.speed.isUpdated() && reader.speed.isValid()) {
-        p.ground_speed = reader.speed.kmph();
-    }
-
-    return true;
-}
-
-bool NMEAGPS::hasLock()
-{
-    // Using GPGGA fix quality indicator
-    if (fixQual >= 1 && fixQual <= 5) {
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-        // Use GPGSA fix type 2D/3D (better) if available
-        if (fixType == 3 || fixType == 0) // zero means "no data received"
-#endif
-            return true;
-    }
-
-    return false;
-}
-
-bool NMEAGPS::hasFlow()
-{
-    return reader.passedChecksum() > 0;
-}
-
-bool NMEAGPS::whileIdle()
-{
-    bool isValid = false;
-#ifdef SERIAL_BUFFER_SIZE
-    if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) {
-        LOG_WARN("GPS Buffer full with %u bytes waiting. Flushing to avoid corruption.\n", _serial_gps->available());
-        clearBuffer();
-    }
-#endif
-    // if (_serial_gps->available() > 0)
-    // LOG_DEBUG("GPS Bytes Waiting: %u\n", _serial_gps->available());
-    // First consume any chars that have piled up at the receiver
-    while (_serial_gps->available() > 0) {
-        int c = _serial_gps->read();
-        // LOG_DEBUG("%c", c);
-        isValid |= reader.encode(c);
-    }
-
-    return isValid;
-}

src/gps/NMEAGPS.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include "GPS.h"
-#include "Observer.h"
-#include "TinyGPS++.h"
-
-/**
- * A gps class thatreads from a NMEA GPS stream (and FIXME - eventually keeps the gps powered down except when reading)
- *
- * When new data is available it will notify observers.
- */
-class NMEAGPS : public GPS
-{
-    TinyGPSPlus reader;
-    uint8_t fixQual = 0; // fix quality from GPGGA
-    uint32_t lastChecksumFailCount = 0;
-
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
-    // via optional feature "custom fields", currently disabled (bug #525)
-    TinyGPSCustom gsafixtype; // custom extract fix type from GPGSA
-    TinyGPSCustom gsapdop;    // custom extract PDOP from GPGSA
-    uint8_t fixType = 0;      // fix type from GPGSA
-#endif
-
-  public:
-    virtual bool factoryReset() override;
-
-  protected:
-    /** Subclasses should look for serial rx characters here and feed it to their GPS parser
-     *
-     * Return true if we received a valid message from the GPS
-     */
-    virtual bool whileIdle() override;
-
-    /**
-     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
-     * Override this method to check for new locations
-     *
-     * @return true if we've acquired a time
-     */
-    virtual bool lookForTime() override;
-
-    /**
-     * Perform any processing that should be done only while the GPS is awake and looking for a fix.
-     * Override this method to check for new locations
-     *
-     * @return true if we've acquired a new location
-     */
-    virtual bool lookForLocation() override;
-
-    virtual bool hasLock() override;
-
-    virtual bool hasFlow() override;
-};

src/gps/RTC.cpp

@@ -103,9 +103,8 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
 
     bool shouldSet;
     if (q > currentQuality) {
-        currentQuality = q;
         shouldSet = true;
-        LOG_DEBUG("Upgrading time to RTC %ld secs (quality %d)\n", tv->tv_sec, q);
+        LOG_DEBUG("Upgrading time to quality %d\n", q);
     } else if (q == RTCQualityGPS && (now - lastSetMsec) > (12 * 60 * 60 * 1000UL)) {
         // Every 12 hrs we will slam in a new GPS time, to correct for local RTC clock drift
         shouldSet = true;
@@ -114,12 +113,12 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
         shouldSet = false;
 
     if (shouldSet) {
+        currentQuality = q;
         lastSetMsec = now;
 
         // This delta value works on all platforms
         timeStartMsec = now;
         zeroOffsetSecs = tv->tv_sec;
-
         // If this platform has a setable RTC, set it
 #ifdef RV3028_RTC
         if (rtc_found.address == RV3028_RTC) {
@@ -209,4 +208,4 @@ uint32_t getTime()
 uint32_t getValidTime(RTCQuality minQuality)
 {
     return (currentQuality >= minQuality) ? getTime() : 0;
-}
+}

src/input/RotaryEncoderInterruptImpl1.cpp

@@ -5,12 +5,12 @@ RotaryEncoderInterruptImpl1 *rotaryEncoderInterruptImpl1;
 
 RotaryEncoderInterruptImpl1::RotaryEncoderInterruptImpl1() : RotaryEncoderInterruptBase("rotEnc1") {}
 
-void RotaryEncoderInterruptImpl1::init()
+bool RotaryEncoderInterruptImpl1::init()
 {
     if (!moduleConfig.canned_message.rotary1_enabled) {
         // Input device is disabled.
         disable();
-        return;
+        return false;
     }
 
     uint8_t pinA = moduleConfig.canned_message.inputbroker_pin_a;
@@ -25,6 +25,7 @@ void RotaryEncoderInterruptImpl1::init()
                                      RotaryEncoderInterruptImpl1::handleIntA, RotaryEncoderInterruptImpl1::handleIntB,
                                      RotaryEncoderInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+    return true;
 }
 
 void RotaryEncoderInterruptImpl1::handleIntA()
@@ -38,4 +39,4 @@ void RotaryEncoderInterruptImpl1::handleIntB()
 void RotaryEncoderInterruptImpl1::handleIntPressed()
 {
     rotaryEncoderInterruptImpl1->intPressHandler();
-}
+}

src/input/RotaryEncoderInterruptImpl1.h

@@ -12,7 +12,7 @@ class RotaryEncoderInterruptImpl1 : public RotaryEncoderInterruptBase
 {
   public:
     RotaryEncoderInterruptImpl1();
-    void init();
+    bool init();
     static void handleIntA();
     static void handleIntB();
     static void handleIntPressed();

src/input/UpDownInterruptImpl1.cpp

@@ -5,12 +5,12 @@ UpDownInterruptImpl1 *upDownInterruptImpl1;
 
 UpDownInterruptImpl1::UpDownInterruptImpl1() : UpDownInterruptBase("upDown1") {}
 
-void UpDownInterruptImpl1::init()
+bool UpDownInterruptImpl1::init()
 {
 
     if (!moduleConfig.canned_message.updown1_enabled) {
         // Input device is disabled.
-        return;
+        return false;
     }
 
     uint8_t pinUp = moduleConfig.canned_message.inputbroker_pin_a;
@@ -24,6 +24,7 @@ void UpDownInterruptImpl1::init()
     UpDownInterruptBase::init(pinDown, pinUp, pinPress, eventDown, eventUp, eventPressed, UpDownInterruptImpl1::handleIntDown,
                               UpDownInterruptImpl1::handleIntUp, UpDownInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+    return true;
 }
 
 void UpDownInterruptImpl1::handleIntDown()
@@ -37,4 +38,4 @@ void UpDownInterruptImpl1::handleIntUp()
 void UpDownInterruptImpl1::handleIntPressed()
 {
     upDownInterruptImpl1->intPressHandler();
-}
+}

src/input/UpDownInterruptImpl1.h

@@ -5,10 +5,10 @@ class UpDownInterruptImpl1 : public UpDownInterruptBase
 {
   public:
     UpDownInterruptImpl1();
-    void init();
+    bool init();
     static void handleIntDown();
     static void handleIntUp();
     static void handleIntPressed();
 };
 
-extern UpDownInterruptImpl1 *upDownInterruptImpl1;
+extern UpDownInterruptImpl1 *upDownInterruptImpl1;

src/main.cpp

@@ -221,11 +221,6 @@ void setup()
     digitalWrite(VEXT_ENABLE, 0); // turn on the display power
 #endif
 
-#ifdef VGNSS_CTRL
-    pinMode(VGNSS_CTRL, OUTPUT);
-    digitalWrite(VGNSS_CTRL, LOW);
-#endif
-
 #if defined(VTFT_CTRL)
     pinMode(VTFT_CTRL, OUTPUT);
     digitalWrite(VTFT_CTRL, LOW);
@@ -557,9 +552,13 @@ void setup()
     screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
 
     readFromRTC(); // read the main CPU RTC at first (in case we can't get GPS time)
-    gps = createGps();
-    if (gps)
+
+    gps = GPS::createGps();
+    if (gps) {
         gpsStatus->observe(&gps->newStatus);
+    } else {
+        LOG_DEBUG("Running without GPS.\n");
+    }
     nodeStatus->observe(&nodeDB.newStatus);
 
     service.init();

src/mesh/NodeDB.cpp

@@ -169,6 +169,14 @@ void NodeDB::installDefaultConfig()
     config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
     config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
     config.lora.hop_limit = HOP_RELIABLE;
+#ifdef PIN_GPS_EN
+    config.position.gps_en_gpio = PIN_GPS_EN;
+#endif
+#ifdef GPS_POWER_TOGGLE
+    config.device.disable_triple_click = false;
+#else
+    config.device.disable_triple_click = true;
+#endif
     config.position.gps_enabled = true;
     config.position.position_broadcast_smart_enabled = true;
     config.position.broadcast_smart_minimum_distance = 100;
@@ -304,6 +312,19 @@ void NodeDB::resetNodes()
         neighborInfoModule->resetNeighbors();
 }
 
+void NodeDB::cleanupMeshDB()
+{
+    int newPos = 0, removed = 0;
+    for (int i = 0; i < *numMeshNodes; i++) {
+        if (meshNodes[i].has_user)
+            meshNodes[newPos++] = meshNodes[i];
+        else
+            removed++;
+    }
+    *numMeshNodes -= removed;
+    LOG_DEBUG("cleanupMeshDB purged %d entries\n", removed);
+}
+
 void NodeDB::installDefaultDeviceState()
 {
     LOG_INFO("Installing default DeviceState\n");
@@ -333,6 +354,7 @@ void NodeDB::init()
 {
     LOG_INFO("Initializing NodeDB\n");
     loadFromDisk();
+    cleanupMeshDB();
 
     uint32_t devicestateCRC = crc32Buffer(&devicestate, sizeof(devicestate));
     uint32_t configCRC = crc32Buffer(&config, sizeof(config));
@@ -388,25 +410,20 @@ void NodeDB::init()
  */
 void NodeDB::pickNewNodeNum()
 {
-    NodeNum r = myNodeInfo.my_node_num;
-
     getMacAddr(ourMacAddr); // Make sure ourMacAddr is set
 
     // Pick an initial nodenum based on the macaddr
-    r = (ourMacAddr[2] << 24) | (ourMacAddr[3] << 16) | (ourMacAddr[4] << 8) | ourMacAddr[5];
-
-    if (r == NODENUM_BROADCAST || r < NUM_RESERVED)
-        r = NUM_RESERVED; // don't pick a reserved node number
+    NodeNum nodeNum = (ourMacAddr[2] << 24) | (ourMacAddr[3] << 16) | (ourMacAddr[4] << 8) | ourMacAddr[5];
 
     meshtastic_NodeInfoLite *found;
-    while ((found = getMeshNode(r)) && memcmp(found->user.macaddr, owner.macaddr, sizeof(owner.macaddr))) {
-        // FIXME: input for random() is int, so NODENUM_BROADCAST becomes -1
-        NodeNum n = random(NUM_RESERVED, NODENUM_BROADCAST); // try a new random choice
-        LOG_WARN("NOTE! Our desired nodenum 0x%x is in use, so trying for 0x%x\n", r, n);
-        r = n;
+    while ((nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED) ||
+           ((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, owner.macaddr, sizeof(owner.macaddr)) != 0)) {
+        NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
+        LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, so trying for 0x%x\n", nodeNum, candidate);
+        nodeNum = candidate;
     }
 
-    myNodeInfo.my_node_num = r;
+    myNodeInfo.my_node_num = nodeNum;
 }
 
 static const char *prefFileName = "/prefs/db.proto";

src/mesh/NodeDB.h

@@ -146,6 +146,9 @@ class NodeDB
     /// read our db from flash
     void loadFromDisk();
 
+    /// purge db entries without user info
+    void cleanupMeshDB();
+
     /// Reinit device state from scratch (not loading from disk)
     void installDefaultDeviceState(), installDefaultChannels(), installDefaultConfig(), installDefaultModuleConfig();
 };

src/mesh/PhoneAPI.cpp

@@ -155,11 +155,18 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         // app not to send locations on our behalf.
         fromRadioScratch.which_payload_variant = meshtastic_FromRadio_my_info_tag;
         fromRadioScratch.my_info = myNodeInfo;
-        state = STATE_SEND_NODEINFO;
+        state = STATE_SEND_METADATA;
 
         service.refreshLocalMeshNode(); // Update my NodeInfo because the client will be asking for it soon.
         break;
 
+    case STATE_SEND_METADATA:
+        LOG_INFO("getFromRadio=STATE_SEND_METADATA\n");
+        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_metadata_tag;
+        fromRadioScratch.metadata = getDeviceMetadata();
+        state = STATE_SEND_NODEINFO;
+        break;
+
     case STATE_SEND_NODEINFO: {
         LOG_INFO("getFromRadio=STATE_SEND_NODEINFO\n");
 
@@ -294,15 +301,11 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         config_state++;
         // Advance when we have sent all of our ModuleConfig objects
         if (config_state > (_meshtastic_AdminMessage_ModuleConfigType_MAX + 1)) {
-            state = STATE_SEND_METADATA;
+            state = STATE_SEND_COMPLETE_ID;
             config_state = 0;
         }
         break;
-    case STATE_SEND_METADATA:
-        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_metadata_tag;
-        fromRadioScratch.metadata = getDeviceMetadata();
-        state = STATE_SEND_COMPLETE_ID;
-        break;
+
     case STATE_SEND_COMPLETE_ID:
         LOG_INFO("getFromRadio=STATE_SEND_COMPLETE_ID\n");
         fromRadioScratch.which_payload_variant = meshtastic_FromRadio_config_complete_id_tag;

src/mesh/RadioInterface.cpp

@@ -534,8 +534,8 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
     h->id = p->id;
     h->channel = p->channel;
     if (p->hop_limit > HOP_MAX) {
-        LOG_WARN("hop limit %d is too high, setting to %d\n", p->hop_limit, HOP_MAX);
-        p->hop_limit = HOP_MAX;
+        LOG_WARN("hop limit %d is too high, setting to %d\n", p->hop_limit, HOP_RELIABLE);
+        p->hop_limit = HOP_RELIABLE;
     }
     h->flags = p->hop_limit | (p->want_ack ? PACKET_FLAGS_WANT_ACK_MASK : 0);
 

src/mesh/Router.cpp

@@ -359,6 +359,7 @@ bool perhapsDecode(meshtastic_MeshPacket *p)
                     // LOG_DEBUG("\n\n**\n\nDecompressed length - %d \n", decompressed_len);
 
                     memcpy(p->decoded.payload.bytes, decompressed_out, decompressed_len);
+                    p->decoded.payload.size = decompressed_len;
 
                     // Switch the port from PortNum_TEXT_MESSAGE_COMPRESSED_APP to PortNum_TEXT_MESSAGE_APP
                     p->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
@@ -382,9 +383,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
 
     // If the packet is not yet encrypted, do so now
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
-        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_Data_msg, &p->decoded);
-
-        // Only allow encryption on the text message app.
+        // Only allow compression on the text message app.
         //  TODO: Allow modules to opt into compression.
         if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) {
 
@@ -396,17 +395,12 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             int compressed_len;
             compressed_len = unishox2_compress_simple(original_payload, p->decoded.payload.size, compressed_out);
 
-            LOG_DEBUG("Original length - %d \n", p->decoded.payload.size);
-            LOG_DEBUG("Compressed length - %d \n", compressed_len);
+            LOG_DEBUG("Length - %d, compressed length - %d \n", p->decoded.payload.size, compressed_len);
             LOG_DEBUG("Original message - %s \n", p->decoded.payload.bytes);
 
             // If the compressed length is greater than or equal to the original size, don't use the compressed form
             if (compressed_len >= p->decoded.payload.size) {
-
                 LOG_DEBUG("Not using compressing message.\n");
-                // Set the uncompressed payload variant anyway. Shouldn't hurt?
-                // p->decoded.which_payloadVariant = Data_payload_tag;
-
                 // Otherwise we use the compressor
             } else {
                 LOG_DEBUG("Using compressed message.\n");
@@ -419,6 +413,8 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             }
         }
 
+        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_Data_msg, &p->decoded);
+
         if (numbytes > MAX_RHPACKETLEN)
             return meshtastic_Routing_Error_TOO_LARGE;
 

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

@@ -237,6 +237,8 @@ typedef struct _meshtastic_Config_DeviceConfig {
     /* If true, device is considered to be "managed" by a mesh administrator
  Clients should then limit available configuration and administrative options inside the user interface */
     bool is_managed;
+    /* Disables the triple-press of user button to enable or disable GPS */
+    bool disable_triple_click;
 } meshtastic_Config_DeviceConfig;
 
 /* Position Config */
@@ -272,6 +274,8 @@ typedef struct _meshtastic_Config_PositionConfig {
     uint32_t broadcast_smart_minimum_distance;
     /* The minimum number of seconds (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled */
     uint32_t broadcast_smart_minimum_interval_secs;
+    /* (Re)define PIN_GPS_EN for your board. */
+    uint32_t gps_en_gpio;
 } meshtastic_Config_PositionConfig;
 
 /* Power Config\
@@ -399,7 +403,8 @@ typedef struct _meshtastic_Config_LoRaConfig {
     /* The region code for the radio (US, CN, EU433, etc...) */
     meshtastic_Config_LoRaConfig_RegionCode region;
     /* Maximum number of hops. This can't be greater than 7.
- Default of 3 */
+ Default of 3
+ Attempting to set a value > 7 results in the default */
     uint32_t hop_limit;
     /* Disable TX from the LoRa radio. Useful for hot-swapping antennas and other tests.
  Defaults to false */
@@ -530,8 +535,8 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_Config_init_default           {0, {meshtastic_Config_DeviceConfig_init_default}}
-#define meshtastic_Config_DeviceConfig_init_default {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0}
-#define meshtastic_Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_Config_DeviceConfig_init_default {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0, 0}
+#define meshtastic_Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
@@ -539,8 +544,8 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_init_zero              {0, {meshtastic_Config_DeviceConfig_init_zero}}
-#define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0}
-#define meshtastic_Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0, 0}
+#define meshtastic_Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
@@ -558,6 +563,7 @@ extern "C" {
 #define meshtastic_Config_DeviceConfig_node_info_broadcast_secs_tag 7
 #define meshtastic_Config_DeviceConfig_double_tap_as_button_press_tag 8
 #define meshtastic_Config_DeviceConfig_is_managed_tag 9
+#define meshtastic_Config_DeviceConfig_disable_triple_click_tag 10
 #define meshtastic_Config_PositionConfig_position_broadcast_secs_tag 1
 #define meshtastic_Config_PositionConfig_position_broadcast_smart_enabled_tag 2
 #define meshtastic_Config_PositionConfig_fixed_position_tag 3
@@ -569,6 +575,7 @@ extern "C" {
 #define meshtastic_Config_PositionConfig_tx_gpio_tag 9
 #define meshtastic_Config_PositionConfig_broadcast_smart_minimum_distance_tag 10
 #define meshtastic_Config_PositionConfig_broadcast_smart_minimum_interval_secs_tag 11
+#define meshtastic_Config_PositionConfig_gps_en_gpio_tag 12
 #define meshtastic_Config_PowerConfig_is_power_saving_tag 1
 #define meshtastic_Config_PowerConfig_on_battery_shutdown_after_secs_tag 2
 #define meshtastic_Config_PowerConfig_adc_multiplier_override_tag 3
@@ -653,7 +660,8 @@ X(a, STATIC,   SINGULAR, UINT32,   buzzer_gpio,       5) \
 X(a, STATIC,   SINGULAR, UENUM,    rebroadcast_mode,   6) \
 X(a, STATIC,   SINGULAR, UINT32,   node_info_broadcast_secs,   7) \
 X(a, STATIC,   SINGULAR, BOOL,     double_tap_as_button_press,   8) \
-X(a, STATIC,   SINGULAR, BOOL,     is_managed,        9)
+X(a, STATIC,   SINGULAR, BOOL,     is_managed,        9) \
+X(a, STATIC,   SINGULAR, BOOL,     disable_triple_click,  10)
 #define meshtastic_Config_DeviceConfig_CALLBACK NULL
 #define meshtastic_Config_DeviceConfig_DEFAULT NULL
 
@@ -668,7 +676,8 @@ X(a, STATIC,   SINGULAR, UINT32,   position_flags,    7) \
 X(a, STATIC,   SINGULAR, UINT32,   rx_gpio,           8) \
 X(a, STATIC,   SINGULAR, UINT32,   tx_gpio,           9) \
 X(a, STATIC,   SINGULAR, UINT32,   broadcast_smart_minimum_distance,  10) \
-X(a, STATIC,   SINGULAR, UINT32,   broadcast_smart_minimum_interval_secs,  11)
+X(a, STATIC,   SINGULAR, UINT32,   broadcast_smart_minimum_interval_secs,  11) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_en_gpio,      12)
 #define meshtastic_Config_PositionConfig_CALLBACK NULL
 #define meshtastic_Config_PositionConfig_DEFAULT NULL
 
@@ -768,12 +777,12 @@ extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_Config_BluetoothConfig_size   10
-#define meshtastic_Config_DeviceConfig_size      30
+#define meshtastic_Config_DeviceConfig_size      32
 #define meshtastic_Config_DisplayConfig_size     28
 #define meshtastic_Config_LoRaConfig_size        77
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     195
-#define meshtastic_Config_PositionConfig_size    54
+#define meshtastic_Config_PositionConfig_size    60
 #define meshtastic_Config_PowerConfig_size       40
 #define meshtastic_Config_size                   198
 

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

@@ -316,7 +316,7 @@ extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePin_msg;
 #define meshtastic_DeviceState_size              16854
 #define meshtastic_NodeInfoLite_size             151
 #define meshtastic_NodeRemoteHardwarePin_size    29
-#define meshtastic_OEMStore_size                 3210
+#define meshtastic_OEMStore_size                 3218
 #define meshtastic_PositionLite_size             28
 
 #ifdef __cplusplus

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

@@ -174,7 +174,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 #define meshtastic_LocalModuleConfig_fields &meshtastic_LocalModuleConfig_msg
 
 /* Maximum encoded size of messages (where known) */
-#define meshtastic_LocalConfig_size              455
+#define meshtastic_LocalConfig_size              463
 #define meshtastic_LocalModuleConfig_size        609
 
 #ifdef __cplusplus

src/mesh/mesh-pb-constants.cpp

@@ -25,7 +25,7 @@ bool pb_decode_from_bytes(const uint8_t *srcbuf, size_t srcbufsize, const pb_msg
 {
     pb_istream_t stream = pb_istream_from_buffer(srcbuf, srcbufsize);
     if (!pb_decode(&stream, fields, dest_struct)) {
-        LOG_ERROR("Can't decode protobuf reason='%s', pb_msgdesc 0x%p\n", PB_GET_ERROR(&stream), fields);
+        LOG_ERROR("Can't decode protobuf reason='%s', pb_msgdesc %p\n", PB_GET_ERROR(&stream), fields);
         return false;
     } else {
         return true;

src/modules/Modules.cpp

@@ -60,9 +60,15 @@ void setupModules()
         new ReplyModule();
 #if HAS_BUTTON
         rotaryEncoderInterruptImpl1 = new RotaryEncoderInterruptImpl1();
-        rotaryEncoderInterruptImpl1->init();
+        if (!rotaryEncoderInterruptImpl1->init()) {
+            delete rotaryEncoderInterruptImpl1;
+            rotaryEncoderInterruptImpl1 = nullptr;
+        }
         upDownInterruptImpl1 = new UpDownInterruptImpl1();
-        upDownInterruptImpl1->init();
+        if (!upDownInterruptImpl1->init()) {
+            delete upDownInterruptImpl1;
+            upDownInterruptImpl1 = nullptr;
+        }
         cardKbI2cImpl = new CardKbI2cImpl();
         cardKbI2cImpl->init();
 #ifdef INPUTBROKER_MATRIX_TYPE

src/modules/PositionModule.cpp

@@ -230,4 +230,41 @@ int32_t PositionModule::runOnce()
     }
 
     return 5000; // to save power only wake for our callback occasionally
+}
+
+void PositionModule::handleNewPosition()
+{
+    meshtastic_NodeInfoLite *node = nodeDB.getMeshNode(nodeDB.getNodeNum());
+    const meshtastic_NodeInfoLite *node2 = service.refreshLocalMeshNode(); // should guarantee there is now a position
+    // We limit our GPS broadcasts to a max rate
+    uint32_t now = millis();
+    uint32_t msSinceLastSend = now - lastGpsSend;
+
+    if (hasValidPosition(node2)) {
+        // The minimum distance to travel before we are able to send a new position packet.
+        const uint32_t distanceTravelThreshold =
+            config.position.broadcast_smart_minimum_distance > 0 ? config.position.broadcast_smart_minimum_distance : 100;
+
+        // Determine the distance in meters between two points on the globe
+        float distanceTraveledSinceLastSend = GeoCoord::latLongToMeter(
+            lastGpsLatitude * 1e-7, lastGpsLongitude * 1e-7, node->position.latitude_i * 1e-7, node->position.longitude_i * 1e-7);
+
+        if ((abs(distanceTraveledSinceLastSend) >= distanceTravelThreshold)) {
+            bool requestReplies = currentGeneration != radioGeneration;
+            currentGeneration = radioGeneration;
+
+            LOG_INFO("Sending smart pos@%x:6 to mesh (distanceTraveled=%fm, minDistanceThreshold=%im, timeElapsed=%ims)\n",
+                     localPosition.timestamp, abs(distanceTraveledSinceLastSend), distanceTravelThreshold, msSinceLastSend);
+            sendOurPosition(NODENUM_BROADCAST, requestReplies);
+
+            // Set the current coords as our last ones, after we've compared distance with current and decided to send
+            lastGpsLatitude = node->position.latitude_i;
+            lastGpsLongitude = node->position.longitude_i;
+
+            /* Update lastGpsSend to now. This means if the device is stationary, then
+                getPref_position_broadcast_secs will still apply.
+            */
+            lastGpsSend = now;
+        }
+    }
 }

src/modules/PositionModule.h

@@ -31,6 +31,8 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
      */
     void sendOurPosition(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false, uint8_t channel = 0);
 
+    void handleNewPosition();
+
   protected:
     /** Called to handle a particular incoming message
 

src/platform/esp32/architecture.h

@@ -123,22 +123,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_HT62
 #endif
 
-//
-// Standard definitions for ESP32 targets
-//
-
-#define GPS_SERIAL_NUM 1
-#ifndef GPS_RX_PIN
-#define GPS_RX_PIN 34
-#endif
-#ifndef GPS_TX_PIN
-#ifdef USE_JTAG
-#define GPS_TX_PIN -1
-#else
-#define GPS_TX_PIN 12
-#endif
-#endif
-
 // -----------------------------------------------------------------------------
 // LoRa SPI
 // -----------------------------------------------------------------------------
@@ -151,4 +135,4 @@
 #define RF95_NSS 18
 #endif
 
-#define SERIAL0_RX_GPIO 3 // Always GPIO3 on ESP32
+#define SERIAL0_RX_GPIO 3 // Always GPIO3 on ESP32

src/sleep.cpp

@@ -90,33 +90,6 @@ void setLed(bool ledOn)
 #endif
 }
 
-void setGPSPower(bool on)
-{
-    LOG_INFO("Setting GPS power=%d\n", on);
-
-#ifdef PIN_GPS_EN
-    digitalWrite(PIN_GPS_EN, on ? 1 : 0);
-#endif
-
-#ifdef HAS_PMU
-    if (pmu_found && PMU) {
-        uint8_t model = PMU->getChipModel();
-        if (model == XPOWERS_AXP2101) {
-            if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
-                // t-beam v1.2 GNSS power channel
-                on ? PMU->enablePowerOutput(XPOWERS_ALDO3) : PMU->disablePowerOutput(XPOWERS_ALDO3);
-            } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
-                // t-beam-s3-core GNSS  power channel
-                on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
-            }
-        } else if (model == XPOWERS_AXP192) {
-            // t-beam v1.1 GNSS  power channel
-            on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3);
-        }
-    }
-#endif
-}
-
 // Perform power on init that we do on each wake from deep sleep
 void initDeepSleep()
 {
@@ -182,41 +155,6 @@ static void waitEnterSleep()
     notifySleep.notifyObservers(NULL);
 }
 
-void doGPSpowersave(bool on)
-{
-#if defined(HAS_PMU) || defined(PIN_GPS_EN)
-    if (on) {
-        LOG_INFO("Turning GPS back on\n");
-        gps->forceWake(1);
-        setGPSPower(1);
-    } else {
-        LOG_INFO("Turning off GPS chip\n");
-        notifyGPSSleep.notifyObservers(NULL);
-        setGPSPower(0);
-    }
-#endif
-#ifdef PIN_GPS_WAKE
-    if (on) {
-        LOG_INFO("Waking GPS");
-        gps->forceWake(1);
-    } else {
-        LOG_INFO("GPS entering sleep");
-        notifyGPSSleep.notifyObservers(NULL);
-    }
-#endif
-#if !(defined(HAS_PMU) || defined(PIN_GPS_EN) || defined(PIN_GPS_WAKE))
-    if (!on) {
-        uint8_t msglen;
-        notifyGPSSleep.notifyObservers(NULL);
-        msglen = gps->makeUBXPacket(0x02, 0x41, 0x08, gps->_message_PMREQ);
-        gps->_serial_gps->write(gps->UBXscratch, msglen);
-    } else {
-        gps->forceWake(1);
-        gps->_serial_gps->write(0xFF);
-    }
-#endif
-}
-
 void doDeepSleep(uint32_t msecToWake)
 {
     if (INCLUDE_vTaskSuspend && (msecToWake == portMAX_DELAY)) {
@@ -235,7 +173,7 @@ void doDeepSleep(uint32_t msecToWake)
     nodeDB.saveToDisk();
 
     // Kill GPS power completely (even if previously we just had it in sleep mode)
-    setGPSPower(false);
+    gps->setGPSPower(false, false);
 
     setLed(false);
 

src/sleep.h

@@ -18,8 +18,6 @@ extern esp_sleep_source_t wakeCause;
 extern XPowersLibInterface *PMU;
 #endif
 
-void setGPSPower(bool on);
-void doGPSpowersave(bool on);
 // Perform power on init that we do on each wake from deep sleep
 void initDeepSleep();
 

variants/heltec_v3/variant.h

@@ -11,8 +11,6 @@
 #define VEXT_ENABLE Vext // active low, powers the oled display and the lora antenna boost
 #define BUTTON_PIN 0
 
-#define PIN_GPS_EN 46 // GPS power enable pin
-
 #define BATTERY_PIN 1 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define ADC_CHANNEL ADC1_GPIO1_CHANNEL
 #define ADC_ATTENUATION ADC_ATTEN_DB_2_5 // lower dB for high resistance voltage divider
@@ -35,4 +33,4 @@
 #define SX126X_DIO1 LORA_DIO1
 #define SX126X_BUSY LORA_DIO2
 #define SX126X_RESET LORA_RESET
-#define SX126X_E22
+#define SX126X_E22

variants/heltec_wireless_tracker/platformio.ini

@@ -5,6 +5,7 @@ upload_protocol = esp-builtin
 
 build_flags = 
   ${esp32s3_base.build_flags} -I variants/heltec_wireless_tracker
+  -DGPS_POWER_TOGGLE
 
 lib_deps =
   ${esp32s3_base.lib_deps}

variants/heltec_wireless_tracker/variant.h

@@ -38,6 +38,8 @@
 #define PIN_GPS_RESET 35
 #define PIN_GPS_PPS 36
 #define VGNSS_CTRL 37 // Heltec Tracker needs this pulled low for GPS
+#define PIN_GPS_EN VGNSS_CTRL
+#define GPS_EN_ACTIVE LOW
 #define GPS_RESET_MODE LOW
 #define GPS_UC6580
 

variants/lora_relay_v2/variant.h

@@ -164,8 +164,8 @@ static const uint8_t SCK = PIN_SPI_SCK;
 #define ST7735_SDA (39) // actually spi MOSI
 #define ST7735_SCK (37) // actually spi clk
 
-#define PIN_GPS_WAKE 36   // Just kill GPS power when we want it to sleep?  FIXME
-#define GPS_WAKE_ACTIVE 0 // GPS Power output is active low
+#define PIN_GPS_EN 36   // Just kill GPS power when we want it to sleep?  FIXME
+#define GPS_EN_ACTIVE 0 // GPS Power output is active low
 
 // #define LORA_DISABLE_SENDING // The board can brownout during lora TX if you don't have a battery connected.  Disable sending
 // to allow USB power only based debugging

variants/nano-g2-ultra/variant.h

@@ -23,7 +23,7 @@
 #define VARIANT_MCK (64000000ul)
 
 #define USE_LFXO // Board uses 32khz crystal for LF
-//#define USE_LFRC  // Board uses 32khz RC for LF
+// #define USE_LFRC  // Board uses 32khz RC for LF
 
 /*----------------------------------------------------------------------------
  *        Headers
@@ -54,7 +54,7 @@ extern "C" {
 #define LED_CONN PIN_GREEN
 
 #define LED_STATE_ON 0 // State when LED is lit
-//#define LED_INVERTED 1
+// #define LED_INVERTED 1
 
 /*
  * Buttons
@@ -114,7 +114,7 @@ External serial flash W25Q16JV_IQ
 #define SX126X_CS (32 + 13) // FIXME - we really should define LORA_CS instead
 #define SX126X_DIO1 (32 + 10)
 // Note DIO2 is attached internally to the module to an analog switch for TX/RX switching
-//#define SX1262_DIO3 (0 + 21)
+// #define SX1262_DIO3 (0 + 21)
 // This is used as an *output* from the sx1262 and connected internally to power the tcxo, do not drive from the main CPU?
 #define SX126X_BUSY (32 + 11)
 #define SX126X_RESET (32 + 15)
@@ -130,11 +130,11 @@ External serial flash W25Q16JV_IQ
 
 #define GPS_L76K
 
-#define PIN_GPS_WAKE (0 + 13) // An output to wake GPS, low means allow sleep, high means force wake
-#define PIN_GPS_TX (0 + 9)    // This is for bits going TOWARDS the CPU
-#define PIN_GPS_RX (0 + 10)   // This is for bits going TOWARDS the GPS
+#define PIN_GPS_STANDBY (0 + 13) // An output to wake GPS, low means allow sleep, high means force wake STANDBY
+#define PIN_GPS_TX (0 + 9)       // This is for bits going TOWARDS the CPU
+#define PIN_GPS_RX (0 + 10)      // This is for bits going TOWARDS the GPS
 
-//#define GPS_THREAD_INTERVAL 50
+// #define GPS_THREAD_INTERVAL 50
 
 #define PIN_SERIAL1_RX PIN_GPS_TX
 #define PIN_SERIAL1_TX PIN_GPS_RX
@@ -152,7 +152,7 @@ External serial flash W25Q16JV_IQ
 #define PIN_SPI_MOSI (0 + 11)
 #define PIN_SPI_SCK (0 + 12)
 
-//#define PIN_PWR_EN (0 + 6)
+// #define PIN_PWR_EN (0 + 6)
 
 // To debug via the segger JLINK console rather than the CDC-ACM serial device
 // #define USE_SEGGER

variants/picomputer-s3/platformio.ini

@@ -1,7 +1,7 @@
 [env:picomputer-s3]
 extends = esp32s3_base
 board = bpi_picow_esp32_s3
-board_level = extra
+
 ;OpenOCD flash method
 ;upload_protocol = esp-builtin
 ;Normal method

variants/picomputer-s3/variant.h

@@ -5,9 +5,14 @@
 
 #define PIN_BUZZER 43
 
-#define HAS_GPS 0
 #define HAS_WIRE 0
 
+#define BATTERY_PIN ADC1_CHANNEL_1_GPIO_NUM // 2
+// A battery voltage measurement pin, voltage divider connected here to measure battery voltage
+// ratio of voltage divider = 3.0 (R11=200k, R7=100k)
+#define ADC_MULTIPLIER 3.1 // 3.0 with correction of display undervoltage.
+#define ADC_CHANNEL ADC1_GPIO2_CHANNEL
+
 #define USE_RF95 // RFM95/SX127x
 
 #define RF95_SCK SCK   // 21

variants/rak11310/variant.h

@@ -11,8 +11,6 @@
 #undef ECB
 #define ECB 0
 
-#undef GPS_SERIAL_NUM
-
 #define LED_CONN PIN_LED2
 #define LED_PIN LED_BUILTIN
 

variants/rpipico/variant.h

@@ -11,9 +11,7 @@
 #undef ECB
 #define ECB 0
 
-#define NO_GPS 1
 #define USE_SH1106 1
-#undef GPS_SERIAL_NUM
 
 // default I2C pins:
 // SDA = 4

variants/rpipicow/variant.h

@@ -11,9 +11,7 @@
 #undef ECB
 #define ECB 0
 
-#define NO_GPS 1
 #define USE_SH1106 1
-#undef GPS_SERIAL_NUM
 
 // default I2C pins:
 // SDA = 4

variants/station-g1/variant.h

@@ -46,3 +46,7 @@
 
 // different screen
 #define USE_SH1106
+
+// Station may not have GPS installed, but it has a labeled GPS pinout
+#define GPS_RX_PIN 34
+#define GPS_TX_PIN 12

variants/t-deck/platformio.ini

@@ -8,6 +8,7 @@ debug_tool = esp-builtin
 build_flags = ${esp32_base.build_flags} 
   -DT_DECK 
   -DBOARD_HAS_PSRAM
+  -DGPS_POWER_TOGGLE
   -Ivariants/t-deck
 
 lib_deps = ${esp32s3_base.lib_deps}

variants/t-echo/variant.h

@@ -85,9 +85,9 @@ static const uint8_t A0 = PIN_A0;
 /*
 No longer populated on PCB
 */
-//#define PIN_SERIAL2_RX (0 + 6)
-//#define PIN_SERIAL2_TX (0 + 8)
-// #define PIN_SERIAL2_EN (0 + 17)
+// #define PIN_SERIAL2_RX (0 + 6)
+// #define PIN_SERIAL2_TX (0 + 8)
+//  #define PIN_SERIAL2_EN (0 + 17)
 
 /**
     Wire Interfaces
@@ -171,7 +171,7 @@ External serial flash WP25R1635FZUIL0
 #define GPS_L76K
 #define PIN_GPS_REINIT (32 + 5) // An output to reset L76K GPS. As per datasheet, low for > 100ms will reset the L76K
 
-#define PIN_GPS_WAKE (32 + 2) // An output to wake GPS, low means allow sleep, high means force wake
+#define PIN_GPS_STANDBY (32 + 2) // An output to wake GPS, low means allow sleep, high means force wake
 // Seems to be missing on this new board
 // #define PIN_GPS_PPS (32 + 4)  // Pulse per second input from the GPS
 #define PIN_GPS_TX (32 + 9) // This is for bits going TOWARDS the CPU

variants/tbeam/variant.h

@@ -4,8 +4,8 @@
 #define I2C_SCL 22
 
 #define BUTTON_PIN 38 // The middle button GPIO on the T-Beam
-//#define BUTTON_PIN_ALT 13 // Alternate GPIO for an external button if needed. Does anyone use this? It is not documented
-// anywhere.
+// #define BUTTON_PIN_ALT 13 // Alternate GPIO for an external button if needed. Does anyone use this? It is not documented
+//  anywhere.
 #define EXT_NOTIFY_OUT 13 // Default pin to use for Ext Notify Module.
 
 #define LED_INVERTED 1
@@ -37,4 +37,6 @@
 // and waking from light sleep
 // #define PMU_IRQ 35
 #define HAS_AXP192
-#define GPS_UBLOX
+#define GPS_UBLOX
+#define GPS_RX_PIN 34
+#define GPS_TX_PIN 12

variants/tlora_t3s3_v1/variant.h

@@ -1,8 +1,3 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-
-#define PIN_GPS_EN 42 // GPS power enable pin
-
 #define HAS_SDCARD
 #define SDCARD_USE_SPI1
 

variants/tlora_v1/variant.h

@@ -1,6 +1,3 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-
 #define I2C_SDA 4 // I2C pins for this board
 #define I2C_SCL 15
 
@@ -16,4 +13,4 @@
 #define LORA_DIO0 26 // a No connect on the SX1262 module
 #define LORA_RESET 14
 #define LORA_DIO1 33 // Must be manually wired: https://www.thethingsnetwork.org/forum/t/big-esp32-sx127x-topic-part-3/18436
-#define LORA_DIO2 32 // Not really used
+#define LORA_DIO2 32 // Not really used

variants/tlora_v1_3/variant.h

@@ -1,8 +1,3 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-#define GPS_RX_PIN 36
-#define GPS_TX_PIN 13 // per @eugene
-
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 

variants/tlora_v2/variant.h

@@ -1,8 +1,3 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-#define GPS_RX_PIN 36
-#define GPS_TX_PIN 13 // per @eugene
-
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 

variants/tlora_v2_1_16/variant.h

@@ -1,10 +1,3 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-#define GPS_RX_PIN 15 // per @der_bear on the forum, 36 is incorrect for this board type and 15 is a better pick
-#define GPS_TX_PIN 13
-
-#define PIN_GPS_EN 19 // GPS power enable pin
-
 #define BATTERY_PIN 35
 #define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_SAMPLES 30

variants/tlora_v2_1_18/variant.h

@@ -1,6 +1,3 @@
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
-
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 // ratio of voltage divider = 2.0 (R42=100k, R43=100k)
 #define ADC_MULTIPLIER 2.11 // 2.0 + 10% for correction of display undervoltage.

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 2
-build = 6
+build = 8