update to latest e-h 1.0.0-rc.1

Cargo.toml

@@ -9,12 +9,12 @@ license = "MPL-2.0"
 edition = "2018"
 
 [features]
-util = [ "structopt", "simplelog", "rand", "hex" ]
+util = [ "clap", "simplelog", "rand", "hex" ]
 examples = []
 default = [ "util" ]
 
 [dependencies]
-embedded-hal = { version = "1.0.0-alpha.7" }
+embedded-hal = { version = "1.0.0-rc.1" }
 
 libc = "0.2.66"
 log = "0.4.8"
@@ -24,22 +24,10 @@ lazy_static = "1.4.0"
 failure = "0.1.7"
 rusb = "0.9.0"
 
-
-[dependencies.structopt]
-version = "0.3.5"
-optional = true
-
-[dependencies.simplelog]
-version = "0.9.0"
-optional = true
-
-[dependencies.hex] 
-version = "0.4.2"
-optional = true
-
-[dependencies.rand] 
-version = "0.8.0"
-optional = true
+clap = { version = "4.4.7", optional = true, features = [ "derive", "env" ] }
+simplelog = { version = "0.9.0", optional = true }
+hex = { version = "0.4.2", optional = true }
+rand = { version = "0.8.0", optional = true }
 
 [dev-dependencies]
 ssd1306 = "0.7.0"

src/cli.rs

@@ -3,8 +3,8 @@
 //! 
 //! Copyright 2019 Ryan Kurte
 
-extern crate structopt;
-use structopt::StructOpt;
+extern crate clap;
+use clap::Parser;
 
 #[macro_use] extern crate log;
 extern crate simplelog;
@@ -13,106 +13,106 @@ use simplelog::{TermLogger, LevelFilter, TerminalMode};
 use driver_cp2130::prelude::*;
 
 extern crate embedded_hal;
-use embedded_hal::spi::blocking::*;
+use embedded_hal::spi::*;
 
 extern crate hex;
 extern crate rand;
 use crate::rand::Rng;
 
 
-#[derive(Debug, StructOpt)]
-#[structopt(name = "cp2130-util")]
+#[derive(Debug, Parser)]
+#[clap(name = "cp2130-util")]
 /// CP2130 Utility
 pub struct Options {
 
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     pub command: Command,
 
-    #[structopt(flatten)]
+    #[clap(flatten)]
     pub filter: Filter,
 
-    #[structopt(flatten)]
+    #[clap(flatten)]
     pub options: UsbOptions,
 
-    #[structopt(long, default_value="0")]
+    #[clap(long, default_value="0")]
     /// Device index (to select from multiple devices)
     pub index: usize,
 
-    #[structopt(long = "log-level", default_value="info")]
+    #[clap(long = "log-level", default_value="info")]
     /// Enable verbose logging
     pub level: LevelFilter,
 }
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub enum Command {
     /// Fetch the chip version
     Version,
     /// Fetch chip info
     Info,
     /// Set a GPIO output
     SetOutput {
-        #[structopt(long, default_value="6")]
+        #[clap(long, default_value="6")]
         /// GPIO pin index
         pin: u8,
 
-        #[structopt(long, default_value="push-pull")]
+        #[clap(long, default_value="push-pull")]
         /// GPIO pin mode to set (input, open drain, push-pull)
         mode: GpioMode,
 
-        #[structopt(default_value="high")]
+        #[clap(default_value="high")]
         /// GPIO pin state (high, low)
         state: GpioLevel,
     },
     /// Read a GPIO input
     ReadInput {
-        #[structopt(long, default_value="6")]
+        #[clap(long, default_value="6")]
         /// GPIO pin index
         pin: u8,
 
-        #[structopt(long)]
+        #[clap(long)]
         /// GPIO pin mode to set
         mode: Option<GpioMode>,
     },
     /// Transfer (write-read) to an attached SPI device
     SpiTransfer {
-        #[structopt(parse(try_from_str=parse_hex_str))]
+        #[clap(value_parser=parse_hex_str)]
         /// Data to write (in hex)
         data: Data,
 
-        #[structopt(flatten)]
+        #[clap(flatten)]
         spi_opts: SpiOpts,
     },
     /// Write to an attached SPI device
     SpiWrite {
-        #[structopt(parse(try_from_str=parse_hex_str))]
+        #[clap(value_parser=parse_hex_str)]
         /// Data to write (in hex)
         data: Data,
 
-        #[structopt(flatten)]
+        #[clap(flatten)]
         spi_opts: SpiOpts,
     },
     /// Test interaction with the CP2130 device
     Test(TestOpts)
 }
 
