Extract default intervals and coalesce methods into their own file / static class methods

src/PowerFSM.cpp

@@ -8,6 +8,7 @@
  * actions to be taken upon entering or exiting each state.
  */
 #include "PowerFSM.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "configuration.h"
@@ -45,7 +46,7 @@ static void sdsEnter()
 {
     LOG_DEBUG("Enter state: SDS\n");
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
-    doDeepSleep(getConfiguredOrDefaultMs(config.power.sds_secs), false);
+    doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false);
 }
 
 extern Power *power;
@@ -343,13 +344,13 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateDARK, &stateDARK, EVENT_CONTACT_FROM_PHONE, NULL, "Contact from phone");
 
     powerFSM.add_timed_transition(&stateON, &stateDARK,
-                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
+                                  Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
                                   "Screen-on timeout");
     powerFSM.add_timed_transition(&statePOWER, &stateDARK,
-                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
+                                  Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
                                   "Screen-on timeout");
     powerFSM.add_timed_transition(&stateDARK, &stateDARK,
-                                  getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
+                                  Default::getConfiguredOrDefaultMs(config.display.screen_on_secs, default_screen_on_secs), NULL,
                                   "Screen-on timeout");
 
 // We never enter light-sleep or NB states on NRF52 (because the CPU uses so little power normally)
@@ -359,11 +360,12 @@ void PowerFSM_setup()
     // modules
     if ((isRouter || config.power.is_power_saving) && !isTrackerOrSensor) {
         powerFSM.add_timed_transition(&stateNB, &stateLS,
-                                      getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
+                                      Default::getConfiguredOrDefaultMs(config.power.min_wake_secs, default_min_wake_secs), NULL,
                                       "Min wake timeout");
-        powerFSM.add_timed_transition(&stateDARK, &stateLS,
-                                      getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs),
-                                      NULL, "Bluetooth timeout");
+        powerFSM.add_timed_transition(
+            &stateDARK, &stateLS,
+            Default::getConfiguredOrDefaultMs(config.power.wait_bluetooth_secs, default_wait_bluetooth_secs), NULL,
+            "Bluetooth timeout");
     }
 #endif
 

src/PowerFSMThread.h

@@ -1,3 +1,4 @@
+#include "Default.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "concurrency/OSThread.h"
@@ -28,7 +29,7 @@ class PowerFSMThread : public OSThread
             timeLastPowered = millis();
         } else if (config.power.on_battery_shutdown_after_secs > 0 && config.power.on_battery_shutdown_after_secs != UINT32_MAX &&
                    millis() > (timeLastPowered +
-                               getConfiguredOrDefaultMs(
+                               Default::getConfiguredOrDefaultMs(
                                    config.power.on_battery_shutdown_after_secs))) { // shutdown after 30 minutes unpowered
             powerFSM.trigger(EVENT_SHUTDOWN);
         }

src/gps/GPS.cpp

@@ -1,4 +1,5 @@
 #include "GPS.h"
+#include "Default.h"
 #include "NodeDB.h"
 #include "RTC.h"
 #include "configuration.h"
@@ -495,7 +496,6 @@ bool GPS::setup()
                         }
                     }
                 }
