app: shell: add att_inspect command

Add a new shell command, att_inspect, that provides an overview of the
current state of the application and its modules. Registering each
module to the shell command with macros using iterable sections.

Signed-off-by: Trond F. Christiansen <trond.christiansen@nordicsemi.no>

Author: Trond-F-Christiansen

app/CMakeLists.txt

@@ -30,3 +30,4 @@ add_subdirectory_ifdef(CONFIG_APP_CLOUD src/modules/cloud)
 add_subdirectory_ifdef(CONFIG_APP_FOTA src/modules/fota)
 add_subdirectory_ifdef(CONFIG_APP_STORAGE src/modules/storage)
 add_subdirectory_ifdef(CONFIG_APP_SGP4 src/modules/sgp4)
+add_subdirectory_ifdef(CONFIG_APP_INSPECT_SHELL src/inspect)

app/Kconfig

@@ -17,6 +17,7 @@ rsource "src/modules/environmental/Kconfig.environmental"
 rsource "src/modules/button/Kconfig.button"
 rsource "src/modules/storage/Kconfig.storage"
 rsource "src/modules/sgp4/Kconfig.sgp4"
+rsource "src/inspect/Kconfig.inspect"
 endmenu
 
 menu "Zephyr Kernel"

app/src/inspect/CMakeLists.txt

@@ -0,0 +1,9 @@
+#
+# Copyright (c) 2026 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+target_sources(app PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inspect_shell.c)
+zephyr_linker_sources(SECTIONS inspect_sections.ld)
+target_include_directories(app PRIVATE .)

app/src/inspect/Kconfig.inspect

@@ -0,0 +1,16 @@
+#
+# Copyright (c) 2026 Nordic Semiconductor
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+menu "Inspect"
+
+config APP_INSPECT_SHELL
+	bool "Inspect shell command"
+	depends on SHELL
+	default y
+	help
+	  Enable the 'att_inspect' shell command.
+
+endmenu # Inspect

app/src/inspect/app_inspect.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#ifndef _APP_INSPECT_H_
+#define _APP_INSPECT_H_
+
+#include <zephyr/sys/iterable_sections.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct app_inspect_provider {
+	const char *name;
+	const char *(*get_state_name)(void);
+};
+
+#if defined(CONFIG_APP_INSPECT_SHELL)
+/* Macro to register an inspect provider for a module.
+ * The provider will be used to print the state of the module in the inspect shell.
+ */
+#define APP_INSPECT_MODULE_REGISTER(_name, _get_state_name_fn)                                     \
+	STRUCT_SECTION_ITERABLE(app_inspect_provider, _name##_inspect_provider) = {                \
+		.name = #_name,                                                                    \
+		.get_state_name = _get_state_name_fn,                                              \
+	}
+
+/* Macro to register an inspect provider and state names */
+#define APP_INSPECT_MODULE_REGISTER_STATE(_name, _state_ctx_ptr, _states, _state_enum_t,           \
+					  _to_string_fn)                                           \
+	/* Create a function that translates the current state to a string */                      \
+	static const char *_name##_state_name_get(void)                                            \
+	{                                                                                          \
+		const struct smf_state *current;                                                   \
+                                                                                                   \
+		if ((_state_ctx_ptr) == NULL) {                                                    \
+			return "STATE_UNINITIALIZED";                                              \
+		}                                                                                  \
+                                                                                                   \
+		current = smf_get_current_leaf_state(SMF_CTX(_state_ctx_ptr));                     \
+                                                                                                   \
+		for (size_t i = 0; i < ARRAY_SIZE(_states); i++) {                                 \
+			if (current == &(_states)[i]) {                                            \
+				return _to_string_fn((_state_enum_t)i);                            \
+			}                                                                          \
+		}                                                                                  \
+                                                                                                   \
+		return "STATE_UNKNOWN";                                                            \
+	}                                                                                          \
+	APP_INSPECT_MODULE_REGISTER(_name, _name##_state_name_get)
+#else
+/* If the inspect shell is not enabled, define empty macros to avoid compilation errors. */
+#define APP_INSPECT_MODULE_REGISTER(_name, _get_state_name_fn)
+#define APP_INSPECT_MODULE_REGISTER_STATE(_name, _state_ctx_ptr, _states, _state_enum_t,           \
+					  _to_string_fn)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _APP_INSPECT_H_ */

app/src/inspect/inspect_sections.ld

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2026 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+ITERABLE_SECTION_ROM(app_inspect_provider, Z_LINK_ITERABLE_SUBALIGN)

