add bme680 iaq test application

src/app/bme680-bsec/Kconfig

+# Copyright 2020 Daniel Friesel
+#
+# SPDX-License-Identifier: CC0-1.0
+
+prompt "BME680 BSEC logger"
+depends on driver_bme680_bsec && meta_driver_uptime && loop && !wakeup

src/app/bme680-bsec/main.cc

+/*
+ * Copyright 2020 Daniel Friesel
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+#include "arch.h"
+#include "driver/gpio.h"
+#include "driver/stdout.h"
+#include "driver/uptime.h"
+
+#if defined(CONFIG_meta_driver_hardware_i2c)
+#include "driver/i2c.h"
+#elif defined(CONFIG_driver_softi2c)
+#include "driver/soft_i2c.h"
+#endif
+
+#include "driver/bme680.h"
+#include "driver/bme680_util.h"
+#include "driver/bme680-bsec-armv6/bsec_interface.h"
+
+const char* accuracy[] = {"(unreliable)", "(calibration required)", "(auto-trim in progress)", ""};
+
+void loop(void)
+{
+	static bsec_bme_settings_t sensor_settings;
+
+	struct bme680_field_data data;
+	bsec_input_t bsec_inputs[BSEC_MAX_PHYSICAL_SENSOR];
+	bsec_output_t bsec_outputs[BSEC_NUMBER_OUTPUTS];
+
+	uint8_t num_bsec_inputs = 0;
+	uint8_t num_bsec_outputs = BSEC_NUMBER_OUTPUTS;
+
+	int64_t now = uptime.get_us() * 1000;
+	uint32_t now_s = uptime.get_s();
+
+	/*
+	 * BSEC expects the application to observe precise timing constraints.
+	 * After each call to bsec_sensor_control, sensor_settings.next_call is set
+	 * to the nanosecond timestamp of the next call. Significant violations
+	 * cause bsec_sensor_control to return a BSEC_W_SC_CALL_TIMING_VIOLATION
+	 * warning.
+	 */
+
+	if (now < sensor_settings.next_call) {
+		if (sensor_settings.next_call - now < 1000000000) {
+			// less than one second -> sleep
+			arch.delay_us((sensor_settings.next_call - now) / 1000);
+			now = uptime.get_us() * 1000;
+		} else {
+			// more than one second -> next loop() call is sufficient
+			return;
+		}
+	}
+
+	/*
+	 * Retrieve sensor configuration from BSEC. In our case, it's fairly simple:
+	 * all virtual sensors are set to the same sample rate, so we expect
+	 * physical sensor readings to be the same for each BSEC call. However,
+	 * if we disable virtual sensors, or change their sample rate, this is
+	 * no longer the case.
+	 * Also, bsec_sensor_control controls sensor_settings.next_call, so we
+	 * need to call it anyways.
+	 */
+	bsec_library_return_t status = bsec_sensor_control(now, &sensor_settings);
+
+	if (status < 0) {
+		kout << "bsec_sensor_control error: " << status << endl;
+		return;
+	}
+	if (status > 0) {
+		kout << "bsec_sensor_control warning: " << status << endl;
+	}
+
+	/*
+	 * bsec_sensor_control tells us whether it needs new sensor data or
+	 * not. If so: configure the sensor as indicated and perform a measurement.
+	 */
+	if (sensor_settings.trigger_measurement) {
+		bme680.tph_sett.os_hum = sensor_settings.humidity_oversampling;
+		bme680.tph_sett.os_pres = sensor_settings.pressure_oversampling;
+		bme680.tph_sett.os_temp = sensor_settings.temperature_oversampling;
+		bme680.gas_sett.run_gas = sensor_settings.run_gas;
+		bme680.gas_sett.heatr_temp = sensor_settings.heater_temperature;
+		bme680.gas_sett.heatr_dur = sensor_settings.heating_duration;
+
+		bme680.power_mode = BME680_FORCED_MODE;
+		bme680.setSensorSettings(BME680_OST_SEL | BME680_OSP_SEL | BME680_OSH_SEL | BME680_GAS_SENSOR_SEL);
+
+		bme680.setSensorMode();
+
+		/*
+		 * TODO recent versions of the bme680 open-source driver are able to
+		 * calculate the required delay.
+		 */
+		arch.delay_ms(250);
+
+		do {
+			arch.delay_ms(5);
+			bme680.getSensorMode();
+		} while (bme680.power_mode == BME680_FORCED_MODE);
+
+		if (sensor_settings.process_data) {
+			bme680.getSensorData(&data);
+			if (data.status & BME680_NEW_DATA_MSK) {
+				if (sensor_settings.process_data & BSEC_PROCESS_TEMPERATURE) {
+					bsec_inputs[num_bsec_inputs].sensor_id = BSEC_INPUT_TEMPERATURE;
+					bsec_inputs[num_bsec_inputs].signal = data.temperature / 100.0f;
+					bsec_inputs[num_bsec_inputs].time_stamp = now;
+					num_bsec_inputs++;
+				}
+				if (sensor_settings.process_data & BSEC_PROCESS_HUMIDITY) {
+					bsec_inputs[num_bsec_inputs].sensor_id = BSEC_INPUT_HUMIDITY;
+					bsec_inputs[num_bsec_inputs].signal = data.humidity / 1000.0f;
+					bsec_inputs[num_bsec_inputs].time_stamp = now;
+					num_bsec_inputs++;
+				}
+				if (sensor_settings.process_data & BSEC_PROCESS_PRESSURE) {
+					bsec_inputs[num_bsec_inputs].sensor_id = BSEC_INPUT_PRESSURE;
+					bsec_inputs[num_bsec_inputs].signal = data.pressure;
+					bsec_inputs[num_bsec_inputs].time_stamp = now;
+					num_bsec_inputs++;
+				}
+				if (sensor_settings.process_data & BSEC_PROCESS_GAS) {
+					bsec_inputs[num_bsec_inputs].sensor_id = BSEC_INPUT_GASRESISTOR;
+					bsec_inputs[num_bsec_inputs].signal = data.gas_resistance;
+					bsec_inputs[num_bsec_inputs].time_stamp = now;
+					num_bsec_inputs++;
+				}
+			}
+		}
+
+		if (num_bsec_inputs > 0) {
+			status = bsec_do_steps(bsec_inputs, num_bsec_inputs, bsec_outputs, &num_bsec_outputs);
+
+			if (status < 0) {
+				kout << "bsec_do_steps error: " << status << endl;
+				return;
+			}
+			if (status > 0) {
+				kout << "bsec_do_steps warning: " << status << endl;
+			}
+
+			for (uint8_t i = 0; i < num_bsec_outputs; i++) {
+				switch (bsec_outputs[i].sensor_id) {
+					case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE:
+						kout << now_s << " BME680 temperature " << bsec_outputs[i].signal << " °c" << endl;
+						break;
+					case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY:
+						kout << now_s << " BME680 humidity " << bsec_outputs[i].signal << " %" << endl;
+						break;
+					case BSEC_OUTPUT_RAW_PRESSURE:
+						kout << now_s << " BME680 pressure " << bsec_outputs[i].signal / 100 << " hPa" << endl;
+						break;
+					case BSEC_OUTPUT_RAW_GAS:
+						kout << now_s << " BME680 gas resistance " << bsec_outputs[i].signal << " Ω" << endl;
+						break;
+					case BSEC_OUTPUT_IAQ:
+						if (bsec_outputs[i].accuracy > 0) {
+							kout << now_s << " BME680 IAQ: " << bsec_outputs[i].signal << " " << accuracy[bsec_outputs[i].accuracy] << endl;
+						}
+						break;
+					case BSEC_OUTPUT_STABILIZATION_STATUS:
+						if (bsec_outputs[i].signal < 1) {
+							kout << now_s << " BME680 IAQ initial stabilization in progress" << endl;
+						}
+						break;
+					case BSEC_OUTPUT_RUN_IN_STATUS:
+						if (bsec_outputs[i].signal < 1) {
+							kout << now_s << " BME680 IAQ power-on stabilization in progress" << endl;
+						}
+						break;
+					default:
+						continue;
+				}
+			}
+			kout << endl;
+		}
+	}
+}
+
+int main(void)
+{
+
+	arch.setup();
+	gpio.setup();
+	kout.setup();
+
+#if defined(CONFIG_meta_driver_i2c)
+	while (i2c.setup() != 0) {
+		kout << "I2C setup FAILED" << endl;
+		arch.delay_ms(1000);
+	}
+	kout << "I2C setup OK" << endl;
+#endif
+
+	// Set up (open-source) BME680 driver
+	bme680.intf = BME680_I2C_INTF;
+	bme680.read = bme680_i2c_read;
+	bme680.write = bme680_i2c_write;
+	bme680.delay_ms = bme680_delay_ms;
+
+	int8_t bme680_status = bme680.init();
+	while (bme680_status != 0) {
+		kout << "BME680 init failed: " << (uint8_t)bme680_status << endl;
+		arch.delay_ms(1000);
+	}
+	kout << "BME680 init OK" << endl;
+
+	// Initialize proprietary BSEC library
+	bsec_library_return_t bsec_status = bsec_init();
+	while (bsec_status != BSEC_OK) {
+		kout << "BSEC init failed: " << bsec_status << endl;
+		arch.delay_ms(1000);
+	}
+	kout << "BSEC init OK" << endl;
+
+	/*
+	 * Output configuration. The BME680 BSEC library supports several virtual
+	 * sensors such as raw temperature, compensated temperature, or IAQ. Each
+	 * virtual sensor is calculated based on past observations and the
+	 * TPH+Gas readings obtained from the BME680 sinsor.
+	 *
+	 * Here, we are interested in seven different types of readings.
+	 */
+	bsec_sensor_configuration_t virtual_sensors[7];
+	unsigned char n_virtual_sensors = 7;
+
+	/*
+	 * bsec_update_subscription writes required sensor settings to the
+	 * sensor_configs array. We're not interested in them at the moment.
+	 */
+	bsec_sensor_configuration_t sensor_configs[BSEC_MAX_PHYSICAL_SENSOR];
+	unsigned char n_sensor_settings = BSEC_MAX_PHYSICAL_SENSOR;
+
+	/*
+	 * Low Power mode -> 1/3 Hz (i.e., one sample every three seconds).
+	 */
+	float sample_rate = BSEC_SAMPLE_RATE_LP;
+
+	/*
+	 * We're interested in the following readings.
+	 * See bsec_virtual_sensor_t definition in bsec_datatypes for a list of
+	 * supported virtual sensor types ("sensor_ids").
+	 */
+	virtual_sensors[0].sensor_id = BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE;
+	virtual_sensors[0].sample_rate = sample_rate;
+	virtual_sensors[1].sensor_id = BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY;
+	virtual_sensors[1].sample_rate = sample_rate;
+	virtual_sensors[2].sensor_id = BSEC_OUTPUT_RAW_PRESSURE;
+	virtual_sensors[2].sample_rate = sample_rate;
+	virtual_sensors[3].sensor_id = BSEC_OUTPUT_RAW_GAS;
+	virtual_sensors[3].sample_rate = sample_rate;
+	virtual_sensors[4].sensor_id = BSEC_OUTPUT_IAQ;
+	virtual_sensors[4].sample_rate = sample_rate;
+	virtual_sensors[5].sensor_id = BSEC_OUTPUT_STABILIZATION_STATUS;
+	virtual_sensors[5].sample_rate = sample_rate;
+	virtual_sensors[6].sensor_id = BSEC_OUTPUT_RUN_IN_STATUS;
+	virtual_sensors[6].sample_rate = sample_rate;
+
+	bsec_status = bsec_update_subscription(virtual_sensors, n_virtual_sensors, sensor_configs, &n_sensor_settings);
+
+	while (bsec_status != BSEC_OK) {
+		kout << "bsec_update_subscription error: " << bsec_status << endl;
+		arch.delay_ms(1000);
+	}
+	kout << "bsec_update_subscription OK" << endl;
+
+	arch.idle_loop();
+
+	return 0;
+}