modules: battery: Add battery percentage request/response events

- Add battery percentage request/response events
- Send battery percentage to the transport module
- Forward battery percentage to nRF Cloud
- Add test for battery module
- Update test for trigger module to handle the new battery percentage
  sample event

Signed-off-by: Simen S. Røstad <simen.rostad@nordicsemi.no>

Author: simensrostad

app/src/common/message_channel.c

@@ -50,6 +50,14 @@ ZBUS_CHAN_DEFINE(NETWORK_CHAN,
 		 ZBUS_MSG_INIT(.type = NETWORK_DISCONNECTED)
 );
 
+ZBUS_CHAN_DEFINE(BATTERY_CHAN,
+		 struct battery_msg,
+		 NULL,
+		 NULL,
+		 ZBUS_OBSERVERS_EMPTY,
+		 ZBUS_MSG_INIT(0)
+);
+
 ZBUS_CHAN_DEFINE(ERROR_CHAN,
 		 enum error_type,
 		 NULL,

app/src/common/message_channel.h

@@ -53,6 +53,8 @@ struct payload {
 
 #define MSG_TO_PAYLOAD(_msg) ((struct payload *)_msg)
 
+/** NETWORK_MODULE */
+
 enum network_msg_type {
 	/* Output message types */
 
@@ -178,6 +180,33 @@ struct network_msg {
 
 #define MSG_TO_NETWORK_MSG(_msg)	(*(const struct network_msg *)_msg)
 
+/** BATTERY MODULE */
+
+enum battery_msg_type {
+	/* Output message types */
+
+	/* Response message to a request for a battery percentage sample. The sample is found in the
+	 * .percentage field of the message.
+	 */
+	BATTERY_PERCENTAGE_SAMPLE_RESPONSE = 0x1,
+
+	/* Input message types */
+
+	/* Request to retrieve the current battery percentage. The response is sent as a
+	 * BATTERY_PERCENTAGE_SAMPLE_RESPONSE message.
+	 */
+	BATTERY_PERCENTAGE_SAMPLE_REQUEST,
+};
+
+struct battery_msg {
+	enum battery_msg_type type;
+
+	/** Contains the current charge of the battery in percentage. */
+	double percentage;
+};
+
+#define MSG_TO_BATTERY_MSG(_msg)	(*(const struct battery_msg *)_msg)
+
 enum cloud_status {
 	CLOUD_DISCONNECTED = 0x1,
 	CLOUD_CONNECTED_READY_TO_SEND,
@@ -263,6 +292,7 @@ ZBUS_CHAN_DECLARE(
 	FOTA_STATUS_CHAN,
 	LED_CHAN,
 	NETWORK_CHAN,
+	BATTERY_CHAN,
 	PAYLOAD_CHAN,
 	TIME_CHAN,
 	TRIGGER_CHAN,

app/src/modules/battery/battery.c

@@ -26,17 +26,13 @@ LOG_MODULE_REGISTER(battery, CONFIG_APP_BATTERY_LOG_LEVEL);
 ZBUS_MSG_SUBSCRIBER_DEFINE(battery);
 
 /* Observe channels */
-ZBUS_CHAN_ADD_OBS(TRIGGER_CHAN, battery, 0);
-ZBUS_CHAN_ADD_OBS(NETWORK_CHAN, battery, 0);
-ZBUS_CHAN_ADD_OBS(TIME_CHAN, battery, 0);
+ZBUS_CHAN_ADD_OBS(BATTERY_CHAN, battery, 0);
 
-#define MAX_MSG_SIZE \
-	(MAX(sizeof(enum trigger_type), \
-		(MAX(sizeof(struct network_msg), sizeof(enum time_status)))))
+#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_EXEC_TIME_SECONDS_MAX,
+	     "Watchdog timeout must be greater than maximum execution time");
 
 /* nPM1300 register bitmasks */
 
@@ -50,20 +46,17 @@ BUILD_ASSERT(CONFIG_APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS >
 static const struct device *charger = DEVICE_DT_GET(DT_NODELABEL(npm1300_charger));
 
 /* Forward declarations */
-static struct s_object s_obj;
 static int charger_read_sensors(float *voltage, float *current, float *temp, int32_t *chg_status);
 static void sample(int64_t *ref_time);
 
 /* State machine */
 
 /* Defininig the module states.
  *
- * STATE_INIT: The battery module is initializing and waiting for time to be available.
- * STATE_SAMPLING: The battery module is ready to sample upon receiving a trigger.
+ * STATE_RUNNING: The battery module is initializing and waiting battery percentage to be requested.
  */
 enum battery_module_state {
-	STATE_INIT,
-	STATE_SAMPLING,
+	STATE_RUNNING,
 };
 
 /* User defined state object.
@@ -84,25 +77,18 @@ struct s_object {
 };
 
 /* Forward declarations of state handlers */
-static void state_init_entry(void *o);
-static void state_init_run(void *o);
-static void state_sampling_run(void *o);
+static void state_running_entry(void *o);
+static void state_running_run(void *o);
 
 static struct s_object battery_state_object;
 static const struct smf_state states[] = {
-	[STATE_INIT] =
-		SMF_CREATE_STATE(state_init_entry, state_init_run, NULL,
-				 NULL,	/* No parent state */
-				 NULL), /* No initial transition */
-	[STATE_SAMPLING] =
-		SMF_CREATE_STATE(NULL, state_sampling_run, NULL,
-				 NULL,
-				 NULL),
+	[STATE_RUNNING] =
+		SMF_CREATE_STATE(state_running_entry, state_running_run, NULL, NULL, NULL),
 };
 
 /* State handlers */
 
-static void state_init_entry(void *o)
+static void state_running_entry(void *o)
 {
 	int err;
 	struct sensor_value value;
@@ -142,30 +128,15 @@ static void state_init_entry(void *o)
 	}
 }
 
-static void state_init_run(void *o)
+static void state_running_run(void *o)
 {
 	struct s_object *state_object = o;
 
-	if (&TIME_CHAN == state_object->chan) {
-		enum time_status time_status = MSG_TO_TIME_STATUS(state_object->msg_buf);
+	if (&BATTERY_CHAN == state_object->chan) {
+		struct battery_msg msg = MSG_TO_BATTERY_MSG(state_object->msg_buf);
 
-		if (time_status == TIME_AVAILABLE) {
-			LOG_DBG("Time available, sampling can start");
-
-			STATE_SET(battery_state_object, STATE_SAMPLING);
-		}
-	}
-}
-
-static void state_sampling_run(void *o)
-{
-	struct s_object *state_object = o;
-
-	if (&TRIGGER_CHAN == state_object->chan) {
-		enum trigger_type trigger_type = MSG_TO_TRIGGER_TYPE(state_object->msg_buf);
-
-		if (trigger_type == TRIGGER_DATA_SAMPLE) {
-			LOG_DBG("Data sample trigger received, getting battery data");
+		if (msg.type == BATTERY_PERCENTAGE_SAMPLE_REQUEST) {
+			LOG_DBG("Battery percentage sample request received, getting battery data");
 			sample(&state_object->fuel_gauge_ref_time);
 		}
 	}
@@ -209,13 +180,6 @@ static void sample(int64_t *ref_time)
 	float temp;
 	float state_of_charge;
 	float delta;
-	int64_t system_time;
-
-	err = date_time_now(&system_time);
-	if (err) {
-		LOG_ERR("Failed to convert uptime to unix time, error: %d", err);
-		return;
-	}
 
 	err = charger_read_sensors(&voltage, &current, &temp, &chg_status);
 	if (err) {
@@ -235,7 +199,17 @@ static void sample(int64_t *ref_time)
 	LOG_DBG("State of charge: %f", (double)roundf(state_of_charge));
 	LOG_DBG("The battery is %s", charging ? "charging" : "not charging");
 
-	/* No further use of the battery data is implemented */
+	struct battery_msg msg = {
+		.type = BATTERY_PERCENTAGE_SAMPLE_RESPONSE,
+		.percentage = (double)roundf(state_of_charge)
+	};
+
+	err = zbus_chan_pub(&BATTERY_CHAN, &msg, K_NO_WAIT);
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+		return;
+	}
 }
 
 static void task_wdt_callback(int channel_id, void *user_data)
@@ -258,7 +232,7 @@ static void battery_task(void)
 
 	task_wdt_id = task_wdt_add(wdt_timeout_ms, task_wdt_callback, (void *)k_current_get());
 
-	STATE_SET_INITIAL(battery_state_object, STATE_INIT);
+	STATE_SET_INITIAL(battery_state_object, STATE_RUNNING);
 
 	while (true) {
 		err = task_wdt_feed(task_wdt_id);
@@ -268,7 +242,10 @@ static void battery_task(void)
 			return;
 		}
 
-		err = zbus_sub_wait_msg(&battery, &s_obj.chan, s_obj.msg_buf, zbus_wait_ms);
+		err = zbus_sub_wait_msg(&battery,
+					&battery_state_object.chan,
+					battery_state_object.msg_buf,
+					zbus_wait_ms);
 		if (err == -ENOMSG) {
 			continue;
 		} else if (err) {

app/src/modules/transport/transport.c

@@ -19,6 +19,8 @@
 /* Register log module */
 LOG_MODULE_REGISTER(transport, CONFIG_APP_TRANSPORT_LOG_LEVEL);
 
+#define CUSTOM_JSON_APPID_VAL_CONEVAL "CONEVAL"
+#define CUSTOM_JSON_APPID_VAL_BATTERY "BATTERY"
 
 BUILD_ASSERT(CONFIG_APP_TRANSPORT_WATCHDOG_TIMEOUT_SECONDS >
 			 CONFIG_APP_TRANSPORT_EXEC_TIME_SECONDS_MAX,
@@ -30,8 +32,9 @@ ZBUS_MSG_SUBSCRIBER_DEFINE(transport);
 /* Observe channels */
 ZBUS_CHAN_ADD_OBS(PAYLOAD_CHAN, transport, 0);
 ZBUS_CHAN_ADD_OBS(NETWORK_CHAN, transport, 0);
+ZBUS_CHAN_ADD_OBS(BATTERY_CHAN, transport, 0);
 
-#define MAX_MSG_SIZE (MAX(sizeof(struct payload), sizeof(struct network_msg)))
+#define MAX_MSG_SIZE (MAX(sizeof(struct payload), MAX(sizeof(struct network_msg), sizeof(struct battery_msg))))
 
 /* Enumerator to be used in privat transport channel */
 enum priv_transport_evt {
@@ -366,7 +369,6 @@ static void state_connected_ready_run(void *o)
 {
 	int err;
 	struct state_object *state_object = o;
-	struct network_msg msg = MSG_TO_NETWORK_MSG(state_object->msg_buf);
 
 	LOG_DBG("%s", __func__);
 
@@ -382,6 +384,9 @@ static void state_connected_ready_run(void *o)
 	}
 
 	if (state_object->chan == &NETWORK_CHAN) {
+
+		struct network_msg msg = MSG_TO_NETWORK_MSG(state_object->msg_buf);
+
 		if (msg.type == NETWORK_DISCONNECTED) {
 			STATE_SET(transport_state, STATE_CONNECTED_PAUSED);
 
@@ -396,7 +401,34 @@ static void state_connected_ready_run(void *o)
 
 		if (msg.type == NETWORK_QUALITY_SAMPLE_RESPONSE) {
 
-			err = nrf_cloud_coap_sensor_send("RSRP", msg.conn_eval_params.rsrp,
+			err = nrf_cloud_coap_sensor_send(CUSTOM_JSON_APPID_VAL_CONEVAL,
+							 msg.conn_eval_params.energy_estimate,
+							 NRF_CLOUD_NO_TIMESTAMP, true);
+			if (err) {
+				LOG_ERR("nrf_cloud_coap_sensor_send, error: %d", err);
+				SEND_FATAL_ERROR();
+			}
+
+			err = nrf_cloud_coap_sensor_send(NRF_CLOUD_JSON_APPID_VAL_RSRP,
+							 msg.conn_eval_params.rsrp,
+							 NRF_CLOUD_NO_TIMESTAMP, true);
+			if (err) {
+				LOG_ERR("nrf_cloud_coap_sensor_send, error: %d", err);
+				SEND_FATAL_ERROR();
+			}
+
+			return;
+		}
+	}
+
+	if (state_object->chan == &BATTERY_CHAN) {
+
+		struct battery_msg msg = MSG_TO_BATTERY_MSG(state_object->msg_buf);
+
+		if (msg.type == BATTERY_PERCENTAGE_SAMPLE_RESPONSE) {
+
+			err = nrf_cloud_coap_sensor_send(CUSTOM_JSON_APPID_VAL_BATTERY,
+							 msg.percentage,
 							 NRF_CLOUD_NO_TIMESTAMP, true);
 			if (err) {
 				LOG_ERR("nrf_cloud_coap_sensor_send, error: %d", err);
@@ -405,6 +437,7 @@ static void state_connected_ready_run(void *o)
 
 			return;
 		}
+
 	}
 }
 

app/src/modules/trigger/trigger.c

@@ -62,12 +62,22 @@ static struct state_object trigger_state;
 
 static void trigger_send(void)
 {
+	int err;
 	struct network_msg network_msg = {
 		.type = NETWORK_QUALITY_SAMPLE_REQUEST,
 	};
+	struct battery_msg battery_msg = {
+		.type = BATTERY_PERCENTAGE_SAMPLE_REQUEST,
+	};
 
-	int err = zbus_chan_pub(&NETWORK_CHAN, &network_msg, K_SECONDS(1));
+	err = zbus_chan_pub(&NETWORK_CHAN, &network_msg, K_SECONDS(1));
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+		return;
+	}
 
+	err = zbus_chan_pub(&BATTERY_CHAN, &battery_msg, K_SECONDS(1));
 	if (err) {
 		LOG_ERR("zbus_chan_pub, error: %d", err);
 		SEND_FATAL_ERROR();

tests/module/battery/CMakeLists.txt

@@ -0,0 +1,41 @@
+#
+# Copyright (c) 2024 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(battery_module_test)
+
+test_runner_generate(src/main.c)
+
+set(ASSET_TRACKER_TEMPLATE_DIR ../../..)
+
+target_sources(app
+  PRIVATE
+  src/main.c
+  src/redef.c
+  ${ASSET_TRACKER_TEMPLATE_DIR}/app/src/modules/battery/battery.c
+  ${ASSET_TRACKER_TEMPLATE_DIR}/app/src/common/message_channel.c
+)
+
+target_include_directories(app PRIVATE src)
+
+zephyr_include_directories(${ZEPHYR_BASE}/include/zephyr/)
+zephyr_include_directories(${ZEPHYR_NRFXLIB_MODULE_DIR}/nrf_fuel_gauge/include/)
+zephyr_include_directories(${ZEPHYR_BASE}/subsys/testsuite/include)
+zephyr_include_directories(${ASSET_TRACKER_TEMPLATE_DIR}/app/src/common)
+
+# Options that cannot be passed through Kconfig fragments
+target_compile_definitions(app PRIVATE
+	-DCONFIG_APP_BATTERY_LOG_LEVEL=4
+	-DCONFIG_APP_BATTERY_THREAD_STACK_SIZE=4096
+	-DCONFIG_APP_PAYLOAD_CHANNEL_BUFFER_MAX_SIZE=100
+  -DCONFIG_APP_BATTERY_EXEC_TIME_SECONDS_MAX=3
+  -DCONFIG_APP_BATTERY_WATCHDOG_TIMEOUT_SECONDS=120
+)
+
+set_property(SOURCE ${ASSET_TRACKER_TEMPLATE_DIR}/app/src/modules/battery/battery.c PROPERTY COMPILE_FLAGS
+             "-include ${CMAKE_CURRENT_SOURCE_DIR}/src/redef.h")