[create-pull-request] automated change (#2810)

Co-authored-by: thebentern <thebentern@users.noreply.github.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

boards/t-deck.json

@@ -1,7 +1,8 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "esp32s3_out.ld"
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
     },
     "core": "esp32",
     "extra_flags": [
@@ -13,7 +14,7 @@
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
-    "flash_mode": "dio",
+    "flash_mode": "qio",
     "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "t-deck"

boards/t-watch-s3.json

@@ -1,7 +1,8 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "esp32s3_out.ld"
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
     },
     "core": "esp32",
     "extra_flags": [
@@ -14,7 +15,7 @@
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
-    "flash_mode": "dio",
+    "flash_mode": "qio",
     "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "t-watch-s3"
@@ -31,8 +32,9 @@
     "maximum_size": 8388608,
     "require_upload_port": true,
     "use_1200bps_touch": true,
-    "wait_for_upload_port": true
+    "wait_for_upload_port": true,
+    "speed": 921600
   },
-  "url": "http://www.lilygo.cn/",
+  "url": "https://www.lilygo.cc/en-pl/products/t-watch-s3",
   "vendor": "LilyGo"
 }

src/ButtonThread.h

@@ -165,13 +165,15 @@ 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 (gps != nullptr) {
+            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");
+            }
+            config.position.gps_enabled = !(config.position.gps_enabled);
+            gps->doGPSpowersave(config.position.gps_enabled);
         }
-        config.position.gps_enabled = !(config.position.gps_enabled);
-        doGPSpowersave(config.position.gps_enabled);
 #endif
     }
 

src/PowerFSM.cpp

@@ -158,6 +158,9 @@ static void darkEnter()
 {
     setBluetoothEnable(true);
     screen->setOn(false);
+#ifdef KB_POWERON
+    digitalWrite(KB_POWERON, LOW);
+#endif
 }
 
 static void serialEnter()
@@ -185,6 +188,9 @@ static void powerEnter()
     } else {
         screen->setOn(true);
         setBluetoothEnable(true);
+#ifdef KB_POWERON
+        digitalWrite(KB_POWERON, HIGH);
+#endif
         // within enter() the function getState() returns the state we came from
         if (strcmp(powerFSM.getState()->name, "BOOT") != 0 && strcmp(powerFSM.getState()->name, "POWER") != 0 &&
             strcmp(powerFSM.getState()->name, "DARK") != 0) {
@@ -215,6 +221,9 @@ static void onEnter()
     LOG_DEBUG("Enter state: ON\n");
     screen->setOn(true);
     setBluetoothEnable(true);
+#ifdef KB_POWERON
+    digitalWrite(KB_POWERON, HIGH);
+#endif
 }
 
 static void onIdle()

src/gps/GPS.cpp

@@ -13,12 +13,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 +27,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)
 {
@@ -251,56 +248,30 @@ int GPS::getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t
     return 0;
 }
 
-bool GPS::setupGPS()
+bool GPS::setup()
 {
+    int msglen = 0;
+
     if (_serial_gps && !didSerialInit) {
-        didSerialInit = true;
-
-#ifdef ARCH_ESP32
-        // In esp32 framework, setRxBufferSize needs to be initialized before Serial
-        _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);
-            _serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, config.position.rx_gpio, config.position.tx_gpio);
+#if !defined(GPS_UC6580)
+        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;
+            }
+        } else {
+            gnssModel = GNSS_MODEL_UNKNOWN;
         }
 #else
-        _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)
-        _serial_gps->updateBaudRate(115200);
         gnssModel = GNSS_MODEL_UC6850;
