applications: 93m1_at: General cleanup of the 93m1_at application

General cleanup and refactoring of the 93m1_at application.

Signed-off-by: Syver Haraldsen <syver.haraldsen@nordicsemi.no>

Author: SyverHaraldsen

applications/93m1_at/src/main.c

@@ -58,28 +58,43 @@ struct app_object {
 	uint8_t msg_buf[MAX_MSG_SIZE];
 };
 
-static struct app_object app;
-static const struct smf_state states[];
+static void sync_timer_fn(struct k_work *work);
+static K_WORK_DELAYABLE_DEFINE(sync_timer, sync_timer_fn);
+
+static void request_module_updates(void);
+static enum smf_state_result disconnected_run(void *obj);
+static void connected_entry(void *obj);
+static enum smf_state_result connected_run(void *obj);
+static void connected_exit(void *obj);
+static void wdt_callback(int channel_id, void *user_data);
+
+static const struct smf_state states[] = {
+	[STATE_DISCONNECTED] = SMF_CREATE_STATE(NULL, disconnected_run, NULL, NULL, NULL),
+	[STATE_CONNECTED] = SMF_CREATE_STATE(connected_entry, connected_run, connected_exit,
+					     NULL, NULL),
+};
 
-/* Periodic sync trigger: publishes MAIN_SYNC; the state machine drives it. */
 static void sync_timer_fn(struct k_work *work)
 {
 	ARG_UNUSED(work);
+
 	struct main_msg msg = { .type = MAIN_SYNC };
 
 	(void)zbus_chan_pub(&main_chan, &msg, PUB_TIMEOUT);
 }
 
-static K_WORK_DELAYABLE_DEFINE(sync_timer, sync_timer_fn);
-
-static void run_sync(void)
+static void request_module_updates(void)
 {
-	LOG_INF("Sync");
+	LOG_DBG("Requesting module updates");
 #if defined(CONFIG_APP_LOCATION)
-	location_update();
+	struct location_msg loc_msg = { .type = LOCATION_FIX_REQUEST };
+
+	(void)zbus_chan_pub(&location_chan, &loc_msg, PUB_TIMEOUT);
 #endif
 #if defined(CONFIG_APP_BATTERY)
-	(void)battery_report();
+	struct battery_msg bat_msg = { .type = BATTERY_SAMPLE };
+
+	(void)zbus_chan_pub(&battery_chan, &bat_msg, PUB_TIMEOUT);
 #endif
 }
 
@@ -103,7 +118,6 @@ static void connected_entry(void *obj)
 	ARG_UNUSED(obj);
 	LOG_INF("Connected");
 
-	/* First sync shortly after connecting. */
 	(void)k_work_reschedule(&sync_timer, K_SECONDS(CONFIG_APP_SYNC_BOOT_DELAY_SECONDS));
 }
 
@@ -121,8 +135,9 @@ static enum smf_state_result connected_run(void *obj)
 		const struct main_msg *msg = (const struct main_msg *)state->msg_buf;
 
 		if (msg->type == MAIN_SYNC) {
-			run_sync();
-			(void)k_work_reschedule(&sync_timer, K_SECONDS(CONFIG_APP_SYNC_INTERVAL));
+			request_module_updates();
+			(void)k_work_reschedule(&sync_timer,
+						K_SECONDS(CONFIG_APP_SYNC_INTERVAL));
 		}
 	}
 
@@ -135,12 +150,6 @@ static void connected_exit(void *obj)
 	(void)k_work_cancel_delayable(&sync_timer);
 }
 
