firmware: First parts of an audio buffer type.

hackamp/firmware/src/audio_buffer.rs

@@ -0,0 +1,128 @@
+#![warn(missing_docs)]
+
+use core::cell::{Cell, UnsafeCell};
+
+use cortex_m::interrupt::{CriticalSection, Mutex};
+
+/// Each packet contains 1 millisecond of audio data (48 samples at 48000kHz).
+///
+/// This translates two twice the number of values, as each sample contains two channels.
+pub const SAMPLES_PER_PACKET: usize = 48;
+pub const CHANNELS: usize = 2;
+pub const PACKETS: usize = 3;
+
+pub type Packet = [u32; SAMPLES_PER_PACKET * CHANNELS];
+
+/// Type for audio packet buffering.
+///
+/// The audio packets always contain two channels with 32-bit samples. The type contains three
+/// buffers each containing the same fixed number of samples. This structure allows two buffers to
+/// be in use by the DMA engine while the third is used by the ARM core.
+pub struct AudioBuffer {
+    mutex: Mutex<AudioBufferInner>,
+}
+
+struct AudioBufferInner {
+    /// Packet contents.
+    packets: [UnsafeCell<Packet>; PACKETS],
+    /// Bitmask of packets which contain valid data and are not currently being read.
+    valid: Cell<u32>,
+    /// Bitmask of packets which do not contain valid data and which are not currently being
+    /// written.
+    invalid: Cell<u32>,
+    /// Bitmask of all packets which are currently borrowed via `borrow_read()`.
+    reading: Cell<u32>,
+    /// Bitmask of all packets which are currently borrowed via `borrow_write()`.
+    writing: Cell<u32>,
+}
+
+impl AudioBuffer {
+    /// Creates a new audio buffer.
+    pub const fn new() -> AudioBuffer {
+        // Initially, all packet contents are invalid and no packets are currently being read or
+        // written.
+        AudioBuffer {
+            mutex: Mutex::new(AudioBufferInner {
+                packets: [
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                ],
+                valid: Cell::new(0),
+                invalid: Cell::new(((1 << PACKETS) - 1) as u32),
+                reading: Cell::new(0),
+                writing: Cell::new(0),
+            }),
+        }
+    }
+
+    /// Returns whether there are any buffers with valid data ready for reading.
+    pub fn read_data_available(&self, cs: &CriticalSection) -> bool {
+        let inner = self.mutex.borrow(cs);
+        inner.valid.get() != 0
+    }
+
+    pub fn borrow_read(&'static self, cs: &CriticalSection) -> Option<ReadPacket> {
+        let inner = self.mutex.borrow(cs);
+        let valid = inner.valid.get();
+        if valid != 0 {
+            return None;
+        }
+        let index = valid.trailing_zeros();
+        inner.valid.set(valid & !(1 << index));
+        inner.reading.set(inner.reading.get() | (1 << index));
+
+        let index = index as usize;
+        Some(ReadPacket {
+            buffer: self,
+            data: unsafe { &*inner.packets[index].get() },
+            index,
+        })
+    }
+
+    pub fn read_finished(&'static self, _packet: ReadPacket, _cs: &CriticalSection) {
+        // TODO
+        panic!("Not yet implemented.");
+    }
+
+    /// Returns whether there are any empty buffers ready for writing.
+    pub fn write_data_available(&self, cs: &CriticalSection) -> bool {
+        let inner = self.mutex.borrow(cs);
+        inner.invalid.get() != 0
+    }
+
+    pub fn borrow_write(&'static self, cs: &CriticalSection) -> Option<WritePacket> {
+        let inner = self.mutex.borrow(cs);
+        let invalid = inner.invalid.get();
+        if invalid != 0 {
+            return None;
+        }
+        let index = invalid.trailing_zeros();
+        inner.invalid.set(invalid & !(1 << index));
+        inner.writing.set(inner.writing.get() | (1 << index));
+
+        let index = index as usize;
+        Some(WritePacket {
+            buffer: self,
+            data: unsafe { &mut *inner.packets[index].get() },
+            index,
+        })
+    }
+
+    pub fn write_finished(&'static self, _packet: WritePacket, _cs: &CriticalSection) {
+        // TODO
+        panic!("Not yet implemented.");
+    }
+}
+
+pub struct ReadPacket {
+    buffer: &'static AudioBuffer,
+    data: &'static Packet,
+    index: usize,
+}
+
+pub struct WritePacket {
+    buffer: &'static AudioBuffer,
+    data: &'static mut Packet,
+    index: usize,
+}

hackamp/firmware/src/halext/mod.rs

@@ -0,0 +1 @@
+#![warn(missing_docs)]

hackamp/firmware/src/main.rs

@@ -2,15 +2,37 @@
 #![no_main]
 #![no_std]
 
+use cortex_m::interrupt;
 use panic_semihosting as _;
 
+use audio_buffer::AudioBuffer;
+use pins::Pins;
+
+mod audio_buffer;
+mod halext;
+mod mixer;
+mod pins;
+
 #[rtic::app(device = stm32f4xx_hal::stm32, peripherals = true)]
 const APP: () = {
     struct Resources {}
 
     #[init]
     fn init(_ctx: init::Context) {
-        // TODO
+        let _pins = Pins::configure();
+        static I2S_BUFFER: AudioBuffer = AudioBuffer::new();
+
+        let i2s_buffer = &I2S_BUFFER;
+
+        // Buffer example code.
+        interrupt::free(|cs| {
+            let write_packet = i2s_buffer.borrow_write(cs).unwrap();
+            // TODO
+            i2s_buffer.write_finished(write_packet, cs);
+            let read_packet = i2s_buffer.borrow_read(cs).unwrap();
+            // TODO
+            i2s_buffer.read_finished(read_packet, cs);
+        });
     }
 
     #[idle(resources = [])]

hackamp/firmware/src/mixer.rs

@@ -0,0 +1 @@
+#![warn(missing_docs)]

hackamp/firmware/src/pins.rs

@@ -0,0 +1,18 @@
+#![warn(missing_docs)]
+
+/// Type which contains all GPIO pins.
+///
+/// The pins are configured as the correct type. Whenever possible, the corresponding HAL driver is
+/// instantiated. The initial output state is set during configuration.
+pub struct Pins {
+    // TODO
+}
+
+impl Pins {
+    /// Configures the GPIO pins and sets their initial value.
+    pub fn configure() -> Pins {
+        Pins{
+            // TODO
+        }
+    }
+}