Add support for I2S

ui-app/Cargo.toml

@@ -10,3 +10,6 @@ embedded-graphics = "0.8.1"
 embedded-graphics-core = { version = "0.4.0", default-features = false }
 heapless = "0.9.1"
 hex = { version = "0.4.3", default-features = false }
+
+[dev-dependencies]
+tokio = { version = "1.47.1", features = ["time", "rt", "macros", "sync"] }

ui-app/src/lib.rs

@@ -1,6 +1,7 @@
 #![no_std]
+#![allow(async_fn_in_trait)]
 
-use bitmap_font::{BitmapFont, TextStyle, tamzen::FONT_10x20};
+use bitmap_font::{tamzen::FONT_10x20, BitmapFont, TextStyle};
 use core::fmt::Write;
 use defmt::Format;
 use embedded_graphics::{
@@ -12,7 +13,6 @@ use embedded_graphics::{
     text::Text,
 };
 use heapless::String;
-use hex::ToHex;
 
 #[derive(Copy, Clone, Debug, PartialEq, Format)]
 pub enum Key {
@@ -73,17 +73,23 @@ pub enum Button {
     B,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Format)]
+pub const MAX_MESSAGE_LEN: usize = 128;
+
+#[derive(Clone, Debug, PartialEq, Format)]
 pub enum FromNet {
     Pong,
+    AudioFrame(Frame),
+    Chat(String<MAX_MESSAGE_LEN>),
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Format)]
+#[derive(Clone, Debug, PartialEq, Format)]
 pub enum ToNet {
     Ping,
+    AudioFrame(Frame),
+    Chat(String<MAX_MESSAGE_LEN>),
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Format)]
+#[derive(Clone, Debug, PartialEq, Format)]
 pub enum Event {
     ButtonDown(Button),
     ButtonUp(Button),
@@ -196,19 +202,79 @@ pub trait Eeprom {
     fn write(&mut self, data: &[u8; 256]);
 }
 
+pub const FRAME_SIZE: usize = 320;
+
+#[derive(Clone, Debug, PartialEq, Format)]
+pub struct Frame(pub [u16; FRAME_SIZE]);
+
+impl Default for Frame {
+    fn default() -> Self {
+        Self([0; FRAME_SIZE])
+    }
+}
+
+pub trait AudioControl {
+    fn start(&mut self);
+    fn enable_input(&mut self, enabled: bool);
+    fn enable_output(&mut self, enabled: bool);
+}
+
+pub trait AudioData {
+    async fn start(&mut self);
+    async fn stop(&mut self);
+    async fn read(&mut self) -> Frame;
+    async fn write(&mut self, frame: &Frame);
+
+    async fn write_iter(&mut self, samples: impl Iterator<Item = u16>) {
+        let mut send = Frame::default();
+
+        let mut i_mod = 0;
+        for (i, sample) in samples.enumerate() {
+            i_mod = i % FRAME_SIZE;
+            send.0[i_mod] = sample;
+
+            if i_mod == FRAME_SIZE - 1 {
+                self.write(&send).await;
+            }
+        }
+
+        i_mod += 1;
+        if i_mod < FRAME_SIZE {
+            send.0[i_mod..].fill(0);
+            self.write(&send).await;
+        }
+    }
+}
+
 pub trait Outputs {
+    fn button_a_down(&self) -> bool;
+    fn button_b_down(&self) -> bool;
     fn status_led(&mut self) -> &mut impl Led;
     fn screen(&mut self) -> &mut impl DrawTarget<Color = Rgb565>;
     fn net_tx(&mut self) -> &mut impl NetTx;
     fn eeprom(&mut self) -> impl Eeprom;
+    fn audio_control(&mut self) -> impl AudioControl;
+    fn audio_data(&mut self) -> &mut impl AudioData;
     fn log(&mut self, message: &str);
 }
 
+pub trait EventSource {
+    async fn receive(&mut self) -> Option<Event>;
+}
+
+#[derive(Debug, PartialEq, Format)]
+enum PttState {
+    Idle,
+    Transmitting,
+    Receiving,
+}
+
 #[derive(Debug)]
 pub struct App {
     a_down: bool,
     b_down: bool,
-    message_buffer: String<24>,
+    ptt_state: PttState,
+    message_buffer: String<MAX_MESSAGE_LEN>,
 }
 
 impl App {
@@ -220,6 +286,7 @@ impl App {
         Self {
             a_down: false,
             b_down: false,
+            ptt_state: PttState::Idle,
             message_buffer: Default::default(),
         }
     }
@@ -228,19 +295,10 @@ impl App {
         // Extinguish the status LED
         out.status_led().set_color(Color::Black);
 
-        // Read the EEPROM, XOR with 0xFF, write it, then read it back
-        let mut eeprom_data = [0u8; 256];
-        out.eeprom().read(&mut eeprom_data);
-        let hex: heapless::String<1024> = eeprom_data.encode_hex();
-        defmt::info!("eeprom before {}", hex);
-
-        eeprom_data.iter_mut().for_each(|x| *x ^= 0xff);
-        out.eeprom().write(&eeprom_data);
-
-        eeprom_data.fill(0);
-        out.eeprom().read(&mut eeprom_data);
-        let hex: heapless::String<1024> = eeprom_data.encode_hex();
-        defmt::info!("eeprom after {}", hex);
+        // Start up the audio interface
+        out.audio_control().start();
+        out.audio_control().enable_input(true);
+        out.audio_control().enable_output(true);
 
         // Draw a test pattern to the screen
         let rect = out.screen().bounding_box();
@@ -280,91 +338,138 @@ impl App {
             .unwrap_or_else(|_| panic!("graphics error"));
     }
 
-    pub fn handle(&mut self, event: Event, out: &mut impl Outputs) {
-        match event {
-            Event::ButtonDown(button) => match button {
-                Button::A => {
-                    out.log("button a down");
-                    self.a_down = true;
-                    out.net_tx().write(&ToNet::Ping);
-                }
-                Button::B => {
-                    out.log("button b down");
-                    self.b_down = true;
-                }
-            },
+    async fn handle_button_down(&mut self, button: Button, out: &mut impl Outputs) {
+        match button {
+            Button::A => {
+                out.log("button a down");
+                self.a_down = true;
+                out.status_led().set(false, self.a_down, self.b_down);
 
-            Event::ButtonUp(button) => match button {
-                Button::A => {
-                    out.log("button a up");
-                    self.a_down = false;
-                }
-                Button::B => {
-                    out.log("button b up");
-                    self.b_down = false;
-                }
-            },
-
-            Event::KeyDown(key, value) => {
-                // Log the key press
-                let mut msg: String<32> = Default::default();
-                write!(&mut msg, "key down: {:?} {:?}", key, value).unwrap();
-                out.log(&msg);
-
-                // If this key press is a return, then clear things out
-                if let Key::Enter = key {
-                    let mut msg: String<64> = Default::default();
-                    write!(&mut msg, "sending message: {}", self.message_buffer).unwrap();
-                    out.log(&msg);
-
-                    self.message_buffer.clear();
-
-                    let width = out.screen().bounding_box().size.width;
-                    let height = Self::FONT.height();
-                    Rectangle::new(Point::new(0, 0), Size::new(width, height))
-                        .into_styled(PrimitiveStyle::with_fill(Self::BACKGROUND))
-                        .draw(out.screen())
-                        .unwrap_or_else(|_| panic!("graphics error"));
-                    return;
+                out.net_tx().write(&ToNet::Ping);
+            }
+            Button::B => {
+                out.log("button b down");
+                self.b_down = true;
+                out.status_led().set(false, self.a_down, self.b_down);
+
+                self.ptt_state = PttState::Transmitting;
+                out.audio_data().start().await;
+
+                while out.button_b_down() {
+                    out.log("frame");
+                    let frame = out.audio_data().read().await;
+                    out.net_tx().write(&ToNet::AudioFrame(frame));
                 }
 
-                // Otherwise, if it's a character, add it to the buffer and render it to the screen
-                let KeyValue::Char(c) = value else {
-                    return;
-                };
+                out.log("button b up (via down)");
+                // TODO: Stop the audio buffer.  If we have this line right now, it causes a
+                // DmaUnsynced error.  Probably an error in the underlying driver code.
+                // out.audio_data().stop().await;
+                self.ptt_state = PttState::Idle;
+            }
+        }
+    }
 
-                if self.message_buffer.len() == self.message_buffer.capacity() {
-                    // Ignore any characters beyond the capacity of the message buffer
-                    return;
-                }
+    fn handle_button_up(&mut self, button: Button, out: &mut impl Outputs) {
+        match button {
+            Button::A => {
+                out.log("button a up");
+                self.a_down = false;
+            }
+            Button::B => {
+                out.log("button b up");
+                self.b_down = false;
+            }
+        }
+
+        out.status_led().set(false, self.a_down, self.b_down);
+    }
+
+    fn handle_key_down(&mut self, key: Key, value: KeyValue, out: &mut impl Outputs) {
+        // Log the key press
+        let mut msg: String<32> = Default::default();
+        write!(&mut msg, "key down: {:?} {:?}", key, value).unwrap();
+        out.log(&msg);
+
+        // If this key press is a return, then clear things out
+        if let Key::Enter = key {
+            let mut msg: String<{ MAX_MESSAGE_LEN + 20 }> = Default::default();
+            write!(&mut msg, "sending message: {}", self.message_buffer).unwrap();
+            out.log(&msg);
 
-                self.message_buffer.push(c).unwrap();
+            out.net_tx()
+                .write(&ToNet::Chat(self.message_buffer.clone()));
 
-                let text = Text::new(
-                    &self.message_buffer,
-                    Point { x: 0, y: 0 },
-                    TextStyle::new(&Self::FONT, BinaryColor::On),
-                );
+            self.message_buffer.clear();
 
-                let mut binary_display =
-                    BinaryDisplay::new(Rgb565::WHITE, Rgb565::BLACK, out.screen());
-                text.draw(&mut binary_display)
-                    .unwrap_or_else(|_| panic!("graphics error"));
+            let width = out.screen().bounding_box().size.width;
+            let height = Self::FONT.height();
+            Rectangle::new(Point::new(0, 0), Size::new(width, height))
+                .into_styled(PrimitiveStyle::with_fill(Self::BACKGROUND))
+                .draw(out.screen())
+                .unwrap_or_else(|_| panic!("graphics error"));
+            return;
+        }
+
+        // Otherwise, if it's a character, add it to the buffer and render it to the screen
+        let KeyValue::Char(c) = value else {
+            return;
+        };
+
+        if self.message_buffer.len() == self.message_buffer.capacity() {
+            // Ignore any characters beyond the capacity of the message buffer
+            return;
+        }
+
+        self.message_buffer.push(c).unwrap();
+
+        let text = Text::new(
+            &self.message_buffer,
+            Point { x: 0, y: 0 },
+            TextStyle::new(&Self::FONT, BinaryColor::On),
+        );
+
+        let mut binary_display = BinaryDisplay::new(Rgb565::WHITE, Rgb565::BLACK, out.screen());
+        text.draw(&mut binary_display)
+            .unwrap_or_else(|_| panic!("graphics error"));
+    }
+
+    fn handle_key_up(&mut self, key: Key, out: &mut impl Outputs) {
+        let mut msg: heapless::String<32> = Default::default();
+        write!(&mut msg, "key up: {:?}", key).unwrap();
+        out.log(&msg);
+    }
+
+    async fn handle_from_net(&mut self, from_net: FromNet, out: &mut impl Outputs) {
+        match from_net {
+            FromNet::Pong => {
+                out.log("pong");
             }
 
-            Event::KeyUp(key) => {
-                let mut msg: heapless::String<32> = Default::default();
-                write!(&mut msg, "key up: {:?}", key).unwrap();
-                out.log(&msg);
+            FromNet::AudioFrame(frame) if self.ptt_state == PttState::Receiving => {
+                out.audio_data().start().await;
+                out.audio_data().write(&frame).await
             }
 
-            Event::FromNet(from_net) => match from_net {
-                FromNet::Pong => {
-                    out.log("pong");
-                }
-            },
+            _ => {
+                out.log("Dropped out-of-context message from NET chip");
+            }
         }
+    }
 
-        out.status_led().set(false, self.a_down, self.b_down);
+    pub async fn handle(&mut self, event: Event, out: &mut impl Outputs) {
+        match event {
+            Event::ButtonDown(button) => self.handle_button_down(button, out).await,
+            Event::ButtonUp(button) => self.handle_button_up(button, out),
+            Event::KeyDown(key, value) => self.handle_key_down(key, value, out),
+            Event::KeyUp(key) => self.handle_key_up(key, out),
+            Event::FromNet(from_net) => self.handle_from_net(from_net, out).await,
+        }
+    }
+
+    pub async fn run(&mut self, mut events: impl EventSource, mut board: impl Outputs) {
+        while let Some(event) = events.receive().await {
+            self.handle(event, &mut board).await;
+        }
     }
 }