read/write registers

src/lib.rs

@@ -1,18 +1,43 @@
 use embassy_embedded_hal::adapter::BlockingAsync;
-use embedded_hal_async::spi::SpiBus;
+use embedded_hal_async::spi::{SpiBus, SpiDevice};
 
 pub struct ADIS16475<T> where T: SpiBus {
-    bus: BlockingAsync<T>,
+    bus: T,
 }
 
 impl<T: SpiBus> ADIS16475<T> {
     pub fn new(bus: T) -> Self {
-        let bus = BlockingAsync::new(bus);
+        //let bus = BlockingAsync::new(bus);
         Self { bus }
     }
 
-    async fn read_word(&self, addr: u8) {
+    async fn read_u16(&mut self, addr: u8) -> Result<u16, T::Error> {
-        let mut dat = [0;4];
+        let request = [addr & 0x7F, 0];
-        self.bus.read(&mut dat).await;
+        self.bus.write(&request).await?;
+        let mut dat = [0;2];
+        self.bus.read(&mut dat).await?;
+
+        Ok(u16::from_be_bytes(dat))
+    }
+
+    async fn write_u8(&mut self, addr: u8, data: u8) -> Result<(), T::Error> {
+        let request = [addr | 0x80, data];
+        self.bus.write(&request).await?;
+
+        Ok(())
+    }
+
+    async fn read_u32(&mut self, addr: u8) -> Result<u32, T::Error> {
+        let low = self.read_u16(addr).await? as u32;
+        let high = self.read_u16(addr+2).await? as u32;
+        Ok(high << 16 + low)
+    }
+
+    async fn write_u16(&mut self, addr: u8, data: u16) -> Result<(), T::Error> {
+        let data = u16::to_le_bytes(data);
+        // TODO: do some soul searching
+        self.write_u8(addr, data[0]).await?; // lower byte
+        self.write_u8(addr+1, data[1]).await?; // higher byte
+        Ok(())
     }
 }