dnutiu/bme680-rust
dnutiu/bme680-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: soft_reset, init and set registers

Browse source
This commit is contained in:
Denis-Cosmin Nutiu 2024-02-27 22:05:18 +02:00
parent 4dc106450a
commit 432d3643c7
1 changed files with 30 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
src/lib.rs
View file

@ -202,6 +202,7 @@ impl PowerMode {
} }
} }
/// Retrieves the power mode value.
fn value(&self) -> u8 { fn value(&self) -> u8 {
match self { match self {
PowerMode::SleepMode => BME680_SLEEP_MODE, PowerMode::SleepMode => BME680_SLEEP_MODE,
@ -364,65 +365,68 @@ impl<I2C: I2c, D: DelayNs> Bme680<I2C, D>
D: DelayNs, D: DelayNs,
I2C: I2c, I2C: I2c,
{ {
/// Sends the soft reset command to the chip.
pub fn soft_reset( pub fn soft_reset(
i2c: &mut I2C, i2c_handle: &mut I2C,
delay: &mut D, delay: &mut D,
dev_id: Address, device_address: Address,
) -> Result<(), Bme680Error> { ) -> Result<(), Bme680Error> {
let tmp_buff: [u8; 2] = [BME680_SOFT_RESET_ADDR, BME680_SOFT_RESET_CMD]; let tmp_buff: [u8; 2] = [BME680_SOFT_RESET_ADDR, BME680_SOFT_RESET_CMD];
I2CUtility::write_bytes(i2c, dev_id.addr(), &tmp_buff)?; I2CUtility::write_bytes(i2c_handle, device_address.addr(), &tmp_buff)?;
delay.delay_ms(BME680_RESET_PERIOD as u32); delay.delay_ms(BME680_RESET_PERIOD as u32);
Ok(()) Ok(())
} }
/// Initializes the BME680 sensor with an I2C handle.
pub fn init( pub fn init(
mut i2c: I2C, mut i2c_handle: I2C,
delay: &mut D, delay: &mut D,
dev_id: Address, device_address: Address,
) -> Result<Bme680<I2C, D>, Bme680Error> { ) -> Result<Bme680<I2C, D>, Bme680Error> {
Bme680::soft_reset(&mut i2c, delay, dev_id)?; Bme680::soft_reset(&mut i2c_handle, delay, device_address)?;
debug!("Reading chip id"); debug!("Reading chip id");
/* Soft reset to restore it to default values*/ /* Soft reset to restore it to default values*/
let chip_id = I2CUtility::read_byte::<I2C>(&mut i2c, dev_id.addr(), BME680_CHIP_ID_ADDR)?; let chip_id = I2CUtility::read_byte::<I2C>(&mut i2c_handle, device_address.addr(), BME680_CHIP_ID_ADDR)?;
debug!("Chip id: {}", chip_id); debug!("Chip id: {}", chip_id);
if chip_id == BME680_CHIP_ID { if chip_id == BME680_CHIP_ID {
debug!("Reading calibration data"); debug!("Reading calibration data");
let calibration = Bme680::<I2C, D>::get_calib_data::<I2C>(&mut i2c, dev_id)?; let calibration_data = Bme680::<I2C, D>::get_calib_data::<I2C>(&mut i2c_handle, device_address)?;
debug!("Calibration data {:?}", calibration); debug!("Calibration data {:?}", calibration_data);
let dev = Bme680 { let device = Bme680 {
i2c_bus_handle: i2c, i2c_bus_handle: i2c_handle,
delay: PhantomData, delay: PhantomData,
device_address: dev_id, device_address,
calibration_data: calibration, calibration_data,
temperature_offset: 0.0, temperature_offset: 0.0,
power_mode: PowerMode::ForcedMode, power_mode: PowerMode::ForcedMode,
}; };
info!("Finished device init"); info!("Finished device init");
Ok(dev) Ok(device)
} else { } else {
error!("Device does not match chip id {}", BME680_CHIP_ID); error!("Device does not match chip id {}", BME680_CHIP_ID);
Err(Bme680Error::DeviceNotFound) Err(Bme680Error::DeviceNotFound)
} }
} }
fn bme680_set_regs( /// Sets the sensor registers.
fn bme680_set_registers(
&mut self, &mut self,
reg: &[(u8, u8)], registers: &[(u8, u8)],
) -> Result<(), Bme680Error> { ) -> Result<(), Bme680Error> {
if reg.is_empty() || reg.len() > (BME680_TMP_BUFFER_LENGTH / 2) as usize { if registers.is_empty() || registers.len() > (BME680_TMP_BUFFER_LENGTH / 2) as usize {
return Err(Bme680Error::InvalidLength); return Err(Bme680Error::InvalidLength);
} }
for (reg_addr, reg_data) in reg { for (register_address, register_data) in registers {
let tmp_buff: [u8; 2] = [*reg_addr, *reg_data]; let buffer: [u8; 2] = [*register_address, *register_data];
debug!( debug!(
"Setting register reg: {:?} tmp_buf: {:?}", "Setting register reg: {:?} buffer: {:?}",
reg_addr, tmp_buff register_address, buffer
); );
self.i2c_bus_handle self.i2c_bus_handle
.write(self.device_address.addr(), &tmp_buff) .write(self.device_address.addr(), &buffer)
.map_err(|_e| { I2CWrite })?; .map_err(|_e| { I2CWrite })?;
} }
@ -547,7 +551,7 @@ impl<I2C: I2c, D: DelayNs> Bme680<I2C, D>
element_index += 1; element_index += 1;
} }
self.bme680_set_regs(&reg[0..element_index])?; self.bme680_set_registers(&reg[0..element_index])?;
// Restore previous intended power mode // Restore previous intended power mode
self.power_mode = intended_power_mode; self.power_mode = intended_power_mode;
@ -635,7 +639,7 @@ impl<I2C: I2c, D: DelayNs> Bme680<I2C, D>
// Set to sleep // Set to sleep
tmp_pow_mode &= !BME680_MODE_MSK; tmp_pow_mode &= !BME680_MODE_MSK;
debug!("Setting to sleep tmp_pow_mode: {}", tmp_pow_mode); debug!("Setting to sleep tmp_pow_mode: {}", tmp_pow_mode);
self.bme680_set_regs(&[(BME680_CONF_T_P_MODE_ADDR, tmp_pow_mode)])?; self.bme680_set_registers(&[(BME680_CONF_T_P_MODE_ADDR, tmp_pow_mode)])?;
delay delay
.delay_ms(BME680_POLL_PERIOD_MS as u32); .delay_ms(BME680_POLL_PERIOD_MS as u32);
} else { } else {
@ -647,7 +651,7 @@ impl<I2C: I2c, D: DelayNs> Bme680<I2C, D>
if target_power_mode != PowerMode::SleepMode { if target_power_mode != PowerMode::SleepMode {
tmp_pow_mode = tmp_pow_mode & !BME680_MODE_MSK | target_power_mode.value(); tmp_pow_mode = tmp_pow_mode & !BME680_MODE_MSK | target_power_mode.value();
debug!("Already in sleep Target power mode: {}", tmp_pow_mode); debug!("Already in sleep Target power mode: {}", tmp_pow_mode);
self.bme680_set_regs(&[(BME680_CONF_T_P_MODE_ADDR, tmp_pow_mode)])?; self.bme680_set_registers(&[(BME680_CONF_T_P_MODE_ADDR, tmp_pow_mode)])?;
} }
Ok(()) Ok(())
} }
@ -789,7 +793,7 @@ impl<I2C: I2c, D: DelayNs> Bme680<I2C, D>
), ),
]; ];
self.bme680_set_regs(&reg) self.bme680_set_registers(&reg)
} }
fn get_gas_config(&mut self) -> Result<GasSettings, Bme680Error> { fn get_gas_config(&mut self) -> Result<GasSettings, Bme680Error> {