diff --git a/ui-app/src/lib.rs b/ui-app/src/lib.rs
index e4fee8e..108dee2 100644
--- a/ui-app/src/lib.rs
+++ b/ui-app/src/lib.rs
@@ -61,12 +61,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 +142,14 @@ pub trait Screen {
     fn draw(&mut self, left: usize, right: usize, top: usize, bottom: usize, data: &[u16]);
 }
 
+pub trait NetTx {
+    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);
 }
 
@@ -204,18 +220,23 @@ impl App {
         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;
                 }
             },
 
             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 +248,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-app/tests/integration.rs b/ui-app/tests/integration.rs
index 2652442..f627372 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/Cargo.toml b/ui-stm32/Cargo.toml
index 23bb70c..6336fe8 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -22,11 +22,17 @@ 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"] }
+embedded-io-async = "0.6.1"
+embedded-io = { version = "0.6.1", default-features = false }
 
 [profile.release]
 debug = 2
+
+[profile.dev]
+debug = 2
+opt-level = "s"
diff --git a/ui-stm32/src/board/ev12.rs b/ui-stm32/src/board/ev12.rs
index af90eff..30ddaf8 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);
     }
diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index 0507e65..f7ee6af 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -1,22 +1,62 @@
-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 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);
@@ -25,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 = [
@@ -64,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),
         }
     }
 }
@@ -86,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 b9e2744..0dde2fe 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 0000000..af9086e
--- /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::Write,
+{
+    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(PACKET).unwrap();
+            }
+        }
+    }
+}
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index e2f6b3c..d1d485e 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -3,12 +3,13 @@
 
 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 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;
@@ -38,26 +39,47 @@ 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_net(from: UartRx<'static, Async>, events: EventSender) {
+    const DMA_BUFFER_SIZE: usize = 1024;
+
+    // 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);
+
+    loop {
+        let Some(from_net) = from.next().await else {
+            continue;
+        };
+
+        events.send(Event::FromNet(from_net)).await;
+    }
+}
+
 #[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(),
+        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()
     )));
@@ -68,6 +90,13 @@ async fn main(spawner: Spawner) {
         EVENT_QUEUE.sender()
     )));
 
+    // Capture UART events from the NET chip
+    unwrap!(spawner.spawn(monitor_net(
+        board.net_rx.take().unwrap(),
+        EVENT_QUEUE.sender()
+    )));
+
+    debug!("app start");
     app.start(&mut board);
 
     // Main event loop
diff --git a/ui-tauri/src-tauri/src/lib.rs b/ui-tauri/src-tauri/src/lib.rs
index 235be23..afab3bd 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();