-
             } else {
                 // LOG_INFO("u-blox M10 hardware found.\n");
                 delay(1000);
@@ -759,7 +759,7 @@ uint32_t GPS::getWakeTime() const
     if (t == UINT32_MAX)
         return t; // already maxint
 
-    return getConfiguredOrDefaultMs(t, default_broadcast_interval_secs);
+    return Default::Default::getConfiguredOrDefaultMs(t, default_broadcast_interval_secs);
 }
 
 /** Get how long we should sleep between aqusition attempts in msecs

src/mesh/Default.cpp

@@ -0,0 +1,23 @@
+#include "Default.h"
+
+uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
+{
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return default_broadcast_interval_secs * 1000;
+}
+
+uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
+{
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return defaultInterval * 1000;
+}
+
+uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
+{
+    if (configured > 0)
+        return configured;
+
+    return defaultValue;
+}

src/mesh/Default.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <NodeDB.h>
+#include <cstdint>
+#define ONE_DAY 24 * 60 * 60
+
+#define default_gps_update_interval IF_ROUTER(ONE_DAY, 2 * 60)
+#define default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 15 * 60)
+#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)
+#define default_min_wake_secs 10
+#define default_screen_on_secs IF_ROUTER(1, 60 * 10)
+#define default_node_info_broadcast_secs 3 * 60 * 60
+#define min_node_info_broadcast_secs 60 * 60 // No regular broadcasts of more than once an hour
+
+#define default_mqtt_address "mqtt.meshtastic.org"
+#define default_mqtt_username "meshdev"
+#define default_mqtt_password "large4cats"
+#define default_mqtt_root "msh"
+
+#define IF_ROUTER(routerVal, normalVal)                                                                                          \
+    ((config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER) ? (routerVal) : (normalVal))
+
+class Default
+{
+  public:
+    static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval);
+    static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval);
+    static uint32_t getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue);
+};

src/mesh/NodeDB.cpp

@@ -3,6 +3,7 @@
 #include "../detect/ScanI2C.h"
 #include "Channels.h"
 #include "CryptoEngine.h"
+#include "Default.h"
 #include "FSCommon.h"
 #include "GPS.h"
 #include "MeshRadio.h"

src/mesh/NodeDB.h

@@ -191,48 +191,6 @@ extern NodeDB nodeDB;
 // Our delay functions check for this for times that should never expire
 #define NODE_DELAY_FOREVER 0xffffffff
 
-#define IF_ROUTER(routerVal, normalVal)                                                                                          \
-    ((config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER) ? (routerVal) : (normalVal))
-
-#define ONE_DAY 24 * 60 * 60
-
-#define default_gps_update_interval IF_ROUTER(ONE_DAY, 2 * 60)
-#define default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 15 * 60)
-#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)
-#define default_min_wake_secs 10
-#define default_screen_on_secs IF_ROUTER(1, 60 * 10)
-#define default_node_info_broadcast_secs 3 * 60 * 60
-#define min_node_info_broadcast_secs 60 * 60 // No regular broadcasts of more than once an hour
-
-#define default_mqtt_address "mqtt.meshtastic.org"
-#define default_mqtt_username "meshdev"
-#define default_mqtt_password "large4cats"
-#define default_mqtt_root "msh"
-
-inline uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval)
-{
-    if (configuredInterval > 0)
-        return configuredInterval * 1000;
-    return default_broadcast_interval_secs * 1000;
-}
-
-inline uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
-{
-    if (configuredInterval > 0)
-        return configuredInterval * 1000;
-    return defaultInterval * 1000;
-}
-
-inline uint32_t getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
-{
-    if (configured > 0)
-        return configured;
-
-    return defaultValue;
-}
-
 /// Sometimes we will have Position objects that only have a time, so check for
 /// valid lat/lon
 static inline bool hasValidPosition(const meshtastic_NodeInfoLite *n)

src/mesh/PhoneAPI.cpp

@@ -1,5 +1,6 @@
 #include "PhoneAPI.h"
 #include "Channels.h"
+#include "Default.h"
 #include "GPS.h"
 #include "MeshService.h"
 #include "NodeDB.h"

src/modules/AdminModule.cpp

@@ -16,6 +16,7 @@
 #ifdef ARCH_PORTDUINO
 #include "unistd.h"
 #endif
+#include "Default.h"
 
 #include "mqtt/MQTT.h"
 

src/modules/AtakPluginModule.cpp

@@ -1,4 +1,5 @@
 #include "AtakPluginModule.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"

src/modules/DetectionSensorModule.cpp

@@ -1,10 +1,10 @@
 #include "DetectionSensorModule.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "configuration.h"
 #include "main.h"
-
 DetectionSensorModule *detectionSensorModule;
 
 #define GPIO_POLLING_INTERVAL 100
@@ -49,7 +49,7 @@ int32_t DetectionSensorModule::runOnce()
 
     // LOG_DEBUG("Detection Sensor Module: Current pin state: %i\n", digitalRead(moduleConfig.detection_sensor.monitor_pin));
 
-    if ((millis() - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.detection_sensor.minimum_broadcast_secs) &&
+    if ((millis() - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.minimum_broadcast_secs) &&
         hasDetectionEvent()) {
         sendDetectionMessage();
         return DELAYED_INTERVAL;
@@ -58,7 +58,8 @@ int32_t DetectionSensorModule::runOnce()
     // of heartbeat. We only do this if the minimum broadcast interval is greater than zero, otherwise we'll only broadcast state
     // change detections.
     else if (moduleConfig.detection_sensor.state_broadcast_secs > 0 &&
-             (millis() - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs)) {
+             (millis() - lastSentToMesh) >=
+                 Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs)) {
         sendCurrentStateMessage();
         return DELAYED_INTERVAL;
     }

src/modules/NeighborInfoModule.cpp

@@ -1,4 +1,5 @@
 #include "NeighborInfoModule.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "RTC.h"
@@ -194,7 +195,7 @@ int32_t NeighborInfoModule::runOnce()
 {
     bool requestReplies = false;
     sendNeighborInfo(NODENUM_BROADCAST, requestReplies);
-    return getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs);
+    return Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs);
 }
 
 /*

src/modules/NodeInfoModule.cpp

@@ -1,4 +1,5 @@
 #include "NodeInfoModule.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "RTC.h"
@@ -91,5 +92,5 @@ int32_t NodeInfoModule::runOnce()
         LOG_INFO("Sending our nodeinfo to mesh (wantReplies=%d)\n", requestReplies);
         sendOurNodeInfo(NODENUM_BROADCAST, requestReplies); // Send our info (don't request replies)
     }
-    return getConfiguredOrDefaultMs(config.device.node_info_broadcast_secs, default_node_info_broadcast_secs);
+    return Default::getConfiguredOrDefaultMs(config.device.node_info_broadcast_secs, default_node_info_broadcast_secs);
 }

src/modules/PositionModule.cpp

@@ -1,4 +1,5 @@
 #include "PositionModule.h"
+#include "Default.h"
 #include "GPS.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -280,7 +281,7 @@ int32_t PositionModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = getConfiguredOrDefaultMs(config.position.position_broadcast_secs);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs);
         LOG_DEBUG("Sleeping for %ims, then awaking to send position again.\n", nightyNightMs);
         doDeepSleep(nightyNightMs, false);
     }
@@ -291,7 +292,8 @@ int32_t PositionModule::runOnce()
 
     // We limit our GPS broadcasts to a max rate
     uint32_t now = millis();
-    uint32_t intervalMs = getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
+    uint32_t intervalMs =
+        Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
     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 &&
@@ -322,7 +324,7 @@ int32_t PositionModule::runOnce()
         if (hasValidPosition(node2)) {
             // The minimum time (in seconds) that would pass before we are able to send a new position packet.
             const uint32_t minimumTimeThreshold =
-                getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);
+                Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);
 
             auto smartPosition = getDistanceTraveledSinceLastSend(node->position);
 
@@ -369,7 +371,8 @@ void PositionModule::sendLostAndFoundText()
 struct SmartPosition PositionModule::getDistanceTraveledSinceLastSend(meshtastic_PositionLite currentPosition)
 {
     // The minimum distance to travel before we are able to send a new position packet.
-    const uint32_t distanceTravelThreshold = getConfiguredOrDefault(config.position.broadcast_smart_minimum_distance, 100);
+    const uint32_t distanceTravelThreshold =
+        Default::getConfiguredOrDefault(config.position.broadcast_smart_minimum_distance, 100);
 
     // Determine the distance in meters between two points on the globe
     float distanceTraveledSinceLastSend = GeoCoord::latLongToMeter(

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -1,5 +1,6 @@
 #include "AirQualityTelemetry.h"
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
@@ -43,7 +44,7 @@ int32_t AirQualityTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.air_quality_interval))) &&
+             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.air_quality_interval))) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
             lastSentToMesh = now;

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -1,5 +1,6 @@
 #include "DeviceTelemetry.h"
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
@@ -16,7 +17,7 @@ int32_t DeviceTelemetryModule::runOnce()
 {
     uint32_t now = millis();
     if (((lastSentToMesh == 0) ||
-         ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.device_update_interval))) &&
+         ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.device_update_interval))) &&
         airTime->isTxAllowedChannelUtil() && airTime->isTxAllowedAirUtil() &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN) {

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -1,5 +1,6 @@
 #include "EnvironmentTelemetry.h"
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
@@ -41,7 +42,7 @@ int32_t EnvironmentTelemetryModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval);
         LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.\n", nightyNightMs);
         doDeepSleep(nightyNightMs, true);
     }
@@ -102,7 +103,7 @@ int32_t EnvironmentTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval))) &&
+             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval))) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
             lastSentToMesh = now;