-#else
-        for (int serialSpeed : {9600, 4800, 38400, 57600, 115200}) {
-            LOG_DEBUG("Probing for GPS at %d \n", serialSpeed);
-            gnssModel = probe(serialSpeed);
-            if (gnssModel != GNSS_MODEL_UNKNOWN)
-                break;
-        }
-        if (gnssModel == GNSS_MODEL_UNKNOWN) {
-            LOG_DEBUG("No GPS found, retrying at 9600 baud.\n");
-            gnssModel = probe(9600);
-        }
 #endif
 
         if (gnssModel == GNSS_MODEL_MTK) {
@@ -308,8 +279,6 @@ bool GPS::setupGPS()
              * t-beam-s3-core uses the same L76K GNSS module as t-echo.
              * Unlike t-echo, L76K uses 9600 baud rate for communication by default.
              * */
-            // _serial_gps->begin(9600);    //The baud rate of 9600 has been initialized at the beginning of setupGPS, this line
-            // is the redundant part delay(250);
 
             // Initialize the L76K Chip, use GPS + GLONASS + BEIDOU
             _serial_gps->write("$PCAS04,7*1E\r\n");
@@ -326,23 +295,6 @@ bool GPS::setupGPS()
             _serial_gps->write("$CFGSYS,h15\r\n");
             delay(250);
         } else if (gnssModel == GNSS_MODEL_UBLOX) {
-            /*
-            uint8_t buffer[768] = {0};
-            uint8_t _message_GNSS[8] = {0xb5, 0x62, // Sync message for UBX protocol
-                                        0x06, 0x3e, // Message class and ID (UBX-CFG-GNSS)
-                                        0x00, 0x00, // Length of payload (28 bytes)
-                                        0x00, 0x00};
-            UBXChecksum(_message_GNSS, sizeof(_message_GNSS));
-                        // Send the message to the module
-            _serial_gps->write(_message_GNSS, sizeof(_message_GNSS));
-            int ackLen = getACK(buffer, sizeof(buffer), 0x06, 0x3e, 2000);
-            LOG_DEBUG("monver reply size = %d\n", ackLen);
-            LOG_DEBUG("Ack: ");
-            for (int i = 0; i < ackLen; i++) {
-                LOG_DEBUG("%02X", buffer[i]);
-            }
-            LOG_DEBUG("\n"); */
-
             // Configure GNSS system to GPS+SBAS+GLONASS (Module may restart after this command)
             // We need set it because by default it is GPS only, and we want to use GLONASS too
             // Also we need SBAS for better accuracy and extra features
@@ -352,51 +304,15 @@ bool GPS::setupGPS()
                 0) { // The original ublox 6 is GPS only and doesn't support the UBX-CFG-GNSS message
                 if (strncmp(info.hwVersion, "00070000", 8) == 0) { // Max7 seems to only support GPS *or* GLONASS
                     LOG_DEBUG("Setting GPS+SBAS\n");
-                    uint8_t _message_GNSS[28] = {
-                        0xb5, 0x62, // Sync message for UBX protocol
-                        0x06, 0x3e, // Message class and ID (UBX-CFG-GNSS)
-                        0x14, 0x00, // Length of payload (28 bytes)
-                        0x00,       // msgVer (0 for this version)
-                        0x00,       // numTrkChHw (max number of hardware channels, read only, so it's always 0)
-                        0xff,       // numTrkChUse (max number of channels to use, 0xff = max available)
-                        0x02,       // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
-                        // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
-                        0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x00, 0x01, // GPS
-                        0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x01, // SBAS
-                        0x00, 0x00                                      // Checksum (to be calculated below)
-                    };
-                    // Calculate the checksum and update the message.
-                    UBXChecksum(_message_GNSS, sizeof(_message_GNSS));
-                    // Send the message to the module
-                    _serial_gps->write(_message_GNSS, sizeof(_message_GNSS));
+                    msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_7), _message_GNSS_7);
+                    _serial_gps->write(UBXscratch, msglen);
                 } else {
-                    uint8_t _message_GNSS[36] = {
-                        0xb5, 0x62, // Sync message for UBX protocol
-                        0x06, 0x3e, // Message class and ID (UBX-CFG-GNSS)
-                        0x1c, 0x00, // Length of payload (28 bytes)
-                        0x00,       // msgVer (0 for this version)
-                        0x00,       // numTrkChHw (max number of hardware channels, read only, so it's always 0)
-                        0xff,       // numTrkChUse (max number of channels to use, 0xff = max available)
-                        0x03,       // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
-                        // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
-                        0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, // GPS
-                        0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // SBAS
-                        0x06, 0x08, 0x0e, 0x00, 0x01, 0x00, 0x01, 0x01, // GLONASS
-                        0x00, 0x00                                      // Checksum (to be calculated below)
-                    };
-                    // Calculate the checksum and update the message.
-                    UBXChecksum(_message_GNSS, sizeof(_message_GNSS));
-                    // Send the message to the module
-                    _serial_gps->write(_message_GNSS, sizeof(_message_GNSS));
+                    msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS), _message_GNSS);
+                    _serial_gps->write(UBXscratch, msglen);
                 }
 
                 if (getACK(0x06, 0x3e, 800) == GNSS_RESPONSE_NAK) {
                     // It's not critical if the module doesn't acknowledge this configuration.
-                    // The module should operate adequately with its factory or previously saved settings.
-                    // It appears that there is a firmware bug in some GPS modules: When an attempt is made
-                    // to overwrite a saved state with identical values, no ACK/NAK is received, contrary to
-                    // what is specified in the Ublox documentation.
-                    // There is also a possibility that the module may be GPS-only.
                     LOG_INFO("Unable to reconfigure GNSS - defaults maintained. Is this module GPS-only?\n");
                 } else {
                     if (strncmp(info.hwVersion, "00070000", 8) == 0) {
@@ -410,254 +326,71 @@ bool GPS::setupGPS()
                 }
             }
 
-            // Enable interference resistance, because we are using LoRa, WiFi and Bluetooth on same board,
-            // and we need to reduce interference from them
-            uint8_t _message_JAM[16] = {
-                0xB5, 0x62, // UBX protocol sync characters
-                0x06, 0x39, // Message class and ID (UBX-CFG-ITFM)
-                0x08, 0x00, // Length of payload (8 bytes)
-                // bbThreshold (Broadband jamming detection threshold) is set to 0x3F (63 in decimal)
-                // cwThreshold (CW jamming detection threshold) is set to 0x10 (16 in decimal)
-                // algorithmBits (Reserved algorithm settings) is set to 0x16B156 as recommended
-                // enable (Enable interference detection) is set to 1 (enabled)
-                0x3F, 0x10, 0xB1, 0x56, // config: Interference config word
-                // generalBits (General settings) is set to 0x31E as recommended
-                // antSetting (Antenna setting, 0=unknown, 1=passive, 2=active) is set to 0 (unknown)
-                // ToDo: Set to 1 (passive) or 2 (active) if known, for example from UBX-MON-HW, or from board info
-                // enable2 (Set to 1 to scan auxiliary bands, u-blox 8 / u-blox M8 only, otherwise ignored) is set to 1
-                // (enabled)
-                0x1E, 0x03, 0x00, 0x01, // config2: Extra settings for jamming/interference monitor
-                0x00, 0x00              // Checksum (calculated below)
-            };
-
-            // Calculate the checksum and update the message.
-            UBXChecksum(_message_JAM, sizeof(_message_JAM));
-
-            // Send the message to the module
-            _serial_gps->write(_message_JAM, sizeof(_message_JAM));
-
+            msglen = makeUBXPacket(0x06, 0x39, sizeof(_message_JAM), _message_JAM);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x39, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to enable interference resistance.\n");
             }
 
