aboutsummaryrefslogtreecommitdiff
path: root/examples
diff options
context:
space:
mode:
Diffstat (limited to 'examples')
-rw-r--r--examples/stm32f1/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32f3/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32f3/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32f4/src/bin/i2c.rs9
-rw-r--r--examples/stm32f4/src/bin/sdmmc.rs10
-rw-r--r--examples/stm32f4/src/bin/usart.rs9
-rw-r--r--examples/stm32f4/src/bin/usart_buffered.rs9
-rw-r--r--examples/stm32f4/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32f4/src/bin/usb_ethernet.rs9
-rw-r--r--examples/stm32f4/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32f7/src/bin/eth.rs9
-rw-r--r--examples/stm32f7/src/bin/sdmmc.rs10
-rw-r--r--examples/stm32f7/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32f7/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32h5/src/bin/eth.rs9
-rw-r--r--examples/stm32h5/src/bin/i2c.rs9
-rw-r--r--examples/stm32h5/src/bin/usart.rs9
-rw-r--r--examples/stm32h5/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32h5/src/bin/usart_split.rs9
-rw-r--r--examples/stm32h5/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32h7/src/bin/camera.rs14
-rw-r--r--examples/stm32h7/src/bin/eth.rs9
-rw-r--r--examples/stm32h7/src/bin/eth_client.rs9
-rw-r--r--examples/stm32h7/src/bin/i2c.rs9
-rw-r--r--examples/stm32h7/src/bin/sdmmc.rs10
-rw-r--r--examples/stm32h7/src/bin/usart.rs9
-rw-r--r--examples/stm32h7/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32h7/src/bin/usart_split.rs9
-rw-r--r--examples/stm32h7/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32l0/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32l0/src/bin/usart_irq.rs9
-rw-r--r--examples/stm32l4/src/bin/i2c.rs9
-rw-r--r--examples/stm32l4/src/bin/i2c_blocking_async.rs9
-rw-r--r--examples/stm32l4/src/bin/i2c_dma.rs9
-rw-r--r--examples/stm32l4/src/bin/usart.rs9
-rw-r--r--examples/stm32l4/src/bin/usart_dma.rs9
-rw-r--r--examples/stm32l4/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32l5/src/bin/usb_ethernet.rs9
-rw-r--r--examples/stm32l5/src/bin/usb_hid_mouse.rs9
-rw-r--r--examples/stm32l5/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32u5/src/bin/usb_serial.rs9
-rw-r--r--examples/stm32wb/src/bin/tl_mbox.rs12
-rw-r--r--examples/stm32wb/src/bin/tl_mbox_tx_rx.rs12
-rw-r--r--examples/stm32wl/src/bin/lora_lorawan.rs12
-rw-r--r--examples/stm32wl/src/bin/lora_p2p_receive.rs12
-rw-r--r--examples/stm32wl/src/bin/lora_p2p_send.rs12
-rw-r--r--examples/stm32wl/src/bin/uart_async.rs15
47 files changed, 292 insertions, 160 deletions
diff --git a/examples/stm32f1/src/bin/usb_serial.rs b/examples/stm32f1/src/bin/usb_serial.rs
index 07cad84ef..663099ff7 100644
--- a/examples/stm32f1/src/bin/usb_serial.rs
+++ b/examples/stm32f1/src/bin/usb_serial.rs
@@ -8,13 +8,17 @@ use embassy_futures::join::join;
8use embassy_stm32::gpio::{Level, Output, Speed}; 8use embassy_stm32::gpio::{Level, Output, Speed};
9use embassy_stm32::time::Hertz; 9use embassy_stm32::time::Hertz;
10use embassy_stm32::usb::{Driver, Instance}; 10use embassy_stm32::usb::{Driver, Instance};
11use embassy_stm32::{interrupt, Config}; 11use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
12use embassy_time::{Duration, Timer}; 12use embassy_time::{Duration, Timer};
13use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 13use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
14use embassy_usb::driver::EndpointError; 14use embassy_usb::driver::EndpointError;
15use embassy_usb::Builder; 15use embassy_usb::Builder;
16use {defmt_rtt as _, panic_probe as _}; 16use {defmt_rtt as _, panic_probe as _};
17 17
18bind_interrupts!(struct Irqs {
19 USB_LP_CAN1_RX0 => usb::InterruptHandler<peripherals::USB>;
20});
21
18#[embassy_executor::main] 22#[embassy_executor::main]
19async fn main(_spawner: Spawner) { 23async fn main(_spawner: Spawner) {
20 let mut config = Config::default(); 24 let mut config = Config::default();
@@ -35,8 +39,7 @@ async fn main(_spawner: Spawner) {
35 } 39 }
36 40
37 // Create the driver, from the HAL. 41 // Create the driver, from the HAL.
38 let irq = interrupt::take!(USB_LP_CAN1_RX0); 42 let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
39 let driver = Driver::new(p.USB, irq, p.PA12, p.PA11);
40 43
41 // Create embassy-usb Config 44 // Create embassy-usb Config
42 let config = embassy_usb::Config::new(0xc0de, 0xcafe); 45 let config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32f3/src/bin/usart_dma.rs b/examples/stm32f3/src/bin/usart_dma.rs
index 47121acf1..85f01a69e 100644
--- a/examples/stm32f3/src/bin/usart_dma.rs
+++ b/examples/stm32f3/src/bin/usart_dma.rs
@@ -7,19 +7,22 @@ use core::fmt::Write;
7use defmt::*; 7use defmt::*;
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_stm32::dma::NoDma; 9use embassy_stm32::dma::NoDma;
10use embassy_stm32::interrupt;
11use embassy_stm32::usart::{Config, Uart}; 10use embassy_stm32::usart::{Config, Uart};
11use embassy_stm32::{bind_interrupts, peripherals, usart};
12use heapless::String; 12use heapless::String;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs {
16 USART1 => usart::InterruptHandler<peripherals::USART1>;
17});
18
15#[embassy_executor::main] 19#[embassy_executor::main]
16async fn main(_spawner: Spawner) { 20async fn main(_spawner: Spawner) {
17 let p = embassy_stm32::init(Default::default()); 21 let p = embassy_stm32::init(Default::default());
18 info!("Hello World!"); 22 info!("Hello World!");
19 23
20 let config = Config::default(); 24 let config = Config::default();
21 let irq = interrupt::take!(USART1); 25 let mut usart = Uart::new(p.USART1, p.PE1, p.PE0, Irqs, p.DMA1_CH4, NoDma, config);
22 let mut usart = Uart::new(p.USART1, p.PE1, p.PE0, irq, p.DMA1_CH4, NoDma, config);
23 26
24 for n in 0u32.. { 27 for n in 0u32.. {
25 let mut s: String<128> = String::new(); 28 let mut s: String<128> = String::new();
diff --git a/examples/stm32f3/src/bin/usb_serial.rs b/examples/stm32f3/src/bin/usb_serial.rs
index 5b4e0a91a..f15f333b7 100644
--- a/examples/stm32f3/src/bin/usb_serial.rs
+++ b/examples/stm32f3/src/bin/usb_serial.rs
@@ -8,13 +8,17 @@ use embassy_futures::join::join;
8use embassy_stm32::gpio::{Level, Output, Speed}; 8use embassy_stm32::gpio::{Level, Output, Speed};
9use embassy_stm32::time::mhz; 9use embassy_stm32::time::mhz;
10use embassy_stm32::usb::{Driver, Instance}; 10use embassy_stm32::usb::{Driver, Instance};
11use embassy_stm32::{interrupt, Config}; 11use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
12use embassy_time::{Duration, Timer}; 12use embassy_time::{Duration, Timer};
13use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 13use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
14use embassy_usb::driver::EndpointError; 14use embassy_usb::driver::EndpointError;
15use embassy_usb::Builder; 15use embassy_usb::Builder;
16use {defmt_rtt as _, panic_probe as _}; 16use {defmt_rtt as _, panic_probe as _};
17 17
18bind_interrupts!(struct Irqs {
19 USB_LP_CAN_RX0 => usb::InterruptHandler<peripherals::USB>;
20});
21
18#[embassy_executor::main] 22#[embassy_executor::main]
19async fn main(_spawner: Spawner) { 23async fn main(_spawner: Spawner) {
20 let mut config = Config::default(); 24 let mut config = Config::default();
@@ -33,8 +37,7 @@ async fn main(_spawner: Spawner) {
33 dp_pullup.set_high(); 37 dp_pullup.set_high();
34 38
35 // Create the driver, from the HAL. 39 // Create the driver, from the HAL.
36 let irq = interrupt::take!(USB_LP_CAN_RX0); 40 let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
37 let driver = Driver::new(p.USB, irq, p.PA12, p.PA11);
38 41
39 // Create embassy-usb Config 42 // Create embassy-usb Config
40 let config = embassy_usb::Config::new(0xc0de, 0xcafe); 43 let config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32f4/src/bin/i2c.rs b/examples/stm32f4/src/bin/i2c.rs
index f8ae0890c..a92957325 100644
--- a/examples/stm32f4/src/bin/i2c.rs
+++ b/examples/stm32f4/src/bin/i2c.rs
@@ -6,25 +6,28 @@ use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::dma::NoDma; 7use embassy_stm32::dma::NoDma;
8use embassy_stm32::i2c::{Error, I2c, TimeoutI2c}; 8use embassy_stm32::i2c::{Error, I2c, TimeoutI2c};
9use embassy_stm32::interrupt;
10use embassy_stm32::time::Hertz; 9use embassy_stm32::time::Hertz;
10use embassy_stm32::{bind_interrupts, i2c, peripherals};
11use embassy_time::Duration; 11use embassy_time::Duration;
12use {defmt_rtt as _, panic_probe as _}; 12use {defmt_rtt as _, panic_probe as _};
13 13
14const ADDRESS: u8 = 0x5F; 14const ADDRESS: u8 = 0x5F;
15const WHOAMI: u8 = 0x0F; 15const WHOAMI: u8 = 0x0F;
16 16
17bind_interrupts!(struct Irqs {
18 I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
19});
20
17#[embassy_executor::main] 21#[embassy_executor::main]
18async fn main(_spawner: Spawner) { 22async fn main(_spawner: Spawner) {
19 info!("Hello world!"); 23 info!("Hello world!");
20 let p = embassy_stm32::init(Default::default()); 24 let p = embassy_stm32::init(Default::default());
21 25
22 let irq = interrupt::take!(I2C2_EV);
23 let mut i2c = I2c::new( 26 let mut i2c = I2c::new(
24 p.I2C2, 27 p.I2C2,
25 p.PB10, 28 p.PB10,
26 p.PB11, 29 p.PB11,
27 irq, 30 Irqs,
28 NoDma, 31 NoDma,
29 NoDma, 32 NoDma,
30 Hertz(100_000), 33 Hertz(100_000),
diff --git a/examples/stm32f4/src/bin/sdmmc.rs b/examples/stm32f4/src/bin/sdmmc.rs
index eeecbd321..6ec7d0fec 100644
--- a/examples/stm32f4/src/bin/sdmmc.rs
+++ b/examples/stm32f4/src/bin/sdmmc.rs
@@ -6,13 +6,17 @@ use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::sdmmc::{DataBlock, Sdmmc}; 7use embassy_stm32::sdmmc::{DataBlock, Sdmmc};
8use embassy_stm32::time::mhz; 8use embassy_stm32::time::mhz;
9use embassy_stm32::{interrupt, Config}; 9use embassy_stm32::{bind_interrupts, peripherals, sdmmc, Config};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12/// This is a safeguard to not overwrite any data on the SD card. 12/// This is a safeguard to not overwrite any data on the SD card.
13/// If you don't care about SD card contents, set this to `true` to test writes. 13/// If you don't care about SD card contents, set this to `true` to test writes.
14const ALLOW_WRITES: bool = false; 14const ALLOW_WRITES: bool = false;
15 15
16bind_interrupts!(struct Irqs {
17 SDIO => sdmmc::InterruptHandler<peripherals::SDIO>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 let mut config = Config::default(); 22 let mut config = Config::default();
@@ -21,11 +25,9 @@ async fn main(_spawner: Spawner) {
21 let p = embassy_stm32::init(config); 25 let p = embassy_stm32::init(config);
22 info!("Hello World!"); 26 info!("Hello World!");
23 27
24 let irq = interrupt::take!(SDIO);
25
26 let mut sdmmc = Sdmmc::new_4bit( 28 let mut sdmmc = Sdmmc::new_4bit(
27 p.SDIO, 29 p.SDIO,
28 irq, 30 Irqs,
29 p.DMA2_CH3, 31 p.DMA2_CH3,
30 p.PC12, 32 p.PC12,
31 p.PD2, 33 p.PD2,
diff --git a/examples/stm32f4/src/bin/usart.rs b/examples/stm32f4/src/bin/usart.rs
index 8f41bb6c4..7680fe845 100644
--- a/examples/stm32f4/src/bin/usart.rs
+++ b/examples/stm32f4/src/bin/usart.rs
@@ -5,10 +5,14 @@
5use cortex_m_rt::entry; 5use cortex_m_rt::entry;
6use defmt::*; 6use defmt::*;
7use embassy_stm32::dma::NoDma; 7use embassy_stm32::dma::NoDma;
8use embassy_stm32::interrupt;
9use embassy_stm32::usart::{Config, Uart}; 8use embassy_stm32::usart::{Config, Uart};
9use embassy_stm32::{bind_interrupts, peripherals, usart};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12bind_interrupts!(struct Irqs {
13 USART3 => usart::InterruptHandler<peripherals::USART3>;
14});
15
12#[entry] 16#[entry]
13fn main() -> ! { 17fn main() -> ! {
14 info!("Hello World!"); 18 info!("Hello World!");
@@ -16,8 +20,7 @@ fn main() -> ! {
16 let p = embassy_stm32::init(Default::default()); 20 let p = embassy_stm32::init(Default::default());
17 21
18 let config = Config::default(); 22 let config = Config::default();
19 let irq = interrupt::take!(USART3); 23 let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, Irqs, NoDma, NoDma, config);
20 let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, irq, NoDma, NoDma, config);
21 24
22 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); 25 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
23 info!("wrote Hello, starting echo"); 26 info!("wrote Hello, starting echo");
diff --git a/examples/stm32f4/src/bin/usart_buffered.rs b/examples/stm32f4/src/bin/usart_buffered.rs
index a93f8baeb..c573dc3a3 100644
--- a/examples/stm32f4/src/bin/usart_buffered.rs
+++ b/examples/stm32f4/src/bin/usart_buffered.rs
@@ -4,11 +4,15 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::interrupt;
8use embassy_stm32::usart::{BufferedUart, Config}; 7use embassy_stm32::usart::{BufferedUart, Config};
8use embassy_stm32::{bind_interrupts, peripherals, usart};
9use embedded_io::asynch::BufRead; 9use embedded_io::asynch::BufRead;
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12bind_interrupts!(struct Irqs {
13 USART3 => usart::BufferedInterruptHandler<peripherals::USART3>;
14});
15
12#[embassy_executor::main] 16#[embassy_executor::main]
13async fn main(_spawner: Spawner) { 17async fn main(_spawner: Spawner) {
14 let p = embassy_stm32::init(Default::default()); 18 let p = embassy_stm32::init(Default::default());
@@ -16,10 +20,9 @@ async fn main(_spawner: Spawner) {
16 20
17 let config = Config::default(); 21 let config = Config::default();
18 22
19 let irq = interrupt::take!(USART3);
20 let mut tx_buf = [0u8; 32]; 23 let mut tx_buf = [0u8; 32];
21 let mut rx_buf = [0u8; 32]; 24 let mut rx_buf = [0u8; 32];
22 let mut buf_usart = BufferedUart::new(p.USART3, irq, p.PD9, p.PD8, &mut tx_buf, &mut rx_buf, config); 25 let mut buf_usart = BufferedUart::new(p.USART3, Irqs, p.PD9, p.PD8, &mut tx_buf, &mut rx_buf, config);
23 26
24 loop { 27 loop {
25 let buf = buf_usart.fill_buf().await.unwrap(); 28 let buf = buf_usart.fill_buf().await.unwrap();
diff --git a/examples/stm32f4/src/bin/usart_dma.rs b/examples/stm32f4/src/bin/usart_dma.rs
index 78baeaa0d..3408ec370 100644
--- a/examples/stm32f4/src/bin/usart_dma.rs
+++ b/examples/stm32f4/src/bin/usart_dma.rs
@@ -7,19 +7,22 @@ use core::fmt::Write;
7use defmt::*; 7use defmt::*;
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_stm32::dma::NoDma; 9use embassy_stm32::dma::NoDma;
10use embassy_stm32::interrupt;
11use embassy_stm32::usart::{Config, Uart}; 10use embassy_stm32::usart::{Config, Uart};
11use embassy_stm32::{bind_interrupts, peripherals, usart};
12use heapless::String; 12use heapless::String;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs {
16 USART3 => usart::InterruptHandler<peripherals::USART3>;
17});
18
15#[embassy_executor::main] 19#[embassy_executor::main]
16async fn main(_spawner: Spawner) { 20async fn main(_spawner: Spawner) {
17 let p = embassy_stm32::init(Default::default()); 21 let p = embassy_stm32::init(Default::default());
18 info!("Hello World!"); 22 info!("Hello World!");
19 23
20 let config = Config::default(); 24 let config = Config::default();
21 let irq = interrupt::take!(USART3); 25 let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, Irqs, p.DMA1_CH3, NoDma, config);
22 let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, irq, p.DMA1_CH3, NoDma, config);
23 26
24 for n in 0u32.. { 27 for n in 0u32.. {
25 let mut s: String<128> = String::new(); 28 let mut s: String<128> = String::new();
diff --git a/examples/stm32f4/src/bin/usb_ethernet.rs b/examples/stm32f4/src/bin/usb_ethernet.rs
index 9131e5896..c4e395f0f 100644
--- a/examples/stm32f4/src/bin/usb_ethernet.rs
+++ b/examples/stm32f4/src/bin/usb_ethernet.rs
@@ -9,7 +9,7 @@ use embassy_net::{Stack, StackResources};
9use embassy_stm32::rng::Rng; 9use embassy_stm32::rng::Rng;
10use embassy_stm32::time::mhz; 10use embassy_stm32::time::mhz;
11use embassy_stm32::usb_otg::Driver; 11use embassy_stm32::usb_otg::Driver;
12use embassy_stm32::{interrupt, Config}; 12use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
13use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState}; 13use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState};
14use embassy_usb::class::cdc_ncm::{CdcNcmClass, State}; 14use embassy_usb::class::cdc_ncm::{CdcNcmClass, State};
15use embassy_usb::{Builder, UsbDevice}; 15use embassy_usb::{Builder, UsbDevice};
@@ -45,6 +45,10 @@ async fn net_task(stack: &'static Stack<Device<'static, MTU>>) -> ! {
45 stack.run().await 45 stack.run().await
46} 46}
47 47
48bind_interrupts!(struct Irqs {
49 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>;
50});
51
48#[embassy_executor::main] 52#[embassy_executor::main]
49async fn main(spawner: Spawner) { 53async fn main(spawner: Spawner) {
50 info!("Hello World!"); 54 info!("Hello World!");
@@ -56,9 +60,8 @@ async fn main(spawner: Spawner) {
56 let p = embassy_stm32::init(config); 60 let p = embassy_stm32::init(config);
57 61
58 // Create the driver, from the HAL. 62 // Create the driver, from the HAL.
59 let irq = interrupt::take!(OTG_FS);
60 let ep_out_buffer = &mut singleton!([0; 256])[..]; 63 let ep_out_buffer = &mut singleton!([0; 256])[..];
61 let driver = Driver::new_fs(p.USB_OTG_FS, irq, p.PA12, p.PA11, ep_out_buffer); 64 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, ep_out_buffer);
62 65
63 // Create embassy-usb Config 66 // Create embassy-usb Config
64 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 67 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32f4/src/bin/usb_serial.rs b/examples/stm32f4/src/bin/usb_serial.rs
index d2b1dca43..f8f5940a7 100644
--- a/examples/stm32f4/src/bin/usb_serial.rs
+++ b/examples/stm32f4/src/bin/usb_serial.rs
@@ -6,13 +6,17 @@ use defmt::{panic, *};
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::time::mhz; 7use embassy_stm32::time::mhz;
8use embassy_stm32::usb_otg::{Driver, Instance}; 8use embassy_stm32::usb_otg::{Driver, Instance};
9use embassy_stm32::{interrupt, Config}; 9use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
10use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 10use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
11use embassy_usb::driver::EndpointError; 11use embassy_usb::driver::EndpointError;
12use embassy_usb::Builder; 12use embassy_usb::Builder;
13use futures::future::join; 13use futures::future::join;
14use {defmt_rtt as _, panic_probe as _}; 14use {defmt_rtt as _, panic_probe as _};
15 15
16bind_interrupts!(struct Irqs {
17 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 info!("Hello World!"); 22 info!("Hello World!");
@@ -24,9 +28,8 @@ async fn main(_spawner: Spawner) {
24 let p = embassy_stm32::init(config); 28 let p = embassy_stm32::init(config);
25 29
26 // Create the driver, from the HAL. 30 // Create the driver, from the HAL.
27 let irq = interrupt::take!(OTG_FS);
28 let mut ep_out_buffer = [0u8; 256]; 31 let mut ep_out_buffer = [0u8; 256];
29 let driver = Driver::new_fs(p.USB_OTG_FS, irq, p.PA12, p.PA11, &mut ep_out_buffer); 32 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer);
30 33
31 // Create embassy-usb Config 34 // Create embassy-usb Config
32 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 35 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32f7/src/bin/eth.rs b/examples/stm32f7/src/bin/eth.rs
index b947361ac..6d286c368 100644
--- a/examples/stm32f7/src/bin/eth.rs
+++ b/examples/stm32f7/src/bin/eth.rs
@@ -11,7 +11,7 @@ use embassy_stm32::eth::{Ethernet, PacketQueue};
11use embassy_stm32::peripherals::ETH; 11use embassy_stm32::peripherals::ETH;
12use embassy_stm32::rng::Rng; 12use embassy_stm32::rng::Rng;
13use embassy_stm32::time::mhz; 13use embassy_stm32::time::mhz;
14use embassy_stm32::{interrupt, Config}; 14use embassy_stm32::{bind_interrupts, eth, Config};
15use embassy_time::{Duration, Timer}; 15use embassy_time::{Duration, Timer};
16use embedded_io::asynch::Write; 16use embedded_io::asynch::Write;
17use rand_core::RngCore; 17use rand_core::RngCore;
@@ -27,6 +27,10 @@ macro_rules! singleton {
27 }}; 27 }};
28} 28}
29 29
30bind_interrupts!(struct Irqs {
31 ETH => eth::InterruptHandler;
32});
33
30type Device = Ethernet<'static, ETH, GenericSMI>; 34type Device = Ethernet<'static, ETH, GenericSMI>;
31 35
32#[embassy_executor::task] 36#[embassy_executor::task]
@@ -48,13 +52,12 @@ async fn main(spawner: Spawner) -> ! {
48 rng.fill_bytes(&mut seed); 52 rng.fill_bytes(&mut seed);
49 let seed = u64::from_le_bytes(seed); 53 let seed = u64::from_le_bytes(seed);
50 54
51 let eth_int = interrupt::take!(ETH);
52 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]; 55 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
53 56
54 let device = Ethernet::new( 57 let device = Ethernet::new(
55 singleton!(PacketQueue::<16, 16>::new()), 58 singleton!(PacketQueue::<16, 16>::new()),
56 p.ETH, 59 p.ETH,
57 eth_int, 60 Irqs,
58 p.PA1, 61 p.PA1,
59 p.PA2, 62 p.PA2,
60 p.PC1, 63 p.PC1,
diff --git a/examples/stm32f7/src/bin/sdmmc.rs b/examples/stm32f7/src/bin/sdmmc.rs
index c050a4002..9d43892a0 100644
--- a/examples/stm32f7/src/bin/sdmmc.rs
+++ b/examples/stm32f7/src/bin/sdmmc.rs
@@ -6,9 +6,13 @@ use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::sdmmc::Sdmmc; 7use embassy_stm32::sdmmc::Sdmmc;
8use embassy_stm32::time::mhz; 8use embassy_stm32::time::mhz;
9use embassy_stm32::{interrupt, Config}; 9use embassy_stm32::{bind_interrupts, peripherals, sdmmc, Config};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12bind_interrupts!(struct Irqs {
13 SDMMC1 => sdmmc::InterruptHandler<peripherals::SDMMC1>;
14});
15
12#[embassy_executor::main] 16#[embassy_executor::main]
13async fn main(_spawner: Spawner) { 17async fn main(_spawner: Spawner) {
14 let mut config = Config::default(); 18 let mut config = Config::default();
@@ -18,11 +22,9 @@ async fn main(_spawner: Spawner) {
18 22
19 info!("Hello World!"); 23 info!("Hello World!");
20 24
21 let irq = interrupt::take!(SDMMC1);
22
23 let mut sdmmc = Sdmmc::new_4bit( 25 let mut sdmmc = Sdmmc::new_4bit(
24 p.SDMMC1, 26 p.SDMMC1,
25 irq, 27 Irqs,
26 p.DMA2_CH3, 28 p.DMA2_CH3,
27 p.PC12, 29 p.PC12,
28 p.PD2, 30 p.PD2,
diff --git a/examples/stm32f7/src/bin/usart_dma.rs b/examples/stm32f7/src/bin/usart_dma.rs
index 4827c52ae..4700287a7 100644
--- a/examples/stm32f7/src/bin/usart_dma.rs
+++ b/examples/stm32f7/src/bin/usart_dma.rs
@@ -7,17 +7,20 @@ use core::fmt::Write;
7use defmt::*; 7use defmt::*;
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_stm32::dma::NoDma; 9use embassy_stm32::dma::NoDma;
10use embassy_stm32::interrupt;
11use embassy_stm32::usart::{Config, Uart}; 10use embassy_stm32::usart::{Config, Uart};
11use embassy_stm32::{bind_interrupts, peripherals, usart};
12use heapless::String; 12use heapless::String;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs {
16 UART7 => usart::InterruptHandler<peripherals::UART7>;
17});
18
15#[embassy_executor::main] 19#[embassy_executor::main]
16async fn main(_spawner: Spawner) { 20async fn main(_spawner: Spawner) {
17 let p = embassy_stm32::init(Default::default()); 21 let p = embassy_stm32::init(Default::default());
18 let config = Config::default(); 22 let config = Config::default();
19 let irq = interrupt::take!(UART7); 23 let mut usart = Uart::new(p.UART7, p.PA8, p.PA15, Irqs, p.DMA1_CH1, NoDma, config);
20 let mut usart = Uart::new(p.UART7, p.PA8, p.PA15, irq, p.DMA1_CH1, NoDma, config);
21 24
22 for n in 0u32.. { 25 for n in 0u32.. {
23 let mut s: String<128> = String::new(); 26 let mut s: String<128> = String::new();
diff --git a/examples/stm32f7/src/bin/usb_serial.rs b/examples/stm32f7/src/bin/usb_serial.rs
index dca90d9cb..763309ce2 100644
--- a/examples/stm32f7/src/bin/usb_serial.rs
+++ b/examples/stm32f7/src/bin/usb_serial.rs
@@ -6,13 +6,17 @@ use defmt::{panic, *};
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::time::mhz; 7use embassy_stm32::time::mhz;
8use embassy_stm32::usb_otg::{Driver, Instance}; 8use embassy_stm32::usb_otg::{Driver, Instance};
9use embassy_stm32::{interrupt, Config}; 9use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
10use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 10use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
11use embassy_usb::driver::EndpointError; 11use embassy_usb::driver::EndpointError;
12use embassy_usb::Builder; 12use embassy_usb::Builder;
13use futures::future::join; 13use futures::future::join;
14use {defmt_rtt as _, panic_probe as _}; 14use {defmt_rtt as _, panic_probe as _};
15 15
16bind_interrupts!(struct Irqs {
17 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 info!("Hello World!"); 22 info!("Hello World!");
@@ -25,9 +29,8 @@ async fn main(_spawner: Spawner) {
25 let p = embassy_stm32::init(config); 29 let p = embassy_stm32::init(config);
26 30
27 // Create the driver, from the HAL. 31 // Create the driver, from the HAL.
28 let irq = interrupt::take!(OTG_FS);
29 let mut ep_out_buffer = [0u8; 256]; 32 let mut ep_out_buffer = [0u8; 256];
30 let driver = Driver::new_fs(p.USB_OTG_FS, irq, p.PA12, p.PA11, &mut ep_out_buffer); 33 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer);
31 34
32 // Create embassy-usb Config 35 // Create embassy-usb Config
33 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 36 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32h5/src/bin/eth.rs b/examples/stm32h5/src/bin/eth.rs
index b2e252fc7..fa1f225fe 100644
--- a/examples/stm32h5/src/bin/eth.rs
+++ b/examples/stm32h5/src/bin/eth.rs
@@ -12,7 +12,7 @@ use embassy_stm32::peripherals::ETH;
12use embassy_stm32::rcc::{AHBPrescaler, APBPrescaler, Hse, HseMode, Pll, PllSource, Sysclk, VoltageScale}; 12use embassy_stm32::rcc::{AHBPrescaler, APBPrescaler, Hse, HseMode, Pll, PllSource, Sysclk, VoltageScale};
13use embassy_stm32::rng::Rng; 13use embassy_stm32::rng::Rng;
14use embassy_stm32::time::Hertz; 14use embassy_stm32::time::Hertz;
15use embassy_stm32::{interrupt, Config}; 15use embassy_stm32::{bind_interrupts, eth, Config};
16use embassy_time::{Duration, Timer}; 16use embassy_time::{Duration, Timer};
17use embedded_io::asynch::Write; 17use embedded_io::asynch::Write;
18use rand_core::RngCore; 18use rand_core::RngCore;
@@ -28,6 +28,10 @@ macro_rules! singleton {
28 }}; 28 }};
29} 29}
30 30
31bind_interrupts!(struct Irqs {
32 ETH => eth::InterruptHandler;
33});
34
31type Device = Ethernet<'static, ETH, GenericSMI>; 35type Device = Ethernet<'static, ETH, GenericSMI>;
32 36
33#[embassy_executor::task] 37#[embassy_executor::task]
@@ -67,13 +71,12 @@ async fn main(spawner: Spawner) -> ! {
67 rng.fill_bytes(&mut seed); 71 rng.fill_bytes(&mut seed);
68 let seed = u64::from_le_bytes(seed); 72 let seed = u64::from_le_bytes(seed);
69 73
70 let eth_int = interrupt::take!(ETH);
71 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]; 74 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
72 75
73 let device = Ethernet::new( 76 let device = Ethernet::new(
74 singleton!(PacketQueue::<4, 4>::new()), 77 singleton!(PacketQueue::<4, 4>::new()),
75 p.ETH, 78 p.ETH,
76 eth_int, 79 Irqs,
77 p.PA1, 80 p.PA1,
78 p.PA2, 81 p.PA2,
79 p.PC1, 82 p.PC1,
diff --git a/examples/stm32h5/src/bin/i2c.rs b/examples/stm32h5/src/bin/i2c.rs
index 6cbf58bbc..8b6fe71ae 100644
--- a/examples/stm32h5/src/bin/i2c.rs
+++ b/examples/stm32h5/src/bin/i2c.rs
@@ -5,25 +5,28 @@
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::i2c::{Error, I2c, TimeoutI2c}; 7use embassy_stm32::i2c::{Error, I2c, TimeoutI2c};
8use embassy_stm32::interrupt;
9use embassy_stm32::time::Hertz; 8use embassy_stm32::time::Hertz;
9use embassy_stm32::{bind_interrupts, i2c, peripherals};
10use embassy_time::Duration; 10use embassy_time::Duration;
11use {defmt_rtt as _, panic_probe as _}; 11use {defmt_rtt as _, panic_probe as _};
12 12
13const ADDRESS: u8 = 0x5F; 13const ADDRESS: u8 = 0x5F;
14const WHOAMI: u8 = 0x0F; 14const WHOAMI: u8 = 0x0F;
15 15
16bind_interrupts!(struct Irqs {
17 I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 info!("Hello world!"); 22 info!("Hello world!");
19 let p = embassy_stm32::init(Default::default()); 23 let p = embassy_stm32::init(Default::default());
20 24
21 let irq = interrupt::take!(I2C2_EV);
22 let mut i2c = I2c::new( 25 let mut i2c = I2c::new(
23 p.I2C2, 26 p.I2C2,
24 p.PB10, 27 p.PB10,
25 p.PB11, 28 p.PB11,
26 irq, 29 Irqs,
27 p.GPDMA1_CH4, 30 p.GPDMA1_CH4,
28 p.GPDMA1_CH5, 31 p.GPDMA1_CH5,
29 Hertz(100_000), 32 Hertz(100_000),
diff --git a/examples/stm32h5/src/bin/usart.rs b/examples/stm32h5/src/bin/usart.rs
index 405f18ec7..0abb94abb 100644
--- a/examples/stm32h5/src/bin/usart.rs
+++ b/examples/stm32h5/src/bin/usart.rs
@@ -6,18 +6,21 @@ use cortex_m_rt::entry;
6use defmt::*; 6use defmt::*;
7use embassy_executor::Executor; 7use embassy_executor::Executor;
8use embassy_stm32::dma::NoDma; 8use embassy_stm32::dma::NoDma;
9use embassy_stm32::interrupt;
10use embassy_stm32::usart::{Config, Uart}; 9use embassy_stm32::usart::{Config, Uart};
10use embassy_stm32::{bind_interrupts, peripherals, usart};
11use static_cell::StaticCell; 11use static_cell::StaticCell;
12use {defmt_rtt as _, panic_probe as _}; 12use {defmt_rtt as _, panic_probe as _};
13 13
14bind_interrupts!(struct Irqs {
15 UART7 => usart::InterruptHandler<peripherals::UART7>;
16});
17
14#[embassy_executor::task] 18#[embassy_executor::task]
15async fn main_task() { 19async fn main_task() {
16 let p = embassy_stm32::init(Default::default()); 20 let p = embassy_stm32::init(Default::default());
17 21
18 let config = Config::default(); 22 let config = Config::default();
19 let irq = interrupt::take!(UART7); 23 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, NoDma, NoDma, config);
20 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, irq, NoDma, NoDma, config);
21 24
22 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); 25 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
23 info!("wrote Hello, starting echo"); 26 info!("wrote Hello, starting echo");
diff --git a/examples/stm32h5/src/bin/usart_dma.rs b/examples/stm32h5/src/bin/usart_dma.rs
index 43d791aae..48264f884 100644
--- a/examples/stm32h5/src/bin/usart_dma.rs
+++ b/examples/stm32h5/src/bin/usart_dma.rs
@@ -8,19 +8,22 @@ use cortex_m_rt::entry;
8use defmt::*; 8use defmt::*;
9use embassy_executor::Executor; 9use embassy_executor::Executor;
10use embassy_stm32::dma::NoDma; 10use embassy_stm32::dma::NoDma;
11use embassy_stm32::interrupt;
12use embassy_stm32::usart::{Config, Uart}; 11use embassy_stm32::usart::{Config, Uart};
12use embassy_stm32::{bind_interrupts, peripherals, usart};
13use heapless::String; 13use heapless::String;
14use static_cell::StaticCell; 14use static_cell::StaticCell;
15use {defmt_rtt as _, panic_probe as _}; 15use {defmt_rtt as _, panic_probe as _};
16 16
17bind_interrupts!(struct Irqs {
18 UART7 => usart::InterruptHandler<peripherals::UART7>;
19});
20
17#[embassy_executor::task] 21#[embassy_executor::task]
18async fn main_task() { 22async fn main_task() {
19 let p = embassy_stm32::init(Default::default()); 23 let p = embassy_stm32::init(Default::default());
20 24
21 let config = Config::default(); 25 let config = Config::default();
22 let irq = interrupt::take!(UART7); 26 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.GPDMA1_CH0, NoDma, config);
23 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, irq, p.GPDMA1_CH0, NoDma, config);
24 27
25 for n in 0u32.. { 28 for n in 0u32.. {
26 let mut s: String<128> = String::new(); 29 let mut s: String<128> = String::new();
diff --git a/examples/stm32h5/src/bin/usart_split.rs b/examples/stm32h5/src/bin/usart_split.rs
index 16a499582..debd6f454 100644
--- a/examples/stm32h5/src/bin/usart_split.rs
+++ b/examples/stm32h5/src/bin/usart_split.rs
@@ -5,13 +5,17 @@
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::dma::NoDma; 7use embassy_stm32::dma::NoDma;
8use embassy_stm32::interrupt;
9use embassy_stm32::peripherals::{GPDMA1_CH1, UART7}; 8use embassy_stm32::peripherals::{GPDMA1_CH1, UART7};
10use embassy_stm32::usart::{Config, Uart, UartRx}; 9use embassy_stm32::usart::{Config, Uart, UartRx};
10use embassy_stm32::{bind_interrupts, peripherals, usart};
11use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex; 11use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
12use embassy_sync::channel::Channel; 12use embassy_sync::channel::Channel;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs {
16 UART7 => usart::InterruptHandler<peripherals::UART7>;
17});
18
15#[embassy_executor::task] 19#[embassy_executor::task]
16async fn writer(mut usart: Uart<'static, UART7, NoDma, NoDma>) { 20async fn writer(mut usart: Uart<'static, UART7, NoDma, NoDma>) {
17 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); 21 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
@@ -32,8 +36,7 @@ async fn main(spawner: Spawner) -> ! {
32 info!("Hello World!"); 36 info!("Hello World!");
33 37
34 let config = Config::default(); 38 let config = Config::default();
35 let irq = interrupt::take!(UART7); 39 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.GPDMA1_CH0, p.GPDMA1_CH1, config);
36 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, irq, p.GPDMA1_CH0, p.GPDMA1_CH1, config);
37 unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n")); 40 unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n"));
38 41
39 let (mut tx, rx) = usart.split(); 42 let (mut tx, rx) = usart.split();
diff --git a/examples/stm32h5/src/bin/usb_serial.rs b/examples/stm32h5/src/bin/usb_serial.rs
index 4f987cbd1..3912327e2 100644
--- a/examples/stm32h5/src/bin/usb_serial.rs
+++ b/examples/stm32h5/src/bin/usb_serial.rs
@@ -7,13 +7,17 @@ use embassy_executor::Spawner;
7use embassy_stm32::rcc::{AHBPrescaler, APBPrescaler, Hse, HseMode, Pll, PllSource, Sysclk, VoltageScale}; 7use embassy_stm32::rcc::{AHBPrescaler, APBPrescaler, Hse, HseMode, Pll, PllSource, Sysclk, VoltageScale};
8use embassy_stm32::time::Hertz; 8use embassy_stm32::time::Hertz;
9use embassy_stm32::usb::{Driver, Instance}; 9use embassy_stm32::usb::{Driver, Instance};
10use embassy_stm32::{interrupt, pac, Config}; 10use embassy_stm32::{bind_interrupts, pac, peripherals, usb, Config};
11use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 11use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
12use embassy_usb::driver::EndpointError; 12use embassy_usb::driver::EndpointError;
13use embassy_usb::Builder; 13use embassy_usb::Builder;
14use futures::future::join; 14use futures::future::join;
15use {defmt_rtt as _, panic_probe as _}; 15use {defmt_rtt as _, panic_probe as _};
16 16
17bind_interrupts!(struct Irqs {
18 USB_DRD_FS => usb::InterruptHandler<peripherals::USB>;
19});
20
17#[embassy_executor::main] 21#[embassy_executor::main]
18async fn main(_spawner: Spawner) { 22async fn main(_spawner: Spawner) {
19 let mut config = Config::default(); 23 let mut config = Config::default();
@@ -48,8 +52,7 @@ async fn main(_spawner: Spawner) {
48 } 52 }
49 53
50 // Create the driver, from the HAL. 54 // Create the driver, from the HAL.
51 let irq = interrupt::take!(USB_DRD_FS); 55 let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
52 let driver = Driver::new(p.USB, irq, p.PA12, p.PA11);
53 56
54 // Create embassy-usb Config 57 // Create embassy-usb Config
55 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 58 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32h7/src/bin/camera.rs b/examples/stm32h7/src/bin/camera.rs
index 9c443b83a..6f75a0630 100644
--- a/examples/stm32h7/src/bin/camera.rs
+++ b/examples/stm32h7/src/bin/camera.rs
@@ -8,7 +8,7 @@ use embassy_stm32::gpio::{Level, Output, Speed};
8use embassy_stm32::i2c::I2c; 8use embassy_stm32::i2c::I2c;
9use embassy_stm32::rcc::{Mco, Mco1Source, McoClock}; 9use embassy_stm32::rcc::{Mco, Mco1Source, McoClock};
10use embassy_stm32::time::{khz, mhz}; 10use embassy_stm32::time::{khz, mhz};
11use embassy_stm32::{interrupt, Config}; 11use embassy_stm32::{bind_interrupts, i2c, peripherals, Config};
12use embassy_time::{Duration, Timer}; 12use embassy_time::{Duration, Timer};
13use ov7725::*; 13use ov7725::*;
14use {defmt_rtt as _, panic_probe as _}; 14use {defmt_rtt as _, panic_probe as _};
@@ -18,6 +18,11 @@ const HEIGHT: usize = 100;
18 18
19static mut FRAME: [u32; WIDTH * HEIGHT / 2] = [0u32; WIDTH * HEIGHT / 2]; 19static mut FRAME: [u32; WIDTH * HEIGHT / 2] = [0u32; WIDTH * HEIGHT / 2];
20 20
21bind_interrupts!(struct Irqs {
22 I2C1_EV => i2c::InterruptHandler<peripherals::I2C1>;
23 DCMI => dcmi::InterruptHandler<peripherals::DCMI>;
24});
25
21#[embassy_executor::main] 26#[embassy_executor::main]
22async fn main(_spawner: Spawner) { 27async fn main(_spawner: Spawner) {
23 let mut config = Config::default(); 28 let mut config = Config::default();
@@ -34,12 +39,11 @@ async fn main(_spawner: Spawner) {
34 let mco = Mco::new(p.MCO1, p.PA8, Mco1Source::Hsi, McoClock::Divided(3)); 39 let mco = Mco::new(p.MCO1, p.PA8, Mco1Source::Hsi, McoClock::Divided(3));
35 40
36 let mut led = Output::new(p.PE3, Level::High, Speed::Low); 41 let mut led = Output::new(p.PE3, Level::High, Speed::Low);
37 let i2c_irq = interrupt::take!(I2C1_EV);
38 let cam_i2c = I2c::new( 42 let cam_i2c = I2c::new(
39 p.I2C1, 43 p.I2C1,
40 p.PB8, 44 p.PB8,
41 p.PB9, 45 p.PB9,
42 i2c_irq, 46 Irqs,
43 p.DMA1_CH1, 47 p.DMA1_CH1,
44 p.DMA1_CH2, 48 p.DMA1_CH2,
45 khz(100), 49 khz(100),
@@ -55,11 +59,9 @@ async fn main(_spawner: Spawner) {
55 59
56 defmt::info!("manufacturer: 0x{:x}, pid: 0x{:x}", manufacturer_id, camera_id); 60 defmt::info!("manufacturer: 0x{:x}, pid: 0x{:x}", manufacturer_id, camera_id);
57 61
58 let dcmi_irq = interrupt::take!(DCMI);
59 let config = dcmi::Config::default(); 62 let config = dcmi::Config::default();
60 let mut dcmi = Dcmi::new_8bit( 63 let mut dcmi = Dcmi::new_8bit(
61 p.DCMI, p.DMA1_CH0, dcmi_irq, p.PC6, p.PC7, p.PE0, p.PE1, p.PE4, p.PD3, p.PE5, p.PE6, p.PB7, p.PA4, p.PA6, 64 p.DCMI, p.DMA1_CH0, Irqs, p.PC6, p.PC7, p.PE0, p.PE1, p.PE4, p.PD3, p.PE5, p.PE6, p.PB7, p.PA4, p.PA6, config,
62 config,
63 ); 65 );
64 66
65 defmt::info!("attempting capture"); 67 defmt::info!("attempting capture");
diff --git a/examples/stm32h7/src/bin/eth.rs b/examples/stm32h7/src/bin/eth.rs
index 61bb7e37b..dbfc90cf4 100644
--- a/examples/stm32h7/src/bin/eth.rs
+++ b/examples/stm32h7/src/bin/eth.rs
@@ -11,7 +11,7 @@ use embassy_stm32::eth::{Ethernet, PacketQueue};
11use embassy_stm32::peripherals::ETH; 11use embassy_stm32::peripherals::ETH;
12use embassy_stm32::rng::Rng; 12use embassy_stm32::rng::Rng;
13use embassy_stm32::time::mhz; 13use embassy_stm32::time::mhz;
14use embassy_stm32::{interrupt, Config}; 14use embassy_stm32::{bind_interrupts, eth, Config};
15use embassy_time::{Duration, Timer}; 15use embassy_time::{Duration, Timer};
16use embedded_io::asynch::Write; 16use embedded_io::asynch::Write;
17use rand_core::RngCore; 17use rand_core::RngCore;
@@ -27,6 +27,10 @@ macro_rules! singleton {
27 }}; 27 }};
28} 28}
29 29
30bind_interrupts!(struct Irqs {
31 ETH => eth::InterruptHandler;
32});
33
30type Device = Ethernet<'static, ETH, GenericSMI>; 34type Device = Ethernet<'static, ETH, GenericSMI>;
31 35
32#[embassy_executor::task] 36#[embassy_executor::task]
@@ -49,13 +53,12 @@ async fn main(spawner: Spawner) -> ! {
49 rng.fill_bytes(&mut seed); 53 rng.fill_bytes(&mut seed);
50 let seed = u64::from_le_bytes(seed); 54 let seed = u64::from_le_bytes(seed);
51 55
52 let eth_int = interrupt::take!(ETH);
53 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]; 56 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
54 57
55 let device = Ethernet::new( 58 let device = Ethernet::new(
56 singleton!(PacketQueue::<16, 16>::new()), 59 singleton!(PacketQueue::<16, 16>::new()),
57 p.ETH, 60 p.ETH,
58 eth_int, 61 Irqs,
59 p.PA1, 62 p.PA1,
60 p.PA2, 63 p.PA2,
61 p.PC1, 64 p.PC1,
diff --git a/examples/stm32h7/src/bin/eth_client.rs b/examples/stm32h7/src/bin/eth_client.rs
index b609fa5df..14e6b7914 100644
--- a/examples/stm32h7/src/bin/eth_client.rs
+++ b/examples/stm32h7/src/bin/eth_client.rs
@@ -11,7 +11,7 @@ use embassy_stm32::eth::{Ethernet, PacketQueue};
11use embassy_stm32::peripherals::ETH; 11use embassy_stm32::peripherals::ETH;
12use embassy_stm32::rng::Rng; 12use embassy_stm32::rng::Rng;
13use embassy_stm32::time::mhz; 13use embassy_stm32::time::mhz;
14use embassy_stm32::{interrupt, Config}; 14use embassy_stm32::{bind_interrupts, eth, Config};
15use embassy_time::{Duration, Timer}; 15use embassy_time::{Duration, Timer};
16use embedded_io::asynch::Write; 16use embedded_io::asynch::Write;
17use embedded_nal_async::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpConnect}; 17use embedded_nal_async::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpConnect};
@@ -28,6 +28,10 @@ macro_rules! singleton {
28 }}; 28 }};
29} 29}
30 30
31bind_interrupts!(struct Irqs {
32 ETH => eth::InterruptHandler;
33});
34
31type Device = Ethernet<'static, ETH, GenericSMI>; 35type Device = Ethernet<'static, ETH, GenericSMI>;
32 36
33#[embassy_executor::task] 37#[embassy_executor::task]
@@ -50,13 +54,12 @@ async fn main(spawner: Spawner) -> ! {
50 rng.fill_bytes(&mut seed); 54 rng.fill_bytes(&mut seed);
51 let seed = u64::from_le_bytes(seed); 55 let seed = u64::from_le_bytes(seed);
52 56
53 let eth_int = interrupt::take!(ETH);
54 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]; 57 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
55 58
56 let device = Ethernet::new( 59 let device = Ethernet::new(
57 singleton!(PacketQueue::<16, 16>::new()), 60 singleton!(PacketQueue::<16, 16>::new()),
58 p.ETH, 61 p.ETH,
59 eth_int, 62 Irqs,
60 p.PA1, 63 p.PA1,
61 p.PA2, 64 p.PA2,
62 p.PC1, 65 p.PC1,
diff --git a/examples/stm32h7/src/bin/i2c.rs b/examples/stm32h7/src/bin/i2c.rs
index 78e03f014..c2979c59b 100644
--- a/examples/stm32h7/src/bin/i2c.rs
+++ b/examples/stm32h7/src/bin/i2c.rs
@@ -5,25 +5,28 @@
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::i2c::{Error, I2c, TimeoutI2c}; 7use embassy_stm32::i2c::{Error, I2c, TimeoutI2c};
8use embassy_stm32::interrupt;
9use embassy_stm32::time::Hertz; 8use embassy_stm32::time::Hertz;
9use embassy_stm32::{bind_interrupts, i2c, peripherals};
10use embassy_time::Duration; 10use embassy_time::Duration;
11use {defmt_rtt as _, panic_probe as _}; 11use {defmt_rtt as _, panic_probe as _};
12 12
13const ADDRESS: u8 = 0x5F; 13const ADDRESS: u8 = 0x5F;
14const WHOAMI: u8 = 0x0F; 14const WHOAMI: u8 = 0x0F;
15 15
16bind_interrupts!(struct Irqs {
17 I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 info!("Hello world!"); 22 info!("Hello world!");
19 let p = embassy_stm32::init(Default::default()); 23 let p = embassy_stm32::init(Default::default());
20 24
21 let irq = interrupt::take!(I2C2_EV);
22 let mut i2c = I2c::new( 25 let mut i2c = I2c::new(
23 p.I2C2, 26 p.I2C2,
24 p.PB10, 27 p.PB10,
25 p.PB11, 28 p.PB11,
26 irq, 29 Irqs,
27 p.DMA1_CH4, 30 p.DMA1_CH4,
28 p.DMA1_CH5, 31 p.DMA1_CH5,
29 Hertz(100_000), 32 Hertz(100_000),
diff --git a/examples/stm32h7/src/bin/sdmmc.rs b/examples/stm32h7/src/bin/sdmmc.rs
index 26d1db01e..ce91b6b1c 100644
--- a/examples/stm32h7/src/bin/sdmmc.rs
+++ b/examples/stm32h7/src/bin/sdmmc.rs
@@ -6,9 +6,13 @@ use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::sdmmc::Sdmmc; 7use embassy_stm32::sdmmc::Sdmmc;
8use embassy_stm32::time::mhz; 8use embassy_stm32::time::mhz;
9use embassy_stm32::{interrupt, Config}; 9use embassy_stm32::{bind_interrupts, peripherals, sdmmc, Config};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12bind_interrupts!(struct Irqs {
13 SDMMC1 => sdmmc::InterruptHandler<peripherals::SDMMC1>;
14});
15
12#[embassy_executor::main] 16#[embassy_executor::main]
13async fn main(_spawner: Spawner) -> ! { 17async fn main(_spawner: Spawner) -> ! {
14 let mut config = Config::default(); 18 let mut config = Config::default();
@@ -16,11 +20,9 @@ async fn main(_spawner: Spawner) -> ! {
16 let p = embassy_stm32::init(config); 20 let p = embassy_stm32::init(config);
17 info!("Hello World!"); 21 info!("Hello World!");
18 22
19 let irq = interrupt::take!(SDMMC1);
20
21 let mut sdmmc = Sdmmc::new_4bit( 23 let mut sdmmc = Sdmmc::new_4bit(
22 p.SDMMC1, 24 p.SDMMC1,
23 irq, 25 Irqs,
24 p.PC12, 26 p.PC12,
25 p.PD2, 27 p.PD2,
26 p.PC8, 28 p.PC8,
diff --git a/examples/stm32h7/src/bin/usart.rs b/examples/stm32h7/src/bin/usart.rs
index 405f18ec7..0abb94abb 100644
--- a/examples/stm32h7/src/bin/usart.rs
+++ b/examples/stm32h7/src/bin/usart.rs
@@ -6,18 +6,21 @@ use cortex_m_rt::entry;
6use defmt::*; 6use defmt::*;
7use embassy_executor::Executor; 7use embassy_executor::Executor;
8use embassy_stm32::dma::NoDma; 8use embassy_stm32::dma::NoDma;
9use embassy_stm32::interrupt;
10use embassy_stm32::usart::{Config, Uart}; 9use embassy_stm32::usart::{Config, Uart};
10use embassy_stm32::{bind_interrupts, peripherals, usart};
11use static_cell::StaticCell; 11use static_cell::StaticCell;
12use {defmt_rtt as _, panic_probe as _}; 12use {defmt_rtt as _, panic_probe as _};
13 13
14bind_interrupts!(struct Irqs {
15 UART7 => usart::InterruptHandler<peripherals::UART7>;
16});
17
14#[embassy_executor::task] 18#[embassy_executor::task]
15async fn main_task() { 19async fn main_task() {
16 let p = embassy_stm32::init(Default::default()); 20 let p = embassy_stm32::init(Default::default());
17 21
18 let config = Config::default(); 22 let config = Config::default();
19 let irq = interrupt::take!(UART7); 23 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, NoDma, NoDma, config);
20 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, irq, NoDma, NoDma, config);
21 24
22 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); 25 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
23 info!("wrote Hello, starting echo"); 26 info!("wrote Hello, starting echo");
diff --git a/examples/stm32h7/src/bin/usart_dma.rs b/examples/stm32h7/src/bin/usart_dma.rs
index 6e3491e55..f1fe7fce6 100644
--- a/examples/stm32h7/src/bin/usart_dma.rs
+++ b/examples/stm32h7/src/bin/usart_dma.rs
@@ -8,19 +8,22 @@ use cortex_m_rt::entry;
8use defmt::*; 8use defmt::*;
9use embassy_executor::Executor; 9use embassy_executor::Executor;
10use embassy_stm32::dma::NoDma; 10use embassy_stm32::dma::NoDma;
11use embassy_stm32::interrupt;
12use embassy_stm32::usart::{Config, Uart}; 11use embassy_stm32::usart::{Config, Uart};
12use embassy_stm32::{bind_interrupts, peripherals, usart};
13use heapless::String; 13use heapless::String;
14use static_cell::StaticCell; 14use static_cell::StaticCell;
15use {defmt_rtt as _, panic_probe as _}; 15use {defmt_rtt as _, panic_probe as _};
16 16
17bind_interrupts!(struct Irqs {
18 UART7 => usart::InterruptHandler<peripherals::UART7>;
19});
20
17#[embassy_executor::task] 21#[embassy_executor::task]
18async fn main_task() { 22async fn main_task() {
19 let p = embassy_stm32::init(Default::default()); 23 let p = embassy_stm32::init(Default::default());
20 24
21 let config = Config::default(); 25 let config = Config::default();
22 let irq = interrupt::take!(UART7); 26 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.DMA1_CH0, NoDma, config);
23 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, irq, p.DMA1_CH0, NoDma, config);
24 27
25 for n in 0u32.. { 28 for n in 0u32.. {
26 let mut s: String<128> = String::new(); 29 let mut s: String<128> = String::new();
diff --git a/examples/stm32h7/src/bin/usart_split.rs b/examples/stm32h7/src/bin/usart_split.rs
index f97176ecb..330d1ce09 100644
--- a/examples/stm32h7/src/bin/usart_split.rs
+++ b/examples/stm32h7/src/bin/usart_split.rs
@@ -5,13 +5,17 @@
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::dma::NoDma; 7use embassy_stm32::dma::NoDma;
8use embassy_stm32::interrupt;
9use embassy_stm32::peripherals::{DMA1_CH1, UART7}; 8use embassy_stm32::peripherals::{DMA1_CH1, UART7};
10use embassy_stm32::usart::{Config, Uart, UartRx}; 9use embassy_stm32::usart::{Config, Uart, UartRx};
10use embassy_stm32::{bind_interrupts, peripherals, usart};
11use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex; 11use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
12use embassy_sync::channel::Channel; 12use embassy_sync::channel::Channel;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs {
16 UART7 => usart::InterruptHandler<peripherals::UART7>;
17});
18
15#[embassy_executor::task] 19#[embassy_executor::task]
16async fn writer(mut usart: Uart<'static, UART7, NoDma, NoDma>) { 20async fn writer(mut usart: Uart<'static, UART7, NoDma, NoDma>) {
17 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); 21 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
@@ -32,8 +36,7 @@ async fn main(spawner: Spawner) -> ! {
32 info!("Hello World!"); 36 info!("Hello World!");
33 37
34 let config = Config::default(); 38 let config = Config::default();
35 let irq = interrupt::take!(UART7); 39 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.DMA1_CH0, p.DMA1_CH1, config);
36 let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, irq, p.DMA1_CH0, p.DMA1_CH1, config);
37 unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n")); 40 unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n"));
38 41
39 let (mut tx, rx) = usart.split(); 42 let (mut tx, rx) = usart.split();
diff --git a/examples/stm32h7/src/bin/usb_serial.rs b/examples/stm32h7/src/bin/usb_serial.rs
index 475af116d..c622f19f7 100644
--- a/examples/stm32h7/src/bin/usb_serial.rs
+++ b/examples/stm32h7/src/bin/usb_serial.rs
@@ -6,13 +6,17 @@ use defmt::{panic, *};
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::time::mhz; 7use embassy_stm32::time::mhz;
8use embassy_stm32::usb_otg::{Driver, Instance}; 8use embassy_stm32::usb_otg::{Driver, Instance};
9use embassy_stm32::{interrupt, Config}; 9use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
10use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 10use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
11use embassy_usb::driver::EndpointError; 11use embassy_usb::driver::EndpointError;
12use embassy_usb::Builder; 12use embassy_usb::Builder;
13use futures::future::join; 13use futures::future::join;
14use {defmt_rtt as _, panic_probe as _}; 14use {defmt_rtt as _, panic_probe as _};
15 15
16bind_interrupts!(struct Irqs {
17 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 info!("Hello World!"); 22 info!("Hello World!");
@@ -24,9 +28,8 @@ async fn main(_spawner: Spawner) {
24 let p = embassy_stm32::init(config); 28 let p = embassy_stm32::init(config);
25 29
26 // Create the driver, from the HAL. 30 // Create the driver, from the HAL.
27 let irq = interrupt::take!(OTG_FS);
28 let mut ep_out_buffer = [0u8; 256]; 31 let mut ep_out_buffer = [0u8; 256];
29 let driver = Driver::new_fs(p.USB_OTG_FS, irq, p.PA12, p.PA11, &mut ep_out_buffer); 32 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer);
30 33
31 // Create embassy-usb Config 34 // Create embassy-usb Config
32 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 35 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32l0/src/bin/usart_dma.rs b/examples/stm32l0/src/bin/usart_dma.rs
index c307f857a..eae8f3452 100644
--- a/examples/stm32l0/src/bin/usart_dma.rs
+++ b/examples/stm32l0/src/bin/usart_dma.rs
@@ -4,15 +4,18 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::interrupt;
8use embassy_stm32::usart::{Config, Uart}; 7use embassy_stm32::usart::{Config, Uart};
8use embassy_stm32::{bind_interrupts, peripherals, usart};
9use {defmt_rtt as _, panic_probe as _}; 9use {defmt_rtt as _, panic_probe as _};
10 10
11bind_interrupts!(struct Irqs {
12 USART1 => usart::InterruptHandler<peripherals::USART1>;
13});
14
11#[embassy_executor::main] 15#[embassy_executor::main]
12async fn main(_spawner: Spawner) { 16async fn main(_spawner: Spawner) {
13 let p = embassy_stm32::init(Default::default()); 17 let p = embassy_stm32::init(Default::default());
14 let irq = interrupt::take!(USART1); 18 let mut usart = Uart::new(p.USART1, p.PB7, p.PB6, Irqs, p.DMA1_CH2, p.DMA1_CH3, Config::default());
15 let mut usart = Uart::new(p.USART1, p.PB7, p.PB6, irq, p.DMA1_CH2, p.DMA1_CH3, Config::default());
16 19
17 usart.write(b"Hello Embassy World!\r\n").await.unwrap(); 20 usart.write(b"Hello Embassy World!\r\n").await.unwrap();
18 info!("wrote Hello, starting echo"); 21 info!("wrote Hello, starting echo");
diff --git a/examples/stm32l0/src/bin/usart_irq.rs b/examples/stm32l0/src/bin/usart_irq.rs
index 465347004..f2c72a107 100644
--- a/examples/stm32l0/src/bin/usart_irq.rs
+++ b/examples/stm32l0/src/bin/usart_irq.rs
@@ -4,11 +4,15 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::interrupt;
8use embassy_stm32::usart::{BufferedUart, Config}; 7use embassy_stm32::usart::{BufferedUart, Config};
8use embassy_stm32::{bind_interrupts, peripherals, usart};
9use embedded_io::asynch::{Read, Write}; 9use embedded_io::asynch::{Read, Write};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12bind_interrupts!(struct Irqs {
13 USART2 => usart::BufferedInterruptHandler<peripherals::USART2>;
14});
15
12#[embassy_executor::main] 16#[embassy_executor::main]
13async fn main(_spawner: Spawner) { 17async fn main(_spawner: Spawner) {
14 let p = embassy_stm32::init(Default::default()); 18 let p = embassy_stm32::init(Default::default());
@@ -20,8 +24,7 @@ async fn main(_spawner: Spawner) {
20 let mut config = Config::default(); 24 let mut config = Config::default();
21 config.baudrate = 9600; 25 config.baudrate = 9600;
22 26
23 let irq = interrupt::take!(USART2); 27 let mut usart = unsafe { BufferedUart::new(p.USART2, Irqs, p.PA3, p.PA2, &mut TX_BUFFER, &mut RX_BUFFER, config) };
24 let mut usart = unsafe { BufferedUart::new(p.USART2, irq, p.PA3, p.PA2, &mut TX_BUFFER, &mut RX_BUFFER, config) };
25 28
26 usart.write_all(b"Hello Embassy World!\r\n").await.unwrap(); 29 usart.write_all(b"Hello Embassy World!\r\n").await.unwrap();
27 info!("wrote Hello, starting echo"); 30 info!("wrote Hello, starting echo");
diff --git a/examples/stm32l4/src/bin/i2c.rs b/examples/stm32l4/src/bin/i2c.rs
index d40d6803d..d0060d20c 100644
--- a/examples/stm32l4/src/bin/i2c.rs
+++ b/examples/stm32l4/src/bin/i2c.rs
@@ -6,22 +6,25 @@ use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::dma::NoDma; 7use embassy_stm32::dma::NoDma;
8use embassy_stm32::i2c::I2c; 8use embassy_stm32::i2c::I2c;
9use embassy_stm32::interrupt;
10use embassy_stm32::time::Hertz; 9use embassy_stm32::time::Hertz;
10use embassy_stm32::{bind_interrupts, i2c, peripherals};
11use {defmt_rtt as _, panic_probe as _}; 11use {defmt_rtt as _, panic_probe as _};
12 12
13const ADDRESS: u8 = 0x5F; 13const ADDRESS: u8 = 0x5F;
14const WHOAMI: u8 = 0x0F; 14const WHOAMI: u8 = 0x0F;
15 15
16bind_interrupts!(struct Irqs {
17 I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 let p = embassy_stm32::init(Default::default()); 22 let p = embassy_stm32::init(Default::default());
19 let irq = interrupt::take!(I2C2_EV);
20 let mut i2c = I2c::new( 23 let mut i2c = I2c::new(
21 p.I2C2, 24 p.I2C2,
22 p.PB10, 25 p.PB10,
23 p.PB11, 26 p.PB11,
24 irq, 27 Irqs,
25 NoDma, 28 NoDma,
26 NoDma, 29 NoDma,
27 Hertz(100_000), 30 Hertz(100_000),
diff --git a/examples/stm32l4/src/bin/i2c_blocking_async.rs b/examples/stm32l4/src/bin/i2c_blocking_async.rs
index d868cac01..eca59087b 100644
--- a/examples/stm32l4/src/bin/i2c_blocking_async.rs
+++ b/examples/stm32l4/src/bin/i2c_blocking_async.rs
@@ -7,23 +7,26 @@ use embassy_embedded_hal::adapter::BlockingAsync;
7use embassy_executor::Spawner; 7use embassy_executor::Spawner;
8use embassy_stm32::dma::NoDma; 8use embassy_stm32::dma::NoDma;
9use embassy_stm32::i2c::I2c; 9use embassy_stm32::i2c::I2c;
10use embassy_stm32::interrupt;
11use embassy_stm32::time::Hertz; 10use embassy_stm32::time::Hertz;
11use embassy_stm32::{bind_interrupts, i2c, peripherals};
12use embedded_hal_async::i2c::I2c as I2cTrait; 12use embedded_hal_async::i2c::I2c as I2cTrait;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15const ADDRESS: u8 = 0x5F; 15const ADDRESS: u8 = 0x5F;
16const WHOAMI: u8 = 0x0F; 16const WHOAMI: u8 = 0x0F;
17 17
18bind_interrupts!(struct Irqs {
19 I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
20});
21
18#[embassy_executor::main] 22#[embassy_executor::main]
19async fn main(_spawner: Spawner) { 23async fn main(_spawner: Spawner) {
20 let p = embassy_stm32::init(Default::default()); 24 let p = embassy_stm32::init(Default::default());
21 let irq = interrupt::take!(I2C2_EV);
22 let i2c = I2c::new( 25 let i2c = I2c::new(
23 p.I2C2, 26 p.I2C2,
24 p.PB10, 27 p.PB10,
25 p.PB11, 28 p.PB11,
26 irq, 29 Irqs,
27 NoDma, 30 NoDma,
28 NoDma, 31 NoDma,
29 Hertz(100_000), 32 Hertz(100_000),
diff --git a/examples/stm32l4/src/bin/i2c_dma.rs b/examples/stm32l4/src/bin/i2c_dma.rs
index 7e62ee637..cf6f3da67 100644
--- a/examples/stm32l4/src/bin/i2c_dma.rs
+++ b/examples/stm32l4/src/bin/i2c_dma.rs
@@ -5,22 +5,25 @@
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::i2c::I2c; 7use embassy_stm32::i2c::I2c;
8use embassy_stm32::interrupt;
9use embassy_stm32::time::Hertz; 8use embassy_stm32::time::Hertz;
9use embassy_stm32::{bind_interrupts, i2c, peripherals};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12const ADDRESS: u8 = 0x5F; 12const ADDRESS: u8 = 0x5F;
13const WHOAMI: u8 = 0x0F; 13const WHOAMI: u8 = 0x0F;
14 14
15bind_interrupts!(struct Irqs {
16 I2C2_EV => i2c::InterruptHandler<peripherals::I2C2>;
17});
18
15#[embassy_executor::main] 19#[embassy_executor::main]
16async fn main(_spawner: Spawner) { 20async fn main(_spawner: Spawner) {
17 let p = embassy_stm32::init(Default::default()); 21 let p = embassy_stm32::init(Default::default());
18 let irq = interrupt::take!(I2C2_EV);
19 let mut i2c = I2c::new( 22 let mut i2c = I2c::new(
20 p.I2C2, 23 p.I2C2,
21 p.PB10, 24 p.PB10,
22 p.PB11, 25 p.PB11,
23 irq, 26 Irqs,
24 p.DMA1_CH4, 27 p.DMA1_CH4,
25 p.DMA1_CH5, 28 p.DMA1_CH5,
26 Hertz(100_000), 29 Hertz(100_000),
diff --git a/examples/stm32l4/src/bin/usart.rs b/examples/stm32l4/src/bin/usart.rs
index 7d874d9d7..beb5ec558 100644
--- a/examples/stm32l4/src/bin/usart.rs
+++ b/examples/stm32l4/src/bin/usart.rs
@@ -4,10 +4,14 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_stm32::dma::NoDma; 6use embassy_stm32::dma::NoDma;
7use embassy_stm32::interrupt;
8use embassy_stm32::usart::{Config, Uart}; 7use embassy_stm32::usart::{Config, Uart};
8use embassy_stm32::{bind_interrupts, peripherals, usart};
9use {defmt_rtt as _, panic_probe as _}; 9use {defmt_rtt as _, panic_probe as _};
10 10
11bind_interrupts!(struct Irqs {
12 UART4 => usart::InterruptHandler<peripherals::UART4>;
13});
14
11#[cortex_m_rt::entry] 15#[cortex_m_rt::entry]
12fn main() -> ! { 16fn main() -> ! {
13 info!("Hello World!"); 17 info!("Hello World!");
@@ -15,8 +19,7 @@ fn main() -> ! {
15 let p = embassy_stm32::init(Default::default()); 19 let p = embassy_stm32::init(Default::default());
16 20
17 let config = Config::default(); 21 let config = Config::default();
18 let irq = interrupt::take!(UART4); 22 let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, Irqs, NoDma, NoDma, config);
19 let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, irq, NoDma, NoDma, config);
20 23
21 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); 24 unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
22 info!("wrote Hello, starting echo"); 25 info!("wrote Hello, starting echo");
diff --git a/examples/stm32l4/src/bin/usart_dma.rs b/examples/stm32l4/src/bin/usart_dma.rs
index 452bede30..b7d4cb01e 100644
--- a/examples/stm32l4/src/bin/usart_dma.rs
+++ b/examples/stm32l4/src/bin/usart_dma.rs
@@ -7,19 +7,22 @@ use core::fmt::Write;
7use defmt::*; 7use defmt::*;
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_stm32::dma::NoDma; 9use embassy_stm32::dma::NoDma;
10use embassy_stm32::interrupt;
11use embassy_stm32::usart::{Config, Uart}; 10use embassy_stm32::usart::{Config, Uart};
11use embassy_stm32::{bind_interrupts, peripherals, usart};
12use heapless::String; 12use heapless::String;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs {
16 UART4 => usart::InterruptHandler<peripherals::UART4>;
17});
18
15#[embassy_executor::main] 19#[embassy_executor::main]
16async fn main(_spawner: Spawner) { 20async fn main(_spawner: Spawner) {
17 let p = embassy_stm32::init(Default::default()); 21 let p = embassy_stm32::init(Default::default());
18 info!("Hello World!"); 22 info!("Hello World!");
19 23
20 let config = Config::default(); 24 let config = Config::default();
21 let irq = interrupt::take!(UART4); 25 let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, Irqs, p.DMA1_CH3, NoDma, config);
22 let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, irq, p.DMA1_CH3, NoDma, config);
23 26
24 for n in 0u32.. { 27 for n in 0u32.. {
25 let mut s: String<128> = String::new(); 28 let mut s: String<128> = String::new();
diff --git a/examples/stm32l4/src/bin/usb_serial.rs b/examples/stm32l4/src/bin/usb_serial.rs
index bdb290e63..80811a43e 100644
--- a/examples/stm32l4/src/bin/usb_serial.rs
+++ b/examples/stm32l4/src/bin/usb_serial.rs
@@ -7,13 +7,17 @@ use defmt_rtt as _; // global logger
7use embassy_executor::Spawner; 7use embassy_executor::Spawner;
8use embassy_stm32::rcc::*; 8use embassy_stm32::rcc::*;
9use embassy_stm32::usb_otg::{Driver, Instance}; 9use embassy_stm32::usb_otg::{Driver, Instance};
10use embassy_stm32::{interrupt, Config}; 10use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
11use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 11use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
12use embassy_usb::driver::EndpointError; 12use embassy_usb::driver::EndpointError;
13use embassy_usb::Builder; 13use embassy_usb::Builder;
14use futures::future::join; 14use futures::future::join;
15use panic_probe as _; 15use panic_probe as _;
16 16
17bind_interrupts!(struct Irqs {
18 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>;
19});
20
17#[embassy_executor::main] 21#[embassy_executor::main]
18async fn main(_spawner: Spawner) { 22async fn main(_spawner: Spawner) {
19 info!("Hello World!"); 23 info!("Hello World!");
@@ -25,9 +29,8 @@ async fn main(_spawner: Spawner) {
25 let p = embassy_stm32::init(config); 29 let p = embassy_stm32::init(config);
26 30
27 // Create the driver, from the HAL. 31 // Create the driver, from the HAL.
28 let irq = interrupt::take!(OTG_FS);
29 let mut ep_out_buffer = [0u8; 256]; 32 let mut ep_out_buffer = [0u8; 256];
30 let driver = Driver::new_fs(p.USB_OTG_FS, irq, p.PA12, p.PA11, &mut ep_out_buffer); 33 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer);
31 34
32 // Create embassy-usb Config 35 // Create embassy-usb Config
33 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 36 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32l5/src/bin/usb_ethernet.rs b/examples/stm32l5/src/bin/usb_ethernet.rs
index 6c5645a41..b84e53d3a 100644
--- a/examples/stm32l5/src/bin/usb_ethernet.rs
+++ b/examples/stm32l5/src/bin/usb_ethernet.rs
@@ -9,7 +9,7 @@ use embassy_net::{Stack, StackResources};
9use embassy_stm32::rcc::*; 9use embassy_stm32::rcc::*;
10use embassy_stm32::rng::Rng; 10use embassy_stm32::rng::Rng;
11use embassy_stm32::usb::Driver; 11use embassy_stm32::usb::Driver;
12use embassy_stm32::{interrupt, Config}; 12use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
13use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState}; 13use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState};
14use embassy_usb::class::cdc_ncm::{CdcNcmClass, State}; 14use embassy_usb::class::cdc_ncm::{CdcNcmClass, State};
15use embassy_usb::{Builder, UsbDevice}; 15use embassy_usb::{Builder, UsbDevice};
@@ -31,6 +31,10 @@ macro_rules! singleton {
31 31
32const MTU: usize = 1514; 32const MTU: usize = 1514;
33 33
34bind_interrupts!(struct Irqs {
35 USB_FS => usb::InterruptHandler<peripherals::USB>;
36});
37
34#[embassy_executor::task] 38#[embassy_executor::task]
35async fn usb_task(mut device: UsbDevice<'static, MyDriver>) -> ! { 39async fn usb_task(mut device: UsbDevice<'static, MyDriver>) -> ! {
36 device.run().await 40 device.run().await
@@ -54,8 +58,7 @@ async fn main(spawner: Spawner) {
54 let p = embassy_stm32::init(config); 58 let p = embassy_stm32::init(config);
55 59
56 // Create the driver, from the HAL. 60 // Create the driver, from the HAL.
57 let irq = interrupt::take!(USB_FS); 61 let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
58 let driver = Driver::new(p.USB, irq, p.PA12, p.PA11);
59 62
60 // Create embassy-usb Config 63 // Create embassy-usb Config
61 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 64 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32l5/src/bin/usb_hid_mouse.rs b/examples/stm32l5/src/bin/usb_hid_mouse.rs
index e3bbe9d09..7e894e407 100644
--- a/examples/stm32l5/src/bin/usb_hid_mouse.rs
+++ b/examples/stm32l5/src/bin/usb_hid_mouse.rs
@@ -7,7 +7,7 @@ use embassy_executor::Spawner;
7use embassy_futures::join::join; 7use embassy_futures::join::join;
8use embassy_stm32::rcc::*; 8use embassy_stm32::rcc::*;
9use embassy_stm32::usb::Driver; 9use embassy_stm32::usb::Driver;
10use embassy_stm32::{interrupt, Config}; 10use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
11use embassy_time::{Duration, Timer}; 11use embassy_time::{Duration, Timer};
12use embassy_usb::class::hid::{HidWriter, ReportId, RequestHandler, State}; 12use embassy_usb::class::hid::{HidWriter, ReportId, RequestHandler, State};
13use embassy_usb::control::OutResponse; 13use embassy_usb::control::OutResponse;
@@ -15,6 +15,10 @@ use embassy_usb::Builder;
15use usbd_hid::descriptor::{MouseReport, SerializedDescriptor}; 15use usbd_hid::descriptor::{MouseReport, SerializedDescriptor};
16use {defmt_rtt as _, panic_probe as _}; 16use {defmt_rtt as _, panic_probe as _};
17 17
18bind_interrupts!(struct Irqs {
19 USB_FS => usb::InterruptHandler<peripherals::USB>;
20});
21
18#[embassy_executor::main] 22#[embassy_executor::main]
19async fn main(_spawner: Spawner) { 23async fn main(_spawner: Spawner) {
20 let mut config = Config::default(); 24 let mut config = Config::default();
@@ -23,8 +27,7 @@ async fn main(_spawner: Spawner) {
23 let p = embassy_stm32::init(config); 27 let p = embassy_stm32::init(config);
24 28
25 // Create the driver, from the HAL. 29 // Create the driver, from the HAL.
26 let irq = interrupt::take!(USB_FS); 30 let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
27 let driver = Driver::new(p.USB, irq, p.PA12, p.PA11);
28 31
29 // Create embassy-usb Config 32 // Create embassy-usb Config
30 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 33 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32l5/src/bin/usb_serial.rs b/examples/stm32l5/src/bin/usb_serial.rs
index 66ccacb73..0c719560f 100644
--- a/examples/stm32l5/src/bin/usb_serial.rs
+++ b/examples/stm32l5/src/bin/usb_serial.rs
@@ -7,12 +7,16 @@ use embassy_executor::Spawner;
7use embassy_futures::join::join; 7use embassy_futures::join::join;
8use embassy_stm32::rcc::*; 8use embassy_stm32::rcc::*;
9use embassy_stm32::usb::{Driver, Instance}; 9use embassy_stm32::usb::{Driver, Instance};
10use embassy_stm32::{interrupt, Config}; 10use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
11use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 11use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
12use embassy_usb::driver::EndpointError; 12use embassy_usb::driver::EndpointError;
13use embassy_usb::Builder; 13use embassy_usb::Builder;
14use {defmt_rtt as _, panic_probe as _}; 14use {defmt_rtt as _, panic_probe as _};
15 15
16bind_interrupts!(struct Irqs {
17 USB_FS => usb::InterruptHandler<peripherals::USB>;
18});
19
16#[embassy_executor::main] 20#[embassy_executor::main]
17async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
18 let mut config = Config::default(); 22 let mut config = Config::default();
@@ -23,8 +27,7 @@ async fn main(_spawner: Spawner) {
23 info!("Hello World!"); 27 info!("Hello World!");
24 28
25 // Create the driver, from the HAL. 29 // Create the driver, from the HAL.
26 let irq = interrupt::take!(USB_FS); 30 let driver = Driver::new(p.USB, Irqs, p.PA12, p.PA11);
27 let driver = Driver::new(p.USB, irq, p.PA12, p.PA11);
28 31
29 // Create embassy-usb Config 32 // Create embassy-usb Config
30 let config = embassy_usb::Config::new(0xc0de, 0xcafe); 33 let config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32u5/src/bin/usb_serial.rs b/examples/stm32u5/src/bin/usb_serial.rs
index 4882cd2e0..f36daf91b 100644
--- a/examples/stm32u5/src/bin/usb_serial.rs
+++ b/examples/stm32u5/src/bin/usb_serial.rs
@@ -7,13 +7,17 @@ use defmt_rtt as _; // global logger
7use embassy_executor::Spawner; 7use embassy_executor::Spawner;
8use embassy_stm32::rcc::*; 8use embassy_stm32::rcc::*;
9use embassy_stm32::usb_otg::{Driver, Instance}; 9use embassy_stm32::usb_otg::{Driver, Instance};
10use embassy_stm32::{interrupt, Config}; 10use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
11use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 11use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
12use embassy_usb::driver::EndpointError; 12use embassy_usb::driver::EndpointError;
13use embassy_usb::Builder; 13use embassy_usb::Builder;
14use futures::future::join; 14use futures::future::join;
15use panic_probe as _; 15use panic_probe as _;
16 16
17bind_interrupts!(struct Irqs {
18 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>;
19});
20
17#[embassy_executor::main] 21#[embassy_executor::main]
18async fn main(_spawner: Spawner) { 22async fn main(_spawner: Spawner) {
19 info!("Hello World!"); 23 info!("Hello World!");
@@ -26,9 +30,8 @@ async fn main(_spawner: Spawner) {
26 let p = embassy_stm32::init(config); 30 let p = embassy_stm32::init(config);
27 31
28 // Create the driver, from the HAL. 32 // Create the driver, from the HAL.
29 let irq = interrupt::take!(OTG_FS);
30 let mut ep_out_buffer = [0u8; 256]; 33 let mut ep_out_buffer = [0u8; 256];
31 let driver = Driver::new_fs(p.USB_OTG_FS, irq, p.PA12, p.PA11, &mut ep_out_buffer); 34 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer);
32 35
33 // Create embassy-usb Config 36 // Create embassy-usb Config
34 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe); 37 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
diff --git a/examples/stm32wb/src/bin/tl_mbox.rs b/examples/stm32wb/src/bin/tl_mbox.rs
index acbc60c87..326e4be85 100644
--- a/examples/stm32wb/src/bin/tl_mbox.rs
+++ b/examples/stm32wb/src/bin/tl_mbox.rs
@@ -4,12 +4,17 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::interrupt;
8use embassy_stm32::ipcc::{Config, Ipcc}; 7use embassy_stm32::ipcc::{Config, Ipcc};
9use embassy_stm32::tl_mbox::TlMbox; 8use embassy_stm32::tl_mbox::TlMbox;
9use embassy_stm32::{bind_interrupts, tl_mbox};
10use embassy_time::{Duration, Timer}; 10use embassy_time::{Duration, Timer};
11use {defmt_rtt as _, panic_probe as _}; 11use {defmt_rtt as _, panic_probe as _};
12 12
13bind_interrupts!(struct Irqs{
14 IPCC_C1_RX => tl_mbox::ReceiveInterruptHandler;
15 IPCC_C1_TX => tl_mbox::TransmitInterruptHandler;
16});
17
13#[embassy_executor::main] 18#[embassy_executor::main]
14async fn main(_spawner: Spawner) { 19async fn main(_spawner: Spawner) {
15 /* 20 /*
@@ -42,10 +47,7 @@ async fn main(_spawner: Spawner) {
42 let config = Config::default(); 47 let config = Config::default();
43 let mut ipcc = Ipcc::new(p.IPCC, config); 48 let mut ipcc = Ipcc::new(p.IPCC, config);
44 49
45 let rx_irq = interrupt::take!(IPCC_C1_RX); 50 let mbox = TlMbox::init(&mut ipcc, Irqs);
46 let tx_irq = interrupt::take!(IPCC_C1_TX);
47
48 let mbox = TlMbox::init(&mut ipcc, rx_irq, tx_irq);
49 51
50 loop { 52 loop {
51 let wireless_fw_info = mbox.wireless_fw_info(); 53 let wireless_fw_info = mbox.wireless_fw_info();
diff --git a/examples/stm32wb/src/bin/tl_mbox_tx_rx.rs b/examples/stm32wb/src/bin/tl_mbox_tx_rx.rs
index 1008e1e41..7a69f26b7 100644
--- a/examples/stm32wb/src/bin/tl_mbox_tx_rx.rs
+++ b/examples/stm32wb/src/bin/tl_mbox_tx_rx.rs
@@ -4,11 +4,16 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::interrupt;
8use embassy_stm32::ipcc::{Config, Ipcc}; 7use embassy_stm32::ipcc::{Config, Ipcc};
9use embassy_stm32::tl_mbox::TlMbox; 8use embassy_stm32::tl_mbox::TlMbox;
9use embassy_stm32::{bind_interrupts, tl_mbox};
10use {defmt_rtt as _, panic_probe as _}; 10use {defmt_rtt as _, panic_probe as _};
11 11
12bind_interrupts!(struct Irqs{
13 IPCC_C1_RX => tl_mbox::ReceiveInterruptHandler;
14 IPCC_C1_TX => tl_mbox::TransmitInterruptHandler;
15});
16
12#[embassy_executor::main] 17#[embassy_executor::main]
13async fn main(_spawner: Spawner) { 18async fn main(_spawner: Spawner) {
14 /* 19 /*
@@ -41,10 +46,7 @@ async fn main(_spawner: Spawner) {
41 let config = Config::default(); 46 let config = Config::default();
42 let mut ipcc = Ipcc::new(p.IPCC, config); 47 let mut ipcc = Ipcc::new(p.IPCC, config);
43 48
44 let rx_irq = interrupt::take!(IPCC_C1_RX); 49 let mbox = TlMbox::init(&mut ipcc, Irqs);
45 let tx_irq = interrupt::take!(IPCC_C1_TX);
46
47 let mbox = TlMbox::init(&mut ipcc, rx_irq, tx_irq);
48 50
49 // initialize ble stack, does not return a response 51 // initialize ble stack, does not return a response
50 mbox.shci_ble_init(&mut ipcc, Default::default()); 52 mbox.shci_ble_init(&mut ipcc, Default::default());
diff --git a/examples/stm32wl/src/bin/lora_lorawan.rs b/examples/stm32wl/src/bin/lora_lorawan.rs
index 1a271b2f2..e179c5ca1 100644
--- a/examples/stm32wl/src/bin/lora_lorawan.rs
+++ b/examples/stm32wl/src/bin/lora_lorawan.rs
@@ -7,12 +7,12 @@
7 7
8use defmt::info; 8use defmt::info;
9use embassy_executor::Spawner; 9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32wlInterfaceVariant; 10use embassy_lora::iv::{InterruptHandler, Stm32wlInterfaceVariant};
11use embassy_lora::LoraTimer; 11use embassy_lora::LoraTimer;
12use embassy_stm32::gpio::{Level, Output, Pin, Speed}; 12use embassy_stm32::gpio::{Level, Output, Pin, Speed};
13use embassy_stm32::rng::Rng; 13use embassy_stm32::rng::Rng;
14use embassy_stm32::spi::Spi; 14use embassy_stm32::spi::Spi;
15use embassy_stm32::{interrupt, into_ref, pac, Peripheral}; 15use embassy_stm32::{bind_interrupts, pac};
16use embassy_time::Delay; 16use embassy_time::Delay;
17use lora_phy::mod_params::*; 17use lora_phy::mod_params::*;
18use lora_phy::sx1261_2::SX1261_2; 18use lora_phy::sx1261_2::SX1261_2;
@@ -24,6 +24,10 @@ use {defmt_rtt as _, panic_probe as _};
24 24
25const LORAWAN_REGION: region::Region = region::Region::EU868; // warning: set this appropriately for the region 25const LORAWAN_REGION: region::Region = region::Region::EU868; // warning: set this appropriately for the region
26 26
27bind_interrupts!(struct Irqs{
28 SUBGHZ_RADIO => InterruptHandler;
29});
30
27#[embassy_executor::main] 31#[embassy_executor::main]
28async fn main(_spawner: Spawner) { 32async fn main(_spawner: Spawner) {
29 let mut config = embassy_stm32::Config::default(); 33 let mut config = embassy_stm32::Config::default();
@@ -35,13 +39,11 @@ async fn main(_spawner: Spawner) {
35 39
36 let spi = Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2); 40 let spi = Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2);
37 41
38 let irq = interrupt::take!(SUBGHZ_RADIO);
39 into_ref!(irq);
40 // Set CTRL1 and CTRL3 for high-power transmission, while CTRL2 acts as an RF switch between tx and rx 42 // Set CTRL1 and CTRL3 for high-power transmission, while CTRL2 acts as an RF switch between tx and rx
41 let _ctrl1 = Output::new(p.PC4.degrade(), Level::Low, Speed::High); 43 let _ctrl1 = Output::new(p.PC4.degrade(), Level::Low, Speed::High);
42 let ctrl2 = Output::new(p.PC5.degrade(), Level::High, Speed::High); 44 let ctrl2 = Output::new(p.PC5.degrade(), Level::High, Speed::High);
43 let _ctrl3 = Output::new(p.PC3.degrade(), Level::High, Speed::High); 45 let _ctrl3 = Output::new(p.PC3.degrade(), Level::High, Speed::High);
44 let iv = Stm32wlInterfaceVariant::new(irq, None, Some(ctrl2)).unwrap(); 46 let iv = Stm32wlInterfaceVariant::new(Irqs, None, Some(ctrl2)).unwrap();
45 47
46 let mut delay = Delay; 48 let mut delay = Delay;
47 49
diff --git a/examples/stm32wl/src/bin/lora_p2p_receive.rs b/examples/stm32wl/src/bin/lora_p2p_receive.rs
index 5e80e8f6a..d3f051b1c 100644
--- a/examples/stm32wl/src/bin/lora_p2p_receive.rs
+++ b/examples/stm32wl/src/bin/lora_p2p_receive.rs
@@ -7,10 +7,10 @@
7 7
8use defmt::info; 8use defmt::info;
9use embassy_executor::Spawner; 9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32wlInterfaceVariant; 10use embassy_lora::iv::{InterruptHandler, Stm32wlInterfaceVariant};
11use embassy_stm32::bind_interrupts;
11use embassy_stm32::gpio::{Level, Output, Pin, Speed}; 12use embassy_stm32::gpio::{Level, Output, Pin, Speed};
12use embassy_stm32::spi::Spi; 13use embassy_stm32::spi::Spi;
13use embassy_stm32::{interrupt, into_ref, Peripheral};
14use embassy_time::{Delay, Duration, Timer}; 14use embassy_time::{Delay, Duration, Timer};
15use lora_phy::mod_params::*; 15use lora_phy::mod_params::*;
16use lora_phy::sx1261_2::SX1261_2; 16use lora_phy::sx1261_2::SX1261_2;
@@ -19,6 +19,10 @@ use {defmt_rtt as _, panic_probe as _};
19 19
20const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region 20const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
21 21
22bind_interrupts!(struct Irqs{
23 SUBGHZ_RADIO => InterruptHandler;
24});
25
22#[embassy_executor::main] 26#[embassy_executor::main]
23async fn main(_spawner: Spawner) { 27async fn main(_spawner: Spawner) {
24 let mut config = embassy_stm32::Config::default(); 28 let mut config = embassy_stm32::Config::default();
@@ -27,13 +31,11 @@ async fn main(_spawner: Spawner) {
27 31
28 let spi = Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2); 32 let spi = Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2);
29 33
30 let irq = interrupt::take!(SUBGHZ_RADIO);
31 into_ref!(irq);
32 // Set CTRL1 and CTRL3 for high-power transmission, while CTRL2 acts as an RF switch between tx and rx 34 // Set CTRL1 and CTRL3 for high-power transmission, while CTRL2 acts as an RF switch between tx and rx
33 let _ctrl1 = Output::new(p.PC4.degrade(), Level::Low, Speed::High); 35 let _ctrl1 = Output::new(p.PC4.degrade(), Level::Low, Speed::High);
34 let ctrl2 = Output::new(p.PC5.degrade(), Level::High, Speed::High); 36 let ctrl2 = Output::new(p.PC5.degrade(), Level::High, Speed::High);
35 let _ctrl3 = Output::new(p.PC3.degrade(), Level::High, Speed::High); 37 let _ctrl3 = Output::new(p.PC3.degrade(), Level::High, Speed::High);
36 let iv = Stm32wlInterfaceVariant::new(irq, None, Some(ctrl2)).unwrap(); 38 let iv = Stm32wlInterfaceVariant::new(Irqs, None, Some(ctrl2)).unwrap();
37 39
38 let mut delay = Delay; 40 let mut delay = Delay;
39 41
diff --git a/examples/stm32wl/src/bin/lora_p2p_send.rs b/examples/stm32wl/src/bin/lora_p2p_send.rs
index e22c714bd..fc5205c85 100644
--- a/examples/stm32wl/src/bin/lora_p2p_send.rs
+++ b/examples/stm32wl/src/bin/lora_p2p_send.rs
@@ -7,10 +7,10 @@
7 7
8use defmt::info; 8use defmt::info;
9use embassy_executor::Spawner; 9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32wlInterfaceVariant; 10use embassy_lora::iv::{InterruptHandler, Stm32wlInterfaceVariant};
11use embassy_stm32::bind_interrupts;
11use embassy_stm32::gpio::{Level, Output, Pin, Speed}; 12use embassy_stm32::gpio::{Level, Output, Pin, Speed};
12use embassy_stm32::spi::Spi; 13use embassy_stm32::spi::Spi;
13use embassy_stm32::{interrupt, into_ref, Peripheral};
14use embassy_time::Delay; 14use embassy_time::Delay;
15use lora_phy::mod_params::*; 15use lora_phy::mod_params::*;
16use lora_phy::sx1261_2::SX1261_2; 16use lora_phy::sx1261_2::SX1261_2;
@@ -19,6 +19,10 @@ use {defmt_rtt as _, panic_probe as _};
19 19
20const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region 20const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
21 21
22bind_interrupts!(struct Irqs{
23 SUBGHZ_RADIO => InterruptHandler;
24});
25
22#[embassy_executor::main] 26#[embassy_executor::main]
23async fn main(_spawner: Spawner) { 27async fn main(_spawner: Spawner) {
24 let mut config = embassy_stm32::Config::default(); 28 let mut config = embassy_stm32::Config::default();
@@ -27,13 +31,11 @@ async fn main(_spawner: Spawner) {
27 31
28 let spi = Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2); 32 let spi = Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2);
29 33
30 let irq = interrupt::take!(SUBGHZ_RADIO);
31 into_ref!(irq);
32 // Set CTRL1 and CTRL3 for high-power transmission, while CTRL2 acts as an RF switch between tx and rx 34 // Set CTRL1 and CTRL3 for high-power transmission, while CTRL2 acts as an RF switch between tx and rx
33 let _ctrl1 = Output::new(p.PC4.degrade(), Level::Low, Speed::High); 35 let _ctrl1 = Output::new(p.PC4.degrade(), Level::Low, Speed::High);
34 let ctrl2 = Output::new(p.PC5.degrade(), Level::High, Speed::High); 36 let ctrl2 = Output::new(p.PC5.degrade(), Level::High, Speed::High);
35 let _ctrl3 = Output::new(p.PC3.degrade(), Level::High, Speed::High); 37 let _ctrl3 = Output::new(p.PC3.degrade(), Level::High, Speed::High);
36 let iv = Stm32wlInterfaceVariant::new(irq, None, Some(ctrl2)).unwrap(); 38 let iv = Stm32wlInterfaceVariant::new(Irqs, None, Some(ctrl2)).unwrap();
37 39
38 let mut delay = Delay; 40 let mut delay = Delay;
39 41
diff --git a/examples/stm32wl/src/bin/uart_async.rs b/examples/stm32wl/src/bin/uart_async.rs
index ac8766af6..07b0f9d2c 100644
--- a/examples/stm32wl/src/bin/uart_async.rs
+++ b/examples/stm32wl/src/bin/uart_async.rs
@@ -4,10 +4,15 @@
4 4
5use defmt::*; 5use defmt::*;
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::interrupt; 7use embassy_stm32::usart::{Config, InterruptHandler, Uart};
8use embassy_stm32::usart::{Config, Uart}; 8use embassy_stm32::{bind_interrupts, peripherals};
9use {defmt_rtt as _, panic_probe as _}; 9use {defmt_rtt as _, panic_probe as _};
10 10
11bind_interrupts!(struct Irqs{
12 USART1 => InterruptHandler<peripherals::USART1>;
13 LPUART1 => InterruptHandler<peripherals::LPUART1>;
14});
15
11/* 16/*
12Pass Incoming data from LPUART1 to USART1 17Pass Incoming data from LPUART1 to USART1
13Example is written for the LoRa-E5 mini v1.0, 18Example is written for the LoRa-E5 mini v1.0,
@@ -28,12 +33,10 @@ async fn main(_spawner: Spawner) {
28 config2.baudrate = 9600; 33 config2.baudrate = 9600;
29 34
30 //RX/TX connected to USB/UART Bridge on LoRa-E5 mini v1.0 35 //RX/TX connected to USB/UART Bridge on LoRa-E5 mini v1.0
31 let irq = interrupt::take!(USART1); 36 let mut usart1 = Uart::new(p.USART1, p.PB7, p.PB6, Irqs, p.DMA1_CH3, p.DMA1_CH4, config1);
32 let mut usart1 = Uart::new(p.USART1, p.PB7, p.PB6, irq, p.DMA1_CH3, p.DMA1_CH4, config1);
33 37
34 //RX1/TX1 (LPUART) on LoRa-E5 mini v1.0 38 //RX1/TX1 (LPUART) on LoRa-E5 mini v1.0
35 let irq = interrupt::take!(LPUART1); 39 let mut usart2 = Uart::new(p.LPUART1, p.PC0, p.PC1, Irqs, p.DMA1_CH5, p.DMA1_CH6, config2);
36 let mut usart2 = Uart::new(p.LPUART1, p.PC0, p.PC1, irq, p.DMA1_CH5, p.DMA1_CH6, config2);
37 40
38 unwrap!(usart1.write(b"Hello Embassy World!\r\n").await); 41 unwrap!(usart1.write(b"Hello Embassy World!\r\n").await);
39 unwrap!(usart2.write(b"Hello Embassy World!\r\n").await); 42 unwrap!(usart2.write(b"Hello Embassy World!\r\n").await);
generated by cgit (git 2.34.1) at 2026-04-05 22:59:34 +0000