task_runner: tasks: environmental: optional secondary device

apps/data_logger/src/main.c

@@ -161,7 +161,8 @@ TASK_SCHEDULE_STATES_DEFINE(states, schedules);
 TASK_RUNNER_TASKS_DEFINE(app_tasks, app_tasks_data, (TDF_LOGGER_TASK, custom_tdf_logger),
 			 (IMU_TASK, DEVICE_DT_GET(DT_ALIAS(imu0))), GNSS_TASK_DEFINE,
 			 (BATTERY_TASK, DEVICE_DT_GET(DT_ALIAS(fuel_gauge0))),
-			 (ENVIRONMENTAL_TASK, DEVICE_DT_GET(DT_ALIAS(environmental0))));
+			 (ENVIRONMENTAL_TASK, DEVICE_DT_GET(DT_ALIAS(environmental0)),
+			  DEVICE_DT_GET_OR_NULL(DT_ALIAS(environmental1))));
 
 static void custom_tdf_logger(uint8_t tdf_loggers, uint64_t timestamp)
 {

apps/gateway_lte/src/main.c

@@ -111,7 +111,9 @@ static const struct task_schedule schedules[] = {
 };
 
 #if DT_NODE_EXISTS(DT_ALIAS(environmental0))
-#define ENV_TASK_DEFINE (ENVIRONMENTAL_TASK, DEVICE_DT_GET(DT_ALIAS(environmental0)))
+#define ENV_TASK_DEFINE                                                                            \
+	(ENVIRONMENTAL_TASK, DEVICE_DT_GET(DT_ALIAS(environmental0)),                              \
+	 DEVICE_DT_GET_OR_NULL(DT_ALIAS(environmental1)))
 #else
 #define ENV_TASK_DEFINE
 #endif

apps/lte_tracker/src/main.c

@@ -125,7 +125,9 @@ static const struct task_schedule schedules[] = {
 };
 
 #if DT_NODE_EXISTS(DT_ALIAS(environmental0))
-#define ENV_TASK_DEFINE (ENVIRONMENTAL_TASK, DEVICE_DT_GET(DT_ALIAS(environmental0)))
+#define ENV_TASK_DEFINE                                                                            \
+	(ENVIRONMENTAL_TASK, DEVICE_DT_GET(DT_ALIAS(environmental0)),                              \
+	 DEVICE_DT_GET_OR_NULL(DT_ALIAS(environmental1)))
 #else
 #define ENV_TASK_DEFINE
 #endif

boards/embeint/auroch/auroch_nrf9151_common.dtsi

@@ -57,6 +57,7 @@
 		gnss = &max_m10;
 		watchdog0 = &wdt0;
 		environmental0 = &sht4x;
+		environmental1 = &lps22hh;
 	};
 };
 

boards/embeint/kudu/kudu_cpuapp_common.dtsi

@@ -54,6 +54,7 @@
 		watchdog0 = &wdt31;
 		fuel-gauge0 = &fuel_gauge;
 		environmental0 = &sht4x;
+		environmental1 = &lps22hh;
 		imu0 = &lsm6dsv;
 		modem = &telit_le910c1;
 	};

drivers/sensor/generic_sim.c

@@ -13,12 +13,16 @@
 #include <zephyr/drivers/sensor.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/sys/atomic.h>