-            // Configure navigation engine expert settings:
-            uint8_t _message_NAVX5[48] = {
-                0xb5, 0x62, // UBX protocol sync characters
-                0x06, 0x23, // Message class and ID (UBX-CFG-NAVX5)
-                0x28, 0x00, // Length of payload (40 bytes)
-                0x00, 0x00, // msgVer (0 for this version)
-                // minMax flag = 1: apply min/max SVs settings
-                // minCno flag = 1: apply minimum C/N0 setting
-                // initial3dfix flag = 0: apply initial 3D fix settings
-                // aop flag = 1: apply aopCfg (useAOP flag) settings (AssistNow Autonomous)
-                0x1B, 0x00, // mask1 (First parameters bitmask)
-                // adr flag = 0: apply ADR sensor fusion on/off setting (useAdr flag)
-                // If firmware is not ADR/UDR, enabling this flag will fail configuration
-                // ToDo: check this with UBX-MON-VER
-                0x00, 0x00, 0x00, 0x00, // mask2 (Second parameters bitmask)
-                0x00, 0x00,             // Reserved
-                0x03,                   // minSVs (Minimum number of satellites for navigation) = 3
-                0x10,                   // maxSVs (Maximum number of satellites for navigation) = 16
-                0x06,                   // minCNO (Minimum satellite signal level for navigation) = 6 dBHz
-                0x00,                   // Reserved
-                0x00,                   // iniFix3D (Initial fix must be 3D) = 0 (disabled)
-                0x00, 0x00,             // Reserved
-                0x00,                   // ackAiding (Issue acknowledgements for assistance message input) = 0 (disabled)
-                0x00, 0x00,             // Reserved
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Reserved
-                0x00,                               // Reserved
-                0x01,                               // aopCfg (AssistNow Autonomous configuration) = 1 (enabled)
-                0x00, 0x00,                         // Reserved
-                0x00, 0x00,                         // Reserved
-                0x00, 0x00, 0x00, 0x00,             // Reserved
-                0x00, 0x00, 0x00,                   // Reserved
-                0x01,                               // useAdr (Enable/disable ADR sensor fusion) = 1 (enabled)
-                0x00, 0x00                          // Checksum (calculated below)
-            };
-
-            // Calculate the checksum and update the message.
-            UBXChecksum(_message_NAVX5, sizeof(_message_NAVX5));
-
-            // Send the message to the module
-            _serial_gps->write(_message_NAVX5, sizeof(_message_NAVX5));
-
+            msglen = makeUBXPacket(0x06, 0x23, sizeof(_message_NAVX5), _message_NAVX5);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x23, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to configure extra settings.\n");
             }
 
             // ublox-M10S can be compatible with UBLOX traditional protocol, so the following sentence settings are also valid
 
-            // Set GPS update rate to 1Hz
-            // Lowering the update rate helps to save power.
-            // Additionally, for some new modules like the M9/M10, an update rate lower than 5Hz
-            // is recommended to avoid a known issue with satellites disappearing.
-            uint8_t _message_1Hz[] = {
-                0xB5, 0x62, // UBX protocol sync characters
-                0x06, 0x08, // Message class and ID (UBX-CFG-RATE)
-                0x06, 0x00, // Length of payload (6 bytes)
-                0xE8, 0x03, // Measurement Rate (1000ms for 1Hz)
-                0x01, 0x00, // Navigation rate, always 1 in GPS mode
-                0x01, 0x00, // Time reference
-                0x00, 0x00  // Placeholder for checksum, will be calculated next
-            };
-
-            // Calculate the checksum and update the message.
-            UBXChecksum(_message_1Hz, sizeof(_message_1Hz));
-
-            // Send the message to the module
-            _serial_gps->write(_message_1Hz, sizeof(_message_1Hz));
-
+            msglen = makeUBXPacket(0x06, 0x08, sizeof(_message_1HZ), _message_1HZ);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x08, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to set GPS update rate.\n");
             }
 
-            // Disable GGL. GGL - Geographic position (latitude and longitude), which provides the current geographical
-            // coordinates.
-            uint8_t _message_GGL[] = {
-                0xB5, 0x62,             // UBX sync characters
-                0x06, 0x01,             // Message class and ID (UBX-CFG-MSG)
-                0x08, 0x00,             // Length of payload (8 bytes)
-                0xF0, 0x01,             // NMEA ID for GLL
-                0x01,                   // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
-                0x00,                   // Disable
-                0x01, 0x01, 0x01, 0x01, // Reserved
-                0x00, 0x00              // CK_A and CK_B (Checksum)
-            };
-
-            // Calculate the checksum and update the message.
-            UBXChecksum(_message_GGL, sizeof(_message_GGL));
-
-            // Send the message to the module
-            _serial_gps->write(_message_GGL, sizeof(_message_GGL));
-
+            msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GGL), _message_GGL);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x01, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to disable NMEA GGL.\n");
             }
 
-            // Enable GSA. GSA - GPS DOP and active satellites, used for detailing the satellites used in the positioning and
-            // the DOP (Dilution of Precision)
-            uint8_t _message_GSA[] = {
-                0xB5, 0x62,             // UBX sync characters
-                0x06, 0x01,             // Message class and ID (UBX-CFG-MSG)
-                0x08, 0x00,             // Length of payload (8 bytes)
-                0xF0, 0x02,             // NMEA ID for GSA
-                0x01,                   // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
-                0x01,                   // Enable
-                0x01, 0x01, 0x01, 0x01, // Reserved
-                0x00, 0x00              // CK_A and CK_B (Checksum)
-            };
-            UBXChecksum(_message_GSA, sizeof(_message_GSA));
-            _serial_gps->write(_message_GSA, sizeof(_message_GSA));
+            msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GSA), _message_GSA);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x01, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to Enable NMEA GSA.\n");
             }
 
-            // Disable GSV. GSV - Satellites in view, details the number and location of satellites in view.
-            uint8_t _message_GSV[] = {
-                0xB5, 0x62,             // UBX sync characters
-                0x06, 0x01,             // Message class and ID (UBX-CFG-MSG)
-                0x08, 0x00,             // Length of payload (8 bytes)
-                0xF0, 0x03,             // NMEA ID for GSV
-                0x01,                   // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
-                0x00,                   // Disable
-                0x01, 0x01, 0x01, 0x01, // Reserved
-                0x00, 0x00              // CK_A and CK_B (Checksum)
-            };
-            UBXChecksum(_message_GSV, sizeof(_message_GSV));
-            _serial_gps->write(_message_GSV, sizeof(_message_GSV));
+            msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GSV), _message_GSV);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x01, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to disable NMEA GSV.\n");
             }
 
-            // Disable VTG. VTG - Track made good and ground speed, which provides course and speed information relative to
-            // the ground.
-            uint8_t _message_VTG[] = {
-                0xB5, 0x62,             // UBX sync characters
-                0x06, 0x01,             // Message class and ID (UBX-CFG-MSG)
-                0x08, 0x00,             // Length of payload (8 bytes)
-                0xF0, 0x05,             // NMEA ID for VTG
-                0x01,                   // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
-                0x00,                   // Disable
-                0x01, 0x01, 0x01, 0x01, // Reserved
-                0x00, 0x00              // CK_A and CK_B (Checksum)
-            };
-            UBXChecksum(_message_VTG, sizeof(_message_VTG));
-            _serial_gps->write(_message_VTG, sizeof(_message_VTG));
+            msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_VTG), _message_VTG);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x01, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to disable NMEA VTG.\n");
             }
 
