modules: sensor: add warmup delays to prevent CCS811 early read failures

CCS811 sensor needs 5-second stabilization after init before valid readings.
Added configurable per-sensor warmup periods with tracking to skip reads
during warmup.

- CCS811: 5000ms warmup, BME280/HM3301: 100ms
- Individual sensor warmup completion tracking
- Partial data handling during warmup

The change fixes the regression introduced in PR #15 where removing the
global warmup delay caused CCS811 to fail with -EAGAIN during the first
few read attempts after system initialization.

Refs: #16

Signed-off-by: Natalia Pluta <pluta.natalia.m@gmail.com>

Author: nmpluta

app/src/modules/sensor/Kconfig.sensor

@@ -46,6 +46,36 @@ config SENSOR_MODULE_MAX_RETRIES
 	help
 	  Maximum number of recovery attempts before giving up.
 
+# Sensor-specific warmup configurations
+config SENSOR_MODULE_WARMUP_ENABLE
+	bool "Enable sensor warmup periods"
+	default y
+	help
+	  Enable warmup delays for sensors that need stabilization time
+	  before providing accurate readings.
+
+config SENSOR_MODULE_CCS811_WARMUP_MS
+	int "CCS811 warmup period (ms)"
+	default 5000
+	depends on SENSOR_MODULE_WARMUP_ENABLE
+	help
+	  Warmup time required for CCS811 sensor before first valid reading.
+	  CCS811 needs time to stabilize after power-on or reset.
+
+config SENSOR_MODULE_BME280_WARMUP_MS
+	int "BME280 warmup period (ms)"
+	default 100
+	depends on SENSOR_MODULE_WARMUP_ENABLE
+	help
+	  Warmup time required for BME280 sensor before first valid reading.
+
+config SENSOR_MODULE_HM3301_WARMUP_MS
+	int "HM3301 warmup period (ms)"
+	default 100
+	depends on SENSOR_MODULE_WARMUP_ENABLE
+	help
+	  Warmup time required for HM3301 sensor before first valid reading.
+
 config CCS811_ENV_COMPENSATION
 	bool "Enable environmental compensation for CCS811"
 	default y

app/src/modules/sensor/sensor_module.c

@@ -11,10 +11,12 @@
 LOG_MODULE_REGISTER(sensor_module, CONFIG_SENSOR_MODULE_LOG_LEVEL);
 
 /* Macro for type-safe sensor state object initialization */
-#define SENSOR_STATE_OBJECT_INIT()                                                                 \
-	{                                                                                          \
-		.ctx = {0}, .current_state = SENSOR_MODULE_STATE_INIT, .current_data = {0},        \
-		.error_count = 0, .max_retries = 0, .last_read_time = 0, .read_timeout_ms = 0      \
+#define SENSOR_STATE_OBJECT_INIT()                                                                   \
+	{                                                                                            \
+		.ctx = {0}, .current_state = SENSOR_MODULE_STATE_INIT, .current_data = {0},          \
+		.error_count = 0, .max_retries = 0, .last_read_time = 0, .read_timeout_ms = 0,       \
+		IF_ENABLED(CONFIG_SENSOR_MODULE_WARMUP_ENABLE,                                     \
+			   (.sensor_init_time = 0, .sensor_warmup_complete = {false},)) \
 	}
 
 /* ZBUS subscriber for sensor requests */
@@ -56,6 +58,12 @@ struct sensor_state_object {
 	/* Timing */
 	int64_t last_read_time;
 	int64_t read_timeout_ms;
+
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+	/* Sensor warmup tracking */
+	int64_t sensor_init_time;
+	bool sensor_warmup_complete[SENSOR_TYPE_COUNT];
+#endif
 };
 
 /* Forward declarations for state functions */
@@ -115,6 +123,11 @@ static void update_sensor_health(struct sensor_health *health, bool success);
 static const char *get_sensor_name(enum sensor_type type);
 static void sensor_set_state(struct sensor_state_object *ctx, enum sensor_module_state new_state);
 
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+static bool is_sensor_warmup_complete(enum sensor_type type);
+static int64_t get_sensor_warmup_time(enum sensor_type type);
+#endif
+
 #ifdef CONFIG_CCS811_ENV_COMPENSATION
 static int update_ccs811_env_data(const struct sensor_value *temp, const struct sensor_value *hum);
 static void handle_ccs811_env_compensation(const struct sensor_value *temp,
@@ -246,6 +259,14 @@ static void sensor_state_init_run(void *obj)
 		return;
 	}
 
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+	/* Initialize warmup timing */
+	ctx->sensor_init_time = k_uptime_get();
+	for (int i = 0; i < SENSOR_TYPE_COUNT; i++) {
+		ctx->sensor_warmup_complete[i] = false;
+	}
+#endif
+
 	/* Initialize context with configured values */
 	ctx->error_count = 0;
 	ctx->max_retries = sensor_state_obj.max_retries;
@@ -292,6 +313,15 @@ static void sensor_state_reading_run(void *obj)
 			continue;
 		}
 
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+		/* Check if sensor warmup is complete */
+		if (!is_sensor_warmup_complete(i)) {
+			LOG_DBG("Sensor SM: %s warmup not complete, skipping read",
+				get_sensor_name(i));
+			continue;
+		}
+#endif
+
 		int ret = read_sensor_data(i, &ctx->current_data);
 		if (ret == 0) {
 			successful_reads++;
@@ -319,18 +349,43 @@ static void sensor_state_reading_run(void *obj)
 		}
 	}
 