app/src/inspect/inspect_shell.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/shell/shell.h>
+#include <zephyr/sys/iterable_sections.h>
+
+#include <errno.h>
+#include <strings.h>
+
+#include "app_inspect.h"
+
+/**
+ * @brief Format string for printing module state in inspect shell.
+ */
+#define INSPECT_PRINT_FMT "%-14s | %s"
+
+static int cmd_att_inspect(const struct shell *sh, size_t argc, char **argv)
+{
+	STRUCT_SECTION_FOREACH(app_inspect_provider, provider) {
+		const char *state_name = "STATE_UNKNOWN";
+
+		if ((provider->get_state_name != NULL)) {
+			state_name = provider->get_state_name();
+		}
+
+		shell_print(sh, INSPECT_PRINT_FMT, provider->name, state_name);
+	}
+
+	return 0;
+}
+
+SHELL_CMD_REGISTER(att_inspect, NULL, "Inspect module SMF states: att_inspect", cmd_att_inspect);

app/src/main.c

@@ -13,6 +13,9 @@
 #include <zephyr/sys/reboot.h>
 
 #include "app_common.h"
+#ifdef CONFIG_APP_INSPECT_SHELL
+#include "app_inspect.h"
+#endif /* CONFIG_APP_INSPECT_SHELL */
 #include "button.h"
 #include "modules/button/button.h"
 #include "modules/storage/storage.h"
@@ -380,6 +383,54 @@ static const struct smf_state states[] = {
 	),
 };
 
+#if defined(CONFIG_APP_INSPECT_SHELL)
+static struct main_state *main_state_ctx;
+
+static const char *main_state_to_string(enum app_state state)
+{
+	switch (state) {
+	case STATE_WAITING_FOR_MODULES_INIT:
+		return "STATE_WAITING_FOR_MODULES_INIT";
+	case STATE_RUNNING:
+		return "STATE_RUNNING";
+	case STATE_DISCONNECTED:
+		return "STATE_DISCONNECTED";
+	case STATE_DISCONNECTED_SAMPLING:
+		return "STATE_DISCONNECTED_SAMPLING";
+	case STATE_DISCONNECTED_WAITING:
+		return "STATE_DISCONNECTED_WAITING";
+	case STATE_CONNECTED:
+		return "STATE_CONNECTED";
+	case STATE_CONNECTED_SAMPLING:
+		return "STATE_CONNECTED_SAMPLING";
+	case STATE_CONNECTED_WAITING:
+		return "STATE_CONNECTED_WAITING";
+	case STATE_CONNECTED_SENDING:
+		return "STATE_CONNECTED_SENDING";
+	case STATE_FOTA:
+		return "STATE_FOTA";
+	case STATE_FOTA_DOWNLOADING:
+		return "STATE_FOTA_DOWNLOADING";
+	case STATE_FOTA_WAITING_FOR_NETWORK_DISCONNECT:
+		return "STATE_FOTA_WAITING_FOR_NETWORK_DISCONNECT";
+	case STATE_FOTA_WAITING_FOR_NETWORK_DISCONNECT_TO_APPLY_IMAGE:
+		return "STATE_FOTA_WAITING_FOR_NETWORK_DISCONNECT_TO_APPLY_IMAGE";
+	case STATE_FOTA_APPLYING_IMAGE:
+		return "STATE_FOTA_APPLYING_IMAGE";
+	case STATE_FOTA_REBOOTING:
+		return "STATE_FOTA_REBOOTING";
+	default:
+		return "STATE_UNKNOWN";
+	}
+}
+
+APP_INSPECT_MODULE_REGISTER_STATE(main,
+				  main_state_ctx,
+				  states,
+				  enum app_state,
+				  main_state_to_string);
+#endif /* CONFIG_APP_INSPECT_SHELL */
+
 /* Static helper function */
 
 static void task_wdt_callback(int channel_id, void *user_data)
@@ -1760,6 +1811,10 @@ int main(void)
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 	static struct main_state main_state;
 
+#if defined(CONFIG_APP_INSPECT_SHELL)
+	main_state_ctx = &main_state;
+#endif /* CONFIG_APP_INSPECT_SHELL */
+
 	main_state.sample_interval_sec = CONFIG_APP_SAMPLING_INTERVAL_SECONDS;
 	main_state.update_interval_sec = CONFIG_APP_CLOUD_UPDATE_INTERVAL_SECONDS;
 	main_state.storage_threshold = CONFIG_APP_STORAGE_INITIAL_THRESHOLD;

