Deprecate unneeded GPS settings

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/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,8 +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_attempt_time > MAX_INTERVAL)
         config.position.gps_attempt_time = MAX_INTERVAL;
     if (config.position.position_flags > MAX_INTERVAL)
@@ -739,11 +737,6 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 
 void NodeDB::initConfigIntervals()
 {
-#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;
@@ -899,11 +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_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_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 |
@@ -917,7 +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_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)
@@ -928,7 +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_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/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) /
+                Default::getConfiguredOrDefaultMs(position_broadcast_secs, default_broadcast_interval_secs) / 1000U);
-                    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,
+    uint32_t intervalMs =
-                                                                  default_broadcast_interval_secs, numOnlineNodes);
+        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 &&