undid changes + put ftdi & serial behind features

- serial_comm and ftdi_comm features added
- received/recieved typos reverted for inclusion in another PR
- fuel_level change reverted for inclusion in another PR
- DeviceError's 0 field made private again

src/commands/mod.rs

@@ -220,7 +220,4 @@ 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/ftdi_comm.rs

@@ -0,0 +1,42 @@
+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

@@ -4,7 +4,16 @@ mod elm327;
 pub use elm327::Elm327;
 
 mod serial_comm;
-pub use serial_comm::{FTDIDevice, SerialPort};
+
+#[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>;
 
@@ -54,10 +63,12 @@ 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),
 
@@ -70,12 +81,14 @@ 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)

src/device/serial_comm.rs

@@ -1,8 +1,6 @@
 use super::Result;
-use std::io::{Read, Write};
-use std::time::Duration;
 
-const DEFAULT_BAUD_RATE: u32 = 38_400;
+pub const DEFAULT_BAUD_RATE: u32 = 38_400;
 
 /// An API to communicate with a serial device
 pub trait SerialComm {
@@ -11,84 +9,3 @@ pub trait SerialComm {
     fn set_baud_rate(&mut self, baud_rate: u32) -> Result<()>;
     fn purge_buffers(&mut self) -> Result<()>;
 }
-
-/// 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)?)
-    }
-}
-
-/// 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/serialport_comm.rs

@@ -0,0 +1,46 @@
+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

@@ -21,7 +21,7 @@ pub enum Error {
 
 /// An error with the ELM327 device
 #[derive(Debug)]
-pub struct DeviceError(pub crate::device::Error);
+pub struct DeviceError(crate::device::Error);
 
 impl From<super::device::Error> for Error {
     fn from(e: super::device::Error) -> Self {
@@ -31,12 +31,12 @@ impl From<super::device::Error> for Error {
 
 impl From<std::num::ParseIntError> for Error {
     fn from(e: std::num::ParseIntError) -> Self {
-        Error::Other(format!("invalid data received: {:?}", e))
+        Error::Other(format!("invalid data recieved: {:?}", e))
     }
 }
 
 impl From<std::string::FromUtf8Error> for Error {
     fn from(e: std::string::FromUtf8Error) -> Self {
-        Error::Other(format!("invalid string received: {:?}", e))
+        Error::Other(format!("invalid string recieved: {:?}", e))
     }
 }