modules: Align watchdog configuration and naming

jtguggedal · jtguggedal · commit a0a3487f6b0b · 2025-02-24T14:38:41.000+01:00
Align how each module configures watchdog timeouts and the naming
of options and variables. Add build asserts where missing to
ensure that message processing time is shorter than the watchdog
timeout.

Signed-off-by: Jan Tore Guggedal &lt;jantore.guggedal@nordicsemi.no&gt;
diff --git a/app/src/modules/app/Kconfig.app b/app/src/modules/app/Kconfig.app
@@ -17,7 +17,7 @@ config APP_MODULE_THREAD_STACK_SIZE
 	default 3200
 
 config APP_MODULE_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 330
 
 config APP_MODULE_EXEC_TIME_SECONDS_MAX
diff --git a/app/src/modules/battery/Kconfig.battery b/app/src/modules/battery/Kconfig.battery
@@ -16,14 +16,24 @@ config APP_BATTERY_THREAD_STACK_SIZE
 	default 1536
 
 config APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 120
-
-config APP_BATTERY_EXEC_TIME_SECONDS_MAX
-	int "Maximum execution time seconds"
+	help
+	  Timeout in seconds for the battery module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_BATTERY_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_BATTERY_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
+
+config APP_BATTERY_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 3
 	help
-	  Maximum time allowed for a single execution of the module thread loop.
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS.
 
 module = APP_BATTERY
 module-str = Battery
diff --git a/app/src/modules/battery/battery.c b/app/src/modules/battery/battery.c
@@ -41,8 +41,8 @@ ZBUS_CHAN_ADD_OBS(BATTERY_CHAN, battery, 0);
 #define MAX_MSG_SIZE sizeof(struct battery_msg)
 
 BUILD_ASSERT(CONFIG_APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS >
-	     CONFIG_APP_BATTERY_EXEC_TIME_SECONDS_MAX,
-	     "Watchdog timeout must be greater than maximum execution time");
+	     CONFIG_APP_BATTERY_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
 
 /* nPM1300 register bitmasks */
 
@@ -234,8 +234,10 @@ static void battery_task(void)
 {
 	int err;
 	int task_wdt_id;
-	const uint32_t wdt_timeout_ms = (CONFIG_APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const uint32_t execution_time_ms = (CONFIG_APP_BATTERY_EXEC_TIME_SECONDS_MAX * MSEC_PER_SEC);
+	const uint32_t wdt_timeout_ms =
+		(CONFIG_APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_BATTERY_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 
 	LOG_DBG("Battery module task started");
diff --git a/app/src/modules/cloud/Kconfig.cloud b/app/src/modules/cloud/Kconfig.cloud
@@ -68,14 +68,25 @@ config APP_CLOUD_POLL_INTERVAL_SECONDS
 	  Interval in seconds between polling nRF Cloud CoAP.
 
 config APP_CLOUD_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 180
-
-config APP_CLOUD_EXEC_TIME_SECONDS_MAX
-	int "Maximum execution time seconds"
+	help
+	  Timeout in seconds for the cloud module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_CLOUD_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_CLOUD_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
+
+
+config APP_CLOUD_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 120
 	help
-	  Maximum time allowed for a single execution of the module's thread loop.
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_CLOUD_WATCHDOG_TIMEOUT_SECONDS.
 
 module = APP_CLOUD
 module-str = Cloud
diff --git a/app/src/modules/cloud/cloud_module.c b/app/src/modules/cloud/cloud_module.c
@@ -53,8 +53,8 @@ LOG_MODULE_REGISTER(cloud, CONFIG_APP_CLOUD_LOG_LEVEL);
 			 MAX(BAT_MSG_SIZE, ENV_MSG_SIZE))))
 
 BUILD_ASSERT(CONFIG_APP_CLOUD_WATCHDOG_TIMEOUT_SECONDS >
-	     CONFIG_APP_CLOUD_EXEC_TIME_SECONDS_MAX,
-	     "Watchdog timeout must be greater than maximum execution time");
+	     CONFIG_APP_CLOUD_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
 
 /* Register subscriber */
 ZBUS_MSG_SUBSCRIBER_DEFINE(cloud);
