Added node comms

node/Cargo.toml

@@ -7,6 +7,11 @@ repository.workspace = true
 readme.workspace = true
 license.workspace = true
 
+[features]
+comms = []
+usb = ["embassy-usb"]
+stm32 = ["embassy-stm32", "physical/stm32"]
+
 [dependencies.physical]
 path = ".."
 [dependencies.embedded-hal]
@@ -17,3 +22,9 @@ workspace = true
 workspace = true
 [dependencies.uom]
 workspace = true
+[dependencies.embassy-stm32]
+workspace = true
+optional = true
+[dependencies.embassy-usb]
+workspace = true
+optional = true

node/src/comms.rs

@@ -0,0 +1,17 @@
+pub trait Sender {
+    async fn send(&mut self, msg: &[u8]) -> Result<(), Reset>;
+}
+
+pub trait Receiver {
+    async fn receive(&mut self, buffer: &mut [u8]) -> Result<(), Reset>;
+}
+
+//TODO: Replace with !
+pub struct Never;
+
+/// Communication errors indicates either:
+/// Our connection was already disconnected, in which case we should reset and wait for new connection to made.
+/// or
+/// There was an unexpected, irrecoverable error in communication, in which case we don't want to enter a terminal error
+/// safe mode, because there is no indication the actual control is broken, so all we can really do is reset the connection.
+pub struct Reset;

node/src/lib.rs

@@ -1,3 +1,8 @@
 #![no_std]
 
+#[cfg(feature = "comms")]
+pub mod comms;
+#[cfg(feature = "stm32")]
+pub mod stm32;
+
 pub use physical::CriticalError;

node/src/stm32/mod.rs

@@ -0,0 +1,2 @@
+#[cfg(feature = "usb")]
+pub mod usb;

node/src/stm32/usb.rs

@@ -0,0 +1,25 @@
+use crate::comms;
+use embassy_stm32::peripherals::USB_OTG_FS;
+use embassy_stm32::usb_otg::{Driver, Endpoint, In, Out};
+use embassy_usb::driver::{EndpointIn, EndpointOut};
+use embassy_usb::UsbDevice;
+
+pub type TypedUSB = UsbDevice<'static, Driver<'static, USB_OTG_FS>>;
+pub type TypedInterIn = Endpoint<'static, USB_OTG_FS, In>;
+pub type TypedInterOut = Endpoint<'static, USB_OTG_FS, Out>;
+
+impl comms::Sender for TypedInterIn {
+    async fn send(&mut self, msg: &[u8]) -> Result<(), comms::Reset> {
+        self.write(msg).await.map_err(|_| comms::Reset)
+    }
+}
+
+impl comms::Receiver for TypedInterOut {
+    async fn receive(&mut self, buffer: &mut [u8]) -> Result<(), comms::Reset> {
+        // This should be OK because all our messages are smaller than a single packet.
+        self.read(buffer)
+            .await
+            .map(|_| ())
+            .map_err(|_| comms::Reset)
+    }
+}