tests: task_runner: tasks: env: added

drivers/imu/lsm6dsv/Kconfig

@@ -14,6 +14,10 @@ menuconfig INFUSE_IMU_LSM6DSV
 
 if INFUSE_IMU_LSM6DSV
 
+# Zephyr and Infuse driver conflict
+configdefault LSM6DSV16X
+	default n
+
 config LSM6DSV_BUS_I2C
 	bool
 	default y

drivers/sensor/CMakeLists.txt

@@ -3,3 +3,4 @@
 zephyr_sources_ifdef(CONFIG_BQ25798 bq25798.c)
 zephyr_sources_ifdef(CONFIG_NRF9X_TEMP nrf9x_temp.c)
 zephyr_sources_ifdef(CONFIG_NRF9X_BATT nrf9x_batt.c)
+zephyr_sources_ifdef(CONFIG_SENSOR_GENERIC_SIM generic_sim.c)

drivers/sensor/Kconfig

@@ -35,3 +35,11 @@ config BQ25798_FETCH_POOR_SOURCE_RETRY
 	   source qualification if the charger is in poor source mode.
 
 endif
+
+config SENSOR_GENERIC_SIM
+	bool "Generic simulated sensor"
+	depends on DT_HAS_ZEPHYR_GENERIC_SIM_SENSOR_ENABLED
+	depends on SENSOR
+	default y
+	help
+	  Simulated sensor that can expose any configured channel.

drivers/sensor/generic_sim.c

@@ -0,0 +1,95 @@
+/**
+ * @file
+ * @copyright 2025 Embeint Holdings Pty Ltd
+ * @author Jordan Yates <[email protected]>
+ *
+ * SPDX-License-Identifier: FSL-1.1-ALv2
+ */
+
+#define DT_DRV_COMPAT zephyr_generic_sim_sensor
+
+#include <zephyr/device.h>
+#include <zephyr/devicetree.h>
+#include <zephyr/drivers/sensor.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/sys/atomic.h>
+
+#include <infuse/drivers/sensor/generic_sim.h>
+
+struct generic_sim_data {
+	struct sensor_value channel_values[SENSOR_CHAN_ALL];
+	ATOMIC_DEFINE(channels_set, SENSOR_CHAN_ALL);
+};
+
+struct generic_sim_cfg {
+	int init_rc;
+};
+
+LOG_MODULE_DECLARE(GENERIC_SIM, CONFIG_SENSOR_LOG_LEVEL);
+
+void generic_sim_reset(const struct device *dev)
+{
+	struct generic_sim_data *data = dev->data;
+
+	memset(data->channels_set, 0, sizeof(data->channels_set));
+}
+
+int generic_sim_channel_set(const struct device *dev, enum sensor_channel chan,
+			    struct sensor_value val)
+{
+	struct generic_sim_data *data = dev->data;
+
+	if (chan >= SENSOR_CHAN_ALL) {
+		return -EINVAL;
+	}
+
+	atomic_set_bit(data->channels_set, chan);
+	data->channel_values[chan] = val;
+	return 0;
+}
+
+static int generic_sim_sample_fetch(const struct device *dev, enum sensor_channel chan)
+{
+	return 0;
+}
+
+static int generic_sim_channel_get(const struct device *dev, enum sensor_channel chan,
+				   struct sensor_value *val)
+{
+	struct generic_sim_data *data = dev->data;
+
+	if (chan >= SENSOR_CHAN_ALL) {
+		return -ENOTSUP;
+	}
+
+	if (!atomic_test_bit(data->channels_set, chan)) {
+		/* Channel that hasn't been configured */
+		return -ENOTSUP;
+	}
+
+	*val = data->channel_values[chan];
+	return 0;
+}
+
+static const struct sensor_driver_api generic_sim_driver_api = {
+	.sample_fetch = generic_sim_sample_fetch,
+	.channel_get = generic_sim_channel_get,
+};
+
+int generic_sim_init(const struct device *dev)
+{
+	const struct generic_sim_cfg *cfg = dev->config;
+
+	return cfg->init_rc;
+}
+
+#define GENERIC_SIM_DEFINE(inst)                                                                   \
+	static const struct generic_sim_cfg generic_sim_cfg_##inst = {                             \
+		.init_rc = -DT_INST_PROP(inst, negated_init_rc),                                   \
+	};                                                                                         \
+	static struct generic_sim_data generic_sim_data_##inst;                                    \
+	SENSOR_DEVICE_DT_INST_DEFINE(inst, generic_sim_init, NULL, &generic_sim_data_##inst,       \
+				     &generic_sim_cfg_##inst, POST_KERNEL,                         \
+				     CONFIG_SENSOR_INIT_PRIORITY, &generic_sim_driver_api);
+
+DT_INST_FOREACH_STATUS_OKAY(GENERIC_SIM_DEFINE)

