added get_fuel_level() obdii command

Cargo.toml

@@ -8,11 +8,6 @@ edition = "2021"
 
 [dependencies]
 env_logger = "0.10"
+ftdi = "0.1.3"
 log = "0.4.8"
 thiserror = "1.0.15"
-ftdi = { version = "0.1.3", optional = true }
-serialport= { version = "=4.6.1", optional = true }
-
-[features]
-ftdi_comm = [ "dep:ftdi" ]
-serialport_comm = [ "dep:serialport" ]

README.md

@@ -9,20 +9,13 @@ vehicle.
 ## Usage
 
 ```rs
-use obd2::{commands::Obd2DataRetrieval, device::{Elm327, FTDIDevice}, Obd2};
+use obd2::{commands::Obd2DataRetrieval, device::Elm327, Obd2};
 
 fn main() -> Result<(), obd2::Error> {
-    let mut device = Obd2::<Elm327::<FTDIDevice>>::new(Elm327::new(FTDIDevice::new()?)?)?;
+    let mut device = Obd2::<Elm327>::default();
     println!("VIN: {}", device.get_vin()?);
     Ok(())
 }
 ```
 
-alternatively, you could use a serial port provided by your operating system such as 
-/dev/ttyUSB0 on unix-like systems
-
-```rs
-let mut device = Obd2::<Elm327::<SerialPort>>::new(Elm327::new(SerialPort::new("/dev/ttyUSB0")?)?)?;
-```
-
 See the docs for more: https://docs.rs/obd2/

examples/basic/main.rs

@@ -2,16 +2,15 @@ use obd2::commands::Obd2DataRetrieval;
 
 use std::time;
 