app/src/modules/cloud/cloud.c

@@ -24,6 +24,9 @@
 #endif /* CONFIG_MEMFAULT */
 
 #include "app_common.h"
+#ifdef CONFIG_APP_INSPECT_SHELL
+#include "app_inspect.h"
+#endif /* CONFIG_APP_INSPECT_SHELL */
 #include "cloud.h"
 #include "cloud_internal.h"
 #include "cloud_configuration.h"
@@ -239,6 +242,41 @@ static const struct smf_state states[] = {
 				 NULL),
 };
 
+#if defined(CONFIG_APP_INSPECT_SHELL)
+static struct cloud_state_object *cloud_state_ctx;
+
+static const char *cloud_state_to_string(enum cloud_module_state state)
+{
+	switch (state) {
+	case STATE_RUNNING:
+		return "STATE_RUNNING";
+	case STATE_DISCONNECTED:
+		return "STATE_DISCONNECTED";
+	case STATE_CONNECTING:
+		return "STATE_CONNECTING";
+	case STATE_CONNECTING_ATTEMPT:
+		return "STATE_CONNECTING_ATTEMPT";
+	case STATE_PROVISIONED:
+		return "STATE_PROVISIONED";
+	case STATE_PROVISIONING:
+		return "STATE_PROVISIONING";
+	case STATE_CONNECTING_BACKOFF:
+		return "STATE_CONNECTING_BACKOFF";
+	case STATE_CONNECTED:
+		return "STATE_CONNECTED";
+	case STATE_CONNECTED_READY:
+		return "STATE_CONNECTED_READY";
+	case STATE_CONNECTED_PAUSED:
+		return "STATE_CONNECTED_PAUSED";
+	default:
+		return "STATE_UNKNOWN";
+	}
+}
+
+APP_INSPECT_MODULE_REGISTER_STATE(cloud, cloud_state_ctx, states,
+					  enum cloud_module_state, cloud_state_to_string);
+#endif /* CONFIG_APP_INSPECT_SHELL */
+
 static void cloud_wdt_callback(int channel_id, void *user_data)
 {
 	LOG_ERR("Watchdog expired, Channel: %d, Thread: %s",
@@ -1274,6 +1312,10 @@ static void cloud_module_thread(void)
 	const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
 	static struct cloud_state_object cloud_state;
 
+#if defined(CONFIG_APP_INSPECT_SHELL)
+	cloud_state_ctx = &cloud_state;
+#endif /* CONFIG_APP_INSPECT_SHELL */
+
 	LOG_DBG("Cloud module task started");
 
 	task_wdt_id = task_wdt_add(wdt_timeout_ms, cloud_wdt_callback, (void *)k_current_get());

app/src/modules/environmental/environmental.c

@@ -13,6 +13,9 @@
 #include <date_time.h>
 
 #include "app_common.h"
+#ifdef CONFIG_APP_INSPECT_SHELL
+#include "app_inspect.h"
+#endif /* CONFIG_APP_INSPECT_SHELL */
 #include "environmental.h"
 
 /* Register log module */
@@ -78,6 +81,26 @@ static const struct smf_state states[] = {
 	[STATE_RUNNING] = SMF_CREATE_STATE(NULL, state_running_run, NULL, NULL, NULL),
 };
 
+#if defined(CONFIG_APP_INSPECT_SHELL)
+static struct environmental_state_object *environmental_state_ctx;
+
+static const char *environmental_state_to_string(enum environmental_module_state state)
+{
+	switch (state) {
+	case STATE_RUNNING:
+		return "STATE_RUNNING";
+	default:
+		return "STATE_UNKNOWN";
+	}
+}
+
+APP_INSPECT_MODULE_REGISTER_STATE(env,
+				  environmental_state_ctx,
+				  states,
+				  enum environmental_module_state,
+				  environmental_state_to_string);
+#endif /* CONFIG_APP_INSPECT_SHELL */
+
 static void sample_sensors(const struct device *const bme680)
 {
 	int err;
@@ -181,6 +204,10 @@ static void env_module_thread(void)
 		.bme680 = DEVICE_DT_GET(DT_NODELABEL(bme680)),
 	};
 
+#if defined(CONFIG_APP_INSPECT_SHELL)
+	environmental_state_ctx = &environmental_state;
+#endif /* CONFIG_APP_INSPECT_SHELL */
+
 	LOG_DBG("Environmental module task started");
 
 	task_wdt_id = task_wdt_add(wdt_timeout_ms, env_wdt_callback, (void *)k_current_get());