Initial commit, copied examples from postcard-rpc repo.

src/client.rs

@@ -0,0 +1,130 @@
+use postcard_rpc::{
+    header::VarSeqKind,
+    host_client::{HostClient, HostErr},
+    standard_icd::{PingEndpoint, WireError, ERROR_PATH},
+};
+use std::convert::Infallible;
+use bioz_icd::{
+    AccelRange, BadPositionError, GetUniqueIdEndpoint, Rgb8, SetAllLedEndpoint,
+    SetSingleLedEndpoint, SingleLed, StartAccel, StartAccelerationEndpoint,
+    StopAccelerationEndpoint,
+};
+
+#[derive(Debug)]
+pub struct WorkbookClient {
+    pub client: HostClient<WireError>,
+}
+
+#[derive(Debug)]
+pub enum WorkbookError<E> {
+    Comms(HostErr<WireError>),
+    Endpoint(E),
+}
+
+impl<E> From<HostErr<WireError>> for WorkbookError<E> {
+    fn from(value: HostErr<WireError>) -> Self {
+        Self::Comms(value)
+    }
+}
+
+trait FlattenErr {
+    type Good;
+    type Bad;
+    fn flatten(self) -> Result<Self::Good, WorkbookError<Self::Bad>>;
+}
+
+impl<T, E> FlattenErr for Result<T, E> {
+    type Good = T;
+    type Bad = E;
+    fn flatten(self) -> Result<Self::Good, WorkbookError<Self::Bad>> {
+        self.map_err(WorkbookError::Endpoint)
+    }
+}
+
+// ---
+
+impl WorkbookClient {
+    pub fn new() -> Self {
+        let client = HostClient::new_raw_nusb(
+            |d| d.product_string() == Some("bioz-amplifier"),
+            ERROR_PATH,
+            8,
+            VarSeqKind::Seq2,
+        );
+        Self { client }
+    }
+
+    pub fn new_serial(port: &str) -> Self {
+        let client = HostClient::new_serial_cobs(port, ERROR_PATH, 8, 9600, VarSeqKind::Seq2);
+        Self { client }
+    }
+
+    pub async fn wait_closed(&self) {
+        self.client.wait_closed().await;
+    }
+
+    pub async fn ping(&self, id: u32) -> Result<u32, WorkbookError<Infallible>> {
+        let val = self.client.send_resp::<PingEndpoint>(&id).await?;
+        Ok(val)
+    }
+
+    pub async fn get_id(&self) -> Result<u64, WorkbookError<Infallible>> {
+        let id = self.client.send_resp::<GetUniqueIdEndpoint>(&()).await?;
+        Ok(id)
+    }
+
+    pub async fn set_rgb_single(
+        &self,
+        position: u32,
+        r: u8,
+        g: u8,
+        b: u8,
+    ) -> Result<(), WorkbookError<BadPositionError>> {
+        self.client
+            .send_resp::<SetSingleLedEndpoint>(&SingleLed {
+                position,
+                rgb: Rgb8 { r, g, b },
+            })
+            .await?
+            .flatten()
+    }
+
+    pub async fn set_all_rgb_single(
+        &self,
+        r: u8,
+        g: u8,
+        b: u8,
+    ) -> Result<(), WorkbookError<Infallible>> {
+        self.client
+            .send_resp::<SetAllLedEndpoint>(&[Rgb8 { r, g, b }; 24])
+            .await?;
+        Ok(())
+    }
+
+    pub async fn start_accelerometer(
+        &self,
+        interval_ms: u32,
+        range: AccelRange,
+    ) -> Result<(), WorkbookError<Infallible>> {
+        self.client
+            .send_resp::<StartAccelerationEndpoint>(&StartAccel { interval_ms, range })
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn stop_accelerometer(&self) -> Result<bool, WorkbookError<Infallible>> {
+        let res = self
+            .client
+            .send_resp::<StopAccelerationEndpoint>(&())
+            .await?;
+
+        Ok(res)
+    }
+}
+
+impl Default for WorkbookClient {
+    fn default() -> Self {
+        Self::new()
+    }
+}