Rename XXBusDevice to XXDevice.

2 files changed, 42 insertions, 42 deletions

diff --git a/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs b/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
index 136117920..5bd3d9bc5 100644
--- a/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
+++ b/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
@@ -3,7 +3,7 @@
 //! # Example (nrf52)
 //!
 //! ```rust
-//! use embassy_embedded_hal::shared_bus::i2c::I2cBusDevice;
+//! use embassy_embedded_hal::shared_bus::i2c::I2cDevice;
 //! use embassy::mutex::Mutex;
 //! use embassy::blocking_mutex::raw::ThreadModeRawMutex;
 //!
@@ -15,11 +15,11 @@
 //! let i2c_bus = I2C_BUS.put(i2c_bus);
 //!
 //! // Device 1, using embedded-hal-async compatible driver for QMC5883L compass
-//! let i2c_dev1 = I2cBusDevice::new(i2c_bus);
+//! let i2c_dev1 = I2cDevice::new(i2c_bus);
 //! let compass = QMC5883L::new(i2c_dev1).await.unwrap();
 //!
 //! // Device 2, using embedded-hal-async compatible driver for Mpu6050 accelerometer
-//! let i2c_dev2 = I2cBusDevice::new(i2c_bus);
+//! let i2c_dev2 = I2cDevice::new(i2c_bus);
 //! let mpu = Mpu6050::new(i2c_dev2);
 //! ```
 use core::future::Future;
@@ -28,27 +28,27 @@ use embassy::blocking_mutex::raw::RawMutex;
 use embassy::mutex::Mutex;
 use embedded_hal_async::i2c;
 
-use crate::shared_bus::I2cBusDeviceError;
+use crate::shared_bus::I2cDeviceError;
 use crate::SetConfig;
 
-pub struct I2cBusDevice<'a, M: RawMutex, BUS> {
+pub struct I2cDevice<'a, M: RawMutex, BUS> {
     bus: &'a Mutex<M, BUS>,
 }
 
-impl<'a, M: RawMutex, BUS> I2cBusDevice<'a, M, BUS> {
+impl<'a, M: RawMutex, BUS> I2cDevice<'a, M, BUS> {
     pub fn new(bus: &'a Mutex<M, BUS>) -> Self {
         Self { bus }
     }
 }
 
-impl<'a, M: RawMutex, BUS> i2c::ErrorType for I2cBusDevice<'a, M, BUS>
+impl<'a, M: RawMutex, BUS> i2c::ErrorType for I2cDevice<'a, M, BUS>
 where
     BUS: i2c::ErrorType,
 {
-    type Error = I2cBusDeviceError<BUS::Error>;
+    type Error = I2cDeviceError<BUS::Error>;
 }
 
-impl<M, BUS> i2c::I2c for I2cBusDevice<'_, M, BUS>
+impl<M, BUS> i2c::I2c for I2cDevice<'_, M, BUS>
 where
     M: RawMutex + 'static,
     BUS: i2c::I2c + 'static,
@@ -58,7 +58,7 @@ where
     fn read<'a>(&'a mut self, address: u8, buffer: &'a mut [u8]) -> Self::ReadFuture<'a> {
         async move {
             let mut bus = self.bus.lock().await;
-            bus.read(address, buffer).await.map_err(I2cBusDeviceError::I2c)?;
+            bus.read(address, buffer).await.map_err(I2cDeviceError::I2c)?;
             Ok(())
         }
     }
@@ -68,7 +68,7 @@ where
     fn write<'a>(&'a mut self, address: u8, bytes: &'a [u8]) -> Self::WriteFuture<'a> {
         async move {
             let mut bus = self.bus.lock().await;
-            bus.write(address, bytes).await.map_err(I2cBusDeviceError::I2c)?;
+            bus.write(address, bytes).await.map_err(I2cDeviceError::I2c)?;
             Ok(())
         }
     }
@@ -85,7 +85,7 @@ where
             let mut bus = self.bus.lock().await;
             bus.write_read(address, wr_buffer, rd_buffer)
                 .await
-                .map_err(I2cBusDeviceError::I2c)?;
+                .map_err(I2cDeviceError::I2c)?;
             Ok(())
         }
     }
@@ -103,27 +103,27 @@ where
     }
 }
 