-            // Enable RMC. RMC - Recommended Minimum data, the essential gps pvt (position, velocity, time) data.
-            uint8_t _message_RMC[] = {
-                0xB5, 0x62,             // UBX sync characters
-                0x06, 0x01,             // Message class and ID (UBX-CFG-MSG)
-                0x08, 0x00,             // Length of payload (8 bytes)
-                0xF0, 0x04,             // NMEA ID for RMC
-                0x01,                   // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
-                0x01,                   // Enable
-                0x01, 0x01, 0x01, 0x01, // Reserved
-                0x00, 0x00              // CK_A and CK_B (Checksum)
-            };
-            UBXChecksum(_message_RMC, sizeof(_message_RMC));
-            _serial_gps->write(_message_RMC, sizeof(_message_RMC));
+            msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_RMC), _message_RMC);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x01, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to enable NMEA RMC.\n");
             }
 
-            // Enable GGA. GGA - Global Positioning System Fix Data, which provides 3D location and accuracy data.
-            uint8_t _message_GGA[] = {
-                0xB5, 0x62,             // UBX sync characters
-                0x06, 0x01,             // Message class and ID (UBX-CFG-MSG)
-                0x08, 0x00,             // Length of payload (8 bytes)
-                0xF0, 0x00,             // NMEA ID for GGA
-                0x01,                   // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
-                0x01,                   // Enable
-                0x01, 0x01, 0x01, 0x01, // Reserved
-                0x00, 0x00              // CK_A and CK_B (Checksum)
-            };
-            UBXChecksum(_message_GGA, sizeof(_message_GGA));
-            _serial_gps->write(_message_GGA, sizeof(_message_GGA));
+            msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GGA), _message_GGA);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x01, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to enable NMEA GGA.\n");
             }
 
-            // The Power Management configuration allows the GPS module to operate in different power modes for optimized power
-            // consumption.
-            // The modes supported are:
-            // 0x00 = Full power: The module operates at full power with no power saving.
-            // 0x01 = Balanced: The module dynamically adjusts the tracking behavior to balance power consumption.
-            // 0x02 = Interval: The module operates in a periodic mode, cycling between tracking and power saving states.
-            // 0x03 = Aggressive with 1 Hz: The module operates in a power saving mode with a 1 Hz update rate.
-            // 0x04 = Aggressive with 2 Hz: The module operates in a power saving mode with a 2 Hz update rate.
-            // 0x05 = Aggressive with 4 Hz: The module operates in a power saving mode with a 4 Hz update rate.
-            // The 'period' field specifies the position update and search period. It is only valid when the powerSetupValue is
-            // set to Interval; otherwise, it must be set to '0'. The 'onTime' field specifies the duration of the ON phase and
-            // must be smaller than the period. It is only valid when the powerSetupValue is set to Interval; otherwise, it must
-            // be set to '0'.
             if (uBloxProtocolVersion >= 18) {
-                byte UBX_CFG_PMS[16] = {
-                    0xB5, 0x62, // UBX sync characters
-                    0x06, 0x86, // Message class and ID (UBX-CFG-PMS)
-                    0x08, 0x00, // Length of payload (6 bytes)
-                    0x00,       // Version (0)
-                    0x03,       // Power setup value
-                    0x00, 0x00, // period: not applicable, set to 0
-                    0x00, 0x00, // onTime: not applicable, set to 0
-                    0x97, 0x6F, // reserved, generated by u-center
-                    0x00, 0x00  // Placeholder for checksum, will be calculated next
-                };
-
-                // Calculate the checksum and update the message
-                UBXChecksum(UBX_CFG_PMS, sizeof(UBX_CFG_PMS));
-
-                // Send the message to the module
-                _serial_gps->write(UBX_CFG_PMS, sizeof(UBX_CFG_PMS));
+                msglen = makeUBXPacket(0x06, 0x86, sizeof(_message_PMS), _message_PMS);
+                _serial_gps->write(UBXscratch, msglen);
                 if (getACK(0x06, 0x86, 300) != GNSS_RESPONSE_OK) {
                     LOG_WARN("Unable to enable powersaving for GPS.\n");
                 }
             } else {
                 if (strncmp(info.hwVersion, "00040007", 8) == 0) { // This PSM mode has only been tested on this hardware
-                    int msglen = makeUBXPacket(0x06, 0x11, 0x2, _message_CFG_RXM_PSM);
+                    msglen = makeUBXPacket(0x06, 0x11, 0x2, _message_CFG_RXM_PSM);
                     _serial_gps->write(UBXscratch, msglen);
                     if (getACK(0x06, 0x11, 300) != GNSS_RESPONSE_OK) {
                         LOG_WARN("Unable to enable powersaving mode for GPS.\n");
@@ -668,74 +401,33 @@ bool GPS::setupGPS()
                         LOG_WARN("Unable to enable powersaving details for GPS.\n");
                     }
                 } else {
-                    int msglen = makeUBXPacket(0x06, 0x11, 0x2, _message_CFG_RXM_ECO);
+                    msglen = makeUBXPacket(0x06, 0x11, 0x2, _message_CFG_RXM_ECO);
                     _serial_gps->write(UBXscratch, msglen);
                     if (getACK(0x06, 0x11, 300) != GNSS_RESPONSE_OK) {
                         LOG_WARN("Unable to enable powersaving ECO mode for GPS.\n");
                     }
                 }
             }
-            // We need save configuration to flash to make our config changes persistent
-            uint8_t _message_SAVE[21] = {
-                0xB5, 0x62,             // UBX protocol header
-                0x06, 0x09,             // UBX class ID (Configuration Input Messages), message ID (UBX-CFG-CFG)
-                0x0D, 0x00,             // Length of payload (13 bytes)
-                0x00, 0x00, 0x00, 0x00, // clearMask: no sections cleared
-                0xFF, 0xFF, 0x00, 0x00, // saveMask: save all sections
-                0x00, 0x00, 0x00, 0x00, // loadMask: no sections loaded
-                0x0F,                   // deviceMask: BBR, Flash, EEPROM, and SPI Flash
-                0x00, 0x00              // Checksum (calculated below)
-            };
-
-            // Calculate the checksum and update the message.
-            UBXChecksum(_message_SAVE, sizeof(_message_SAVE));
-
-            // Send the message to the module
-            _serial_gps->write(_message_SAVE, sizeof(_message_SAVE));
 
