Struct lis3dh_async::Lis3dh

pub struct Lis3dh<CORE> { /* private fields */ }

LIS3DH driver.

Implementations

impl<I2C, E> Lis3dh<Lis3dhI2C<I2C>>where
    I2C: I2c<Error = E>,

pub async fn new_i2c(i2c: I2C, address: SlaveAddr) -> Result<Self, Error<E>>

Create a new LIS3DH driver from the given I2C peripheral using the default config. Default is Hz_400 HighResolution. An example using the nrf52840_hal:

use nrf52840_hal::gpio::{Level, PushPull};
use lis3dh::Lis3dh;

let peripherals = nrf52840_hal::pac::Peripherals::take().unwrap();
let pins = p0::Parts::new(peripherals.P0);

let twim0_scl = pins.p0_31.into_floating_input().degrade();
let twim0_sda = pins.p0_30.into_floating_input().degrade();

let i2c = nrf52840_hal::twim::Twim::new(
    peripherals.TWIM0,
    nrf52840_hal::twim::Pins {
        scl: twim0_scl,
        sda: twim0_sda,
    },
    nrf52840_hal::twim::Frequency::K400,
);

let lis3dh = Lis3dh::new_i2c(i2c, lis3dh::SlaveAddr::Default).unwrap();

pub async fn new_i2c_without_config(i2c: I2C, address: SlaveAddr) -> Self

Create a new driver instance without talking to the LIS3DH. This can be useful when the accelerometer was already on while the microcontroller rebooted and you need continuous operation.

pub async fn new_i2c_with_config(
    i2c: I2C,
    address: SlaveAddr,
    config: Configuration
) -> Result<Self, Error<E>>

impl<SPI, ESPI> Lis3dh<Lis3dhSPI<SPI>>where
    SPI: SpiDevice<Error = ESPI>,
    SPI::Bus: SpiBus + SpiBusWrite,

pub async fn new_spi(spi: SPI) -> Result<Self, Error<ESPI>>

Create a new LIS3DH driver from the given SPI peripheral. An example using the nrf52840_hal:

use nrf52840_hal::gpio::{p0::{Parts, P0_28}, *};
use nrf52840_hal::spim::Spim;
use lis3dh::Lis3dh;

let peripherals = nrf52840_hal::pac::Peripherals::take().unwrap();
let port0 = Parts::new(peripherals.P0);

// define the chip select pin
let cs: P0_28<Output<PushPull>> = port0.p0_28.into_push_pull_output(Level::High);

// spi pins: clock, miso, mosi
let pins = nrf52840_hal::spim::Pins {
    sck: port0.p0_31.into_push_pull_output(Level::Low).degrade(),
    miso: Some(port0.p0_30.into_push_pull_output(Level::Low).degrade()),
    mosi: Some(port0.p0_29.into_floating_input().degrade()),
};

// set up the spi peripheral
let spi = Spim::new(
    peripherals.SPIM2,
    pins,
    nrf52840_hal::spim::Frequency::K500,
    nrf52840_hal::spim::MODE_0,
    0,
);
// create and initialize the sensor
let lis3dh = Lis3dh::new_spi(spi, cs).unwrap();

pub async fn new_spi_without_config(spi: SPI) -> Self

Create a new driver instance without talking to the LIS3DH. This can be useful when the accelerometer was already on while the microcontroller rebooted and you need continuous operation.

pub async fn new_spi_with_config(
    spi: SPI,
    config: Configuration
) -> Result<Self, Error<ESPI>>

impl<CORE> Lis3dh<CORE>where
    CORE: Lis3dhCore,

pub async fn configure(
    &mut self,
    conf: Configuration
) -> Result<(), Error<CORE::BusError>>

Configure the device

pub async fn get_device_id(&mut self) -> Result<u8, Error<CORE::BusError>>

WHO_AM_I register.

pub async fn set_mode(&mut self, mode: Mode) -> Result<(), Error<CORE::BusError>>

Operating mode selection. CTRL_REG1: LPen bit, CTRL_REG4: HR bit. You need to wait for stabilization after setting. In future this function will be deprecated and instead take a Delay to do this for you.

From	To	Wait for
HighResolution	LowPower	1/datarate
HighResolution	Normal	1/datarate
Normal	LowPower	1/datarate
Normal	HighResolution	7/datarate
LowPower	Normal	1/datarate
LowPower	HighResolution	7/datarate

