max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2200 from barnabywalters/asynci2cv1

Browse Source 
Implemented async I2C for v1
This commit is contained in:
Dario Nieuwenhuis
2023-11-24 23:08:47 +00:00
committed by GitHub
parent 47bac9df70 3efc3eee57
commit f5c9e3baa6
15 changed files with 810 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
examples/stm32f4/src/bin/i2c.rs
View File

@ -14,7 +14,8 @@ const ADDRESS: u8 = 0x5F;
const WHOAMI: u8 = 0x0F;
bind_interrupts!(struct Irqs {
I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
});
#[embassy_executor::main]

62
examples/stm32f4/src/bin/i2c_async.rs Normal file
View File

@ -0,0 +1,62 @@
#![no_std]
#![no_main]
#![feature(type_alias_impl_trait)]
// Example originally designed for stm32f411ceu6 reading an A1454 hall effect sensor on I2C1
// DMA peripherals changed to compile for stm32f429zi, for the CI.
use defmt::*;
use embassy_executor::Spawner;
use embassy_stm32::i2c::I2c;
use embassy_stm32::time::Hertz;
use embassy_stm32::{bind_interrupts, i2c, peripherals};
use {defmt_rtt as _, panic_probe as _};
const ADDRESS: u8 = 96;
bind_interrupts!(struct Irqs {
I2C1_EV => i2c::EventInterruptHandler<peripherals::I2C1>;
I2C1_ER => i2c::ErrorInterruptHandler<peripherals::I2C1>;
});
#[embassy_executor::main]
async fn main(_spawner: Spawner) {
info!("Hello world!");
let p = embassy_stm32::init(Default::default());
let mut i2c = I2c::new(
p.I2C1,
p.PB8,
p.PB7,
Irqs,
p.DMA1_CH6,
p.DMA1_CH0,
Hertz(100_000),
Default::default(),
);
loop {
let a1454_read_sensor_command = [0x1F];
let mut sensor_data_buffer: [u8; 4] = [0, 0, 0, 0];
match i2c
.write_read(ADDRESS, &a1454_read_sensor_command, &mut sensor_data_buffer)
.await
{
Ok(()) => {
// Convert 12-bit signed integer into 16-bit signed integer.
// Is the 12 bit number negative?
if (sensor_data_buffer[2] & 0b00001000) == 0b0001000 {
sensor_data_buffer[2] = sensor_data_buffer[2] | 0b11110000;
}
let mut sensor_value_raw: u16 = sensor_data_buffer[3].into();
sensor_value_raw |= (sensor_data_buffer[2] as u16) << 8;
let sensor_value: u16 = sensor_value_raw.into();
let sensor_value = sensor_value as i16;
info!("Data: {}", sensor_value);
}
Err(e) => error!("I2C Error during read: {:?}", e),
}
}
}

135
examples/stm32f4/src/bin/i2c_comparison.rs Normal file
View File

