Trait bsec::bme::BmeSensor

source ·

pub trait BmeSensor {
    type Error: Debug;

    // Required methods
    fn start_measurement(
        &mut self,
        settings: &BmeSettingsHandle<'_>
    ) -> Result<Duration, Self::Error>;
    fn get_measurement(&mut self) -> Result<Vec<Input>, Self::Error>;
}

Expand description

Trait to implement for your specific hardware to obtain measurements from the BME sensor.

Example

An rudimentary implementation for the BME680 sensor with the bme680 crate might look like this:

use bme680::{Bme680, OversamplingSetting, PowerMode, SettingsBuilder};
use bsec::{Input, InputKind};
use bsec::bme::{BmeSensor, BmeSettingsHandle};
use embedded_hal::blocking::{delay::DelayMs, i2c};
use std::fmt::Debug;
use std::time::Duration;

pub struct Bme680Sensor<I2C, D>
where
    D: DelayMs<u8>,
    I2C: i2c::Read + i2c::Write
{
    bme680: Bme680<I2C, D>,
    delay: D,
}

impl<I2C, D> BmeSensor for Bme680Sensor<I2C, D>
where
    D: DelayMs<u8>,
    I2C: i2c::Read + i2c::Write,
    <I2C as i2c::Read>::Error: Debug,
    <I2C as i2c::Write>::Error: Debug,
{
    type Error = bme680::Error<<I2C as i2c::Read>::Error, <I2C as i2c::Write>::Error>;
     
    fn start_measurement(
        &mut self,
        settings: &BmeSettingsHandle,
    ) -> Result<std::time::Duration, Self::Error> {
        let settings = SettingsBuilder::new()
            .with_humidity_oversampling(OversamplingSetting::from_u8(
                settings.humidity_oversampling(),
            ))
            .with_temperature_oversampling(OversamplingSetting::from_u8(
                settings.temperature_oversampling(),
            ))
            .with_pressure_oversampling(OversamplingSetting::from_u8(
                settings.pressure_oversampling(),
            ))
            .with_run_gas(settings.run_gas())
            .with_gas_measurement(
                Duration::from_millis(settings.heating_duration().into()),
                settings.heater_temperature(),
                20,
            )
            .build();
        self.bme680
            .set_sensor_settings(&mut self.delay, settings)?;
        let profile_duration = self.bme680.get_profile_dur(&settings.0)?;
        self.bme680.set_sensor_mode(&mut self.delay, PowerMode::ForcedMode)?;
        Ok(profile_duration)
    }

    fn get_measurement(&mut self) -> nb::Result<Vec<Input>, Self::Error> {
        let (data, _state) = self.bme680.get_sensor_data(&mut self.delay)?;
        Ok(vec![
            Input {
                sensor: InputKind::Temperature,
                signal: data.temperature_celsius(),
            },
            Input {
                sensor: InputKind::Pressure,
                signal: data.pressure_hpa(),
            },
            Input {
                sensor: InputKind::Humidity,
                signal: data.humidity_percent(),
            },
            Input {
                sensor: InputKind::GasResistor,
                signal: data.gas_resistance_ohm() as f32,
            },
        ])
    }
}

Required Associated Types§

source

type Error: Debug

Error type if an operation with the sensor fails.

Required Methods§

source

fn start_measurement( &mut self, settings: &BmeSettingsHandle<'_> ) -> Result<Duration, Self::Error>

Starts a sensor measurement.

Use settings to configure your BME sensor as requested by the BSEC algorithm.

Shoud return the duration after which the measurement will be available or an error.

source

fn get_measurement(&mut self) -> Result<Vec<Input>, Self::Error>

Read a finished sensor measurement.

Returns the sensor measurements as a vector with an item for each physical sensor read.

To compensate for heat sources near the sensor, add an additional output to the vector, using the sensor type super::InputKind::HeatSource and the desired correction in degrees Celsius.