@@ -669,7 +669,8 @@ static void cloud_module_thread(void)
 	int err;
 	int task_wdt_id;
 	const uint32_t wdt_timeout_ms = (CONFIG_APP_CLOUD_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const uint32_t execution_time_ms = (CONFIG_APP_CLOUD_EXEC_TIME_SECONDS_MAX * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_CLOUD_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 
 	LOG_DBG("cloud  module task started");
diff --git a/app/src/modules/environmental/Kconfig.environmental b/app/src/modules/environmental/Kconfig.environmental
@@ -16,14 +16,24 @@ config APP_ENVIRONMENTAL_THREAD_STACK_SIZE
 	default 1280
 
 config APP_ENVIRONMENTAL_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 120
+	help
+	  Timeout in seconds for the environmental module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_ENVIRONMENTAL_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_ENVIRONMENTAL_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
 
-config APP_ENVIRONMENTAL_EXEC_TIME_SECONDS_MAX
-	int "Maximum execution time seconds"
+config APP_ENVIRONMENTAL_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 3
 	help
-	  Maximum time allowed for a single execution of the module's thread loop.
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_ENVIRONMENTAL_WATCHDOG_TIMEOUT_SECONDS.
 
 module = APP_ENVIRONMENTAL
 module-str = ENVIRONMENTAL
diff --git a/app/src/modules/environmental/environmental.c b/app/src/modules/environmental/environmental.c
@@ -38,8 +38,8 @@ ZBUS_CHAN_ADD_OBS(ENVIRONMENTAL_CHAN, environmental, 0);
 #define MAX_MSG_SIZE sizeof(struct environmental_msg)
 
 BUILD_ASSERT(CONFIG_APP_ENVIRONMENTAL_WATCHDOG_TIMEOUT_SECONDS >
-	     CONFIG_APP_ENVIRONMENTAL_EXEC_TIME_SECONDS_MAX,
-	     "Watchdog timeout must be greater than maximum execution time");
+	     CONFIG_APP_ENVIRONMENTAL_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
 
 static const struct device *const sensor_dev = DEVICE_DT_GET(DT_NODELABEL(bme680));
 
@@ -148,8 +148,10 @@ static void environmental_task(void)
 {
 	int err;
 	int task_wdt_id;
-	const uint32_t wdt_timeout_ms = (CONFIG_APP_ENVIRONMENTAL_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const uint32_t execution_time_ms = (CONFIG_APP_ENVIRONMENTAL_EXEC_TIME_SECONDS_MAX * MSEC_PER_SEC);
+	const uint32_t wdt_timeout_ms =
+		(CONFIG_APP_ENVIRONMENTAL_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_ENVIRONMENTAL_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 
 	LOG_DBG("Environmental module task started");
diff --git a/app/src/modules/fota/Kconfig.fota b/app/src/modules/fota/Kconfig.fota
@@ -14,14 +14,24 @@ config APP_FOTA_THREAD_STACK_SIZE
 	default 2500
 
 config APP_FOTA_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 210
+	help
+	  Timeout in seconds for the FOTA module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_FOTA_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_FOTA_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
 
-config APP_FOTA_EXEC_TIME_SECONDS_MAX
-	int "Maximum execution time seconds"
+config APP_FOTA_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 180
 	help
-	  Watchdog timeout in seconds for a state machine run.
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_FOTA_WATCHDOG_TIMEOUT_SECONDS.
 
 if APP_FOTA
 
diff --git a/app/src/modules/fota/fota.c b/app/src/modules/fota/fota.c
@@ -24,6 +24,10 @@
 /* Register log module */
 LOG_MODULE_REGISTER(fota, CONFIG_APP_FOTA_LOG_LEVEL);
 
+BUILD_ASSERT(CONFIG_APP_FOTA_WATCHDOG_TIMEOUT_SECONDS >
+	     CONFIG_APP_FOTA_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
+
 /* Register message subscriber - will be called everytime a channel that the module listens on
  * receives a new message.
  */
@@ -431,7 +435,8 @@ static void fota_task(void)
 	int err;
 	int task_wdt_id;
 	const uint32_t wdt_timeout_ms = (CONFIG_APP_FOTA_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const uint32_t execution_time_ms = (CONFIG_APP_FOTA_EXEC_TIME_SECONDS_MAX * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_FOTA_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 
 	LOG_DBG("FOTA module task started");
diff --git a/app/src/modules/location/Kconfig.location b/app/src/modules/location/Kconfig.location
@@ -12,12 +12,24 @@ config APP_LOCATION_THREAD_STACK_SIZE
 	default 2048
 
 config APP_LOCATION_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 120
+	help
+	  Timeout in seconds for the location module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_LOCATION_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_LOCATION_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
 
-config APP_LOCATION_ZBUS_TIMEOUT_SECONDS
-	int "Wait for zbus timeout seconds"
+config APP_LOCATION_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 60
+	help
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_LOCATION_WATCHDOG_TIMEOUT_SECONDS.
 
 module = APP_LOCATION
 module-str = Location
diff --git a/app/src/modules/location/location.c b/app/src/modules/location/location.c
@@ -25,8 +25,8 @@
 LOG_MODULE_REGISTER(location_module, CONFIG_APP_LOCATION_LOG_LEVEL);
 
 BUILD_ASSERT(CONFIG_APP_LOCATION_WATCHDOG_TIMEOUT_SECONDS >
-	     CONFIG_APP_LOCATION_ZBUS_TIMEOUT_SECONDS,
-	     "Watchdog timeout must be greater than trigger timeout");
+	     CONFIG_APP_LOCATION_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
 
 /* Define channels provided by this module */
 ZBUS_CHAN_DEFINE(LOCATION_CHAN,
@@ -179,8 +179,11 @@ void location_task(void)
 	int err = 0;
 	const struct zbus_channel *chan;
 	int task_wdt_id;
-	const uint32_t wdt_timeout_ms = (CONFIG_APP_LOCATION_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const k_timeout_t zbus_timeout = K_SECONDS(CONFIG_APP_LOCATION_ZBUS_TIMEOUT_SECONDS);
+	const uint32_t wdt_timeout_ms =
+		(CONFIG_APP_LOCATION_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_LOCATION_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
+	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 	uint8_t msg_buf[MAX_MSG_SIZE];
 
 	LOG_DBG("Location module task started");
@@ -209,7 +212,7 @@ void location_task(void)
 			return;
 		}
 
-		err = zbus_sub_wait_msg(&location, &chan, &msg_buf, zbus_timeout);
+		err = zbus_sub_wait_msg(&location, &chan, &msg_buf, zbus_wait_ms);
 		if (err == -ENOMSG) {
 			continue;
 		} else if (err) {
diff --git a/app/src/modules/network/Kconfig.network b/app/src/modules/network/Kconfig.network
@@ -12,14 +12,24 @@ config APP_NETWORK_THREAD_STACK_SIZE
 	default 2048
 
 config APP_NETWORK_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 600
+	help
+	  Timeout in seconds for the network module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_NETWORK__MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_NETWORK__MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
 
-config APP_NETWORK_EXEC_TIME_SECONDS_MAX
-	int "Maximum execution time seconds"
+config APP_NETWORK_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 570
 	help
-	  Maximum time allowed for a single execution of the module's thread loop.
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_NETWORK__WATCHDOG_TIMEOUT_SECONDS.
 
 config APP_NETWORK_SEARCH_NETWORK_ON_STARTUP
 	bool "Search for network on startup"
diff --git a/app/src/modules/network/network.c b/app/src/modules/network/network.c
@@ -22,6 +22,10 @@
 /* Register log module */
 LOG_MODULE_REGISTER(network, CONFIG_APP_NETWORK_LOG_LEVEL);
 
+BUILD_ASSERT(CONFIG_APP_NETWORK_WATCHDOG_TIMEOUT_SECONDS >
+	     CONFIG_APP_NETWORK_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
+
 /* Define channels provided by this module */
 ZBUS_CHAN_DEFINE(NETWORK_CHAN,
 		 struct network_msg,
@@ -569,8 +573,10 @@ static void network_module_thread(void)
 {
 	int err;
 	int task_wdt_id;
-	const uint32_t wdt_timeout_ms = (CONFIG_APP_NETWORK_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const uint32_t execution_time_ms = (CONFIG_APP_NETWORK_EXEC_TIME_SECONDS_MAX * MSEC_PER_SEC);
+	const uint32_t wdt_timeout_ms =
+		(CONFIG_APP_NETWORK_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_NETWORK_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 
 	task_wdt_id = task_wdt_add(wdt_timeout_ms, network_wdt_callback, (void *)k_current_get());
diff --git a/app/src/modules/shell/Kconfig.shell b/app/src/modules/shell/Kconfig.shell
@@ -22,14 +22,24 @@ config APP_SHELL_THREAD_STACK_SIZE
 	default 1024
 
 config APP_SHELL_WATCHDOG_TIMEOUT_SECONDS
-	int "Watchdog timeout seconds"
+	int "Watchdog timeout"
 	default 120
-
-config APP_SHELL_EXEC_TIME_SECONDS_MAX
-	int "Maximum execution time seconds"
+	help
+	  Timeout in seconds for the shell module watchdog.
+	  The timeout given in this option covers both:
+	    * Waiting for an incoming message in zbus_sub_wait_msg().
+	    * Time spent processing the message, defined by
+	      CONFIG_APP_SHELL_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  Ensure that this value exceeds CONFIG_APP_SHELL_MSG_PROCESSING_TIMEOUT_SECONDS.
+	  A small difference between the two can mean more frequent watchdog feeds, which increases
+	  power consumption.
+
+config APP_SHELL_MSG_PROCESSING_TIMEOUT_SECONDS
+	int "Maximum message processing time"
 	default 3
 	help
-	  Maximum time allowed for a single execution of the module thread loop.
+	  Maximum time allowed for processing a single message in the module's state machine.
+	  The value must be smaller than CONFIG_APP_SHELL_WATCHDOG_TIMEOUT_SECONDS.
 
 config APP_SHELL_UART_PM_ENABLE
 	bool "Enable UART power management feature"
diff --git a/app/src/modules/shell/shell.c b/app/src/modules/shell/shell.c
@@ -26,6 +26,10 @@
 
 LOG_MODULE_REGISTER(shell, CONFIG_APP_SHELL_LOG_LEVEL);
 
+BUILD_ASSERT(CONFIG_APP_SHELL_WATCHDOG_TIMEOUT_SECONDS >
+	     CONFIG_APP_SHELL_MSG_PROCESSING_TIMEOUT_SECONDS,
+	     "Watchdog timeout must be greater than maximum message processing time");
+
 #define PAYLOAD_MSG_TEMPLATE	\
 	"{\""NRF_CLOUD_JSON_MSG_TYPE_KEY"\":\""NRF_CLOUD_JSON_MSG_TYPE_VAL_DATA"\","	\
 	"\""NRF_CLOUD_JSON_APPID_KEY"\":\"%s\","					\
@@ -282,7 +286,8 @@ static void shell_task(void)
 	const struct zbus_channel *chan;
 	int task_wdt_id;
 	const uint32_t wdt_timeout_ms = (CONFIG_APP_SHELL_WATCHDOG_TIMEOUT_SECONDS * MSEC_PER_SEC);
-	const uint32_t execution_time_ms = (CONFIG_APP_SHELL_EXEC_TIME_SECONDS_MAX * MSEC_PER_SEC);
+	const uint32_t execution_time_ms =
+		(CONFIG_APP_SHELL_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 	uint8_t msg_buf[MAX_MSG_SIZE];
 