-pub struct I2cBusDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig> {
+pub struct I2cDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig> {
     bus: &'a Mutex<M, BUS>,
     config: BUS::Config,
 }
 
-impl<'a, M: RawMutex, BUS: SetConfig> I2cBusDeviceWithConfig<'a, M, BUS> {
+impl<'a, M: RawMutex, BUS: SetConfig> I2cDeviceWithConfig<'a, M, BUS> {
     pub fn new(bus: &'a Mutex<M, BUS>, config: BUS::Config) -> Self {
         Self { bus, config }
     }
 }
 
-impl<'a, M, BUS> i2c::ErrorType for I2cBusDeviceWithConfig<'a, M, BUS>
+impl<'a, M, BUS> i2c::ErrorType for I2cDeviceWithConfig<'a, M, BUS>
 where
     BUS: i2c::ErrorType,
     M: RawMutex,
     BUS: SetConfig,
 {
-    type Error = I2cBusDeviceError<BUS::Error>;
+    type Error = I2cDeviceError<BUS::Error>;
 }
 
-impl<M, BUS> i2c::I2c for I2cBusDeviceWithConfig<'_, M, BUS>
+impl<M, BUS> i2c::I2c for I2cDeviceWithConfig<'_, M, BUS>
 where
     M: RawMutex + 'static,
     BUS: i2c::I2c + SetConfig + 'static,
@@ -134,7 +134,7 @@ where
         async move {
             let mut bus = self.bus.lock().await;
             bus.set_config(&self.config);
-            bus.read(address, buffer).await.map_err(I2cBusDeviceError::I2c)?;
+            bus.read(address, buffer).await.map_err(I2cDeviceError::I2c)?;
             Ok(())
         }
     }
@@ -145,7 +145,7 @@ where
         async move {
             let mut bus = self.bus.lock().await;
             bus.set_config(&self.config);
-            bus.write(address, bytes).await.map_err(I2cBusDeviceError::I2c)?;
+            bus.write(address, bytes).await.map_err(I2cDeviceError::I2c)?;
             Ok(())
         }
     }
@@ -163,7 +163,7 @@ where
             bus.set_config(&self.config);
             bus.write_read(address, wr_buffer, rd_buffer)
                 .await
-                .map_err(I2cBusDeviceError::I2c)?;
+                .map_err(I2cDeviceError::I2c)?;
             Ok(())
         }
     }
diff --git a/embassy-embedded-hal/src/shared_bus/asynch/spi.rs b/embassy-embedded-hal/src/shared_bus/asynch/spi.rs
index 8034c90b5..343184d12 100644
--- a/embassy-embedded-hal/src/shared_bus/asynch/spi.rs
+++ b/embassy-embedded-hal/src/shared_bus/asynch/spi.rs
@@ -3,7 +3,7 @@
 //! # Example (nrf52)
 //!
 //! ```rust
-//! use embassy_embedded_hal::shared_bus::spi::SpiBusDevice;
+//! use embassy_embedded_hal::shared_bus::spi::SpiDevice;
 //! use embassy::mutex::Mutex;
 //! use embassy::blocking_mutex::raw::ThreadModeRawMutex;
 //!
@@ -17,12 +17,12 @@
 //!
 //! // Device 1, using embedded-hal-async compatible driver for ST7735 LCD display
 //! let cs_pin1 = Output::new(p.P0_24, Level::Low, OutputDrive::Standard);
-//! let spi_dev1 = SpiBusDevice::new(spi_bus, cs_pin1);
+//! let spi_dev1 = SpiDevice::new(spi_bus, cs_pin1);
 //! let display1 = ST7735::new(spi_dev1, dc1, rst1, Default::default(), 160, 128);
 //!
 //! // Device 2
 //! let cs_pin2 = Output::new(p.P0_24, Level::Low, OutputDrive::Standard);
-//! let spi_dev2 = SpiBusDevice::new(spi_bus, cs_pin2);
+//! let spi_dev2 = SpiDevice::new(spi_bus, cs_pin2);
 //! let display2 = ST7735::new(spi_dev2, dc2, rst2, Default::default(), 160, 128);
 //! ```
 use core::future::Future;
@@ -33,29 +33,29 @@ use embedded_hal_1::digital::blocking::OutputPin;
 use embedded_hal_1::spi::ErrorType;
 use embedded_hal_async::spi;
 
-use crate::shared_bus::SpiBusDeviceError;
+use crate::shared_bus::SpiDeviceError;
 use crate::SetConfig;
 
-pub struct SpiBusDevice<'a, M: RawMutex, BUS, CS> {
+pub struct SpiDevice<'a, M: RawMutex, BUS, CS> {
     bus: &'a Mutex<M, BUS>,
     cs: CS,
 }
 
