Clean up API and Errors

README.md

@@ -9,7 +9,7 @@ Welcome to the `automotive` crate documentation. The purpose of this crate is to
 The following adapter opens the first available adapter on the system, and then receives all frames.
 
 ```rust
-let adapter = automotive::adapter::get_adapter().unwrap();
+let adapter = automotive::can::get_adapter().unwrap();
 let mut stream = adapter.recv();
 
 while let Some(frame) = stream.next().await {
@@ -23,7 +23,7 @@ while let Some(frame) = stream.next().await {
 The automotive crate also supplies interfaces for various diagnostic protocols such as UDS. The adapter is first wrapped to support the ISO Transport Layer, then a UDS Client is created. All methods are fully async, making it easy to communicate with multiple ECUs in parallel. See [https://github.com/I-CAN-hack/automotive/issues/21](https://github.com/I-CAN-hack/automotive/issues/21) for progress on the supported SIDs.
 
 ```rust
-let adapter = automotive::adapter::get_adapter().unwrap();
+let adapter = automotive::can::get_adapter().unwrap();
 let isotp = automotive::isotp::IsoTPAdapter::from_id(&adapter, 0x7a1);
 let uds = automotive::uds::UDSClient::new(&isotp);
 

examples/can_printer.rs

@@ -5,7 +5,7 @@ use tracing_subscriber;
 async fn main() {
  tracing_subscriber::fmt::init();
 
- let adapter = automotive::adapter::get_adapter().unwrap();
+ let adapter = automotive::can::get_adapter().unwrap();
  let mut stream = adapter.recv();
 
  while let Some(frame) = stream.next().await {

examples/isotp.rs

@@ -7,7 +7,7 @@ use tracing_subscriber;
 async fn main() {
  tracing_subscriber::fmt::init();
 
- let adapter = automotive::adapter::get_adapter().unwrap();
+ let adapter = automotive::can::get_adapter().unwrap();
  let config = IsoTPConfig::new(0, Identifier::Standard(0x7a1));
  let isotp = IsoTPAdapter::new(&adapter, config);
 

examples/query_fw_versions.rs

@@ -1,9 +1,9 @@
-use automotive::async_can::AsyncCanAdapter;
+use automotive::can::AsyncCanAdapter;
 use automotive::can::Identifier;
-use automotive::error::Error;
 use automotive::isotp::{IsoTPAdapter, IsoTPConfig};
+use automotive::Error;
 
-use automotive::uds::constants::DataIdentifier;
+use automotive::uds::DataIdentifier;
 use automotive::uds::UDSClient;
 
 use bstr::ByteSlice;
@@ -43,7 +43,7 @@ async fn get_version(adapter: &AsyncCanAdapter, identifier: u32) -> Result<(), E
 async fn main() {
  tracing_subscriber::fmt::init();
 
- let adapter = automotive::adapter::get_adapter().unwrap();
+ let adapter = automotive::can::get_adapter().unwrap();
 
  let standard_ids = 0x700..=0x7ff;
  let extended_ids = (0x00..=0xff).map(|i| 0x18da0000 + (i << 8) + 0xf1);

examples/uds.rs

@@ -1,11 +1,11 @@
-use automotive::uds::constants::{DataIdentifier, SessionType};
+use automotive::uds::{DataIdentifier, SessionType};
 use bstr::ByteSlice;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
  tracing_subscriber::fmt::init();
 
- let adapter = automotive::adapter::get_adapter()?;
+ let adapter = automotive::can::get_adapter()?;
  let isotp = automotive::isotp::IsoTPAdapter::from_id(&adapter, 0x7a1);
  let uds = automotive::uds::UDSClient::new(&isotp);
 

src/adapter.rs → src/can/adapter.rs

@@ -1,7 +1,7 @@
 //! Convenience functions to get a CAN adapter.
 
 /// Convenience function to get the first available adapter on the system. Supports both comma.ai panda, and SocketCAN.
-pub fn get_adapter() -> Result<crate::async_can::AsyncCanAdapter, crate::error::Error> {
+pub fn get_adapter() -> Result<crate::can::AsyncCanAdapter, crate::error::Error> {
  if let Ok(panda) = crate::panda::Panda::new_async() {
  return Ok(panda);
  }

src/can.rs → src/can/mod.rs

@@ -1,7 +1,13 @@
 //! Generic CAN types and traits
 
+pub mod adapter;
+pub mod async_can;
+
 use std::fmt;
 
+pub use adapter::get_adapter;
+pub use async_can::AsyncCanAdapter;
+
 pub static DLC_TO_LEN: &[usize] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64];
 
 /// Identifier for a CAN frame

src/error.rs

@@ -13,13 +13,13 @@ pub enum Error {
  #[error("Timeout")]
  Timeout,
  #[error(transparent)]
- IsoTPError(#[from] crate::isotp::error::Error),
+ IsoTPError(#[from] crate::isotp::Error),
  #[error(transparent)]
  LibUsbError(#[from] rusb::Error),
  #[error(transparent)]
- PandaError(#[from] crate::panda::error::Error),
+ PandaError(#[from] crate::panda::Error),
  #[error(transparent)]
- UDSError(#[from] crate::uds::error::Error),
+ UDSError(#[from] crate::uds::Error),
 }
 
 impl From<tokio_stream::Elapsed> for Error {

src/isotp/mod.rs

@@ -3,7 +3,7 @@
 //! ```rust
 //! use futures_util::stream::StreamExt;
 //! async fn isotp_example() {
-//! let adapter = automotive::adapter::get_adapter().unwrap();
+//! let adapter = automotive::can::get_adapter().unwrap();
 //! let config = automotive::isotp::IsoTPConfig::new(0, automotive::can::Identifier::Standard(0x7a1));
 //! let isotp = automotive::isotp::IsoTPAdapter::new(&adapter, config);
 //!
@@ -13,17 +13,16 @@
 //! }
 //! ```
 
-pub mod constants;
-pub mod error;
-pub mod types;
+mod constants;
+mod error;
+mod types;
 
-use crate::async_can::AsyncCanAdapter;
-use crate::can::{Frame, Identifier, DLC_TO_LEN};
-use crate::error::Error;
-use crate::isotp::constants::FlowStatus;
-use crate::isotp::constants::FLOW_SATUS_MASK;
-use crate::isotp::constants::{FrameType, FRAME_TYPE_MASK};
+pub use constants::{FlowStatus, FrameType, FLOW_SATUS_MASK, FRAME_TYPE_MASK};
+pub use error::Error;
 
+use crate::can::AsyncCanAdapter;
+use crate::can::{Frame, Identifier, DLC_TO_LEN};
+use crate::Result;
 use async_stream::stream;
 use futures_core::stream::Stream;
 use tokio_stream::{StreamExt, Timeout};
@@ -175,7 +174,7 @@ impl<'a> IsoTPAdapter<'a> {
  }
 
  /// Build a CAN frame from the payload. Inserts extended address and padding if needed.
- fn frame(&self, data: &[u8]) -> Result<Frame, Error> {
+ fn frame(&self, data: &[u8]) -> Result<Frame> {
  let mut data = data.to_vec();
 
  if let Some(ext_address) = self.config.ext_address {
@@ -185,7 +184,7 @@ impl<'a> IsoTPAdapter<'a> {
  // Check if the data length is valid
  if !DLC_TO_LEN.contains(&data.len()) {
  println!("len {}", data.len());
- return Err(crate::error::Error::MalformedFrame);
+ return Err(crate::Error::MalformedFrame);
  }
 
  let frame = Frame {
@@ -199,7 +198,7 @@ impl<'a> IsoTPAdapter<'a> {
  Ok(frame)
  }
 
- pub async fn send_single_frame(&self, data: &[u8]) -> Result<(), Error> {
+ pub async fn send_single_frame(&self, data: &[u8]) -> Result<()> {
  let mut buf;
 
  if data.len() < 0xf {
@@ -220,7 +219,7 @@ impl<'a> IsoTPAdapter<'a> {
  Ok(())
  }
 
- pub async fn send_first_frame(&self, data: &[u8]) -> Result<usize, Error> {
+ pub async fn send_first_frame(&self, data: &[u8]) -> Result<usize> {
  let mut buf;
  if data.len() <= ISO_TP_MAX_DLEN {
  let b0: u8 = FrameType::First as u8 | ((data.len() >> 8) & 0xF) as u8;
@@ -242,7 +241,7 @@ impl<'a> IsoTPAdapter<'a> {
  Ok(offset)
  }
 
- pub async fn send_consecutive_frame(&self, data: &[u8], idx: usize) -> Result<(), Error> {
+ pub async fn send_consecutive_frame(&self, data: &[u8], idx: usize) -> Result<()> {
  let idx = ((idx + 1) & 0xF) as u8;
 
  let mut buf = vec![FrameType::Consecutive as u8 | idx];
@@ -261,7 +260,7 @@ impl<'a> IsoTPAdapter<'a> {
  async fn receive_flow_control(
  &self,
  stream: &mut std::pin::Pin<&mut Timeout<impl Stream<Item = Frame>>>,
- ) -> Result<FlowControlConfig, Error> {
+ ) -> Result<FlowControlConfig> {
  for _ in 0..MAX_WAIT_FC {
  let mut frame = stream.next().await.unwrap()?;
 
@@ -296,7 +295,7 @@ impl<'a> IsoTPAdapter<'a> {
  Err(crate::isotp::error::Error::TooManyFCWait.into())
  }
 
- async fn send_multiple(&self, data: &[u8]) -> Result<(), Error> {
+ async fn send_multiple(&self, data: &[u8]) -> Result<()> {
  // Stream for receiving flow control
  let stream = self
  .adapter
@@ -346,7 +345,7 @@ impl<'a> IsoTPAdapter<'a> {
  }
 
  /// Asynchronously send an ISO-TP frame of up to 4095 bytes. Returns [`Error::Timeout`] if the ECU is not responding in time with flow control messages.
- pub async fn send(&self, data: &[u8]) -> Result<(), Error> {
+ pub async fn send(&self, data: &[u8]) -> Result<()> {
  debug!("TX {}", hex::encode(data));
 
  // Single frame has 1 byte of overhead for CAN, and 2 bytes for CAN-FD with escape sequence
@@ -364,7 +363,7 @@ impl<'a> IsoTPAdapter<'a> {
  Ok(())
  }
 
- async fn recv_single_frame(&self, data: &[u8]) -> Result<Vec<u8>, Error> {
+ async fn recv_single_frame(&self, data: &[u8]) -> Result<Vec<u8>> {
  let mut len = (data[0] & 0xF) as usize;
  let mut offset = 1;
 
@@ -384,7 +383,7 @@ impl<'a> IsoTPAdapter<'a> {
  Ok(data[offset..len + offset].to_vec())
  }
 
- async fn recv_first_frame(&self, data: &[u8], buf: &mut Vec<u8>) -> Result<usize, Error> {
+ async fn recv_first_frame(&self, data: &[u8], buf: &mut Vec<u8>) -> Result<usize> {
  let b0 = data[0] as u16;
  let b1 = data[1] as u16;
  let mut len = ((b0 << 8 | b1) & 0xFFF) as usize;
@@ -422,7 +421,7 @@ impl<'a> IsoTPAdapter<'a> {
  buf: &mut Vec<u8>,
  len: usize,
  idx: u8,
- ) -> Result<u8, Error> {
+ ) -> Result<u8> {
  let msg_idx = data[0] & 0xF;
  let remaining_len = len - buf.len();
 
@@ -462,7 +461,7 @@ impl<'a> IsoTPAdapter<'a> {
  async fn recv_from_stream(
  &self,
  stream: &mut std::pin::Pin<&mut Timeout<impl Stream<Item = Frame>>>,
- ) -> Result<Vec<u8>, Error> {
+ ) -> Result<Vec<u8>> {
  let mut buf = Vec::new();
  let mut len: Option<usize> = None;
  let mut idx: u8 = 1;
@@ -478,7 +477,7 @@ impl<'a> IsoTPAdapter<'a> {
  Some(FrameType::First) => {
  // If we already received a first frame, something went wrong
  if len.is_some() {
- return Err(Error::IsoTPError(crate::isotp::error::Error::OutOfOrder));
+ return Err(Error::OutOfOrder.into());
  }
  len = Some(self.recv_first_frame(data, &mut buf).await?);
  }
@@ -491,20 +490,20 @@ impl<'a> IsoTPAdapter<'a> {
  return Ok(buf);
  }
  } else {
- return Err(Error::IsoTPError(crate::isotp::error::Error::OutOfOrder));
+ return Err(Error::OutOfOrder.into());
  }
  }
  Some(FrameType::FlowControl) => {} // Ignore flow control frames, these are from a simultaneous transmission
  _ => {
- return Err(crate::isotp::error::Error::UnknownFrameType.into());
+ return Err(Error::UnknownFrameType.into());
  }
  };
  }
  unreachable!();
  }
 
  /// Stream of ISO-TP packets. Can be used if multiple responses are expected from a single request. Returns [`Error::Timeout`] if the timeout is exceeded between individual ISO-TP frames. Note the total time to receive a packet may be longer than the timeout.
- pub fn recv(&self) -> impl Stream<Item = Result<Vec<u8>, Error>> + '_ {
+ pub fn recv(&self) -> impl Stream<Item = Result<Vec<u8>>> + '_ {
  let stream = self
  .adapter
  .recv_filter(|frame| {

src/lib.rs

@@ -8,7 +8,7 @@
 //! ```rust
 //! use futures_util::stream::StreamExt;
 //! async fn can_example() {
-//! let adapter = automotive::adapter::get_adapter().unwrap();
+//! let adapter = automotive::can::get_adapter().unwrap();
 //! let mut stream = adapter.recv();
 //!
 //! while let Some(frame) = stream.next().await {
@@ -24,12 +24,12 @@
 //!
 //! ```rust
 //! async fn uds_example() {
-//! let adapter = automotive::adapter::get_adapter().unwrap();
+//! let adapter = automotive::can::get_adapter().unwrap();
 //! let isotp = automotive::isotp::IsoTPAdapter::from_id(&adapter, 0x7a1);
 //! let uds = automotive::uds::UDSClient::new(&isotp);
 //!
 //! uds.tester_present().await.unwrap();
-//! let response = uds.read_data_by_identifier(automotive::uds::constants::DataIdentifier::ApplicationSoftwareIdentification as u16).await.unwrap();
+//! let response = uds.read_data_by_identifier(automotive::uds::DataIdentifier::ApplicationSoftwareIdentification as u16).await.unwrap();
 //!
 //! println!("Application Software Identification: {}", hex::encode(response));
 //! }
@@ -40,13 +40,14 @@
 //! - comma.ai panda (all platforms)
 //!
 
-pub mod adapter;
-pub mod async_can;
 pub mod can;
-pub mod error;
+mod error;
 pub mod isotp;
 pub mod panda;
 pub mod uds;
 
+pub use error::Error;
+pub type Result<T> = std::result::Result<T, Error>;
+
 #[cfg(target_os = "linux")]
 pub mod socketcan;