From e43dfd3fa58d6e2a2c4026a110ae2d4ed07ee170 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Tue, 9 Sep 2025 13:21:56 -1000
Subject: [PATCH 1/9] Instantiate UART peripheral for NET connection

---
 ui-stm32/src/board/ev13.rs | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index 0507e652..a3c7f03c 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -1,8 +1,11 @@
 use super::{Button, Keyboard, Screen, StatusLed};
 use embassy_stm32::{
+    bind_interrupts,
     exti::ExtiInput,
     gpio::{Input, Level, Output, Pull, Speed},
+    peripherals,
     spi::Spi,
+    usart,
 };
 use ui_app::{Led, Outputs};
 
@@ -14,6 +17,10 @@ pub struct Board {
     pub keyboard: Option<Keyboard>,
 }
 
+bind_interrupts!(struct Irqs {
+    USART2 => usart::InterruptHandler<peripherals::USART2>;
+});
+
 impl Board {
     pub async fn new() -> Self {
         let p = embassy_stm32::init(Default::default());
@@ -64,8 +71,17 @@ impl Board {
         let spi1 = Spi::new_blocking_txonly(p.SPI1, p.PA5, p.PA7, config);
         let screen = Screen::new(chip_select, data_command, reset, backlight, spi1).await;
 
-        // TODO(RLB): NET UART
-        // TODO(RLB): MGMT UART
+        // NET UART
+        let net_uart = {
+            use embassy_stm32::usart::*;
+            let mut config = Config::default();
+            config.baudrate = 460800;
+            config.data_bits = DataBits::DataBits8;
+            config.stop_bits = StopBits::STOP2;
+            config.parity = Parity::ParityNone;
+
+            Uart::new(p.USART2, p.PA3, p.PA2, Irqs, p.DMA1_CH6, p.DMA1_CH5, config).unwrap()
+        };
 
         Self {
             status_led,

From 600116f505a66c26b94fc135550509f83ecedfa6 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Wed, 10 Sep 2025 12:56:25 -1000
Subject: [PATCH 2/9] Monitor for inbound messages

---
 ui-stm32/Cargo.toml        |  4 ++--
 ui-stm32/src/board/ev13.rs |  9 ++++++++-
 ui-stm32/src/main.rs       | 24 ++++++++++++++++++++++++
 3 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/ui-stm32/Cargo.toml b/ui-stm32/Cargo.toml
index 23bb70cc..b31882ee 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -22,11 +22,11 @@ embassy-executor = { version = "0.8.0", features = ["arch-cortex-m", "executor-t
 embassy-futures = { version = "0.1.1", features = ["defmt"] }
 embassy-stm32 = { version = "0.3.0", features = ["defmt", "stm32f405rg", "memory-x", "time-driver-tim1", "exti", "chrono"] }
 embassy-time = { version = "0.4.0", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-
-heapless = { version = "0.8", default-features = false }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 embassy-sync = { version = "0.7.1", features = ["defmt"] }
 num_enum = { version = "0.7.4", default-features = false }
+hex = { version = "0.4.3", default-features = false }
+heapless = { version = "0.9.1", features = ["defmt"] }
 
 [profile.release]
 debug = 2
diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index a3c7f03c..9b8d977c 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -3,18 +3,21 @@ use embassy_stm32::{
     bind_interrupts,
     exti::ExtiInput,
     gpio::{Input, Level, Output, Pull, Speed},
+    mode::Async,
     peripherals,
     spi::Spi,
-    usart,
+    usart::{self, UartRx, UartTx},
 };
 use ui_app::{Led, Outputs};
 
 pub struct Board {
     status_led: StatusLed,
     screen: Screen,
+    net_tx: UartTx<'static, Async>,
     pub ptt_button: Option<Button>,
     pub ai_button: Option<Button>,
     pub keyboard: Option<Keyboard>,
+    pub net_rx: Option<UartRx<'static, Async>>,
 }
 
 bind_interrupts!(struct Irqs {
@@ -83,12 +86,16 @@ impl Board {
             Uart::new(p.USART2, p.PA3, p.PA2, Irqs, p.DMA1_CH6, p.DMA1_CH5, config).unwrap()
         };
 
+        let (net_tx, net_rx) = net_uart.split();
+
         Self {
             status_led,
             screen,
+            net_tx,
             ptt_button: Some(ptt_button),
             ai_button: Some(ai_button),
             keyboard: Some(keyboard),
+            net_rx: Some(net_rx),
         }
     }
 }
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index 85b08b28..f43029bd 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -8,6 +8,7 @@ use ui_app::{App, Event};
 
 use defmt::*;
 use embassy_executor::Spawner;
+use embassy_stm32::{mode::Async, usart::UartRx};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::{Channel, Sender};
 use embassy_time::Timer;
@@ -43,6 +44,25 @@ async fn monitor_keyboard(mut keyboard: Keyboard, events: EventSender) {
     }
 }
 
+#[embassy_executor::task]
+async fn monitor_uart(mut from: UartRx<'static, Async>) {
+    use hex::ToHex;
+
+    const DMA_BUFFER_SIZE: usize = 1024;
+
+    // Configure a ring buffer on the DMA receiver
+    // let mut dma_buf = [0u8; DMA_BUFFER_SIZE];
+    // let mut from = from.into_ring_buffered(&mut dma_buf);
+
+    // Log results
+    let mut buf = [0u8; 128];
+    loop {
+        let n = unwrap!(from.read_until_idle(&mut buf).await);
+        let hex: heapless::String<256> = (&buf[..n]).encode_hex();
+        defmt::info!("net rx: [{}]", hex);
+    }
+}
+
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let mut board = Board::new().await;
@@ -69,6 +89,10 @@ async fn main(spawner: Spawner) {
         EVENT_QUEUE.sender()
     )));
 
+    // Capture UART events from the NET chip
+    unwrap!(spawner.spawn(monitor_uart(board.net_rx.take().unwrap())));
+
+    debug!("app start");
     app.start(&mut board);
 
     // Main event loop

From 6f7bc2317e7127ff892648383f2ebef33ef1ae3b Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Wed, 10 Sep 2025 16:43:08 -1000
Subject: [PATCH 3/9] Attempt to ping the NET chip

---
 ui-stm32/src/board/ev13.rs |  2 +-
 ui-stm32/src/main.rs       | 28 ++++++++++++++++++++++++++--
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index 9b8d977c..07bb6f7e 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -13,7 +13,7 @@ use ui_app::{Led, Outputs};
 pub struct Board {
     status_led: StatusLed,
     screen: Screen,
-    net_tx: UartTx<'static, Async>,
+    pub net_tx: UartTx<'static, Async>, // XXX should not be pub
     pub ptt_button: Option<Button>,
     pub ai_button: Option<Button>,
     pub keyboard: Option<Keyboard>,
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index f43029bd..46a7afec 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -90,8 +90,31 @@ async fn main(spawner: Spawner) {
     )));
 
     // Capture UART events from the NET chip
-    unwrap!(spawner.spawn(monitor_uart(board.net_rx.take().unwrap())));
-
+    // unwrap!(spawner.spawn(monitor_uart(board.net_rx.take().unwrap())));
+
+    // Send a Ping packet
+    info!("sending Ping");
+    const PING: u8 = 0x0e;
+    const PONG: u8 = 0x0f;
+    unwrap!(board.net_tx.write(&[PING, 0x00, 0x00, 0x00, 0x00]).await);
+
+    // Read a Pong packet (hopefully)
+    info!("awaiting Pong");
+    let mut net_rx = board.net_rx.take().unwrap();
+
+    let mut msg_type = [0_u8; 1];
+    let mut msg_len = [0_u8; 4];
+    unwrap!(net_rx.read(&mut msg_type).await);
+    unwrap!(net_rx.read(&mut msg_len).await);
+    info!(
+        "read T = {} =?= {}, L = {} =?= {}",
+        msg_type[0],
+        PONG,
+        u32::from_be_bytes(msg_len),
+        0
+    );
+
+    /*
     debug!("app start");
     app.start(&mut board);
 
@@ -100,4 +123,5 @@ async fn main(spawner: Spawner) {
         let event = EVENT_QUEUE.receive().await;
         app.handle(event, &mut board);
     }
+    */
 }

From f61828fbc4e393aef25b48dbf2918c87ca8d76da Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Wed, 10 Sep 2025 17:16:26 -1000
Subject: [PATCH 4/9] Add clock config

---
 ui-stm32/Cargo.toml        |  4 ++++
 ui-stm32/src/board/ev13.rs | 32 +++++++++++++++++++++++++++++++-
 ui-stm32/src/main.rs       | 26 ++++++++++++--------------
 3 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/ui-stm32/Cargo.toml b/ui-stm32/Cargo.toml
index b31882ee..7dbf057f 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -30,3 +30,7 @@ heapless = { version = "0.9.1", features = ["defmt"] }
 
 [profile.release]
 debug = 2
+
+[profile.release]
+debug = 2
+opt-level = "s"
diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index 07bb6f7e..46c44dc9 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -26,7 +26,37 @@ bind_interrupts!(struct Irqs {
 
 impl Board {
     pub async fn new() -> Self {
-        let p = embassy_stm32::init(Default::default());
+        let config = {
+            use embassy_stm32::{rcc::*, time::Hertz};
+
+            let mut config = embassy_stm32::Config::default();
+
+            config.rcc.hse = Some(Hse {
+                freq: Hertz(6_000_000),
+                mode: HseMode::Bypass,
+            });
+            config.rcc.sys = Sysclk::PLL1_P;
+            config.rcc.pll_src = PllSource::HSE;
+            config.rcc.pll = Some(Pll {
+                prediv: PllPreDiv::DIV3,
+                mul: PllMul::MUL168,
+                divp: Some(PllPDiv::DIV2),
+                divq: Some(PllQDiv::DIV7),
+                divr: None,
+            });
+
+            config.rcc.ahb_pre = AHBPrescaler::DIV1;
+            config.rcc.apb1_pre = APBPrescaler::DIV4;
+            config.rcc.apb2_pre = APBPrescaler::DIV2;
+            config.rcc.ls = LsConfig {
+                rtc: RtcClockSource::LSI,
+                lsi: true,
+                lse: None,
+            };
+
+            config
+        };
+        let p = embassy_stm32::init(config);
 
         // Status LED
         let r = Output::new(p.PA4, Level::Low, Speed::Low);
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index 46a7afec..0fa11432 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -12,6 +12,7 @@ use embassy_stm32::{mode::Async, usart::UartRx};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::{Channel, Sender};
 use embassy_time::Timer;
+use hex::ToHex;
 use {defmt_rtt as _, panic_probe as _};
 
 // Configuration parameters
@@ -46,8 +47,6 @@ async fn monitor_keyboard(mut keyboard: Keyboard, events: EventSender) {
 
 #[embassy_executor::task]
 async fn monitor_uart(mut from: UartRx<'static, Async>) {
-    use hex::ToHex;
-
     const DMA_BUFFER_SIZE: usize = 1024;
 
     // Configure a ring buffer on the DMA receiver
@@ -65,9 +64,13 @@ async fn monitor_uart(mut from: UartRx<'static, Async>) {
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
+    info!("about to instantiate board");
+
     let mut board = Board::new().await;
     let mut app = App::new();
 
+    info!("done setting up board and app");
+
     // Capture button events
     unwrap!(spawner.spawn(monitor_button(
         board.ai_button.take().unwrap(),
@@ -96,23 +99,18 @@ async fn main(spawner: Spawner) {
     info!("sending Ping");
     const PING: u8 = 0x0e;
     const PONG: u8 = 0x0f;
-    unwrap!(board.net_tx.write(&[PING, 0x00, 0x00, 0x00, 0x00]).await);
+    // unwrap!(board.net_tx.write(&[PING, 0x00, 0x00, 0x00, 0x00]).await);
 
     // Read a Pong packet (hopefully)
     info!("awaiting Pong");
     let mut net_rx = board.net_rx.take().unwrap();
 
-    let mut msg_type = [0_u8; 1];
-    let mut msg_len = [0_u8; 4];
-    unwrap!(net_rx.read(&mut msg_type).await);
-    unwrap!(net_rx.read(&mut msg_len).await);
-    info!(
-        "read T = {} =?= {}, L = {} =?= {}",
-        msg_type[0],
-        PONG,
-        u32::from_be_bytes(msg_len),
-        0
-    );
+    let mut buf = [0u8; 128];
+    loop {
+        let n = unwrap!(net_rx.read_until_idle(&mut buf).await);
+        let hex: heapless::String<256> = (&buf[..n]).encode_hex();
+        defmt::info!("net rx: [{}]", hex);
+    }
 
     /*
     debug!("app start");

From 1b2c9da40fe05c15c50ecf8839dd521f17e4fa0b Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Wed, 10 Sep 2025 20:02:44 -1000
Subject: [PATCH 5/9] Successful ping/pong test

---
 ui-stm32/Cargo.toml  |  2 +-
 ui-stm32/src/main.rs | 20 ++++++--------------
 2 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/ui-stm32/Cargo.toml b/ui-stm32/Cargo.toml
index 7dbf057f..1e924d9f 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -31,6 +31,6 @@ heapless = { version = "0.9.1", features = ["defmt"] }
 [profile.release]
 debug = 2
 
-[profile.release]
+[profile.dev]
 debug = 2
 opt-level = "s"
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index 0fa11432..3370f99f 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -47,7 +47,7 @@ async fn monitor_keyboard(mut keyboard: Keyboard, events: EventSender) {
 
 #[embassy_executor::task]
 async fn monitor_uart(mut from: UartRx<'static, Async>) {
-    const DMA_BUFFER_SIZE: usize = 1024;
+    // const DMA_BUFFER_SIZE: usize = 1024;
 
     // Configure a ring buffer on the DMA receiver
     // let mut dma_buf = [0u8; DMA_BUFFER_SIZE];
@@ -93,23 +93,15 @@ async fn main(spawner: Spawner) {
     )));
 
     // Capture UART events from the NET chip
-    // unwrap!(spawner.spawn(monitor_uart(board.net_rx.take().unwrap())));
+    unwrap!(spawner.spawn(monitor_uart(board.net_rx.take().unwrap())));
 
     // Send a Ping packet
-    info!("sending Ping");
     const PING: u8 = 0x0e;
-    const PONG: u8 = 0x0f;
-    // unwrap!(board.net_tx.write(&[PING, 0x00, 0x00, 0x00, 0x00]).await);
-
-    // Read a Pong packet (hopefully)
-    info!("awaiting Pong");
-    let mut net_rx = board.net_rx.take().unwrap();
-
-    let mut buf = [0u8; 128];
+    const PACKET: &[u8] = &[PING, 0x00, 0x00, 0x00, 0x00, 0xC0];
     loop {
-        let n = unwrap!(net_rx.read_until_idle(&mut buf).await);
-        let hex: heapless::String<256> = (&buf[..n]).encode_hex();
-        defmt::info!("net rx: [{}]", hex);
+        info!("ping");
+        Timer::after_millis(1000).await;
+        unwrap!(board.net_tx.write(PACKET).await);
     }
 
     /*

From a76e08fe6a17843c150b02f7b041842894598506 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Thu, 11 Sep 2025 15:33:26 -1000
Subject: [PATCH 6/9] Add stm32 implementation

---
 ui-app/src/lib.rs          | 30 ++++++++++++++++-
 ui-stm32/Cargo.toml        |  1 +
 ui-stm32/src/board/ev13.rs | 21 +++++++-----
 ui-stm32/src/board/mod.rs  |  3 ++
 ui-stm32/src/board/net.rs  | 68 ++++++++++++++++++++++++++++++++++++++
 ui-stm32/src/main.rs       | 49 +++++++++++----------------
 6 files changed, 134 insertions(+), 38 deletions(-)
 create mode 100644 ui-stm32/src/board/net.rs

diff --git a/ui-app/src/lib.rs b/ui-app/src/lib.rs
index e4fee8ea..9dc02efe 100644
--- a/ui-app/src/lib.rs
+++ b/ui-app/src/lib.rs
@@ -1,4 +1,5 @@
 #![no_std]
+#![allow(async_fn_in_trait)]
 
 use defmt::Format;
 
@@ -61,12 +62,23 @@ pub enum Button {
     B,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Format)]
+pub enum FromNet {
+    Pong,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Format)]
+pub enum ToNet {
+    Ping,
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Format)]
 pub enum Event {
     ButtonDown(Button),
     ButtonUp(Button),
     KeyDown(Key, KeyValue),
     KeyUp(Key),
+    FromNet(FromNet),
 }
 
 #[allow(dead_code)]
@@ -131,9 +143,14 @@ pub trait Screen {
     fn draw(&mut self, left: usize, right: usize, top: usize, bottom: usize, data: &[u16]);
 }
 
+pub trait NetTx {
+    async fn write(&mut self, to_net: &ToNet);
+}
+
 pub trait Outputs {
     fn status_led(&mut self) -> &mut impl Led;
     fn screen(&mut self) -> &mut impl Screen;
+    fn net_tx(&mut self) -> &mut impl NetTx;
     fn log(&mut self, message: &str);
 }
 
@@ -200,22 +217,27 @@ impl App {
         screen.draw(x0, x1, y0, y1, &data);
     }
 
-    pub fn handle(&mut self, event: Event, out: &mut impl Outputs) {
+    pub async 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).await;
                 }
                 Button::B => {
+                    out.log("button b down");
                     self.b_down = true;
                 }
             },
 
             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;
                 }
             },
@@ -227,6 +249,12 @@ impl App {
             Event::KeyUp(_key) => {
                 out.log("key up");
             }
+
+            Event::FromNet(from_net) => match from_net {
+                FromNet::Pong => {
+                    out.log("pong");
+                }
+            },
         }
 
         out.status_led().set(false, self.a_down, self.b_down);
diff --git a/ui-stm32/Cargo.toml b/ui-stm32/Cargo.toml
index 1e924d9f..bbd8e329 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -27,6 +27,7 @@ embassy-sync = { version = "0.7.1", features = ["defmt"] }
 num_enum = { version = "0.7.4", default-features = false }
 hex = { version = "0.4.3", default-features = false }
 heapless = { version = "0.9.1", features = ["defmt"] }
+embedded-io-async = "0.6.1"
 
 [profile.release]
 debug = 2
diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index 46c44dc9..f7ee6af1 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -1,4 +1,4 @@
-use super::{Button, Keyboard, Screen, StatusLed};
+use super::{Button, Keyboard, NetTx, Screen, StatusLed};
 use embassy_stm32::{
     bind_interrupts,
     exti::ExtiInput,
@@ -13,9 +13,9 @@ use ui_app::{Led, Outputs};
 pub struct Board {
     status_led: StatusLed,
     screen: Screen,
-    pub net_tx: UartTx<'static, Async>, // XXX should not be pub
-    pub ptt_button: Option<Button>,
-    pub ai_button: Option<Button>,
+    net_tx: NetTx<UartTx<'static, Async>>,
+    pub button_a: Option<Button>,
+    pub button_b: Option<Button>,
     pub keyboard: Option<Keyboard>,
     pub net_rx: Option<UartRx<'static, Async>>,
 }
@@ -65,8 +65,8 @@ impl Board {
         let status_led = StatusLed { r, g, b };
 
         // Buttons
-        let ai_button = ExtiInput::new(p.PC0, p.EXTI0, Pull::Up);
-        let ptt_button = ExtiInput::new(p.PC1, p.EXTI1, Pull::Up);
+        let button_a = ExtiInput::new(p.PC1, p.EXTI1, Pull::Up);
+        let button_b = ExtiInput::new(p.PC0, p.EXTI0, Pull::Up);
 
         // Keyboard
         let cols = [
@@ -117,13 +117,14 @@ impl Board {
         };
 
         let (net_tx, net_rx) = net_uart.split();
+        let net_tx = NetTx::new(net_tx);
 
         Self {
             status_led,
             screen,
             net_tx,
-            ptt_button: Some(ptt_button),
-            ai_button: Some(ai_button),
+            button_a: Some(button_a),
+            button_b: Some(button_b),
             keyboard: Some(keyboard),
             net_rx: Some(net_rx),
         }
@@ -139,6 +140,10 @@ impl Outputs for Board {
         &mut self.screen
     }
 
+    fn net_tx(&mut self) -> &mut impl ui_app::NetTx {
+        &mut self.net_tx
+    }
+
     fn log(&mut self, message: &str) {
         defmt::info!("{}", message);
     }
diff --git a/ui-stm32/src/board/mod.rs b/ui-stm32/src/board/mod.rs
index b9e27446..0dde2fea 100644
--- a/ui-stm32/src/board/mod.rs
+++ b/ui-stm32/src/board/mod.rs
@@ -30,6 +30,9 @@ pub use keyboard::Keyboard;
 mod screen;
 pub use screen::Screen;
 
+mod net;
+pub use net::{NetRx, NetTx};
+
 struct StatusLed {
     r: Output<'static>,
     g: Output<'static>,
diff --git a/ui-stm32/src/board/net.rs b/ui-stm32/src/board/net.rs
new file mode 100644
index 00000000..4da768a2
--- /dev/null
+++ b/ui-stm32/src/board/net.rs
@@ -0,0 +1,68 @@
+use ui_app::{FromNet, ToNet};
+
+// XXX(RLB) This reader will only work as long as the data in the value of the TLV doesn't have any
+// characters that need to be escaped according to SLIP.  Also, it only supports TLVs with up to
+// 128 bytes of payload.
+pub struct NetRx<'a, Reader> {
+    rx: &'a mut Reader,
+}
+
+impl<'a, Reader> NetRx<'a, Reader>
+where
+    Reader: embedded_io_async::Read + 'a,
+{
+    pub fn new(rx: &'a mut Reader) -> Self {
+        Self { rx }
+    }
+
+    pub async fn next(&mut self) -> Option<FromNet> {
+        let mut type_ = [0u8; 1];
+        let mut length = [0u8; 4];
+        let mut value = [0u8; 128];
+
+        self.rx.read(&mut type_).await.unwrap();
+        self.rx.read(&mut length).await.unwrap();
+
+        let length = u32::from_be_bytes(length) as usize;
+        let delimited_value = &mut value[..(length + 1)];
+        self.rx.read(delimited_value).await.unwrap();
+
+        match type_[0] {
+            0x0f => {
+                defmt::assert_eq!(length, 0);
+                Some(FromNet::Pong)
+            }
+            _ => {
+                defmt::debug!("skipping TLV of type {:x}", type_[0]);
+                None
+            }
+        }
+    }
+}
+
+// XXX(RLB) This is just a fixed writer right now, with no generic logic for SLIP or the TLV
+// format.  It will need to be generalized.
+pub struct NetTx<Writer> {
+    tx: Writer,
+}
+
+impl<Writer> NetTx<Writer> {
+    pub fn new(tx: Writer) -> Self {
+        Self { tx }
+    }
+}
+
+impl<Writer> ui_app::NetTx for NetTx<Writer>
+where
+    Writer: embedded_io_async::Write,
+{
+    async fn write(&mut self, to_net: &ToNet) {
+        match to_net {
+            ToNet::Ping => {
+                const PING: u8 = 0x0e;
+                const PACKET: &[u8] = &[PING, 0x00, 0x00, 0x00, 0x00, 0xC0];
+                self.tx.write_all(PACKET).await.unwrap();
+            }
+        }
+    }
+}
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index f6752129..6984b198 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -3,9 +3,9 @@
 
 mod board;
 
-use board::{Board, Button, Keyboard};
+use board::{Board, Button, Keyboard, NetRx};
 use ui_app::Button as ButtonId;
-use ui_app::{App, Event};
+use ui_app::{App, Event, NetTx, Outputs, ToNet};
 
 use defmt::*;
 use embassy_executor::Spawner;
@@ -13,7 +13,6 @@ use embassy_stm32::{mode::Async, usart::UartRx};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::{Channel, Sender};
 use embassy_time::Timer;
-use hex::ToHex;
 use {defmt_rtt as _, panic_probe as _};
 
 // Configuration parameters
@@ -40,26 +39,26 @@ async fn monitor_keyboard(mut keyboard: Keyboard, events: EventSender) {
     loop {
         let _ = Timer::after_millis(KEYBOARD_SCAN_MILLIS).await;
         for event in keyboard.scan() {
-            defmt::info!("kbd event: {:?}", event);
             events.send(event).await;
         }
     }
 }
 
 #[embassy_executor::task]
-async fn monitor_uart(mut from: UartRx<'static, Async>) {
-    // const DMA_BUFFER_SIZE: usize = 1024;
+async fn monitor_net(from: UartRx<'static, Async>, events: EventSender) {
+    const DMA_BUFFER_SIZE: usize = 1024;
 
-    // Configure a ring buffer on the DMA receiver
-    // let mut dma_buf = [0u8; DMA_BUFFER_SIZE];
-    // let mut from = from.into_ring_buffered(&mut dma_buf);
+    // Wrap the raw receiver in a DMA-buffered, SLIP-parsing, TLV-parsing version
+    let mut dma_buf = [0u8; DMA_BUFFER_SIZE];
+    let mut from = from.into_ring_buffered(&mut dma_buf);
+    let mut from = NetRx::new(&mut from);
 
-    // Log results
-    let mut buf = [0u8; 128];
     loop {
-        let n = unwrap!(from.read_until_idle(&mut buf).await);
-        let hex: heapless::String<256> = (&buf[..n]).encode_hex();
-        defmt::info!("net rx: [{}]", hex);
+        let Some(from_net) = from.next().await else {
+            continue;
+        };
+
+        events.send(Event::FromNet(from_net)).await;
     }
 }
 
@@ -74,13 +73,13 @@ async fn main(spawner: Spawner) {
 
     // Capture button events
     unwrap!(spawner.spawn(monitor_button(
-        board.ai_button.take().unwrap(),
+        board.button_a.take().unwrap(),
         ButtonId::A,
         EVENT_QUEUE.sender()
     )));
 
     unwrap!(spawner.spawn(monitor_button(
-        board.ptt_button.take().unwrap(),
+        board.button_b.take().unwrap(),
         ButtonId::B,
         EVENT_QUEUE.sender()
     )));
@@ -92,25 +91,17 @@ async fn main(spawner: Spawner) {
     )));
 
     // Capture UART events from the NET chip
-    unwrap!(spawner.spawn(monitor_uart(board.net_rx.take().unwrap())));
-
-    // Send a Ping packet
-    const PING: u8 = 0x0e;
-    const PACKET: &[u8] = &[PING, 0x00, 0x00, 0x00, 0x00, 0xC0];
-    loop {
-        info!("ping");
-        Timer::after_millis(1000).await;
-        unwrap!(board.net_tx.write(PACKET).await);
-    }
+    unwrap!(spawner.spawn(monitor_net(
+        board.net_rx.take().unwrap(),
+        EVENT_QUEUE.sender()
+    )));
 
-    /*
     debug!("app start");
     app.start(&mut board);
 
     // Main event loop
     loop {
         let event = EVENT_QUEUE.receive().await;
-        app.handle(event, &mut board);
+        app.handle(event, &mut board).await;
     }
-    */
 }

From f1f027b4020297e77618c30f7f3c6ad0e8646c62 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Thu, 11 Sep 2025 20:09:53 -1000
Subject: [PATCH 7/9] Revert the net_tx interface to being sync

---
 ui-app/src/lib.rs         | 4 ++--
 ui-stm32/Cargo.toml       | 1 +
 ui-stm32/src/board/net.rs | 6 +++---
 ui-stm32/src/main.rs      | 2 +-
 4 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/ui-app/src/lib.rs b/ui-app/src/lib.rs
index 9dc02efe..4d3cf433 100644
--- a/ui-app/src/lib.rs
+++ b/ui-app/src/lib.rs
@@ -144,7 +144,7 @@ pub trait Screen {
 }
 
 pub trait NetTx {
-    async fn write(&mut self, to_net: &ToNet);
+    fn write(&mut self, to_net: &ToNet);
 }
 
 pub trait Outputs {
@@ -223,7 +223,7 @@ impl App {
                 Button::A => {
                     out.log("button a down");
                     self.a_down = true;
-                    out.net_tx().write(&ToNet::Ping).await;
+                    out.net_tx().write(&ToNet::Ping);
                 }
                 Button::B => {
                     out.log("button b down");
diff --git a/ui-stm32/Cargo.toml b/ui-stm32/Cargo.toml
index bbd8e329..6336fe8c 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -28,6 +28,7 @@ num_enum = { version = "0.7.4", default-features = false }
 hex = { version = "0.4.3", default-features = false }
 heapless = { version = "0.9.1", features = ["defmt"] }
 embedded-io-async = "0.6.1"
+embedded-io = { version = "0.6.1", default-features = false }
 
 [profile.release]
 debug = 2
diff --git a/ui-stm32/src/board/net.rs b/ui-stm32/src/board/net.rs
index 4da768a2..af9086ea 100644
--- a/ui-stm32/src/board/net.rs
+++ b/ui-stm32/src/board/net.rs
@@ -54,14 +54,14 @@ impl<Writer> NetTx<Writer> {
 
 impl<Writer> ui_app::NetTx for NetTx<Writer>
 where
-    Writer: embedded_io_async::Write,
+    Writer: embedded_io::Write,
 {
-    async fn write(&mut self, to_net: &ToNet) {
+    fn write(&mut self, to_net: &ToNet) {
         match to_net {
             ToNet::Ping => {
                 const PING: u8 = 0x0e;
                 const PACKET: &[u8] = &[PING, 0x00, 0x00, 0x00, 0x00, 0xC0];
-                self.tx.write_all(PACKET).await.unwrap();
+                self.tx.write(PACKET).unwrap();
             }
         }
     }
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index 6984b198..b12e819b 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -5,7 +5,7 @@ mod board;
 
 use board::{Board, Button, Keyboard, NetRx};
 use ui_app::Button as ButtonId;
-use ui_app::{App, Event, NetTx, Outputs, ToNet};
+use ui_app::{App, Event};
 
 use defmt::*;
 use embassy_executor::Spawner;

From bd3496f6f89be2c4b8390571af160f1a1c9aa774 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Thu, 11 Sep 2025 20:13:37 -1000
Subject: [PATCH 8/9] Backport to ev12

---
 ui-stm32/src/board/ev12.rs | 46 ++++++++++++++++++++++++++++++--------
 1 file changed, 37 insertions(+), 9 deletions(-)

diff --git a/ui-stm32/src/board/ev12.rs b/ui-stm32/src/board/ev12.rs
index af90eff1..30ddaf85 100644
--- a/ui-stm32/src/board/ev12.rs
+++ b/ui-stm32/src/board/ev12.rs
@@ -1,19 +1,29 @@
-use super::{Button, Keyboard, Screen, StatusLed};
+use super::{Button, Keyboard, NetTx, Screen, StatusLed};
 use embassy_stm32::{
+    bind_interrupts,
     exti::ExtiInput,
     gpio::{Input, Level, Output, Pull, Speed},
+    mode::Async,
+    peripherals,
     spi::Spi,
+    usart::{self, UartRx, UartTx},
 };
 use ui_app::{Led, Outputs};
 
 pub struct Board {
     status_led: StatusLed,
     screen: Screen,
-    pub ptt_button: Option<Button>,
-    pub ai_button: Option<Button>,
+    net_tx: NetTx<UartTx<'static, Async>>,
+    pub button_a: Option<Button>,
+    pub button_b: Option<Button>,
     pub keyboard: Option<Keyboard>,
+    pub net_rx: Option<UartRx<'static, Async>>,
 }
 
+bind_interrupts!(struct Irqs {
+    USART2 => usart::InterruptHandler<peripherals::USART2>;
+});
+
 impl Board {
     pub async fn new() -> Self {
         let config = {
@@ -55,8 +65,8 @@ impl Board {
         let status_led = StatusLed { r, g, b };
 
         // Buttons
-        let ai_button = ExtiInput::new(p.PC0, p.EXTI0, Pull::Up);
-        let ptt_button = ExtiInput::new(p.PC1, p.EXTI1, Pull::Up);
+        let button_a = ExtiInput::new(p.PC1, p.EXTI1, Pull::Up);
+        let button_b = ExtiInput::new(p.PC0, p.EXTI0, Pull::Up);
 
         // Keyboard
         let cols = [
@@ -94,15 +104,29 @@ impl Board {
         let spi1 = Spi::new_blocking_txonly(p.SPI1, p.PA5, p.PA7, config);
         let screen = Screen::new(chip_select, data_command, reset, backlight, spi1).await;
 
-        // TODO(RLB): NET UART
-        // TODO(RLB): MGMT UART
+        // NET UART
+        let net_uart = {
+            use embassy_stm32::usart::*;
+            let mut config = Config::default();
+            config.baudrate = 460800;
+            config.data_bits = DataBits::DataBits8;
+            config.stop_bits = StopBits::STOP2;
+            config.parity = Parity::ParityNone;
+
+            Uart::new(p.USART2, p.PA3, p.PA2, Irqs, p.DMA1_CH6, p.DMA1_CH5, config).unwrap()
+        };
+
+        let (net_tx, net_rx) = net_uart.split();
+        let net_tx = NetTx::new(net_tx);
 
         Self {
             status_led,
             screen,
-            ptt_button: Some(ptt_button),
-            ai_button: Some(ai_button),
+            net_tx,
+            button_a: Some(button_a),
+            button_b: Some(button_b),
             keyboard: Some(keyboard),
+            net_rx: Some(net_rx),
         }
     }
 }
@@ -116,6 +140,10 @@ impl Outputs for Board {
         &mut self.screen
     }
 
+    fn net_tx(&mut self) -> &mut impl ui_app::NetTx {
+        &mut self.net_tx
+    }
+
     fn log(&mut self, message: &str) {
         defmt::info!("{}", message);
     }

From 15dd8c89e23a04c068d77eafbb2a3b1cc9d1bb50 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rlb@ipv.sx>
Date: Thu, 11 Sep 2025 20:35:07 -1000
Subject: [PATCH 9/9] Fix ui-app tests and tauri

---
 ui-app/src/lib.rs             |  3 +--
 ui-app/tests/integration.rs   | 26 +++++++++++++++++++++
 ui-stm32/src/main.rs          |  2 +-
 ui-tauri/src-tauri/src/lib.rs | 44 +++++++++++++++++++++++++++++++----
 4 files changed, 67 insertions(+), 8 deletions(-)

diff --git a/ui-app/src/lib.rs b/ui-app/src/lib.rs
index 4d3cf433..108dee28 100644
--- a/ui-app/src/lib.rs
+++ b/ui-app/src/lib.rs
@@ -1,5 +1,4 @@
 #![no_std]
-#![allow(async_fn_in_trait)]
 
 use defmt::Format;
 
@@ -217,7 +216,7 @@ impl App {
         screen.draw(x0, x1, y0, y1, &data);
     }
 
-    pub async fn handle(&mut self, event: Event, out: &mut impl Outputs) {
+    pub fn handle(&mut self, event: Event, out: &mut impl Outputs) {
         match event {
             Event::ButtonDown(button) => match button {
                 Button::A => {
diff --git a/ui-app/tests/integration.rs b/ui-app/tests/integration.rs
index 2652442a..f6273721 100644
--- a/ui-app/tests/integration.rs
+++ b/ui-app/tests/integration.rs
@@ -33,10 +33,22 @@ impl Screen for MockScreen {
     }
 }
 
+#[derive(Default)]
+struct MockNetTx {
+    last_to_net: Option<ToNet>,
+}
+
+impl NetTx for MockNetTx {
+    fn write(&mut self, to_net: &ToNet) {
+        self.last_to_net = Some(*to_net);
+    }
+}
+
 #[derive(Default)]
 struct MockOutputs {
     status_led: MockLed,
     screen: MockScreen,
+    net_tx: MockNetTx,
     last_message: String,
 }
 
@@ -49,6 +61,10 @@ impl Outputs for MockOutputs {
         &mut self.screen
     }
 
+    fn net_tx(&mut self) -> &mut impl NetTx {
+        &mut self.net_tx
+    }
+
     fn log(&mut self, message: &str) {
         self.last_message = message.into();
     }
@@ -130,3 +146,13 @@ fn key_logging() {
     app.handle(Event::KeyUp(Key::A), &mut outputs);
     assert_eq!(outputs.last_message, "key up");
 }
+
+#[test]
+fn button_a_sends_ping() {
+    let mut outputs = MockOutputs::default();
+    let mut app = App::new();
+    app.start(&mut outputs);
+
+    app.handle(Event::ButtonDown(Button::A), &mut outputs);
+    assert_eq!(outputs.net_tx.last_to_net, Some(ToNet::Ping));
+}
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index b12e819b..d1d485e8 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -102,6 +102,6 @@ async fn main(spawner: Spawner) {
     // Main event loop
     loop {
         let event = EVENT_QUEUE.receive().await;
-        app.handle(event, &mut board).await;
+        app.handle(event, &mut board);
     }
 }
diff --git a/ui-tauri/src-tauri/src/lib.rs b/ui-tauri/src-tauri/src/lib.rs
index 235be230..afab3bd1 100644
--- a/ui-tauri/src-tauri/src/lib.rs
+++ b/ui-tauri/src-tauri/src/lib.rs
@@ -3,9 +3,9 @@
 
 use core::ops::DerefMut;
 use once_cell::sync::OnceCell;
-use std::sync::Mutex;
+use std::sync::{mpsc, Mutex};
 use tauri::Emitter;
-use ui_app::{App, Button, Event, Key, KeyValue, Led, Outputs, Screen};
+use ui_app::{App, Button, Event, FromNet, Key, KeyValue, Led, NetTx, Outputs, Screen, ToNet};
 
 mod hactar_vaporwave;
 
@@ -37,11 +37,12 @@ const UI_LED_NAME: &str = "led-ui";
 #[derive(Debug)]
 struct Board {
     app: tauri::AppHandle,
+    to_net: mpsc::Sender<ToNet>,
 }
 
 impl Board {
-    fn new(app: tauri::AppHandle) -> Self {
-        Self { app }
+    fn new(app: tauri::AppHandle, to_net: mpsc::Sender<ToNet>) -> Self {
+        Self { app, to_net }
     }
 }
 
@@ -112,6 +113,12 @@ impl Screen for Board {
     }
 }
 
+impl NetTx for Board {
+    fn write(&mut self, to_net: &ToNet) {
+        self.to_net.send(*to_net).unwrap();
+    }
+}
+
 impl Outputs for Board {
     fn status_led(&mut self) -> &mut impl Led {
         self
@@ -121,6 +128,10 @@ impl Outputs for Board {
         self
     }
 
+    fn net_tx(&mut self) -> &mut impl NetTx {
+        self
+    }
+
     fn log(&mut self, message: &str) {
         println!("LOG: {}", message);
     }
@@ -252,9 +263,32 @@ static UI_APP: OnceCell<Mutex<App>> = OnceCell::new();
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    let (to_net, from_ui) = mpsc::channel::<ToNet>();
+    let (to_ui, from_net) = mpsc::channel::<FromNet>();
+
+    // Consume and process NET messages
+    std::thread::spawn(move || {
+        while let Ok(to_net) = from_ui.recv() {
+            match to_net {
+                ToNet::Ping => {
+                    to_ui.send(FromNet::Pong).unwrap();
+                }
+            }
+        }
+    });
+
+    // Forward messages to NET to the app
+    std::thread::spawn(move || {
+        while let Ok(from_net) = from_net.recv() {
+            let mut board = BOARD.get().unwrap().lock().unwrap();
+            let mut ui_app = UI_APP.get().unwrap().lock().unwrap();
+            ui_app.handle(Event::FromNet(from_net), board.deref_mut());
+        }
+    });
+
     tauri::Builder::default()
         .setup(|app| {
-            let board = Board::new(app.handle().clone());
+            let board = Board::new(app.handle().clone(), to_net);
             BOARD.set(Mutex::new(board)).unwrap();
 
             let ui_app = App::new();