-impl<'a, M: RawMutex, BUS, CS> SpiBusDevice<'a, M, BUS, CS> {
+impl<'a, M: RawMutex, BUS, CS> SpiDevice<'a, M, BUS, CS> {
     pub fn new(bus: &'a Mutex<M, BUS>, cs: CS) -> Self {
         Self { bus, cs }
     }
 }
 
-impl<'a, M: RawMutex, BUS, CS> spi::ErrorType for SpiBusDevice<'a, M, BUS, CS>
+impl<'a, M: RawMutex, BUS, CS> spi::ErrorType for SpiDevice<'a, M, BUS, CS>
 where
     BUS: spi::ErrorType,
     CS: OutputPin,
 {
-    type Error = SpiBusDeviceError<BUS::Error, CS::Error>;
+    type Error = SpiDeviceError<BUS::Error, CS::Error>;
 }
 
-impl<M, BUS, CS> spi::SpiDevice for SpiBusDevice<'_, M, BUS, CS>
+impl<M, BUS, CS> spi::SpiDevice for SpiDevice<'_, M, BUS, CS>
 where
     M: RawMutex + 'static,
     BUS: spi::SpiBusFlush + 'static,
@@ -76,7 +76,7 @@ where
     {
         async move {
             let mut bus = self.bus.lock().await;
-            self.cs.set_low().map_err(SpiBusDeviceError::Cs)?;
+            self.cs.set_low().map_err(SpiDeviceError::Cs)?;
 
             let f_res = f(&mut *bus).await;
 
@@ -84,37 +84,37 @@ where
             let flush_res = bus.flush().await;
             let cs_res = self.cs.set_high();
 
-            let f_res = f_res.map_err(SpiBusDeviceError::Spi)?;
-            flush_res.map_err(SpiBusDeviceError::Spi)?;
-            cs_res.map_err(SpiBusDeviceError::Cs)?;
+            let f_res = f_res.map_err(SpiDeviceError::Spi)?;
+            flush_res.map_err(SpiDeviceError::Spi)?;
+            cs_res.map_err(SpiDeviceError::Cs)?;
 
             Ok(f_res)
         }
     }
 }
 
-pub struct SpiBusDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig, CS> {
+pub struct SpiDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig, CS> {
     bus: &'a Mutex<M, BUS>,
     cs: CS,
     config: BUS::Config,
 }
 
-impl<'a, M: RawMutex, BUS: SetConfig, CS> SpiBusDeviceWithConfig<'a, M, BUS, CS> {
+impl<'a, M: RawMutex, BUS: SetConfig, CS> SpiDeviceWithConfig<'a, M, BUS, CS> {
     pub fn new(bus: &'a Mutex<M, BUS>, cs: CS, config: BUS::Config) -> Self {
         Self { bus, cs, config }
     }
 }
 
-impl<'a, M, BUS, CS> spi::ErrorType for SpiBusDeviceWithConfig<'a, M, BUS, CS>
+impl<'a, M, BUS, CS> spi::ErrorType for SpiDeviceWithConfig<'a, M, BUS, CS>
 where
     BUS: spi::ErrorType + SetConfig,
     CS: OutputPin,
     M: RawMutex,
 {
-    type Error = SpiBusDeviceError<BUS::Error, CS::Error>;
+    type Error = SpiDeviceError<BUS::Error, CS::Error>;
 }
 
-impl<M, BUS, CS> spi::SpiDevice for SpiBusDeviceWithConfig<'_, M, BUS, CS>
+impl<M, BUS, CS> spi::SpiDevice for SpiDeviceWithConfig<'_, M, BUS, CS>
 where
     M: RawMutex + 'static,
     BUS: spi::SpiBusFlush + SetConfig + 'static,
@@ -136,7 +136,7 @@ where
         async move {
             let mut bus = self.bus.lock().await;
             bus.set_config(&self.config);
-            self.cs.set_low().map_err(SpiBusDeviceError::Cs)?;
+            self.cs.set_low().map_err(SpiDeviceError::Cs)?;
 
             let f_res = f(&mut *bus).await;
 
@@ -144,9 +144,9 @@ where
             let flush_res = bus.flush().await;
             let cs_res = self.cs.set_high();
 
-            let f_res = f_res.map_err(SpiBusDeviceError::Spi)?;
-            flush_res.map_err(SpiBusDeviceError::Spi)?;
-            cs_res.map_err(SpiBusDeviceError::Cs)?;
+            let f_res = f_res.map_err(SpiDeviceError::Spi)?;
+            flush_res.map_err(SpiDeviceError::Spi)?;
+            cs_res.map_err(SpiDeviceError::Cs)?;
 
             Ok(f_res)
         }