I2S with INMP441 on ESP32-C3

[ksmarty]

Hello, I saw this earlier discussion and followed it as reference, but a lot has changed in the last year: #1596

I've tried with both an ESP32 WROOM and ESP32-C3 (super mini board) and have gotten the same error on both boards. I confirmed the microphone is functional and wired up correctly by flashing an example Arduino sketch to the same board.

The error is occurring on the unwrap of read_dma_circular()

Thank you in advance for any assistance!

Here is my setup and the error:

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use esp_backtrace as _;
use esp_hal::clock::CpuClock;
use esp_hal::dma_buffers;
use esp_hal::i2s::master::{DataFormat, I2s, Standard};
use esp_hal::{time::RateExtU32, timer::systimer::SystemTimer};
use esp_hal_embassy::main;
use esp_println::println;
use log::info;

extern crate alloc;

// DMA buffer size
const I2S_BYTES: usize = 4092;

#[main]
async fn main(_spawner: Spawner) {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    esp_alloc::heap_allocator!(72 * 1024);

    esp_println::logger::init_logger_from_env();

    let timer0 = SystemTimer::new(peripherals.SYSTIMER);
    esp_hal_embassy::init(timer0.alarm0);

    info!("Embassy initialized!");

    let bclk = peripherals.GPIO0; // sck - purple
    let din = peripherals.GPIO2; //  sd  - black
    let ws = peripherals.GPIO1; //   ws  - blue

    let dma_channel = peripherals.DMA_CH0;
    let (mut rx_buffer, rx_descriptors, _, tx_descriptors) = dma_buffers!(0, 4 * I2S_BYTES);

    let i2s = I2s::new(
        peripherals.I2S0,
        Standard::Philips,
        DataFormat::Data32Channel32,
        44100.Hz(),
        dma_channel,
        rx_descriptors,
        tx_descriptors,
    );

    let mut i2s_rx = i2s.i2s_rx.with_bclk(bclk).with_ws(ws).with_din(din).build();

    let mut transfer = i2s_rx.read_dma_circular(&mut rx_buffer).unwrap();

    loop {
        let avail = transfer.available().unwrap();

        if avail > 0 {
            let mut rcv = [0u8; 5000];
            transfer.pop(&mut rcv[..avail]).unwrap();
            println!("{:?}", &rcv[..avail]);
        }
    }
}

====================== PANIC ======================
panicked at /Users/USER/.cargo/registry/src/index.crates.io-6f17d22bba15001f/esp-hal-0.23.1/src/dma/mod.rs:983:33:
called `Option::unwrap()` on a `None` value

Backtrace:

0x420021f0
0x420021f0 - core::option::unwrap_failed
    at /rustc/9fc6b43126469e3858e2fe86cafb4f0fd5068869/library/core/src/option.rs:2009
0x42001268
0x42001268 - core::option::Option<T>::unwrap
    at /Users/USER/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/option.rs:972
0x420002fa
0x420002fa - embassy_executor::raw::util::SyncUnsafeCell<T>::get
    at /Users/USER/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.7.0/src/raw/util.rs:55
0x4200148c
0x4200148c - main
    at /Users/USER/PROJECT/src/bin/async_main.rs:32
0x42000130
0x42000130 - hal_main
    at /Users/USER/.cargo/registry/src/index.crates.io-6f17d22bba15001f/esp-hal-0.23.1/src/lib.rs:511

[bjoernQ]

A few things to note here:

• you are using the non-async API in an async application - that will become a problem later but it's not causing a problem here
• let (mut rx_buffer, rx_descriptors, _, tx_descriptors) = dma_buffers!(0, 4 * I2S_BYTES); - you are creating an RX buffer of size 0 - that's the problem here, you probably want let (mut rx_buffer, rx_descriptors, _, tx_descriptors) = dma_buffers!(4 * I2S_BYTES, 0); (note the changed order of parameters)
• println!("{:?}", &rcv[..avail]); is pretty slow and will result in a situation where you won't be able to pop the read data fast enough - for this simple example you can work around by just printing a smaller part of the buffer, e.g. println!("{:?}", &rcv[..20]);

[ksmarty]

Thank you so much!! I had tried switching the RX buffer size before, but still had the error. Only reading 20 bytes solved it!

[ksmarty]

Out of curiosity, what would I have to change to make it async?

[ksmarty]

Solved it:

let (rx_buffer, rx_descriptors, _, tx_descriptors) = dma_buffers!(4 * I2S_BYTES, 0);

let i2s = I2s::new(
    peripherals.I2S0,
    Standard::Philips,
    DataFormat::Data32Channel32,
    44100.Hz(),
    dma_channel,
    rx_descriptors,
    tx_descriptors,
)
.into_async();

let i2s_rx = i2s.i2s_rx.with_bclk(bclk).with_ws(ws).with_din(din).build();

let mut transfer = i2s_rx.read_dma_circular_async(rx_buffer).unwrap();
let mut data = [0u8; 5000];

loop {
    let _avail = transfer.available().await.unwrap();

    transfer.pop(&mut data).await.unwrap();
    println!("{:?}", &data[..128]);
}

[bjoernQ]

Awesome! Yes - turn the driver into async mode and use the async variants of functions. Happy to hear it's working for you

[bjoernQ]

But I have to admit the panic is quite confusing and misleading