+            msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
+            _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x09, 300) != GNSS_RESPONSE_OK) {
                 LOG_WARN("Unable to save GNSS module configuration.\n");
             } else {
                 LOG_INFO("GNSS module configuration saved!\n");
             }
         }
+        didSerialInit = true;
     }
 
-    return true;
-}
-
-bool GPS::setup()
-{
-    // Master power for the GPS
-
-#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);
-    }
-#endif
-
-#ifdef PIN_GPS_RESET
-    digitalWrite(PIN_GPS_RESET, GPS_RESET_MODE); // assert for 10ms
-    pinMode(PIN_GPS_RESET, OUTPUT);
-    delay(10);
-    digitalWrite(PIN_GPS_RESET, !GPS_RESET_MODE);
-#endif
-    setAwake(true); // Wake GPS power before doing any init
-    bool ok = setupGPS();
-
-    if (ok) {
-        notifySleepObserver.observe(&notifySleep);
-        notifyDeepSleepObserver.observe(&notifyDeepSleep);
-        notifyGPSSleepObserver.observe(&notifyGPSSleep);
-    }
+    notifySleepObserver.observe(&notifySleep);
+    notifyDeepSleepObserver.observe(&notifyDeepSleep);
+    notifyGPSSleepObserver.observe(&notifyGPSSleep);
 
     if (config.position.gps_enabled == false && config.position.fixed_position == false) {
         setAwake(false);
     }
-    return ok;
+    return true;
 }
 
 GPS::~GPS()
@@ -746,16 +438,6 @@ GPS::~GPS()
     notifyGPSSleepObserver.observe(&notifyGPSSleep);
 }
 
-bool GPS::hasLock()
-{
-    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
@@ -865,6 +547,29 @@ void GPS::publishUpdate()
 
 int32_t GPS::runOnce()
 {
+    if (!GPSInitFinished) {
+        if (!setup())
+            return 2000; // Setup failed, re-run in two seconds
+
+        // We have now loaded our saved preferences from flash
+
+        // ONCE we will factory reset the GPS for bug #327
+        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;
+                nodeDB.saveToDisk(SEGMENT_DEVICESTATE);
+            }
+        }
+        GPSInitFinished = true;
+        if (config.position.gps_enabled == false) {
+            doGPSpowersave(false);
+            return 0;
+        }
+    }
+    if (config.position.gps_enabled == false)
+        return 0;
+
     // Repeaters have no need for GPS
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER)
         disable();
@@ -1128,34 +833,363 @@ GnssModel_t GPS::probe(int serialSpeed)
     return GNSS_MODEL_UBLOX;
 }
 
-#if HAS_GPS
-#include "NMEAGPS.h"
-#endif
-
-GPS *createGps()
+// GPS::GPS(uint32_t _rx_gpio, uint32_t _tx_gpio) : concurrency::OSThread("GPS")
+GPS *GPS::createGps()
 {
-
-#if !HAS_GPS
-    return nullptr;
-#else
-    if (config.position.gps_enabled) {
-#ifdef GPS_ALTITUDE_HAE
-        LOG_DEBUG("Using HAE altitude model\n");
-#else
-        LOG_DEBUG("Using MSL altitude model\n");
+    int8_t _rx_gpio = config.position.rx_gpio;
+    int8_t _tx_gpio = config.position.tx_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 (GPS::_serial_gps) {
-            // Some boards might have only the TX line from the GPS connected, in that case, we can't configure it at all.
-            // Just assume NMEA at 9600 baud.
-            GPS *new_gps = new NMEAGPS();
-            new_gps->setup();
-            return new_gps;
+#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 (!_rx_gpio) // 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;
+
+#ifdef PIN_GPS_PPS
+    // pulse per second
+    pinMode(PIN_GPS_PPS, INPUT);
+#endif
+
+// Currently disabled per issue #525 (TinyGPS++ crash bug)
+// when fixed upstream, can be un-disabled to enable 3D FixType and PDOP
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    // see NMEAGPS.h
+    gsafixtype.begin(reader, NMEA_MSG_GXGSA, 2);
+    gsapdop.begin(reader, NMEA_MSG_GXGSA, 15);
+    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);
+    }
+#endif
+
+#ifdef PIN_GPS_RESET
+    digitalWrite(PIN_GPS_RESET, GPS_RESET_MODE); // assert for 10ms
+    pinMode(PIN_GPS_RESET, OUTPUT);
+    delay(10);
+    digitalWrite(PIN_GPS_RESET, !GPS_RESET_MODE);
+#endif
+    new_gps->setAwake(true); // Wake GPS power before doing any init
+
+    if (_serial_gps) {
+#ifdef ARCH_ESP32
+        // In esp32 framework, setRxBufferSize needs to be initialized before Serial
+        _serial_gps->setRxBufferSize(SERIAL_BUFFER_SIZE); // the default is 256
+#endif
+
+//  ESP32 has a special set of parameters vs other arduino ports
+#if defined(ARCH_ESP32)
+        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
+        _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)
+        _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;
+#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::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);
+        setAwake(1);
     } else {
-        GPS *new_gps = new NMEAGPS();
-        new_gps->setup();
-        return new_gps;
+        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);
+        setAwake(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) {
+        notifyGPSSleep.notifyObservers(NULL);
+        if (gnssModel == GNSS_MODEL_UBLOX) {
+            uint8_t msglen;
+            msglen = gps->makeUBXPacket(0x02, 0x41, 0x08, gps->_message_PMREQ);
+            gps->_serial_gps->write(gps->UBXscratch, msglen);
+        }
+        setAwake(1);
+    } else {
+        gps->forceWake(1);
+        if (gnssModel == GNSS_MODEL_UBLOX)
+            gps->_serial_gps->write(0xFF);
     }
-    return nullptr;
 #endif
 }

src/gps/GPS.h

@@ -2,6 +2,7 @@
 
 #include "GPSStatus.h"
 #include "Observer.h"
