Initial PDM support

examples/pdm-demo/Embed.toml

@@ -0,0 +1,63 @@
+[default.probe]
+# USB vendor ID
+# usb_vid = "1337"
+# USB product ID
+# usb_pid = "1337"
+# Serial number
+# serial = "12345678"
+# The protocol to be used for communicating with the target.
+protocol = "Swd"
+# The speed in kHz of the data link to the target.
+# speed = 1337
+
+[default.flashing]
+# Whether or not the target should be flashed.
+enabled = true
+# Whether or not the target should be halted after reset.
+# DEPRECATED, moved to reset section
+halt_afterwards = false
+# Whether or not bytes erased but not rewritten with data from the ELF
+# should be restored with their contents before erasing.
+restore_unwritten_bytes = false
+# The path where an SVG of the assembled flash layout should be written to.
+# flash_layout_output_path = "out.svg"
+
+[default.reset]
+# Whether or not the target should be reset.
+# When flashing is enabled as well, the target will be reset after flashing.
+enabled = true
+# Whether or not the target should be halted after reset.
+halt_afterwards = false
+
+[default.general]
+# The chip name of the chip to be debugged.
+chip = "nRF52840"
+# A list of chip descriptions to be loaded during runtime.
+chip_descriptions = []
+# The default log level to be used. Possible values are one of:
+# "OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE" 
+log_level = "WARN"
+
+[default.rtt]
+# Whether or not an RTTUI should be opened after flashing.
+# This is exclusive and cannot be used with GDB at the moment.
+enabled = true
+# A list of channel associations to be displayed. If left empty, all channels are displayed.
+channels = [
+ # { up = 0, down = 0, name = "name", format = "String" }
+]
+# The duration in ms for which the logger should retry to attach to RTT.
+timeout = 3000
+# Whether timestamps in the RTTUI are enabled
+show_timestamps = true
+# Whether to save rtt history buffer on exit.
+log_enabled = false
+# Where to save rtt history buffer relative to manifest path.
+log_path = "./logs"
+
+[default.gdb]
+# Whether or not a GDB server should be opened after flashing.
+# This is exclusive and cannot be used with RTT at the moment.
+enabled = false
+# The connection string in host:port format wher the GDB server will open a socket.
+# gdb_connection_string

examples/pdm-demo/README.md

@@ -0,0 +1,12 @@
+# Pulse Density Modulation demo
+
+This example showcases how to use the PDM peripheral to acquire microphone samples on an Arduino Nano 33 BLE board.
+
+
+## How to run
+
+If using `cargo-embed`, just run
+
+```console
+$ cargo embed --release --target=thumbv7em-none-eabihf
+```

examples/pdm-demo/src/main.rs

@@ -0,0 +1,75 @@
+#![no_main]
+#![no_std]
+
+use core::{
+ panic::PanicInfo,
+ sync::atomic::{compiler_fence, Ordering},
+};
+
+use nrf52840_hal as hal;
+use hal::{
+ pdm::{self, Pdm},
+ clocks::Clocks,
+ gpio::Level,
+};
+use rtt_target::{rprintln, rtt_init_print};
+
+// The lenght of the buffer allocated to the pdm samples (in mono mode it is
+// exactly the number of samples per read)
+const PDM_BUFFER_LEN: usize = 8192;
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+ rtt_init_print!();
+ rprintln!("Hello, world!");
+
+ let peripherals = hal::pac::Peripherals::take().unwrap();
+ let port0 = hal::gpio::p0::Parts::new(peripherals.P0);
+
+ // Enable the high frequency oscillator if not already enabled
+ let _clocks = Clocks::new(peripherals.CLOCK).enable_ext_hfosc();
+
+ // Retreive the right pins used in the Arduino Nano 33 BLE Sense board
+ let _mic_vcc = port0.p0_17.into_push_pull_output(Level::High);
+ let mic_clk = port0.p0_26.into_push_pull_output(Level::Low).degrade();
+ let mic_din = port0.p0_25.into_floating_input().degrade();
+
+ let pdm = Pdm::new(peripherals.PDM, mic_clk, mic_din);
+ pdm.sampling(pdm::Sampling::LEFTFALLING)
+ .channel(pdm::Channel::MONO)
+ .frequency(pdm::Frequency::_1280K)
+ .left_gain(pdm::GainL::MAXGAIN)
+ .enable();
+
+ // Allocate the buffer
+ let mut buffer = [0; PDM_BUFFER_LEN];
+
+ // Skip a few samples as suggested by the nrf-52840 docs
+ for i in 0..10 {
+ rprintln!("{}", i);
+ pdm.read(&mut buffer);
+ }
+
+
+ // Output the power of the received signal
+ loop {
+ // Ask the pdm peripheral to fill our buffer with samples
+ pdm.read(&mut buffer);
+
+ let square_sum = buffer.iter().fold(0i64, |sum, &item| {
+ sum + (item as i64).pow(2)
+ });
+ rprintln!("Energy : {}", square_sum as f32 / PDM_BUFFER_LEN as f32);
+
+ for _ in 0..10_000 {}
+ }
+}
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+ cortex_m::interrupt::disable();
+ rprintln!("{}", info);
+ loop {
+ compiler_fence(Ordering::SeqCst);
+ }
+}

nrf-hal-common/src/lib.rs

