Hi, I'm trying to use Rust on STM32F429-DISC1 with embassy. The goal of the project is to record a voice with an ADAFRUIT microphone (this one: Adafruit PDM MEMS Microphone Breakout : ID 3492 : Adafruit Industries, Unique & fun DIY electronics and kits) with SAI1, store the data with DMA2 on SDRAM, convert and filter them and play them with the DAC (also with other DMA1 channels).
Currently, I'm trying to read the SAI with .read(&mut buf) but I get an overrun error. I assume this is because my bitlock frequency is still at 72MHz instead of 3.072MHz and acquisition is also at 72MHz instead of 48kHz.
Normally, CubeMX divides the frequency according to channels and frame length, but maybe Embassy doesn't, and I haven't found an rcc pointer to change this.
If anyone can help me, I'd be very grateful, here's my code:
#![no_std]
#![no_main]
// cd \embassy\examples\stm32f4\src\bin
// cargo build --bin Projet_3A --release
// cargo run --bin Projet_3A --release
use defmt::*;
use {defmt_rtt as _, panic_probe as _};
use core::cell::UnsafeCell;
use core::convert::TryInto;
use core::sync::atomic::{AtomicUsize, Ordering};
use grounded::uninit::GroundedArrayCell;
use embassy_stm32::dac::{Dac, DacChannel, TriggerSel, Value};
use embassy_stm32::exti::ExtiInput;
use embassy_stm32::gpio::{Level, Output, Pull, Speed};
use embassy_stm32::bind_interrupts;
use embassy_stm32::Config;
use embassy_stm32::peripherals::*;
use embassy_stm32::rcc::{
Pll, PllSource, Sysclk, PllPreDiv, PllMul, PllPDiv, PllQDiv, AHBPrescaler, APBPrescaler, PllSaiQ
};
use embassy_stm32::sai::{
Config as SaiConfig, Sai, split_subblocks, Mode, TxRx, Protocol, DataSize, SlotSize,
BitOrder, FrameSyncDefinition, FrameSyncPolarity, FrameSyncOffset, ClockStrobe, StereoMono,
OutputDrive,
};
use embassy_stm32::time::Hertz;
use embassy_stm32::usart::{Config as UartConfig, Parity, StopBits, Uart};
use embassy_stm32::timer::low_level::Timer;
use embassy_executor::Spawner;
use embassy_time::{Duration, with_timeout, Timer as EmbassyTimer};
use stm32_fmc::devices::is42s16400j_7::Is42s16400j;
use cortex_m::delay::Delay;
use cortex_m::Peripherals as CortexPeripherals;
// Parameters
const DMA_SIZE: usize = 1024;
const HALF_DMA_SIZE: usize = DMA_SIZE / 2;
const AUDIO_SIZE: usize = 32250; // Size of the audio zone (PCM)
const NB_COEF: usize = 62;
const SDRAM_SIZE: usize = 8 * 1024 * 1024; // 8 Mo en octets
// Coeff FIR
const H: [f32; NB_COEF] = [
0.00022791, 0.00043387, 0.00078005, 0.0012266, 0.0017349, 0.0022304, 0.0026025, 0.0027107,
0.0023986, 0.0015169, -4.8658e-05, -0.0023457, -0.0053254, -0.0088194, -0.01253, -0.016035,
-0.018813, -0.020289, -0.01989, -0.01712, -0.011625, -0.0032666, 0.0078402, 0.021299,
0.036444, 0.05238, 0.068052, 0.082342, 0.094179, 0.10264, 0.10705, 0.10705, 0.10264, 0.094179,
0.082342, 0.068052, 0.05238, 0.036444, 0.021299, 0.0078402, -0.0032666, -0.011625, -0.01712,
-0.01989, -0.020289, -0.018813, -0.016035, -0.01253, -0.0088194, -0.0053254, -0.0023457,
-4.8658e-05, 0.0015169, 0.0023986, 0.0027107, 0.0026025, 0.0022304, 0.0017349, 0.0012266,
0.00078005, 0.00043387, 0.00022791,
];
static RAM_USED: AtomicUsize = AtomicUsize::new(0);
struct RxBuffer {
cell: UnsafeCell<GroundedArrayCell<u8, DMA_SIZE>>,
}
unsafe impl Sync for RxBuffer {}
static RX_BUFFER: RxBuffer = RxBuffer {
cell: UnsafeCell::new(GroundedArrayCell::uninit()),
};
fn get_rx_buffer() -> &'static mut GroundedArrayCell<u8, DMA_SIZE> {
unsafe { &mut *RX_BUFFER.cell.get() }
}
// Other functions ...
#[embassy_executor::main]
async fn main(spawn: Spawner) {
info!("main(): Begining of the main()");
// Initialisation RCC/PLL/PLLSAI (72 MHz)
let mut config = Config::default();
config.rcc.pll_src = PllSource::HSI;
config.rcc.pll = Some(Pll {
prediv: PllPreDiv::DIV8,
mul: PllMul::MUL72,
divp: Some(PllPDiv::DIV2),
divq: None,
divr: None,
}); // 72Mhz
config.rcc.pllsai = Some(Pll {
prediv: PllPreDiv::DIV8,
mul: PllMul::MUL192,
divp: None,
divq: Some(PllQDiv::DIV5),
divr: None,
});
config.rcc.sys = Sysclk::PLL1_P;
config.rcc.pllsai_divdivq = PllSaiQ::DIV25;
config.rcc.ahb_pre = AHBPrescaler::DIV1;
config.rcc.apb1_pre = APBPrescaler::DIV2;
config.rcc.apb2_pre = APBPrescaler::DIV2;
let p = embassy_stm32::init(config);
info!("main(): Config Générale done");
// Initialisation UART pour debug
let mut uart_config = UartConfig::default();
uart_config.baudrate = 115200;
uart_config.parity = Parity::ParityNone;
uart_config.stop_bits = StopBits::STOP1;
bind_interrupts!(struct IrqsUART {
USART1 => embassy_stm32::usart::InterruptHandler<USART1>;
});
let _uart = Uart::new(
p.USART1,
p.PA10,
p.PA9,
IrqsUART,
p.DMA2_CH7,
p.DMA2_CH2,
uart_config,
);
info!("main(): Config UART done");
// Initialisation GPIO (bouton et LEDs)
let mut exti_button = ExtiInput::new(p.PA0, p.EXTI0, Pull::None);
let mut led_red = Output::new(p.PG14, Level::Low, Speed::Low);
let mut led_green = Output::new(p.PG13, Level::Low, Speed::Low);
info!("main(): Config GPIO done");
// Initialisation Timer pour DAC (48 kHz)
let mut tim2 = Timer::new(p.TIM2);
tim2.set_frequency(Hertz(48_000));
tim2.start();
info!("main(): Config TIMER2 done");
// Initialisation DAC
let dac = Dac::new(p.DAC1, p.DMA1_CH5, p.DMA1_CH6, p.PA4, p.PA5);
let (mut dac_ch1, mut dac_ch2) = dac.split();
dac_ch1.set_trigger(TriggerSel::Tim2);
dac_ch1.set_triggering(true);
dac_ch2.set_trigger(TriggerSel::Tim2);
dac_ch2.set_triggering(true);
info!("main(): Config DAC done");
// Initialisation SDRAM via FMC
let mut sdram = embassy_stm32::fmc::Fmc::sdram_a12bits_d16bits_4banks_bank2(
p.FMC,
p.PF0, p.PF1, p.PF2, p.PF3, p.PF4, p.PF5, p.PF12, p.PF13, p.PF14, p.PF15, p.PG0, p.PG1,
p.PG4, p.PG5,
p.PD14, p.PD15, p.PD0, p.PD1, p.PE7, p.PE8, p.PE9, p.PE10, p.PE11, p.PE12, p.PE13, p.PE14,
p.PE15, p.PD8, p.PD9, p.PD10,
p.PE0, p.PE1,
p.PB5,
p.PG8,
p.PG15,
p.PB6,
p.PF11,
p.PC0,
Is42s16400j {}
);
let cp: CortexPeripherals;
unsafe { cp = CortexPeripherals::steal(); }
let mut delay = Delay::new(cp.SYST, 72_000_000);
let mut ram_slice: &mut [u16] = unsafe {
let ram_ptr: *mut u16 = sdram.init(&mut delay) as *mut _;
core::slice::from_raw_parts_mut(ram_ptr, SDRAM_SIZE / core::mem::size_of::<u16>())
};
info!("main(): Config SDRAM done");
spawn.spawn(alive()).unwrap();
// Configuration SAI
let mut sai_config = SaiConfig::default();
sai_config.mode = Mode::Master;
sai_config.tx_rx = TxRx::Receiver;
sai_config.protocol = Protocol::Free;
sai_config.frame_length = 64;
sai_config.data_size = DataSize::Data16;
sai_config.slot_size = SlotSize::DataSize;
sai_config.bit_order = BitOrder::MsbFirst;
sai_config.frame_sync_definition = FrameSyncDefinition::ChannelIdentification;
sai_config.frame_sync_polarity = FrameSyncPolarity::ActiveLow;
sai_config.frame_sync_offset = FrameSyncOffset::OnFirstBit;
sai_config.slot_count = embassy_stm32::dma::word::U4(4);
sai_config.clock_strobe = ClockStrobe::Rising;
sai_config.stereo_mono = StereoMono::Mono;
sai_config.output_drive = OutputDrive::Immediately;
let (sub_block_a, _) = split_subblocks(p.SAI1);
// Initialisation du buffer DMA pour le SAI (en u8)
let rx_buff: &mut [u8] = {
let rx_buf = get_rx_buffer();
unsafe { rx_buf.initialize_all_copied(0); }
let (ptr, len) = rx_buf.get_ptr_len();
unsafe { core::slice::from_raw_parts_mut(ptr, len) }
};
let mut sai = Sai::new_asynchronous(
sub_block_a,
p.PE5, // SCK
p.PE6, // SD
p.PE4, // FS
p.DMA2_CH1,
rx_buff,
sai_config,
);
info!("main(): Config SAI1 done");
if let Err(e) = sai.start() {
error!("main(): Error strating SAI: {:?}", e);
loop {}
}
// RX Buffer in PDM
let mut pdm_buffer: [u8; HALF_DMA_SIZE] = [0; HALF_DMA_SIZE];
info!("Entrée dans boucle d'enregistrement, appuyez sur le bouton");
loop {
exti_button.wait_for_falling_edge().await;
info!("main(): Début de l'enregistrement");
led_red.set_high();
//embassy_stm32::sai::Sai::<'_, embassy_stm32::peripherals::SAI1, u8>::reset();
info!("main(): Première lecture du SAI");
let result = with_timeout(Duration::from_millis(5000), sai.read(&mut pdm_buffer)).await;
match result {
Ok(Ok(())) => {
info!("SAI receive something");
process_task(&mut pdm_buffer, &mut ram_slice).await;
info!("main(): Seconde lecture du SAI");
let result = with_timeout(Duration::from_millis(5000), sai.read(&mut pdm_buffer)).await;
match result {
Ok(Ok(())) => {
info!("SAI receive something");
process_task(&mut pdm_buffer, &mut ram_slice).await;
led_red.set_low();
led_green.set_high();
info!("main(): Enregistrement terminé");
play_audio(&mut dac_ch1, &mut dac_ch2, &mut tim2, &ram_slice).await;
led_green.set_low();
RAM_USED.store(0, Ordering::Relaxed);
}
Ok(Err(e)) => {
error!("SAI error: {:?}", e);
led_red.set_low();
}
Err(timeout_err) => {
error!("Timeout in sai.read(): {:?}", timeout_err);
led_red.set_low();
}
}
}
Ok(Err(e)) => {
error!("SAI error: {:?}", e);
led_red.set_low();
}
Err(timeout_err) => {
error!("Timeout in sai.read(): {:?}", timeout_err);
led_red.set_low();
}
}
info!("Press the USER1 button to record a new time your voice");
}
}