-#[derive(Clone, Debug, PartialEq, StructOpt)]
+#[derive(Clone, Debug, PartialEq, Parser)]
 pub struct SpiOpts {
-    #[structopt(long, default_value="0")]
+    #[clap(long, default_value="0")]
     /// SPI Channel
     channel: u8,
 
-    #[structopt(long, default_value="0")]
+    #[clap(long, default_value="0")]
     /// SPI CS gpio index
     cs_pin: u8,
 }
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct TestOpts {
-    #[structopt(long, default_value="0")]
+    #[clap(long, default_value="0")]
     /// Pin for GPIO write
     write_pin: u8,
 
-    #[structopt(long, default_value="1")]
+    #[clap(long, default_value="1")]
     /// Pin for GPIO read
     read_pin: u8,
 }
@@ -125,7 +125,7 @@ fn parse_hex_str(src: &str) -> Result<Vec<u8>, hex::FromHexError> {
 
 
 fn main() {
-    let opts = Options::from_args();
+    let opts = Options::parse();
 
     // Setup logging
     TermLogger::init(opts.level, simplelog::Config::default(), TerminalMode::Mixed).unwrap();
@@ -166,7 +166,7 @@ fn main() {
 
             let mut buff = data.clone();
 
-            spi.transfer_inplace(&mut buff).unwrap();
+            spi.transfer_in_place(&mut buff).unwrap();
 
             cp2130.set_gpio_mode_level(spi_opts.cs_pin, GpioMode::PushPull, GpioLevel::High).unwrap();
 

src/device.rs

@@ -171,13 +171,13 @@ struct Endpoint {
 
 /// Options for creating a device instance
 #[derive(Debug, PartialEq, Clone)]
-#[cfg_attr(feature = "structopt", derive(structopt::StructOpt))]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
 pub struct UsbOptions {
-    #[cfg_attr(feature = "structopt", structopt(long))]
+    #[cfg_attr(feature = "clap", clap(long))]
     /// Detach kernel driver if required
     pub detach_kernel_driver: bool,
 
-    #[cfg_attr(feature = "structopt", structopt(long))]
+    #[cfg_attr(feature = "clap", clap(long))]
     /// Attempt to claim interface
     pub claim_interface: bool,
 }

src/lib.rs

@@ -3,7 +3,7 @@
 //! 
 //! Copyright 2019 Ryan Kurte
 
-use std::sync::{Arc, Mutex};
+use std::{sync::{Arc, Mutex}, time::{Instant, Duration}};
 
 #[macro_use]
 extern crate log;
@@ -145,7 +145,7 @@ impl Cp2130 {
 }
 
 /// Underlying device functions
-impl  Device for Cp2130 {
+impl Device for Cp2130 {
     fn spi_read(&self, buff: &mut [u8]) -> Result<usize, Error> {
         let mut inner = self.inner.lock().unwrap();
         inner.spi_read(buff)
@@ -189,61 +189,51 @@ pub struct Spi {
     inner: Arc<Mutex<Inner>>,
 }
 
+use embedded_hal::spi::Operation as SpiOp;
 
-impl embedded_hal::spi::blocking::Transfer<u8> for Spi {
+impl embedded_hal::spi::SpiDevice<u8> for Spi {
+
+    fn transaction(&mut self, operations: &mut [SpiOp<'_, u8>]) -> Result<(), Self::Error> {
+        for o in operations {
+            match o {
+                SpiOp::Write(w) => self.write(w)?,
+                SpiOp::Transfer(r, w) => self.transfer(r, w)?,
+                SpiOp::TransferInPlace(b) => self.transfer_in_place(b)?,
+                SpiOp::Read(r) => self.read(r)?,
+                SpiOp::DelayUs(us) => {
+                    let now = Instant::now();
+                    while now.elapsed() < Duration::from_micros(*us as u64) {}
+                }
+            }
+        }
 
-    fn transfer<'w>(&mut self, buff: &'w mut [u8], out: &'w [u8]) -> Result<(), Self::Error> {
-        let _n = self.inner.lock().unwrap().spi_write_read(&out, buff)?;
         Ok(())
     }
-}
-
-impl embedded_hal::spi::blocking::TransferInplace<u8> for Spi {
-
-    fn transfer_inplace<'w>(&mut self, buff: &'w mut [u8]) -> Result<(), Self::Error> {
-        let out = buff.to_vec();
+
+    fn read(&mut self, buff: &mut [u8] ) -> Result<(), Self::Error> {
+        let out = vec![0u8; buff.len()];
         let _n = self.inner.lock().unwrap().spi_write_read(&out, buff)?;
         Ok(())
     }
-}
-
-
-impl embedded_hal::spi::blocking::Write<u8> for Spi {
 
     fn write(&mut self, words: &[u8] ) -> Result<(), Self::Error> {
         let _n = self.inner.lock().unwrap().spi_write(words)?;
         Ok(())
     }
-}
 
-impl embedded_hal::spi::blocking::Read<u8> for Spi {
-
-    fn read(&mut self, buff: &mut [u8] ) -> Result<(), Self::Error> {
-        let out = vec![0u8; buff.len()];
+    fn transfer<'w>(&mut self, buff: &'w mut [u8], out: &'w [u8]) -> Result<(), Self::Error> {
         let _n = self.inner.lock().unwrap().spi_write_read(&out, buff)?;
         Ok(())
     }
-}
-
-use embedded_hal::spi::blocking::{Operation, Read as _, Write as _, Transfer as _, TransferInplace};
-
-/// Default impl for transactional SPI
-impl embedded_hal::spi::blocking::Transactional<u8> for Spi {
-
-    fn exec<'a>(&mut self, operations: &mut [Operation<'a, u8>]) -> Result<(), Self::Error> {
-        for o in operations {
-            match o {
-                Operation::Write(w) => self.write(w)?,
-                Operation::Transfer(r, w) => self.transfer(r, w)?,
-                Operation::TransferInplace(b) => self.transfer_inplace(b)?,
-                Operation::Read(r) => self.read(r)?,
-            }
-        }
 
+    fn transfer_in_place<'w>(&mut self, buff: &'w mut [u8]) -> Result<(), Self::Error> {
+        let out = buff.to_vec();
+        let _n = self.inner.lock().unwrap().spi_write_read(&out, buff)?;
         Ok(())
     }
 }
 
+
 impl embedded_hal::spi::ErrorType for Spi {
     type Error = Error;
 }
@@ -259,7 +249,7 @@ pub struct InputPin {
     inner: Arc<Mutex<Inner>>,
 }
 
-impl  embedded_hal::digital::blocking::InputPin for InputPin {
+impl  embedded_hal::digital::InputPin for InputPin {
     fn is_high(&self) -> Result<bool, Self::Error> {
         self.inner.lock().unwrap().get_gpio_level(self.index)
     }
@@ -274,14 +264,20 @@ impl embedded_hal::digital::ErrorType for InputPin {
     type Error = Error;
 }
 
+impl embedded_hal::digital::Error for Error {
+    fn kind(&self) -> embedded_hal::digital::ErrorKind {
+        embedded_hal::digital::ErrorKind::Other
+    }
+}
+
 /// OutputPin object implements embedded-hal OutputPin traits for the CP2130
 pub struct OutputPin {
     index: u8,
     mode: GpioMode,
     inner: Arc<Mutex<Inner>>,
 }
 
-impl  embedded_hal::digital::blocking::OutputPin for OutputPin {
+impl embedded_hal::digital::OutputPin for OutputPin {
     fn set_high(&mut self) -> Result<(), Self::Error> {
         self.inner.lock().unwrap().set_gpio_mode_level(self.index, self.mode, GpioLevel::High)
     }

src/manager.rs

@@ -5,13 +5,13 @@
 
 pub use rusb::{Device as UsbDevice, UsbContext as _, Context as UsbContext, DeviceList, DeviceDescriptor};
 
-#[cfg(feature = "structopt")]
+#[cfg(feature = "clap")]
 use std::num::ParseIntError;
 
-#[cfg(feature = "structopt")]
-use structopt::StructOpt;
+#[cfg(feature = "clap")]
+use clap::Parser;
 
-use crate::{Error};
+use crate::Error;
 use crate::device::{VID, PID};
 
 lazy_static!{
@@ -28,18 +28,18 @@ pub struct Manager {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "structopt", derive(StructOpt))]
+#[cfg_attr(feature = "clap", derive(Parser))]
 pub struct Filter {
-    #[cfg_attr(feature = "structopt", structopt(long, default_value="10c4", parse(try_from_str=parse_hex)))]
+    #[cfg_attr(feature = "clap", clap(long, default_value="10c4", value_parser=parse_hex))]
     /// Device Vendor ID (VID) in hex
     pub vid: u16,
 
-    #[cfg_attr(feature = "structopt", structopt(long, default_value="87a0", parse(try_from_str=parse_hex)))]
+    #[cfg_attr(feature = "clap", clap(long, default_value="87a0", value_parser=parse_hex))]
     /// Device Product ID (PID) in hex
     pub pid: u16,
 }
 
-#[cfg(feature = "structopt")]
+#[cfg(feature = "clap")]
 fn parse_hex(src: &str) -> Result<u16, ParseIntError> {
     u16::from_str_radix(src, 16)
 }