@@ -85,6 +85,8 @@ pub mod uicr;
 #[cfg(feature = "nrf-usbd")]
 pub mod usbd;
 pub mod wdt;
+#[cfg(feature = "52840")]
+pub mod pdm;
 
 pub mod prelude {
  pub use crate::hal::digital::v2::*;

nrf-hal-common/src/pdm.rs

@@ -0,0 +1,134 @@
+//! HAL interface to the PDM peripheral
+//!
+//! The PDM (Pulse Density Modulation) peripheral enables the sampling of pulse
+//! density signals.
+
+use crate::{
+ hal::digital::v2::OutputPin,
+ gpio::{Floating, Input, Output, Pin, PushPull},
+ pac::PDM,
+};
+// Publicly re-export configuration enums for convenience
+pub use crate::pac::pdm::{
+ gainl::GAINL_A as GainL, 
+ gainr::GAINR_A as GainR, 
+ mode::EDGE_A as Sampling,
+ mode::OPERATION_A as Channel, 
+ pdmclkctrl::FREQ_A as Frequency, 
+ ratio::RATIO_A as Ratio,
+};
+
+pub struct Pdm {
+ pdm: PDM,
+ clk: Pin<Output<PushPull>>,
+ din: Pin<Input<Floating>>,
+}
+
+impl Pdm {
+ /// Create the `Pdm` instance, initialize the raw peripheral and enable it.
+ pub fn new(pdm: PDM, mut clk: Pin<Output<PushPull>>, din: Pin<Input<Floating>>) -> Self {
+ // Set the CLK pin low as requested by the docs
+ clk.set_low().unwrap();
+
+ // Configure the pins
+ pdm.psel.clk.write(|w| {
+ unsafe { w.bits(clk.psel_bits()) };
+ w.connect().connected()
+ });
+ pdm.psel.din.write(|w| {
+ unsafe { w.bits(din.psel_bits()) };
+ w.connect().connected()
+ });
+
+ Self { pdm, clk, din }
+ }
+
+ /// Set clock frequency
+ pub fn frequency(&self, frequency: Frequency) -> &Self {
+ self.pdm.pdmclkctrl.write(|w| w.freq().variant(frequency));
+
+ self
+ }
+
+ /// Set the hardware decimation filter gain for the left channel (this is
+ /// also the gain used in mono mode)
+ pub fn left_gain(&self, gain: GainL) -> &Self {
+ self.pdm.gainl.write(|w| w.gainl().variant(gain));
+
+ self
+ }
+
+ /// Set the hardware decimation filter gain for the left channel (this is
+ /// also the gain used in mono mode)
+ pub fn right_gain(&self, gain: GainR) -> &Self {
+ self.pdm.gainr.write(|w| w.gainr().variant(gain));
+
+ self
+ }
+
+ /// Set the ratio clock frequency/sample rate (sample rate = clock frequency / ratio)
+ pub fn ratio(&self, ratio: Ratio) -> &Self {
+ self.pdm.ratio.write(|w| w.ratio().variant(ratio));
+
+ self
+ }
+
+ /// Set whether the left (or mono) samples are taken on a clock rise or fall.
+ pub fn sampling(&self, sampling: Sampling) -> &Self {
+ self.pdm.mode.write(|w| w.edge().variant(sampling));
+
+ self
+ }
+
+ /// Set the channel mode : mono or stereo
+ pub fn channel(&self, channel: Channel) -> &Self {
+ self.pdm.mode.write(|w| w.operation().variant(channel));
+
+ self
+ }
+
+ /// Enable the peripheral
+ pub fn enable(&self) {
+ self.pdm.enable.write(|w| w.enable().enabled());
+ } 
+
+ /// Return ownership of underlying pins and peripheral
+ pub fn free(self) -> (PDM, Pin<Output<PushPull>>, Pin<Input<Floating>>) {
+ (self.pdm, self.clk, self.din)
+ }
+
+ /// Perform one blocking acquisition, filling the given buffer with samples.
+ ///
+ /// The buffer length must not exceed 2^16 - 1
+ pub fn read(&self, buffer: &mut [i16]) {
+ // Setup the buffer address and the number of samples to acquire
+ self.pdm.sample
+ .ptr
+ .write(|w| unsafe { w.sampleptr().bits(buffer.as_ptr() as u32) });
+ self.pdm.sample
+ .maxcnt
+ .write(|w| unsafe { w.buffsize().bits(buffer.len() as u16) });
+
+ // Start the acquisition
+ self.pdm.tasks_start.write(|w| w.tasks_start().set_bit());
+
+ // Wait for the acquisition to start then prevent it from restarting
+ // after
+ while !self.pdm.events_started.read().events_started().bit_is_set() {}
+ self.pdm.sample
+ .maxcnt
+ .write(|w| unsafe { w.buffsize().bits(0) });
+
+ // Wait for the acquisition to finish
+ while !self.pdm.events_end.read().events_end().bit_is_set() {}
+
+ self.clear_events();
+ }
+
+ /// Clear all events
+ fn clear_events(&self) {
+ self.pdm.events_started.write(|w| w.events_started().clear_bit());
+ self.pdm.events_stopped.write(|w| w.events_stopped().clear_bit());
+ self.pdm.events_end.write(|w| w.events_end().clear_bit());
+ }
+}