-fn main() -> Result<(), obd2::Error> {
+fn main() {
     env_logger::init();
-    let mut device: obd2::Obd2<obd2::device::Elm327<obd2::device::FTDIDevice>> =
+    let mut device: obd2::Obd2<obd2::device::Elm327> = obd2::Obd2::default();
-        obd2::Obd2::new(obd2::device::Elm327::new(obd2::device::FTDIDevice::new()?)?)?;
 
     println!("VIN: {:?}", device.get_vin());
-    for s in device.get_service_1_pid_support_1()?.iter() {
+    for s in device.get_service_1_pid_support_1().unwrap().iter() {
         println!("PID support ($01-$20): {:08X}", s);
     }
-    for s in device.get_service_1_pid_support_2()?.iter() {
+    for s in device.get_service_1_pid_support_2().unwrap().iter() {
         println!("PID support ($21-$40): {:08X}", s);
     }
 
@@ -48,6 +47,4 @@ fn main() -> Result<(), obd2::Error> {
             device.get_throttle_position()
         );
     }
-
-    Ok(())
 }

src/commands/mod.rs

@@ -220,4 +220,7 @@ func! {
 
     /// Get service 1 PID support for $21 to $40
     fn get_service_1_pid_support_2(0x01, 0x20) -> u32;
+
+    // Get the fuel level (out of 255)
+    fn get_fuel_level(0x01, 0x2F) -> u8;
 }

src/device/elm327.rs

@@ -1,24 +1,38 @@
 use log::{debug, info, trace};
-use std::{collections::VecDeque, thread, time};
+use std::{
+    collections::VecDeque,
+    io::{Read, Write},
+    thread, time,
+};
 
-use super::{serial_comm::SerialComm, Error, Obd2BaseDevice, Obd2Reader, Result};
+use super::{Error, Obd2BaseDevice, Obd2Reader, Result};
 
 /// An ELM327 OBD-II adapter
 ///
-/// It communicates with the computer or UART using an FTDI FT232R USB-to-UART converter.
+/// It communicates with the computer over UART using an FTDI FT232R USB-to-UART converter.
 /// Commands to the device itself are indicated by sending "AT" followed by the command, while
 /// plain strings of hex data indicate OBD-II requests to be sent to the vehicle. The responses of
 /// the vehicle are echoed back as hex characters. Capitalization and spaces are always ignored.
 ///
 /// [Datasheet for v1.4b](https://github.com/rsammelson/obd2/blob/master/docs/ELM327DSH.pdf), and
 /// the [source](https://www.elmelectronics.com/products/dsheets/).
-pub struct Elm327<T: SerialComm> {
+pub struct Elm327 {
-    device: T,
+    device: ftdi::Device,
     buffer: VecDeque<u8>,
     baud_rate: u32,
 }
 
-impl<T: SerialComm> Obd2BaseDevice for Elm327<T> {
+impl Default for Elm327 {
+    /// Create a Elm327 device
+    ///
+    /// # Panics
+    /// If the device cannot be initialized. Use [Self::new] for a panic-free API.
+    fn default() -> Self {
+        Elm327::new().unwrap()
+    }
+}
+
+impl Obd2BaseDevice for Elm327 {
     fn reset(&mut self) -> Result<()> {
         self.flush_buffers()?;
         self.reset_ic()?;
@@ -38,7 +52,7 @@ impl<T: SerialComm> Obd2BaseDevice for Elm327<T> {
     }
 }
 
-impl<T: SerialComm> Obd2Reader for Elm327<T> {
+impl Obd2Reader for Elm327 {
     fn get_line(&mut self) -> Result<Option<Vec<u8>>> {
         self.get_until(b'\n', false)
     }
@@ -54,14 +68,22 @@ impl<T: SerialComm> Obd2Reader for Elm327<T> {
     }
 }
 
-impl<T: SerialComm> Elm327<T> {
+impl Elm327 {
-    /// Creates a new Elm327 adapter with the given
+    fn new() -> Result<Self> {
-    /// unserlying Serial Communication device
+        let mut ftdi_device = ftdi::find_by_vid_pid(0x0403, 0x6001)
-    pub fn new(serial_device: T) -> Result<Self> {
+            .interface(ftdi::Interface::A)
+            .open()?;
+
+        ftdi_device.set_baud_rate(38400)?;
+        ftdi_device.configure(ftdi::Bits::Eight, ftdi::StopBits::One, ftdi::Parity::None)?;
+        // device.set_latency_timer(2).unwrap();
+
+        ftdi_device.usb_reset()?;
+
         let mut device = Elm327 {
-            device: serial_device,
+            device: ftdi_device,
             buffer: VecDeque::new(),
-            baud_rate: 38_400,
+            baud_rate: 38400,
         };
 
         device.connect(false)?;
@@ -80,7 +102,7 @@ impl<T: SerialComm> Elm327<T> {
     }
 
     fn flush_buffers(&mut self) -> Result<()> {
-        self.device.purge_buffers()?;
+        self.device.usb_purge_buffers()?;
         Ok(())
     }
 
@@ -105,10 +127,11 @@ impl<T: SerialComm> Elm327<T> {
     fn reset_ic(&mut self) -> Result<()> {
         info!("Performing IC reset");
         self.send_serial_str("ATZ")?;
-        let response = self.get_response()?;
         debug!(
             "reset_ic: got response {:?}",
-            response.as_ref().map(|l| std::str::from_utf8(l.as_slice()))
+            self.get_response()?
+                .as_ref()
+                .map(|l| std::str::from_utf8(l.as_slice()))
         );
         Ok(())
     }
@@ -117,12 +140,16 @@ impl<T: SerialComm> Elm327<T> {
         info!("Performing protocol reset");
 
         // set to use automatic protocol selection
-        let elm_response = self.serial_cmd("ATSP0")?;
+        debug!(
-        debug!("reset_protocol: got response {:?}", elm_response);
+            "reset_protocol: got response {:?}",
+            self.serial_cmd("ATSP0")?
+        );
 
-        // perform the search for ECUs
+        // perform the search
-        let obd_response = self.cmd(&[0x01, 0x00])?;
+        debug!(
-        debug!("reset_protocol: got OBD response {:?}", obd_response);
+            "reset_protocol: got OBD response {:?}",
+            self.cmd(&[0x01, 0x00])?
+        );
 
         // get rid of extra data hanging around in the buffer
         self.flush_buffers()?;
@@ -242,18 +269,13 @@ impl<T: SerialComm> Elm327<T> {
     fn read_into_queue(&mut self) -> Result<()> {
         let mut buf = [0u8; 16];
         loop {
-            let len_res = self.device.read(&mut buf);
+            let len = self.device.read(&mut buf)?;
-            if let Ok(len) = len_res {
+            if len > 0 {
-                if len > 0 {
+                self.buffer.extend(&buf[0..len]);
-                    self.buffer.extend(&buf[0..len]);
+                trace!(
-                    trace!(
+                    "read_into_queue: values {:?}",
-                        "read_into_queue: values {:?}",
+                    std::str::from_utf8(&buf[0..len])
-                        std::str::from_utf8(&buf[0..len])
+                );
-                    );
-                } else {
-                    trace!("read_into_queue: no values left to read");
-                    break;
-                }
             } else {
                 trace!("read_into_queue: no values left to read");
                 break;

src/device/ftdi_comm.rs

@@ -1,42 +0,0 @@
-use super::serial_comm::{SerialComm, DEFAULT_BAUD_RATE};
-use super::Result;
-use std::io::{Read, Write};
-
-/// Communicate with a USB to Serial FTDI device
-/// with the FTDI library
-pub struct FTDIDevice {
-    device: ftdi::Device,
-}
-
-impl FTDIDevice {
-    /// Creates a new instance of an FTDIDevice
-    pub fn new() -> Result<Self> {
-        let mut device = ftdi::find_by_vid_pid(0x0404, 0x6001)
-            .interface(ftdi::Interface::A)
-            .open()?;
-
-        device.set_baud_rate(DEFAULT_BAUD_RATE)?;
-        device.configure(ftdi::Bits::Eight, ftdi::StopBits::One, ftdi::Parity::None)?;
-        device.usb_reset()?;
-
-        Ok(Self { device })
-    }
-}
-
-impl SerialComm for FTDIDevice {
-    fn write_all(&mut self, data: &[u8]) -> Result<()> {
-        Ok(self.device.write_all(data)?)
-    }
-
-    fn read(&mut self, data: &mut [u8]) -> Result<usize> {
-        Ok(self.device.read(data)?)
-    }
-
-    fn set_baud_rate(&mut self, baud_rate: u32) -> Result<()> {
-        Ok(self.device.set_baud_rate(baud_rate)?)
-    }
-
-    fn purge_buffers(&mut self) -> Result<()> {
-        Ok(self.device.usb_purge_buffers()?)
-    }
-}

src/device/mod.rs

@@ -3,18 +3,6 @@
 mod elm327;
 pub use elm327::Elm327;
 
-mod serial_comm;
-
-#[cfg(feature = "ftdi_comm")]
-mod ftdi_comm;
-#[cfg(feature = "ftdi_comm")]
-pub use ftdi_comm::FTDIDevice;
-
-#[cfg(feature = "serialport_comm")]
-mod serialport_comm;
-#[cfg(feature = "serialport_comm")]
-pub use serialport_comm::SerialPort;
-
 type Result<T> = std::result::Result<T, Error>;
 
 /// A lower-level API for using an OBD-II device
@@ -63,15 +51,9 @@ pub trait Obd2Reader {
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     /// An error with the underlying [FTDI device](ftdi::Device)
-    #[cfg(feature = "ftdi_comm")]
     #[error("FTDI error: `{0:?}`")]
     Ftdi(ftdi::Error),
 
-    /// An error with the underlying [serialport device](serialport::SerialPort)
-    #[cfg(feature = "serialport_comm")]
-    #[error("Serialport error: `{0:?}`")]
-    Serialport(serialport::Error),
-
     /// An I/O error in a low-level [std::io] stream operation
     #[error("IO error: `{0:?}`")]
     IO(std::io::Error),
@@ -81,20 +63,12 @@ pub enum Error {
     Communication(String),
 }
 
-#[cfg(feature = "ftdi_comm")]
 impl From<ftdi::Error> for Error {
     fn from(e: ftdi::Error) -> Self {
         Error::Ftdi(e)
     }
 }
 
-#[cfg(feature = "serialport_comm")]
-impl From<serialport::Error> for Error {
-    fn from(e: serialport::Error) -> Self {
-        Error::Serialport(e)
-    }
-}
-
 impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
         Error::IO(e)

src/device/serial_comm.rs

@@ -1,11 +0,0 @@
-use super::Result;
-
-pub const DEFAULT_BAUD_RATE: u32 = 38_400;
-
-/// An API to communicate with a serial device
-pub trait SerialComm {
-    fn write_all(&mut self, data: &[u8]) -> Result<()>;
-    fn read(&mut self, data: &mut [u8]) -> Result<usize>;
-    fn set_baud_rate(&mut self, baud_rate: u32) -> Result<()>;
-    fn purge_buffers(&mut self) -> Result<()>;
-}

src/device/serialport_comm.rs

@@ -1,46 +0,0 @@
-use super::serial_comm::{SerialComm, DEFAULT_BAUD_RATE};
-use super::Result;
-use std::io::{Read, Write};
-use std::time::Duration;
-
-/// Communicate with a serial device using the
-/// serialport library
-///
-/// /dev/tty* or similar on unix-like systems
-/// COM devices on Windows systems
-pub struct SerialPort {
-    device: Box<dyn serialport::SerialPort>,
-}
-
-impl SerialPort {
-    /// Creates a new instance of a SerialPort
-    pub fn new(path: &str) -> Result<Self> {
-        let device = serialport::new(path, DEFAULT_BAUD_RATE)
-            .timeout(Duration::from_millis(10))
-            .parity(serialport::Parity::None)
-            .data_bits(serialport::DataBits::Eight)
-            .stop_bits(serialport::StopBits::One)
-            .path(path)
-            .open()?;
-
-        Ok(Self { device })
-    }
-}
-
-impl SerialComm for SerialPort {
-    fn write_all(&mut self, data: &[u8]) -> Result<()> {
-        Ok(self.device.write_all(data)?)
-    }
-
-    fn read(&mut self, data: &mut [u8]) -> Result<usize> {
-        Ok(self.device.read(data)?)
-    }
-
-    fn set_baud_rate(&mut self, baud_rate: u32) -> Result<()> {
-        Ok(self.device.set_baud_rate(baud_rate)?)
-    }
-
-    fn purge_buffers(&mut self) -> Result<()> {
-        Ok(self.device.clear(serialport::ClearBuffer::All)?)
-    }
-}

src/error.rs

@@ -1,6 +1,3 @@
-//! Error types for OBD-II related errors
-
-/// Result type defaulted with this library's error type
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// An error with OBD-II communication
@@ -19,7 +16,6 @@ pub enum Error {
     Other(String),
 }
 
-/// An error with the ELM327 device
 #[derive(Debug)]
 pub struct DeviceError(crate::device::Error);
 

src/interface.rs

@@ -6,6 +6,7 @@ use super::{device::Obd2BaseDevice, Error, Obd2Device, Result};
 ///
 /// Wraps an implementer of [Obd2BaseDevice] to allow for higher-level usage of the OBD-II
 /// interface.
+#[derive(Default)]
 pub struct Obd2<T: Obd2BaseDevice> {
     device: T,
 }
@@ -42,18 +43,6 @@ impl<T: Obd2BaseDevice> Obd2Device for Obd2<T> {
 }
 
 impl<T: Obd2BaseDevice> Obd2<T> {
-    /// Creates a new instance of an Obd device
-    pub fn new(dev: T) -> Result<Self> {
-        let device = Obd2 { device: dev };
-
-        Ok(device)
-    }
-
-    /// Resets the device
-    pub fn reset(&mut self) -> Result<()> {
-        Ok(self.device.reset()?)
-    }
-
     fn command(&mut self, command: &[u8]) -> Result<Vec<Vec<u8>>> {
         let response = self
             .device

src/lib.rs

@@ -6,20 +6,14 @@
 //!
 //! # Usage
 //! ```
-//! use obd2::{commands::Obd2DataRetrieval, device::{Elm327, FTDIDevice}, Obd2};
+//! use obd2::{commands::Obd2DataRetrieval, device::Elm327, Obd2};
 //!
 //! fn main() -> Result<(), obd2::Error> {
-//!     let mut device = Obd2::<Elm327::<FTDIDevice>>::new(Elm327::new(FTDIDevice::new()?)?)?;
+//!     let mut device = Obd2::<Elm327>::default();
 //!     println!("VIN: {}", device.get_vin()?);
 //!     Ok(())
 //! }
 //! ```
-//!
-//! alternatively, you could use a serial port provided by your operating system such as
-//! /dev/ttyUSB0 on unix-like systems
-//! ```
-//! let mut device = Obd2::<Elm327::<SerialPort>>::new(Elm327::new(SerialPort::new("/dev/ttyUSB0")?)?)?;
-//! ```
 
 #![forbid(unsafe_code)]
 #![warn(missing_docs, clippy::panic)]
@@ -28,7 +22,7 @@ pub mod commands;
 
 pub mod device;
 
-pub mod error;
+mod error;
 pub use error::Error;
 use error::Result;