pub async fn get_mode(&mut self) -> Result<Mode, Error<CORE::BusError>>

Read the current operating mode.

pub async fn set_datarate(
    &mut self,
    datarate: DataRate
) -> Result<(), Error<CORE::BusError>>

Data rate selection.

pub async fn get_datarate(&mut self) -> Result<DataRate, Error<CORE::BusError>>

Read the current data selection rate.

pub async fn set_range(
    &mut self,
    range: Range
) -> Result<(), Error<CORE::BusError>>

Full-scale selection.

pub async fn get_range(&mut self) -> Result<Range, Error<CORE::BusError>>

Read the current full-scale.

pub async fn set_ref(
    &mut self,
    reference: u8
) -> Result<(), Error<CORE::BusError>>

Set REFERENCE register.

pub async fn get_ref(&mut self) -> Result<u8, Error<CORE::BusError>>

Read the REFERENCE register.

pub async fn get_status(&mut self) -> Result<DataStatus, Error<CORE::BusError>>

Accelerometer data-available status.

pub async fn is_data_ready(&mut self) -> Result<bool, Error<CORE::BusError>>

Convenience function for STATUS_REG to confirm all three X, Y and Z-axis have new data available for reading by accel_raw and associated function calls.

pub async fn enable_temp(
    &mut self,
    enable: bool
) -> Result<(), Error<CORE::BusError>>

Temperature sensor enable. TEMP_CGF_REG: TEMP_EN, the BDU bit in CTRL_REG4 is also set.

pub async fn get_temp_out(&mut self) -> Result<i16, Error<CORE::BusError>>

Raw temperature sensor data as i16. The temperature sensor must be enabled via enable_temp prior to reading.

pub async fn get_temp_outf(&mut self) -> Result<f32, Error<CORE::BusError>>

Temperature sensor data converted to f32. Output is in degree celsius. The temperature sensor must be enabled via enable_temp prior to reading.

pub async fn register_clear_bits(
    &mut self,
    reg: Register,
    bits: u8
) -> Result<(), Error<CORE::BusError>>

Clear the given bits in the given register. For example:

lis3dh.register_clear_bits(0b0110)

This call clears (sets to 0) the bits at index 1 and 2. Other bits of the register are not touched.

pub async fn register_set_bits(
    &mut self,
    reg: Register,
    bits: u8
) -> Result<(), Error<CORE::BusError>>

Set the given bits in the given register. For example:

lis3dh.register_set_bits(0b0110)

This call sets to 1 the bits at index 1 and 2. Other bits of the register are not touched.

pub async fn configure_interrupt_pin<P: IrqPin>(
    &mut self,
    pin: P
) -> Result<(), Error<CORE::BusError>>

Configure one of the interrupt pins

lis3dh.configure_interrupt_pin(IrqPin1Config {
    // Raise if interrupt 1 is raised
    ia1_en: true,
    // Disable for all other interrupts
    ..IrqPin1Config::default()
})?;

pub async fn configure_irq_src<I: Interrupt>(
    &mut self,
    int: I,
    interrupt_mode: InterruptMode,
    interrupt_config: InterruptConfig
) -> Result<(), Error<CORE::BusError>>

Configure an IRQ source

Example: configure interrupt 1 to fire when there is movement along any of the axes.

lis3dh.configure_irq_src(
    lis3dh::Interrupt1,
    lis3dh::InterruptMode::Movement,
    lis3dh::InterruptConfig::high_and_low(),
)?;

pub async fn configure_irq_src_and_control<I: Interrupt>(
    &mut self,
    _int: I,
    interrupt_mode: InterruptMode,
    interrupt_config: InterruptConfig,
    latch_interrupt_request: LatchInterruptRequest,
    detect_4d: Detect4D
) -> Result<(), Error<CORE::BusError>>

Configure an IRQ source.

LIS (latch interrupt request) will latch (keep active) the interrupt until the Lis3dh::get_irq_src is read.

4D detection is a subset of the 6D detection where detection on the Z axis is disabled. This setting only has effect when the interrupt mode is either Movement or Position.

Example: configure interrupt 1 to fire when there is movement along any of the axes.

lis3dh.configure_irq_src(
    lis3dh::Interrupt1,
    lis3dh::InterruptMode::Movement,
    lis3dh::InterruptConfig::high_and_low(),
    lis3dh::LatchInterruptRequest::Enable,
    lis3dh::Detect4D::Enable,
)?;

