use core::fmt;
use embedded_hal::i2c::{I2c, Operation};
use super::RegisterInterface;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum I2cAddress {
Low = 0x76,
High = 0x77,
}
impl From<I2cAddress> for u8 {
fn from(value: I2cAddress) -> Self {
value as Self
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct InvalidI2cAddress(pub u8);
impl fmt::Display for InvalidI2cAddress {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "invalid BME68x I2C address 0x{:02x}", self.0)
}
}
impl TryFrom<u8> for I2cAddress {
type Error = InvalidI2cAddress;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
0x76 => Ok(Self::Low),
0x77 => Ok(Self::High),
other => Err(InvalidI2cAddress(other)),
}
}
}
#[derive(Debug)]
pub struct I2cInterface<I2C> {
bus: I2C,
address: I2cAddress,
}
impl<I2C> I2cInterface<I2C> {
pub const fn new(bus: I2C, address: I2cAddress) -> Self {
Self { bus, address }
}
pub const fn address(&self) -> I2cAddress {
self.address
}
pub fn release(self) -> I2C {
self.bus
}
}
impl<I2C> RegisterInterface for I2cInterface<I2C>
where
I2C: I2c,
{
type Error = I2C::Error;
fn read(&mut self, register: u8, data: &mut [u8]) -> Result<(), Self::Error> {
self.bus.write_read(self.address.into(), &[register], data)
}
fn write(&mut self, register: u8, data: &[u8]) -> Result<(), Self::Error> {
let command = [register];
self.bus.transaction(
self.address.into(),
&mut [Operation::Write(&command), Operation::Write(data)],
)
}
fn write_pairs(&mut self, registers: &[u8], values: &[u8]) -> Result<(), Self::Error> {
if registers.is_empty() {
return Ok(());
}
if registers.len() > 10 || registers.len() != values.len() {
for (®ister, &value) in registers.iter().zip(values) {
self.write(register, core::slice::from_ref(&value))?;
}
return Ok(());
}
let mut wire = [0_u8; 20];
for (index, (®ister, &value)) in registers.iter().zip(values).enumerate() {
wire[index * 2] = register;
wire[index * 2 + 1] = value;
}
self.bus
.write(self.address.into(), &wire[..registers.len() * 2])
}
}