Deprecate unneeded GPS settings

src/gps/GPS.cpp

@@ -855,7 +855,7 @@ void GPS::setPowerState(GPSPowerState newState, uint32_t sleepTime)
         writePinStandby(true);                                      // Standby (pin): asleep (not awake)
         setPowerUBLOX(false, sleepTime);                            // Standby (UBLOX): asleep, timed
 #ifdef GNSS_AIROHA
-        if (config.position.gps_update_interval * 1000 >= GPS_FIX_HOLD_TIME * 2) {
+        if (config.position.broadcast_smart_minimum_interval_secs * 1000 >= GPS_FIX_HOLD_TIME * 2) {
             digitalWrite(PIN_GPS_EN, LOW);
         }
 #endif
@@ -869,7 +869,7 @@ void GPS::setPowerState(GPSPowerState newState, uint32_t sleepTime)
         writePinStandby(true);                                      // Standby (pin): asleep
         setPowerUBLOX(false, 0);                                    // Standby (UBLOX): asleep, indefinitely
 #ifdef GNSS_AIROHA
-        if (config.position.gps_update_interval * 1000 >= GPS_FIX_HOLD_TIME * 2) {
+        if (config.position.broadcast_smart_minimum_interval_secs * 1000 >= GPS_FIX_HOLD_TIME * 2) {
             digitalWrite(PIN_GPS_EN, LOW);
         }
 #endif
@@ -1018,7 +1018,7 @@ void GPS::down()
     scheduling.informGotLock();
     uint32_t predictedSearchDuration = scheduling.predictedSearchDurationMs();
     uint32_t sleepTime = scheduling.msUntilNextSearch();
-    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
+    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs);
 
     LOG_DEBUG("%us until next search", sleepTime / 1000);
 
@@ -1039,12 +1039,12 @@ void GPS::down()
             softsleepSupported = true;
 
         if (softsleepSupported) {
-            // How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than
+            // How long does broadcast_smart_minimum_interval_secs need to be, for GPS_HARDSLEEP to become more efficient than
             // GPS_SOFTSLEEP? Heuristic equation. A compromise manually fitted to power observations from U-blox NEO-6M
             // and M10050 https://www.desmos.com/calculator/6gvjghoumr This is not particularly accurate, but probably an
             // improvement over a single, fixed threshold
             uint32_t hardsleepThreshold = (2750 * pow(predictedSearchDuration / 1000, 1.22));
-            LOG_DEBUG("gps_update_interval >= %us needed to justify hardsleep", hardsleepThreshold / 1000);
+            LOG_DEBUG("broadcast_smart_minimum_interval_secs >= %us needed to justify hardsleep", hardsleepThreshold / 1000);
 
             // If update interval too short: softsleep (if supported by hardware)
             if (updateInterval < hardsleepThreshold) {
@@ -1556,7 +1556,7 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
 bool GPS::lookForLocation()
 {
 #ifdef GNSS_AIROHA
-    if ((config.position.gps_update_interval * 1000) >= (GPS_FIX_HOLD_TIME * 2)) {
+    if ((config.position.broadcast_smart_minimum_interval_secs * 1000) >= (GPS_FIX_HOLD_TIME * 2)) {
         uint8_t fix = reader.fixQuality();
         if (fix > 0) {
             if (lastFixStartMsec > 0) {

src/gps/GPSUpdateScheduling.cpp

@@ -34,7 +34,8 @@ uint32_t GPSUpdateScheduling::msUntilNextSearch()
     uint32_t now = millis();
 
     // Target interval (seconds), between GPS updates
-    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval, default_gps_update_interval);
+    uint32_t updateInterval =
+        Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, default_gps_update_interval);
 
     // Check how long until we should start searching, to hopefully hit our target interval
     uint32_t dueAtMs = searchEndedMs + updateInterval;
@@ -71,7 +72,7 @@ bool GPSUpdateScheduling::isUpdateDue()
 bool GPSUpdateScheduling::searchedTooLong()
 {
     uint32_t minimumOrConfiguredSecs =
-        Default::getConfiguredOrMinimumValue(config.position.position_broadcast_secs, default_broadcast_interval_secs);
+        Default::getConfiguredOrMinimumValue(position_broadcast_secs, default_broadcast_interval_secs);
     uint32_t maxSearchMs = Default::getConfiguredOrDefaultMs(minimumOrConfiguredSecs, default_broadcast_interval_secs);
     // If broadcast interval set to max, no such thing as "too long"
     if (maxSearchMs == UINT32_MAX)

src/input/ExpressLRSFiveWay.cpp

@@ -199,12 +199,10 @@ void ExpressLRSFiveWay::sendKey(input_broker_event key)
 void ExpressLRSFiveWay::toggleGPS()
 {
 #if HAS_GPS && !MESHTASTIC_EXCLUDE_GPS
-    if (!config.device.disable_triple_click && (gps != nullptr)) {
-        gps->toggleGpsMode();
-        screen->startAlert("GPS Toggled");
-        alerting = true;
-        alertingSinceMs = millis();
-    }
+    gps->toggleGpsMode();
+    screen->startAlert("GPS Toggled");
+    alerting = true;
+    alertingSinceMs = millis();
 #endif
 }
 

src/mesh/Default.h

@@ -14,6 +14,7 @@
 #define default_gps_update_interval IF_ROUTER(ONE_DAY, 2 * 60)
 #define default_telemetry_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 60 * 60)
 #define default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 15 * 60)
+#define position_broadcast_secs config.position.broadcast_smart_minimum_interval_secs * 30
 #define default_wait_bluetooth_secs IF_ROUTER(1, 60)
 #define default_sds_secs IF_ROUTER(ONE_DAY, UINT32_MAX) // Default to forever super deep sleep
 #define default_ls_secs IF_ROUTER(ONE_DAY, 5 * 60)

src/mesh/NodeDB.cpp

@@ -342,10 +342,6 @@ NodeDB::NodeDB()
     // FIXME: UINT32_MAX intervals overflows Apple clients until they are fully patched
     if (config.device.node_info_broadcast_secs > MAX_INTERVAL)
         config.device.node_info_broadcast_secs = MAX_INTERVAL;
-    if (config.position.position_broadcast_secs > MAX_INTERVAL)
-        config.position.position_broadcast_secs = MAX_INTERVAL;
-    if (config.position.gps_update_interval > MAX_INTERVAL)
-        config.position.gps_update_interval = MAX_INTERVAL;
     if (config.position.gps_attempt_time > MAX_INTERVAL)
         config.position.gps_attempt_time = MAX_INTERVAL;
     if (config.position.position_flags > MAX_INTERVAL)
@@ -628,11 +624,6 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #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
 #if defined(USERPREFS_CONFIG_GPS_MODE)
     config.position.gps_mode = USERPREFS_CONFIG_GPS_MODE;
 #elif !HAS_GPS || GPS_DEFAULT_NOT_PRESENT
@@ -644,11 +635,6 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_DISABLED;
 #else
     config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_ENABLED;
-#endif
-#ifdef USERPREFS_CONFIG_SMART_POSITION_ENABLED
-    config.position.position_broadcast_smart_enabled = USERPREFS_CONFIG_SMART_POSITION_ENABLED;
-#else
-    config.position.position_broadcast_smart_enabled = true;
 #endif
     config.position.broadcast_smart_minimum_distance = 100;
     config.position.broadcast_smart_minimum_interval_secs = 30;
@@ -751,16 +737,6 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 
 void NodeDB::initConfigIntervals()
 {
-#ifdef USERPREFS_CONFIG_GPS_UPDATE_INTERVAL
-    config.position.gps_update_interval = USERPREFS_CONFIG_GPS_UPDATE_INTERVAL;
-#else
-    config.position.gps_update_interval = default_gps_update_interval;
-#endif
-#ifdef USERPREFS_CONFIG_POSITION_BROADCAST_INTERVAL
-    config.position.position_broadcast_secs = USERPREFS_CONFIG_POSITION_BROADCAST_INTERVAL;
-#else
-    config.position.position_broadcast_secs = default_broadcast_interval_secs;
-#endif
 
     config.power.ls_secs = default_ls_secs;
     config.power.min_wake_secs = default_min_wake_secs;
@@ -916,13 +892,8 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
         moduleConfig.telemetry.device_update_interval = default_telemetry_broadcast_interval_secs;
         moduleConfig.telemetry.environment_measurement_enabled = true;
         moduleConfig.telemetry.environment_update_interval = 300;
-    } else if (role == meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND) {
-        config.position.position_broadcast_smart_enabled = false;
-        config.position.position_broadcast_secs = 300; // Every 5 minutes
     } else if (role == meshtastic_Config_DeviceConfig_Role_TAK) {
         config.device.node_info_broadcast_secs = ONE_DAY;
-        config.position.position_broadcast_smart_enabled = false;
-        config.position.position_broadcast_secs = ONE_DAY;
         // Remove Altitude MSL from flags since CoTs use HAE (height above ellipsoid)
         config.position.position_flags =
             (meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE | meshtastic_Config_PositionConfig_PositionFlags_SPEED |
@@ -936,8 +907,6 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
         owner.has_is_unmessagable = true;
         owner.is_unmessagable = true;
         config.device.node_info_broadcast_secs = ONE_DAY;
-        config.position.position_broadcast_smart_enabled = true;
-        config.position.position_broadcast_secs = 3 * 60; // Every 3 minutes
         config.position.broadcast_smart_minimum_distance = 20;
         config.position.broadcast_smart_minimum_interval_secs = 15;
         // Remove Altitude MSL from flags since CoTs use HAE (height above ellipsoid)
@@ -948,8 +917,6 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
     } else if (role == meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN) {
         config.device.rebroadcast_mode = meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY;
         config.device.node_info_broadcast_secs = MAX_INTERVAL;
-        config.position.position_broadcast_smart_enabled = false;
-        config.position.position_broadcast_secs = MAX_INTERVAL;
         moduleConfig.neighbor_info.update_interval = MAX_INTERVAL;
         moduleConfig.telemetry.device_update_interval = MAX_INTERVAL;
         moduleConfig.telemetry.environment_update_interval = MAX_INTERVAL;

src/mesh/NodeDB.h

@@ -336,14 +336,11 @@ extern NodeDB *nodeDB;
 
         # FIXME - after tuning, move these params into the on-device defaults based on is_router and is_power_saving
 
-        # prefs.position_broadcast_secs = FIXME possibly broadcast only once an hr
         prefs.wait_bluetooth_secs = 1  # Don't stay in bluetooth mode
         # try to stay in light sleep one full day, then briefly wake and sleep again
 
         prefs.ls_secs = oneday
 
-        prefs.position_broadcast_secs = 12 hours # send either position or owner every 12hrs
-
         # get a new GPS position once per day
         prefs.gps_update_interval = oneday
 

src/modules/AdminModule.cpp

@@ -596,7 +596,6 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         if (config.device.button_gpio == c.payload_variant.device.button_gpio &&
             config.device.buzzer_gpio == c.payload_variant.device.buzzer_gpio &&
             config.device.role == c.payload_variant.device.role &&
-            config.device.disable_triple_click == c.payload_variant.device.disable_triple_click &&
             config.device.rebroadcast_mode == c.payload_variant.device.rebroadcast_mode) {
             requiresReboot = false;
         }

src/modules/PositionModule.cpp

@@ -381,8 +381,7 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha
         notification->level = meshtastic_LogRecord_Level_INFO;
         notification->time = getValidTime(RTCQualityFromNet);
         sprintf(notification->message, "Sending position and sleeping for %us interval in a moment",
-                Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs) /
-                    1000U);
+                Default::getConfiguredOrDefaultMs(position_broadcast_secs, default_broadcast_interval_secs) / 1000U);
         service->sendClientNotification(notification);
         sleepOnNextExecution = true;
         LOG_DEBUG("Start next execution in 5s, then sleep");
@@ -396,7 +395,7 @@ int32_t PositionModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(position_broadcast_secs);
         LOG_DEBUG("Sleep for %ims, then awaking to send position again", nightyNightMs);
         doDeepSleep(nightyNightMs, false, false);
     }
@@ -407,8 +406,8 @@ int32_t PositionModule::runOnce()
 
     // We limit our GPS broadcasts to a max rate
     uint32_t now = millis();
-    uint32_t intervalMs = Default::getConfiguredOrDefaultMsScaled(config.position.position_broadcast_secs,
-                                                                  default_broadcast_interval_secs, numOnlineNodes);
+    uint32_t intervalMs =
+        Default::getConfiguredOrDefaultMsScaled(position_broadcast_secs, default_broadcast_interval_secs, numOnlineNodes);
     uint32_t msSinceLastSend = now - lastGpsSend;
     // Only send packets if the channel util. is less than 25% utilized or we're a tracker with less than 40% utilized.
     if (!airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&
@@ -428,7 +427,7 @@ int32_t PositionModule::runOnce()
                 sendLostAndFoundText();
             }
         }
-    } else if (config.position.position_broadcast_smart_enabled) {
+    } else {
         const meshtastic_NodeInfoLite *node2 = service->refreshLocalMeshNode(); // should guarantee there is now a position
 
         if (nodeDB->hasValidPosition(node2)) {