add Rust PWM support

Author: dragonlock2

clients/jabi-rs/src/lib.rs

@@ -6,6 +6,7 @@ mod peripherals {
     pub mod gpio;
     pub mod i2c;
     pub mod metadata;
+    pub mod pwm;
 }
 
 pub use crate::device::Device;

clients/jabi-rs/src/peripherals/pwm.rs

@@ -0,0 +1,47 @@
+use crate::interfaces::InterfaceRequest;
+use crate::Error;
+use deku::{DekuContainerWrite, DekuUpdate, DekuWrite};
+
+enum Func {
+    Write = 0,
+}
+
+fn gen_req(f: Func, idx: usize, payload: Vec<u8>) -> Result<InterfaceRequest, Error> {
+    let mut r = InterfaceRequest {
+        periph_id: crate::InstID::PWM as u16,
+        periph_idx: idx as u16,
+        periph_fn: f as u16,
+        payload_len: 0,
+        payload: payload,
+    };
+    r.update().map_or(Err(Error::PacketFormat), |_| Ok(r))
+}
+
+impl crate::Device {
+    pub fn pwm_write(
+        &self,
+        idx: usize,
+        pulsewidth: std::time::Duration,
+        period: std::time::Duration,
+    ) -> Result<(), Error> {
+        if pulsewidth.as_nanos() > u32::MAX.into() || period.as_nanos() > u32::MAX.into() {
+            return Err(Error::InvalidArgs);
+        }
+        #[derive(DekuWrite)]
+        #[deku(endian = "little")]
+        struct WriteRequest {
+            pulsewidth: u32, // ns
+            period: u32,
+        }
+        let req = WriteRequest {
+            pulsewidth: pulsewidth.as_nanos() as u32,
+            period: period.as_nanos() as u32,
+        };
+        let resp = self.send(&gen_req(Func::Write, idx, req.to_bytes().unwrap())?)?;
+        if resp.len() == 0 {
+            Ok(())
+        } else {
+            Err(Error::PacketFormat)
+        }
+    }
+}

examples/jabi-rs/src/main.rs

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 fn test_device(d: &jabi::Device) -> Result<(), jabi::Error> {
     // Metadata
     println!(
@@ -21,7 +23,7 @@ fn test_device(d: &jabi::Device) -> Result<(), jabi::Error> {
         d.can_write(i, &jabi::CANMessage::new_rtr(0x69420, 2, true))?;
         println!("\tSent some messages");
 
-        std::thread::sleep(std::time::Duration::from_millis(500));
+        std::thread::sleep(Duration::from_millis(500));
         println!("\tPrinting received messages");
         while let Some(msg) = d.can_read(i)? {
             println!("\t{msg}");
@@ -41,21 +43,32 @@ fn test_device(d: &jabi::Device) -> Result<(), jabi::Error> {
     }
     println!();
 
+    // PWM (GPIO overrides it until reset)
+    for i in 0..d.num_inst(jabi::InstID::PWM)? {
+        println!("\tFlashing PWM {i} at 1Hz");
+        d.pwm_write(i, Duration::from_millis(500), Duration::from_millis(1000))?;
+        std::thread::sleep(Duration::from_millis(100));
+    }
+    if d.num_inst(jabi::InstID::PWM)? > 0 {
+        std::thread::sleep(Duration::from_secs(3));
+    }
+
     // GPIO
     for i in 0..d.num_inst(jabi::InstID::GPIO)? {
         println!("\tFlashing GPIO {i}");
         d.gpio_set_mode(i, jabi::GPIODir::Output, jabi::GPIOPull::None, false)?;
         for _ in 0..6 {
             d.gpio_write(i, false)?;
-            std::thread::sleep(std::time::Duration::from_millis(25));
+            std::thread::sleep(Duration::from_millis(25));
             d.gpio_write(i, true)?;
-            std::thread::sleep(std::time::Duration::from_millis(25));
+            std::thread::sleep(Duration::from_millis(25));
         }
     }
     for i in 0..d.num_inst(jabi::InstID::GPIO)? {
         d.gpio_set_mode(i, jabi::GPIODir::Input, jabi::GPIOPull::Up, false)?;
         println!("\tRead GPIO {i} w/ pullups: {}", d.gpio_read(i)?);
     }
+    println!();
 
     Ok(())
 }