-	/* Count enabled sensors */
+	/* Count enabled sensors that have completed warmup */
 	int enabled_sensor_count = 0;
 	for (int i = 0; i < SENSOR_TYPE_COUNT; i++) {
 		if (sensors[i].enabled) {
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+			if (is_sensor_warmup_complete(i)) {
+				enabled_sensor_count++;
+			}
+#else
 			enabled_sensor_count++;
+#endif
 		}
 	}
 
 	/* Only publish data if at least one sensor read successfully */
 	if (successful_reads == 0) {
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+		/* Check if any sensors are still warming up */
+		bool any_warming = false;
+		for (int i = 0; i < SENSOR_TYPE_COUNT; i++) {
+			if (sensors[i].enabled && !is_sensor_warmup_complete(i)) {
+				any_warming = true;
+				break;
+			}
+		}
+
+		if (any_warming) {
+			LOG_DBG("Sensor SM: No readings yet - sensors still warming up");
+			sensor_set_state(ctx, SENSOR_MODULE_STATE_IDLE);
+		} else {
+			LOG_ERR("Sensor SM: All sensors failed, entering error state");
+			sensor_set_state(ctx, SENSOR_MODULE_STATE_ERROR);
+		}
+#else
 		LOG_ERR("Sensor SM: All sensors failed, entering error state");
 		sensor_set_state(ctx, SENSOR_MODULE_STATE_ERROR);
+#endif
 	} else if (successful_reads < enabled_sensor_count) {
 		LOG_WRN("Sensor SM: Partial sensor failure (%d/%d successful), but publishing "
 			"available data",
@@ -703,3 +758,47 @@ static void sensor_set_state(struct sensor_state_object *ctx, enum sensor_module
 	ctx->current_state = new_state;
 	smf_set_state(SMF_CTX(ctx), &sensor_states[new_state]);
 }
+
+#ifdef CONFIG_SENSOR_MODULE_WARMUP_ENABLE
+/* Helper function to get warmup time for a sensor type */
+static int64_t get_sensor_warmup_time(enum sensor_type type)
+{
+	switch (type) {
+	case SENSOR_TYPE_BME280:
+		return CONFIG_SENSOR_MODULE_BME280_WARMUP_MS;
+	case SENSOR_TYPE_CCS811:
+		return CONFIG_SENSOR_MODULE_CCS811_WARMUP_MS;
+	case SENSOR_TYPE_HM3301:
+		return CONFIG_SENSOR_MODULE_HM3301_WARMUP_MS;
+	default:
+		return 0;
+	}
+}
+
+/* Helper function to check if sensor warmup is complete */
+static bool is_sensor_warmup_complete(enum sensor_type type)
+{
+	if (type >= SENSOR_TYPE_COUNT) {
+		return false;
+	}
+
+	/* Check if already marked as complete */
+	if (sensor_state_obj.sensor_warmup_complete[type]) {
+		return true;
+	}
+
+	/* Check if warmup time has elapsed */
+	int64_t elapsed_time = k_uptime_get() - sensor_state_obj.sensor_init_time;
+	int64_t warmup_time = get_sensor_warmup_time(type);
+
+	if (elapsed_time >= warmup_time) {
+		/* Mark as complete and log */
+		sensor_state_obj.sensor_warmup_complete[type] = true;
+		LOG_INF("Sensor SM: %s warmup complete after %lld ms", get_sensor_name(type),
+			elapsed_time);
+		return true;
+	}
+
+	return false;
+}
+#endif /* CONFIG_SENSOR_MODULE_WARMUP_ENABLE */