pub async fn configure_irq_duration<I: Interrupt>(
    &mut self,
    _int: I,
    duration: Duration
) -> Result<(), Error<CORE::BusError>>

Set the minimum duration for the Interrupt event to be recognized.

Example: the event has to last at least 25 miliseconds to be recognized.

// let mut lis3dh = ...
let duration = Duration::miliseconds(DataRate::Hz_400, 25.0);
lis3dh.configure_irq_duration(duration);

pub async fn configure_irq_threshold<I: Interrupt>(
    &mut self,
    _int: I,
    threshold: Threshold
) -> Result<(), Error<CORE::BusError>>

Set the minimum magnitude for the Interrupt event to be recognized.

Example: the event has to have a magnitude of at least 1.1g to be recognized.

// let mut lis3dh = ...
let threshold = Threshold::g(Range::G2, 1.1);
lis3dh.configure_irq_threshold(threshold);

pub async fn get_irq_src<I: Interrupt>(
    &mut self,
    _int: I
) -> Result<InterruptSource, Error<CORE::BusError>>

Get interrupt source. The interrupt_active field is true when an interrupt is active. The other fields specify what measurement caused the interrupt.

pub async fn configure_switch_to_low_power(
    &mut self,
    threshold: Threshold,
    duration: Duration
) -> Result<(), Error<CORE::BusError>>

Configure ‘Sleep to wake’ and ‘Return to sleep’ threshold and duration.

The LIS3DH can be programmed to automatically switch to low-power mode upon recognition of a determined event.
Once the event condition is over, the device returns back to the preset normal or highresolution mode.

Example: enter low-power mode. When a measurement above 1.1g is registered, then wake up for 25ms to send the data.

// let mut lis3dh = ...

let range = Range::default();
let data_rate = DataRate::Hz_400;

let threshold = Threshold::g(range, 1.1);
let duration = Duration::miliseconds(data_rate, 25.0);

lis3dh.configure_switch_to_low_power(threshold, duration)?;

lis3dh.set_datarate(data_rate)?;

pub async fn reboot_memory_content(
    &mut self
) -> Result<(), Error<CORE::BusError>>

Reboot memory content

pub async fn enable_fifo(
    &mut self,
    mode: FifoMode,
    threshold: u8
) -> Result<(), Error<CORE::BusError>>

Configures FIFO and then enables it

pub async fn disable_fifo(&mut self) -> Result<(), Error<CORE::BusError>>

Disable FIFO. This resets the FIFO state

pub async fn get_fifo_status(
    &mut self
) -> Result<FifoStatus, Error<CORE::BusError>>

Get the status of the FIFO

pub async fn accel_norm(&mut self) -> Result<F32x3, Error<CORE::BusError>>

Get normalized ±g reading from the accelerometer. You should be reading based on data ready interrupt or if reading in a tight loop you should waiting for is_data_ready.

pub async fn sample_rate(&mut self) -> Result<f32, Error<CORE::BusError>>

Get the sample rate of the accelerometer data.

pub async fn accel_raw(&mut self) -> Result<I16x3, Error<CORE::BusError>>

Get raw acceleration data from the accelerometer. You should be reading based on data ready interrupt or if reading in a tight loop you should waiting for is_data_ready.

Trait Implementations

impl<CORE> Lis3dhCore for Lis3dh<CORE>where
    CORE: Lis3dhCore,

type BusError = <CORE as Lis3dhCore>::BusError

type WriteRegisterFuture<'a>
where
    Self: 'a = impl Future<Output = Result<(), Error<<Lis3dh<CORE> as Lis3dhCore>::BusError>>> + 'a

type ReadRegisterFuture<'a>
where
    Self: 'a = impl Future<Output = Result<u8, Error<<Lis3dh<CORE> as Lis3dhCore>::BusError>>> + 'a

type ReadAccelBytesFuture<'a>
where
    Self: 'a = impl Future<Output = Result<[u8; 6], Error<<Lis3dh<CORE> as Lis3dhCore>::BusError>>> + 'a

fn write_register(
    &mut self,
    register: Register,
    value: u8
) -> Self::WriteRegisterFuture<'_>

fn read_register(&mut self, register: Register) -> Self::ReadRegisterFuture<'_>

fn read_accel_bytes(&mut self) -> Self::ReadAccelBytesFuture<'_>