dts/bindings/sensor/zephyr,generic-sim-sensor.yaml

@@ -0,0 +1,15 @@
+# Copyright (c) 2025 Embeint Holdings Pty Ltd
+# SPDX-License-Identifier: FSL-1.1-ALv2
+
+description: |
+  Generic simulated sensor
+
+compatible: "zephyr,generic-sim-sensor"
+
+properties:
+  negated-init-rc:
+    type: int
+    default: 0
+    description:
+      Value to return in init function (negated due to devicetree limitation
+      to unsigned integers).

include/infuse/drivers/sensor/generic_sim.h

@@ -0,0 +1,44 @@
+/**
+ * @file
+ * @brief Generic simulated sensor
+ * @copyright 2025 Embeint Holdings Pty Ltd
+ * @author Jordan Yates <[email protected]>
+ *
+ * SPDX-License-Identifier: FSL-1.1-ALv2
+ */
+
+#ifndef INFUSE_SDK_INCLUDE_INFUSE_DRIVERS_SENSOR_GENERIC_SIM_H_
+#define INFUSE_SDK_INCLUDE_INFUSE_DRIVERS_SENSOR_GENERIC_SIM_H_
+
+#include <zephyr/device.h>
+#include <zephyr/drivers/sensor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Reset all channels back to unconfigured
+ *
+ * @param dev Generic simulator sensor device to reset
+ */
+void generic_sim_reset(const struct device *dev);
+
+/**
+ * @brief Set the value to be returned for a given channel
+ *
+ * @param dev Generic simulator sensor device
+ * @param chan Channel to configure
+ * @param val Value to return when channel queried
+ *
+ * @retval 0 on success
+ * @retval -EINVAL on invalid channel
+ */
+int generic_sim_channel_set(const struct device *dev, enum sensor_channel chan,
+			    struct sensor_value val);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INFUSE_SDK_INCLUDE_INFUSE_DRIVERS_SENSOR_GENERIC_SIM_H_ */

tests/drivers/build_all/app.overlay

@@ -93,5 +93,7 @@
 
 			#include "spi.dtsi"
 		};
+
+		#include "other.dtsi"
 	};
 };

tests/drivers/build_all/other.dtsi

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2025, Embeint Pty Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Application overlay for other devices
+ */
+
+generic_sim_sensor: generic_sim_sensor {
+	compatible = "zephyr,generic-sim-sensor";
+	status = "okay";
+};

tests/drivers/sensor/generic_sim/CMakeLists.txt

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+# Infuse-IoT application
+if(NOT infuse IN_LIST SNIPPET)
+  set(SNIPPET infuse ${SNIPPET} CACHE STRING "" FORCE)
+endif()
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(gnss)
+
+target_sources(app PRIVATE
+  src/main.c
+)

tests/drivers/sensor/generic_sim/app.overlay

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2025, Embeint Pty Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/ {
+	test_sensor: test_sensor {
+		compatible = "zephyr,generic-sim-sensor";
+		status = "okay";
+	};
+
+	fail_sensor: fail_sensor {
+		compatible = "zephyr,generic-sim-sensor";
+		status = "okay";
+		negated-init-rc = <2>;
+	};
+};

tests/drivers/sensor/generic_sim/prj.conf

@@ -0,0 +1,2 @@
+CONFIG_ZTEST=y
+CONFIG_SENSOR=y

tests/drivers/sensor/generic_sim/src/main.c

@@ -0,0 +1,71 @@
+/**
+ * @file
+ * @copyright 2024 Embeint Holdings Pty Ltd
+ * @author Jordan Yates <[email protected]>
+ *
+ * SPDX-License-Identifier: FSL-1.1-ALv2
+ */
+
+#include <zephyr/ztest.h>
+#include <zephyr/kernel.h>
+#include <zephyr/devicetree.h>
+
+#include <infuse/drivers/sensor/generic_sim.h>
+
+ZTEST(drivers_sensor_generic_sim, test_init_fail)
+{
+	const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(fail_sensor));
+
+	zassert_false(device_is_ready(dev));
+}
+
+ZTEST(drivers_sensor_generic_sim, test_init_pass)
+{
+	const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(test_sensor));
+
+	zassert_true(device_is_ready(dev));
+}
+
+ZTEST(drivers_sensor_generic_sim, test_set_invalid)
+{
+	const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(test_sensor));
+	struct sensor_value val = {0};
+
+	zassert_equal(-EINVAL, generic_sim_channel_set(dev, SENSOR_CHAN_ALL, val));
+}
+
+ZTEST(drivers_sensor_generic_sim, test_value_echo)
+{
+	const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(test_sensor));
+	struct sensor_value val_write, val_read;
+
+	zassert_equal(0, sensor_sample_fetch(dev));
+
+	for (int i = 0; i < SENSOR_CHAN_ALL; i++) {
+		/* Not supported before configuring */
+		zassert_equal(-ENOTSUP, sensor_channel_get(dev, i, &val_read));
+		/* Can configure */
+		val_write.val1 = i + 1;
+		val_write.val2 = i - 10;
+		zassert_equal(0, generic_sim_channel_set(dev, i, val_write));
+		/* Returns the expected value */
+		zassert_equal(0, sensor_channel_get(dev, i, &val_read));
+		zassert_equal(val_write.val1, val_read.val1);
+		zassert_equal(val_write.val2, val_read.val2);
+	}
+
+	/* Reset clears all channels */
+	generic_sim_reset(dev);
+	for (int i = 0; i < SENSOR_CHAN_ALL; i++) {
+		zassert_equal(-ENOTSUP, sensor_channel_get(dev, i, &val_read));
+	}
+}
+
+static void before_fn(void *unused)
+{
+	const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(test_sensor));
+
+	generic_sim_reset(dev);
+}
+
+ZTEST_SUITE(drivers_sensor_generic_sim, NULL, NULL, before_fn, NULL, NULL);