+#include "TinyGPS++.h"
 #include "concurrency/OSThread.h"
 
 struct uBloxGnssModelInfo {
@@ -35,8 +36,26 @@ 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;
+    const int serialSpeeds[6] = {9600, 4800, 38400, 57600, 115200, 9600};
+
+    uint32_t rx_gpio = 0;
+    uint32_t tx_gpio = 0;
+
+    int speedSelect = 0;
+    int probeTries = 2;
 
     /**
      * hasValidLocation - indicates that the position variables contain a complete
@@ -52,6 +71,9 @@ class GPS : private concurrency::OSThread
 
     bool hasGPS = false; // Do we have a GPS we are talking to
 
+    bool GPSInitFinished = false; // Init thread finished?
+    bool GPSInitStarted = false;  // Init thread finished?
+
     uint8_t numSatellites = 0;
 
     CallbackObserver<GPS, void *> notifySleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareSleep);
@@ -62,10 +84,24 @@ class GPS : private concurrency::OSThread
     /** If !NULL we will use this serial port to construct our GPS */
     static HardwareSerial *_serial_gps;
 
-    static const uint8_t _message_PMREQ[8];
-    static const uint8_t _message_CFG_RXM_PSM[2];
-    static const uint8_t _message_CFG_RXM_ECO[2];
-    static const uint8_t _message_CFG_PM2[44];
+    static const uint8_t _message_PMREQ[];
+    static const uint8_t _message_CFG_RXM_PSM[];
+    static const uint8_t _message_CFG_RXM_ECO[];
+    static const uint8_t _message_CFG_PM2[];
+    static const uint8_t _message_GNSS_7[];
+    static const uint8_t _message_GNSS[];
+    static const uint8_t _message_JAM[];
+    static const uint8_t _message_NAVX5[];
+    static const uint8_t _message_1HZ[];
+    static const uint8_t _message_GGL[];
+    static const uint8_t _message_GSA[];
+    static const uint8_t _message_GSV[];
+    static const uint8_t _message_VTG[];
+    static const uint8_t _message_RMC[];
+    static const uint8_t _message_GGA[];
+    static const uint8_t _message_PMS[];
+    static const uint8_t _message_SAVE[];
+
     meshtastic_Position p = meshtastic_Position_init_default;
 
     GPS() : concurrency::OSThread("GPS") {}
@@ -99,9 +135,6 @@ class GPS : private concurrency::OSThread
      * */
     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();
 
@@ -111,10 +144,24 @@ class GPS : private concurrency::OSThread
     // scratch space for creating ublox packets
     uint8_t UBXscratch[250] = {0};
 
-  protected:
-    /// Do gps chipset specific init, return true for success
-    virtual bool setupGPS();
+    int getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID, uint32_t waitMillis);
+    GPS_RESPONSE getACK(uint8_t c, uint8_t i, uint32_t waitMillis);
+    GPS_RESPONSE getACK(const char *message, uint32_t waitMillis);
 
+    /**
+     * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
+     *
+     * calls sleep/wake
+     */
+    void setAwake(bool on);
+    void doGPSpowersave(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();
 
@@ -125,7 +172,6 @@ class GPS : private concurrency::OSThread
      *
      * 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() {}
@@ -136,7 +182,6 @@ class GPS : private concurrency::OSThread
      *
      * @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.
@@ -144,13 +189,34 @@ 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
@@ -163,13 +229,6 @@ class GPS : private concurrency::OSThread
     // Calculate checksum
     void UBXChecksum(uint8_t *message, size_t length);
 
-    /**
-     * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
-     *
-     * calls sleep/wake
-     */
-    void setAwake(bool on);
-
     /** Get how long we should stay looking for each aquisition
      */
     uint32_t getWakeTime() const;
@@ -189,9 +248,6 @@ class GPS : private concurrency::OSThread
     String getNMEA();
     GnssModel_t probe(int serialSpeed);
 
-    int getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID, uint32_t waitMillis);
-    GPS_RESPONSE getACK(uint8_t c, uint8_t i, uint32_t waitMillis);
-    GPS_RESPONSE getACK(const char *message, uint32_t waitMillis);
     // delay counter to allow more sats before fixed position stops GPS thread
     uint8_t fixeddelayCtr = 0;
 
