drogue-bme680 0.3.0

A crate to interface with the BME680 environmental sensor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

#![deny(unsafe_code)]
#![no_main]
#![no_std]

//! Example for using the BME680 sensor.
//!
//! ## STM32F411RE - Nucleo 64
//!
//! Connect the BME680 sensor to the I2C port #1 using pins PB8/PB9.
//!
//! ## STM32F723E - DISCOVERY
//!
//! Connect the BME680 to the STM32F723E DISCOVERY board via the Grove I2C connector
//! on the extension board.

#[cfg(not(feature = "env_logging"))]
use panic_rtt_target as _;
use rtt_target::rtt_init_print;

#[cfg(any(feature = "stm32f7xx", feature = "stm32f4xx"))]
use cortex_m_rt::entry;

#[cfg(feature = "stm32f4xx")]
use stm32f4 as _;
#[cfg(feature = "stm32f4xx")]
use stm32f4xx_hal as hal;
#[cfg(feature = "stm32f4xx")]
use stm32f4xx_hal::stm32::Peripherals as DevicePeripherals;

#[cfg(feature = "stm32f4xx")]
use hal::i2c::I2c;

#[cfg(feature = "stm32f7xx")]
use stm32f7 as _;
#[cfg(feature = "stm32f7xx")]
use stm32f7xx_hal as hal;
#[cfg(feature = "stm32f7xx")]
use stm32f7xx_hal::device::Peripherals as DevicePeripherals;

#[cfg(feature = "stm32f7xx")]
use hal::i2c::{BlockingI2c, Mode};

use hal::{delay::Delay, gpio::GpioExt, rcc::RccExt, time::U32Ext};

use drogue_bme680::{
    Address, Bme680Controller, Bme680Sensor, Configuration, DelayMsWrapper, StaticProvider,
};

use log::LevelFilter;
use rtt_logger::RTTLogger;

use embedded_time::duration::Milliseconds;

static LOGGER: RTTLogger = RTTLogger::new(LevelFilter::Info);

#[entry]
fn main() -> ! {
    rtt_init_print!(NoBlockSkip, 4096);
    log::set_logger(&LOGGER).unwrap();
    log::set_max_level(log::LevelFilter::Trace);
    log::info!("Starting up...");

    let p = DevicePeripherals::take().unwrap();
    let cp = cortex_m::Peripherals::take().unwrap();

    #[cfg(feature = "stm32f4xx")]
    let rcc = p.RCC.constrain();
    #[cfg(feature = "stm32f7xx")]
    let mut rcc = p.RCC.constrain();

    #[cfg(feature = "stm32f4xx")]
    let clocks = rcc.cfgr.sysclk(50.mhz()).freeze();
    #[cfg(feature = "stm32f7xx")]
    let clocks = rcc.cfgr.sysclk(216.mhz()).freeze();

    #[cfg(feature = "stm32f4xx")]
    let gpiob = p.GPIOB.split();
    #[cfg(feature = "stm32f7xx")]
    let gpioh = p.GPIOH.split();

    // delay implementation

    let delay = Delay::new(cp.SYST, clocks);
    let delay = DelayMsWrapper::new(delay);

    // init

    #[cfg(feature = "stm32f4xx")]
    let (sda, scl) = {
        let sda = gpiob.pb9.into_alternate_af4_open_drain();
        let scl = gpiob.pb8.into_alternate_af4_open_drain();
        (sda, scl)
    };
    #[cfg(feature = "stm32f7xx")]
    let (sda, scl) = {
        let sda = gpioh.ph5.into_alternate_af4();
        let scl = gpioh.ph4.into_alternate_af4();
        (sda, scl)
    };

    // Initialize I2C

    #[cfg(feature = "stm32f4xx")]
    let i2c = I2c::i2c1(p.I2C1, (scl, sda), 100.khz(), clocks);
    #[cfg(feature = "stm32f7xx")]
    let i2c = BlockingI2c::i2c2(
        p.I2C2,
        (scl, sda),
        Mode::standard(100_000.hz()),
        clocks,
        &mut rcc.apb1,
        100,
    );

    let bme680 = Bme680Sensor::from(i2c, Address::Secondary).unwrap();

    let mut controller =
        Bme680Controller::new(bme680, delay, Configuration::standard(), StaticProvider(25))
            .unwrap();

    let mut cnt = 0;

    loop {
        if cnt == 0 {
            log::info!(
                "Measured: {:?}",
                controller.measure(5, Milliseconds(50)).unwrap()
            );
        }
        cnt += 1;
        if cnt > 30 {
            cnt = 0;
        }

        controller.delay(Milliseconds(1_000));
    }
}