switch to udp

dev-proxy/index.ts

@@ -2,41 +2,45 @@ import type {
 	PartySocketEvent,
 	PartyState,
 } from "../api/src/party-types";
-let ws: WebSocket | null = null;
+let ws: WebSocket | null  = new WebSocket("ws://localhost:3000/api/dev-socket/ws");
 
-Bun.listen({
-  hostname: "0.0.0.0",
+const socket = await Bun.udpSocket({
   port: 7070,
   socket: {
-    data(socket, data) {
-      // in1={} in2={} in3={} in4={} angle={}
-      console.log("recv", data)
-    }, // message received from client
-    open(socket) {
-      console.log("Connected");
-      ws = new WebSocket("ws://localhost:3000/api/dev-socket/ws");
-
-      ws.onmessage = e => {
-        const data = JSON.parse(e.data) as PartySocketEvent;
-        switch (data.type) {
-          case "party_status":
-            const { party: { data: { currentQuestion } } } = data;
-            console.log(currentQuestion)
-            let text = currentQuestion?.text
-            if (text) {
-              ws?.send(text)
-            }
-            break;
-        }
-      }
-    }, // socket opened
-    close(socket, error) {
-      ws?.close();
-      ws = null;
-    }, // socket closed
-    drain(socket) {}, // socket ready for more data
-    error(socket, error) {}, // error handler
+    data(socket, buf, port, addr) {
+      console.log(`message from ${addr}:${port}:`);
+      console.log(buf.toString());
+    },
   },
 });
 
+
+
+ws.onerror = e => {
+  console.error(e)
+}
+
+ws.onopen = () => {
+  console.log("WebSocket open")
+}
+
+ws.onmessage = e => {
+  const data = JSON.parse(e.data) as PartySocketEvent;
+  console.log(data)
+  switch (data.type) {
+    case "party_status":
+      const { party } = data;
+      if (!party) return;
+      const partyData = party.data;
+      if (!partyData) return;
+      const { currentQuestion } = partyData
+      console.log(currentQuestion)
+      let text = currentQuestion?.text
+      if (text) {
+        ws?.send(text)
+      }
+      break;
+  }
+}
+
 console.log("Started on :7070")

pico/src/main.rs

@@ -3,9 +3,11 @@
 
 use arrayvec::ArrayVec;
 use core::convert::Infallible;
+use core::net::SocketAddrV4;
 use core::ops::Deref;
 use core::str::FromStr;
 use embassy_net::tcp::ConnectError;
+use embassy_net::udp::{PacketMetadata, UdpMetadata, UdpSocket};
 use embedded_io::ReadReady;
 
 use ag_lcd::{Blink, Cursor, Display, LcdDisplay};
@@ -166,31 +168,22 @@ async fn main(spawner: Spawner) {
     let in4 = Input::new(p.PIN_21, embassy_rp::gpio::Pull::Up);
 
     let mut rx_buffer = [0; 4096];
+    let mut rx_meta = [PacketMetadata::EMPTY; 16];
     let mut tx_buffer = [0; 4096];
-    let mut socket = embassy_net::tcp::TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
+    let mut tx_meta = [PacketMetadata::EMPTY; 16];
+
+    let mut socket = UdpSocket::new(
+        stack,
+        &mut rx_meta,
+        &mut rx_buffer,
+        &mut tx_meta,
+        &mut tx_buffer,
+    );
+    socket.bind(7070).unwrap();
 
-    led.set_low();
-    info!("Connecting...");
-    uwrite!(lcd, "con2.");
     let host_addr = embassy_net::Ipv4Address::from_str("192.168.12.1").unwrap();
-    if let Err(e) = socket.connect((host_addr, 7070)).await {
-        lcd.clear();
-        uwrite!(lcd, "conerr");
-        Timer::after(Duration::from_micros(100)).await;
-        lcd.set_position(0, 1);
-        let emsg = match e {
-            ConnectError::ConnectionReset => "rst",
-            ConnectError::InvalidState => "inv",
-            ConnectError::TimedOut => "tout",
-            ConnectError::NoRoute => "nroute",
-        };
-        uwrite!(lcd, "{}", emsg);
-        warn!("connect error: {:?}", e);
-    } else {
-        uwrite!(lcd, "conok");
-    }
-    info!("Connected to {:?}", socket.remote_endpoint());
+    let target = UdpMetadata::from(SocketAddrV4::new(host_addr, 7070));
+    uwrite!(lcd, "udp.");
 
     let delay = Duration::from_millis(100);
     let mut buffer = WriteBuffer::<1024>::new();
@@ -213,12 +206,12 @@ async fn main(spawner: Spawner) {
             );
         }
         {
-            use embedded_io_async::Write;
-            let _ = socket.write_all(&*buffer).await;
+            let _ = socket.send_to(&*buffer, target).await;
+            buffer.0.clear();
         }
-        if socket.read_ready().unwrap_or(false) {
+        if socket.may_recv() {
             let mut rx_buffer = [0; 4096];
-            let n = socket.read(&mut rx_buffer).await.unwrap_or(0);
+            let (n, ep) = socket.recv_from(&mut rx_buffer).await.unwrap();
             if n > 0 {
                 lcd.clear();
                 lcd.home();