1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
//! I2C slave example using async operations with DMA
//!
//! This example demonstrates DMA-accelerated I2C slave operations,
//! which provide better performance and lower CPU overhead for
//! high-frequency I2C transactions.
#![no_std]
#![no_main]
use defmt::{error, info};
use embassy_executor::Spawner;
use embassy_stm32::i2c::{self, Address, I2c, SlaveAddrConfig, SlaveCommand, SlaveCommandKind};
use embassy_stm32::time::Hertz;
use embassy_stm32::{bind_interrupts, peripherals};
use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_sync::mutex::Mutex;
use embassy_time::{Duration, Timer};
use {defmt_rtt as _, panic_probe as _};
pub const I2C_SLAVE_ADDR: u8 = 0x42;
pub const BUFFER_SIZE: usize = 8;
static I2C_BUFFER: Mutex<ThreadModeRawMutex, [u8; BUFFER_SIZE]> = Mutex::new([0; BUFFER_SIZE]);
bind_interrupts!(struct Irqs {
I2C1_EV => i2c::EventInterruptHandler<peripherals::I2C1>;
I2C1_ER => i2c::ErrorInterruptHandler<peripherals::I2C1>;
});
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let p = embassy_stm32::init(Default::default());
// Configure I2C
let mut i2c_config = i2c::Config::default();
i2c_config.sda_pullup = false;
i2c_config.scl_pullup = false;
i2c_config.frequency = Hertz(100_000); // 100kHz I2C speed
// Initialize I2C as master first
let i2c_master = I2c::new(
p.I2C1, p.PB8, // SCL
p.PB9, // SDA
Irqs, p.DMA1_CH6, // TX DMA
p.DMA1_CH0, // RX DMA
i2c_config,
);
// Convert to MultiMaster mode
let slave_config = SlaveAddrConfig::basic(I2C_SLAVE_ADDR);
let i2c_slave = i2c_master.into_slave_multimaster(slave_config);
spawner.spawn(i2c_slave_task(i2c_slave).unwrap());
}
#[embassy_executor::task]
pub async fn i2c_slave_task(mut i2c_slave: I2c<'static, embassy_stm32::mode::Async, i2c::mode::MultiMaster>) {
info!("Async I2C slave ready at address 0x{:02X}", I2C_SLAVE_ADDR);
loop {
match i2c_slave.listen().await {
Ok(SlaveCommand {
kind: SlaveCommandKind::Write,
address,
}) => {
let addr_val = match address {
Address::SevenBit(addr) => addr,
Address::TenBit(addr) => (addr & 0xFF) as u8,
};
info!("I2C: Received write command - Address 0x{:02X}", addr_val);
let mut data_buffer = I2C_BUFFER.lock().await;
match i2c_slave.respond_to_write(&mut *data_buffer).await {
Ok(_) => {
info!(
"I2C: Data received - Buffer now contains: 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}",
data_buffer[0],
data_buffer[1],
data_buffer[2],
data_buffer[3],
data_buffer[4],
data_buffer[5],
data_buffer[6],
data_buffer[7]
);
}
Err(e) => {
error!("I2C: Write error: {}", format_i2c_error(&e));
}
}
}
Ok(SlaveCommand {
kind: SlaveCommandKind::Read,
address,
}) => {
let addr_val = match address {
Address::SevenBit(addr) => addr,
Address::TenBit(addr) => (addr & 0xFF) as u8, // Show low byte for 10-bit
};
info!("I2C: Received read command - Address 0x{:02X}", addr_val);
let data_buffer = I2C_BUFFER.lock().await;
match i2c_slave.respond_to_read(&data_buffer[..BUFFER_SIZE]).await {
Ok(_) => {
info!("I2C: Responded to read command");
}
Err(e) => {
error!("I2C: Read error: {}", format_i2c_error(&e));
}
}
}
Err(e) => {
error!("I2C: Listen error: {}", format_i2c_error(&e));
Timer::after(Duration::from_millis(100)).await;
}
}
}
}
fn format_i2c_error(e: &embassy_stm32::i2c::Error) -> &'static str {
match e {
embassy_stm32::i2c::Error::Bus => "Bus",
embassy_stm32::i2c::Error::Arbitration => "Arbitration",
embassy_stm32::i2c::Error::Nack => "Nack",
embassy_stm32::i2c::Error::Timeout => "Timeout",
embassy_stm32::i2c::Error::Crc => "Crc",
embassy_stm32::i2c::Error::Overrun => "Overrun",
embassy_stm32::i2c::Error::ZeroLengthTransfer => "ZeroLengthTransfer",
}
}
|