@ -0,0 +1,135 @@
#![no_std]
#![no_main]
#![feature(type_alias_impl_trait)]
// Example originally designed for stm32f411ceu6 with three A1454 hall effect sensors, connected to I2C1, 2 and 3
// on the pins referenced in the peripheral definitions.
// Pins and DMA peripherals changed to compile for stm32f429zi, to work with the CI.
// MUST be compiled in release mode to see actual performance, otherwise the async transactions take 2x
// as long to complete as the blocking ones!
use defmt::*;
use embassy_executor::Spawner;
use embassy_stm32::i2c::I2c;
use embassy_stm32::time::Hertz;
use embassy_stm32::{bind_interrupts, i2c, peripherals};
use embassy_time::Instant;
use futures::future::try_join3;
use {defmt_rtt as _, panic_probe as _};
const ADDRESS: u8 = 96;
bind_interrupts!(struct Irqs {
I2C1_EV => i2c::EventInterruptHandler<peripherals::I2C1>;
I2C1_ER => i2c::ErrorInterruptHandler<peripherals::I2C1>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
I2C3_EV => i2c::EventInterruptHandler<peripherals::I2C3>;
I2C3_ER => i2c::ErrorInterruptHandler<peripherals::I2C3>;
});
/// Convert 12-bit signed integer within a 4 byte long buffer into 16-bit signed integer.
fn a1454_buf_to_i16(buffer: &[u8; 4]) -> i16 {
let lower = buffer[3];
let mut upper = buffer[2];
// Fill in additional 1s if the 12 bit number is negative.
if (upper & 0b00001000) == 0b0001000 {
upper = upper | 0b11110000;
}
let mut sensor_value_raw: u16 = lower.into();
sensor_value_raw |= (upper as u16) << 8;
let sensor_value: u16 = sensor_value_raw.into();
let sensor_value = sensor_value as i16;
sensor_value
}
#[embassy_executor::main]
async fn main(_spawner: Spawner) {
info!("Setting up peripherals.");
let p = embassy_stm32::init(Default::default());
let mut i2c1 = I2c::new(
p.I2C1,
p.PB8,
p.PB7,
Irqs,
p.DMA1_CH6,
p.DMA1_CH0,
Hertz(100_000),
Default::default(),
);
let mut i2c2 = I2c::new(
p.I2C2,
p.PB10,
p.PB11,
Irqs,
p.DMA1_CH7,
p.DMA1_CH3,
Hertz(100_000),
Default::default(),
);
let mut i2c3 = I2c::new(
p.I2C3,
p.PA8,
p.PC9,
Irqs,
p.DMA1_CH4,
p.DMA1_CH2,
Hertz(100_000),
Default::default(),
);
let a1454_read_sensor_command = [0x1F];
let mut i2c1_buffer: [u8; 4] = [0, 0, 0, 0];
let mut i2c2_buffer: [u8; 4] = [0, 0, 0, 0];
let mut i2c3_buffer: [u8; 4] = [0, 0, 0, 0];
loop {
// Blocking reads one after the other. Completes in about 2000us.
let blocking_read_start_us = Instant::now().as_micros();
match i2c1.blocking_write_read(ADDRESS, &a1454_read_sensor_command, &mut i2c1_buffer) {
Ok(()) => {}
Err(e) => error!("I2C Error: {:?}", e),
}
match i2c2.blocking_write_read(ADDRESS, &a1454_read_sensor_command, &mut i2c2_buffer) {
Ok(()) => {}
Err(e) => error!("I2C Error: {:?}", e),
}
match i2c3.blocking_write_read(ADDRESS, &a1454_read_sensor_command, &mut i2c3_buffer) {
Ok(()) => {}
Err(e) => error!("I2C Error: {:?}", e),
}
let blocking_read_total_us = Instant::now().as_micros() - blocking_read_start_us;
info!(
"Blocking reads completed in {}us: i2c1: {} i2c2: {} i2c3: {}",
blocking_read_total_us,
a1454_buf_to_i16(&i2c1_buffer),
a1454_buf_to_i16(&i2c2_buffer),
a1454_buf_to_i16(&i2c3_buffer)
);
// Async reads overlapping. Completes in about 1000us.
let async_read_start_us = Instant::now().as_micros();
let i2c1_result = i2c1.write_read(ADDRESS, &a1454_read_sensor_command, &mut i2c1_buffer);
let i2c2_result = i2c2.write_read(ADDRESS, &a1454_read_sensor_command, &mut i2c2_buffer);
let i2c3_result = i2c3.write_read(ADDRESS, &a1454_read_sensor_command, &mut i2c3_buffer);
// Wait for all three transactions to finish, or any one of them to fail.
match try_join3(i2c1_result, i2c2_result, i2c3_result).await {
Ok(_) => {
let async_read_total_us = Instant::now().as_micros() - async_read_start_us;
info!(
"Async reads completed in {}us: i2c1: {} i2c2: {} i2c3: {}",
async_read_total_us,
a1454_buf_to_i16(&i2c1_buffer),
a1454_buf_to_i16(&i2c2_buffer),
a1454_buf_to_i16(&i2c3_buffer)
);
}
Err(e) => error!("I2C Error during async write-read: {}", e),
};
}
}

3
examples/stm32h5/src/bin/i2c.rs
View File

@ -13,7 +13,8 @@ const ADDRESS: u8 = 0x5F;
const WHOAMI: u8 = 0x0F;
bind_interrupts!(struct Irqs {
I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
});
#[embassy_executor::main]

3
examples/stm32h7/src/bin/camera.rs
View File

@ -19,7 +19,8 @@ const HEIGHT: usize = 100;
static mut FRAME: [u32; WIDTH * HEIGHT / 2] = [0u32; WIDTH * HEIGHT / 2];
bind_interrupts!(struct Irqs {
I2C1_EV => i2c::InterruptHandler<peripherals::I2C1>;
I2C1_EV => i2c::EventInterruptHandler<peripherals::I2C1>;
I2C1_ER => i2c::ErrorInterruptHandler<peripherals::I2C1>;
DCMI => dcmi::InterruptHandler<peripherals::DCMI>;
});

3
examples/stm32h7/src/bin/i2c.rs
View File

@ -13,7 +13,8 @@ const ADDRESS: u8 = 0x5F;
const WHOAMI: u8 = 0x0F;
bind_interrupts!(struct Irqs {
I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
});
#[embassy_executor::main]

3
examples/stm32l4/src/bin/i2c.rs
View File

@ -14,7 +14,8 @@ const ADDRESS: u8 = 0x5F;
const WHOAMI: u8 = 0x0F;
bind_interrupts!(struct Irqs {
I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
});
#[embassy_executor::main]

3
examples/stm32l4/src/bin/i2c_blocking_async.rs
View File

@ -16,7 +16,8 @@ const ADDRESS: u8 = 0x5F;
const WHOAMI: u8 = 0x0F;
bind_interrupts!(struct Irqs {
I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
});
#[embassy_executor::main]

3
examples/stm32l4/src/bin/i2c_dma.rs
View File

@ -13,7 +13,8 @@ const ADDRESS: u8 = 0x5F;
const WHOAMI: u8 = 0x0F;
bind_interrupts!(struct Irqs {
I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
});
#[embassy_executor::main]

3
examples/stm32l4/src/bin/spe_adin1110_http_server.rs
View File

@ -40,7 +40,8 @@ use static_cell::make_static;
use {embassy_stm32 as hal, panic_probe as _};
bind_interrupts!(struct Irqs {
I2C3_EV => i2c::InterruptHandler<peripherals::I2C3>;
I2C3_EV => i2c::EventInterruptHandler<peripherals::I2C3>;
I2C3_ER => i2c::ErrorInterruptHandler<peripherals::I2C3>;
RNG => rng::InterruptHandler<peripherals::RNG>;
});