+#include <zephyr/pm/device.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);
+	int resume_rc;
+	int suspend_rc;
+	int fetch_rc;
 };
 
 struct generic_sim_cfg {
@@ -27,11 +31,25 @@ struct generic_sim_cfg {
 
 LOG_MODULE_DECLARE(GENERIC_SIM, CONFIG_SENSOR_LOG_LEVEL);
 
-void generic_sim_reset(const struct device *dev)
+void generic_sim_reset(const struct device *dev, bool reset_rc)
 {
 	struct generic_sim_data *data = dev->data;
 
 	memset(data->channels_set, 0, sizeof(data->channels_set));
+	if (reset_rc) {
+		data->resume_rc = 0;
+		data->suspend_rc = 0;
+		data->fetch_rc = 0;
+	}
+}
+
+void generic_sim_func_rc(const struct device *dev, int resume_rc, int suspend_rc, int fetch_rc)
+{
+	struct generic_sim_data *data = dev->data;
+
+	data->resume_rc = resume_rc;
+	data->suspend_rc = suspend_rc;
+	data->fetch_rc = fetch_rc;
 }
 
 int generic_sim_channel_set(const struct device *dev, enum sensor_channel chan,
@@ -50,7 +68,13 @@ int generic_sim_channel_set(const struct device *dev, enum sensor_channel chan,
 
 static int generic_sim_sample_fetch(const struct device *dev, enum sensor_channel chan)
 {
-	return 0;
+	struct generic_sim_data *data = dev->data;
+
+	if (chan > SENSOR_CHAN_ALL) {
+		return -ENOTSUP;
+	}
+
+	return data->fetch_rc;
 }
 
 static int generic_sim_channel_get(const struct device *dev, enum sensor_channel chan,
@@ -71,6 +95,26 @@ static int generic_sim_channel_get(const struct device *dev, enum sensor_channel
 	return 0;
 }
 
+#ifdef CONFIG_PM_DEVICE
+static int generic_sim_pm_control(const struct device *dev, enum pm_device_action action)
+{
+	struct generic_sim_data *data = dev->data;
+
+	switch (action) {
+	case PM_DEVICE_ACTION_SUSPEND:
+		return data->suspend_rc;
+	case PM_DEVICE_ACTION_RESUME:
+		return data->resume_rc;
+	case PM_DEVICE_ACTION_TURN_OFF:
+		return 0;
+	case PM_DEVICE_ACTION_TURN_ON:
+		return 0;
+	default:
+		return -ENOTSUP;
+	}
+}
+#endif /* CONFIG_PM_DEVICE */
+
 static const struct sensor_driver_api generic_sim_driver_api = {
 	.sample_fetch = generic_sim_sample_fetch,
 	.channel_get = generic_sim_channel_get,
@@ -88,8 +132,10 @@ int generic_sim_init(const struct device *dev)
 		.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);
+	PM_DEVICE_DT_INST_DEFINE(inst, generic_sim_pm_control);                                    \
+	SENSOR_DEVICE_DT_INST_DEFINE(inst, generic_sim_init, PM_DEVICE_DT_INST_GET(inst),          \
+				     &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

@@ -6,6 +6,8 @@ description: |
 
 compatible: "zephyr,generic-sim-sensor"
 
+include: [sensor-device.yaml]
+
 properties:
   negated-init-rc:
     type: int

include/infuse/drivers/sensor/generic_sim.h

@@ -21,8 +21,19 @@ extern "C" {
  * @brief Reset all channels back to unconfigured
  *
  * @param dev Generic simulator sensor device to reset
+ * @param reset_rc Reset the return codes
  */
-void generic_sim_reset(const struct device *dev);
+void generic_sim_reset(const struct device *dev, bool reset_rc);
+
+/**
+ * @brief Configure return value for generic sensor device
+ *
+ * @param dev Generic simulator sensor device to reset
+ * @param resume_rc Return code for @a PM_DEVICE_ACTION_RESUME
+ * @param suspend_rc Return code for @a PM_DEVICE_ACTION_SUSPEND
+ * @param fetch_rc Return code for @a sensor_sample_fetch
+ */
+void generic_sim_func_rc(const struct device *dev, int resume_rc, int suspend_rc, int fetch_rc);
 
 /**
  * @brief Set the value to be returned for a given channel

include/infuse/task_runner/tasks/environmental.h

@@ -21,6 +21,14 @@
 extern "C" {
 #endif
 
+/** Configuration struct to hold multiple devices */
+struct task_environmental_devices {
+	/** Primary environmental sensor, used in preference to @a secondary */
+	const struct device *primary;
+	/** Secondary environmental sensor, used if a channel doesn't exist on @a primary */
+	const struct device *secondary;
+};
+
 /**
  * @brief Environmental task function
  *
@@ -33,14 +41,18 @@ void environmental_task_fn(struct k_work *work);
  *
  * @param define_mem Define memory
  * @param define_config Define task
- * @param env_ptr Environmental sensing device bound to task
+ * @param env_primary Environmental sensing device bound to task (Primary)
+ * @param env_secondary Environmental sensing device bound to task (Seconday, optional)
  */
-#define ENVIRONMENTAL_TASK(define_mem, define_config, env_ptr)                                     \
+#define ENVIRONMENTAL_TASK(define_mem, define_config, env_primary, env_secondary)                  \
+	IF_ENABLED(define_mem, (const struct task_environmental_devices _env_task_devices = {      \
+					.primary = env_primary,                                    \
+					.secondary = env_secondary,                                \
+				}))                                                                \
 	IF_ENABLED(define_config, ({.name = "env",                                                 \
 				    .task_id = TASK_ID_ENVIRONMENTAL,                              \
 				    .exec_type = TASK_EXECUTOR_WORKQUEUE,                          \
-				    .flags = TASK_FLAG_ARG_IS_DEVICE,                              \
-				    .task_arg.dev = env_ptr,                                       \
+				    .task_arg.const_arg = &_env_task_devices,                      \
 				    .executor.workqueue = {                                        \
 					    .worker_fn = environmental_task_fn,                    \
 				    }}))

samples/validation/src/main.c

@@ -61,16 +61,24 @@ K_THREAD_DEFINE(imu_thread, 2048, imu_validator, NULL, NULL, NULL, 5, 0, 0);
 #endif /* DT_NODE_EXISTS(DT_ALIAS(imu0)) */
 
 #if DT_NODE_EXISTS(DT_ALIAS(environmental0))
-static int env_validator(void *a, void *b, void *c)
+
+static void env_validation_run(const struct device *dev)
 {
 	atomic_inc(&validators_registered);
-	if (infuse_validation_env(DEVICE_DT_GET(DT_ALIAS(environmental0)), VALIDATION_ENV_DRIVER) ==
-	    0) {
+	if (infuse_validation_env(dev, VALIDATION_ENV_DRIVER) == 0) {
 		atomic_inc(&validators_passed);
 	} else {
 		atomic_inc(&validators_failed);
 	}
 	atomic_inc(&validators_complete);
+}
+
+static int env_validator(void *a, void *b, void *c)
+{
+	env_validation_run(DEVICE_DT_GET(DT_ALIAS(environmental0)));
+#if DT_NODE_EXISTS(DT_ALIAS(environmental1))
+	env_validation_run(DEVICE_DT_GET(DT_ALIAS(environmental1)));
+#endif /* DT_NODE_EXISTS(DT_ALIAS(environmental1)) */
 	k_sem_give(&task_complete);
 	return 0;
 }

subsys/data_logger/data_logger.c

@@ -502,7 +502,7 @@ int data_logger_block_read(const struct device *dev, uint32_t block_idx, uint16_
 		LOG_ERR("%s failed to read from backend", dev->name);
 	}
 	/* Read data remaining after wrap */
-	if (second_read) {
+	if (second_read && (rc == 0)) {
 		block = (uint8_t *)block + block_len;
 		LOG_DBG("%s reading remaining %d bytes", dev->name, second_read);
 		rc = api->read(dev, 0, 0, block, second_read);

subsys/task_runner/tasks/task_environmental.c

@@ -22,48 +22,106 @@ LOG_MODULE_REGISTER(task_env, CONFIG_TASK_ENVIRONMENTAL_LOG_LEVEL);
 INFUSE_ZBUS_CHAN_DEFINE(INFUSE_ZBUS_CHAN_AMBIENT_ENV);
 #define ZBUS_CHAN INFUSE_ZBUS_CHAN_GET(INFUSE_ZBUS_CHAN_AMBIENT_ENV)
 
-void environmental_task_fn(struct k_work *work)
+static int env_fetch(const struct device *dev)
 {
-	struct task_data *task = task_data_from_work(work);
-	const struct task_schedule *sch = task_schedule_from_data(task);
-	const struct device *env = task->executor.workqueue.task_arg.const_arg;
-	struct tdf_ambient_temp_pres_hum tdf_tph;
-	struct tdf_ambient_temperature tdf_temp;
-	struct sensor_value value;
-	bool has_pressure;
-	bool has_humidity;
 	int rc;
 
+	/* Validate existence and init state */
+	if (dev == NULL) {
+		return -ENODEV;
+	}
+	if (!device_is_ready(dev)) {
+		LOG_WRN_ONCE("%s not ready", dev->name);
+		return -ENODEV;
+	}
 	/* Request sensor to be powered */
-	rc = pm_device_runtime_get(env);
+	rc = pm_device_runtime_get(dev);
 	if (rc < 0) {
-		LOG_ERR("Terminating due to %s", "PM failure");
-		return;
+		return rc;
 	}
 
 	/* Trigger the sample */
-	rc = sensor_sample_fetch(env);
+	rc = sensor_sample_fetch(dev);
 	if (rc < 0) {
-		LOG_ERR("Terminating due to %s", "fetch failure");
-		return;
+		/* Release PM constraint */
+		(void)pm_device_runtime_put(dev);
+		return rc;
 	}
+	return 0;
+}
 
-	/* Populate the output TDFs */
-	rc = sensor_channel_get(env, SENSOR_CHAN_AMBIENT_TEMP, &value);
-	tdf_tph.temperature = sensor_value_to_milli(&value);
-	tdf_temp.temperature = tdf_tph.temperature;
-	rc = sensor_channel_get(env, SENSOR_CHAN_PRESS, &value);
-	has_pressure = rc == 0;
-	tdf_tph.pressure = has_pressure ? sensor_value_to_milli(&value) : 0;
-	rc = sensor_channel_get(env, SENSOR_CHAN_HUMIDITY, &value);
-	has_humidity = rc == 0;
-	tdf_tph.humidity = has_humidity ? sensor_value_to_centi(&value) : 0;
-
-	/* Release power requirement */
-	rc = pm_device_runtime_put(env);
+static void env_release(const struct device *dev, bool sampled)
+{
+	int rc;
+
+	if (!sampled) {
+		return;
+	}
+	rc = pm_device_runtime_put(dev);
 	if (rc < 0) {
 		LOG_ERR("PM put failure");
 	}
+}
+
+void environmental_task_fn(struct k_work *work)
+{
+	struct task_data *task = task_data_from_work(work);
+	const struct task_schedule *sch = task_schedule_from_data(task);
+	const struct task_environmental_devices *devices =
+		task->executor.workqueue.task_arg.const_arg;
+	const struct device *primary = devices->primary;
+	const struct device *secondary = devices->secondary;
+	struct tdf_ambient_temp_pres_hum tdf_tph = {0};
+	struct tdf_ambient_temperature tdf_temp = {0};
+	struct sensor_value value;
+	bool primary_sampled = false;
+	bool secondary_sampled = false;
+	bool has_pressure = false;
+	bool has_humidity = false;
+	int rc;
+
+	/* Sample from provided sensors */
+	rc = env_fetch(primary);
+	if (rc == 0) {
+		primary_sampled = true;
+	}
+	rc = env_fetch(secondary);
+	if (rc == 0) {
+		secondary_sampled = true;
+	}
+
+	if (!primary_sampled && !secondary_sampled) {
+		LOG_ERR("Terminating due to no samples");
+		return;
+	}
+
+	LOG_DBG("Sources: %d %d", primary_sampled, secondary_sampled);
+
+	/* Populate the output TDFs */
+	if ((primary_sampled &&
+	     (sensor_channel_get(primary, SENSOR_CHAN_AMBIENT_TEMP, &value) == 0)) ||
+	    ((secondary_sampled &&
+	      (sensor_channel_get(secondary, SENSOR_CHAN_AMBIENT_TEMP, &value) == 0)))) {
+		tdf_tph.temperature = sensor_value_to_milli(&value);
+		tdf_temp.temperature = tdf_tph.temperature;
+	}
+
+	if ((primary_sampled && (sensor_channel_get(primary, SENSOR_CHAN_PRESS, &value) == 0)) ||
+	    ((secondary_sampled &&
+	      (sensor_channel_get(secondary, SENSOR_CHAN_PRESS, &value) == 0)))) {
+		tdf_tph.pressure = sensor_value_to_milli(&value);
+		has_pressure = true;
+	}
+	if ((primary_sampled && (sensor_channel_get(primary, SENSOR_CHAN_HUMIDITY, &value) == 0)) ||
+	    ((secondary_sampled &&
+	      (sensor_channel_get(secondary, SENSOR_CHAN_HUMIDITY, &value) == 0)))) {
+		tdf_tph.humidity = sensor_value_to_centi(&value);
+		has_humidity = true;
+	}
+
+	/* Release power requirements */
+	env_release(primary, primary_sampled);
+	env_release(secondary, secondary_sampled);
 
 	/* Log output TDFs */
 	TASK_SCHEDULE_TDF_LOG(sch, TASK_ENVIRONMENTAL_LOG_TPH, TDF_AMBIENT_TEMP_PRES_HUM,
@@ -75,6 +133,6 @@ void environmental_task_fn(struct k_work *work)
 	zbus_chan_pub(ZBUS_CHAN, &tdf_tph, K_FOREVER);
 
 	/* Print the measured values */
-	LOG_INF("%s: T=%6d mDeg P=%6d Pa H=%3d %%", env->name, tdf_tph.temperature,
+	LOG_INF("T=%6d mDeg P=%6d Pa H=%3d %%", tdf_tph.temperature,
 		has_pressure ? tdf_tph.pressure : -1, has_humidity ? tdf_tph.humidity / 100 : -1);
 }