-static const struct smf_state states[] = {
-	[STATE_DISCONNECTED] = SMF_CREATE_STATE(NULL, disconnected_run, NULL, NULL, NULL),
-	[STATE_CONNECTED] = SMF_CREATE_STATE(connected_entry, connected_run, connected_exit,
-					     NULL, NULL),
-};
-
 static void wdt_callback(int channel_id, void *user_data)
 {
 	LOG_ERR("Main watchdog expired, channel: %d, thread: %s",
@@ -158,6 +167,7 @@ int main(void)
 	const uint32_t execution_time_ms =
 		(CONFIG_APP_MAIN_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
 	const k_timeout_t zbus_wait = K_MSEC(wdt_timeout_ms - execution_time_ms);
+	static struct app_object app;
 
 	task_wdt_id = task_wdt_add(wdt_timeout_ms, wdt_callback, (void *)k_current_get());
 	if (task_wdt_id < 0) {

applications/93m1_at/src/modules/battery/Kconfig.battery

@@ -15,6 +15,10 @@ menuconfig APP_BATTERY
 
 if APP_BATTERY
 
+config APP_BATTERY_THREAD_STACK_SIZE
+	int "Battery thread stack size (bytes)"
+	default 2048
+
 config APP_BATTERY_AT_TIMEOUT_SECONDS
 	int "AT%NRFCLOUDMESSAGE timeout (seconds)"
 	default 60

applications/93m1_at/src/modules/battery/battery.c

@@ -7,11 +7,14 @@
 #include <stdio.h>
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
+#include <zephyr/zbus/zbus.h>
 #include <zephyr/drivers/sensor.h>
 #include <zephyr/drivers/sensor/npm13xx_charger.h>
 #include <nrf_fuel_gauge.h>
 
+#include "app_common.h"
 #include "modules/modem_at/modem_at.h"
+#include "modules/network/network.h"
 #include "lp803448_model.h"
 #include "battery.h"
 
@@ -23,14 +26,35 @@ LOG_MODULE_REGISTER(battery, CONFIG_APP_BATTERY_LOG_LEVEL);
 #define CHG_STATUS_CC_MASK       BIT(3)
 #define CHG_STATUS_CV_MASK       BIT(4)
 
-static const struct device *const charger = DEVICE_DT_GET(DT_NODELABEL(npm1300_charger));
+ZBUS_CHAN_DEFINE(battery_chan,
+		 struct battery_msg,
+		 NULL,
+		 NULL,
+		 ZBUS_OBSERVERS_EMPTY,
+		 ZBUS_MSG_INIT(0));
 
-static bool gauge_ready;
-static int64_t ref_time;
-static int32_t prev_chg_status = -1;
+ZBUS_MSG_SUBSCRIBER_DEFINE(battery);
 
-static int read_sensors(float *voltage, float *current, float *temp, int32_t *chg_status,
-			bool *vbus)
+#define CHANNEL_LIST(X)				\
+	X(network_chan, struct network_msg)	\
+	X(battery_chan, struct battery_msg)
+
+#define MAX_MSG_SIZE MAX_MSG_SIZE_FROM_LIST(CHANNEL_LIST)
+
+#define ADD_OBSERVERS(_chan, _type) ZBUS_CHAN_ADD_OBS(_chan, battery, 0);
+
+CHANNEL_LIST(ADD_OBSERVERS)
+
+static int read_sensors(const struct device *charger, float *voltage, float *current,
+			float *temp, int32_t *chg_status, bool *vbus);
+static void update_charge_state(int32_t chg_status, int32_t *prev);
+static int fuel_gauge_setup(const struct device *charger);
+static void battery_sample_and_report(const struct device *charger, int64_t *ref_time,
+				      int32_t *prev_chg_status);
+static void battery_thread(void);
+
+static int read_sensors(const struct device *charger, float *voltage, float *current,
+			float *temp, int32_t *chg_status, bool *vbus)
 {
 	int err;
 	struct sensor_value val = {0};
@@ -59,31 +83,32 @@ static int read_sensors(float *voltage, float *current, float *temp, int32_t *ch
 	/* Fuel gauge wants charge-positive; the sensor API is discharge-negative. */
 	*current = -sensor_value_to_float(&val);
 
-	err = sensor_channel_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_STATUS,
-				 &val);
+	err = sensor_channel_get(charger,
+				 (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_STATUS, &val);
 	if (err) {
 		return err;
 	}
 	*chg_status = val.val1;
 
 	struct sensor_value vbus_val;
 
-	err = sensor_attr_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_VBUS_STATUS,
+	err = sensor_attr_get(charger,
+			      (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_VBUS_STATUS,
 			      (enum sensor_attribute)SENSOR_ATTR_NPM13XX_CHARGER_VBUS_PRESENT,
 			      &vbus_val);
 	*vbus = (err == 0) && (vbus_val.val1 != 0);
 
 	return 0;
 }
 
-static void update_charge_state(int32_t chg_status)
+static void update_charge_state(int32_t chg_status, int32_t *prev)
 {
 	union nrf_fuel_gauge_ext_state_info_data ext;
 
-	if (chg_status == prev_chg_status) {
+	if (chg_status == *prev) {
 		return;
 	}
-	prev_chg_status = chg_status;
+	*prev = chg_status;
 
 	if (chg_status & CHG_STATUS_COMPLETE_MASK) {
 		ext.charge_state = NRF_FUEL_GAUGE_CHARGE_STATE_COMPLETE;
@@ -101,15 +126,15 @@ static void update_charge_state(int32_t chg_status)
 					      &ext);
 }
 
-static int fuel_gauge_setup(void)
+static int fuel_gauge_setup(const struct device *charger)
 {
 	int err;
 	int32_t chg_status;
 	bool vbus;
 	struct nrf_fuel_gauge_init_parameters params = { .model = &battery_model };
 	float soc;
 
-	err = read_sensors(&params.v0, &params.i0, &params.t0, &chg_status, &vbus);
+	err = read_sensors(charger, &params.v0, &params.i0, &params.t0, &chg_status, &vbus);
 	if (err) {
 		return err;
 	}
@@ -124,67 +149,87 @@ static int fuel_gauge_setup(void)
 	return 0;
 }
 
-/* Sample the gauge and return state of charge in percent, or -1 on error. */
-static int sample_soc(void)
+static void battery_sample_and_report(const struct device *charger, int64_t *ref_time,
+				      int32_t *prev_chg_status)
 {
 	float voltage;
 	float current;
 	float temp;
 	float soc;
 	int32_t chg_status;
 	bool vbus;
+	char cmd[64];
+	int err;
 
-	if (read_sensors(&voltage, &current, &temp, &chg_status, &vbus)) {
-		return -1;
+	err = read_sensors(charger, &voltage, &current, &temp, &chg_status, &vbus);
+	if (err) {
+		LOG_WRN("read_sensors, error: %d", err);
+		return;
 	}
 
 	(void)nrf_fuel_gauge_ext_state_update(
 		vbus ? NRF_FUEL_GAUGE_EXT_STATE_INFO_VBUS_CONNECTED
 		     : NRF_FUEL_GAUGE_EXT_STATE_INFO_VBUS_DISCONNECTED, NULL);
-	update_charge_state(chg_status);
+	update_charge_state(chg_status, prev_chg_status);
 
-	float delta = (float)k_uptime_delta(&ref_time) / 1000.0f;
+	float delta = (float)k_uptime_delta(ref_time) / 1000.0f;
 
-	if (nrf_fuel_gauge_process(voltage, current, temp, delta, &soc, NULL)) {
-		return -1;
+	err = nrf_fuel_gauge_process(voltage, current, temp, delta, &soc, NULL);
+	if (err) {
+		LOG_WRN("nrf_fuel_gauge_process, error: %d", err);
+		return;
+	}
+
+	(void)snprintf(cmd, sizeof(cmd),
+		       "AT%%NRFCLOUDMESSAGE={\"appId\":\"BATTERY\",\"data\":\"%d\"}", (int)soc);
+
+	err = modem_at_run(cmd, NULL, 0, CONFIG_APP_BATTERY_AT_TIMEOUT_SECONDS);
+	if (err) {
+		LOG_WRN("Battery cloud message failed: %d", err);
+		return;
 	}
 
-	return (int)soc;
+	LOG_INF("Battery %d%% sent to nRF Cloud", (int)soc);
 }
 
-int battery_report(void)
+static void battery_thread(void)
 {
-	char cmd[64];
-	int soc;
 	int err;
-
-	if (!gauge_ready) {
-		if (!device_is_ready(charger)) {
-			LOG_ERR("Charger device not ready");
-			return -ENODEV;
-		}
-		if (fuel_gauge_setup()) {
-			LOG_ERR("Fuel gauge init failed");
-			return -EIO;
-		}
-		ref_time = k_uptime_get();
-		gauge_ready = true;
+	const struct zbus_channel *chan;
+	uint8_t msg_buf[MAX_MSG_SIZE];
+	int64_t ref_time;
+	int32_t prev_chg_status = -1;
+	bool connected = false;
+	const struct device *const charger = DEVICE_DT_GET(DT_NODELABEL(npm1300_charger));
+
+	if (!device_is_ready(charger)) {
+		LOG_ERR("Charger device not ready");
+		return;
 	}
 
-	soc = sample_soc();
-	if (soc < 0) {
-		return -EIO;
+	err = fuel_gauge_setup(charger);
+	if (err) {
+		LOG_ERR("fuel_gauge_setup, error: %d", err);
+		return;
 	}
+	ref_time = k_uptime_get();
 
-	(void)snprintf(cmd, sizeof(cmd),
-		       "AT%%NRFCLOUDMESSAGE={\"appId\":\"BATTERY\",\"data\":\"%d\"}", soc);
+	while (true) {
+		err = zbus_sub_wait_msg(&battery, &chan, msg_buf, K_FOREVER);
+		if (err) {
+			LOG_ERR("zbus_sub_wait_msg, error: %d", err);
+			return;
+		}
 
-	err = modem_at_run(cmd, NULL, 0, CONFIG_APP_BATTERY_AT_TIMEOUT_SECONDS);
-	if (err) {
-		LOG_WRN("Battery cloud message failed: %d", err);
-		return err;
-	}
+		if (chan == &network_chan) {
+			const struct network_msg *msg = (const struct network_msg *)msg_buf;
 
-	LOG_INF("Battery %d%% sent to nRF Cloud", soc);
-	return 0;
+			connected = (msg->type == NETWORK_CONNECTED);
+		} else if (chan == &battery_chan && connected) {
+			battery_sample_and_report(charger, &ref_time, &prev_chg_status);
+		}
+	}
 }
+
+K_THREAD_DEFINE(battery_tid, CONFIG_APP_BATTERY_THREAD_STACK_SIZE, battery_thread,
+		NULL, NULL, NULL, K_LOWEST_APPLICATION_THREAD_PRIO, 0, 0);

applications/93m1_at/src/modules/battery/battery.h

@@ -7,19 +7,21 @@
 #ifndef BATTERY_H_
 #define BATTERY_H_
 
+#include <zephyr/zbus/zbus.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/**
- * @brief Sample the fuel gauge and report state of charge to nRF Cloud.
- *
- * Reads the nPM1300 fuel gauge and sends the state of charge as an
- * AT%NRFCLOUDMESSAGE (appId "BATTERY"). Called by the sync state machine.
- *
- * @retval 0 on success, negative errno otherwise.
- */
-int battery_report(void);
+enum battery_msg_type {
+	BATTERY_SAMPLE,
+};
+
+struct battery_msg {
+	enum battery_msg_type type;
+};
+
+ZBUS_CHAN_DECLARE(battery_chan);
 
 #ifdef __cplusplus
 }

applications/93m1_at/src/modules/cloud/cloud.c

@@ -13,7 +13,7 @@
 
 LOG_MODULE_REGISTER(cloud, CONFIG_APP_CLOUD_LOG_LEVEL);
 
-static int extract(const char *resp, const char *prefix, char *out, size_t out_size)
+static int parse_resp_field(const char *resp, const char *prefix, char *out, size_t out_size)
 {
 	const char *p = strstr(resp, prefix);
 
@@ -40,7 +40,7 @@ void cloud_provision(void)
 	char uuid[40];
 
 	if (modem_at_run("AT%DEVICEUUID", resp, sizeof(resp), 10) == 0 &&
-	    extract(resp, "%DEVICEUUID: ", uuid, sizeof(uuid)) == 0) {
+	    parse_resp_field(resp, "%DEVICEUUID: ", uuid, sizeof(uuid)) == 0) {
 		LOG_INF("Device UUID: %s", uuid);
 	} else {
 		LOG_ERR("Failed to read device UUID");