Struct aht20_driver::AHT20Initialized

pub struct AHT20Initialized<'a, I>
where
    I: Read + Write,
{ /* private fields */ }

AHT20Initialized is returned by AHT20::init() and the sensor is ready to read from.

In this state you can trigger a measurement with .measure(&mut delay).

Implementations

impl<'a, E, I> AHT20Initialized<'a, I>

where I: Read<Error = E> + Write<Error = E>,

pub fn measure( &mut self, delay: &mut (impl DelayUs<u16> + DelayMs<u16>) ) -> Result<SensorReading, Error<E>>

Measure temperature and humidity.

This masurement takes at least 80ms to complete. Together with the measure_once method, this is the work being carried out:

Command::TriggerMeasurement (0xAC)   ◄─┐
                 │                     │
                 ▼                     │
            Wait 80 ms                 │
                 │                     │
                 ▼                     │
          Read status byte    ◄──┐     │
                 │               │     │
                 ▼               │     │
            Status::Busy  ───►  Yes    │
                 │                     │
                 ▼                     │
                No                     │
                 │                     │
                 ▼                     │
            Read 7 bytes               │
                 │                     │
                 ▼                     │
            Calculate CRC              │
                 │                     │
                 ▼                     │
              CRC good ─► No  ─────────┘
                 │                     ▲
                 ▼                     │
                Yes                    │
                 │                     │
                 ▼                     │
          CRC-checked Ready ─► No ─────┘
                 │
                 ▼
                Yes
                 │
                 ▼
       Calc Humidity and Temp

pub fn measure_no_fp( &mut self, delay: &mut (impl DelayUs<u16> + DelayMs<u16>) ) -> Result<SensorReading, Error<E>>

This is identical to measure, except it doesn’t use floating point math.

This means it can be used on microcontrollers with no FP support, without having to bring in floating point math functions, which can take up a lot of space, and might be slow.

The drawback is that precision is limited to only integer values.

pub fn soft_reset( &mut self, delay: &mut (impl DelayUs<u16> + DelayMs<u16>) ) -> Result<(), Error<E>>

Send the Soft Reset command to the sensor.

This performs a soft reset, it’s unclear when this might be needed. It takes 20ms to complete and returns nothing.

pub fn destroy(self) -> Self

Destroys this initialized driver and lets you release the I2C bus I