105 lines
2.8 KiB
Rust
105 lines
2.8 KiB
Rust
use anyhow::anyhow;
|
|
use core::fmt::{Display, Formatter};
|
|
use embedded_hal::i2c::I2c;
|
|
|
|
///
|
|
/// Represents the I2C address of the BME680 Sensor.
|
|
///
|
|
#[derive(Debug, Clone, Copy, Default)]
|
|
pub enum Address {
|
|
/// Primary Address 0x76
|
|
#[default]
|
|
Primary,
|
|
/// Secondary Address 0x77
|
|
Secondary,
|
|
/// Alternative address
|
|
Other(u8),
|
|
}
|
|
|
|
impl Address {
|
|
pub fn addr(&self) -> u8 {
|
|
match &self {
|
|
Address::Primary => 0x76u8,
|
|
Address::Secondary => 0x77u8,
|
|
Address::Other(addr) => *addr,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Address {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
|
|
write!(f, "Address={:#01x}", self.addr())
|
|
}
|
|
}
|
|
|
|
/// I2CUtility is a simple wrapper over the I2c trait to make reading and writing data easier.
|
|
pub(crate) struct I2CUtility {}
|
|
|
|
impl I2CUtility {
|
|
/// Reads a byte from the I2C bus.
|
|
pub fn read_byte<I2C: I2c>(
|
|
i2c_handle: &mut I2C,
|
|
device_address: u8,
|
|
register_address: u8,
|
|
) -> Result<u8, anyhow::Error> {
|
|
let mut buf = [0; 1];
|
|
|
|
i2c_handle
|
|
.write(device_address, &[register_address])
|
|
.map_err(|e| {
|
|
anyhow!(
|
|
"Failed to write a byte {} to device {}: {:?}",
|
|
register_address,
|
|
device_address,
|
|
e
|
|
)
|
|
})?;
|
|
|
|
match i2c_handle.read(device_address, &mut buf) {
|
|
Ok(()) => Ok(buf[0]),
|
|
Err(_e) => Err(anyhow!(
|
|
"Failed to read byte {} from device {}",
|
|
register_address,
|
|
device_address
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// Reads bytes from the I2C bus.
|
|
pub fn read_bytes<I2C: I2c>(
|
|
i2c_handle: &mut I2C,
|
|
device_address: u8,
|
|
register_address: u8,
|
|
buffer: &mut [u8],
|
|
) -> Result<(), anyhow::Error> {
|
|
i2c_handle
|
|
.write(device_address, &[register_address])
|
|
.map_err(|_e| {
|
|
anyhow!(
|
|
"Failed to write a byte {} from device {}",
|
|
register_address,
|
|
device_address
|
|
)
|
|
})?;
|
|
|
|
match i2c_handle.read(device_address, buffer) {
|
|
Ok(()) => Ok(()),
|
|
Err(_e) => Err(anyhow!(
|
|
"Failed to read bytes from register {} and device {}",
|
|
register_address,
|
|
device_address
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// Writes bytes to the I2C bus.
|
|
pub fn write_bytes<I2C: I2c>(
|
|
i2c_handle: &mut I2C,
|
|
device_address: u8,
|
|
buffer: &[u8],
|
|
) -> Result<(), anyhow::Error> {
|
|
i2c_handle
|
|
.write(device_address, buffer)
|
|
.map_err(|_e| anyhow!("Failed to write bytes to address {}", device_address))
|
|
}
|
|
}
|