add stm32 i2c slave example

2 files changed, 18 insertions, 18 deletions

diff --git a/embassy-stm32/src/i2c/mod.rs b/embassy-stm32/src/i2c/mod.rs
index 94507eb34..2ff21702b 100644
--- a/embassy-stm32/src/i2c/mod.rs
+++ b/embassy-stm32/src/i2c/mod.rs
@@ -70,19 +70,19 @@ pub mod mode {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// The command kind to the slave from the master
-pub enum CommandKind {
+pub enum SlaveCommandKind {
     /// Write to the slave
-    SlaveReceive,
+    Write,
     /// Read from the slave
-    SlaveSend,
+    Read,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// The command kind to the slave from the master and the address that the slave matched
-pub struct Command {
+pub struct SlaveCommand {
     /// The kind of command
-    pub kind: CommandKind,
+    pub kind: SlaveCommandKind,
     /// The address that the slave matched
     pub address: Address,
 }
diff --git a/embassy-stm32/src/i2c/v2.rs b/embassy-stm32/src/i2c/v2.rs
index 1cc41fb5f..64ccd24c7 100644
--- a/embassy-stm32/src/i2c/v2.rs
+++ b/embassy-stm32/src/i2c/v2.rs
@@ -887,7 +887,7 @@ impl<'d, M: Mode> I2c<'d, M, MultiMaster> {
     /// Listen for incoming I2C messages.
     ///
     /// The listen method is an asynchronous method but it does not require DMA to be asynchronous.
-    pub async fn listen(&mut self) -> Result<Command, Error> {
+    pub async fn listen(&mut self) -> Result<SlaveCommand, Error> {
         let state = self.state;
         self.info.regs.cr1().modify(|reg| {
             reg.set_addrie(true);
@@ -902,12 +902,12 @@ impl<'d, M: Mode> I2c<'d, M, MultiMaster> {
                 // we do not clear the address flag here as it will be cleared by the dma read/write
                 // if we clear it here the clock stretching will stop and the master will read in data before the slave is ready to send it
                 match isr.dir() {
-                    i2c::vals::Dir::WRITE => Poll::Ready(Ok(Command {
-                        kind: CommandKind::SlaveReceive,
+                    i2c::vals::Dir::WRITE => Poll::Ready(Ok(SlaveCommand {
+                        kind: SlaveCommandKind::Write,
                         address: self.determine_matched_address()?,
                     })),
-                    i2c::vals::Dir::READ => Poll::Ready(Ok(Command {
-                        kind: CommandKind::SlaveSend,
+                    i2c::vals::Dir::READ => Poll::Ready(Ok(SlaveCommand {
+                        kind: SlaveCommandKind::Read,
                         address: self.determine_matched_address()?,
                     })),
                 }
@@ -916,30 +916,30 @@ impl<'d, M: Mode> I2c<'d, M, MultiMaster> {
         .await
     }
 
-    /// Respond to a receive command.
-    pub fn blocking_respond_to_receive(&self, read: &mut [u8]) -> Result<(), Error> {
+    /// Respond to a write command.
+    pub fn blocking_respond_to_write(&self, read: &mut [u8]) -> Result<(), Error> {
         let timeout = self.timeout();
         self.slave_read_internal(read, timeout)
     }
 
-    /// Respond to a send command.
-    pub fn blocking_respond_to_send(&mut self, write: &[u8]) -> Result<(), Error> {
+    /// Respond to a read command.
+    pub fn blocking_respond_to_read(&mut self, write: &[u8]) -> Result<(), Error> {
         let timeout = self.timeout();
         self.slave_write_internal(write, timeout)
     }
 }
 
 impl<'d> I2c<'d, Async, MultiMaster> {
-    /// Respond to a receive command.
+    /// Respond to a write command.
     ///
     /// Returns the total number of bytes received.
-    pub async fn respond_to_receive(&mut self, buffer: &mut [u8]) -> Result<usize, Error> {
+    pub async fn respond_to_write(&mut self, buffer: &mut [u8]) -> Result<usize, Error> {
         let timeout = self.timeout();
         timeout.with(self.read_dma_internal_slave(buffer, timeout)).await
     }
 
-    /// Respond to a send request from an I2C master.
-    pub async fn respond_to_send(&mut self, write: &[u8]) -> Result<SendStatus, Error> {
+    /// Respond to a read request from an I2C master.
+    pub async fn respond_to_read(&mut self, write: &[u8]) -> Result<SendStatus, Error> {
         let timeout = self.timeout();
         timeout.with(self.write_dma_internal_slave(write, timeout)).await
     }