aboutsummaryrefslogtreecommitdiff
path: root/examples
diff options
context:
space:
mode:
authorKarun Koppula <[email protected]>2024-04-02 15:51:50 -0400
committerGitHub <[email protected]>2024-04-02 15:51:50 -0400
commit9344f55ff3107917ce1b765bc4fa57965ec86ca6 (patch)
tree4ca4936f84d4ad9ecf85a0129159b6d6d20c53cd /examples
parent2caea89b6ab9859470ccf6c7d7414c01251bbecd (diff)
parent990f2717673de5e6de6be6a9fb001bc0c8d34745 (diff)
Merge branch 'main' into karun/main_octospi_implementation
Diffstat (limited to 'examples')
-rw-r--r--examples/boot/application/stm32wb-dfu/src/main.rs2
-rw-r--r--examples/boot/bootloader/stm32wb-dfu/src/main.rs2
-rw-r--r--examples/nrf52840/src/bin/usb_ethernet.rs2
-rw-r--r--examples/nrf52840/src/bin/usb_hid_keyboard.rs2
-rw-r--r--examples/nrf52840/src/bin/usb_hid_mouse.rs2
-rw-r--r--examples/nrf52840/src/bin/usb_serial.rs2
-rw-r--r--examples/nrf52840/src/bin/usb_serial_multitask.rs2
-rw-r--r--examples/nrf52840/src/bin/usb_serial_winusb.rs2
-rw-r--r--examples/rp/src/bin/multicore.rs12
-rw-r--r--examples/rp/src/bin/pio_hd44780.rs2
-rw-r--r--examples/rp/src/bin/pio_uart.rs2
-rw-r--r--examples/rp/src/bin/pwm.rs2
-rw-r--r--examples/rp/src/bin/pwm_input.rs2
-rw-r--r--examples/rp/src/bin/usb_ethernet.rs2
-rw-r--r--examples/rp/src/bin/usb_hid_keyboard.rs2
-rw-r--r--examples/rp/src/bin/usb_hid_mouse.rs2
-rw-r--r--examples/rp/src/bin/usb_midi.rs2
-rw-r--r--examples/rp/src/bin/usb_raw.rs2
-rw-r--r--examples/rp/src/bin/usb_raw_bulk.rs2
-rw-r--r--examples/rp/src/bin/usb_serial.rs2
-rw-r--r--examples/rp/src/bin/usb_serial_with_logger.rs2
-rw-r--r--examples/std/src/bin/net.rs2
-rw-r--r--examples/std/src/bin/net_dns.rs2
-rw-r--r--examples/std/src/bin/tcp_accept.rs1
-rw-r--r--examples/stm32f1/Cargo.toml1
-rw-r--r--examples/stm32f1/src/bin/can.rs122
-rw-r--r--examples/stm32f1/src/bin/usb_serial.rs2
-rw-r--r--examples/stm32f2/src/bin/pll.rs2
-rw-r--r--examples/stm32f3/src/bin/usb_serial.rs2
-rw-r--r--examples/stm32f4/src/bin/can.rs22
-rw-r--r--examples/stm32f4/src/bin/usb_ethernet.rs11
-rw-r--r--examples/stm32f4/src/bin/usb_hid_keyboard.rs221
-rw-r--r--examples/stm32f4/src/bin/usb_hid_mouse.rs11
-rw-r--r--examples/stm32f4/src/bin/usb_raw.rs11
-rw-r--r--examples/stm32f4/src/bin/usb_serial.rs11
-rw-r--r--examples/stm32f4/src/bin/ws2812_pwm.rs5
-rw-r--r--examples/stm32f7/src/bin/can.rs35
-rw-r--r--examples/stm32f7/src/bin/cryp.rs28
-rw-r--r--examples/stm32f7/src/bin/usb_serial.rs11
-rw-r--r--examples/stm32g0/src/bin/usb_serial.rs2
-rw-r--r--examples/stm32g4/src/bin/can.rs29
-rw-r--r--examples/stm32g4/src/bin/usb_c_pd.rs86
-rw-r--r--examples/stm32g4/src/bin/usb_serial.rs2
-rw-r--r--examples/stm32h5/src/bin/can.rs12
-rw-r--r--examples/stm32h5/src/bin/usb_serial.rs2
-rw-r--r--examples/stm32h7/src/bin/camera.rs4
-rw-r--r--examples/stm32h7/src/bin/can.rs12
-rw-r--r--examples/stm32h7/src/bin/dac_dma.rs40
-rw-r--r--examples/stm32h7/src/bin/eth.rs20
-rw-r--r--examples/stm32h7/src/bin/low_level_timer_api.rs71
-rw-r--r--examples/stm32h7/src/bin/usb_serial.rs11
-rw-r--r--examples/stm32l1/src/bin/usb_serial.rs2
-rw-r--r--examples/stm32l4/src/bin/dac_dma.rs40
-rw-r--r--examples/stm32l4/src/bin/spe_adin1110_http_server.rs8
-rw-r--r--examples/stm32l4/src/bin/usb_serial.rs38
-rw-r--r--examples/stm32l5/src/bin/usb_ethernet.rs30
-rw-r--r--examples/stm32l5/src/bin/usb_hid_mouse.rs30
-rw-r--r--examples/stm32l5/src/bin/usb_serial.rs30
-rw-r--r--examples/stm32u5/src/bin/usb_serial.rs11
59 files changed, 696 insertions, 336 deletions
diff --git a/examples/boot/application/stm32wb-dfu/src/main.rs b/examples/boot/application/stm32wb-dfu/src/main.rs
index 37c3d7d90..929d6802c 100644
--- a/examples/boot/application/stm32wb-dfu/src/main.rs
+++ b/examples/boot/application/stm32wb-dfu/src/main.rs
@@ -41,7 +41,6 @@ async fn main(_spawner: Spawner) {
41 config.product = Some("USB-DFU Runtime example"); 41 config.product = Some("USB-DFU Runtime example");
42 config.serial_number = Some("1235678"); 42 config.serial_number = Some("1235678");
43 43
44 let mut device_descriptor = [0; 256];
45 let mut config_descriptor = [0; 256]; 44 let mut config_descriptor = [0; 256];
46 let mut bos_descriptor = [0; 256]; 45 let mut bos_descriptor = [0; 256];
47 let mut control_buf = [0; 64]; 46 let mut control_buf = [0; 64];
@@ -49,7 +48,6 @@ async fn main(_spawner: Spawner) {
49 let mut builder = Builder::new( 48 let mut builder = Builder::new(
50 driver, 49 driver,
51 config, 50 config,
52 &mut device_descriptor,
53 &mut config_descriptor, 51 &mut config_descriptor,
54 &mut bos_descriptor, 52 &mut bos_descriptor,
55 &mut [], 53 &mut [],
diff --git a/examples/boot/bootloader/stm32wb-dfu/src/main.rs b/examples/boot/bootloader/stm32wb-dfu/src/main.rs
index d989fbfdf..093b39f9d 100644
--- a/examples/boot/bootloader/stm32wb-dfu/src/main.rs
+++ b/examples/boot/bootloader/stm32wb-dfu/src/main.rs
@@ -49,7 +49,6 @@ fn main() -> ! {
49 let mut buffer = AlignedBuffer([0; WRITE_SIZE]); 49 let mut buffer = AlignedBuffer([0; WRITE_SIZE]);
50 let updater = BlockingFirmwareUpdater::new(fw_config, &mut buffer.0[..]); 50 let updater = BlockingFirmwareUpdater::new(fw_config, &mut buffer.0[..]);
51 51
52 let mut device_descriptor = [0; 256];
53 let mut config_descriptor = [0; 256]; 52 let mut config_descriptor = [0; 256];
54 let mut bos_descriptor = [0; 256]; 53 let mut bos_descriptor = [0; 256];
55 let mut control_buf = [0; 4096]; 54 let mut control_buf = [0; 4096];
@@ -57,7 +56,6 @@ fn main() -> ! {
57 let mut builder = Builder::new( 56 let mut builder = Builder::new(
58 driver, 57 driver,
59 config, 58 config,
60 &mut device_descriptor,
61 &mut config_descriptor, 59 &mut config_descriptor,
62 &mut bos_descriptor, 60 &mut bos_descriptor,
63 &mut [], 61 &mut [],
diff --git a/examples/nrf52840/src/bin/usb_ethernet.rs b/examples/nrf52840/src/bin/usb_ethernet.rs
index 3469c6e5f..a7e5c2668 100644
--- a/examples/nrf52840/src/bin/usb_ethernet.rs
+++ b/examples/nrf52840/src/bin/usb_ethernet.rs
@@ -70,7 +70,6 @@ async fn main(spawner: Spawner) {
70 config.device_protocol = 0x01; 70 config.device_protocol = 0x01;
71 71
72 // Create embassy-usb DeviceBuilder using the driver and config. 72 // Create embassy-usb DeviceBuilder using the driver and config.
73 static DEVICE_DESC: StaticCell<[u8; 256]> = StaticCell::new();
74 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 73 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
75 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 74 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
76 static MSOS_DESC: StaticCell<[u8; 128]> = StaticCell::new(); 75 static MSOS_DESC: StaticCell<[u8; 128]> = StaticCell::new();
@@ -78,7 +77,6 @@ async fn main(spawner: Spawner) {
78 let mut builder = Builder::new( 77 let mut builder = Builder::new(
79 driver, 78 driver,
80 config, 79 config,
81 &mut DEVICE_DESC.init([0; 256])[..],
82 &mut CONFIG_DESC.init([0; 256])[..], 80 &mut CONFIG_DESC.init([0; 256])[..],
83 &mut BOS_DESC.init([0; 256])[..], 81 &mut BOS_DESC.init([0; 256])[..],
84 &mut MSOS_DESC.init([0; 128])[..], 82 &mut MSOS_DESC.init([0; 128])[..],
diff --git a/examples/nrf52840/src/bin/usb_hid_keyboard.rs b/examples/nrf52840/src/bin/usb_hid_keyboard.rs
index 3e86590c4..52f081487 100644
--- a/examples/nrf52840/src/bin/usb_hid_keyboard.rs
+++ b/examples/nrf52840/src/bin/usb_hid_keyboard.rs
@@ -50,7 +50,6 @@ async fn main(_spawner: Spawner) {
50 50
51 // Create embassy-usb DeviceBuilder using the driver and config. 51 // Create embassy-usb DeviceBuilder using the driver and config.
52 // It needs some buffers for building the descriptors. 52 // It needs some buffers for building the descriptors.
53 let mut device_descriptor = [0; 256];
54 let mut config_descriptor = [0; 256]; 53 let mut config_descriptor = [0; 256];
55 let mut bos_descriptor = [0; 256]; 54 let mut bos_descriptor = [0; 256];
56 let mut msos_descriptor = [0; 256]; 55 let mut msos_descriptor = [0; 256];
@@ -63,7 +62,6 @@ async fn main(_spawner: Spawner) {
63 let mut builder = Builder::new( 62 let mut builder = Builder::new(
64 driver, 63 driver,
65 config, 64 config,
66 &mut device_descriptor,
67 &mut config_descriptor, 65 &mut config_descriptor,
68 &mut bos_descriptor, 66 &mut bos_descriptor,
69 &mut msos_descriptor, 67 &mut msos_descriptor,
diff --git a/examples/nrf52840/src/bin/usb_hid_mouse.rs b/examples/nrf52840/src/bin/usb_hid_mouse.rs
index 04ad841b7..5d2837793 100644
--- a/examples/nrf52840/src/bin/usb_hid_mouse.rs
+++ b/examples/nrf52840/src/bin/usb_hid_mouse.rs
@@ -43,7 +43,6 @@ async fn main(_spawner: Spawner) {
43 43
44 // Create embassy-usb DeviceBuilder using the driver and config. 44 // Create embassy-usb DeviceBuilder using the driver and config.
45 // It needs some buffers for building the descriptors. 45 // It needs some buffers for building the descriptors.
46 let mut device_descriptor = [0; 256];
47 let mut config_descriptor = [0; 256]; 46 let mut config_descriptor = [0; 256];
48 let mut bos_descriptor = [0; 256]; 47 let mut bos_descriptor = [0; 256];
49 let mut msos_descriptor = [0; 256]; 48 let mut msos_descriptor = [0; 256];
@@ -55,7 +54,6 @@ async fn main(_spawner: Spawner) {
55 let mut builder = Builder::new( 54 let mut builder = Builder::new(
56 driver, 55 driver,
57 config, 56 config,
58 &mut device_descriptor,
59 &mut config_descriptor, 57 &mut config_descriptor,
60 &mut bos_descriptor, 58 &mut bos_descriptor,
61 &mut msos_descriptor, 59 &mut msos_descriptor,
diff --git a/examples/nrf52840/src/bin/usb_serial.rs b/examples/nrf52840/src/bin/usb_serial.rs
index aff539b1b..02048e692 100644
--- a/examples/nrf52840/src/bin/usb_serial.rs
+++ b/examples/nrf52840/src/bin/usb_serial.rs
@@ -48,7 +48,6 @@ async fn main(_spawner: Spawner) {
48 48
49 // Create embassy-usb DeviceBuilder using the driver and config. 49 // Create embassy-usb DeviceBuilder using the driver and config.
50 // It needs some buffers for building the descriptors. 50 // It needs some buffers for building the descriptors.
51 let mut device_descriptor = [0; 256];
52 let mut config_descriptor = [0; 256]; 51 let mut config_descriptor = [0; 256];
53 let mut bos_descriptor = [0; 256]; 52 let mut bos_descriptor = [0; 256];
54 let mut msos_descriptor = [0; 256]; 53 let mut msos_descriptor = [0; 256];
@@ -59,7 +58,6 @@ async fn main(_spawner: Spawner) {
59 let mut builder = Builder::new( 58 let mut builder = Builder::new(
60 driver, 59 driver,
61 config, 60 config,
62 &mut device_descriptor,
63 &mut config_descriptor, 61 &mut config_descriptor,
64 &mut bos_descriptor, 62 &mut bos_descriptor,
65 &mut msos_descriptor, 63 &mut msos_descriptor,
diff --git a/examples/nrf52840/src/bin/usb_serial_multitask.rs b/examples/nrf52840/src/bin/usb_serial_multitask.rs
index 4e8118fb8..895cca8b9 100644
--- a/examples/nrf52840/src/bin/usb_serial_multitask.rs
+++ b/examples/nrf52840/src/bin/usb_serial_multitask.rs
@@ -67,7 +67,6 @@ async fn main(spawner: Spawner) {
67 let state = STATE.init(State::new()); 67 let state = STATE.init(State::new());
68 68
69 // Create embassy-usb DeviceBuilder using the driver and config. 69 // Create embassy-usb DeviceBuilder using the driver and config.
70 static DEVICE_DESC: StaticCell<[u8; 256]> = StaticCell::new();
71 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 70 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
72 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 71 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
73 static MSOS_DESC: StaticCell<[u8; 128]> = StaticCell::new(); 72 static MSOS_DESC: StaticCell<[u8; 128]> = StaticCell::new();
@@ -75,7 +74,6 @@ async fn main(spawner: Spawner) {
75 let mut builder = Builder::new( 74 let mut builder = Builder::new(
76 driver, 75 driver,
77 config, 76 config,
78 &mut DEVICE_DESC.init([0; 256])[..],
79 &mut CONFIG_DESC.init([0; 256])[..], 77 &mut CONFIG_DESC.init([0; 256])[..],
80 &mut BOS_DESC.init([0; 256])[..], 78 &mut BOS_DESC.init([0; 256])[..],
81 &mut MSOS_DESC.init([0; 128])[..], 79 &mut MSOS_DESC.init([0; 128])[..],
diff --git a/examples/nrf52840/src/bin/usb_serial_winusb.rs b/examples/nrf52840/src/bin/usb_serial_winusb.rs
index 060f9ba94..c6675a3d3 100644
--- a/examples/nrf52840/src/bin/usb_serial_winusb.rs
+++ b/examples/nrf52840/src/bin/usb_serial_winusb.rs
@@ -53,7 +53,6 @@ async fn main(_spawner: Spawner) {
53 53
54 // Create embassy-usb DeviceBuilder using the driver and config. 54 // Create embassy-usb DeviceBuilder using the driver and config.
55 // It needs some buffers for building the descriptors. 55 // It needs some buffers for building the descriptors.
56 let mut device_descriptor = [0; 256];
57 let mut config_descriptor = [0; 256]; 56 let mut config_descriptor = [0; 256];
58 let mut bos_descriptor = [0; 256]; 57 let mut bos_descriptor = [0; 256];
59 let mut msos_descriptor = [0; 256]; 58 let mut msos_descriptor = [0; 256];
@@ -64,7 +63,6 @@ async fn main(_spawner: Spawner) {
64 let mut builder = Builder::new( 63 let mut builder = Builder::new(
65 driver, 64 driver,
66 config, 65 config,
67 &mut device_descriptor,
68 &mut config_descriptor, 66 &mut config_descriptor,
69 &mut bos_descriptor, 67 &mut bos_descriptor,
70 &mut msos_descriptor, 68 &mut msos_descriptor,
diff --git a/examples/rp/src/bin/multicore.rs b/examples/rp/src/bin/multicore.rs
index c7b087476..7cb546c91 100644
--- a/examples/rp/src/bin/multicore.rs
+++ b/examples/rp/src/bin/multicore.rs
@@ -30,10 +30,14 @@ fn main() -> ! {
30 let p = embassy_rp::init(Default::default()); 30 let p = embassy_rp::init(Default::default());
31 let led = Output::new(p.PIN_25, Level::Low); 31 let led = Output::new(p.PIN_25, Level::Low);
32 32
33 spawn_core1(p.CORE1, unsafe { &mut CORE1_STACK }, move || { 33 spawn_core1(
34 let executor1 = EXECUTOR1.init(Executor::new()); 34 p.CORE1,
35 executor1.run(|spawner| unwrap!(spawner.spawn(core1_task(led)))); 35 unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
36 }); 36 move || {
37 let executor1 = EXECUTOR1.init(Executor::new());
38 executor1.run(|spawner| unwrap!(spawner.spawn(core1_task(led))));
39 },
40 );
37 41
38 let executor0 = EXECUTOR0.init(Executor::new()); 42 let executor0 = EXECUTOR0.init(Executor::new());
39 executor0.run(|spawner| unwrap!(spawner.spawn(core0_task()))); 43 executor0.run(|spawner| unwrap!(spawner.spawn(core0_task())));
diff --git a/examples/rp/src/bin/pio_hd44780.rs b/examples/rp/src/bin/pio_hd44780.rs
index 3fab7b5f2..6c02630e0 100644
--- a/examples/rp/src/bin/pio_hd44780.rs
+++ b/examples/rp/src/bin/pio_hd44780.rs
@@ -35,7 +35,7 @@ async fn main(_spawner: Spawner) {
35 // allowing direct connection of the display to the RP2040 without level shifters. 35 // allowing direct connection of the display to the RP2040 without level shifters.
36 let p = embassy_rp::init(Default::default()); 36 let p = embassy_rp::init(Default::default());
37 37
38 let _pwm = Pwm::new_output_b(p.PWM_CH7, p.PIN_15, { 38 let _pwm = Pwm::new_output_b(p.PWM_SLICE7, p.PIN_15, {
39 let mut c = pwm::Config::default(); 39 let mut c = pwm::Config::default();
40 c.divider = 125.into(); 40 c.divider = 125.into();
41 c.top = 100; 41 c.top = 100;
diff --git a/examples/rp/src/bin/pio_uart.rs b/examples/rp/src/bin/pio_uart.rs
index a07f1c180..53b696309 100644
--- a/examples/rp/src/bin/pio_uart.rs
+++ b/examples/rp/src/bin/pio_uart.rs
@@ -60,7 +60,6 @@ async fn main(_spawner: Spawner) {
60 60
61 // Create embassy-usb DeviceBuilder using the driver and config. 61 // Create embassy-usb DeviceBuilder using the driver and config.
62 // It needs some buffers for building the descriptors. 62 // It needs some buffers for building the descriptors.
63 let mut device_descriptor = [0; 256];
64 let mut config_descriptor = [0; 256]; 63 let mut config_descriptor = [0; 256];
65 let mut bos_descriptor = [0; 256]; 64 let mut bos_descriptor = [0; 256];
66 let mut control_buf = [0; 64]; 65 let mut control_buf = [0; 64];
@@ -70,7 +69,6 @@ async fn main(_spawner: Spawner) {
70 let mut builder = Builder::new( 69 let mut builder = Builder::new(
71 driver, 70 driver,
72 config, 71 config,
73 &mut device_descriptor,
74 &mut config_descriptor, 72 &mut config_descriptor,
75 &mut bos_descriptor, 73 &mut bos_descriptor,
76 &mut [], // no msos descriptors 74 &mut [], // no msos descriptors
diff --git a/examples/rp/src/bin/pwm.rs b/examples/rp/src/bin/pwm.rs
index 4fb62546d..26e233260 100644
--- a/examples/rp/src/bin/pwm.rs
+++ b/examples/rp/src/bin/pwm.rs
@@ -18,7 +18,7 @@ async fn main(_spawner: Spawner) {
18 let mut c: Config = Default::default(); 18 let mut c: Config = Default::default();
19 c.top = 0x8000; 19 c.top = 0x8000;
20 c.compare_b = 8; 20 c.compare_b = 8;
21 let mut pwm = Pwm::new_output_b(p.PWM_CH4, p.PIN_25, c.clone()); 21 let mut pwm = Pwm::new_output_b(p.PWM_SLICE4, p.PIN_25, c.clone());
22 22
23 loop { 23 loop {
24 info!("current LED duty cycle: {}/32768", c.compare_b); 24 info!("current LED duty cycle: {}/32768", c.compare_b);
diff --git a/examples/rp/src/bin/pwm_input.rs b/examples/rp/src/bin/pwm_input.rs
index e7bcbfbd4..0652dc42b 100644
--- a/examples/rp/src/bin/pwm_input.rs
+++ b/examples/rp/src/bin/pwm_input.rs
@@ -14,7 +14,7 @@ async fn main(_spawner: Spawner) {
14 let p = embassy_rp::init(Default::default()); 14 let p = embassy_rp::init(Default::default());
15 15
16 let cfg: Config = Default::default(); 16 let cfg: Config = Default::default();
17 let pwm = Pwm::new_input(p.PWM_CH2, p.PIN_5, InputMode::RisingEdge, cfg); 17 let pwm = Pwm::new_input(p.PWM_SLICE2, p.PIN_5, InputMode::RisingEdge, cfg);
18 18
19 let mut ticker = Ticker::every(Duration::from_secs(1)); 19 let mut ticker = Ticker::every(Duration::from_secs(1));
20 loop { 20 loop {
diff --git a/examples/rp/src/bin/usb_ethernet.rs b/examples/rp/src/bin/usb_ethernet.rs
index 01f0d5967..f1b124efa 100644
--- a/examples/rp/src/bin/usb_ethernet.rs
+++ b/examples/rp/src/bin/usb_ethernet.rs
@@ -64,14 +64,12 @@ async fn main(spawner: Spawner) {
64 config.device_protocol = 0x01; 64 config.device_protocol = 0x01;
65 65
66 // Create embassy-usb DeviceBuilder using the driver and config. 66 // Create embassy-usb DeviceBuilder using the driver and config.
67 static DEVICE_DESC: StaticCell<[u8; 256]> = StaticCell::new();
68 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 67 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
69 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 68 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
70 static CONTROL_BUF: StaticCell<[u8; 128]> = StaticCell::new(); 69 static CONTROL_BUF: StaticCell<[u8; 128]> = StaticCell::new();
71 let mut builder = Builder::new( 70 let mut builder = Builder::new(
72 driver, 71 driver,
73 config, 72 config,
74 &mut DEVICE_DESC.init([0; 256])[..],
75 &mut CONFIG_DESC.init([0; 256])[..], 73 &mut CONFIG_DESC.init([0; 256])[..],
76 &mut BOS_DESC.init([0; 256])[..], 74 &mut BOS_DESC.init([0; 256])[..],
77 &mut [], // no msos descriptors 75 &mut [], // no msos descriptors
diff --git a/examples/rp/src/bin/usb_hid_keyboard.rs b/examples/rp/src/bin/usb_hid_keyboard.rs
index b5ac16245..710be8d13 100644
--- a/examples/rp/src/bin/usb_hid_keyboard.rs
+++ b/examples/rp/src/bin/usb_hid_keyboard.rs
@@ -36,7 +36,6 @@ async fn main(_spawner: Spawner) {
36 36
37 // Create embassy-usb DeviceBuilder using the driver and config. 37 // Create embassy-usb DeviceBuilder using the driver and config.
38 // It needs some buffers for building the descriptors. 38 // It needs some buffers for building the descriptors.
39 let mut device_descriptor = [0; 256];
40 let mut config_descriptor = [0; 256]; 39 let mut config_descriptor = [0; 256];
41 let mut bos_descriptor = [0; 256]; 40 let mut bos_descriptor = [0; 256];
42 // You can also add a Microsoft OS descriptor. 41 // You can also add a Microsoft OS descriptor.
@@ -50,7 +49,6 @@ async fn main(_spawner: Spawner) {
50 let mut builder = Builder::new( 49 let mut builder = Builder::new(
51 driver, 50 driver,
52 config, 51 config,
53 &mut device_descriptor,
54 &mut config_descriptor, 52 &mut config_descriptor,
55 &mut bos_descriptor, 53 &mut bos_descriptor,
56 &mut msos_descriptor, 54 &mut msos_descriptor,
diff --git a/examples/rp/src/bin/usb_hid_mouse.rs b/examples/rp/src/bin/usb_hid_mouse.rs
index afebd8813..e8b399cb1 100644
--- a/examples/rp/src/bin/usb_hid_mouse.rs
+++ b/examples/rp/src/bin/usb_hid_mouse.rs
@@ -39,7 +39,6 @@ async fn main(_spawner: Spawner) {
39 39
40 // Create embassy-usb DeviceBuilder using the driver and config. 40 // Create embassy-usb DeviceBuilder using the driver and config.
41 // It needs some buffers for building the descriptors. 41 // It needs some buffers for building the descriptors.
42 let mut device_descriptor = [0; 256];
43 let mut config_descriptor = [0; 256]; 42 let mut config_descriptor = [0; 256];
44 let mut bos_descriptor = [0; 256]; 43 let mut bos_descriptor = [0; 256];
45 // You can also add a Microsoft OS descriptor. 44 // You can also add a Microsoft OS descriptor.
@@ -53,7 +52,6 @@ async fn main(_spawner: Spawner) {
53 let mut builder = Builder::new( 52 let mut builder = Builder::new(
54 driver, 53 driver,
55 config, 54 config,
56 &mut device_descriptor,
57 &mut config_descriptor, 55 &mut config_descriptor,
58 &mut bos_descriptor, 56 &mut bos_descriptor,
59 &mut msos_descriptor, 57 &mut msos_descriptor,
diff --git a/examples/rp/src/bin/usb_midi.rs b/examples/rp/src/bin/usb_midi.rs
index 95306a35c..11db1b2e1 100644
--- a/examples/rp/src/bin/usb_midi.rs
+++ b/examples/rp/src/bin/usb_midi.rs
@@ -46,7 +46,6 @@ async fn main(_spawner: Spawner) {
46 46
47 // Create embassy-usb DeviceBuilder using the driver and config. 47 // Create embassy-usb DeviceBuilder using the driver and config.
48 // It needs some buffers for building the descriptors. 48 // It needs some buffers for building the descriptors.
49 let mut device_descriptor = [0; 256];
50 let mut config_descriptor = [0; 256]; 49 let mut config_descriptor = [0; 256];
51 let mut bos_descriptor = [0; 256]; 50 let mut bos_descriptor = [0; 256];
52 let mut control_buf = [0; 64]; 51 let mut control_buf = [0; 64];
@@ -54,7 +53,6 @@ async fn main(_spawner: Spawner) {
54 let mut builder = Builder::new( 53 let mut builder = Builder::new(
55 driver, 54 driver,
56 config, 55 config,
57 &mut device_descriptor,
58 &mut config_descriptor, 56 &mut config_descriptor,
59 &mut bos_descriptor, 57 &mut bos_descriptor,
60 &mut [], // no msos descriptors 58 &mut [], // no msos descriptors
diff --git a/examples/rp/src/bin/usb_raw.rs b/examples/rp/src/bin/usb_raw.rs
index a6c8a5b2e..97e7e0244 100644
--- a/examples/rp/src/bin/usb_raw.rs
+++ b/examples/rp/src/bin/usb_raw.rs
@@ -93,7 +93,6 @@ async fn main(_spawner: Spawner) {
93 93
94 // Create embassy-usb DeviceBuilder using the driver and config. 94 // Create embassy-usb DeviceBuilder using the driver and config.
95 // It needs some buffers for building the descriptors. 95 // It needs some buffers for building the descriptors.
96 let mut device_descriptor = [0; 256];
97 let mut config_descriptor = [0; 256]; 96 let mut config_descriptor = [0; 256];
98 let mut bos_descriptor = [0; 256]; 97 let mut bos_descriptor = [0; 256];
99 let mut msos_descriptor = [0; 256]; 98 let mut msos_descriptor = [0; 256];
@@ -106,7 +105,6 @@ async fn main(_spawner: Spawner) {
106 let mut builder = Builder::new( 105 let mut builder = Builder::new(
107 driver, 106 driver,
108 config, 107 config,
109 &mut device_descriptor,
110 &mut config_descriptor, 108 &mut config_descriptor,
111 &mut bos_descriptor, 109 &mut bos_descriptor,
112 &mut msos_descriptor, 110 &mut msos_descriptor,
diff --git a/examples/rp/src/bin/usb_raw_bulk.rs b/examples/rp/src/bin/usb_raw_bulk.rs
index 0dc8e9f72..331c3da4c 100644
--- a/examples/rp/src/bin/usb_raw_bulk.rs
+++ b/examples/rp/src/bin/usb_raw_bulk.rs
@@ -71,7 +71,6 @@ async fn main(_spawner: Spawner) {
71 71
72 // Create embassy-usb DeviceBuilder using the driver and config. 72 // Create embassy-usb DeviceBuilder using the driver and config.
73 // It needs some buffers for building the descriptors. 73 // It needs some buffers for building the descriptors.
74 let mut device_descriptor = [0; 256];
75 let mut config_descriptor = [0; 256]; 74 let mut config_descriptor = [0; 256];
76 let mut bos_descriptor = [0; 256]; 75 let mut bos_descriptor = [0; 256];
77 let mut msos_descriptor = [0; 256]; 76 let mut msos_descriptor = [0; 256];
@@ -80,7 +79,6 @@ async fn main(_spawner: Spawner) {
80 let mut builder = Builder::new( 79 let mut builder = Builder::new(
81 driver, 80 driver,
82 config, 81 config,
83 &mut device_descriptor,
84 &mut config_descriptor, 82 &mut config_descriptor,
85 &mut bos_descriptor, 83 &mut bos_descriptor,
86 &mut msos_descriptor, 84 &mut msos_descriptor,
diff --git a/examples/rp/src/bin/usb_serial.rs b/examples/rp/src/bin/usb_serial.rs
index ab24a994c..3c9bc96dd 100644
--- a/examples/rp/src/bin/usb_serial.rs
+++ b/examples/rp/src/bin/usb_serial.rs
@@ -46,7 +46,6 @@ async fn main(_spawner: Spawner) {
46 46
47 // Create embassy-usb DeviceBuilder using the driver and config. 47 // Create embassy-usb DeviceBuilder using the driver and config.
48 // It needs some buffers for building the descriptors. 48 // It needs some buffers for building the descriptors.
49 let mut device_descriptor = [0; 256];
50 let mut config_descriptor = [0; 256]; 49 let mut config_descriptor = [0; 256];
51 let mut bos_descriptor = [0; 256]; 50 let mut bos_descriptor = [0; 256];
52 let mut control_buf = [0; 64]; 51 let mut control_buf = [0; 64];
@@ -56,7 +55,6 @@ async fn main(_spawner: Spawner) {
56 let mut builder = Builder::new( 55 let mut builder = Builder::new(
57 driver, 56 driver,
58 config, 57 config,
59 &mut device_descriptor,
60 &mut config_descriptor, 58 &mut config_descriptor,
61 &mut bos_descriptor, 59 &mut bos_descriptor,
62 &mut [], // no msos descriptors 60 &mut [], // no msos descriptors
diff --git a/examples/rp/src/bin/usb_serial_with_logger.rs b/examples/rp/src/bin/usb_serial_with_logger.rs
index 4ba4fc25c..f9cfdef94 100644
--- a/examples/rp/src/bin/usb_serial_with_logger.rs
+++ b/examples/rp/src/bin/usb_serial_with_logger.rs
@@ -46,7 +46,6 @@ async fn main(_spawner: Spawner) {
46 46
47 // Create embassy-usb DeviceBuilder using the driver and config. 47 // Create embassy-usb DeviceBuilder using the driver and config.
48 // It needs some buffers for building the descriptors. 48 // It needs some buffers for building the descriptors.
49 let mut device_descriptor = [0; 256];
50 let mut config_descriptor = [0; 256]; 49 let mut config_descriptor = [0; 256];
51 let mut bos_descriptor = [0; 256]; 50 let mut bos_descriptor = [0; 256];
52 let mut control_buf = [0; 64]; 51 let mut control_buf = [0; 64];
@@ -57,7 +56,6 @@ async fn main(_spawner: Spawner) {
57 let mut builder = Builder::new( 56 let mut builder = Builder::new(
58 driver, 57 driver,
59 config, 58 config,
60 &mut device_descriptor,
61 &mut config_descriptor, 59 &mut config_descriptor,
62 &mut bos_descriptor, 60 &mut bos_descriptor,
63 &mut [], // no msos descriptors 61 &mut [], // no msos descriptors
diff --git a/examples/std/src/bin/net.rs b/examples/std/src/bin/net.rs
index dad93d0a1..59813d8cb 100644
--- a/examples/std/src/bin/net.rs
+++ b/examples/std/src/bin/net.rs
@@ -1,5 +1,3 @@
1use std::default::Default;
2
3use clap::Parser; 1use clap::Parser;
4use embassy_executor::{Executor, Spawner}; 2use embassy_executor::{Executor, Spawner};
5use embassy_net::tcp::TcpSocket; 3use embassy_net::tcp::TcpSocket;
diff --git a/examples/std/src/bin/net_dns.rs b/examples/std/src/bin/net_dns.rs
index fca1e076e..3b6a3de37 100644
--- a/examples/std/src/bin/net_dns.rs
+++ b/examples/std/src/bin/net_dns.rs
@@ -1,5 +1,3 @@
1use std::default::Default;
2
3use clap::Parser; 1use clap::Parser;
4use embassy_executor::{Executor, Spawner}; 2use embassy_executor::{Executor, Spawner};
5use embassy_net::dns::DnsQueryType; 3use embassy_net::dns::DnsQueryType;
diff --git a/examples/std/src/bin/tcp_accept.rs b/examples/std/src/bin/tcp_accept.rs
index 00ccd83a7..e8b6eaa6c 100644
--- a/examples/std/src/bin/tcp_accept.rs
+++ b/examples/std/src/bin/tcp_accept.rs
@@ -1,5 +1,4 @@
1use core::fmt::Write as _; 1use core::fmt::Write as _;
2use std::default::Default;
3 2
4use clap::Parser; 3use clap::Parser;
5use embassy_executor::{Executor, Spawner}; 4use embassy_executor::{Executor, Spawner};
diff --git a/examples/stm32f1/Cargo.toml b/examples/stm32f1/Cargo.toml
index df5d32f70..4f282f326 100644
--- a/examples/stm32f1/Cargo.toml
+++ b/examples/stm32f1/Cargo.toml
@@ -23,6 +23,7 @@ panic-probe = { version = "0.3", features = ["print-defmt"] }
23futures = { version = "0.3.17", default-features = false, features = ["async-await"] } 23futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
24heapless = { version = "0.8", default-features = false } 24heapless = { version = "0.8", default-features = false }
25nb = "1.0.0" 25nb = "1.0.0"
26static_cell = "2.0.0"
26 27
27[profile.dev] 28[profile.dev]
28opt-level = "s" 29opt-level = "s"
diff --git a/examples/stm32f1/src/bin/can.rs b/examples/stm32f1/src/bin/can.rs
index c1c4f8359..1c13d623d 100644
--- a/examples/stm32f1/src/bin/can.rs
+++ b/examples/stm32f1/src/bin/can.rs
@@ -3,11 +3,14 @@
3 3
4use defmt::*; 4use defmt::*;
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::can::bxcan::filter::Mask32; 6use embassy_stm32::can::frame::Envelope;
7use embassy_stm32::can::bxcan::{Fifo, Frame, Id, StandardId}; 7use embassy_stm32::can::{
8use embassy_stm32::can::{Can, Rx0InterruptHandler, Rx1InterruptHandler, SceInterruptHandler, TxInterruptHandler}; 8 filter, Can, Fifo, Frame, Id, Rx0InterruptHandler, Rx1InterruptHandler, SceInterruptHandler, StandardId,
9 TxInterruptHandler,
10};
9use embassy_stm32::peripherals::CAN; 11use embassy_stm32::peripherals::CAN;
10use embassy_stm32::{bind_interrupts, Config}; 12use embassy_stm32::{bind_interrupts, Config};
13use static_cell::StaticCell;
11use {defmt_rtt as _, panic_probe as _}; 14use {defmt_rtt as _, panic_probe as _};
12 15
13bind_interrupts!(struct Irqs { 16bind_interrupts!(struct Irqs {
@@ -20,6 +23,27 @@ bind_interrupts!(struct Irqs {
20// This example is configured to work with real CAN transceivers on B8/B9. 23// This example is configured to work with real CAN transceivers on B8/B9.
21// See other examples for loopback. 24// See other examples for loopback.
22 25
26fn handle_frame(env: Envelope, read_mode: &str) {
27 match env.frame.id() {
28 Id::Extended(id) => {
29 defmt::println!(
30 "{} Extended Frame id={:x} {:02x}",
31 read_mode,
32 id.as_raw(),
33 env.frame.data()
34 );
35 }
36 Id::Standard(id) => {
37 defmt::println!(
38 "{} Standard Frame id={:x} {:02x}",
39 read_mode,
40 id.as_raw(),
41 env.frame.data()
42 );
43 }
44 }
45}
46
23#[embassy_executor::main] 47#[embassy_executor::main]
24async fn main(_spawner: Spawner) { 48async fn main(_spawner: Spawner) {
25 let p = embassy_stm32::init(Config::default()); 49 let p = embassy_stm32::init(Config::default());
@@ -27,36 +51,86 @@ async fn main(_spawner: Spawner) {
27 // Set alternate pin mapping to B8/B9 51 // Set alternate pin mapping to B8/B9
28 embassy_stm32::pac::AFIO.mapr().modify(|w| w.set_can1_remap(2)); 52 embassy_stm32::pac::AFIO.mapr().modify(|w| w.set_can1_remap(2));
29 53
54 static RX_BUF: StaticCell<embassy_stm32::can::RxBuf<10>> = StaticCell::new();
55 static TX_BUF: StaticCell<embassy_stm32::can::TxBuf<10>> = StaticCell::new();
56
30 let mut can = Can::new(p.CAN, p.PB8, p.PB9, Irqs); 57 let mut can = Can::new(p.CAN, p.PB8, p.PB9, Irqs);
31 58
32 can.as_mut() 59 can.modify_filters()
33 .modify_filters() 60 .enable_bank(0, Fifo::Fifo0, filter::Mask32::accept_all());
34 .enable_bank(0, Fifo::Fifo0, Mask32::accept_all());
35 61
36 can.as_mut() 62 can.modify_config()
37 .modify_config()
38 .set_loopback(false) 63 .set_loopback(false)
39 .set_silent(false) 64 .set_silent(false)
40 .leave_disabled(); 65 .set_bitrate(250_000);
41
42 can.set_bitrate(250_000);
43 66
44 can.enable().await; 67 can.enable().await;
45
46 let mut i: u8 = 0; 68 let mut i: u8 = 0;
69
70 /*
71 // Example for using buffered Tx and Rx without needing to
72 // split first as is done below.
73 let mut can = can.buffered(
74 TX_BUF.init(embassy_stm32::can::TxBuf::<10>::new()),
75 RX_BUF.init(embassy_stm32::can::RxBuf::<10>::new()));
76 loop {
77 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), &[i, 0, 1, 2, 3, 4, 5, 6]).unwrap();
78 can.write(&tx_frame).await;
79
80 match can.read().await {
81 Ok((frame, ts)) => {
82 handle_frame(Envelope { ts, frame }, "Buf");
83 }
84 Err(err) => {
85 defmt::println!("Error {}", err);
86 }
87 }
88 i += 1;
89 }
90
91 */
92 let (mut tx, mut rx) = can.split();
93
94 // This example shows using the wait_not_empty API before try read
95 while i < 3 {
96 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), &[i, 0, 1, 2, 3, 4, 5, 6]).unwrap();
97 tx.write(&tx_frame).await;
98
99 rx.wait_not_empty().await;
100 let env = rx.try_read().unwrap();
101 handle_frame(env, "Wait");
102 i += 1;
103 }
104
105 // This example shows using the full async non-buffered API
106 while i < 6 {
107 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), &[i, 0, 1, 2, 3, 4, 5, 6]).unwrap();
108 tx.write(&tx_frame).await;
109
110 match rx.read().await {
111 Ok(env) => {
112 handle_frame(env, "NoBuf");
113 }
114 Err(err) => {
115 defmt::println!("Error {}", err);
116 }
117 }
118 i += 1;
119 }
120
121 // This example shows using buffered RX and TX. User passes in desired buffer (size)
122 // It's possible this way to have just RX or TX buffered.
123 let mut rx = rx.buffered(RX_BUF.init(embassy_stm32::can::RxBuf::<10>::new()));
124 let mut tx = tx.buffered(TX_BUF.init(embassy_stm32::can::TxBuf::<10>::new()));
125
47 loop { 126 loop {
48 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), [i]); 127 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), &[i, 0, 1, 2, 3, 4, 5, 6]).unwrap();
49 can.write(&tx_frame).await; 128 tx.write(&tx_frame).await;
50 129
51 match can.read().await { 130 match rx.read().await {
52 Ok(env) => match env.frame.id() { 131 Ok(envelope) => {
53 Id::Extended(id) => { 132 handle_frame(envelope, "Buf");
54 defmt::println!("Extended Frame id={:x}", id.as_raw()); 133 }
55 }
56 Id::Standard(id) => {
57 defmt::println!("Standard Frame id={:x}", id.as_raw());
58 }
59 },
60 Err(err) => { 134 Err(err) => {
61 defmt::println!("Error {}", err); 135 defmt::println!("Error {}", err);
62 } 136 }
diff --git a/examples/stm32f1/src/bin/usb_serial.rs b/examples/stm32f1/src/bin/usb_serial.rs
index 1ae6c1dee..ee99acf41 100644
--- a/examples/stm32f1/src/bin/usb_serial.rs
+++ b/examples/stm32f1/src/bin/usb_serial.rs
@@ -60,7 +60,6 @@ async fn main(_spawner: Spawner) {
60 60
61 // Create embassy-usb DeviceBuilder using the driver and config. 61 // Create embassy-usb DeviceBuilder using the driver and config.
62 // It needs some buffers for building the descriptors. 62 // It needs some buffers for building the descriptors.
63 let mut device_descriptor = [0; 256];
64 let mut config_descriptor = [0; 256]; 63 let mut config_descriptor = [0; 256];
65 let mut bos_descriptor = [0; 256]; 64 let mut bos_descriptor = [0; 256];
66 let mut control_buf = [0; 7]; 65 let mut control_buf = [0; 7];
@@ -70,7 +69,6 @@ async fn main(_spawner: Spawner) {
70 let mut builder = Builder::new( 69 let mut builder = Builder::new(
71 driver, 70 driver,
72 config, 71 config,
73 &mut device_descriptor,
74 &mut config_descriptor, 72 &mut config_descriptor,
75 &mut bos_descriptor, 73 &mut bos_descriptor,
76 &mut [], // no msos descriptors 74 &mut [], // no msos descriptors
diff --git a/examples/stm32f2/src/bin/pll.rs b/examples/stm32f2/src/bin/pll.rs
index e32f283d1..e39e2daec 100644
--- a/examples/stm32f2/src/bin/pll.rs
+++ b/examples/stm32f2/src/bin/pll.rs
@@ -1,8 +1,6 @@
1#![no_std] 1#![no_std]
2#![no_main] 2#![no_main]
3 3
4use core::convert::TryFrom;
5
6use defmt::*; 4use defmt::*;
7use embassy_executor::Spawner; 5use embassy_executor::Spawner;
8use embassy_stm32::time::Hertz; 6use embassy_stm32::time::Hertz;
diff --git a/examples/stm32f3/src/bin/usb_serial.rs b/examples/stm32f3/src/bin/usb_serial.rs
index ee1c43afd..5760f2c1c 100644
--- a/examples/stm32f3/src/bin/usb_serial.rs
+++ b/examples/stm32f3/src/bin/usb_serial.rs
@@ -54,7 +54,6 @@ async fn main(_spawner: Spawner) {
54 54
55 // Create embassy-usb DeviceBuilder using the driver and config. 55 // Create embassy-usb DeviceBuilder using the driver and config.
56 // It needs some buffers for building the descriptors. 56 // It needs some buffers for building the descriptors.
57 let mut device_descriptor = [0; 256];
58 let mut config_descriptor = [0; 256]; 57 let mut config_descriptor = [0; 256];
59 let mut bos_descriptor = [0; 256]; 58 let mut bos_descriptor = [0; 256];
60 let mut control_buf = [0; 7]; 59 let mut control_buf = [0; 7];
@@ -64,7 +63,6 @@ async fn main(_spawner: Spawner) {
64 let mut builder = Builder::new( 63 let mut builder = Builder::new(
65 driver, 64 driver,
66 config, 65 config,
67 &mut device_descriptor,
68 &mut config_descriptor, 66 &mut config_descriptor,
69 &mut bos_descriptor, 67 &mut bos_descriptor,
70 &mut [], // no msos descriptors 68 &mut [], // no msos descriptors
diff --git a/examples/stm32f4/src/bin/can.rs b/examples/stm32f4/src/bin/can.rs
index d074b4265..cedc057a7 100644
--- a/examples/stm32f4/src/bin/can.rs
+++ b/examples/stm32f4/src/bin/can.rs
@@ -4,9 +4,10 @@
4use defmt::*; 4use defmt::*;
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::bind_interrupts; 6use embassy_stm32::bind_interrupts;
7use embassy_stm32::can::bxcan::filter::Mask32; 7use embassy_stm32::can::filter::Mask32;
8use embassy_stm32::can::bxcan::{Fifo, Frame, StandardId}; 8use embassy_stm32::can::{
9use embassy_stm32::can::{Can, Rx0InterruptHandler, Rx1InterruptHandler, SceInterruptHandler, TxInterruptHandler}; 9 Can, Fifo, Frame, Rx0InterruptHandler, Rx1InterruptHandler, SceInterruptHandler, StandardId, TxInterruptHandler,
10};
10use embassy_stm32::gpio::{Input, Pull}; 11use embassy_stm32::gpio::{Input, Pull};
11use embassy_stm32::peripherals::CAN1; 12use embassy_stm32::peripherals::CAN1;
12use embassy_time::Instant; 13use embassy_time::Instant;
@@ -34,23 +35,18 @@ async fn main(_spawner: Spawner) {
34 35
35 let mut can = Can::new(p.CAN1, p.PA11, p.PA12, Irqs); 36 let mut can = Can::new(p.CAN1, p.PA11, p.PA12, Irqs);
36 37
37 can.as_mut() 38 can.modify_filters().enable_bank(0, Fifo::Fifo0, Mask32::accept_all());
38 .modify_filters()
39 .enable_bank(0, Fifo::Fifo0, Mask32::accept_all());
40 39
41 can.as_mut() 40 can.modify_config()
42 .modify_config()
43 .set_loopback(true) // Receive own frames 41 .set_loopback(true) // Receive own frames
44 .set_silent(true) 42 .set_silent(true)
45 .leave_disabled(); 43 .set_bitrate(1_000_000);
46
47 can.set_bitrate(1_000_000);
48 44
49 can.enable().await; 45 can.enable().await;
50 46
51 let mut i: u8 = 0; 47 let mut i: u8 = 0;
52 loop { 48 loop {
53 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), [i]); 49 let tx_frame = Frame::new_data(unwrap!(StandardId::new(i as _)), &[i]).unwrap();
54 let tx_ts = Instant::now(); 50 let tx_ts = Instant::now();
55 can.write(&tx_frame).await; 51 can.write(&tx_frame).await;
56 52
@@ -64,7 +60,7 @@ async fn main(_spawner: Spawner) {
64 60
65 info!( 61 info!(
66 "loopback frame {=u8}, latency: {} us", 62 "loopback frame {=u8}, latency: {} us",
67 unwrap!(envelope.frame.data())[0], 63 envelope.frame.data()[0],
68 latency.as_micros() 64 latency.as_micros()
69 ); 65 );
70 i += 1; 66 i += 1;
diff --git a/examples/stm32f4/src/bin/usb_ethernet.rs b/examples/stm32f4/src/bin/usb_ethernet.rs
index a196259a8..d2cbeea1b 100644
--- a/examples/stm32f4/src/bin/usb_ethernet.rs
+++ b/examples/stm32f4/src/bin/usb_ethernet.rs
@@ -7,8 +7,8 @@ use embassy_net::tcp::TcpSocket;
7use embassy_net::{Stack, StackResources}; 7use embassy_net::{Stack, StackResources};
8use embassy_stm32::rng::{self, Rng}; 8use embassy_stm32::rng::{self, Rng};
9use embassy_stm32::time::Hertz; 9use embassy_stm32::time::Hertz;
10use embassy_stm32::usb_otg::Driver; 10use embassy_stm32::usb::Driver;
11use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 11use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
12use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState}; 12use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState};
13use embassy_usb::class::cdc_ncm::{CdcNcmClass, State}; 13use embassy_usb::class::cdc_ncm::{CdcNcmClass, State};
14use embassy_usb::{Builder, UsbDevice}; 14use embassy_usb::{Builder, UsbDevice};
@@ -36,7 +36,7 @@ async fn net_task(stack: &'static Stack<Device<'static, MTU>>) -> ! {
36} 36}
37 37
38bind_interrupts!(struct Irqs { 38bind_interrupts!(struct Irqs {
39 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 39 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
40 HASH_RNG => rng::InterruptHandler<peripherals::RNG>; 40 HASH_RNG => rng::InterruptHandler<peripherals::RNG>;
41}); 41});
42 42
@@ -63,13 +63,14 @@ async fn main(spawner: Spawner) {
63 config.rcc.apb1_pre = APBPrescaler::DIV4; 63 config.rcc.apb1_pre = APBPrescaler::DIV4;
64 config.rcc.apb2_pre = APBPrescaler::DIV2; 64 config.rcc.apb2_pre = APBPrescaler::DIV2;
65 config.rcc.sys = Sysclk::PLL1_P; 65 config.rcc.sys = Sysclk::PLL1_P;
66 config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
66 } 67 }
67 let p = embassy_stm32::init(config); 68 let p = embassy_stm32::init(config);
68 69
69 // Create the driver, from the HAL. 70 // Create the driver, from the HAL.
70 static OUTPUT_BUFFER: StaticCell<[u8; 256]> = StaticCell::new(); 71 static OUTPUT_BUFFER: StaticCell<[u8; 256]> = StaticCell::new();
71 let ep_out_buffer = &mut OUTPUT_BUFFER.init([0; 256])[..]; 72 let ep_out_buffer = &mut OUTPUT_BUFFER.init([0; 256])[..];
72 let mut config = embassy_stm32::usb_otg::Config::default(); 73 let mut config = embassy_stm32::usb::Config::default();
73 config.vbus_detection = true; 74 config.vbus_detection = true;
74 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, ep_out_buffer, config); 75 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, ep_out_buffer, config);
75 76
@@ -88,14 +89,12 @@ async fn main(spawner: Spawner) {
88 config.device_protocol = 0x01; 89 config.device_protocol = 0x01;
89 90
90 // Create embassy-usb DeviceBuilder using the driver and config. 91 // Create embassy-usb DeviceBuilder using the driver and config.
91 static DEVICE_DESC: StaticCell<[u8; 256]> = StaticCell::new();
92 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 92 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
93 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 93 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
94 static CONTROL_BUF: StaticCell<[u8; 128]> = StaticCell::new(); 94 static CONTROL_BUF: StaticCell<[u8; 128]> = StaticCell::new();
95 let mut builder = Builder::new( 95 let mut builder = Builder::new(
96 driver, 96 driver,
97 config, 97 config,
98 &mut DEVICE_DESC.init([0; 256])[..],
99 &mut CONFIG_DESC.init([0; 256])[..], 98 &mut CONFIG_DESC.init([0; 256])[..],
100 &mut BOS_DESC.init([0; 256])[..], 99 &mut BOS_DESC.init([0; 256])[..],
101 &mut [], // no msos descriptors 100 &mut [], // no msos descriptors
diff --git a/examples/stm32f4/src/bin/usb_hid_keyboard.rs b/examples/stm32f4/src/bin/usb_hid_keyboard.rs
new file mode 100644
index 000000000..a799b4e72
--- /dev/null
+++ b/examples/stm32f4/src/bin/usb_hid_keyboard.rs
@@ -0,0 +1,221 @@
1#![no_std]
2#![no_main]
3
4use core::sync::atomic::{AtomicBool, Ordering};
5
6use defmt::*;
7use embassy_executor::Spawner;
8use embassy_stm32::exti::ExtiInput;
9use embassy_stm32::gpio::Pull;
10use embassy_stm32::time::Hertz;
11use embassy_stm32::usb::Driver;
12use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
13use embassy_usb::class::hid::{HidReaderWriter, ReportId, RequestHandler, State};
14use embassy_usb::control::OutResponse;
15use embassy_usb::{Builder, Handler};
16use futures::future::join;
17use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
18use {defmt_rtt as _, panic_probe as _};
19
20bind_interrupts!(struct Irqs {
21 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
22});
23
24#[embassy_executor::main]
25async fn main(_spawner: Spawner) {
26 let mut config = Config::default();
27 {
28 use embassy_stm32::rcc::*;
29 config.rcc.hse = Some(Hse {
30 freq: Hertz(8_000_000),
31 mode: HseMode::Bypass,
32 });
33 config.rcc.pll_src = PllSource::HSE;
34 config.rcc.pll = Some(Pll {
35 prediv: PllPreDiv::DIV4,
36 mul: PllMul::MUL168,
37 divp: Some(PllPDiv::DIV2), // 8mhz / 4 * 168 / 2 = 168Mhz.
38 divq: Some(PllQDiv::DIV7), // 8mhz / 4 * 168 / 7 = 48Mhz.
39 divr: None,
40 });
41 config.rcc.ahb_pre = AHBPrescaler::DIV1;
42 config.rcc.apb1_pre = APBPrescaler::DIV4;
43 config.rcc.apb2_pre = APBPrescaler::DIV2;
44 config.rcc.sys = Sysclk::PLL1_P;
45 config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
46 }
47 let p = embassy_stm32::init(config);
48
49 // Create the driver, from the HAL.
50 let mut ep_out_buffer = [0u8; 256];
51 let mut config = embassy_stm32::usb::Config::default();
52 config.vbus_detection = true;
53 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
54
55 // Create embassy-usb Config
56 let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
57 config.manufacturer = Some("Embassy");
58 config.product = Some("HID keyboard example");
59 config.serial_number = Some("12345678");
60 config.max_power = 100;
61 config.max_packet_size_0 = 64;
62
63 // Required for windows compatibility.
64 // https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
65 config.device_class = 0xEF;
66 config.device_sub_class = 0x02;
67 config.device_protocol = 0x01;
68 config.composite_with_iads = true;
69
70 // Create embassy-usb DeviceBuilder using the driver and config.
71 // It needs some buffers for building the descriptors.
72 let mut config_descriptor = [0; 256];
73 let mut bos_descriptor = [0; 256];
74 // You can also add a Microsoft OS descriptor.
75 let mut msos_descriptor = [0; 256];
76 let mut control_buf = [0; 64];
77
78 let request_handler = MyRequestHandler {};
79 let mut device_handler = MyDeviceHandler::new();
80
81 let mut state = State::new();
82
83 let mut builder = Builder::new(
84 driver,
85 config,
86 &mut config_descriptor,
87 &mut bos_descriptor,
88 &mut msos_descriptor,
89 &mut control_buf,
90 );
91
92 builder.handler(&mut device_handler);
93
94 // Create classes on the builder.
95 let config = embassy_usb::class::hid::Config {
96 report_descriptor: KeyboardReport::desc(),
97 request_handler: Some(&request_handler),
98 poll_ms: 60,
99 max_packet_size: 8,
100 };
101
102 let hid = HidReaderWriter::<_, 1, 8>::new(&mut builder, &mut state, config);
103
104 // Build the builder.
105 let mut usb = builder.build();
106
107 // Run the USB device.
108 let usb_fut = usb.run();
109
110 let (reader, mut writer) = hid.split();
111
112 let mut button = ExtiInput::new(p.PC13, p.EXTI13, Pull::Down);
113
114 // Do stuff with the class!
115 let in_fut = async {
116 loop {
117 button.wait_for_rising_edge().await;
118 // signal_pin.wait_for_high().await;
119 info!("Button pressed!");
120 // Create a report with the A key pressed. (no shift modifier)
121 let report = KeyboardReport {
122 keycodes: [4, 0, 0, 0, 0, 0],
123 leds: 0,
124 modifier: 0,
125 reserved: 0,
126 };
127 // Send the report.
128 match writer.write_serialize(&report).await {
129 Ok(()) => {}
130 Err(e) => warn!("Failed to send report: {:?}", e),
131 };
132
133 button.wait_for_falling_edge().await;
134 // signal_pin.wait_for_low().await;
135 info!("Button released!");
136 let report = KeyboardReport {
137 keycodes: [0, 0, 0, 0, 0, 0],
138 leds: 0,
139 modifier: 0,
140 reserved: 0,
141 };
142 match writer.write_serialize(&report).await {
143 Ok(()) => {}
144 Err(e) => warn!("Failed to send report: {:?}", e),
145 };
146 }
147 };
148
149 let out_fut = async {
150 reader.run(false, &request_handler).await;
151 };
152
153 // Run everything concurrently.
154 // If we had made everything `'static` above instead, we could do this using separate tasks instead.
155 join(usb_fut, join(in_fut, out_fut)).await;
156}
157
158struct MyRequestHandler {}
159
160impl RequestHandler for MyRequestHandler {
161 fn get_report(&self, id: ReportId, _buf: &mut [u8]) -> Option<usize> {
162 info!("Get report for {:?}", id);
163 None
164 }
165
166 fn set_report(&self, id: ReportId, data: &[u8]) -> OutResponse {
167 info!("Set report for {:?}: {=[u8]}", id, data);
168 OutResponse::Accepted
169 }
170
171 fn set_idle_ms(&self, id: Option<ReportId>, dur: u32) {
172 info!("Set idle rate for {:?} to {:?}", id, dur);
173 }
174
175 fn get_idle_ms(&self, id: Option<ReportId>) -> Option<u32> {
176 info!("Get idle rate for {:?}", id);
177 None
178 }
179}
180
181struct MyDeviceHandler {
182 configured: AtomicBool,
183}
184
185impl MyDeviceHandler {
186 fn new() -> Self {
187 MyDeviceHandler {
188 configured: AtomicBool::new(false),
189 }
190 }
191}
192
193impl Handler for MyDeviceHandler {
194 fn enabled(&mut self, enabled: bool) {
195 self.configured.store(false, Ordering::Relaxed);
196 if enabled {
197 info!("Device enabled");
198 } else {
199 info!("Device disabled");
200 }
201 }
202
203 fn reset(&mut self) {
204 self.configured.store(false, Ordering::Relaxed);
205 info!("Bus reset, the Vbus current limit is 100mA");
206 }
207
208 fn addressed(&mut self, addr: u8) {
209 self.configured.store(false, Ordering::Relaxed);
210 info!("USB address set to: {}", addr);
211 }
212
213 fn configured(&mut self, configured: bool) {
214 self.configured.store(configured, Ordering::Relaxed);
215 if configured {
216 info!("Device configured, it may now draw up to the configured current limit from Vbus.")
217 } else {
218 info!("Device is no longer configured, the Vbus current limit is 100mA.");
219 }
220 }
221}
diff --git a/examples/stm32f4/src/bin/usb_hid_mouse.rs b/examples/stm32f4/src/bin/usb_hid_mouse.rs
index c98792880..0bc236119 100644
--- a/examples/stm32f4/src/bin/usb_hid_mouse.rs
+++ b/examples/stm32f4/src/bin/usb_hid_mouse.rs
@@ -4,8 +4,8 @@
4use defmt::*; 4use defmt::*;
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::time::Hertz; 6use embassy_stm32::time::Hertz;
7use embassy_stm32::usb_otg::Driver; 7use embassy_stm32::usb::Driver;
8use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
9use embassy_time::Timer; 9use embassy_time::Timer;
10use embassy_usb::class::hid::{HidWriter, ReportId, RequestHandler, State}; 10use embassy_usb::class::hid::{HidWriter, ReportId, RequestHandler, State};
11use embassy_usb::control::OutResponse; 11use embassy_usb::control::OutResponse;
@@ -15,7 +15,7 @@ use usbd_hid::descriptor::{MouseReport, SerializedDescriptor};
15use {defmt_rtt as _, panic_probe as _}; 15use {defmt_rtt as _, panic_probe as _};
16 16
17bind_interrupts!(struct Irqs { 17bind_interrupts!(struct Irqs {
18 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 18 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
19}); 19});
20 20
21#[embassy_executor::main] 21#[embassy_executor::main]
@@ -39,12 +39,13 @@ async fn main(_spawner: Spawner) {
39 config.rcc.apb1_pre = APBPrescaler::DIV4; 39 config.rcc.apb1_pre = APBPrescaler::DIV4;
40 config.rcc.apb2_pre = APBPrescaler::DIV2; 40 config.rcc.apb2_pre = APBPrescaler::DIV2;
41 config.rcc.sys = Sysclk::PLL1_P; 41 config.rcc.sys = Sysclk::PLL1_P;
42 config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
42 } 43 }
43 let p = embassy_stm32::init(config); 44 let p = embassy_stm32::init(config);
44 45
45 // Create the driver, from the HAL. 46 // Create the driver, from the HAL.
46 let mut ep_out_buffer = [0u8; 256]; 47 let mut ep_out_buffer = [0u8; 256];
47 let mut config = embassy_stm32::usb_otg::Config::default(); 48 let mut config = embassy_stm32::usb::Config::default();
48 config.vbus_detection = true; 49 config.vbus_detection = true;
49 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 50 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
50 51
@@ -63,7 +64,6 @@ async fn main(_spawner: Spawner) {
63 64
64 // Create embassy-usb DeviceBuilder using the driver and config. 65 // Create embassy-usb DeviceBuilder using the driver and config.
65 // It needs some buffers for building the descriptors. 66 // It needs some buffers for building the descriptors.
66 let mut device_descriptor = [0; 256];
67 let mut config_descriptor = [0; 256]; 67 let mut config_descriptor = [0; 256];
68 let mut bos_descriptor = [0; 256]; 68 let mut bos_descriptor = [0; 256];
69 let mut control_buf = [0; 64]; 69 let mut control_buf = [0; 64];
@@ -75,7 +75,6 @@ async fn main(_spawner: Spawner) {
75 let mut builder = Builder::new( 75 let mut builder = Builder::new(
76 driver, 76 driver,
77 config, 77 config,
78 &mut device_descriptor,
79 &mut config_descriptor, 78 &mut config_descriptor,
80 &mut bos_descriptor, 79 &mut bos_descriptor,
81 &mut [], // no msos descriptors 80 &mut [], // no msos descriptors
diff --git a/examples/stm32f4/src/bin/usb_raw.rs b/examples/stm32f4/src/bin/usb_raw.rs
index afff55187..4e583aeb8 100644
--- a/examples/stm32f4/src/bin/usb_raw.rs
+++ b/examples/stm32f4/src/bin/usb_raw.rs
@@ -52,8 +52,8 @@
52use defmt::*; 52use defmt::*;
53use embassy_executor::Spawner; 53use embassy_executor::Spawner;
54use embassy_stm32::time::Hertz; 54use embassy_stm32::time::Hertz;
55use embassy_stm32::usb_otg::Driver; 55use embassy_stm32::usb::Driver;
56use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 56use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
57use embassy_usb::control::{InResponse, OutResponse, Recipient, Request, RequestType}; 57use embassy_usb::control::{InResponse, OutResponse, Recipient, Request, RequestType};
58use embassy_usb::msos::{self, windows_version}; 58use embassy_usb::msos::{self, windows_version};
59use embassy_usb::types::InterfaceNumber; 59use embassy_usb::types::InterfaceNumber;
@@ -66,7 +66,7 @@ use {defmt_rtt as _, panic_probe as _};
66const DEVICE_INTERFACE_GUIDS: &[&str] = &["{DAC2087C-63FA-458D-A55D-827C0762DEC7}"]; 66const DEVICE_INTERFACE_GUIDS: &[&str] = &["{DAC2087C-63FA-458D-A55D-827C0762DEC7}"];
67 67
68bind_interrupts!(struct Irqs { 68bind_interrupts!(struct Irqs {
69 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 69 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
70}); 70});
71 71
72#[embassy_executor::main] 72#[embassy_executor::main]
@@ -92,12 +92,13 @@ async fn main(_spawner: Spawner) {
92 config.rcc.apb1_pre = APBPrescaler::DIV4; 92 config.rcc.apb1_pre = APBPrescaler::DIV4;
93 config.rcc.apb2_pre = APBPrescaler::DIV2; 93 config.rcc.apb2_pre = APBPrescaler::DIV2;
94 config.rcc.sys = Sysclk::PLL1_P; 94 config.rcc.sys = Sysclk::PLL1_P;
95 config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
95 } 96 }
96 let p = embassy_stm32::init(config); 97 let p = embassy_stm32::init(config);
97 98
98 // Create the driver, from the HAL. 99 // Create the driver, from the HAL.
99 let mut ep_out_buffer = [0u8; 256]; 100 let mut ep_out_buffer = [0u8; 256];
100 let mut config = embassy_stm32::usb_otg::Config::default(); 101 let mut config = embassy_stm32::usb::Config::default();
101 config.vbus_detection = true; 102 config.vbus_detection = true;
102 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 103 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
103 104
@@ -116,7 +117,6 @@ async fn main(_spawner: Spawner) {
116 117
117 // Create embassy-usb DeviceBuilder using the driver and config. 118 // Create embassy-usb DeviceBuilder using the driver and config.
118 // It needs some buffers for building the descriptors. 119 // It needs some buffers for building the descriptors.
119 let mut device_descriptor = [0; 256];
120 let mut config_descriptor = [0; 256]; 120 let mut config_descriptor = [0; 256];
121 let mut bos_descriptor = [0; 256]; 121 let mut bos_descriptor = [0; 256];
122 let mut msos_descriptor = [0; 256]; 122 let mut msos_descriptor = [0; 256];
@@ -129,7 +129,6 @@ async fn main(_spawner: Spawner) {
129 let mut builder = Builder::new( 129 let mut builder = Builder::new(
130 driver, 130 driver,
131 config, 131 config,
132 &mut device_descriptor,
133 &mut config_descriptor, 132 &mut config_descriptor,
134 &mut bos_descriptor, 133 &mut bos_descriptor,
135 &mut msos_descriptor, 134 &mut msos_descriptor,
diff --git a/examples/stm32f4/src/bin/usb_serial.rs b/examples/stm32f4/src/bin/usb_serial.rs
index 58d994a61..f3a375d31 100644
--- a/examples/stm32f4/src/bin/usb_serial.rs
+++ b/examples/stm32f4/src/bin/usb_serial.rs
@@ -4,8 +4,8 @@
4use defmt::{panic, *}; 4use defmt::{panic, *};
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::time::Hertz; 6use embassy_stm32::time::Hertz;
7use embassy_stm32::usb_otg::{Driver, Instance}; 7use embassy_stm32::usb::{Driver, Instance};
8use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
9use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 9use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
10use embassy_usb::driver::EndpointError; 10use embassy_usb::driver::EndpointError;
11use embassy_usb::Builder; 11use embassy_usb::Builder;
@@ -13,7 +13,7 @@ use futures::future::join;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs { 15bind_interrupts!(struct Irqs {
16 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 16 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
17}); 17});
18 18
19#[embassy_executor::main] 19#[embassy_executor::main]
@@ -39,12 +39,13 @@ async fn main(_spawner: Spawner) {
39 config.rcc.apb1_pre = APBPrescaler::DIV4; 39 config.rcc.apb1_pre = APBPrescaler::DIV4;
40 config.rcc.apb2_pre = APBPrescaler::DIV2; 40 config.rcc.apb2_pre = APBPrescaler::DIV2;
41 config.rcc.sys = Sysclk::PLL1_P; 41 config.rcc.sys = Sysclk::PLL1_P;
42 config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
42 } 43 }
43 let p = embassy_stm32::init(config); 44 let p = embassy_stm32::init(config);
44 45
45 // Create the driver, from the HAL. 46 // Create the driver, from the HAL.
46 let mut ep_out_buffer = [0u8; 256]; 47 let mut ep_out_buffer = [0u8; 256];
47 let mut config = embassy_stm32::usb_otg::Config::default(); 48 let mut config = embassy_stm32::usb::Config::default();
48 config.vbus_detection = true; 49 config.vbus_detection = true;
49 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 50 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
50 51
@@ -63,7 +64,6 @@ async fn main(_spawner: Spawner) {
63 64
64 // Create embassy-usb DeviceBuilder using the driver and config. 65 // Create embassy-usb DeviceBuilder using the driver and config.
65 // It needs some buffers for building the descriptors. 66 // It needs some buffers for building the descriptors.
66 let mut device_descriptor = [0; 256];
67 let mut config_descriptor = [0; 256]; 67 let mut config_descriptor = [0; 256];
68 let mut bos_descriptor = [0; 256]; 68 let mut bos_descriptor = [0; 256];
69 let mut control_buf = [0; 64]; 69 let mut control_buf = [0; 64];
@@ -73,7 +73,6 @@ async fn main(_spawner: Spawner) {
73 let mut builder = Builder::new( 73 let mut builder = Builder::new(
74 driver, 74 driver,
75 config, 75 config,
76 &mut device_descriptor,
77 &mut config_descriptor, 76 &mut config_descriptor,
78 &mut bos_descriptor, 77 &mut bos_descriptor,
79 &mut [], // no msos descriptors 78 &mut [], // no msos descriptors
diff --git a/examples/stm32f4/src/bin/ws2812_pwm.rs b/examples/stm32f4/src/bin/ws2812_pwm.rs
index 6122cea2d..cbaff75fc 100644
--- a/examples/stm32f4/src/bin/ws2812_pwm.rs
+++ b/examples/stm32f4/src/bin/ws2812_pwm.rs
@@ -15,8 +15,9 @@
15use embassy_executor::Spawner; 15use embassy_executor::Spawner;
16use embassy_stm32::gpio::OutputType; 16use embassy_stm32::gpio::OutputType;
17use embassy_stm32::time::khz; 17use embassy_stm32::time::khz;
18use embassy_stm32::timer::low_level::CountingMode;
18use embassy_stm32::timer::simple_pwm::{PwmPin, SimplePwm}; 19use embassy_stm32::timer::simple_pwm::{PwmPin, SimplePwm};
19use embassy_stm32::timer::{Channel, CountingMode}; 20use embassy_stm32::timer::Channel;
20use embassy_time::{Duration, Ticker, Timer}; 21use embassy_time::{Duration, Ticker, Timer};
21use {defmt_rtt as _, panic_probe as _}; 22use {defmt_rtt as _, panic_probe as _};
22 23
@@ -60,7 +61,7 @@ async fn main(_spawner: Spawner) {
60 // construct ws2812 non-return-to-zero (NRZ) code bit by bit 61 // construct ws2812 non-return-to-zero (NRZ) code bit by bit
61 // ws2812 only need 24 bits for each LED, but we add one bit more to keep PWM output low 62 // ws2812 only need 24 bits for each LED, but we add one bit more to keep PWM output low
62 63
63 let max_duty = ws2812_pwm.get_max_duty(); 64 let max_duty = ws2812_pwm.get_max_duty() as u16;
64 let n0 = 8 * max_duty / 25; // ws2812 Bit 0 high level timing 65 let n0 = 8 * max_duty / 25; // ws2812 Bit 0 high level timing
65 let n1 = 2 * n0; // ws2812 Bit 1 high level timing 66 let n1 = 2 * n0; // ws2812 Bit 1 high level timing
66 67
diff --git a/examples/stm32f7/src/bin/can.rs b/examples/stm32f7/src/bin/can.rs
index bcfdb67a8..e32b4d3df 100644
--- a/examples/stm32f7/src/bin/can.rs
+++ b/examples/stm32f7/src/bin/can.rs
@@ -1,16 +1,18 @@
1#![no_std] 1#![no_std]
2#![no_main] 2#![no_main]
3 3
4use core::num::{NonZeroU16, NonZeroU8};
5
4use defmt::*; 6use defmt::*;
5use embassy_executor::Spawner; 7use embassy_executor::Spawner;
6use embassy_stm32::bind_interrupts; 8use embassy_stm32::can::filter::Mask32;
7use embassy_stm32::can::bxcan::filter::Mask32;
8use embassy_stm32::can::bxcan::{Fifo, Frame, StandardId};
9use embassy_stm32::can::{ 9use embassy_stm32::can::{
10 Can, CanTx, Rx0InterruptHandler, Rx1InterruptHandler, SceInterruptHandler, TxInterruptHandler, 10 Can, CanTx, Fifo, Frame, Rx0InterruptHandler, Rx1InterruptHandler, SceInterruptHandler, StandardId,
11 TxInterruptHandler,
11}; 12};
12use embassy_stm32::gpio::{Input, Pull}; 13use embassy_stm32::gpio::{Input, Pull};
13use embassy_stm32::peripherals::CAN3; 14use embassy_stm32::peripherals::CAN3;
15use embassy_stm32::{bind_interrupts, can};
14use static_cell::StaticCell; 16use static_cell::StaticCell;
15use {defmt_rtt as _, panic_probe as _}; 17use {defmt_rtt as _, panic_probe as _};
16 18
@@ -22,9 +24,9 @@ bind_interrupts!(struct Irqs {
22}); 24});
23 25
24#[embassy_executor::task] 26#[embassy_executor::task]
25pub async fn send_can_message(tx: &'static mut CanTx<'static, 'static, CAN3>) { 27pub async fn send_can_message(tx: &'static mut CanTx<'static, CAN3>) {
26 loop { 28 loop {
27 let frame = Frame::new_data(unwrap!(StandardId::new(0 as _)), [0]); 29 let frame = Frame::new_data(unwrap!(StandardId::new(0 as _)), &[0]).unwrap();
28 tx.write(&frame).await; 30 tx.write(&frame).await;
29 embassy_time::Timer::after_secs(1).await; 31 embassy_time::Timer::after_secs(1).await;
30 } 32 }
@@ -45,19 +47,22 @@ async fn main(spawner: Spawner) {
45 47
46 static CAN: StaticCell<Can<'static, CAN3>> = StaticCell::new(); 48 static CAN: StaticCell<Can<'static, CAN3>> = StaticCell::new();
47 let can = CAN.init(Can::new(p.CAN3, p.PA8, p.PA15, Irqs)); 49 let can = CAN.init(Can::new(p.CAN3, p.PA8, p.PA15, Irqs));
48 can.as_mut() 50 can.modify_filters().enable_bank(0, Fifo::Fifo0, Mask32::accept_all());
49 .modify_filters() 51
50 .enable_bank(0, Fifo::Fifo0, Mask32::accept_all()); 52 can.modify_config()
53 .set_bit_timing(can::util::NominalBitTiming {
54 prescaler: NonZeroU16::new(2).unwrap(),
55 seg1: NonZeroU8::new(13).unwrap(),
56 seg2: NonZeroU8::new(2).unwrap(),
57 sync_jump_width: NonZeroU8::new(1).unwrap(),
58 }) // http://www.bittiming.can-wiki.info/
59 .set_loopback(true);
51 60
52 can.as_mut() 61 can.enable().await;
53 .modify_config()
54 .set_bit_timing(0x001c0001) // http://www.bittiming.can-wiki.info/
55 .set_loopback(true)
56 .enable();
57 62
58 let (tx, mut rx) = can.split(); 63 let (tx, mut rx) = can.split();
59 64
60 static CAN_TX: StaticCell<CanTx<'static, 'static, CAN3>> = StaticCell::new(); 65 static CAN_TX: StaticCell<CanTx<'static, CAN3>> = StaticCell::new();
61 let tx = CAN_TX.init(tx); 66 let tx = CAN_TX.init(tx);
62 spawner.spawn(send_can_message(tx)).unwrap(); 67 spawner.spawn(send_can_message(tx)).unwrap();
63 68
diff --git a/examples/stm32f7/src/bin/cryp.rs b/examples/stm32f7/src/bin/cryp.rs
index 04927841a..235853cb9 100644
--- a/examples/stm32f7/src/bin/cryp.rs
+++ b/examples/stm32f7/src/bin/cryp.rs
@@ -6,11 +6,15 @@ use aes_gcm::aead::{AeadInPlace, KeyInit};
6use aes_gcm::Aes128Gcm; 6use aes_gcm::Aes128Gcm;
7use defmt::info; 7use defmt::info;
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_stm32::cryp::*; 9use embassy_stm32::cryp::{self, *};
10use embassy_stm32::Config; 10use embassy_stm32::{bind_interrupts, peripherals, Config};
11use embassy_time::Instant; 11use embassy_time::Instant;
12use {defmt_rtt as _, panic_probe as _}; 12use {defmt_rtt as _, panic_probe as _};
13 13
14bind_interrupts!(struct Irqs {
15 CRYP => cryp::InterruptHandler<peripherals::CRYP>;
16});
17
14#[embassy_executor::main] 18#[embassy_executor::main]
15async fn main(_spawner: Spawner) -> ! { 19async fn main(_spawner: Spawner) -> ! {
16 let config = Config::default(); 20 let config = Config::default();
@@ -19,7 +23,7 @@ async fn main(_spawner: Spawner) -> ! {
19 let payload: &[u8] = b"hello world"; 23 let payload: &[u8] = b"hello world";
20 let aad: &[u8] = b"additional data"; 24 let aad: &[u8] = b"additional data";
21 25
22 let hw_cryp = Cryp::new(p.CRYP); 26 let mut hw_cryp = Cryp::new(p.CRYP, p.DMA2_CH6, p.DMA2_CH5, Irqs);
23 let key: [u8; 16] = [0; 16]; 27 let key: [u8; 16] = [0; 16];
24 let mut ciphertext: [u8; 11] = [0; 11]; 28 let mut ciphertext: [u8; 11] = [0; 11];
25 let mut plaintext: [u8; 11] = [0; 11]; 29 let mut plaintext: [u8; 11] = [0; 11];
@@ -29,16 +33,18 @@ async fn main(_spawner: Spawner) -> ! {
29 33
30 // Encrypt in hardware using AES-GCM 128-bit 34 // Encrypt in hardware using AES-GCM 128-bit
31 let aes_gcm = AesGcm::new(&key, &iv); 35 let aes_gcm = AesGcm::new(&key, &iv);
32 let mut gcm_encrypt = hw_cryp.start(&aes_gcm, Direction::Encrypt); 36 let mut gcm_encrypt = hw_cryp.start(&aes_gcm, Direction::Encrypt).await;
33 hw_cryp.aad_blocking(&mut gcm_encrypt, aad, true); 37 hw_cryp.aad(&mut gcm_encrypt, aad, true).await;
34 hw_cryp.payload_blocking(&mut gcm_encrypt, payload, &mut ciphertext, true); 38 hw_cryp.payload(&mut gcm_encrypt, payload, &mut ciphertext, true).await;
35 let encrypt_tag = hw_cryp.finish_blocking(gcm_encrypt); 39 let encrypt_tag = hw_cryp.finish(gcm_encrypt).await;
36 40
37 // Decrypt in hardware using AES-GCM 128-bit 41 // Decrypt in hardware using AES-GCM 128-bit
38 let mut gcm_decrypt = hw_cryp.start(&aes_gcm, Direction::Decrypt); 42 let mut gcm_decrypt = hw_cryp.start(&aes_gcm, Direction::Decrypt).await;
39 hw_cryp.aad_blocking(&mut gcm_decrypt, aad, true); 43 hw_cryp.aad(&mut gcm_decrypt, aad, true).await;
40 hw_cryp.payload_blocking(&mut gcm_decrypt, &ciphertext, &mut plaintext, true); 44 hw_cryp
41 let decrypt_tag = hw_cryp.finish_blocking(gcm_decrypt); 45 .payload(&mut gcm_decrypt, &ciphertext, &mut plaintext, true)
46 .await;
47 let decrypt_tag = hw_cryp.finish(gcm_decrypt).await;
42 48
43 let hw_end_time = Instant::now(); 49 let hw_end_time = Instant::now();
44 let hw_execution_time = hw_end_time - hw_start_time; 50 let hw_execution_time = hw_end_time - hw_start_time;
diff --git a/examples/stm32f7/src/bin/usb_serial.rs b/examples/stm32f7/src/bin/usb_serial.rs
index 97daf6bd1..39a5512f4 100644
--- a/examples/stm32f7/src/bin/usb_serial.rs
+++ b/examples/stm32f7/src/bin/usb_serial.rs
@@ -4,8 +4,8 @@
4use defmt::{panic, *}; 4use defmt::{panic, *};
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::time::Hertz; 6use embassy_stm32::time::Hertz;
7use embassy_stm32::usb_otg::{Driver, Instance}; 7use embassy_stm32::usb::{Driver, Instance};
8use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
9use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 9use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
10use embassy_usb::driver::EndpointError; 10use embassy_usb::driver::EndpointError;
11use embassy_usb::Builder; 11use embassy_usb::Builder;
@@ -13,7 +13,7 @@ use futures::future::join;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
15bind_interrupts!(struct Irqs { 15bind_interrupts!(struct Irqs {
16 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 16 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
17}); 17});
18 18
19#[embassy_executor::main] 19#[embassy_executor::main]
@@ -39,12 +39,13 @@ async fn main(_spawner: Spawner) {
39 config.rcc.apb1_pre = APBPrescaler::DIV4; 39 config.rcc.apb1_pre = APBPrescaler::DIV4;
40 config.rcc.apb2_pre = APBPrescaler::DIV2; 40 config.rcc.apb2_pre = APBPrescaler::DIV2;
41 config.rcc.sys = Sysclk::PLL1_P; 41 config.rcc.sys = Sysclk::PLL1_P;
42 config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
42 } 43 }
43 let p = embassy_stm32::init(config); 44 let p = embassy_stm32::init(config);
44 45
45 // Create the driver, from the HAL. 46 // Create the driver, from the HAL.
46 let mut ep_out_buffer = [0u8; 256]; 47 let mut ep_out_buffer = [0u8; 256];
47 let mut config = embassy_stm32::usb_otg::Config::default(); 48 let mut config = embassy_stm32::usb::Config::default();
48 config.vbus_detection = true; 49 config.vbus_detection = true;
49 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 50 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
50 51
@@ -63,7 +64,6 @@ async fn main(_spawner: Spawner) {
63 64
64 // Create embassy-usb DeviceBuilder using the driver and config. 65 // Create embassy-usb DeviceBuilder using the driver and config.
65 // It needs some buffers for building the descriptors. 66 // It needs some buffers for building the descriptors.
66 let mut device_descriptor = [0; 256];
67 let mut config_descriptor = [0; 256]; 67 let mut config_descriptor = [0; 256];
68 let mut bos_descriptor = [0; 256]; 68 let mut bos_descriptor = [0; 256];
69 let mut control_buf = [0; 64]; 69 let mut control_buf = [0; 64];
@@ -73,7 +73,6 @@ async fn main(_spawner: Spawner) {
73 let mut builder = Builder::new( 73 let mut builder = Builder::new(
74 driver, 74 driver,
75 config, 75 config,
76 &mut device_descriptor,
77 &mut config_descriptor, 76 &mut config_descriptor,
78 &mut bos_descriptor, 77 &mut bos_descriptor,
79 &mut [], // no msos descriptors 78 &mut [], // no msos descriptors
diff --git a/examples/stm32g0/src/bin/usb_serial.rs b/examples/stm32g0/src/bin/usb_serial.rs
index 8b9915626..162dfd86b 100644
--- a/examples/stm32g0/src/bin/usb_serial.rs
+++ b/examples/stm32g0/src/bin/usb_serial.rs
@@ -36,7 +36,6 @@ async fn main(_spawner: Spawner) {
36 36
37 // Create embassy-usb DeviceBuilder using the driver and config. 37 // Create embassy-usb DeviceBuilder using the driver and config.
38 // It needs some buffers for building the descriptors. 38 // It needs some buffers for building the descriptors.
39 let mut device_descriptor = [0; 256];
40 let mut config_descriptor = [0; 256]; 39 let mut config_descriptor = [0; 256];
41 let mut bos_descriptor = [0; 256]; 40 let mut bos_descriptor = [0; 256];
42 let mut control_buf = [0; 7]; 41 let mut control_buf = [0; 7];
@@ -46,7 +45,6 @@ async fn main(_spawner: Spawner) {
46 let mut builder = Builder::new( 45 let mut builder = Builder::new(
47 driver, 46 driver,
48 config, 47 config,
49 &mut device_descriptor,
50 &mut config_descriptor, 48 &mut config_descriptor,
51 &mut bos_descriptor, 49 &mut bos_descriptor,
52 &mut [], // no msos descriptors 50 &mut [], // no msos descriptors
diff --git a/examples/stm32g4/src/bin/can.rs b/examples/stm32g4/src/bin/can.rs
index 4373a89a8..2ed632a93 100644
--- a/examples/stm32g4/src/bin/can.rs
+++ b/examples/stm32g4/src/bin/can.rs
@@ -36,7 +36,7 @@ async fn main(_spawner: Spawner) {
36 } 36 }
37 let peripherals = embassy_stm32::init(config); 37 let peripherals = embassy_stm32::init(config);
38 38
39 let mut can = can::FdcanConfigurator::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs); 39 let mut can = can::CanConfigurator::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs);
40 40
41 can.set_extended_filter( 41 can.set_extended_filter(
42 can::filter::ExtendedFilterSlot::_0, 42 can::filter::ExtendedFilterSlot::_0,
@@ -56,21 +56,22 @@ async fn main(_spawner: Spawner) {
56 info!("Configured"); 56 info!("Configured");
57 57
58 let mut can = can.start(match use_fd { 58 let mut can = can.start(match use_fd {
59 true => can::FdcanOperatingMode::InternalLoopbackMode, 59 true => can::OperatingMode::InternalLoopbackMode,
60 false => can::FdcanOperatingMode::NormalOperationMode, 60 false => can::OperatingMode::NormalOperationMode,
61 }); 61 });
62 62
63 let mut i = 0; 63 let mut i = 0;
64 let mut last_read_ts = embassy_time::Instant::now(); 64 let mut last_read_ts = embassy_time::Instant::now();
65 65
66 loop { 66 loop {
67 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 67 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
68 info!("Writing frame"); 68 info!("Writing frame");
69 69
70 _ = can.write(&frame).await; 70 _ = can.write(&frame).await;
71 71
72 match can.read().await { 72 match can.read().await {
73 Ok((rx_frame, ts)) => { 73 Ok(envelope) => {
74 let (ts, rx_frame) = (envelope.ts, envelope.frame);
74 let delta = (ts - last_read_ts).as_millis(); 75 let delta = (ts - last_read_ts).as_millis();
75 last_read_ts = ts; 76 last_read_ts = ts;
76 info!( 77 info!(
@@ -105,7 +106,8 @@ async fn main(_spawner: Spawner) {
105 } 106 }
106 107
107 match can.read_fd().await { 108 match can.read_fd().await {
108 Ok((rx_frame, ts)) => { 109 Ok(envelope) => {
110 let (ts, rx_frame) = (envelope.ts, envelope.frame);
109 let delta = (ts - last_read_ts).as_millis(); 111 let delta = (ts - last_read_ts).as_millis();
110 last_read_ts = ts; 112 last_read_ts = ts;
111 info!( 113 info!(
@@ -129,12 +131,13 @@ async fn main(_spawner: Spawner) {
129 let (mut tx, mut rx) = can.split(); 131 let (mut tx, mut rx) = can.split();
130 // With split 132 // With split
131 loop { 133 loop {
132 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 134 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
133 info!("Writing frame"); 135 info!("Writing frame");
134 _ = tx.write(&frame).await; 136 _ = tx.write(&frame).await;
135 137
136 match rx.read().await { 138 match rx.read().await {
137 Ok((rx_frame, ts)) => { 139 Ok(envelope) => {
140 let (ts, rx_frame) = (envelope.ts, envelope.frame);
138 let delta = (ts - last_read_ts).as_millis(); 141 let delta = (ts - last_read_ts).as_millis();
139 last_read_ts = ts; 142 last_read_ts = ts;
140 info!( 143 info!(
@@ -156,7 +159,7 @@ async fn main(_spawner: Spawner) {
156 } 159 }
157 } 160 }
158 161
159 let can = can::Fdcan::join(tx, rx); 162 let can = can::Can::join(tx, rx);
160 163
161 info!("\n\n\nBuffered\n"); 164 info!("\n\n\nBuffered\n");
162 if use_fd { 165 if use_fd {
@@ -173,7 +176,8 @@ async fn main(_spawner: Spawner) {
173 _ = can.write(frame).await; 176 _ = can.write(frame).await;
174 177
175 match can.read().await { 178 match can.read().await {
176 Ok((rx_frame, ts)) => { 179 Ok(envelope) => {
180 let (ts, rx_frame) = (envelope.ts, envelope.frame);
177 let delta = (ts - last_read_ts).as_millis(); 181 let delta = (ts - last_read_ts).as_millis();
178 last_read_ts = ts; 182 last_read_ts = ts;
179 info!( 183 info!(
@@ -198,7 +202,7 @@ async fn main(_spawner: Spawner) {
198 RX_BUF.init(can::RxBuf::<10>::new()), 202 RX_BUF.init(can::RxBuf::<10>::new()),
199 ); 203 );
200 loop { 204 loop {
201 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 205 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
202 info!("Writing frame"); 206 info!("Writing frame");
203 207
204 // You can use any of these approaches to send. The writer makes it 208 // You can use any of these approaches to send. The writer makes it
@@ -208,7 +212,8 @@ async fn main(_spawner: Spawner) {
208 can.writer().write(frame).await; 212 can.writer().write(frame).await;
209 213
210 match can.read().await { 214 match can.read().await {
211 Ok((rx_frame, ts)) => { 215 Ok(envelope) => {
216 let (ts, rx_frame) = (envelope.ts, envelope.frame);
212 let delta = (ts - last_read_ts).as_millis(); 217 let delta = (ts - last_read_ts).as_millis();
213 last_read_ts = ts; 218 last_read_ts = ts;
214 info!( 219 info!(
diff --git a/examples/stm32g4/src/bin/usb_c_pd.rs b/examples/stm32g4/src/bin/usb_c_pd.rs
new file mode 100644
index 000000000..7caea634f
--- /dev/null
+++ b/examples/stm32g4/src/bin/usb_c_pd.rs
@@ -0,0 +1,86 @@
1#![no_std]
2#![no_main]
3
4use defmt::{error, info, Format};
5use embassy_executor::Spawner;
6use embassy_stm32::ucpd::{self, CcPhy, CcPull, CcSel, CcVState, Ucpd};
7use embassy_stm32::{bind_interrupts, peripherals, Config};
8use embassy_time::{with_timeout, Duration};
9use {defmt_rtt as _, panic_probe as _};
10
11bind_interrupts!(struct Irqs {
12 UCPD1 => ucpd::InterruptHandler<peripherals::UCPD1>;
13});
14
15#[derive(Debug, Format)]
16enum CableOrientation {
17 Normal,
18 Flipped,
19 DebugAccessoryMode,
20}
21
22// Returns true when the cable
23async fn wait_attached<T: ucpd::Instance>(cc_phy: &mut CcPhy<'_, T>) -> CableOrientation {
24 loop {
25 let (cc1, cc2) = cc_phy.vstate();
26 if cc1 == CcVState::LOWEST && cc2 == CcVState::LOWEST {
27 // Detached, wait until attached by monitoring the CC lines.
28 cc_phy.wait_for_vstate_change().await;
29 continue;
30 }
31
32 // Attached, wait for CC lines to be stable for tCCDebounce (100..200ms).
33 if with_timeout(Duration::from_millis(100), cc_phy.wait_for_vstate_change())
34 .await
35 .is_ok()
36 {
37 // State has changed, restart detection procedure.
38 continue;
39 };
40
41 // State was stable for the complete debounce period, check orientation.
42 return match (cc1, cc2) {
43 (_, CcVState::LOWEST) => CableOrientation::Normal, // CC1 connected
44 (CcVState::LOWEST, _) => CableOrientation::Flipped, // CC2 connected
45 _ => CableOrientation::DebugAccessoryMode, // Both connected (special cable)
46 };
47 }
48}
49
50#[embassy_executor::main]
51async fn main(_spawner: Spawner) {
52 let mut config = Config::default();
53 config.enable_ucpd1_dead_battery = true;
54 let p = embassy_stm32::init(config);
55
56 info!("Hello World!");
57
58 let mut ucpd = Ucpd::new(p.UCPD1, Irqs {}, p.PB6, p.PB4);
59 ucpd.cc_phy().set_pull(CcPull::Sink);
60
61 info!("Waiting for USB connection...");
62 let cable_orientation = wait_attached(ucpd.cc_phy()).await;
63 info!("USB cable connected, orientation: {}", cable_orientation);
64
65 let cc_sel = match cable_orientation {
66 CableOrientation::Normal => {
67 info!("Starting PD communication on CC1 pin");
68 CcSel::CC1
69 }
70 CableOrientation::Flipped => {
71 info!("Starting PD communication on CC2 pin");
72 CcSel::CC2
73 }
74 CableOrientation::DebugAccessoryMode => panic!("No PD communication in DAM"),
75 };
76 let (_cc_phy, mut pd_phy) = ucpd.split_pd_phy(p.DMA1_CH1, p.DMA1_CH2, cc_sel);
77
78 loop {
79 // Enough space for the longest non-extended data message.
80 let mut buf = [0_u8; 30];
81 match pd_phy.receive(buf.as_mut()).await {
82 Ok(n) => info!("USB PD RX: {=[u8]:?}", &buf[..n]),
83 Err(e) => error!("USB PD RX: {}", e),
84 }
85 }
86}
diff --git a/examples/stm32g4/src/bin/usb_serial.rs b/examples/stm32g4/src/bin/usb_serial.rs
index dc95aa6e5..dbe8f27c1 100644
--- a/examples/stm32g4/src/bin/usb_serial.rs
+++ b/examples/stm32g4/src/bin/usb_serial.rs
@@ -56,7 +56,6 @@ async fn main(_spawner: Spawner) {
56 config.device_protocol = 0x01; 56 config.device_protocol = 0x01;
57 config.composite_with_iads = true; 57 config.composite_with_iads = true;
58 58
59 let mut device_descriptor = [0; 256];
60 let mut config_descriptor = [0; 256]; 59 let mut config_descriptor = [0; 256];
61 let mut bos_descriptor = [0; 256]; 60 let mut bos_descriptor = [0; 256];
62 let mut control_buf = [0; 64]; 61 let mut control_buf = [0; 64];
@@ -66,7 +65,6 @@ async fn main(_spawner: Spawner) {
66 let mut builder = Builder::new( 65 let mut builder = Builder::new(
67 driver, 66 driver,
68 config, 67 config,
69 &mut device_descriptor,
70 &mut config_descriptor, 68 &mut config_descriptor,
71 &mut bos_descriptor, 69 &mut bos_descriptor,
72 &mut [], // no msos descriptors 70 &mut [], // no msos descriptors
diff --git a/examples/stm32h5/src/bin/can.rs b/examples/stm32h5/src/bin/can.rs
index 643df27f9..dd625c90a 100644
--- a/examples/stm32h5/src/bin/can.rs
+++ b/examples/stm32h5/src/bin/can.rs
@@ -24,7 +24,7 @@ async fn main(_spawner: Spawner) {
24 24
25 let peripherals = embassy_stm32::init(config); 25 let peripherals = embassy_stm32::init(config);
26 26
27 let mut can = can::FdcanConfigurator::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs); 27 let mut can = can::CanConfigurator::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs);
28 28
29 // 250k bps 29 // 250k bps
30 can.set_bitrate(250_000); 30 can.set_bitrate(250_000);
@@ -38,12 +38,13 @@ async fn main(_spawner: Spawner) {
38 let mut last_read_ts = embassy_time::Instant::now(); 38 let mut last_read_ts = embassy_time::Instant::now();
39 39
40 loop { 40 loop {
41 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 41 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
42 info!("Writing frame"); 42 info!("Writing frame");
43 _ = can.write(&frame).await; 43 _ = can.write(&frame).await;
44 44
45 match can.read().await { 45 match can.read().await {
46 Ok((rx_frame, ts)) => { 46 Ok(envelope) => {
47 let (rx_frame, ts) = envelope.parts();
47 let delta = (ts - last_read_ts).as_millis(); 48 let delta = (ts - last_read_ts).as_millis();
48 last_read_ts = ts; 49 last_read_ts = ts;
49 info!( 50 info!(
@@ -69,12 +70,13 @@ async fn main(_spawner: Spawner) {
69 let (mut tx, mut rx) = can.split(); 70 let (mut tx, mut rx) = can.split();
70 // With split 71 // With split
71 loop { 72 loop {
72 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 73 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
73 info!("Writing frame"); 74 info!("Writing frame");
74 _ = tx.write(&frame).await; 75 _ = tx.write(&frame).await;
75 76
76 match rx.read().await { 77 match rx.read().await {
77 Ok((rx_frame, ts)) => { 78 Ok(envelope) => {
79 let (rx_frame, ts) = envelope.parts();
78 let delta = (ts - last_read_ts).as_millis(); 80 let delta = (ts - last_read_ts).as_millis();
79 last_read_ts = ts; 81 last_read_ts = ts;
80 info!( 82 info!(
diff --git a/examples/stm32h5/src/bin/usb_serial.rs b/examples/stm32h5/src/bin/usb_serial.rs
index 83477c8fa..4f86bb342 100644
--- a/examples/stm32h5/src/bin/usb_serial.rs
+++ b/examples/stm32h5/src/bin/usb_serial.rs
@@ -65,7 +65,6 @@ async fn main(_spawner: Spawner) {
65 65
66 // Create embassy-usb DeviceBuilder using the driver and config. 66 // Create embassy-usb DeviceBuilder using the driver and config.
67 // It needs some buffers for building the descriptors. 67 // It needs some buffers for building the descriptors.
68 let mut device_descriptor = [0; 256];
69 let mut config_descriptor = [0; 256]; 68 let mut config_descriptor = [0; 256];
70 let mut bos_descriptor = [0; 256]; 69 let mut bos_descriptor = [0; 256];
71 let mut control_buf = [0; 64]; 70 let mut control_buf = [0; 64];
@@ -75,7 +74,6 @@ async fn main(_spawner: Spawner) {
75 let mut builder = Builder::new( 74 let mut builder = Builder::new(
76 driver, 75 driver,
77 config, 76 config,
78 &mut device_descriptor,
79 &mut config_descriptor, 77 &mut config_descriptor,
80 &mut bos_descriptor, 78 &mut bos_descriptor,
81 &mut [], // no msos descriptors 79 &mut [], // no msos descriptors
diff --git a/examples/stm32h7/src/bin/camera.rs b/examples/stm32h7/src/bin/camera.rs
index e5a104baf..170a5aa28 100644
--- a/examples/stm32h7/src/bin/camera.rs
+++ b/examples/stm32h7/src/bin/camera.rs
@@ -78,9 +78,9 @@ async fn main(_spawner: Spawner) {
78 ); 78 );
79 79
80 defmt::info!("attempting capture"); 80 defmt::info!("attempting capture");
81 defmt::unwrap!(dcmi.capture(unsafe { &mut FRAME }).await); 81 defmt::unwrap!(dcmi.capture(unsafe { &mut *core::ptr::addr_of_mut!(FRAME) }).await);
82 82
83 defmt::info!("captured frame: {:x}", unsafe { &FRAME }); 83 defmt::info!("captured frame: {:x}", unsafe { &*core::ptr::addr_of!(FRAME) });
84 84
85 defmt::info!("main loop running"); 85 defmt::info!("main loop running");
86 loop { 86 loop {
diff --git a/examples/stm32h7/src/bin/can.rs b/examples/stm32h7/src/bin/can.rs
index 13a6a5051..22cb27481 100644
--- a/examples/stm32h7/src/bin/can.rs
+++ b/examples/stm32h7/src/bin/can.rs
@@ -24,7 +24,7 @@ async fn main(_spawner: Spawner) {
24 24
25 let peripherals = embassy_stm32::init(config); 25 let peripherals = embassy_stm32::init(config);
26 26
27 let mut can = can::FdcanConfigurator::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs); 27 let mut can = can::CanConfigurator::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs);
28 28
29 // 250k bps 29 // 250k bps
30 can.set_bitrate(250_000); 30 can.set_bitrate(250_000);
@@ -38,12 +38,13 @@ async fn main(_spawner: Spawner) {
38 let mut last_read_ts = embassy_time::Instant::now(); 38 let mut last_read_ts = embassy_time::Instant::now();
39 39
40 loop { 40 loop {
41 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 41 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
42 info!("Writing frame"); 42 info!("Writing frame");
43 _ = can.write(&frame).await; 43 _ = can.write(&frame).await;
44 44
45 match can.read().await { 45 match can.read().await {
46 Ok((rx_frame, ts)) => { 46 Ok(envelope) => {
47 let (rx_frame, ts) = envelope.parts();
47 let delta = (ts - last_read_ts).as_millis(); 48 let delta = (ts - last_read_ts).as_millis();
48 last_read_ts = ts; 49 last_read_ts = ts;
49 info!( 50 info!(
@@ -69,12 +70,13 @@ async fn main(_spawner: Spawner) {
69 let (mut tx, mut rx) = can.split(); 70 let (mut tx, mut rx) = can.split();
70 // With split 71 // With split
71 loop { 72 loop {
72 let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap(); 73 let frame = can::frame::Frame::new_extended(0x123456F, &[i; 8]).unwrap();
73 info!("Writing frame"); 74 info!("Writing frame");
74 _ = tx.write(&frame).await; 75 _ = tx.write(&frame).await;
75 76
76 match rx.read().await { 77 match rx.read().await {
77 Ok((rx_frame, ts)) => { 78 Ok(envelope) => {
79 let (rx_frame, ts) = envelope.parts();
78 let delta = (ts - last_read_ts).as_millis(); 80 let delta = (ts - last_read_ts).as_millis();
79 last_read_ts = ts; 81 last_read_ts = ts;
80 info!( 82 info!(
diff --git a/examples/stm32h7/src/bin/dac_dma.rs b/examples/stm32h7/src/bin/dac_dma.rs
index feec28993..3a9887e3c 100644
--- a/examples/stm32h7/src/bin/dac_dma.rs
+++ b/examples/stm32h7/src/bin/dac_dma.rs
@@ -6,9 +6,9 @@ use embassy_executor::Spawner;
6use embassy_stm32::dac::{DacCh1, DacCh2, ValueArray}; 6use embassy_stm32::dac::{DacCh1, DacCh2, ValueArray};
7use embassy_stm32::pac::timer::vals::Mms; 7use embassy_stm32::pac::timer::vals::Mms;
8use embassy_stm32::peripherals::{DAC1, DMA1_CH3, DMA1_CH4, TIM6, TIM7}; 8use embassy_stm32::peripherals::{DAC1, DMA1_CH3, DMA1_CH4, TIM6, TIM7};
9use embassy_stm32::rcc::low_level::RccPeripheral; 9use embassy_stm32::rcc::frequency;
10use embassy_stm32::time::Hertz; 10use embassy_stm32::time::Hertz;
11use embassy_stm32::timer::low_level::BasicInstance; 11use embassy_stm32::timer::low_level::Timer;
12use micromath::F32Ext; 12use micromath::F32Ext;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
@@ -51,19 +51,19 @@ async fn main(spawner: Spawner) {
51 // Obtain two independent channels (p.DAC1 can only be consumed once, though!) 51 // Obtain two independent channels (p.DAC1 can only be consumed once, though!)
52 let (dac_ch1, dac_ch2) = embassy_stm32::dac::Dac::new(p.DAC1, p.DMA1_CH3, p.DMA1_CH4, p.PA4, p.PA5).split(); 52 let (dac_ch1, dac_ch2) = embassy_stm32::dac::Dac::new(p.DAC1, p.DMA1_CH3, p.DMA1_CH4, p.PA4, p.PA5).split();
53 53
54 spawner.spawn(dac_task1(dac_ch1)).ok(); 54 spawner.spawn(dac_task1(p.TIM6, dac_ch1)).ok();
55 spawner.spawn(dac_task2(dac_ch2)).ok(); 55 spawner.spawn(dac_task2(p.TIM7, dac_ch2)).ok();
56} 56}
57 57
58#[embassy_executor::task] 58#[embassy_executor::task]
59async fn dac_task1(mut dac: DacCh1<'static, DAC1, DMA1_CH3>) { 59async fn dac_task1(tim: TIM6, mut dac: DacCh1<'static, DAC1, DMA1_CH3>) {
60 let data: &[u8; 256] = &calculate_array::<256>(); 60 let data: &[u8; 256] = &calculate_array::<256>();
61 61
62 info!("TIM6 frequency is {}", TIM6::frequency()); 62 info!("TIM6 frequency is {}", frequency::<TIM6>());
63 const FREQUENCY: Hertz = Hertz::hz(200); 63 const FREQUENCY: Hertz = Hertz::hz(200);
64 64
65 // Compute the reload value such that we obtain the FREQUENCY for the sine 65 // Compute the reload value such that we obtain the FREQUENCY for the sine
66 let reload: u32 = (TIM6::frequency().0 / FREQUENCY.0) / data.len() as u32; 66 let reload: u32 = (frequency::<TIM6>().0 / FREQUENCY.0) / data.len() as u32;
67 67
68 // Depends on your clock and on the specific chip used, you may need higher or lower values here 68 // Depends on your clock and on the specific chip used, you may need higher or lower values here
69 if reload < 10 { 69 if reload < 10 {
@@ -74,17 +74,17 @@ async fn dac_task1(mut dac: DacCh1<'static, DAC1, DMA1_CH3>) {
74 dac.set_triggering(true); 74 dac.set_triggering(true);
75 dac.enable(); 75 dac.enable();
76 76
77 TIM6::enable_and_reset(); 77 let tim = Timer::new(tim);
78 TIM6::regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1)); 78 tim.regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1));
79 TIM6::regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE)); 79 tim.regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE));
80 TIM6::regs_basic().cr1().modify(|w| { 80 tim.regs_basic().cr1().modify(|w| {
81 w.set_opm(false); 81 w.set_opm(false);
82 w.set_cen(true); 82 w.set_cen(true);
83 }); 83 });
84 84
85 debug!( 85 debug!(
86 "TIM6 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}", 86 "TIM6 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}",
87 TIM6::frequency(), 87 frequency::<TIM6>(),
88 FREQUENCY, 88 FREQUENCY,
89 reload, 89 reload,
90 reload as u16, 90 reload as u16,
@@ -99,22 +99,22 @@ async fn dac_task1(mut dac: DacCh1<'static, DAC1, DMA1_CH3>) {
99} 99}
100 100
101#[embassy_executor::task] 101#[embassy_executor::task]
102async fn dac_task2(mut dac: DacCh2<'static, DAC1, DMA1_CH4>) { 102async fn dac_task2(tim: TIM7, mut dac: DacCh2<'static, DAC1, DMA1_CH4>) {
103 let data: &[u8; 256] = &calculate_array::<256>(); 103 let data: &[u8; 256] = &calculate_array::<256>();
104 104
105 info!("TIM7 frequency is {}", TIM7::frequency()); 105 info!("TIM7 frequency is {}", frequency::<TIM6>());
106 106
107 const FREQUENCY: Hertz = Hertz::hz(600); 107 const FREQUENCY: Hertz = Hertz::hz(600);
108 let reload: u32 = (TIM7::frequency().0 / FREQUENCY.0) / data.len() as u32; 108 let reload: u32 = (frequency::<TIM7>().0 / FREQUENCY.0) / data.len() as u32;
109 109
110 if reload < 10 { 110 if reload < 10 {
111 error!("Reload value {} below threshold!", reload); 111 error!("Reload value {} below threshold!", reload);
112 } 112 }
113 113
114 TIM7::enable_and_reset(); 114 let tim = Timer::new(tim);
115 TIM7::regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1)); 115 tim.regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1));
116 TIM7::regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE)); 116 tim.regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE));
117 TIM7::regs_basic().cr1().modify(|w| { 117 tim.regs_basic().cr1().modify(|w| {
118 w.set_opm(false); 118 w.set_opm(false);
119 w.set_cen(true); 119 w.set_cen(true);
120 }); 120 });
@@ -125,7 +125,7 @@ async fn dac_task2(mut dac: DacCh2<'static, DAC1, DMA1_CH4>) {
125 125
126 debug!( 126 debug!(
127 "TIM7 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}", 127 "TIM7 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}",
128 TIM7::frequency(), 128 frequency::<TIM7>(),
129 FREQUENCY, 129 FREQUENCY,
130 reload, 130 reload,
131 reload as u16, 131 reload as u16,
diff --git a/examples/stm32h7/src/bin/eth.rs b/examples/stm32h7/src/bin/eth.rs
index cd9a27fcd..7c7964ecd 100644
--- a/examples/stm32h7/src/bin/eth.rs
+++ b/examples/stm32h7/src/bin/eth.rs
@@ -64,19 +64,21 @@ async fn main(spawner: Spawner) -> ! {
64 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF]; 64 let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
65 65
66 static PACKETS: StaticCell<PacketQueue<4, 4>> = StaticCell::new(); 66 static PACKETS: StaticCell<PacketQueue<4, 4>> = StaticCell::new();
67 // warning: Not all STM32H7 devices have the exact same pins here
68 // for STM32H747XIH, replace p.PB13 for PG12
67 let device = Ethernet::new( 69 let device = Ethernet::new(
68 PACKETS.init(PacketQueue::<4, 4>::new()), 70 PACKETS.init(PacketQueue::<4, 4>::new()),
69 p.ETH, 71 p.ETH,
70 Irqs, 72 Irqs,
71 p.PA1, 73 p.PA1, // ref_clk
72 p.PA2, 74 p.PA2, // mdio
73 p.PC1, 75 p.PC1, // eth_mdc
74 p.PA7, 76 p.PA7, // CRS_DV: Carrier Sense
75 p.PC4, 77 p.PC4, // RX_D0: Received Bit 0
76 p.PC5, 78 p.PC5, // RX_D1: Received Bit 1
77 p.PG13, 79 p.PG13, // TX_D0: Transmit Bit 0
78 p.PB13, 80 p.PB13, // TX_D1: Transmit Bit 1
79 p.PG11, 81 p.PG11, // TX_EN: Transmit Enable
80 GenericSMI::new(0), 82 GenericSMI::new(0),
81 mac_addr, 83 mac_addr,
82 ); 84 );
diff --git a/examples/stm32h7/src/bin/low_level_timer_api.rs b/examples/stm32h7/src/bin/low_level_timer_api.rs
index 049d9967d..a95b44b74 100644
--- a/examples/stm32h7/src/bin/low_level_timer_api.rs
+++ b/examples/stm32h7/src/bin/low_level_timer_api.rs
@@ -3,11 +3,11 @@
3 3
4use defmt::*; 4use defmt::*;
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::gpio::low_level::AFType; 6use embassy_stm32::gpio::{AFType, Flex, Pull, Speed};
7use embassy_stm32::gpio::Speed;
8use embassy_stm32::time::{khz, Hertz}; 7use embassy_stm32::time::{khz, Hertz};
9use embassy_stm32::timer::*; 8use embassy_stm32::timer::low_level::{OutputCompareMode, Timer as LLTimer};
10use embassy_stm32::{into_ref, Config, Peripheral, PeripheralRef}; 9use embassy_stm32::timer::{Channel, Channel1Pin, Channel2Pin, Channel3Pin, Channel4Pin, GeneralInstance32bit4Channel};
10use embassy_stm32::{into_ref, Config, Peripheral};
11use embassy_time::Timer; 11use embassy_time::Timer;
12use {defmt_rtt as _, panic_probe as _}; 12use {defmt_rtt as _, panic_probe as _};
13 13
@@ -56,11 +56,15 @@ async fn main(_spawner: Spawner) {
56 Timer::after_millis(300).await; 56 Timer::after_millis(300).await;
57 } 57 }
58} 58}
59pub struct SimplePwm32<'d, T: CaptureCompare32bitInstance> { 59pub struct SimplePwm32<'d, T: GeneralInstance32bit4Channel> {
60 inner: PeripheralRef<'d, T>, 60 tim: LLTimer<'d, T>,
61 _ch1: Flex<'d>,
62 _ch2: Flex<'d>,
63 _ch3: Flex<'d>,
64 _ch4: Flex<'d>,
61} 65}
62 66
63impl<'d, T: CaptureCompare32bitInstance> SimplePwm32<'d, T> { 67impl<'d, T: GeneralInstance32bit4Channel> SimplePwm32<'d, T> {
64 pub fn new( 68 pub fn new(
65 tim: impl Peripheral<P = T> + 'd, 69 tim: impl Peripheral<P = T> + 'd,
66 ch1: impl Peripheral<P = impl Channel1Pin<T>> + 'd, 70 ch1: impl Peripheral<P = impl Channel1Pin<T>> + 'd,
@@ -69,25 +73,33 @@ impl<'d, T: CaptureCompare32bitInstance> SimplePwm32<'d, T> {
69 ch4: impl Peripheral<P = impl Channel4Pin<T>> + 'd, 73 ch4: impl Peripheral<P = impl Channel4Pin<T>> + 'd,
70 freq: Hertz, 74 freq: Hertz,
71 ) -> Self { 75 ) -> Self {
72 into_ref!(tim, ch1, ch2, ch3, ch4); 76 into_ref!(ch1, ch2, ch3, ch4);
73 77
74 T::enable_and_reset(); 78 let af1 = ch1.af_num();
75 79 let af2 = ch2.af_num();
76 ch1.set_speed(Speed::VeryHigh); 80 let af3 = ch3.af_num();
77 ch1.set_as_af(ch1.af_num(), AFType::OutputPushPull); 81 let af4 = ch4.af_num();
78 ch2.set_speed(Speed::VeryHigh); 82 let mut ch1 = Flex::new(ch1);
79 ch2.set_as_af(ch1.af_num(), AFType::OutputPushPull); 83 let mut ch2 = Flex::new(ch2);
80 ch3.set_speed(Speed::VeryHigh); 84 let mut ch3 = Flex::new(ch3);
81 ch3.set_as_af(ch1.af_num(), AFType::OutputPushPull); 85 let mut ch4 = Flex::new(ch4);
82 ch4.set_speed(Speed::VeryHigh); 86 ch1.set_as_af_unchecked(af1, AFType::OutputPushPull, Pull::None, Speed::VeryHigh);
83 ch4.set_as_af(ch1.af_num(), AFType::OutputPushPull); 87 ch2.set_as_af_unchecked(af2, AFType::OutputPushPull, Pull::None, Speed::VeryHigh);
84 88 ch3.set_as_af_unchecked(af3, AFType::OutputPushPull, Pull::None, Speed::VeryHigh);
85 let mut this = Self { inner: tim }; 89 ch4.set_as_af_unchecked(af4, AFType::OutputPushPull, Pull::None, Speed::VeryHigh);
90
91 let mut this = Self {
92 tim: LLTimer::new(tim),
93 _ch1: ch1,
94 _ch2: ch2,
95 _ch3: ch3,
96 _ch4: ch4,
97 };
86 98
87 this.set_frequency(freq); 99 this.set_frequency(freq);
88 this.inner.start(); 100 this.tim.start();
89 101
90 let r = T::regs_gp32(); 102 let r = this.tim.regs_gp32();
91 r.ccmr_output(0) 103 r.ccmr_output(0)
92 .modify(|w| w.set_ocm(0, OutputCompareMode::PwmMode1.into())); 104 .modify(|w| w.set_ocm(0, OutputCompareMode::PwmMode1.into()));
93 r.ccmr_output(0) 105 r.ccmr_output(0)
@@ -101,23 +113,26 @@ impl<'d, T: CaptureCompare32bitInstance> SimplePwm32<'d, T> {
101 } 113 }
102 114
103 pub fn enable(&mut self, channel: Channel) { 115 pub fn enable(&mut self, channel: Channel) {
104 T::regs_gp32().ccer().modify(|w| w.set_cce(channel.index(), true)); 116 self.tim.regs_gp32().ccer().modify(|w| w.set_cce(channel.index(), true));
105 } 117 }
106 118
107 pub fn disable(&mut self, channel: Channel) { 119 pub fn disable(&mut self, channel: Channel) {
108 T::regs_gp32().ccer().modify(|w| w.set_cce(channel.index(), false)); 120 self.tim
121 .regs_gp32()
122 .ccer()
123 .modify(|w| w.set_cce(channel.index(), false));
109 } 124 }
110 125
111 pub fn set_frequency(&mut self, freq: Hertz) { 126 pub fn set_frequency(&mut self, freq: Hertz) {
112 <T as embassy_stm32::timer::low_level::GeneralPurpose32bitInstance>::set_frequency(&mut self.inner, freq); 127 self.tim.set_frequency(freq);
113 } 128 }
114 129
115 pub fn get_max_duty(&self) -> u32 { 130 pub fn get_max_duty(&self) -> u32 {
116 T::regs_gp32().arr().read() 131 self.tim.regs_gp32().arr().read()
117 } 132 }
118 133
119 pub fn set_duty(&mut self, channel: Channel, duty: u32) { 134 pub fn set_duty(&mut self, channel: Channel, duty: u32) {
120 defmt::assert!(duty < self.get_max_duty()); 135 defmt::assert!(duty < self.get_max_duty());
121 T::regs_gp32().ccr(channel.index()).write_value(duty) 136 self.tim.regs_gp32().ccr(channel.index()).write_value(duty)
122 } 137 }
123} 138}
diff --git a/examples/stm32h7/src/bin/usb_serial.rs b/examples/stm32h7/src/bin/usb_serial.rs
index d81efb541..576506ad3 100644
--- a/examples/stm32h7/src/bin/usb_serial.rs
+++ b/examples/stm32h7/src/bin/usb_serial.rs
@@ -3,8 +3,8 @@
3 3
4use defmt::{panic, *}; 4use defmt::{panic, *};
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_stm32::usb_otg::{Driver, Instance}; 6use embassy_stm32::usb::{Driver, Instance};
7use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 7use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
8use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 8use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
9use embassy_usb::driver::EndpointError; 9use embassy_usb::driver::EndpointError;
10use embassy_usb::Builder; 10use embassy_usb::Builder;
@@ -12,7 +12,7 @@ use futures::future::join;
12use {defmt_rtt as _, panic_probe as _}; 12use {defmt_rtt as _, panic_probe as _};
13 13
14bind_interrupts!(struct Irqs { 14bind_interrupts!(struct Irqs {
15 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 15 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
16}); 16});
17 17
18#[embassy_executor::main] 18#[embassy_executor::main]
@@ -40,12 +40,13 @@ async fn main(_spawner: Spawner) {
40 config.rcc.apb3_pre = APBPrescaler::DIV2; // 100 Mhz 40 config.rcc.apb3_pre = APBPrescaler::DIV2; // 100 Mhz
41 config.rcc.apb4_pre = APBPrescaler::DIV2; // 100 Mhz 41 config.rcc.apb4_pre = APBPrescaler::DIV2; // 100 Mhz
42 config.rcc.voltage_scale = VoltageScale::Scale1; 42 config.rcc.voltage_scale = VoltageScale::Scale1;
43 config.rcc.mux.usbsel = mux::Usbsel::HSI48;
43 } 44 }
44 let p = embassy_stm32::init(config); 45 let p = embassy_stm32::init(config);
45 46
46 // Create the driver, from the HAL. 47 // Create the driver, from the HAL.
47 let mut ep_out_buffer = [0u8; 256]; 48 let mut ep_out_buffer = [0u8; 256];
48 let mut config = embassy_stm32::usb_otg::Config::default(); 49 let mut config = embassy_stm32::usb::Config::default();
49 config.vbus_detection = true; 50 config.vbus_detection = true;
50 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 51 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
51 52
@@ -64,7 +65,6 @@ async fn main(_spawner: Spawner) {
64 65
65 // Create embassy-usb DeviceBuilder using the driver and config. 66 // Create embassy-usb DeviceBuilder using the driver and config.
66 // It needs some buffers for building the descriptors. 67 // It needs some buffers for building the descriptors.
67 let mut device_descriptor = [0; 256];
68 let mut config_descriptor = [0; 256]; 68 let mut config_descriptor = [0; 256];
69 let mut bos_descriptor = [0; 256]; 69 let mut bos_descriptor = [0; 256];
70 let mut control_buf = [0; 64]; 70 let mut control_buf = [0; 64];
@@ -74,7 +74,6 @@ async fn main(_spawner: Spawner) {
74 let mut builder = Builder::new( 74 let mut builder = Builder::new(
75 driver, 75 driver,
76 config, 76 config,
77 &mut device_descriptor,
78 &mut config_descriptor, 77 &mut config_descriptor,
79 &mut bos_descriptor, 78 &mut bos_descriptor,
80 &mut [], // no msos descriptors 79 &mut [], // no msos descriptors
diff --git a/examples/stm32l1/src/bin/usb_serial.rs b/examples/stm32l1/src/bin/usb_serial.rs
index f738ea358..653bbd6d2 100644
--- a/examples/stm32l1/src/bin/usb_serial.rs
+++ b/examples/stm32l1/src/bin/usb_serial.rs
@@ -46,7 +46,6 @@ async fn main(_spawner: Spawner) {
46 config.device_protocol = 0x01; 46 config.device_protocol = 0x01;
47 config.composite_with_iads = true; 47 config.composite_with_iads = true;
48 48
49 let mut device_descriptor = [0; 256];
50 let mut config_descriptor = [0; 256]; 49 let mut config_descriptor = [0; 256];
51 let mut bos_descriptor = [0; 256]; 50 let mut bos_descriptor = [0; 256];
52 let mut control_buf = [0; 64]; 51 let mut control_buf = [0; 64];
@@ -56,7 +55,6 @@ async fn main(_spawner: Spawner) {
56 let mut builder = Builder::new( 55 let mut builder = Builder::new(
57 driver, 56 driver,
58 config, 57 config,
59 &mut device_descriptor,
60 &mut config_descriptor, 58 &mut config_descriptor,
61 &mut bos_descriptor, 59 &mut bos_descriptor,
62 &mut [], // no msos descriptors 60 &mut [], // no msos descriptors
diff --git a/examples/stm32l4/src/bin/dac_dma.rs b/examples/stm32l4/src/bin/dac_dma.rs
index f227812cd..d01b016c0 100644
--- a/examples/stm32l4/src/bin/dac_dma.rs
+++ b/examples/stm32l4/src/bin/dac_dma.rs
@@ -6,9 +6,9 @@ use embassy_executor::Spawner;
6use embassy_stm32::dac::{DacCh1, DacCh2, ValueArray}; 6use embassy_stm32::dac::{DacCh1, DacCh2, ValueArray};
7use embassy_stm32::pac::timer::vals::Mms; 7use embassy_stm32::pac::timer::vals::Mms;
8use embassy_stm32::peripherals::{DAC1, DMA1_CH3, DMA1_CH4, TIM6, TIM7}; 8use embassy_stm32::peripherals::{DAC1, DMA1_CH3, DMA1_CH4, TIM6, TIM7};
9use embassy_stm32::rcc::low_level::RccPeripheral; 9use embassy_stm32::rcc::frequency;
10use embassy_stm32::time::Hertz; 10use embassy_stm32::time::Hertz;
11use embassy_stm32::timer::low_level::BasicInstance; 11use embassy_stm32::timer::low_level::Timer;
12use micromath::F32Ext; 12use micromath::F32Ext;
13use {defmt_rtt as _, panic_probe as _}; 13use {defmt_rtt as _, panic_probe as _};
14 14
@@ -22,19 +22,19 @@ async fn main(spawner: Spawner) {
22 // Obtain two independent channels (p.DAC1 can only be consumed once, though!) 22 // Obtain two independent channels (p.DAC1 can only be consumed once, though!)
23 let (dac_ch1, dac_ch2) = embassy_stm32::dac::Dac::new(p.DAC1, p.DMA1_CH3, p.DMA1_CH4, p.PA4, p.PA5).split(); 23 let (dac_ch1, dac_ch2) = embassy_stm32::dac::Dac::new(p.DAC1, p.DMA1_CH3, p.DMA1_CH4, p.PA4, p.PA5).split();
24 24
25 spawner.spawn(dac_task1(dac_ch1)).ok(); 25 spawner.spawn(dac_task1(p.TIM6, dac_ch1)).ok();
26 spawner.spawn(dac_task2(dac_ch2)).ok(); 26 spawner.spawn(dac_task2(p.TIM7, dac_ch2)).ok();
27} 27}
28 28
29#[embassy_executor::task] 29#[embassy_executor::task]
30async fn dac_task1(mut dac: DacCh1<'static, DAC1, DMA1_CH3>) { 30async fn dac_task1(tim: TIM6, mut dac: DacCh1<'static, DAC1, DMA1_CH3>) {
31 let data: &[u8; 256] = &calculate_array::<256>(); 31 let data: &[u8; 256] = &calculate_array::<256>();
32 32
33 info!("TIM6 frequency is {}", TIM6::frequency()); 33 info!("TIM6 frequency is {}", frequency::<TIM6>());
34 const FREQUENCY: Hertz = Hertz::hz(200); 34 const FREQUENCY: Hertz = Hertz::hz(200);
35 35
36 // Compute the reload value such that we obtain the FREQUENCY for the sine 36 // Compute the reload value such that we obtain the FREQUENCY for the sine
37 let reload: u32 = (TIM6::frequency().0 / FREQUENCY.0) / data.len() as u32; 37 let reload: u32 = (frequency::<TIM6>().0 / FREQUENCY.0) / data.len() as u32;
38 38
39 // Depends on your clock and on the specific chip used, you may need higher or lower values here 39 // Depends on your clock and on the specific chip used, you may need higher or lower values here
40 if reload < 10 { 40 if reload < 10 {
@@ -45,17 +45,17 @@ async fn dac_task1(mut dac: DacCh1<'static, DAC1, DMA1_CH3>) {
45 dac.set_triggering(true); 45 dac.set_triggering(true);
46 dac.enable(); 46 dac.enable();
47 47
48 TIM6::enable_and_reset(); 48 let tim = Timer::new(tim);
49 TIM6::regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1)); 49 tim.regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1));
50 TIM6::regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE)); 50 tim.regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE));
51 TIM6::regs_basic().cr1().modify(|w| { 51 tim.regs_basic().cr1().modify(|w| {
52 w.set_opm(false); 52 w.set_opm(false);
53 w.set_cen(true); 53 w.set_cen(true);
54 }); 54 });
55 55
56 debug!( 56 debug!(
57 "TIM6 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}", 57 "TIM6 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}",
58 TIM6::frequency(), 58 frequency::<TIM6>(),
59 FREQUENCY, 59 FREQUENCY,
60 reload, 60 reload,
61 reload as u16, 61 reload as u16,
@@ -70,22 +70,22 @@ async fn dac_task1(mut dac: DacCh1<'static, DAC1, DMA1_CH3>) {
70} 70}
71 71
72#[embassy_executor::task] 72#[embassy_executor::task]
73async fn dac_task2(mut dac: DacCh2<'static, DAC1, DMA1_CH4>) { 73async fn dac_task2(tim: TIM7, mut dac: DacCh2<'static, DAC1, DMA1_CH4>) {
74 let data: &[u8; 256] = &calculate_array::<256>(); 74 let data: &[u8; 256] = &calculate_array::<256>();
75 75
76 info!("TIM7 frequency is {}", TIM7::frequency()); 76 info!("TIM7 frequency is {}", frequency::<TIM7>());
77 77
78 const FREQUENCY: Hertz = Hertz::hz(600); 78 const FREQUENCY: Hertz = Hertz::hz(600);
79 let reload: u32 = (TIM7::frequency().0 / FREQUENCY.0) / data.len() as u32; 79 let reload: u32 = (frequency::<TIM7>().0 / FREQUENCY.0) / data.len() as u32;
80 80
81 if reload < 10 { 81 if reload < 10 {
82 error!("Reload value {} below threshold!", reload); 82 error!("Reload value {} below threshold!", reload);
83 } 83 }
84 84
85 TIM7::enable_and_reset(); 85 let tim = Timer::new(tim);
86 TIM7::regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1)); 86 tim.regs_basic().arr().modify(|w| w.set_arr(reload as u16 - 1));
87 TIM7::regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE)); 87 tim.regs_basic().cr2().modify(|w| w.set_mms(Mms::UPDATE));
88 TIM7::regs_basic().cr1().modify(|w| { 88 tim.regs_basic().cr1().modify(|w| {
89 w.set_opm(false); 89 w.set_opm(false);
90 w.set_cen(true); 90 w.set_cen(true);
91 }); 91 });
@@ -96,7 +96,7 @@ async fn dac_task2(mut dac: DacCh2<'static, DAC1, DMA1_CH4>) {
96 96
97 debug!( 97 debug!(
98 "TIM7 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}", 98 "TIM7 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}",
99 TIM7::frequency(), 99 frequency::<TIM7>(),
100 FREQUENCY, 100 FREQUENCY,
101 reload, 101 reload,
102 reload as u16, 102 reload as u16,
diff --git a/examples/stm32l4/src/bin/spe_adin1110_http_server.rs b/examples/stm32l4/src/bin/spe_adin1110_http_server.rs
index 32bfab6eb..77aa929ab 100644
--- a/examples/stm32l4/src/bin/spe_adin1110_http_server.rs
+++ b/examples/stm32l4/src/bin/spe_adin1110_http_server.rs
@@ -42,7 +42,7 @@ bind_interrupts!(struct Irqs {
42 RNG => rng::InterruptHandler<peripherals::RNG>; 42 RNG => rng::InterruptHandler<peripherals::RNG>;
43}); 43});
44 44
45use embassy_net_adin1110::{self, Device, Runner, ADIN1110}; 45use embassy_net_adin1110::{Device, Runner, ADIN1110};
46use embedded_hal_bus::spi::ExclusiveDevice; 46use embedded_hal_bus::spi::ExclusiveDevice;
47use hal::gpio::Pull; 47use hal::gpio::Pull;
48use hal::i2c::Config as I2C_Config; 48use hal::i2c::Config as I2C_Config;
@@ -93,12 +93,6 @@ async fn main(spawner: Spawner) {
93 93
94 let dp = embassy_stm32::init(config); 94 let dp = embassy_stm32::init(config);
95 95
96 // RM0432rev9, 5.1.2: Independent I/O supply rail
97 // After reset, the I/Os supplied by VDDIO2 are logically and electrically isolated and
98 // therefore are not available. The isolation must be removed before using any I/O from
99 // PG[15:2], by setting the IOSV bit in the PWR_CR2 register, once the VDDIO2 supply is present
100 pac::PWR.cr2().modify(|w| w.set_iosv(true));
101
102 let reset_status = pac::RCC.bdcr().read().0; 96 let reset_status = pac::RCC.bdcr().read().0;
103 defmt::println!("bdcr before: 0x{:X}", reset_status); 97 defmt::println!("bdcr before: 0x{:X}", reset_status);
104 98
diff --git a/examples/stm32l4/src/bin/usb_serial.rs b/examples/stm32l4/src/bin/usb_serial.rs
index 9247e56a1..198504b59 100644
--- a/examples/stm32l4/src/bin/usb_serial.rs
+++ b/examples/stm32l4/src/bin/usb_serial.rs
@@ -4,9 +4,8 @@
4use defmt::{panic, *}; 4use defmt::{panic, *};
5use defmt_rtt as _; // global logger 5use defmt_rtt as _; // global logger
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::rcc::*; 7use embassy_stm32::usb::{Driver, Instance};
8use embassy_stm32::usb_otg::{Driver, Instance}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
9use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config};
10use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 9use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
11use embassy_usb::driver::EndpointError; 10use embassy_usb::driver::EndpointError;
12use embassy_usb::Builder; 11use embassy_usb::Builder;
@@ -14,7 +13,7 @@ use futures::future::join;
14use panic_probe as _; 13use panic_probe as _;
15 14
16bind_interrupts!(struct Irqs { 15bind_interrupts!(struct Irqs {
17 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 16 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
18}); 17});
19 18
20#[embassy_executor::main] 19#[embassy_executor::main]
@@ -22,23 +21,26 @@ async fn main(_spawner: Spawner) {
22 info!("Hello World!"); 21 info!("Hello World!");
23 22
24 let mut config = Config::default(); 23 let mut config = Config::default();
25 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB 24 {
26 config.rcc.sys = Sysclk::PLL1_R; 25 use embassy_stm32::rcc::*;
27 config.rcc.hsi = true; 26 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB
28 config.rcc.pll = Some(Pll { 27 config.rcc.sys = Sysclk::PLL1_R;
29 source: PllSource::HSI, 28 config.rcc.hsi = true;
30 prediv: PllPreDiv::DIV1, 29 config.rcc.pll = Some(Pll {
31 mul: PllMul::MUL10, 30 source: PllSource::HSI,
32 divp: None, 31 prediv: PllPreDiv::DIV1,
33 divq: None, 32 mul: PllMul::MUL10,
34 divr: Some(PllRDiv::DIV2), // sysclk 80Mhz (16 / 1 * 10 / 2) 33 divp: None,
35 }); 34 divq: None,
36 35 divr: Some(PllRDiv::DIV2), // sysclk 80Mhz (16 / 1 * 10 / 2)
36 });
37 config.rcc.mux.clk48sel = mux::Clk48sel::HSI48;
38 }
37 let p = embassy_stm32::init(config); 39 let p = embassy_stm32::init(config);
38 40
39 // Create the driver, from the HAL. 41 // Create the driver, from the HAL.
40 let mut ep_out_buffer = [0u8; 256]; 42 let mut ep_out_buffer = [0u8; 256];
41 let mut config = embassy_stm32::usb_otg::Config::default(); 43 let mut config = embassy_stm32::usb::Config::default();
42 config.vbus_detection = true; 44 config.vbus_detection = true;
43 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 45 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
44 46
@@ -58,7 +60,6 @@ async fn main(_spawner: Spawner) {
58 60
59 // Create embassy-usb DeviceBuilder using the driver and config. 61 // Create embassy-usb DeviceBuilder using the driver and config.
60 // It needs some buffers for building the descriptors. 62 // It needs some buffers for building the descriptors.
61 let mut device_descriptor = [0; 256];
62 let mut config_descriptor = [0; 256]; 63 let mut config_descriptor = [0; 256];
63 let mut bos_descriptor = [0; 256]; 64 let mut bos_descriptor = [0; 256];
64 let mut control_buf = [0; 64]; 65 let mut control_buf = [0; 64];
@@ -68,7 +69,6 @@ async fn main(_spawner: Spawner) {
68 let mut builder = Builder::new( 69 let mut builder = Builder::new(
69 driver, 70 driver,
70 config, 71 config,
71 &mut device_descriptor,
72 &mut config_descriptor, 72 &mut config_descriptor,
73 &mut bos_descriptor, 73 &mut bos_descriptor,
74 &mut [], // no msos descriptors 74 &mut [], // no msos descriptors
diff --git a/examples/stm32l5/src/bin/usb_ethernet.rs b/examples/stm32l5/src/bin/usb_ethernet.rs
index f6d8b16d0..7f73fd677 100644
--- a/examples/stm32l5/src/bin/usb_ethernet.rs
+++ b/examples/stm32l5/src/bin/usb_ethernet.rs
@@ -5,7 +5,6 @@ use defmt::*;
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_net::tcp::TcpSocket; 6use embassy_net::tcp::TcpSocket;
7use embassy_net::{Stack, StackResources}; 7use embassy_net::{Stack, StackResources};
8use embassy_stm32::rcc::*;
9use embassy_stm32::rng::Rng; 8use embassy_stm32::rng::Rng;
10use embassy_stm32::usb::Driver; 9use embassy_stm32::usb::Driver;
11use embassy_stm32::{bind_interrupts, peripherals, rng, usb, Config}; 10use embassy_stm32::{bind_interrupts, peripherals, rng, usb, Config};
@@ -44,17 +43,22 @@ async fn net_task(stack: &'static Stack<Device<'static, MTU>>) -> ! {
44#[embassy_executor::main] 43#[embassy_executor::main]
45async fn main(spawner: Spawner) { 44async fn main(spawner: Spawner) {
46 let mut config = Config::default(); 45 let mut config = Config::default();
47 config.rcc.hsi = true; 46 {
48 config.rcc.sys = Sysclk::PLL1_R; 47 use embassy_stm32::rcc::*;
49 config.rcc.pll = Some(Pll { 48 config.rcc.hsi = true;
50 // 80Mhz clock (16 / 1 * 10 / 2) 49 config.rcc.sys = Sysclk::PLL1_R;
51 source: PllSource::HSI, 50 config.rcc.pll = Some(Pll {
52 prediv: PllPreDiv::DIV1, 51 // 80Mhz clock (16 / 1 * 10 / 2)
53 mul: PllMul::MUL10, 52 source: PllSource::HSI,
54 divp: None, 53 prediv: PllPreDiv::DIV1,
55 divq: None, 54 mul: PllMul::MUL10,
56 divr: Some(PllRDiv::DIV2), 55 divp: None,
57 }); 56 divq: None,
57 divr: Some(PllRDiv::DIV2),
58 });
59 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB
60 config.rcc.mux.clk48sel = mux::Clk48sel::HSI48;
61 }
58 let p = embassy_stm32::init(config); 62 let p = embassy_stm32::init(config);
59 63
60 // Create the driver, from the HAL. 64 // Create the driver, from the HAL.
@@ -75,14 +79,12 @@ async fn main(spawner: Spawner) {
75 config.device_protocol = 0x01; 79 config.device_protocol = 0x01;
76 80
77 // Create embassy-usb DeviceBuilder using the driver and config. 81 // Create embassy-usb DeviceBuilder using the driver and config.
78 static DEVICE_DESC: StaticCell<[u8; 256]> = StaticCell::new();
79 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 82 static CONFIG_DESC: StaticCell<[u8; 256]> = StaticCell::new();
80 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new(); 83 static BOS_DESC: StaticCell<[u8; 256]> = StaticCell::new();
81 static CONTROL_BUF: StaticCell<[u8; 128]> = StaticCell::new(); 84 static CONTROL_BUF: StaticCell<[u8; 128]> = StaticCell::new();
82 let mut builder = Builder::new( 85 let mut builder = Builder::new(
83 driver, 86 driver,
84 config, 87 config,
85 &mut DEVICE_DESC.init([0; 256])[..],
86 &mut CONFIG_DESC.init([0; 256])[..], 88 &mut CONFIG_DESC.init([0; 256])[..],
87 &mut BOS_DESC.init([0; 256])[..], 89 &mut BOS_DESC.init([0; 256])[..],
88 &mut [], // no msos descriptors 90 &mut [], // no msos descriptors
diff --git a/examples/stm32l5/src/bin/usb_hid_mouse.rs b/examples/stm32l5/src/bin/usb_hid_mouse.rs
index c51ed96e0..9d30205bb 100644
--- a/examples/stm32l5/src/bin/usb_hid_mouse.rs
+++ b/examples/stm32l5/src/bin/usb_hid_mouse.rs
@@ -4,7 +4,6 @@
4use defmt::*; 4use defmt::*;
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_futures::join::join; 6use embassy_futures::join::join;
7use embassy_stm32::rcc::*;
8use embassy_stm32::usb::Driver; 7use embassy_stm32::usb::Driver;
9use embassy_stm32::{bind_interrupts, peripherals, usb, Config}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
10use embassy_time::Timer; 9use embassy_time::Timer;
@@ -21,17 +20,22 @@ bind_interrupts!(struct Irqs {
21#[embassy_executor::main] 20#[embassy_executor::main]
22async fn main(_spawner: Spawner) { 21async fn main(_spawner: Spawner) {
23 let mut config = Config::default(); 22 let mut config = Config::default();
24 config.rcc.hsi = true; 23 {
25 config.rcc.sys = Sysclk::PLL1_R; 24 use embassy_stm32::rcc::*;
26 config.rcc.pll = Some(Pll { 25 config.rcc.hsi = true;
27 // 80Mhz clock (16 / 1 * 10 / 2) 26 config.rcc.sys = Sysclk::PLL1_R;
28 source: PllSource::HSI, 27 config.rcc.pll = Some(Pll {
29 prediv: PllPreDiv::DIV1, 28 // 80Mhz clock (16 / 1 * 10 / 2)
30 mul: PllMul::MUL10, 29 source: PllSource::HSI,
31 divp: None, 30 prediv: PllPreDiv::DIV1,
32 divq: None, 31 mul: PllMul::MUL10,
33 divr: Some(PllRDiv::DIV2), 32 divp: None,
34 }); 33 divq: None,
34 divr: Some(PllRDiv::DIV2),
35 });
36 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB
37 config.rcc.mux.clk48sel = mux::Clk48sel::HSI48;
38 }
35 let p = embassy_stm32::init(config); 39 let p = embassy_stm32::init(config);
36 40
37 // Create the driver, from the HAL. 41 // Create the driver, from the HAL.
@@ -47,7 +51,6 @@ async fn main(_spawner: Spawner) {
47 51
48 // Create embassy-usb DeviceBuilder using the driver and config. 52 // Create embassy-usb DeviceBuilder using the driver and config.
49 // It needs some buffers for building the descriptors. 53 // It needs some buffers for building the descriptors.
50 let mut device_descriptor = [0; 256];
51 let mut config_descriptor = [0; 256]; 54 let mut config_descriptor = [0; 256];
52 let mut bos_descriptor = [0; 256]; 55 let mut bos_descriptor = [0; 256];
53 let mut control_buf = [0; 64]; 56 let mut control_buf = [0; 64];
@@ -58,7 +61,6 @@ async fn main(_spawner: Spawner) {
58 let mut builder = Builder::new( 61 let mut builder = Builder::new(
59 driver, 62 driver,
60 config, 63 config,
61 &mut device_descriptor,
62 &mut config_descriptor, 64 &mut config_descriptor,
63 &mut bos_descriptor, 65 &mut bos_descriptor,
64 &mut [], // no msos descriptors 66 &mut [], // no msos descriptors
diff --git a/examples/stm32l5/src/bin/usb_serial.rs b/examples/stm32l5/src/bin/usb_serial.rs
index 87987f2ce..a64bda31b 100644
--- a/examples/stm32l5/src/bin/usb_serial.rs
+++ b/examples/stm32l5/src/bin/usb_serial.rs
@@ -4,7 +4,6 @@
4use defmt::{panic, *}; 4use defmt::{panic, *};
5use embassy_executor::Spawner; 5use embassy_executor::Spawner;
6use embassy_futures::join::join; 6use embassy_futures::join::join;
7use embassy_stm32::rcc::*;
8use embassy_stm32::usb::{Driver, Instance}; 7use embassy_stm32::usb::{Driver, Instance};
9use embassy_stm32::{bind_interrupts, peripherals, usb, Config}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
10use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 9use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
@@ -19,17 +18,22 @@ bind_interrupts!(struct Irqs {
19#[embassy_executor::main] 18#[embassy_executor::main]
20async fn main(_spawner: Spawner) { 19async fn main(_spawner: Spawner) {
21 let mut config = Config::default(); 20 let mut config = Config::default();
22 config.rcc.hsi = true; 21 {
23 config.rcc.sys = Sysclk::PLL1_R; 22 use embassy_stm32::rcc::*;
24 config.rcc.pll = Some(Pll { 23 config.rcc.hsi = true;
25 // 80Mhz clock (16 / 1 * 10 / 2) 24 config.rcc.sys = Sysclk::PLL1_R;
26 source: PllSource::HSI, 25 config.rcc.pll = Some(Pll {
27 prediv: PllPreDiv::DIV1, 26 // 80Mhz clock (16 / 1 * 10 / 2)
28 mul: PllMul::MUL10, 27 source: PllSource::HSI,
29 divp: None, 28 prediv: PllPreDiv::DIV1,
30 divq: None, 29 mul: PllMul::MUL10,
31 divr: Some(PllRDiv::DIV2), 30 divp: None,
32 }); 31 divq: None,
32 divr: Some(PllRDiv::DIV2),
33 });
34 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB
35 config.rcc.mux.clk48sel = mux::Clk48sel::HSI48;
36 }
33 let p = embassy_stm32::init(config); 37 let p = embassy_stm32::init(config);
34 38
35 info!("Hello World!"); 39 info!("Hello World!");
@@ -43,7 +47,6 @@ async fn main(_spawner: Spawner) {
43 47
44 // Create embassy-usb DeviceBuilder using the driver and config. 48 // Create embassy-usb DeviceBuilder using the driver and config.
45 // It needs some buffers for building the descriptors. 49 // It needs some buffers for building the descriptors.
46 let mut device_descriptor = [0; 256];
47 let mut config_descriptor = [0; 256]; 50 let mut config_descriptor = [0; 256];
48 let mut bos_descriptor = [0; 256]; 51 let mut bos_descriptor = [0; 256];
49 let mut control_buf = [0; 7]; 52 let mut control_buf = [0; 7];
@@ -53,7 +56,6 @@ async fn main(_spawner: Spawner) {
53 let mut builder = Builder::new( 56 let mut builder = Builder::new(
54 driver, 57 driver,
55 config, 58 config,
56 &mut device_descriptor,
57 &mut config_descriptor, 59 &mut config_descriptor,
58 &mut bos_descriptor, 60 &mut bos_descriptor,
59 &mut [], // no msos descriptors 61 &mut [], // no msos descriptors
diff --git a/examples/stm32u5/src/bin/usb_serial.rs b/examples/stm32u5/src/bin/usb_serial.rs
index 61851e5a2..6a313efb0 100644
--- a/examples/stm32u5/src/bin/usb_serial.rs
+++ b/examples/stm32u5/src/bin/usb_serial.rs
@@ -4,8 +4,8 @@
4use defmt::{panic, *}; 4use defmt::{panic, *};
5use defmt_rtt as _; // global logger 5use defmt_rtt as _; // global logger
6use embassy_executor::Spawner; 6use embassy_executor::Spawner;
7use embassy_stm32::usb_otg::{Driver, Instance}; 7use embassy_stm32::usb::{Driver, Instance};
8use embassy_stm32::{bind_interrupts, peripherals, usb_otg, Config}; 8use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
9use embassy_usb::class::cdc_acm::{CdcAcmClass, State}; 9use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
10use embassy_usb::driver::EndpointError; 10use embassy_usb::driver::EndpointError;
11use embassy_usb::Builder; 11use embassy_usb::Builder;
@@ -13,7 +13,7 @@ use futures::future::join;
13use panic_probe as _; 13use panic_probe as _;
14 14
15bind_interrupts!(struct Irqs { 15bind_interrupts!(struct Irqs {
16 OTG_FS => usb_otg::InterruptHandler<peripherals::USB_OTG_FS>; 16 OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
17}); 17});
18 18
19#[embassy_executor::main] 19#[embassy_executor::main]
@@ -35,13 +35,14 @@ async fn main(_spawner: Spawner) {
35 config.rcc.sys = Sysclk::PLL1_R; 35 config.rcc.sys = Sysclk::PLL1_R;
36 config.rcc.voltage_range = VoltageScale::RANGE1; 36 config.rcc.voltage_range = VoltageScale::RANGE1;
37 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB 37 config.rcc.hsi48 = Some(Hsi48Config { sync_from_usb: true }); // needed for USB
38 config.rcc.mux.iclksel = mux::Iclksel::HSI48; // USB uses ICLK
38 } 39 }
39 40
40 let p = embassy_stm32::init(config); 41 let p = embassy_stm32::init(config);
41 42
42 // Create the driver, from the HAL. 43 // Create the driver, from the HAL.
43 let mut ep_out_buffer = [0u8; 256]; 44 let mut ep_out_buffer = [0u8; 256];
44 let mut config = embassy_stm32::usb_otg::Config::default(); 45 let mut config = embassy_stm32::usb::Config::default();
45 config.vbus_detection = false; 46 config.vbus_detection = false;
46 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config); 47 let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
47 48
@@ -60,7 +61,6 @@ async fn main(_spawner: Spawner) {
60 61
61 // Create embassy-usb DeviceBuilder using the driver and config. 62 // Create embassy-usb DeviceBuilder using the driver and config.
62 // It needs some buffers for building the descriptors. 63 // It needs some buffers for building the descriptors.
63 let mut device_descriptor = [0; 256];
64 let mut config_descriptor = [0; 256]; 64 let mut config_descriptor = [0; 256];
65 let mut bos_descriptor = [0; 256]; 65 let mut bos_descriptor = [0; 256];
66 let mut control_buf = [0; 64]; 66 let mut control_buf = [0; 64];
@@ -70,7 +70,6 @@ async fn main(_spawner: Spawner) {
70 let mut builder = Builder::new( 70 let mut builder = Builder::new(
71 driver, 71 driver,
72 config, 72 config,
73 &mut device_descriptor,
74 &mut config_descriptor, 73 &mut config_descriptor,
75 &mut bos_descriptor, 74 &mut bos_descriptor,
76 &mut [], // no msos descriptors 75 &mut [], // no msos descriptors
generated by cgit (git 2.34.1) at 2026-04-06 10:37:41 +0000