Skip to content
Snippets Groups Projects
Commit b78f5950 authored by Birte Kristina Friesel's avatar Birte Kristina Friesel
Browse files

bme680-max44009-logger: add POSIX variant with BSEC support

parent 0319d8f5
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/app/bme680-max44009-logger/Kconfig 0 → 100644
+ 6
− 0
View file @ b78f5950
# Copyright 2020 Daniel Friesel
#
# SPDX-License-Identifier: CC0-1.0
prompt "BME680 + MAX44009 data logger"
depends on loop && !wakeup && meta_driver_i2c && driver_max44009 && driver_bme680
src/app/bme680-max44009-logger/Makefile.inc
+ 7
− 1
View file @ b78f5950
......@@ -12,4 +12,10 @@ ifdef app
COMMON_FLAGS += -DCONFIG_driver_bme680 -DCONFIG_driver_max44009
endif
COMMON_FLAGS += -DBME680_FLOAT_POINT_COMPENSATION
ifdef CONFIG_arch_posix
CXX_TARGETS += src/app/${app_dir}/posix.cc
else
CXX_TARGETS += src/app/${app_dir}/generic.cc
COMMON_FLAGS += -DBME680_FLOAT_POINT_COMPENSATION
endif
src/app/bme680-max44009-logger/generic.cc 0 → 100644
+ 161
− 0
View file @ b78f5950
/*
* Copyright 2022 Daniel Friesel
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "arch.h"
#include "driver/gpio.h"
#include "driver/stdout.h"
#if defined(CONFIG_meta_driver_hardware_i2c)
#include "driver/i2c.h"
#else
#include "driver/soft_i2c.h"
#endif
#include "driver/bme680.h"
#include "driver/bme680_util.h"
#include "driver/max44009.h"
#ifdef MULTIPASS_ARCH_arduino_nano
#define POWER_PIN GPIO::pc3
#endif
struct bme680_field_data data;
float lux;
int8_t bme680_status;
static void bme680_init(void)
{
bme680_status = bme680.init();
kout << "# BME680 init returned " << bme680_status << endl;
bme680.power_mode = BME680_FORCED_MODE;
bme680.tph_sett.os_hum = BME680_OS_2X;
bme680.tph_sett.os_pres = BME680_OS_16X;
bme680.tph_sett.os_temp = BME680_OS_2X;
bme680.gas_sett.run_gas = BME680_ENABLE_GAS_MEAS;
bme680.gas_sett.heatr_dur = 100;
bme680.gas_sett.heatr_temp = 300;
bme680.setSensorSettings(BME680_OST_SEL | BME680_OSP_SEL | BME680_OSH_SEL | BME680_GAS_SENSOR_SEL);
}
void loop(void)
{
static unsigned char i = 0;
if (lux >= 0 && bme680_status == 0) {
gpio.led_off(0);
} else {
gpio.led_on(0);
}
#ifdef POWER_PIN
if (lux < 0 || bme680_status != 0) {
if (i == 17) {
kout << "# Cycling power to I2C clients" << endl;
gpio.write(POWER_PIN, 0);
} else if (i == 18) {
gpio.write(POWER_PIN, 1);
} else if (i == 19) {
bme680_init();
}
}
#endif
#ifdef MULTIPASS_ARCH_arduino_nano
if ((i == 1) && (ADCSRA & _BV(ADIF))) {
uint8_t adcr_l = ADCL;
uint8_t adcr_h = ADCH;
uint16_t adcr = adcr_l + (adcr_h << 8);
uint16_t vcc = 1100L * 1023 / adcr;
TIFR1 |= _BV(TOV1);
ADCSRA |= _BV(ADIF);
kout << "VCC: " << vcc << endl;
}
#endif
if (i == 0) {
lux = max44009.getLux();
if (lux >= 0) {
kout << "MAX44009: ";
kout.printf_float(max44009.getLux());
kout << " lx" << endl;
} else {
kout << "# MAX44009 error" << endl;
}
}
if (i == 1 && bme680_status == 0) {
bme680_status = bme680.setSensorMode();
}
else if (i == 2) {
if (bme680_status == 0) {
bme680_status = bme680.getSensorData(&data);
}
if (bme680_status == 0) {
bme680.amb_temp = data.temperature;
kout << "BME680 temperature: " << data.temperature << " degC" << endl;
kout << "BME680 humidity: " << data.humidity << " %" << endl;
kout << "BME680 pressure: " << data.pressure / 100 << " hPa" << endl;
kout << "BME680 gas resistance: " << data.gas_resistance << endl;
} else {
kout << "# BME680 error " << bme680_status << endl;
}
}
i = (i + 1) % 20;
}
int main(void)
{
arch.setup();
gpio.setup();
kout.setup();
#ifdef POWER_PIN
gpio.output(POWER_PIN);
gpio.write(POWER_PIN, 1);
#endif
#ifdef MULTIPASS_ARCH_arduino_nano
kout << "# Reset reason: " << MCUSR << endl;
MCUSR = 0;
/* watchdog reset after ~4 seconds */
asm("wdr");
WDTCSR = _BV(WDCE) | _BV(WDE);
WDTCSR = _BV(WDE) | _BV(WDP3);
// One ADC conversion per four seconds
TCCR0A = 0;
TCCR0B = _BV(CS12) | _BV(CS10);
// Measure internal 1.1V bandgap using VCC as reference on each Timer 0 overflow
ADMUX = _BV(REFS0) | 0x0e;
ADCSRB = _BV(ADTS2);
ADCSRA = _BV(ADEN) | _BV(ADATE) | _BV(ADPS2) | _BV(ADPS1);
#endif
while (i2c.setup() != 0) {
kout << "# I2C setup failed" << endl;
arch.delay_ms(100);
}
kout << "# I2C setup OK" << endl;
bme680.intf = BME680_I2C_INTF;
bme680.read = bme680_i2c_read;
bme680.write = bme680_i2c_write;
bme680.delay_ms = bme680_delay_ms;
bme680.amb_temp = 25;
bme680_init();
arch.idle_loop();
return 0;
}
src/app/bme680-max44009-logger/main.cc
+ 5
− 157
View file @ b78f5950
/*
* Copyright 2021 Daniel Friesel
* Copyright 2022 Daniel Friesel
*
* SPDX-License-Identifier: BSD-2-Clause
* SPDX-License-Identifier: CC0-1.0
*/
#include "arch.h"
#include "driver/gpio.h"
#include "driver/stdout.h"
#if defined(CONFIG_meta_driver_hardware_i2c)
#include "driver/i2c.h"
#else
#include "driver/soft_i2c.h"
#endif
#include "driver/bme680.h"
#include "driver/bme680_util.h"
#include "driver/max44009.h"
#ifdef MULTIPASS_ARCH_arduino_nano
#define POWER_PIN GPIO::pc3
#endif
struct bme680_field_data data;
float lux;
int8_t bme680_status;
static void bme680_init(void)
{
bme680_status = bme680.init();
kout << "# BME680 init returned " << bme680_status << endl;
bme680.power_mode = BME680_FORCED_MODE;
bme680.tph_sett.os_hum = BME680_OS_2X;
bme680.tph_sett.os_pres = BME680_OS_16X;
bme680.tph_sett.os_temp = BME680_OS_2X;
bme680.gas_sett.run_gas = BME680_ENABLE_GAS_MEAS;
bme680.gas_sett.heatr_dur = 100;
bme680.gas_sett.heatr_temp = 300;
bme680.setSensorSettings(BME680_OST_SEL | BME680_OSP_SEL | BME680_OSH_SEL | BME680_GAS_SENSOR_SEL);
}
void loop(void)
{
static unsigned char i = 0;
if (lux >= 0 && bme680_status == 0) {
gpio.led_off(0);
} else {
gpio.led_on(0);
}
#ifdef POWER_PIN
if (lux < 0 || bme680_status != 0) {
if (i == 17) {
kout << "# Cycling power to I2C clients" << endl;
gpio.write(POWER_PIN, 0);
} else if (i == 18) {
gpio.write(POWER_PIN, 1);
} else if (i == 19) {
bme680_init();
}
}
#endif
#ifdef MULTIPASS_ARCH_arduino_nano
if ((i == 1) && (ADCSRA & _BV(ADIF))) {
uint8_t adcr_l = ADCL;
uint8_t adcr_h = ADCH;
uint16_t adcr = adcr_l + (adcr_h << 8);
uint16_t vcc = 1100L * 1023 / adcr;
TIFR1 |= _BV(TOV1);
ADCSRA |= _BV(ADIF);
kout << "VCC: " << vcc << endl;
}
#endif
if (i == 0) {
lux = max44009.getLux();
if (lux >= 0) {
kout << "MAX44009: ";
kout.printf_float(max44009.getLux());
kout << " lx" << endl;
} else {
kout << "# MAX44009 error" << endl;
}
}
if (i == 1 && bme680_status == 0) {
bme680_status = bme680.setSensorMode();
}
else if (i == 2) {
if (bme680_status == 0) {
bme680_status = bme680.getSensorData(&data);
}
if (bme680_status == 0) {
bme680.amb_temp = data.temperature;
kout << "BME680 temperature: " << data.temperature << " degC" << endl;
kout << "BME680 humidity: " << data.humidity << " %" << endl;
kout << "BME680 pressure: " << data.pressure / 100 << " hPa" << endl;
kout << "BME680 gas resistance: " << data.gas_resistance << endl;
} else {
kout << "# BME680 error " << bme680_status << endl;
}
}
i = (i + 1) % 20;
}
int main(void)
{
arch.setup();
gpio.setup();
kout.setup();
#ifdef POWER_PIN
gpio.output(POWER_PIN);
gpio.write(POWER_PIN, 1);
#endif
#ifdef MULTIPASS_ARCH_arduino_nano
kout << "# Reset reason: " << MCUSR << endl;
MCUSR = 0;
/* watchdog reset after ~4 seconds */
asm("wdr");
WDTCSR = _BV(WDCE) | _BV(WDE);
WDTCSR = _BV(WDE) | _BV(WDP3);
// One ADC conversion per four seconds
TCCR0A = 0;
TCCR0B = _BV(CS12) | _BV(CS10);
// Measure internal 1.1V bandgap using VCC as reference on each Timer 0 overflow
ADMUX = _BV(REFS0) | 0x0e;
ADCSRB = _BV(ADTS2);
ADCSRA = _BV(ADEN) | _BV(ADATE) | _BV(ADPS2) | _BV(ADPS1);
#endif
while (i2c.setup() != 0) {
kout << "# I2C setup failed" << endl;
arch.delay_ms(100);
}
kout << "# I2C setup OK" << endl;
bme680.intf = BME680_I2C_INTF;
bme680.read = bme680_i2c_read;
bme680.write = bme680_i2c_write;
bme680.delay_ms = bme680_delay_ms;
bme680.amb_temp = 25;
bme680_init();
arch.idle_loop();
return 0;
}
/*
* Intentionally left blank.
*/
src/app/bme680-max44009-logger/posix.cc 0 → 100644
+ 320
− 0
View file @ b78f5950
/*
* Copyright 2022 Daniel Friesel
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "config.h"
#ifdef CONFIG_driver_bme680_bsec_save_state
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define BSEC_STATE_PATH TOSTRING(CONFIG_driver_bme680_bsec_state_path)
#include <stdio.h>
#endif
#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"
#else
#include "driver/soft_i2c.h"
#endif
#include "driver/bme680.h"
#include "driver/bme680_util.h"
#include "driver/bme680-bsec-armv6/bsec_interface.h"
#include "driver/max44009.h"
bsec_bme_settings_t sensor_settings;
void load_bsec_state()
{
uint8_t serialized_state[BSEC_MAX_STATE_BLOB_SIZE];
uint8_t work_buffer[BSEC_MAX_STATE_BLOB_SIZE];
FILE *f = fopen(BSEC_STATE_PATH, "r");
if (f != NULL) {
size_t serialized_state_size = fread(serialized_state, BSEC_MAX_STATE_BLOB_SIZE, sizeof(uint8_t), f);
if (serialized_state_size > 0) {
bsec_library_return_t bsec_status = bsec_set_state(serialized_state, BSEC_MAX_STATE_BLOB_SIZE, work_buffer, BSEC_MAX_STATE_BLOB_SIZE);
if (bsec_status < 0) {
kout << "# bsec_set_state error: " << bsec_status << endl;
}
if (bsec_status > 0) {
kout << "# bsec_set_state warning: " << bsec_status << endl;
}
}
if (fclose(f) == EOF) {
perror("fclose");
}
} else {
// file doesn't exist. that's harmless.
perror("fopen");
}
}
void save_bsec_state()
{
uint32_t serialized_state_size;
uint8_t serialized_state[BSEC_MAX_STATE_BLOB_SIZE];
uint8_t work_buffer[BSEC_MAX_STATE_BLOB_SIZE];
bsec_library_return_t status = bsec_get_state(0, serialized_state, BSEC_MAX_STATE_BLOB_SIZE, work_buffer, BSEC_MAX_STATE_BLOB_SIZE, &serialized_state_size);
if (status < 0) {
kout << "# bsec_get_state error: " << status << endl;
return;
}
if (status > 0) {
kout << "# bsec_get_state warning: " << status << endl;
}
FILE *f = fopen(BSEC_STATE_PATH, "w");
if (f == NULL) {
perror("fopen");
return;
}
if (fwrite(serialized_state, sizeof(uint8_t), serialized_state_size, f) < serialized_state_size) {
perror("fwrite");
}
if (fclose(f) == EOF) {
perror("fclose");
}
}
int configure_bsec()
{
bsec_sensor_configuration_t virtual_sensors[8];
unsigned char n_virtual_sensors = 8;
bsec_sensor_configuration_t sensor_configs[BSEC_MAX_PHYSICAL_SENSOR];
unsigned char n_sensor_settings = BSEC_MAX_PHYSICAL_SENSOR;
float sample_rate = BSEC_SAMPLE_RATE_LP;
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_RAW_TEMPERATURE;
virtual_sensors[5].sample_rate = sample_rate;
virtual_sensors[6].sensor_id = BSEC_OUTPUT_RAW_HUMIDITY;
virtual_sensors[6].sample_rate = sample_rate;
virtual_sensors[7].sensor_id = BSEC_OUTPUT_STATIC_IAQ;
virtual_sensors[7].sample_rate = sample_rate;
bsec_library_return_t bsec_status = bsec_update_subscription(virtual_sensors, n_virtual_sensors, sensor_configs, &n_sensor_settings);
if (bsec_status != BSEC_OK) {
kout << "# bsec_update_subscription error: " << bsec_status << endl;
return 1;
}
kout << "# bsec_update_subscription OK" << endl;
return 0;
}
void control_bsec(int64_t now)
{
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;
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;
}
if (!sensor_settings.trigger_measurement) {
return;
}
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;
}
kout << "bme680 ";
for (uint8_t i = 0; i < num_bsec_outputs; i++) {
if (i > 0) {
kout << ",";
}
switch (bsec_outputs[i].sensor_id) {
case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE:
kout << "temperature_celsius=" << bsec_outputs[i].signal;
break;
case BSEC_OUTPUT_RAW_TEMPERATURE:
kout << "raw_temperature_celsius=" << bsec_outputs[i].signal;
break;
case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY:
kout << "humidity_relpercent=" << bsec_outputs[i].signal;
break;
case BSEC_OUTPUT_RAW_HUMIDITY:
kout << "raw_humidity_relpercent=" << bsec_outputs[i].signal;
break;
case BSEC_OUTPUT_RAW_PRESSURE:
kout << "pressure_hpa=" << bsec_outputs[i].signal / 100;
break;
case BSEC_OUTPUT_RAW_GAS:
kout << "air_quality_ohm=" << bsec_outputs[i].signal;
break;
case BSEC_OUTPUT_IAQ:
if (bsec_outputs[i].accuracy > 0) {
kout << "air_quality_index=" << bsec_outputs[i].signal << ",";
}
kout << "air_quality_accuracy_index=" << bsec_outputs[i].accuracy;
break;
case BSEC_OUTPUT_STATIC_IAQ:
kout << "air_quality_raw=" << bsec_outputs[i].signal;
break;
default:
continue;
}
}
kout << endl;
}
}
void loop(void)
{
static uint16_t i = 0;
int64_t now = uptime.get_us() * 1000;
if ((now < sensor_settings.next_call) && (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;
}
if (now >= sensor_settings.next_call) {
control_bsec(now);
}
if ((i%20) == 0) {
float lux = max44009.getLux();
if (lux >= 0) {
kout << "max44009 illuminance_lux=" << max44009.getLux() << endl;
} else {
kout << "# MAX44009 error" << endl;
}
}
if ((i%1800) == 0) {
save_bsec_state();
}
i++;
}
int main(void)
{
arch.setup();
gpio.setup();
kout.setup();
while (i2c.setup() != 0) {
kout << "# I2C setup failed" << endl;
return 1;
}
kout << "# I2C setup OK" << endl;
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;
return 1;
}
kout << "# BME680 init OK" << endl;
bsec_library_return_t bsec_status = bsec_init();
while (bsec_status != BSEC_OK) {
kout << "# BSEC init failed: " << bsec_status << endl;
return 1;
}
kout << "# BSEC init OK" << endl;
load_bsec_state();
if (configure_bsec() != 0) {
return 1;
}
arch.idle_loop();
return 0;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment