bmp5xx 2.0.0

True-to-spec async I2C driver for the BMP580/BMP581/BMP585 barometric pressure sensors.
Documentation 
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

// Copyright (C) 2026 Olivér Pirger
// SPDX-License-Identifier: GPL-3.0-or-later

//! Configuration options for interrupts.

use embedded_hal_async::{delay::DelayNs, i2c::I2c};

use crate::{
    Bmp5xx,
    error::{Error::WriteError, Result},
    register::{INT_CONFIG, INT_SOURCE},
};

/// Sensor interrupts configuration.
pub struct Interrupt {
    enabled: bool,
    source: IntSource,
    mode: IntMode,
    polarity: IntPolarity,
    int_pin: IntPin,
}

impl Default for Interrupt {
    fn default() -> Self {
        Self {
            enabled: false,
            source: IntSource::default(),
            mode: IntMode::Pulsed,
            polarity: IntPolarity::ActiveLow,
            int_pin: IntPin::PushPull,
        }
    }
}

impl Interrupt {
    /// Enable or disable interrupts.
    pub fn enable(mut self, enable: bool) -> Self {
        self.enabled = enable;
        self
    }

    /// Sets interrupt mode.
    pub fn mode(mut self, mode: IntMode) -> Self {
        self.mode = mode;
        self
    }

    /// Sets interrupt polarity.
    pub fn polarity(mut self, polarity: IntPolarity) -> Self {
        self.polarity = polarity;
        self
    }

    /// Sets interrupt pin behaviour.
    pub fn pin(mut self, pin: IntPin) -> Self {
        self.int_pin = pin;
        self
    }
}

/// Decide which events trigger an interrupt.
pub struct IntSource {
    data_ready: bool,
    fifo_full: bool,
    fifo_threshold: bool,
    pressure_oor: bool,
}

impl Default for IntSource {
    fn default() -> Self {
        Self {
            data_ready: true,
            fifo_full: false,
            fifo_threshold: false,
            pressure_oor: false,
        }
    }
}

impl IntSource {
    /// Whether new data triggers an interrupt.
    pub fn data_ready(mut self, data_ready: bool) -> Self {
        self.data_ready = data_ready;
        self
    }

    /// Whether the FIFO filling up triggers an interrupt.
    pub fn fifo_full(mut self, fifo_full: bool) -> Self {
        self.fifo_full = fifo_full;
        self
    }

    /// Whether the FIFO reaching a threshold triggers an interrupt.
    pub fn fifo_threshold(mut self, fifo_threshold: bool) -> Self {
        self.fifo_threshold = fifo_threshold;
        self
    }

    /// Whether an out-of-range pressure reading triggers an interrupt.
    pub fn pressure_oor(mut self, pressure_oor: bool) -> Self {
        self.pressure_oor = pressure_oor;
        self
    }
}

/// Whether the interrupt pin is pulsed or held until cleared.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
#[repr(u8)]
pub enum IntMode {
    /// Interrupt is asserted for a short duration.
    Pulsed = 0x00,
    /// Interrupt is held until cleared.
    Latched = 0x01,
}

/// Whether the interrupt pin is active low or high.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
#[repr(u8)]
pub enum IntPolarity {
    /// Interrupt is asserted by pulling the pin low.
    ActiveLow = 0x00,
    /// Interrupt is asserted by pulling the pin high.
    ActiveHigh = 0x01,
}

/// Whether the interrupt pin is push-pull or open-drain.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
#[repr(u8)]
pub enum IntPin {
    /// Pin is driven both high and low by the sensor.
    PushPull = 0x00,
    /// Pin is only pulled low. This mode requires an external pull-up.
    OpenDrain = 0x01,
}

impl<I2C, D> Bmp5xx<I2C, D>
where
    I2C: I2c,
    D: DelayNs,
{
    /// Configures interrupts for the sensor.
    pub async fn int(&mut self, conf: Interrupt) -> Result<()> {
        // set interrupt sources
        let source = conf.source;
        self.i2c
            .write(
                self.addr,
                &[
                    INT_SOURCE,
                    (source.pressure_oor as u8) << 3
                        | (source.fifo_threshold as u8) << 2
                        | (source.fifo_full as u8) << 1
                        | source.data_ready as u8,
                ],
            )
            .await
            .map_err(|_| WriteError)?;

        // configure interrupts
        self.i2c
            .write(
                self.addr,
                &[
                    INT_CONFIG,
                    (conf.enabled as u8) << 3
                        | (conf.int_pin as u8) << 2
                        | (conf.polarity as u8) << 1
                        | conf.mode as u8,
                ],
            )
            .await
            .map_err(|_| WriteError)
    }
}