tests/drivers/sensor/generic_sim/testcase.yaml

@@ -0,0 +1,9 @@
+sample:
+  description: Generic simulated sensor
+  name: Generic simulated sensor
+
+tests:
+  sensor.generic_sim:
+    sysbuild: true
+    integration_platforms:
+      - native_sim

tests/subsys/task_runner/tasks/battery/src/main.c

@@ -17,8 +17,6 @@
 #include <infuse/epacket/interface/epacket_dummy.h>
 #include <infuse/data_logger/logger.h>
 #include <infuse/data_logger/high_level/tdf.h>
-#include <infuse/drivers/imu.h>
-#include <infuse/drivers/imu/emul.h>
 #include <infuse/states.h>
 #include <infuse/tdf/tdf.h>
 #include <infuse/zbus/channels.h>
@@ -75,34 +73,40 @@ static void expect_logging(uint8_t log_mask, uint32_t battery_uv, int32_t curren
 
 	net_buf_pull(pkt, sizeof(struct epacket_dummy_frame));
 
+	rc = tdf_parse_find_in_buf(pkt->data, pkt->len, TDF_BATTERY_STATE, &tdf);
 	if (log_mask & TASK_BATTERY_LOG_COMPLETE) {
 		struct tdf_battery_state *state;
 
-		rc = tdf_parse_find_in_buf(pkt->data, pkt->len, TDF_BATTERY_STATE, &tdf);
 		zassert_equal(0, rc);
 		state = tdf.data;
 
 		zassert_equal(battery_uv / 1000, state->voltage_mv);
 		zassert_equal(current_ua, state->current_ua);
 		zassert_equal(soc, state->soc);
+	} else {
+		zassert_equal(-ENOMEM, rc);
 	}
+	rc = tdf_parse_find_in_buf(pkt->data, pkt->len, TDF_BATTERY_VOLTAGE, &tdf);
 	if (log_mask & TASK_BATTERY_LOG_VOLTAGE) {
 		struct tdf_battery_voltage *state;
 
-		rc = tdf_parse_find_in_buf(pkt->data, pkt->len, TDF_BATTERY_VOLTAGE, &tdf);
 		zassert_equal(0, rc);
 		state = tdf.data;
 
 		zassert_equal(battery_uv / 1000, state->voltage);
+	} else {
+		zassert_equal(-ENOMEM, rc);
 	}
+	rc = tdf_parse_find_in_buf(pkt->data, pkt->len, TDF_BATTERY_SOC, &tdf);
 	if (log_mask & TASK_BATTERY_LOG_SOC) {
 		struct tdf_battery_soc *state;
 
-		rc = tdf_parse_find_in_buf(pkt->data, pkt->len, TDF_BATTERY_SOC, &tdf);
 		zassert_equal(0, rc);
 		state = tdf.data;
 
 		zassert_equal(soc, state->soc);
+	} else {
+		zassert_equal(-ENOMEM, rc);
 	}
 
 	net_buf_unref(pkt);
@@ -220,6 +224,14 @@ ZTEST(task_bat, test_periodic)
 
 static void logger_before(void *fixture)
 {
+	struct k_fifo *tx_queue = epacket_dummmy_transmit_fifo_get();
+	struct net_buf *pkt;
+
+	tdf_data_logger_flush(TDF_DATA_LOGGER_SERIAL);
+	pkt = k_fifo_get(tx_queue, K_MSEC(10));
+	if (pkt) {
+		net_buf_unref(pkt);
+	}
 	k_sem_reset(&bat_published);
 }