@@ -199,8 +255,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,272 +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;
-}
-
-bool NMEAGPS::setupGPS()
-{
-    GPS::setupGPS();
-
-#ifdef PIN_GPS_PPS
-    // pulse per second
-    // FIXME - move into shared GPS code
-    pinMode(PIN_GPS_PPS, INPUT);
-#endif
-
-// Currently disabled per issue #525 (TinyGPS++ crash bug)
-// when fixed upstream, can be un-disabled to enable 3D FixType and PDOP
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    // see NMEAGPS.h
-    gsafixtype.begin(reader, NMEA_MSG_GXGSA, 2);
-    gsapdop.begin(reader, NMEA_MSG_GXGSA, 15);
-    LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
-#else
-    LOG_DEBUG("GxGSA NOT available\n");
-#endif
-
-    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,57 +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 setupGPS() override;
-
-    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/ubx.h

@@ -28,4 +28,165 @@ const uint8_t GPS::_message_CFG_PM2[] PROGMEM = {
     0x03, 0x00, 0x87, 0x02, // reserved
     0x00, 0x00, 0xFF, 0x00, // reserved
     0x01, 0x00, 0xD6, 0x4D  // reserved
+};
+
+const uint8_t GPS::_message_GNSS_7[] = {
+    0x00, // msgVer (0 for this version)
+    0x00, // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+    0xff, // numTrkChUse (max number of channels to use, 0xff = max available)
+    0x02, // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
+    // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+    0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x00, 0x01, // GPS
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x01  // SBAS
+};
+
+// It's not critical if the module doesn't acknowledge this configuration.
+// The module should operate adequately with its factory or previously saved settings.
+// It appears that there is a firmware bug in some GPS modules: When an attempt is made
+// to overwrite a saved state with identical values, no ACK/NAK is received, contrary to
+// what is specified in the Ublox documentation.
+// There is also a possibility that the module may be GPS-only.
+const uint8_t GPS::_message_GNSS[] = {
+    0x00, // msgVer (0 for this version)
+    0x00, // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+    0xff, // numTrkChUse (max number of channels to use, 0xff = max available)
+    0x03, // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
+    // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+    0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, // GPS
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // SBAS
+    0x06, 0x08, 0x0e, 0x00, 0x01, 0x00, 0x01, 0x01  // GLONASS
+};
+
+// Enable interference resistance, because we are using LoRa, WiFi and Bluetooth on same board,
+// and we need to reduce interference from them
+const uint8_t GPS::_message_JAM[] = {
+    // bbThreshold (Broadband jamming detection threshold) is set to 0x3F (63 in decimal)
+    // cwThreshold (CW jamming detection threshold) is set to 0x10 (16 in decimal)
+    // algorithmBits (Reserved algorithm settings) is set to 0x16B156 as recommended
+    // enable (Enable interference detection) is set to 1 (enabled)
+    0x3F, 0x10, 0xB1, 0x56, // config: Interference config word
+    // generalBits (General settings) is set to 0x31E as recommended
+    // antSetting (Antenna setting, 0=unknown, 1=passive, 2=active) is set to 0 (unknown)
+    // ToDo: Set to 1 (passive) or 2 (active) if known, for example from UBX-MON-HW, or from board info
+    // enable2 (Set to 1 to scan auxiliary bands, u-blox 8 / u-blox M8 only, otherwise ignored) is set to 1
+    // (enabled)
+    0x1E, 0x03, 0x00, 0x01 // config2: Extra settings for jamming/interference monitor
+};
+
+// Configure navigation engine expert settings:
+const uint8_t GPS::_message_NAVX5[] = {
+    0x00, 0x00, // msgVer (0 for this version)
+    // minMax flag = 1: apply min/max SVs settings
+    // minCno flag = 1: apply minimum C/N0 setting
+    // initial3dfix flag = 0: apply initial 3D fix settings
+    // aop flag = 1: apply aopCfg (useAOP flag) settings (AssistNow Autonomous)
+    0x1B, 0x00, // mask1 (First parameters bitmask)
+    // adr flag = 0: apply ADR sensor fusion on/off setting (useAdr flag)
+    // If firmware is not ADR/UDR, enabling this flag will fail configuration
+    // ToDo: check this with UBX-MON-VER
+    0x00, 0x00, 0x00, 0x00,             // mask2 (Second parameters bitmask)
+    0x00, 0x00,                         // Reserved
+    0x03,                               // minSVs (Minimum number of satellites for navigation) = 3
+    0x10,                               // maxSVs (Maximum number of satellites for navigation) = 16
+    0x06,                               // minCNO (Minimum satellite signal level for navigation) = 6 dBHz
+    0x00,                               // Reserved
+    0x00,                               // iniFix3D (Initial fix must be 3D) = 0 (disabled)
+    0x00, 0x00,                         // Reserved
+    0x00,                               // ackAiding (Issue acknowledgements for assistance message input) = 0 (disabled)
+    0x00, 0x00,                         // Reserved
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Reserved
+    0x00,                               // Reserved
+    0x01,                               // aopCfg (AssistNow Autonomous configuration) = 1 (enabled)
+    0x00, 0x00,                         // Reserved
+    0x00, 0x00,                         // Reserved
+    0x00, 0x00, 0x00, 0x00,             // Reserved
+    0x00, 0x00, 0x00,                   // Reserved
+    0x01,                               // useAdr (Enable/disable ADR sensor fusion) = 1 (enabled)
+};
+
+// Set GPS update rate to 1Hz
+// Lowering the update rate helps to save power.
+// Additionally, for some new modules like the M9/M10, an update rate lower than 5Hz
+// is recommended to avoid a known issue with satellites disappearing.
+const uint8_t GPS::_message_1HZ[] = {
+    0xE8, 0x03, // Measurement Rate (1000ms for 1Hz)
+    0x01, 0x00, // Navigation rate, always 1 in GPS mode
+    0x01, 0x00, // Time reference
+};
+
+// Disable GGL. GGL - Geographic position (latitude and longitude), which provides the current geographical
+// coordinates.
+const uint8_t GPS::_message_GGL[] = {
+    0xF0, 0x01,            // NMEA ID for GLL
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x00,                  // Disable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Enable GSA. GSA - GPS DOP and active satellites, used for detailing the satellites used in the positioning and
+// the DOP (Dilution of Precision)
+const uint8_t GPS::_message_GSA[] = {
+    0xF0, 0x02,            // NMEA ID for GSA
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x01,                  // Enable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Disable GSV. GSV - Satellites in view, details the number and location of satellites in view.
+const uint8_t GPS::_message_GSV[] = {
+    0xF0, 0x03,            // NMEA ID for GSV
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x00,                  // Disable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Disable VTG. VTG - Track made good and ground speed, which provides course and speed information relative to
+// the ground.
+const uint8_t GPS::_message_VTG[] = {
+    0xF0, 0x05,            // NMEA ID for VTG
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x00,                  // Disable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Enable RMC. RMC - Recommended Minimum data, the essential gps pvt (position, velocity, time) data.
+const uint8_t GPS::_message_RMC[] = {
+    0xF0, 0x04,            // NMEA ID for RMC
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x01,                  // Enable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Enable GGA. GGA - Global Positioning System Fix Data, which provides 3D location and accuracy data.
+const uint8_t GPS::_message_GGA[] = {
+    0xF0, 0x00,            // NMEA ID for GGA
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x01,                  // Enable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// The Power Management configuration allows the GPS module to operate in different power modes for optimized
+// power consumption. The modes supported are: 0x00 = Full power: The module operates at full power with no power
+// saving. 0x01 = Balanced: The module dynamically adjusts the tracking behavior to balance power consumption.
+// 0x02 = Interval: The module operates in a periodic mode, cycling between tracking and power saving states.
+// 0x03 = Aggressive with 1 Hz: The module operates in a power saving mode with a 1 Hz update rate.
+// 0x04 = Aggressive with 2 Hz: The module operates in a power saving mode with a 2 Hz update rate.
+// 0x05 = Aggressive with 4 Hz: The module operates in a power saving mode with a 4 Hz update rate.
+// The 'period' field specifies the position update and search period. It is only valid when the powerSetupValue
+// is set to Interval; otherwise, it must be set to '0'. The 'onTime' field specifies the duration of the ON phase
+// and must be smaller than the period. It is only valid when the powerSetupValue is set to Interval; otherwise,
+// it must be set to '0'.
+const uint8_t GPS::_message_PMS[] = {
+    0x00,       // Version (0)
+    0x03,       // Power setup value
+    0x00, 0x00, // period: not applicable, set to 0
+    0x00, 0x00, // onTime: not applicable, set to 0
+    0x97, 0x6F  // reserved, generated by u-center
+};
+
+const uint8_t GPS::_message_SAVE[] = {
+    0x00, 0x00, 0x00, 0x00, // clearMask: no sections cleared
+    0xFF, 0xFF, 0x00, 0x00, // saveMask: save all sections
+    0x00, 0x00, 0x00, 0x00, // loadMask: no sections loaded
+    0x0F                    // deviceMask: BBR, Flash, EEPROM, and SPI Flash
 };

src/main.cpp

@@ -558,6 +558,12 @@ void setup()
 
     readFromRTC(); // read the main CPU RTC at first (in case we can't get GPS time)
 
+    gps = GPS::createGps();
+    if (gps) {
+        gpsStatus->observe(&gps->newStatus);
+    } else {
+        LOG_DEBUG("Running without GPS.\n");
+    }
     nodeStatus->observe(&nodeDB.newStatus);
 
     service.init();
@@ -736,27 +742,6 @@ void setup()
     PowerFSM_setup(); // we will transition to ON in a couple of seconds, FIXME, only do this for cold boots, not waking from SDS
     powerFSMthread = new PowerFSMThread();
 
-    gps = createGps();
-
-    if (gps) {
-        gpsStatus->observe(&gps->newStatus);
-        if (config.position.gps_enabled == false && config.position.fixed_position == false) {
-            doGPSpowersave(false);
-        }
-    } else {
-        LOG_WARN("No GPS found - running without GPS\n");
-    }
-    // We have now loaded our saved preferences from flash
-
-    // ONCE we will factory reset the GPS for bug #327
-    if (gps && !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;
-            nodeDB.saveToDisk(SEGMENT_DEVICESTATE);
-        }
-    }
-    // setBluetoothEnable(false); we now don't start bluetooth until we enter the proper state
     setCPUFast(false); // 80MHz is fine for our slow peripherals
 }
 

src/mesh/MeshService.cpp

@@ -338,10 +338,8 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus)
         pos = ConvertToPosition(node->position);
     }
 
-    // Finally add a fresh timestamp and battery level reading
-    // I KNOW this is redundant with refreshLocalMeshNode() above, but these are
-    //   inexpensive nonblocking calls and can be refactored in due course
-    pos.time = getValidTime(RTCQualityGPS);
+    // Add a fresh timestamp
+    pos.time = getValidTime(RTCQualityFromNet);
 
     // In debug logs, identify position by @timestamp:stage (stage 4 = nodeDB)
     LOG_DEBUG("onGPSChanged() pos@%x, time=%u, lat=%d, lon=%d, alt=%d\n", pos.timestamp, pos.time, pos.latitude_i,

src/mesh/NodeDB.cpp

@@ -304,6 +304,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 +346,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 +402,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/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/generated/meshtastic/config.pb.h

@@ -399,7 +399,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 */

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

@@ -299,9 +299,8 @@ typedef struct _meshtastic_Position {
     /* In meters above MSL (but see issue #359) */
     int32_t altitude;
     /* This is usually not sent over the mesh (to save space), but it is sent
- from the phone so that the local device can set its RTC If it is sent over
- the mesh (because there are devices on the mesh without GPS), it will only
- be sent by devices which has a hardware GPS clock.
+ from the phone so that the local device can set its time if it is sent over
+ the mesh (because there are devices on the mesh without GPS or RTC).
  seconds since 1970 */
     uint32_t time;
     /* TODO: REPLACE */

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

@@ -101,11 +101,7 @@ typedef struct _meshtastic_AirQualityMetrics {
 
 /* Types of Measurements the telemetry module is equipped to handle */
 typedef struct _meshtastic_Telemetry {
-    /* This is usually not sent over the mesh (to save space), but it is sent
- from the phone so that the local device can set its RTC If it is sent over
- the mesh (because there are devices on the mesh without GPS), it will only
- be sent by devices which has a hardware GPS clock (IE Mobile Phone).
- seconds since 1970 */
+    /* Seconds since 1970 - or 0 for unknown/unset */
     uint32_t time;
     pb_size_t which_variant;
     union {

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/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

@@ -182,43 +182,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);
-        for (int i = 0; i < msglen; i++) {
-            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)) {

src/sleep.h

@@ -19,7 +19,7 @@ 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/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

@@ -11,4 +11,4 @@ build_flags = ${esp32_base.build_flags}
   -Ivariants/t-deck
 
 lib_deps = ${esp32s3_base.lib_deps}
-	lovyan03/LovyanGFX@^1.1.8
+	lovyan03/LovyanGFX@^1.1.9

variants/t-deck/variant.h

@@ -27,8 +27,8 @@
 #define BUTTON_PIN 0
 // #define BUTTON_NEED_PULLUP
 
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
+#define GPS_RX_PIN 44
+#define GPS_TX_PIN 43
 
 // Have SPI interface SD card slot
 #define HAS_SDCARD 1
@@ -41,7 +41,7 @@
 #define BATTERY_PIN 4 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 // ratio of voltage divider = 2.0 (RD2=100k, RD3=100k)
 #define ADC_MULTIPLIER 2.11 // 2.0 + 10% for correction of display undervoltage.
-#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
+#define ADC_CHANNEL ADC1_GPIO4_CHANNEL
 
 // keyboard
 #define I2C_SDA 18 // I2C pins for this board

variants/t-watch-s3/platformio.ini

@@ -3,8 +3,6 @@
 extends = esp32s3_base
 board = t-watch-s3
 upload_protocol = esptool
-upload_speed = 115200
-#upload_port = /dev/tty.usbmodem3485188D636C1
 
 build_flags = ${esp32_base.build_flags} 
   -DT_WATCH_S3
@@ -12,6 +10,6 @@ build_flags = ${esp32_base.build_flags}
   -DPCF8563_RTC=0x51
 
 lib_deps = ${esp32s3_base.lib_deps}
-	lovyan03/LovyanGFX@^1.1.8
+	lovyan03/LovyanGFX@^1.1.9
   lewisxhe/PCF8563_Library@1.0.1
   adafruit/Adafruit DRV2605 Library@^1.2.2

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

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 2
-build = 5
+build = 7