stuff

lib/src/uart.rs

@@ -0,0 +1,171 @@
+use core::mem::size_of;
+
+use bytemuck::{cast, AnyBitPattern, NoUninit};
+use crc_any::CRCu16;
+use embassy_executor::Spawner;
+use embassy_rp::peripherals::{PIN_0, PIN_1, UART0};
+use embassy_rp::uart::{self, BufferedUart, DataBits, Parity, StopBits};
+use embedded_io::asynch::{Read, Write};
+use futures::{select_biased, FutureExt};
+use heapless::Vec;
+use serde::{Deserialize, Serialize};
+use static_cell::StaticCell;
+
+use crate::event::{switch, Half};
+use crate::interrupts::Irqs;
+use crate::keyboard::KbEvents;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+enum Message {
+    KeyboardEvent(switch::Event),
+}
+
+pub async fn start(tx: PIN_0, rx: PIN_1, uart: UART0, board: Half, events: KbEvents) {
+    static TX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
+    static RX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
+
+    let mut config = uart::Config::default();
+    config.baudrate = 115200;
+    config.data_bits = DataBits::DataBits8;
+    config.stop_bits = StopBits::STOP1;
+    config.parity = Parity::ParityNone;
+
+    let uart = embassy_rp::uart::BufferedUart::new(
+        uart,
+        Irqs,
+        tx,
+        rx,
+        TX_BUF.init_with(|| [0u8; 256]),
+        RX_BUF.init_with(|| [0u8; 256]),
+        config,
+    );
+
+    Spawner::for_current_executor()
+        .await
+        .must_spawn(uart_task(uart, board, events))
+}
+
+#[embassy_executor::task]
+async fn uart_task(uart: BufferedUart<'static, UART0>, this_half: Half, mut events: KbEvents) {
+    let (mut rx, mut tx) = uart.split();
+    let (mut events_rx, mut events_tx) = events.split();
+
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug, NoUninit, AnyBitPattern)]
+    struct Header {
+        /// The length of the payload.
+        len: u8,
+
+        /// An arbitrary value to feed the crc, should be different for each message.
+        random: u8,
+
+        /// A little-endian crc16.
+        crc: [u8; 2],
+    }
+
+    const HEADER_LEN: usize = size_of::<Header>();
+
+    let rx_task = async {
+        let mut buf: heapless::Vec<u8, 1024> = Vec::new();
+        loop {
+            if buf.len() >= HEADER_LEN {
+                let (&header, rest) = buf.split_array_ref::<HEADER_LEN>();
+                let header: Header = cast(header);
+                let crc = u16::from_le_bytes(header.crc);
+                let mut calculated_crc = CRCu16::crc16();
+                calculated_crc.digest(&[header.len, header.random]);
+                let calculated_crc = calculated_crc.get_crc();
+
+                if calculated_crc != crc {
+                    log::error!("invalid uart header crc: {header:x?}");
+                    buf.remove(0); // pop the first byte and hope we find a good packet header
+                    continue;
+                }
+
+                log::debug!("got uart header {header:x?}");
+
+                let len = usize::from(header.len);
+                if rest.len() >= len {
+                    let r = postcard::from_bytes(&rest[..len]);
+
+                    // drop packet from buffer
+                    buf.rotate_left(len + HEADER_LEN);
+                    buf.truncate(buf.len() - len - HEADER_LEN);
+
+                    let message: Message = match r {
+                        Ok(v) => v,
+                        Err(e) => {
+                            log::error!("failed to deserialize message: {e}");
+                            continue;
+                        }
+                    };
+
+                    match &message {
+                        Message::KeyboardEvent(event) => events_tx.send(event.clone()),
+                    }
+
+                    log::info!("got msg: {:?}", message);
+                }
+            }
+
+            let mut chunk = [0u8; 128];
+            let n = match rx.read(&mut chunk).await {
+                Ok(n) => n,
+                Err(e) => {
+                    log::error!("uart error: {:?}", e);
+                    continue;
+                }
+            };
+            if buf.extend_from_slice(&chunk[..n]).is_err() {
+                log::error!("uart buffer full");
+                buf.clear();
+            }
+        }
+    };
+
+    let tx_task = async {
+        let mut buf = [0u8; 256 + HEADER_LEN];
+        let mut counter = 0u8;
+        loop {
+            // forward messages to the other keyboard half
+            let event = events_rx.recv().await;
+            if event.source != this_half {
+                continue; // do not forward messages from the other half back to it
+            }
+
+            let message = Message::KeyboardEvent(event);
+            let (buf_header, body) = buf.split_array_mut();
+            let serialized = match postcard::to_slice(&message, body) {
+                Ok(s) => s,
+                Err(e) => {
+                    log::error!("failed to serialize uart message: {e}");
+                    continue;
+                }
+            };
+
+            // add a "random" value to feed the crc
+            counter = counter.wrapping_add(1);
+            let random = counter;
+
+            let len = serialized.len() as u8;
+
+            let mut crc = CRCu16::crc16();
+            crc.digest(&[len, random]);
+            let header = Header {
+                len: serialized.len() as u8,
+                random,
+                crc: crc.get_crc().to_le_bytes(),
+            };
+            let header: [u8; HEADER_LEN] = cast(header);
+            *buf_header = header;
+
+            let package = &buf[..HEADER_LEN + usize::from(len)];
+            tx.write_all(package).await.ok();
+        }
+    };
+
+    select_biased! {
+        _ = tx_task.fuse() => log::error!("uart tx_task exited"),
+        _ = rx_task.fuse() => log::error!("eart rx_task exited"),
+    }
+}