Example for using FIFO?

[gregoryw3]

Hello, I'm having issues getting the FIFO to work and was wondering if an example can be provided?

Here is my code:

#![no_main]
#![no_std]

// #![deny(clippy::float_arithmetic)]

use embassy_executor::Spawner;
use embassy_rp::i2c::{Async, I2c};
use embassy_rp::{bind_interrupts, peripherals::*};
use embassy_time::Timer;
use ism330dhcx::*;
use embassy_rp::peripherals::USB;
use embassy_rp::usb::{Driver, InterruptHandler as UsbInterruptHandler};
use defmt_rtt as _;
use panic_probe as _;
use log::info;

bind_interrupts!(struct Irqs {
    USBCTRL_IRQ => UsbInterruptHandler<USB>;
    I2C1_IRQ => embassy_rp::i2c::InterruptHandler<I2C1>;
});

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    // Peripherals access
    let p = embassy_rp::init(Default::default());

    info!("Setting up USB...");

    let usb_driver = Driver::new(p.USB, Irqs);
    spawner.spawn(logger_task(usb_driver)).unwrap();

    info!("Setting up I2C...");

    let mut ic2_config = embassy_rp::i2c::Config::default();
    ic2_config.frequency = 400_000;

    let i2c_scl = p.PIN_3;
    let i2c_sda = p.PIN_2;

    let mut i2c1 = embassy_rp::i2c::I2c::new_async(
        p.I2C1,
        i2c_scl,
        i2c_sda,
        Irqs,
        ic2_config,
    );

    info!("Setting up ISM330DHCX...");

    // Set up ISM330DHCX
    let mut sensor = match Ism330Dhcx::new_with_address(&mut i2c1, 0x6au8) {
        Ok(sensor) => sensor,
        Err(error) => {
            loop {
                info!("{:?}", error);
                info!("Error initializing ISM330DHCX. Retrying in 1 second...");
                Timer::after_millis(1000).await;
            }
        }
    };
    boot_sensor(&mut sensor, &mut i2c1);

    info!("Spawning ism330dhcx_task...");

    spawner.spawn(ism330dhcx_task(sensor, i2c1)).unwrap();

}

// Async task for USB logging.
#[embassy_executor::task]
async fn logger_task(driver: Driver<'static, USB>) {
    embassy_usb_logger::run!(1024, log::LevelFilter::Info, driver);
}

#[embassy_executor::task]
async fn ism330dhcx_task(
    mut sensor: Ism330Dhcx,
    mut i2c: I2c<'static, I2C1, Async>,
) {

    use embassy_time::{Instant, Timer };

    // let mut last = Instant::now();
    // let mut last_print = Instant::now();
    // let mut reading_count = 0;

    loop {
        // reading_count += 1;

        // info!("Temperature: {}", match sensor.get_temperature(&mut i2c) {
        //     Ok(temp) => temp,
        //     Err(e) => {
        //         info!("Error reading temperature: {:?}", e);
        //         continue;
        //     }
        // });
        // info!(
        //     "Gyroscope: {:?}",
        //     sensor.get_gyroscope(&mut i2c).unwrap().as_dps()
        // );
        // info!(
        //     "Accelerometer: {:?}",
        //     sensor.get_accelerometer(&mut i2c).unwrap().as_m_ss()
        // );

        // let _temp = sensor.get_temperature(&mut i2c).unwrap();
        // let _gyro = sensor.get_gyroscope(&mut i2c).unwrap();
        // let _accel = sensor.get_accelerometer(&mut i2c).unwrap();

        let fifo = sensor.fifo_pop(&mut i2c);
        match fifo {
            Ok(fifo) => {
                match fifo {
                    fifo::Value::Empty => {
                        info!("FIFO empty");
                    }
                    fifo::Value::Gyro(gyro) => {
                        info!("Gyro: {:?}", gyro.as_dps());
                    }
                    fifo::Value::Accel(accel) => {
                        info!("Accel: {:?}", accel.as_m_ss());
                    }
                    fifo::Value::Other(tag, data) => {
                        info!("Other: {:?} {:?}", tag, data);
                    }
                }
            }
            Err(e) => {
                info!("Error reading FIFO: {:?}", e);
            }
        }

        // let now = Instant::now();
        // let dt_ms = (now - last).as_millis() as f32;
        // let _hz = 1000.0 / dt_ms; // optional immediate Hz calculation
        // last = now;

        // // Print average rate every 1 sec
        // if (now - last_print).as_secs() >= 1 {
        //     let secs = (now - last_print).as_secs() as f32;
        //     let avg_hz = reading_count as f32 / secs;
        //     info!("Sensor frequency (avg): {:.2} Hz", avg_hz);
        //     reading_count = 0;
        //     last_print = now;
        // }

        // Timer::after_nanos(1).await;
        Timer::after_millis(5000).await;

    }
}

// Booting the sensor accoring to Adafruit's driver
fn boot_sensor<I2C>(sensor: &mut Ism330Dhcx, i2c: &mut I2C)
where
    I2C: embedded_hal::i2c::I2c,
{
    // =======================================
    // CTRL3_C

    sensor.ctrl3c.set_boot(i2c, true).unwrap();
    sensor.ctrl3c.set_bdu(i2c, true).unwrap();
    sensor.ctrl3c.set_if_inc(i2c, true).unwrap();

    // =======================================
    // CTRL9_XL

    sensor.ctrl9xl.set_den_x(i2c, true).unwrap();
    sensor.ctrl9xl.set_den_y(i2c, true).unwrap();
    sensor.ctrl9xl.set_den_z(i2c, true).unwrap();
    sensor.ctrl9xl.set_device_conf(i2c, true).unwrap();

    // =======================================
    // CTRL1_XL

    sensor
        .ctrl1xl
        .set_accelerometer_data_rate(i2c, ctrl1xl::Odr_Xl::Hz6667)
        .unwrap();

    sensor
        .ctrl1xl
        .set_chain_full_scale(i2c, ctrl1xl::Fs_Xl::G4)
        .unwrap();
    sensor.ctrl1xl.set_lpf2_xl_en(i2c, false).unwrap();

    // =======================================
    // CTRL2_G

    sensor
        .ctrl2g
        .set_gyroscope_data_rate(i2c, ctrl2g::Odr::Hz6667)
        .unwrap();

    sensor
        .ctrl2g
        .set_chain_full_scale(i2c, ctrl2g::Fs::Dps500)
        .unwrap();

    // =======================================
    // CTRL7_G

    sensor.ctrl7g.set_g_hm_mode(i2c, false).unwrap();

    // =======================================
    // FIFO_CTRL

    sensor
        .fifoctrl
        .compression(i2c, false)
        .unwrap();
    sensor 
        .fifoctrl
        .mode(i2c, fifoctrl::FifoMode::Continuous)
        .unwrap();
    sensor
        .fifoctrl
        .set_accelerometer_batch_data_rate(i2c, fifoctrl::BdrXl::Hz6667)
        .unwrap();
    sensor
        .fifoctrl
        .set_gyroscope_batch_data_rate(i2c, fifoctrl::BdrGy::Hz6667)
        .unwrap();
}

[sousandrei]

Hey @gregoryw3!

I finally got to this.
Added one example that is working locally for me, can you verify in your end if it works as expected?