diff --git a/.github/ci/build-stable.sh b/.github/ci/build-stable.sh
index ffaebeb3..9160a2be 100755
--- a/.github/ci/build-stable.sh
+++ b/.github/ci/build-stable.sh
@@ -21,7 +21,7 @@ fi
hashtime restore /ci/cache/filetime.json || true
hashtime save /ci/cache/filetime.json
-sed -i 's/channel.*/channel = "stable"/g' rust-toolchain.toml
+sed -i 's/channel.*/channel = "beta"/g' rust-toolchain.toml
./ci_stable.sh
diff --git a/.github/ci/doc.sh b/.github/ci/doc.sh
index 66caa915..ed3036f2 100755
--- a/.github/ci/doc.sh
+++ b/.github/ci/doc.sh
@@ -22,7 +22,6 @@ docserver-builder -i ./embassy-boot/stm32 -o webroot/crates/embassy-boot-stm32/g
docserver-builder -i ./embassy-embedded-hal -o webroot/crates/embassy-embedded-hal/git.zup
docserver-builder -i ./embassy-executor -o webroot/crates/embassy-executor/git.zup
docserver-builder -i ./embassy-futures -o webroot/crates/embassy-futures/git.zup
-docserver-builder -i ./embassy-lora -o webroot/crates/embassy-lora/git.zup
docserver-builder -i ./embassy-net -o webroot/crates/embassy-net/git.zup
docserver-builder -i ./embassy-net-driver -o webroot/crates/embassy-net-driver/git.zup
docserver-builder -i ./embassy-net-driver-channel -o webroot/crates/embassy-net-driver-channel/git.zup
diff --git a/.github/ci/test.sh b/.github/ci/test.sh
index dfc2b08c..1ee760d3 100755
--- a/.github/ci/test.sh
+++ b/.github/ci/test.sh
@@ -4,17 +4,6 @@
set -euo pipefail
-export RUSTUP_HOME=/ci/cache/rustup
-export CARGO_HOME=/ci/cache/cargo
-export CARGO_TARGET_DIR=/ci/cache/target
-
-# needed for "dumb HTTP" transport support
-# used when pointing stm32-metapac to a CI-built one.
-export CARGO_NET_GIT_FETCH_WITH_CLI=true
-
-hashtime restore /ci/cache/filetime.json || true
-hashtime save /ci/cache/filetime.json
-
MIRIFLAGS=-Zmiri-ignore-leaks cargo miri test --manifest-path ./embassy-executor/Cargo.toml
MIRIFLAGS=-Zmiri-ignore-leaks cargo miri test --manifest-path ./embassy-executor/Cargo.toml --features nightly
@@ -24,16 +13,15 @@ cargo test --manifest-path ./embassy-hal-internal/Cargo.toml
cargo test --manifest-path ./embassy-time/Cargo.toml --features generic-queue
cargo test --manifest-path ./embassy-boot/boot/Cargo.toml
-cargo test --manifest-path ./embassy-boot/boot/Cargo.toml --features nightly
-cargo test --manifest-path ./embassy-boot/boot/Cargo.toml --features nightly,ed25519-dalek
-cargo test --manifest-path ./embassy-boot/boot/Cargo.toml --features nightly,ed25519-salty
+cargo test --manifest-path ./embassy-boot/boot/Cargo.toml --features ed25519-dalek
+cargo test --manifest-path ./embassy-boot/boot/Cargo.toml --features ed25519-salty
-cargo test --manifest-path ./embassy-nrf/Cargo.toml --no-default-features --features nightly,nrf52840,time-driver-rtc1,gpiote
+cargo test --manifest-path ./embassy-nrf/Cargo.toml --no-default-features --features nrf52840,time-driver-rtc1,gpiote
-cargo test --manifest-path ./embassy-rp/Cargo.toml --no-default-features --features nightly,time-driver
+cargo test --manifest-path ./embassy-rp/Cargo.toml --no-default-features --features time-driver
-cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features nightly,stm32f429vg,exti,time-driver-any,exti
-cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features nightly,stm32f732ze,exti,time-driver-any,exti
-cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features nightly,stm32f769ni,exti,time-driver-any,exti
+cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f429vg,exti,time-driver-any,exti
+cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f732ze,exti,time-driver-any,exti
+cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f769ni,exti,time-driver-any,exti
cargo test --manifest-path ./embassy-net-adin1110/Cargo.toml
diff --git a/.vscode/settings.json b/.vscode/settings.json
index d48f7ba1..d46ce603 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -3,6 +3,9 @@
"[toml]": {
"editor.formatOnSave": false
},
+ "[markdown]": {
+ "editor.formatOnSave": false
+ },
"rust-analyzer.check.allTargets": false,
"rust-analyzer.check.noDefaultFeatures": true,
"rust-analyzer.cargo.noDefaultFeatures": true,
diff --git a/README.md b/README.md
index e5a97062..7ae40fe5 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ The nrf-softdevice cr
The embassy-stm32-wpan crate provides Bluetooth Low Energy 5.x support for stm32wb microcontrollers.
- **LoRa** -
-embassy-lora supports LoRa networking.
+The lora-rs project provides an async LoRa and LoRaWAN stack that works well on Embassy.
- **USB** -
embassy-usb implements a device-side USB stack. Implementations for common classes such as USB serial (CDC ACM) and USB HID are available, and a rich builder API allows building your own.
diff --git a/ci.sh b/ci.sh
index 5a4773da..8a5e206d 100755
--- a/ci.sh
+++ b/ci.sh
@@ -35,104 +35,94 @@ cargo batch \
--- build --release --manifest-path embassy-executor/Cargo.toml --target riscv32imac-unknown-none-elf --features nightly,arch-riscv32,integrated-timers \
--- build --release --manifest-path embassy-executor/Cargo.toml --target riscv32imac-unknown-none-elf --features nightly,arch-riscv32,executor-thread \
--- build --release --manifest-path embassy-executor/Cargo.toml --target riscv32imac-unknown-none-elf --features nightly,arch-riscv32,executor-thread,integrated-timers \
- --- build --release --manifest-path embassy-sync/Cargo.toml --target thumbv6m-none-eabi --features nightly,defmt \
- --- build --release --manifest-path embassy-time/Cargo.toml --target thumbv6m-none-eabi --features nightly,defmt,defmt-timestamp-uptime,tick-hz-32_768,generic-queue-8 \
+ --- build --release --manifest-path embassy-sync/Cargo.toml --target thumbv6m-none-eabi --features defmt \
+ --- build --release --manifest-path embassy-time/Cargo.toml --target thumbv6m-none-eabi --features defmt,defmt-timestamp-uptime,tick-hz-32_768,generic-queue-8 \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,medium-ethernet \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,igmp,medium-ethernet \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,dhcpv4,medium-ethernet \
- --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,dhcpv4,medium-ethernet,nightly,dhcpv4-hostname \
+ --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,dhcpv4,medium-ethernet,dhcpv4-hostname \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ieee802154 \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet,medium-ieee802154 \
- --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet,nightly \
+ --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet \
--- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ethernet \
- --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ethernet,nightly \
- --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ip,nightly \
- --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ip,medium-ethernet,nightly \
- --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ip,medium-ethernet,medium-ieee802154,nightly \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52805,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52810,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52811,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52820,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52832,gpiote,time-driver-rtc1,reset-pin-as-gpio \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52833,gpiote,time-driver-rtc1,unstable-traits,nfc-pins-as-gpio \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,nrf9160-s,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,nrf9160-ns,gpiote,time-driver-rtc1,unstable-traits \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,nrf5340-app-s,gpiote,time-driver-rtc1,unstable-traits \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,nrf5340-app-ns,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,nrf5340-net,gpiote,time-driver-rtc1,unstable-traits \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52840,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52840,log,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52840,defmt,gpiote,time-driver-rtc1,unstable-traits \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,unstable-traits,defmt \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,unstable-traits,log \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,unstable-traits \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,intrinsics \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,qspi-as-gpio \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ip \
+ --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ip,medium-ethernet \
+ --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv4,proto-ipv6,medium-ip,medium-ethernet,medium-ieee802154 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52805,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52810,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52811,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52820,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52832,gpiote,time-driver-rtc1,reset-pin-as-gpio \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52833,gpiote,time-driver-rtc1,nfc-pins-as-gpio \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf9160-s,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf9160-ns,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-app-s,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-app-ns,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-net,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,log,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,defmt,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features defmt \
+ --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features log \
+ --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features intrinsics \
+ --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features qspi-as-gpio \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,exti,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,exti,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,exti \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt,exti,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,nightly,defmt \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f401ve,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f405zg,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f407zg,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f401ve,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f405zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f407zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f410tb,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f411ce,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f412zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f413vh,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f415zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f417zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f423zh,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f427zi,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f429zi,log,exti,time-driver-any,unstable-traits,embedded-sdmmc,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f437zi,log,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f439zi,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f446ze,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f469zi,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f479zi,defmt,exti,time-driver-any,unstable-traits,embedded-sdmmc,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f730i8,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h753zi,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h735zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h755zi-cm7,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h725re,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h7b3ai,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32l476vg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32l422cb,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32wb15cc,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l072cz,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l041f6,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l073cz,defmt,exti,time-driver-any,unstable-traits,low-power,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32l151cb-a,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f398ve,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f378cc,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32g0c1ve,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f217zg,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,stm32l552ze,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32wl54jc-cm0p,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32wle5jb,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32g474pe,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f107vc,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f103re,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f100c4,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32h503rb,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32h562ag,defmt,exti,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f401ve,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f405zg,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f407zg,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f401ve,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f405zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f407zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f412zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f413vh,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f415zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f417zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f423zh,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f427zi,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,embedded-sdmmc,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f437zi,log,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f439zi,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f446ze,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f469zi,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f479zi,defmt,exti,time-driver-any,embedded-sdmmc,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f730i8,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h753zi,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h735zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h725re,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h7b3ai,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l422cb,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb15cc,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l041f6,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l073cz,defmt,exti,time-driver-any,low-power,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f398ve,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f378cc,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32g0c1ve,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features stm32l552ze,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32wl54jc-cm0p,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wle5jb,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g474pe,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f107vc,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f103re,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f100c4,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32h503rb,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32h562ag,defmt,exti,time-driver-any,time \
--- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features ''\
--- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features 'log' \
--- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features 'defmt' \
@@ -140,10 +130,10 @@ cargo batch \
--- build --release --manifest-path cyw43/Cargo.toml --target thumbv6m-none-eabi --features 'defmt,firmware-logs' \
--- build --release --manifest-path cyw43-pio/Cargo.toml --target thumbv6m-none-eabi --features '' \
--- build --release --manifest-path cyw43-pio/Cargo.toml --target thumbv6m-none-eabi --features 'overclock' \
- --- build --release --manifest-path embassy-boot/nrf/Cargo.toml --target thumbv7em-none-eabi --features embassy-nrf/nrf52840,nightly \
- --- build --release --manifest-path embassy-boot/nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features embassy-nrf/nrf9160-ns,nightly \
- --- build --release --manifest-path embassy-boot/rp/Cargo.toml --target thumbv6m-none-eabi --features nightly \
- --- build --release --manifest-path embassy-boot/stm32/Cargo.toml --target thumbv7em-none-eabi --features embassy-stm32/stm32wl55jc-cm4,nightly \
+ --- build --release --manifest-path embassy-boot/nrf/Cargo.toml --target thumbv7em-none-eabi --features embassy-nrf/nrf52840 \
+ --- build --release --manifest-path embassy-boot/nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features embassy-nrf/nrf9160-ns \
+ --- build --release --manifest-path embassy-boot/rp/Cargo.toml --target thumbv6m-none-eabi \
+ --- build --release --manifest-path embassy-boot/stm32/Cargo.toml --target thumbv7em-none-eabi --features embassy-stm32/stm32wl55jc-cm4 \
--- build --release --manifest-path docs/modules/ROOT/examples/basic/Cargo.toml --target thumbv7em-none-eabi \
--- build --release --manifest-path docs/modules/ROOT/examples/layer-by-layer/blinky-pac/Cargo.toml --target thumbv7em-none-eabi \
--- build --release --manifest-path docs/modules/ROOT/examples/layer-by-layer/blinky-hal/Cargo.toml --target thumbv7em-none-eabi \
diff --git a/ci_stable.sh b/ci_stable.sh
index 1fe4e3a1..66ed8f79 100755
--- a/ci_stable.sh
+++ b/ci_stable.sh
@@ -22,56 +22,56 @@ cargo batch \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52811,gpiote,time-driver-rtc1 \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52820,gpiote,time-driver-rtc1 \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52832,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52833,gpiote,time-driver-rtc1,unstable-traits \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52833,gpiote,time-driver-rtc1 \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf9160-s,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf9160-ns,gpiote,time-driver-rtc1,unstable-traits \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-app-s,gpiote,time-driver-rtc1,unstable-traits \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf9160-ns,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-app-s,gpiote,time-driver-rtc1 \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-app-ns,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-net,gpiote,time-driver-rtc1,unstable-traits \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv8m.main-none-eabihf --features nrf5340-net,gpiote,time-driver-rtc1 \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,gpiote,time-driver-rtc1 \
--- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,log,gpiote,time-driver-rtc1 \
- --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,defmt,gpiote,time-driver-rtc1,unstable-traits \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features unstable-traits,defmt \
- --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features unstable-traits,log \
+ --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52840,defmt,gpiote,time-driver-rtc1 \
+ --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features defmt \
+ --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features log \
--- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi \
--- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features qspi-as-gpio \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g473cc,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g491re,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32u585zi,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb55vy,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wl55cc-cm4,defmt,exti,time-driver-any,unstable-traits \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g473cc,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g491re,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32u585zi,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb55vy,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wl55cc-cm4,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l4r9zi,defmt,exti,time-driver-any,unstable-traits,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f303vc,defmt,exti,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g473cc,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g491re,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32u585zi,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb55vy,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wl55cc-cm4,defmt,exti,time-driver-any \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g473cc,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g491re,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32u585zi,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb55vy,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wl55cc-cm4,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l4r9zi,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f303vc,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,unstable-traits,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,unstable-traits,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,time \
+ --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,time \
--- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,time \
- --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,unstable-traits,time \
--- build --release --manifest-path examples/nrf52840/Cargo.toml --target thumbv7em-none-eabi --no-default-features --out-dir out/examples/nrf52840 --bin raw_spawn \
--- build --release --manifest-path examples/stm32l0/Cargo.toml --target thumbv6m-none-eabi --no-default-features --out-dir out/examples/stm32l0 --bin raw_spawn \
diff --git a/cyw43-pio/src/lib.rs b/cyw43-pio/src/lib.rs
index de89ed58..41b67032 100644
--- a/cyw43-pio/src/lib.rs
+++ b/cyw43-pio/src/lib.rs
@@ -1,6 +1,5 @@
#![no_std]
-#![feature(async_fn_in_trait)]
-#![allow(stable_features, unknown_lints, async_fn_in_trait)]
+#![allow(async_fn_in_trait)]
use core::slice;
diff --git a/cyw43/Cargo.toml b/cyw43/Cargo.toml
index 789e3ab0..293c0098 100644
--- a/cyw43/Cargo.toml
+++ b/cyw43/Cargo.toml
@@ -11,8 +11,8 @@ log = ["dep:log"]
firmware-logs = []
[dependencies]
-embassy-time = { version = "0.1.5", path = "../embassy-time"}
-embassy-sync = { version = "0.4.0", path = "../embassy-sync"}
+embassy-time = { version = "0.2", path = "../embassy-time"}
+embassy-sync = { version = "0.5.0", path = "../embassy-sync"}
embassy-futures = { version = "0.1.0", path = "../embassy-futures"}
embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel"}
@@ -23,7 +23,7 @@ cortex-m = "0.7.6"
cortex-m-rt = "0.7.0"
futures = { version = "0.3.17", default-features = false, features = ["async-await", "cfg-target-has-atomic", "unstable"] }
-embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-rc.1" }
+embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-rc.2" }
num_enum = { version = "0.5.7", default-features = false }
[package.metadata.embassy_docs]
diff --git a/cyw43/src/lib.rs b/cyw43/src/lib.rs
index 4a1d015a..300465e3 100644
--- a/cyw43/src/lib.rs
+++ b/cyw43/src/lib.rs
@@ -1,7 +1,6 @@
#![no_std]
#![no_main]
-#![feature(async_fn_in_trait, type_alias_impl_trait)]
-#![allow(stable_features, unknown_lints, async_fn_in_trait)]
+#![allow(async_fn_in_trait)]
#![deny(unused_must_use)]
// This mod MUST go first, so that the others see its macros.
diff --git a/docs/modules/ROOT/examples/basic/Cargo.toml b/docs/modules/ROOT/examples/basic/Cargo.toml
index 527ce2ed..b2e173bf 100644
--- a/docs/modules/ROOT/examples/basic/Cargo.toml
+++ b/docs/modules/ROOT/examples/basic/Cargo.toml
@@ -6,9 +6,9 @@ version = "0.1.0"
license = "MIT OR Apache-2.0"
[dependencies]
-embassy-executor = { version = "0.3.0", path = "../../../../../embassy-executor", features = ["defmt", "nightly", "integrated-timers", "arch-cortex-m", "executor-thread"] }
-embassy-time = { version = "0.1.4", path = "../../../../../embassy-time", features = ["defmt", "nightly"] }
-embassy-nrf = { version = "0.1.0", path = "../../../../../embassy-nrf", features = ["defmt", "nrf52840", "time-driver-rtc1", "gpiote", "nightly"] }
+embassy-executor = { version = "0.3.0", path = "../../../../../embassy-executor", features = ["defmt", "integrated-timers", "arch-cortex-m", "executor-thread"] }
+embassy-time = { version = "0.2.0", path = "../../../../../embassy-time", features = ["defmt"] }
+embassy-nrf = { version = "0.1.0", path = "../../../../../embassy-nrf", features = ["defmt", "nrf52840", "time-driver-rtc1", "gpiote"] }
defmt = "0.3"
defmt-rtt = "0.3"
diff --git a/docs/modules/ROOT/nav.adoc b/docs/modules/ROOT/nav.adoc
index 13459099..8d7f6f41 100644
--- a/docs/modules/ROOT/nav.adoc
+++ b/docs/modules/ROOT/nav.adoc
@@ -3,6 +3,7 @@
** xref:project_structure.adoc[Project Structure]
* xref:layer_by_layer.adoc[Bare metal to async]
* xref:runtime.adoc[Executor]
+* xref:delaying_a_task.adoc[Delaying a Task]
* xref:hal.adoc[HAL]
** xref:nrf.adoc[nRF]
** xref:stm32.adoc[STM32]
diff --git a/docs/modules/ROOT/pages/basic_application.adoc b/docs/modules/ROOT/pages/basic_application.adoc
index 73774c71..95792d5a 100644
--- a/docs/modules/ROOT/pages/basic_application.adoc
+++ b/docs/modules/ROOT/pages/basic_application.adoc
@@ -6,13 +6,24 @@ So you've got one of the xref:examples.adoc[examples] running, but what now? Let
The full example can be found link:https://github.com/embassy-rs/embassy/tree/master/docs/modules/ROOT/examples/basic[here].
-=== Rust Nightly
+NOTE: If you’re using VS Code and rust-analyzer to view and edit the examples, you may need to make some changes to `.vscode/settings.json` to tell it which project we’re working on. Follow the instructions commented in that file to get rust-analyzer working correctly.
-The first thing you'll notice is a few declarations stating that Embassy requires some nightly features:
+=== Bare metal
+
+The first thing you’ll notice are two attributes at the top of the file. These tells the compiler that program has no access to std, and that there is no main function (because it is not run by an OS).
[source,rust]
----
-include::example$basic/src/main.rs[lines="1..3"]
+include::example$basic/src/main.rs[lines="1..2"]
+----
+
+=== Rust Nightly
+
+The next declaration is a Rust Unstable feature, which means that Embassy requires Rust Nightly:
+
+[source,rust]
+----
+include::example$basic/src/main.rs[lines="3"]
----
=== Dealing with errors
@@ -39,9 +50,9 @@ NOTE: Notice that there is no busy waiting going on in this task. It is using th
=== Main
-The main entry point of an Embassy application is defined using the `#[embassy_executor::main]` macro. The entry point is also required to take a `Spawner` and a `Peripherals` argument.
+The main entry point of an Embassy application is defined using the `#[embassy_executor::main]` macro. The entry point is passed a `Spawner`, which it can use to spawn other tasks.
-The `Spawner` is the way the main application spawns other tasks. The `Peripherals` type comes from the HAL and holds all peripherals that the application may use. In this case, we want to configure one of the pins as a GPIO output driving the LED:
+We then initialize the HAL with a default config, which gives us a `Peripherals` struct we can use to access the MCU’s various peripherals. In this case, we want to configure one of the pins as a GPIO output driving the LED:
[source,rust]
----
@@ -51,7 +62,6 @@ include::example$basic/src/main.rs[lines="22..-1"]
What happens when the `blinker` task has been spawned and main returns? Well, the main entry point is actually just like any other task, except that you can only have one and it takes some specific type arguments. The magic lies within the `#[embassy_executor::main]` macro. The macro does the following:
. Creates an Embassy Executor
-. Initializes the microcontroller HAL to get the `Peripherals`
. Defines a main task for the entry point
. Runs the executor spawning the main task
diff --git a/docs/modules/ROOT/pages/delaying_a_task.adoc b/docs/modules/ROOT/pages/delaying_a_task.adoc
new file mode 100644
index 00000000..3171e351
--- /dev/null
+++ b/docs/modules/ROOT/pages/delaying_a_task.adoc
@@ -0,0 +1,28 @@
+= Delaying a Task
+
+In an embedded program, delaying a task is one of the most common actions taken. In an event loop, delays will need to be inserted to ensure
+that other tasks have a chance to run before the next iteration of the loop is called, if no other I/O is performed. Embassy provides an abstraction
+to delay the current task for a specified interval of time.
+
+Timing is serviced by the `embassy::time::Timer` struct, which provides two timing methods.
+
+`Timer::at` creates a future that completes at the specified `Instant`, relative to the system boot time.
+`Timer::after` creates a future that completes after the specified `Duration`, relative to when the future was created.
+
+An example of a delay is provided as follows:
+
+[,rust]
+----
+use embassy::executor::{task, Executor};
+use embassy::time::{Duration, Timer};
+
+#[task]
+/// Task that ticks periodically
+async fn tick_periodic() -> ! {
+ loop {
+ rprintln!("tick!");
+ // async sleep primitive, suspends the task for 500ms.
+ Timer::after(Duration::from_millis(500)).await;
+ }
+}
+----
\ No newline at end of file
diff --git a/docs/modules/ROOT/pages/getting_started.adoc b/docs/modules/ROOT/pages/getting_started.adoc
index 2c6f4b1e..ab819ac2 100644
--- a/docs/modules/ROOT/pages/getting_started.adoc
+++ b/docs/modules/ROOT/pages/getting_started.adoc
@@ -9,7 +9,9 @@ If you don't have any supported board, don't worry: you can also run embassy on
== Getting a board with examples
-Embassy supports many microcontroller families, but the easiest ways to get started is if you have one of the more common development kits.
+Embassy supports many microcontroller families, but the quickest way to get started is by using a board which Embassy has existing example code for.
+
+This list is non-exhaustive. If your board isn’t included here, check the link:https://github.com/embassy-rs/embassy/tree/main/examples[examples folder] to see if example code has been written for it.
=== nRF kits
@@ -36,7 +38,7 @@ Embassy supports many microcontroller families, but the easiest ways to get star
== Running an example
-First you need to clone the [github repository];
+First you need to clone the link:https://github.com/embassy-rs/embassy[github repository];
[source, bash]
----
@@ -44,17 +46,80 @@ git clone https://github.com/embassy-rs/embassy.git
cd embassy
----
-You can run an example by opening a terminal and entering the following commands:
+Once you have a copy of the repository, find examples folder for your board and, and build an example program. `blinky` is a good choice as all it does is blink an LED – the embedded world’s equivalent of “Hello World”.
[source, bash]
----
cd examples/nrf52840
+cargo build --bin blinky --release
+----
+
+Once you’ve confirmed you can build the example, connect your computer to your board with a debug probe and run it on hardware:
+
+[source, bash]
+----
cargo run --bin blinky --release
----
+If everything worked correctly, you should see a blinking LED on your board, and debug output similar to this on your computer:
+
+[source]
+----
+ Finished dev [unoptimized + debuginfo] target(s) in 1m 56s
+ Running `probe-run --chip STM32F407VGTx target/thumbv7em-none-eabi/debug/blinky`
+(HOST) INFO flashing program (71.36 KiB)
+(HOST) INFO success!
+────────────────────────────────────────────────────────────────────────────────
+0 INFO Hello World!
+└─ blinky::__embassy_main::task::{generator#0} @ src/bin/blinky.rs:18
+1 INFO high
+└─ blinky::__embassy_main::task::{generator#0} @ src/bin/blinky.rs:23
+2 INFO low
+└─ blinky::__embassy_main::task::{generator#0} @ src/bin/blinky.rs:27
+3 INFO high
+└─ blinky::__embassy_main::task::{generator#0} @ src/bin/blinky.rs:23
+4 INFO low
+└─ blinky::__embassy_main::task::{generator#0} @ src/bin/blinky.rs:27
+----
+
+NOTE: How does the `cargo run` command know how to connect to our board and program it? In each `examples` folder, there’s a `.cargo/config.toml` file which tells cargo to use link:https://probe.rs/[probe-rs] as the runner for ARM binaries in that folder. probe-rs handles communication with the debug probe and MCU. In order for this to work, probe-rs needs to know which chip it’s programming, so you’ll have to edit this file if you want to run examples on other chips.
+
+=== It didn’t work!
+
+If you hare having issues when running `cargo run --release`, please check the following:
+
+* You are specifying the correct `--chip on the command line``, OR
+* You have set `.cargo/config.toml`'s run line to the correct chip, AND
+* You have changed `examples/Cargo.toml`'s HAL (e.g. embassy-stm32) dependency's feature to use the correct chip (replace the existing stm32xxxx feature)
+
+At this point the project should run. If you do not see a blinky LED for blinky, for example, be sure to check the code is toggling your board's LED pin.
+
+If you are trying to run an example with `cargo run --release` and you see the following output:
+[source]
+----
+0.000000 INFO Hello World!
+└─
+0.000000 DEBUG rcc: Clocks { sys: Hertz(80000000), apb1: Hertz(80000000), apb1_tim: Hertz(80000000), apb2: Hertz(80000000), apb2_tim: Hertz(80000000), ahb1: Hertz(80000000), ahb2: Hertz(80000000), ahb3: Hertz(80000000) }
+└─
+0.000061 TRACE allocating type=Interrupt mps=8 interval_ms=255, dir=In
+└─
+0.000091 TRACE index=1
+└─
+----
+
+To get rid of the frame-index error add the following to your `Cargo.toml`:
+
+[source,toml]
+----
+[profile.release]
+debug = 2
+----
+
+If you’re still having problems, check the link:https://embassy.dev/book/dev/faq.html[FAQ], or ask for help in the link:https://matrix.to/#/#embassy-rs:matrix.org[Embassy Chat Room].
+
== What's next?
-Congratulations, you have your first Embassy application running! Here are some alternatives on where to go from here:
+Congratulations, you have your first Embassy application running! Here are some suggestions for where to go from here:
* Read more about the xref:runtime.adoc[executor].
* Read more about the xref:hal.adoc[HAL].
diff --git a/docs/modules/ROOT/pages/index.adoc b/docs/modules/ROOT/pages/index.adoc
index c6dead46..6fba80ed 100644
--- a/docs/modules/ROOT/pages/index.adoc
+++ b/docs/modules/ROOT/pages/index.adoc
@@ -4,34 +4,56 @@ Embassy is a project to make async/await a first-class option for embedded devel
== What is async?
-When handling I/O, software must call functions that block program execution until the I/O operation completes. When running inside of an OS such as Linux, such functions generally transfer control to the kernel so that another task, known as a thread, can be executed if available, or the CPU can be put to sleep until another such task is ready to perform more work. Because an OS cannot presume that threads will behave cooperatively, threads are relatively resource-intensive, and may be forcibly interrupted they do not transfer control back to the kernel within an allotted time. But if tasks could be presumed to behave cooperatively, or at least not maliciously, it would be possible to create tasks that appear to be almost free when compared to a traditional OS thread. In Rust, these lightweight tasks, known as 'coroutines' or 'goroutines' in other languages, are implemented with async.
+When handling I/O, software must call functions that block program execution until the I/O operation completes. When running inside of an OS such as Linux, such functions generally transfer control to the kernel so that another task (known as a “thread”) can be executed if available, or the CPU can be put to sleep until another task is ready.
-Async-await works by transforming each async function into an object called a future. When a future blocks on I/O the future yields, and the scheduler, called an executor, can select a different future to execute. Compared to alternatives such as an RTOS, async can yield better performance and lower power consumption because the executor doesn't have to guess when a future is ready to execute. However, program size may be higher than other alternatives, which may be a problem for certain space-constrained devices with very low memory. On the devices Embassy supports, such as stm32 and nrf, memory is generally large enough to accommodate the modestly-increased program size.
+Because an OS cannot presume that threads will behave cooperatively, threads are relatively resource-intensive, and may be forcibly interrupted they do not transfer control back to the kernel within an allotted time. If tasks could be presumed to behave cooperatively, or at least not maliciously, it would be possible to create tasks that appear to be almost free when compared to a traditional OS thread.
+
+In other programming languages, these lightweight tasks are known as “coroutines” or ”goroutines”. In Rust, they are implemented with async. Async-await works by transforming each async function into an object called a future. When a future blocks on I/O the future yields, and the scheduler, called an executor, can select a different future to execute.
+
+Compared to alternatives such as an RTOS, async can yield better performance and lower power consumption because the executor doesn't have to guess when a future is ready to execute. However, program size may be higher than other alternatives, which may be a problem for certain space-constrained devices with very low memory. On the devices Embassy supports, such as stm32 and nrf, memory is generally large enough to accommodate the modestly-increased program size.
== What is Embassy?
The Embassy project consists of several crates that you can use together or independently:
-* **Executor** - The link:https://docs.embassy.dev/embassy-executor/[embassy-executor] is an async/await executor that generally executes a fixed number of tasks, allocated at startup, though more can be added later. The HAL is an API that you can use to access peripherals, such as USART, UART, I2C, SPI, CAN, and USB. Embassy provides implementations of both async and blocking APIs where it makes sense. DMA (Direct Memory Access) is an example where async is a good fit, whereas GPIO states are a better fit for a blocking API. The executor may also provide a system timer that you can use for both async and blocking delays. For less than one microsecond, blocking delays should be used because the cost of context-switching is too high and the executor will be unable to provide accurate timing.
+=== Executor
+The link:https://docs.embassy.dev/embassy-executor/[embassy-executor] is an async/await executor that generally executes a fixed number of tasks, allocated at startup, though more can be added later. The executor may also provide a system timer that you can use for both async and blocking delays. For less than one microsecond, blocking delays should be used because the cost of context-switching is too high and the executor will be unable to provide accurate timing.
+
+=== Hardware Abstraction Layers
+HALs implement safe Rust API which let you use peripherals such as USART, UART, I2C, SPI, CAN, and USB without having to directly manipulate registers.
+
+Embassy provides implementations of both async and blocking APIs where it makes sense. DMA (Direct Memory Access) is an example where async is a good fit, whereas GPIO states are a better fit for a blocking API.
+
+The Embassy project maintains HALs for select hardware, but you can still use HALs from other projects with Embassy.
+
+* link:https://docs.embassy.dev/embassy-stm32/[embassy-stm32], for all STM32 microcontroller families.
+* link:https://docs.embassy.dev/embassy-nrf/[embassy-nrf], for the Nordic Semiconductor nRF52, nRF53, nRF91 series.
+* link:https://docs.embassy.dev/embassy-rp/[embassy-rp], for the Raspberry Pi RP2040 microcontroller.
+* link:https://github.com/esp-rs[esp-rs], for the Espressif Systems ESP32 series of chips.
-* **Hardware Abstraction Layers** - HALs implement safe, idiomatic Rust APIs to use the hardware capabilities, so raw register manipulation is not needed. The Embassy project maintains HALs for select hardware, but you can still use HALs from other projects with Embassy.
-** link:https://docs.embassy.dev/embassy-stm32/[embassy-stm32], for all STM32 microcontroller families.
-** link:https://docs.embassy.dev/embassy-nrf/[embassy-nrf], for the Nordic Semiconductor nRF52, nRF53, nRF91 series.
-** link:https://docs.embassy.dev/embassy-rp/[embassy-rp], for the Raspberry Pi RP2040 microcontroller.
-** link:https://github.com/esp-rs[esp-rs], for the Espressif Systems ESP32 series of chips.
-+
NOTE: A common question is if one can use the Embassy HALs standalone. Yes, it is possible! There are no dependency on the executor within the HALs. You can even use them without async,
as they implement both the link:https://github.com/rust-embedded/embedded-hal[Embedded HAL] blocking and async traits.
-* **Networking** - The link:https://docs.embassy.dev/embassy-net/[embassy-net] network stack implements extensive networking functionality, including Ethernet, IP, TCP, UDP, ICMP and DHCP. Async drastically simplifies managing timeouts and serving multiple connections concurrently. Several drivers for WiFi and Ethernet chips can be found.
+=== Networking
+The link:https://docs.embassy.dev/embassy-net/[embassy-net] network stack implements extensive networking functionality, including Ethernet, IP, TCP, UDP, ICMP and DHCP. Async drastically simplifies managing timeouts and serving multiple connections concurrently. Several drivers for WiFi and Ethernet chips can be found.
-* **Bluetooth** - The link:https://github.com/embassy-rs/nrf-softdevice[nrf-softdevice] crate provides Bluetooth Low Energy 4.x and 5.x support for nRF52 microcontrollers.
+=== Bluetooth
+The link:https://github.com/embassy-rs/nrf-softdevice[nrf-softdevice] crate provides Bluetooth Low Energy 4.x and 5.x support for nRF52 microcontrollers.
-* **LoRa** - link:https://github.com/embassy-rs/lora-phy[lora-phy] and link:https://docs.embassy.dev/embassy-lora/[embassy-lora] supports LoRa networking on a wide range of LoRa radios, fully integrated with a Rust link:https://github.com/ivajloip/rust-lorawan[LoRaWAN] implementation.
+=== LoRa
+link:https://github.com/embassy-rs/lora-phy[lora-phy] and link:https://docs.embassy.dev/embassy-lora/[embassy-lora] supports LoRa networking on a wide range of LoRa radios, fully integrated with a Rust link:https://github.com/ivajloip/rust-lorawan[LoRaWAN] implementation.
-* **USB** - link:https://docs.embassy.dev/embassy-usb/[embassy-usb] implements a device-side USB stack. Implementations for common classes such as USB serial (CDC ACM) and USB HID are available, and a rich builder API allows building your own.
+=== USB
+link:https://docs.embassy.dev/embassy-usb/[embassy-usb] implements a device-side USB stack. Implementations for common classes such as USB serial (CDC ACM) and USB HID are available, and a rich builder API allows building your own.
-* **Bootloader and DFU** - link:https://github.com/embassy-rs/embassy/tree/master/embassy-boot[embassy-boot] is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe way, with trial boots and rollbacks.
+=== Bootloader and DFU
+link:https://github.com/embassy-rs/embassy/tree/master/embassy-boot[embassy-boot] is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe way, with trial boots and rollbacks.
+
+== What is DMA?
+
+For most I/O in embedded devices, the peripheral doesn't directly support the transmission of multiple bits at once, with CAN being a notable exception. Instead, the MCU must write each byte, one at a time, and then wait until the peripheral is ready to send the next. For high I/O rates, this can pose a problem if the MCU must devote an increasing portion of its time handling each byte. The solution to this problem is to use the Direct Memory Access controller.
+
+The Direct Memory Access controller (DMA) is a controller that is present in MCUs that Embassy supports, including stm32 and nrf. The DMA allows the MCU to set up a transfer, either send or receive, and then wait for the transfer to complete. With DMA, once started, no MCU intervention is required until the transfer is complete, meaning that the MCU can perform other computation, or set up other I/O while the transfer is in progress. For high I/O rates, DMA can cut the time that the MCU spends handling I/O by over half. However, because DMA is more complex to set-up, it is less widely used in the embedded community. Embassy aims to change that by making DMA the first choice rather than the last. Using Embassy, there's no additional tuning required once I/O rates increase because your application is already set-up to handle them.
== Resources
diff --git a/docs/modules/ROOT/pages/runtime.adoc b/docs/modules/ROOT/pages/runtime.adoc
index 8f4921f6..f2812dd7 100644
--- a/docs/modules/ROOT/pages/runtime.adoc
+++ b/docs/modules/ROOT/pages/runtime.adoc
@@ -27,7 +27,7 @@ If you use the `#[embassy_executor::main]` macro in your application, it creates
Interrupts are a common way for peripherals to signal completion of some operation and fits well with the async execution model. The following diagram describes a typical application flow where (1) a task is polled and is attempting to make progress. The task then (2) instructs the peripheral to perform some operation, and awaits. After some time has passed, (3) an interrupt is raised, marking the completion of the operation.
-The peripheral HAL then (4) ensures that interrupt signals are routed to to the peripheral and updating the peripheral state with the results of the operation. The executor is then (5) notified that the task should be polled, which it will do.
+The peripheral HAL then (4) ensures that interrupt signals are routed to the peripheral and updating the peripheral state with the results of the operation. The executor is then (5) notified that the task should be polled, which it will do.
image::embassy_irq.png[Interrupt handling]
diff --git a/embassy-boot/boot/Cargo.toml b/embassy-boot/boot/Cargo.toml
index 8e11db57..dd2ff815 100644
--- a/embassy-boot/boot/Cargo.toml
+++ b/embassy-boot/boot/Cargo.toml
@@ -25,12 +25,12 @@ features = ["defmt"]
[dependencies]
defmt = { version = "0.3", optional = true }
digest = "0.10"
-log = { version = "0.4", optional = true }
+log = { version = "0.4", optional = true }
ed25519-dalek = { version = "1.0.1", default_features = false, features = ["u32_backend"], optional = true }
embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal" }
-embassy-sync = { version = "0.4.0", path = "../../embassy-sync" }
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embassy-sync = { version = "0.5.0", path = "../../embassy-sync" }
+embedded-storage = "0.3.1"
+embedded-storage-async = { version = "0.4.1" }
salty = { git = "https://github.com/ycrypto/salty.git", rev = "a9f17911a5024698406b75c0fac56ab5ccf6a8c7", optional = true }
signature = { version = "1.6.4", default-features = false }
@@ -50,7 +50,5 @@ features = ["rand", "std", "u32_backend"]
ed25519-dalek = ["dep:ed25519-dalek", "_verify"]
ed25519-salty = ["dep:salty", "_verify"]
-nightly = ["dep:embedded-storage-async", "embassy-embedded-hal/nightly"]
-
#Internal features
_verify = []
diff --git a/embassy-boot/boot/src/firmware_updater/mod.rs b/embassy-boot/boot/src/firmware_updater/mod.rs
index 937ddcc6..4814786b 100644
--- a/embassy-boot/boot/src/firmware_updater/mod.rs
+++ b/embassy-boot/boot/src/firmware_updater/mod.rs
@@ -1,8 +1,6 @@
-#[cfg(feature = "nightly")]
mod asynch;
mod blocking;
-#[cfg(feature = "nightly")]
pub use asynch::{FirmwareState, FirmwareUpdater};
pub use blocking::{BlockingFirmwareState, BlockingFirmwareUpdater};
use embedded_storage::nor_flash::{NorFlashError, NorFlashErrorKind};
diff --git a/embassy-boot/boot/src/lib.rs b/embassy-boot/boot/src/lib.rs
index 9f035637..9e70a4dc 100644
--- a/embassy-boot/boot/src/lib.rs
+++ b/embassy-boot/boot/src/lib.rs
@@ -1,6 +1,5 @@
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
#![no_std]
+#![allow(async_fn_in_trait)]
#![warn(missing_docs)]
#![doc = include_str!("../README.md")]
mod fmt;
@@ -18,10 +17,9 @@ mod test_flash;
pub(crate) const STATE_ERASE_VALUE: u8 = 0xFF;
pub use boot_loader::{BootError, BootLoader, BootLoaderConfig};
pub use firmware_updater::{
- BlockingFirmwareState, BlockingFirmwareUpdater, FirmwareUpdaterConfig, FirmwareUpdaterError,
+ BlockingFirmwareState, BlockingFirmwareUpdater, FirmwareState, FirmwareUpdater, FirmwareUpdaterConfig,
+ FirmwareUpdaterError,
};
-#[cfg(feature = "nightly")]
-pub use firmware_updater::{FirmwareState, FirmwareUpdater};
pub(crate) const BOOT_MAGIC: u8 = 0xD0;
pub(crate) const SWAP_MAGIC: u8 = 0xF0;
@@ -57,7 +55,6 @@ mod tests {
#![allow(unused_imports)]
use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
- #[cfg(feature = "nightly")]
use embedded_storage_async::nor_flash::NorFlash as AsyncNorFlash;
use futures::executor::block_on;
@@ -65,9 +62,7 @@ mod tests {
use crate::boot_loader::BootLoaderConfig;
use crate::firmware_updater::FirmwareUpdaterConfig;
use crate::mem_flash::MemFlash;
- #[cfg(feature = "nightly")]
- use crate::test_flash::AsyncTestFlash;
- use crate::test_flash::BlockingTestFlash;
+ use crate::test_flash::{AsyncTestFlash, BlockingTestFlash};
/*
#[test]
@@ -105,7 +100,7 @@ mod tests {
}
#[test]
- #[cfg(all(feature = "nightly", not(feature = "_verify")))]
+ #[cfg(not(feature = "_verify"))]
fn test_swap_state() {
const FIRMWARE_SIZE: usize = 57344;
let flash = AsyncTestFlash::new(BootLoaderConfig {
@@ -183,7 +178,7 @@ mod tests {
}
#[test]
- #[cfg(all(feature = "nightly", not(feature = "_verify")))]
+ #[cfg(not(feature = "_verify"))]
fn test_swap_state_active_page_biggest() {
const FIRMWARE_SIZE: usize = 12288;
let flash = AsyncTestFlash::new(BootLoaderConfig {
@@ -228,7 +223,7 @@ mod tests {
}
#[test]
- #[cfg(all(feature = "nightly", not(feature = "_verify")))]
+ #[cfg(not(feature = "_verify"))]
fn test_swap_state_dfu_page_biggest() {
const FIRMWARE_SIZE: usize = 12288;
let flash = AsyncTestFlash::new(BootLoaderConfig {
@@ -272,7 +267,7 @@ mod tests {
}
#[test]
- #[cfg(all(feature = "nightly", feature = "_verify"))]
+ #[cfg(feature = "_verify")]
fn test_verify() {
// The following key setup is based on:
// https://docs.rs/ed25519-dalek/latest/ed25519_dalek/#example
diff --git a/embassy-boot/boot/src/mem_flash.rs b/embassy-boot/boot/src/mem_flash.rs
index 2728e972..40f352c8 100644
--- a/embassy-boot/boot/src/mem_flash.rs
+++ b/embassy-boot/boot/src/mem_flash.rs
@@ -3,7 +3,6 @@
use core::ops::{Bound, Range, RangeBounds};
use embedded_storage::nor_flash::{ErrorType, NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash};
-#[cfg(feature = "nightly")]
use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
pub struct MemFlash {
@@ -141,7 +140,6 @@ impl NorFla
}
}
-#[cfg(feature = "nightly")]
impl AsyncReadNorFlash
for MemFlash
{
@@ -156,7 +154,6 @@ impl AsyncR
}
}
-#[cfg(feature = "nightly")]
impl AsyncNorFlash
for MemFlash
{
diff --git a/embassy-boot/boot/src/test_flash/blocking.rs b/embassy-boot/boot/src/test_flash/blocking.rs
index ba33c920..5ec476c6 100644
--- a/embassy-boot/boot/src/test_flash/blocking.rs
+++ b/embassy-boot/boot/src/test_flash/blocking.rs
@@ -51,7 +51,6 @@ where
}
}
-#[cfg(feature = "nightly")]
impl BlockingTestFlash
where
ACTIVE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
diff --git a/embassy-boot/boot/src/test_flash/mod.rs b/embassy-boot/boot/src/test_flash/mod.rs
index a0672322..79b15a08 100644
--- a/embassy-boot/boot/src/test_flash/mod.rs
+++ b/embassy-boot/boot/src/test_flash/mod.rs
@@ -1,7 +1,5 @@
-#[cfg(feature = "nightly")]
mod asynch;
mod blocking;
-#[cfg(feature = "nightly")]
pub(crate) use asynch::AsyncTestFlash;
pub(crate) use blocking::BlockingTestFlash;
diff --git a/embassy-boot/nrf/Cargo.toml b/embassy-boot/nrf/Cargo.toml
index 72c27efa..eea29cf2 100644
--- a/embassy-boot/nrf/Cargo.toml
+++ b/embassy-boot/nrf/Cargo.toml
@@ -16,13 +16,13 @@ target = "thumbv7em-none-eabi"
[dependencies]
defmt = { version = "0.3", optional = true }
-embassy-sync = { version = "0.4.0", path = "../../embassy-sync" }
+embassy-sync = { version = "0.5.0", path = "../../embassy-sync" }
embassy-nrf = { path = "../../embassy-nrf" }
embassy-boot = { path = "../boot", default-features = false }
cortex-m = { version = "0.7.6" }
cortex-m-rt = { version = "0.7" }
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-storage = "0.3.1"
+embedded-storage-async = { version = "0.4.1" }
cfg-if = "1.0.0"
nrf-softdevice-mbr = { version = "0.1.0", git = "https://github.com/embassy-rs/nrf-softdevice.git", branch = "master", optional = true }
@@ -36,8 +36,3 @@ defmt = [
softdevice = [
"nrf-softdevice-mbr",
]
-nightly = [
- "dep:embedded-storage-async",
- "embassy-boot/nightly",
- "embassy-nrf/nightly"
-]
diff --git a/embassy-boot/nrf/src/lib.rs b/embassy-boot/nrf/src/lib.rs
index b9d86eb1..5b20a93c 100644
--- a/embassy-boot/nrf/src/lib.rs
+++ b/embassy-boot/nrf/src/lib.rs
@@ -4,10 +4,9 @@
mod fmt;
pub use embassy_boot::{
- AlignedBuffer, BlockingFirmwareState, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareUpdaterConfig,
+ AlignedBuffer, BlockingFirmwareState, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareState, FirmwareUpdater,
+ FirmwareUpdaterConfig,
};
-#[cfg(feature = "nightly")]
-pub use embassy_boot::{FirmwareState, FirmwareUpdater};
use embassy_nrf::nvmc::PAGE_SIZE;
use embassy_nrf::peripherals::WDT;
use embassy_nrf::wdt;
diff --git a/embassy-boot/rp/Cargo.toml b/embassy-boot/rp/Cargo.toml
index efa0ef8a..0f2dc462 100644
--- a/embassy-boot/rp/Cargo.toml
+++ b/embassy-boot/rp/Cargo.toml
@@ -17,15 +17,15 @@ defmt = { version = "0.3", optional = true }
defmt-rtt = { version = "0.4", optional = true }
log = { version = "0.4", optional = true }
-embassy-sync = { version = "0.4.0", path = "../../embassy-sync" }
+embassy-sync = { version = "0.5.0", path = "../../embassy-sync" }
embassy-rp = { path = "../../embassy-rp", default-features = false }
embassy-boot = { path = "../boot", default-features = false }
embassy-time = { path = "../../embassy-time" }
cortex-m = { version = "0.7.6" }
cortex-m-rt = { version = "0.7" }
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-storage = "0.3.1"
+embedded-storage-async = { version = "0.4.1" }
cfg-if = "1.0.0"
[features]
@@ -40,12 +40,6 @@ log = [
"embassy-rp/log",
]
debug = ["defmt-rtt"]
-nightly = [
- "dep:embedded-storage-async",
- "embassy-boot/nightly",
- "embassy-rp/nightly",
- "embassy-time/nightly"
-]
[profile.dev]
debug = 2
diff --git a/embassy-boot/rp/src/lib.rs b/embassy-boot/rp/src/lib.rs
index 989e7521..07a5b3f4 100644
--- a/embassy-boot/rp/src/lib.rs
+++ b/embassy-boot/rp/src/lib.rs
@@ -4,10 +4,9 @@
mod fmt;
pub use embassy_boot::{
- AlignedBuffer, BlockingFirmwareState, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareUpdaterConfig, State,
+ AlignedBuffer, BlockingFirmwareState, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareState, FirmwareUpdater,
+ FirmwareUpdaterConfig, State,
};
-#[cfg(feature = "nightly")]
-pub use embassy_boot::{FirmwareState, FirmwareUpdater};
use embassy_rp::flash::{Blocking, Flash, ERASE_SIZE};
use embassy_rp::peripherals::{FLASH, WATCHDOG};
use embassy_rp::watchdog::Watchdog;
diff --git a/embassy-boot/stm32/Cargo.toml b/embassy-boot/stm32/Cargo.toml
index da310277..bc8da673 100644
--- a/embassy-boot/stm32/Cargo.toml
+++ b/embassy-boot/stm32/Cargo.toml
@@ -18,32 +18,19 @@ defmt = { version = "0.3", optional = true }
defmt-rtt = { version = "0.4", optional = true }
log = { version = "0.4", optional = true }
-embassy-sync = { version = "0.4.0", path = "../../embassy-sync" }
+embassy-sync = { version = "0.5.0", path = "../../embassy-sync" }
embassy-stm32 = { path = "../../embassy-stm32", default-features = false }
embassy-boot = { path = "../boot", default-features = false }
cortex-m = { version = "0.7.6" }
cortex-m-rt = { version = "0.7" }
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-storage = "0.3.1"
+embedded-storage-async = { version = "0.4.1" }
cfg-if = "1.0.0"
[features]
-defmt = [
- "dep:defmt",
- "embassy-boot/defmt",
- "embassy-stm32/defmt",
-]
-log = [
- "dep:log",
- "embassy-boot/log",
- "embassy-stm32/log",
-]
+defmt = ["dep:defmt", "embassy-boot/defmt", "embassy-stm32/defmt"]
+log = ["dep:log", "embassy-boot/log", "embassy-stm32/log"]
debug = ["defmt-rtt"]
-nightly = [
- "dep:embedded-storage-async",
- "embassy-boot/nightly",
- "embassy-stm32/nightly"
-]
[profile.dev]
debug = 2
diff --git a/embassy-boot/stm32/src/lib.rs b/embassy-boot/stm32/src/lib.rs
index c6350c49..c418cb26 100644
--- a/embassy-boot/stm32/src/lib.rs
+++ b/embassy-boot/stm32/src/lib.rs
@@ -4,10 +4,9 @@
mod fmt;
pub use embassy_boot::{
- AlignedBuffer, BlockingFirmwareState, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareUpdaterConfig, State,
+ AlignedBuffer, BlockingFirmwareState, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareState, FirmwareUpdater,
+ FirmwareUpdaterConfig, State,
};
-#[cfg(feature = "nightly")]
-pub use embassy_boot::{FirmwareState, FirmwareUpdater};
use embedded_storage::nor_flash::NorFlash;
/// A bootloader for STM32 devices.
diff --git a/embassy-embedded-hal/Cargo.toml b/embassy-embedded-hal/Cargo.toml
index 11e47acb..2a0b2547 100644
--- a/embassy-embedded-hal/Cargo.toml
+++ b/embassy-embedded-hal/Cargo.toml
@@ -8,27 +8,25 @@ license = "MIT OR Apache-2.0"
[package.metadata.embassy_docs]
src_base = "https://github.com/embassy-rs/embassy/blob/embassy-embedded-hal-v$VERSION/embassy-embedded-hal/src/"
src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-embedded-hal/src/"
-features = ["nightly", "std"]
+features = ["std"]
target = "x86_64-unknown-linux-gnu"
[features]
std = []
-# Enable nightly-only features
-nightly = ["embassy-futures", "embedded-hal-async", "embedded-storage-async"]
time = ["dep:embassy-time"]
default = ["time"]
[dependencies]
-embassy-futures = { version = "0.1.0", path = "../embassy-futures", optional = true }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
-embassy-time = { version = "0.1.5", path = "../embassy-time", optional = true }
+embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
+embassy-time = { version = "0.2", path = "../embassy-time", optional = true }
embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = [
"unproven",
] }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.1" }
-embedded-hal-async = { version = "=1.0.0-rc.1", optional = true }
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
+embedded-storage = "0.3.1"
+embedded-storage-async = { version = "0.4.1" }
nb = "1.0.0"
defmt = { version = "0.3", optional = true }
diff --git a/embassy-embedded-hal/build.rs b/embassy-embedded-hal/build.rs
new file mode 100644
index 00000000..78bd27ec
--- /dev/null
+++ b/embassy-embedded-hal/build.rs
@@ -0,0 +1,18 @@
+use std::env;
+use std::ffi::OsString;
+use std::process::Command;
+
+fn main() {
+ println!("cargo:rerun-if-changed=build.rs");
+
+ let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
+
+ let output = Command::new(rustc)
+ .arg("--version")
+ .output()
+ .expect("failed to run `rustc --version`");
+
+ if String::from_utf8_lossy(&output.stdout).contains("nightly") {
+ println!("cargo:rustc-cfg=nightly");
+ }
+}
diff --git a/embassy-embedded-hal/src/flash/concat_flash.rs b/embassy-embedded-hal/src/flash/concat_flash.rs
index 1ea84269..499941d1 100644
--- a/embassy-embedded-hal/src/flash/concat_flash.rs
+++ b/embassy-embedded-hal/src/flash/concat_flash.rs
@@ -1,5 +1,4 @@
use embedded_storage::nor_flash::{ErrorType, NorFlash, NorFlashError, ReadNorFlash};
-#[cfg(feature = "nightly")]
use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
/// Convenience helper for concatenating two consecutive flashes into one.
@@ -117,7 +116,6 @@ where
}
}
-#[cfg(feature = "nightly")]
impl AsyncReadNorFlash for ConcatFlash
where
First: AsyncReadNorFlash,
@@ -146,7 +144,6 @@ where
}
}
-#[cfg(feature = "nightly")]
impl AsyncNorFlash for ConcatFlash
where
First: AsyncNorFlash,
diff --git a/embassy-embedded-hal/src/flash/mem_flash.rs b/embassy-embedded-hal/src/flash/mem_flash.rs
index afb0d1a1..d24c6182 100644
--- a/embassy-embedded-hal/src/flash/mem_flash.rs
+++ b/embassy-embedded-hal/src/flash/mem_flash.rs
@@ -1,7 +1,6 @@
use alloc::vec::Vec;
use embedded_storage::nor_flash::{ErrorType, NorFlash, ReadNorFlash};
-#[cfg(feature = "nightly")]
use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
extern crate alloc;
@@ -93,7 +92,6 @@ impl NorFla
}
}
-#[cfg(feature = "nightly")]
impl AsyncReadNorFlash
for MemFlash
{
@@ -109,7 +107,6 @@ impl AsyncR
}
}
-#[cfg(feature = "nightly")]
impl AsyncNorFlash
for MemFlash
{
diff --git a/embassy-embedded-hal/src/flash/partition/mod.rs b/embassy-embedded-hal/src/flash/partition/mod.rs
index 42c8a308..6177ed9a 100644
--- a/embassy-embedded-hal/src/flash/partition/mod.rs
+++ b/embassy-embedded-hal/src/flash/partition/mod.rs
@@ -2,11 +2,9 @@
use embedded_storage::nor_flash::{NorFlashError, NorFlashErrorKind};
-#[cfg(feature = "nightly")]
mod asynch;
mod blocking;
-#[cfg(feature = "nightly")]
pub use asynch::Partition;
pub use blocking::BlockingPartition;
diff --git a/embassy-embedded-hal/src/lib.rs b/embassy-embedded-hal/src/lib.rs
index ce5fac3f..b40f892f 100644
--- a/embassy-embedded-hal/src/lib.rs
+++ b/embassy-embedded-hal/src/lib.rs
@@ -1,15 +1,13 @@
#![cfg_attr(not(feature = "std"), no_std)]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![cfg_attr(nightly, feature(async_fn_in_trait, impl_trait_projections))]
+#![cfg_attr(nightly, allow(stable_features, unknown_lints))]
+#![allow(async_fn_in_trait)]
#![warn(missing_docs)]
//! Utilities to use `embedded-hal` traits with Embassy.
-#[cfg(feature = "nightly")]
pub mod adapter;
-
pub mod flash;
-
pub mod shared_bus;
/// Set the configuration of a peripheral driver.
diff --git a/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs b/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
index 1053d384..779c0426 100644
--- a/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
+++ b/embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
@@ -2,16 +2,15 @@
//!
//! # Example (nrf52)
//!
-//! ```rust
-//! use embassy_embedded_hal::shared_bus::i2c::I2cDevice;
+//! ```rust,ignore
+//! use embassy_embedded_hal::shared_bus::asynch::i2c::I2cDevice;
//! use embassy_sync::mutex::Mutex;
-//! use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+//! use embassy_sync::blocking_mutex::raw::NoopRawMutex;
//!
-//! static I2C_BUS: StaticCell>> = StaticCell::new();
+//! static I2C_BUS: StaticCell>> = StaticCell::new();
//! let config = twim::Config::default();
-//! let irq = interrupt::take!(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0);
-//! let i2c = Twim::new(p.TWISPI0, irq, p.P0_03, p.P0_04, config);
-//! let i2c_bus = Mutex::::new(i2c);
+//! let i2c = Twim::new(p.TWISPI0, Irqs, p.P0_03, p.P0_04, config);
+//! let i2c_bus = Mutex::new(i2c);
//! let i2c_bus = I2C_BUS.init(i2c_bus);
//!
//! // Device 1, using embedded-hal-async compatible driver for QMC5883L compass
diff --git a/embassy-embedded-hal/src/shared_bus/asynch/spi.rs b/embassy-embedded-hal/src/shared_bus/asynch/spi.rs
index 17d5f367..62b2c92a 100644
--- a/embassy-embedded-hal/src/shared_bus/asynch/spi.rs
+++ b/embassy-embedded-hal/src/shared_bus/asynch/spi.rs
@@ -2,17 +2,16 @@
//!
//! # Example (nrf52)
//!
-//! ```rust
+//! ```rust,ignore
//! use embassy_embedded_hal::shared_bus::spi::SpiDevice;
//! use embassy_sync::mutex::Mutex;
-//! use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+//! use embassy_sync::blocking_mutex::raw::NoopRawMutex;
//!
-//! static SPI_BUS: StaticCell>> = StaticCell::new();
+//! static SPI_BUS: StaticCell>> = StaticCell::new();
//! let mut config = spim::Config::default();
//! config.frequency = spim::Frequency::M32;
-//! let irq = interrupt::take!(SPIM3);
-//! let spi = spim::Spim::new_txonly(p.SPI3, irq, p.P0_15, p.P0_18, config);
-//! let spi_bus = Mutex::::new(spi);
+//! let spi = spim::Spim::new_txonly(p.SPI3, Irqs, p.P0_15, p.P0_18, config);
+//! let spi_bus = Mutex::new(spi);
//! let spi_bus = SPI_BUS.init(spi_bus);
//!
//! // Device 1, using embedded-hal-async compatible driver for ST7735 LCD display
@@ -63,6 +62,10 @@ where
CS: OutputPin,
{
async fn transaction(&mut self, operations: &mut [spi::Operation<'_, u8>]) -> Result<(), Self::Error> {
+ if cfg!(not(feature = "time")) && operations.iter().any(|op| matches!(op, Operation::DelayNs(_))) {
+ return Err(SpiDeviceError::DelayNotSupported);
+ }
+
let mut bus = self.bus.lock().await;
self.cs.set_low().map_err(SpiDeviceError::Cs)?;
@@ -74,12 +77,12 @@ where
Operation::Transfer(read, write) => bus.transfer(read, write).await,
Operation::TransferInPlace(buf) => bus.transfer_in_place(buf).await,
#[cfg(not(feature = "time"))]
- Operation::DelayUs(us) => return Err(SpiDeviceError::DelayUsNotSupported),
+ Operation::DelayNs(_) => unreachable!(),
#[cfg(feature = "time")]
- Operation::DelayUs(us) => match bus.flush().await {
+ Operation::DelayNs(ns) => match bus.flush().await {
Err(e) => Err(e),
Ok(()) => {
- embassy_time::Timer::after_micros(*us as _).await;
+ embassy_time::Timer::after_nanos(*ns as _).await;
Ok(())
}
},
@@ -137,6 +140,10 @@ where
CS: OutputPin,
{
async fn transaction(&mut self, operations: &mut [spi::Operation<'_, u8>]) -> Result<(), Self::Error> {
+ if cfg!(not(feature = "time")) && operations.iter().any(|op| matches!(op, Operation::DelayNs(_))) {
+ return Err(SpiDeviceError::DelayNotSupported);
+ }
+
let mut bus = self.bus.lock().await;
bus.set_config(&self.config).map_err(|_| SpiDeviceError::Config)?;
self.cs.set_low().map_err(SpiDeviceError::Cs)?;
@@ -149,12 +156,12 @@ where
Operation::Transfer(read, write) => bus.transfer(read, write).await,
Operation::TransferInPlace(buf) => bus.transfer_in_place(buf).await,
#[cfg(not(feature = "time"))]
- Operation::DelayUs(us) => return Err(SpiDeviceError::DelayUsNotSupported),
+ Operation::DelayNs(_) => unreachable!(),
#[cfg(feature = "time")]
- Operation::DelayUs(us) => match bus.flush().await {
+ Operation::DelayNs(ns) => match bus.flush().await {
Err(e) => Err(e),
Ok(()) => {
- embassy_time::Timer::after_micros(*us as _).await;
+ embassy_time::Timer::after_nanos(*ns as _).await;
Ok(())
}
},
diff --git a/embassy-embedded-hal/src/shared_bus/blocking/spi.rs b/embassy-embedded-hal/src/shared_bus/blocking/spi.rs
index 2b67862e..59b65bfb 100644
--- a/embassy-embedded-hal/src/shared_bus/blocking/spi.rs
+++ b/embassy-embedded-hal/src/shared_bus/blocking/spi.rs
@@ -55,8 +55,8 @@ where
CS: OutputPin,
{
fn transaction(&mut self, operations: &mut [Operation<'_, u8>]) -> Result<(), Self::Error> {
- if cfg!(not(feature = "time")) && operations.iter().any(|op| matches!(op, Operation::DelayUs(_))) {
- return Err(SpiDeviceError::DelayUsNotSupported);
+ if cfg!(not(feature = "time")) && operations.iter().any(|op| matches!(op, Operation::DelayNs(_))) {
+ return Err(SpiDeviceError::DelayNotSupported);
}
self.bus.lock(|bus| {
@@ -69,10 +69,10 @@ where
Operation::Transfer(read, write) => bus.transfer(read, write),
Operation::TransferInPlace(buf) => bus.transfer_in_place(buf),
#[cfg(not(feature = "time"))]
- Operation::DelayUs(_) => unreachable!(),
+ Operation::DelayNs(_) => unreachable!(),
#[cfg(feature = "time")]
- Operation::DelayUs(us) => {
- embassy_time::block_for(embassy_time::Duration::from_micros(*us as _));
+ Operation::DelayNs(ns) => {
+ embassy_time::block_for(embassy_time::Duration::from_nanos(*ns as _));
Ok(())
}
});
@@ -165,8 +165,8 @@ where
CS: OutputPin,
{
fn transaction(&mut self, operations: &mut [Operation<'_, u8>]) -> Result<(), Self::Error> {
- if cfg!(not(feature = "time")) && operations.iter().any(|op| matches!(op, Operation::DelayUs(_))) {
- return Err(SpiDeviceError::DelayUsNotSupported);
+ if cfg!(not(feature = "time")) && operations.iter().any(|op| matches!(op, Operation::DelayNs(_))) {
+ return Err(SpiDeviceError::DelayNotSupported);
}
self.bus.lock(|bus| {
@@ -180,10 +180,10 @@ where
Operation::Transfer(read, write) => bus.transfer(read, write),
Operation::TransferInPlace(buf) => bus.transfer_in_place(buf),
#[cfg(not(feature = "time"))]
- Operation::DelayUs(_) => unreachable!(),
+ Operation::DelayNs(_) => unreachable!(),
#[cfg(feature = "time")]
- Operation::DelayUs(us) => {
- embassy_time::block_for(embassy_time::Duration::from_micros(*us as _));
+ Operation::DelayNs(ns) => {
+ embassy_time::block_for(embassy_time::Duration::from_nanos(*ns as _));
Ok(())
}
});
diff --git a/embassy-embedded-hal/src/shared_bus/mod.rs b/embassy-embedded-hal/src/shared_bus/mod.rs
index b0159ac0..d835306b 100644
--- a/embassy-embedded-hal/src/shared_bus/mod.rs
+++ b/embassy-embedded-hal/src/shared_bus/mod.rs
@@ -3,9 +3,7 @@ use core::fmt::Debug;
use embedded_hal_1::{i2c, spi};
-#[cfg(feature = "nightly")]
pub mod asynch;
-
pub mod blocking;
/// Error returned by I2C device implementations in this crate.
@@ -39,8 +37,8 @@ pub enum SpiDeviceError {
Spi(BUS),
/// Setting the value of the Chip Select (CS) pin failed.
Cs(CS),
- /// DelayUs operations are not supported when the `time` Cargo feature is not enabled.
- DelayUsNotSupported,
+ /// Delay operations are not supported when the `time` Cargo feature is not enabled.
+ DelayNotSupported,
/// The SPI bus could not be configured.
Config,
}
@@ -54,7 +52,7 @@ where
match self {
Self::Spi(e) => e.kind(),
Self::Cs(_) => spi::ErrorKind::Other,
- Self::DelayUsNotSupported => spi::ErrorKind::Other,
+ Self::DelayNotSupported => spi::ErrorKind::Other,
Self::Config => spi::ErrorKind::Other,
}
}
diff --git a/embassy-executor/CHANGELOG.md b/embassy-executor/CHANGELOG.md
index 559717da..c839981d 100644
--- a/embassy-executor/CHANGELOG.md
+++ b/embassy-executor/CHANGELOG.md
@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## Unreleased
+
+- Removed `arch-xtensa`. Use the executor provided by the HAL crate (`esp-hal`, `esp32s3-hal`, etc...) instead.
+
## 0.3.3 - 2023-11-15
- Add `main` macro reexport for Xtensa arch.
diff --git a/embassy-executor/Cargo.toml b/embassy-executor/Cargo.toml
index ae46b17c..74efe452 100644
--- a/embassy-executor/Cargo.toml
+++ b/embassy-executor/Cargo.toml
@@ -33,7 +33,7 @@ log = { version = "0.4.14", optional = true }
rtos-trace = { version = "0.1.2", optional = true }
embassy-macros = { version = "0.2.1", path = "../embassy-macros" }
-embassy-time = { version = "0.1.5", path = "../embassy-time", optional = true}
+embassy-time = { version = "0.2", path = "../embassy-time", optional = true}
critical-section = "1.1"
# needed for riscv
@@ -57,7 +57,6 @@ critical-section = { version = "1.1", features = ["std"] }
_arch = [] # some arch was picked
arch-std = ["_arch", "critical-section/std"]
arch-cortex-m = ["_arch", "dep:cortex-m"]
-arch-xtensa = ["_arch"]
arch-riscv32 = ["_arch", "dep:portable-atomic"]
arch-wasm = ["_arch", "dep:wasm-bindgen", "dep:js-sys"]
diff --git a/embassy-executor/src/arch/xtensa.rs b/embassy-executor/src/arch/xtensa.rs
deleted file mode 100644
index 6ed9f9e7..00000000
--- a/embassy-executor/src/arch/xtensa.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-#[cfg(feature = "executor-interrupt")]
-compile_error!("`executor-interrupt` is not supported with `arch-xtensa`.");
-
-#[cfg(feature = "executor-thread")]
-pub use thread::*;
-#[cfg(feature = "executor-thread")]
-mod thread {
- use core::marker::PhantomData;
- use core::sync::atomic::{AtomicBool, Ordering};
-
- pub use embassy_macros::main_riscv as main;
-
- use crate::{raw, Spawner};
-
- /// global atomic used to keep track of whether there is work to do since sev() is not available on Xtensa
- static SIGNAL_WORK_THREAD_MODE: AtomicBool = AtomicBool::new(false);
-
- #[export_name = "__pender"]
- fn __pender(_context: *mut ()) {
- SIGNAL_WORK_THREAD_MODE.store(true, Ordering::SeqCst);
- }
-
- /// Xtensa Executor
- pub struct Executor {
- inner: raw::Executor,
- not_send: PhantomData<*mut ()>,
- }
-
- impl Executor {
- /// Create a new Executor.
- pub fn new() -> Self {
- Self {
- inner: raw::Executor::new(core::ptr::null_mut()),
- not_send: PhantomData,
- }
- }
-
- /// Run the executor.
- ///
- /// The `init` closure is called with a [`Spawner`] that spawns tasks on
- /// this executor. Use it to spawn the initial task(s). After `init` returns,
- /// the executor starts running the tasks.
- ///
- /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
- /// for example by passing it as an argument to the initial tasks.
- ///
- /// This function requires `&'static mut self`. This means you have to store the
- /// Executor instance in a place where it'll live forever and grants you mutable
- /// access. There's a few ways to do this:
- ///
- /// - a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
- /// - a `static mut` (unsafe)
- /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
- ///
- /// This function never returns.
- pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
- init(self.inner.spawner());
-
- loop {
- unsafe {
- self.inner.poll();
-
- // Manual critical section implementation that only masks interrupts handlers.
- // We must not acquire the cross-core on dual-core systems because that would
- // prevent the other core from doing useful work while this core is sleeping.
- let token: critical_section::RawRestoreState;
- core::arch::asm!("rsil {0}, 5", out(reg) token);
-
- // we do not care about race conditions between the load and store operations, interrupts
- // will only set this value to true.
- // if there is work to do, loop back to polling
- if SIGNAL_WORK_THREAD_MODE.load(Ordering::SeqCst) {
- SIGNAL_WORK_THREAD_MODE.store(false, Ordering::SeqCst);
-
- core::arch::asm!(
- "wsr.ps {0}",
- "rsync", in(reg) token)
- } else {
- // waiti sets the PS.INTLEVEL when slipping into sleep
- // because critical sections in Xtensa are implemented via increasing
- // PS.INTLEVEL the critical section ends here
- // take care not add code after `waiti` if it needs to be inside the CS
- core::arch::asm!("waiti 0"); // critical section ends here
- }
- }
- }
- }
- }
-}
diff --git a/embassy-executor/src/lib.rs b/embassy-executor/src/lib.rs
index d8ac4893..89769615 100644
--- a/embassy-executor/src/lib.rs
+++ b/embassy-executor/src/lib.rs
@@ -1,5 +1,4 @@
#![cfg_attr(not(any(feature = "arch-std", feature = "arch-wasm")), no_std)]
-#![cfg_attr(feature = "arch-xtensa", feature(asm_experimental_arch))]
#![allow(clippy::new_without_default)]
#![doc = include_str!("../README.md")]
#![warn(missing_docs)]
@@ -21,12 +20,11 @@ macro_rules! check_at_most_one {
check_at_most_one!(@amo [$($f)*] [$($f)*] []);
};
}
-check_at_most_one!("arch-cortex-m", "arch-riscv32", "arch-xtensa", "arch-std", "arch-wasm",);
+check_at_most_one!("arch-cortex-m", "arch-riscv32", "arch-std", "arch-wasm",);
#[cfg(feature = "_arch")]
#[cfg_attr(feature = "arch-cortex-m", path = "arch/cortex_m.rs")]
#[cfg_attr(feature = "arch-riscv32", path = "arch/riscv32.rs")]
-#[cfg_attr(feature = "arch-xtensa", path = "arch/xtensa.rs")]
#[cfg_attr(feature = "arch-std", path = "arch/std.rs")]
#[cfg_attr(feature = "arch-wasm", path = "arch/wasm.rs")]
mod arch;
diff --git a/embassy-lora/Cargo.toml b/embassy-lora/Cargo.toml
deleted file mode 100644
index f2ba379b..00000000
--- a/embassy-lora/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "embassy-lora"
-version = "0.1.0"
-edition = "2021"
-license = "MIT OR Apache-2.0"
-
-[package.metadata.embassy_docs]
-src_base = "https://github.com/embassy-rs/embassy/blob/embassy-lora-v$VERSION/embassy-lora/src/"
-src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-lora/src/"
-features = ["stm32wl", "embassy-stm32?/stm32wl55jc-cm4", "embassy-stm32?/unstable-pac", "time", "defmt"]
-target = "thumbv7em-none-eabi"
-
-[features]
-stm32wl = ["dep:embassy-stm32"]
-time = ["embassy-time", "lorawan-device"]
-defmt = ["dep:defmt", "lorawan-device/defmt"]
-
-[dependencies]
-
-defmt = { version = "0.3", optional = true }
-log = { version = "0.4.14", optional = true }
-
-embassy-time = { version = "0.1.5", path = "../embassy-time", optional = true }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
-embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32", default-features = false, optional = true }
-embedded-hal-async = { version = "=1.0.0-rc.1" }
-embedded-hal = { version = "0.2", features = ["unproven"] }
-
-futures = { version = "0.3.17", default-features = false, features = [ "async-await" ] }
-lora-phy = { version = "2" }
-lorawan-device = { version = "0.11.0", default-features = false, features = ["async"], optional = true }
diff --git a/embassy-lora/src/fmt.rs b/embassy-lora/src/fmt.rs
deleted file mode 100644
index 78e583c1..00000000
--- a/embassy-lora/src/fmt.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-#![macro_use]
-#![allow(unused_macros)]
-
-use core::fmt::{Debug, Display, LowerHex};
-
-#[cfg(all(feature = "defmt", feature = "log"))]
-compile_error!("You may not enable both `defmt` and `log` features.");
-
-macro_rules! assert {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::assert!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::assert!($($x)*);
- }
- };
-}
-
-macro_rules! assert_eq {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::assert_eq!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::assert_eq!($($x)*);
- }
- };
-}
-
-macro_rules! assert_ne {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::assert_ne!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::assert_ne!($($x)*);
- }
- };
-}
-
-macro_rules! debug_assert {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::debug_assert!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::debug_assert!($($x)*);
- }
- };
-}
-
-macro_rules! debug_assert_eq {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::debug_assert_eq!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::debug_assert_eq!($($x)*);
- }
- };
-}
-
-macro_rules! debug_assert_ne {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::debug_assert_ne!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::debug_assert_ne!($($x)*);
- }
- };
-}
-
-macro_rules! todo {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::todo!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::todo!($($x)*);
- }
- };
-}
-
-#[cfg(not(feature = "defmt"))]
-macro_rules! unreachable {
- ($($x:tt)*) => {
- ::core::unreachable!($($x)*)
- };
-}
-
-#[cfg(feature = "defmt")]
-macro_rules! unreachable {
- ($($x:tt)*) => {
- ::defmt::unreachable!($($x)*)
- };
-}
-
-macro_rules! panic {
- ($($x:tt)*) => {
- {
- #[cfg(not(feature = "defmt"))]
- ::core::panic!($($x)*);
- #[cfg(feature = "defmt")]
- ::defmt::panic!($($x)*);
- }
- };
-}
-
-macro_rules! trace {
- ($s:literal $(, $x:expr)* $(,)?) => {
- {
- #[cfg(feature = "log")]
- ::log::trace!($s $(, $x)*);
- #[cfg(feature = "defmt")]
- ::defmt::trace!($s $(, $x)*);
- #[cfg(not(any(feature = "log", feature="defmt")))]
- let _ = ($( & $x ),*);
- }
- };
-}
-
-macro_rules! debug {
- ($s:literal $(, $x:expr)* $(,)?) => {
- {
- #[cfg(feature = "log")]
- ::log::debug!($s $(, $x)*);
- #[cfg(feature = "defmt")]
- ::defmt::debug!($s $(, $x)*);
- #[cfg(not(any(feature = "log", feature="defmt")))]
- let _ = ($( & $x ),*);
- }
- };
-}
-
-macro_rules! info {
- ($s:literal $(, $x:expr)* $(,)?) => {
- {
- #[cfg(feature = "log")]
- ::log::info!($s $(, $x)*);
- #[cfg(feature = "defmt")]
- ::defmt::info!($s $(, $x)*);
- #[cfg(not(any(feature = "log", feature="defmt")))]
- let _ = ($( & $x ),*);
- }
- };
-}
-
-macro_rules! warn {
- ($s:literal $(, $x:expr)* $(,)?) => {
- {
- #[cfg(feature = "log")]
- ::log::warn!($s $(, $x)*);
- #[cfg(feature = "defmt")]
- ::defmt::warn!($s $(, $x)*);
- #[cfg(not(any(feature = "log", feature="defmt")))]
- let _ = ($( & $x ),*);
- }
- };
-}
-
-macro_rules! error {
- ($s:literal $(, $x:expr)* $(,)?) => {
- {
- #[cfg(feature = "log")]
- ::log::error!($s $(, $x)*);
- #[cfg(feature = "defmt")]
- ::defmt::error!($s $(, $x)*);
- #[cfg(not(any(feature = "log", feature="defmt")))]
- let _ = ($( & $x ),*);
- }
- };
-}
-
-#[cfg(feature = "defmt")]
-macro_rules! unwrap {
- ($($x:tt)*) => {
- ::defmt::unwrap!($($x)*)
- };
-}
-
-#[cfg(not(feature = "defmt"))]
-macro_rules! unwrap {
- ($arg:expr) => {
- match $crate::fmt::Try::into_result($arg) {
- ::core::result::Result::Ok(t) => t,
- ::core::result::Result::Err(e) => {
- ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
- }
- }
- };
- ($arg:expr, $($msg:expr),+ $(,)? ) => {
- match $crate::fmt::Try::into_result($arg) {
- ::core::result::Result::Ok(t) => t,
- ::core::result::Result::Err(e) => {
- ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
- }
- }
- }
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct NoneError;
-
-pub trait Try {
- type Ok;
- type Error;
- fn into_result(self) -> Result;
-}
-
-impl Try for Option {
- type Ok = T;
- type Error = NoneError;
-
- #[inline]
- fn into_result(self) -> Result {
- self.ok_or(NoneError)
- }
-}
-
-impl Try for Result {
- type Ok = T;
- type Error = E;
-
- #[inline]
- fn into_result(self) -> Self {
- self
- }
-}
-
-#[allow(unused)]
-pub(crate) struct Bytes<'a>(pub &'a [u8]);
-
-impl<'a> Debug for Bytes<'a> {
- fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
- write!(f, "{:#02x?}", self.0)
- }
-}
-
-impl<'a> Display for Bytes<'a> {
- fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
- write!(f, "{:#02x?}", self.0)
- }
-}
-
-impl<'a> LowerHex for Bytes<'a> {
- fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
- write!(f, "{:#02x?}", self.0)
- }
-}
-
-#[cfg(feature = "defmt")]
-impl<'a> defmt::Format for Bytes<'a> {
- fn format(&self, fmt: defmt::Formatter) {
- defmt::write!(fmt, "{:02x}", self.0)
- }
-}
diff --git a/embassy-lora/src/iv.rs b/embassy-lora/src/iv.rs
deleted file mode 100644
index d22beb33..00000000
--- a/embassy-lora/src/iv.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-#[cfg(feature = "stm32wl")]
-use embassy_stm32::interrupt;
-#[cfg(feature = "stm32wl")]
-use embassy_stm32::interrupt::InterruptExt;
-#[cfg(feature = "stm32wl")]
-use embassy_stm32::pac;
-#[cfg(feature = "stm32wl")]
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-#[cfg(feature = "stm32wl")]
-use embassy_sync::signal::Signal;
-use embedded_hal::digital::v2::OutputPin;
-use embedded_hal_async::delay::DelayUs;
-use embedded_hal_async::digital::Wait;
-use lora_phy::mod_params::RadioError::*;
-use lora_phy::mod_params::{BoardType, RadioError};
-use lora_phy::mod_traits::InterfaceVariant;
-
-/// Interrupt handler.
-#[cfg(feature = "stm32wl")]
-pub struct InterruptHandler {}
-
-#[cfg(feature = "stm32wl")]
-impl interrupt::typelevel::Handler for InterruptHandler {
- unsafe fn on_interrupt() {
- interrupt::SUBGHZ_RADIO.disable();
- IRQ_SIGNAL.signal(());
- }
-}
-
-#[cfg(feature = "stm32wl")]
-static IRQ_SIGNAL: Signal = Signal::new();
-
-#[cfg(feature = "stm32wl")]
-/// Base for the InterfaceVariant implementation for an stm32wl/sx1262 combination
-pub struct Stm32wlInterfaceVariant {
- board_type: BoardType,
- rf_switch_rx: Option,
- rf_switch_tx: Option,
-}
-
-#[cfg(feature = "stm32wl")]
-impl<'a, CTRL> Stm32wlInterfaceVariant
-where
- CTRL: OutputPin,
-{
- /// Create an InterfaceVariant instance for an stm32wl/sx1262 combination
- pub fn new(
- _irq: impl interrupt::typelevel::Binding,
- rf_switch_rx: Option,
- rf_switch_tx: Option,
- ) -> Result {
- interrupt::SUBGHZ_RADIO.disable();
- Ok(Self {
- board_type: BoardType::Stm32wlSx1262, // updated when associated with a specific LoRa board
- rf_switch_rx,
- rf_switch_tx,
- })
- }
-}
-
-#[cfg(feature = "stm32wl")]
-impl InterfaceVariant for Stm32wlInterfaceVariant
-where
- CTRL: OutputPin,
-{
- fn set_board_type(&mut self, board_type: BoardType) {
- self.board_type = board_type;
- }
- async fn set_nss_low(&mut self) -> Result<(), RadioError> {
- pac::PWR.subghzspicr().modify(|w| w.set_nss(false));
- Ok(())
- }
- async fn set_nss_high(&mut self) -> Result<(), RadioError> {
- pac::PWR.subghzspicr().modify(|w| w.set_nss(true));
- Ok(())
- }
- async fn reset(&mut self, _delay: &mut impl DelayUs) -> Result<(), RadioError> {
- pac::RCC.csr().modify(|w| w.set_rfrst(true));
- pac::RCC.csr().modify(|w| w.set_rfrst(false));
- Ok(())
- }
- async fn wait_on_busy(&mut self) -> Result<(), RadioError> {
- while pac::PWR.sr2().read().rfbusys() {}
- Ok(())
- }
-
- async fn await_irq(&mut self) -> Result<(), RadioError> {
- unsafe { interrupt::SUBGHZ_RADIO.enable() };
- IRQ_SIGNAL.wait().await;
- Ok(())
- }
-
- async fn enable_rf_switch_rx(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchTx)?,
- None => (),
- };
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_high().map_err(|_| RfSwitchRx),
- None => Ok(()),
- }
- }
- async fn enable_rf_switch_tx(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchRx)?,
- None => (),
- };
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_high().map_err(|_| RfSwitchTx),
- None => Ok(()),
- }
- }
- async fn disable_rf_switch(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchRx)?,
- None => (),
- };
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchTx),
- None => Ok(()),
- }
- }
-}
-
-/// Base for the InterfaceVariant implementation for an stm32l0/sx1276 combination
-pub struct Stm32l0InterfaceVariant {
- board_type: BoardType,
- nss: CTRL,
- reset: CTRL,
- irq: WAIT,
- rf_switch_rx: Option,
- rf_switch_tx: Option,
-}
-
-impl Stm32l0InterfaceVariant
-where
- CTRL: OutputPin,
- WAIT: Wait,
-{
- /// Create an InterfaceVariant instance for an stm32l0/sx1276 combination
- pub fn new(
- nss: CTRL,
- reset: CTRL,
- irq: WAIT,
- rf_switch_rx: Option,
- rf_switch_tx: Option,
- ) -> Result {
- Ok(Self {
- board_type: BoardType::Stm32l0Sx1276, // updated when associated with a specific LoRa board
- nss,
- reset,
- irq,
- rf_switch_rx,
- rf_switch_tx,
- })
- }
-}
-
-impl InterfaceVariant for Stm32l0InterfaceVariant
-where
- CTRL: OutputPin,
- WAIT: Wait,
-{
- fn set_board_type(&mut self, board_type: BoardType) {
- self.board_type = board_type;
- }
- async fn set_nss_low(&mut self) -> Result<(), RadioError> {
- self.nss.set_low().map_err(|_| NSS)
- }
- async fn set_nss_high(&mut self) -> Result<(), RadioError> {
- self.nss.set_high().map_err(|_| NSS)
- }
- async fn reset(&mut self, delay: &mut impl DelayUs) -> Result<(), RadioError> {
- delay.delay_ms(10).await;
- self.reset.set_low().map_err(|_| Reset)?;
- delay.delay_ms(10).await;
- self.reset.set_high().map_err(|_| Reset)?;
- delay.delay_ms(10).await;
- Ok(())
- }
- async fn wait_on_busy(&mut self) -> Result<(), RadioError> {
- Ok(())
- }
- async fn await_irq(&mut self) -> Result<(), RadioError> {
- self.irq.wait_for_high().await.map_err(|_| Irq)
- }
-
- async fn enable_rf_switch_rx(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchTx)?,
- None => (),
- };
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_high().map_err(|_| RfSwitchRx),
- None => Ok(()),
- }
- }
- async fn enable_rf_switch_tx(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchRx)?,
- None => (),
- };
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_high().map_err(|_| RfSwitchTx),
- None => Ok(()),
- }
- }
- async fn disable_rf_switch(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchRx)?,
- None => (),
- };
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchTx),
- None => Ok(()),
- }
- }
-}
-
-/// Base for the InterfaceVariant implementation for a generic Sx126x LoRa board
-pub struct GenericSx126xInterfaceVariant {
- board_type: BoardType,
- nss: CTRL,
- reset: CTRL,
- dio1: WAIT,
- busy: WAIT,
- rf_switch_rx: Option,
- rf_switch_tx: Option,
-}
-
-impl GenericSx126xInterfaceVariant
-where
- CTRL: OutputPin,
- WAIT: Wait,
-{
- /// Create an InterfaceVariant instance for an nrf52840/sx1262 combination
- pub fn new(
- nss: CTRL,
- reset: CTRL,
- dio1: WAIT,
- busy: WAIT,
- rf_switch_rx: Option,
- rf_switch_tx: Option,
- ) -> Result {
- Ok(Self {
- board_type: BoardType::Rak4631Sx1262, // updated when associated with a specific LoRa board
- nss,
- reset,
- dio1,
- busy,
- rf_switch_rx,
- rf_switch_tx,
- })
- }
-}
-
-impl InterfaceVariant for GenericSx126xInterfaceVariant
-where
- CTRL: OutputPin,
- WAIT: Wait,
-{
- fn set_board_type(&mut self, board_type: BoardType) {
- self.board_type = board_type;
- }
- async fn set_nss_low(&mut self) -> Result<(), RadioError> {
- self.nss.set_low().map_err(|_| NSS)
- }
- async fn set_nss_high(&mut self) -> Result<(), RadioError> {
- self.nss.set_high().map_err(|_| NSS)
- }
- async fn reset(&mut self, delay: &mut impl DelayUs) -> Result<(), RadioError> {
- delay.delay_ms(10).await;
- self.reset.set_low().map_err(|_| Reset)?;
- delay.delay_ms(20).await;
- self.reset.set_high().map_err(|_| Reset)?;
- delay.delay_ms(10).await;
- Ok(())
- }
- async fn wait_on_busy(&mut self) -> Result<(), RadioError> {
- self.busy.wait_for_low().await.map_err(|_| Busy)
- }
- async fn await_irq(&mut self) -> Result<(), RadioError> {
- self.dio1.wait_for_high().await.map_err(|_| DIO1)?;
- Ok(())
- }
-
- async fn enable_rf_switch_rx(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchTx)?,
- None => (),
- };
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_high().map_err(|_| RfSwitchRx),
- None => Ok(()),
- }
- }
- async fn enable_rf_switch_tx(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchRx)?,
- None => (),
- };
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_high().map_err(|_| RfSwitchTx),
- None => Ok(()),
- }
- }
- async fn disable_rf_switch(&mut self) -> Result<(), RadioError> {
- match &mut self.rf_switch_rx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchRx)?,
- None => (),
- };
- match &mut self.rf_switch_tx {
- Some(pin) => pin.set_low().map_err(|_| RfSwitchTx),
- None => Ok(()),
- }
- }
-}
diff --git a/embassy-lora/src/lib.rs b/embassy-lora/src/lib.rs
deleted file mode 100644
index 653c9825..00000000
--- a/embassy-lora/src/lib.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![no_std]
-#![feature(async_fn_in_trait, impl_trait_projections)]
-#![allow(stable_features, unknown_lints, async_fn_in_trait)]
-//! embassy-lora holds LoRa-specific functionality.
-
-pub(crate) mod fmt;
-
-/// interface variants required by the external lora physical layer crate (lora-phy)
-pub mod iv;
-
-#[cfg(feature = "time")]
-use embassy_time::{Duration, Instant, Timer};
-
-/// A convenience timer to use with the LoRaWAN crate
-#[cfg(feature = "time")]
-pub struct LoraTimer {
- start: Instant,
-}
-
-#[cfg(feature = "time")]
-impl LoraTimer {
- pub fn new() -> Self {
- Self { start: Instant::now() }
- }
-}
-
-#[cfg(feature = "time")]
-impl lorawan_device::async_device::radio::Timer for LoraTimer {
- fn reset(&mut self) {
- self.start = Instant::now();
- }
-
- async fn at(&mut self, millis: u64) {
- Timer::at(self.start + Duration::from_millis(millis)).await
- }
-
- async fn delay_ms(&mut self, millis: u64) {
- Timer::after_millis(millis).await
- }
-}
diff --git a/embassy-net-adin1110/Cargo.toml b/embassy-net-adin1110/Cargo.toml
index 3f016160..d95b2628 100644
--- a/embassy-net-adin1110/Cargo.toml
+++ b/embassy-net-adin1110/Cargo.toml
@@ -13,16 +13,16 @@ edition = "2021"
heapless = "0.8"
defmt = { version = "0.3", optional = true }
log = { version = "0.4", default-features = false, optional = true }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.1" }
-embedded-hal-async = { version = "=1.0.0-rc.1" }
-embedded-hal-bus = { version = "=0.1.0-rc.1", features = ["async"] }
+embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
+embedded-hal-bus = { version = "=0.1.0-rc.2", features = ["async"] }
embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel" }
-embassy-time = { version = "0.1.5", path = "../embassy-time" }
+embassy-time = { version = "0.2", path = "../embassy-time" }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
bitfield = "0.14.0"
[dev-dependencies]
-embedded-hal-mock = { version = "=0.10.0-rc.1", features = ["embedded-hal-async", "eh1"] }
+embedded-hal-mock = { git = "https://github.com/Dirbaio/embedded-hal-mock", rev = "c5c4dca18e043e6386aee02173f61a65fea3981e", features = ["embedded-hal-async", "eh1"] }
crc = "3.0.1"
env_logger = "0.10"
critical-section = { version = "1.1.2", features = ["std"] }
diff --git a/embassy-net-adin1110/src/lib.rs b/embassy-net-adin1110/src/lib.rs
index 331c596d..080b3f94 100644
--- a/embassy-net-adin1110/src/lib.rs
+++ b/embassy-net-adin1110/src/lib.rs
@@ -1,6 +1,5 @@
#![deny(clippy::pedantic)]
-#![feature(async_fn_in_trait)]
-#![allow(stable_features, unknown_lints, async_fn_in_trait)]
+#![allow(async_fn_in_trait)]
#![cfg_attr(not(any(test, feature = "std")), no_std)]
#![allow(clippy::module_name_repetitions)]
#![allow(clippy::missing_errors_doc)]
@@ -729,7 +728,7 @@ mod tests {
use core::convert::Infallible;
use embedded_hal_1::digital::{ErrorType, OutputPin};
- use embedded_hal_async::delay::DelayUs;
+ use embedded_hal_async::delay::DelayNs;
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_hal_mock::common::Generic;
use embedded_hal_mock::eh1::spi::{Mock as SpiMock, Transaction as SpiTransaction};
@@ -760,7 +759,11 @@ mod tests {
// see https://github.com/rust-embedded/embedded-hal/pull/462#issuecomment-1560014426
struct MockDelay {}
- impl DelayUs for MockDelay {
+ impl DelayNs for MockDelay {
+ async fn delay_ns(&mut self, _ns: u32) {
+ todo!()
+ }
+
async fn delay_us(&mut self, _us: u32) {
todo!()
}
diff --git a/embassy-net-driver-channel/Cargo.toml b/embassy-net-driver-channel/Cargo.toml
index 100c3ebc..58d3d231 100644
--- a/embassy-net-driver-channel/Cargo.toml
+++ b/embassy-net-driver-channel/Cargo.toml
@@ -24,6 +24,6 @@ features = ["defmt"]
defmt = { version = "0.3", optional = true }
log = { version = "0.4.14", optional = true }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
embassy-net-driver = { version = "0.2.0", path = "../embassy-net-driver" }
diff --git a/embassy-net-enc28j60/Cargo.toml b/embassy-net-enc28j60/Cargo.toml
index ea2ed1f7..72e1d4e5 100644
--- a/embassy-net-enc28j60/Cargo.toml
+++ b/embassy-net-enc28j60/Cargo.toml
@@ -8,10 +8,10 @@ license = "MIT OR Apache-2.0"
edition = "2021"
[dependencies]
-embedded-hal = { version = "1.0.0-rc.1" }
-embedded-hal-async = { version = "=1.0.0-rc.1" }
+embedded-hal = { version = "1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
embassy-net-driver = { version = "0.2.0", path = "../embassy-net-driver" }
-embassy-time = { version = "0.1.5", path = "../embassy-time" }
+embassy-time = { version = "0.2", path = "../embassy-time" }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
defmt = { version = "0.3", optional = true }
diff --git a/embassy-net-esp-hosted/Cargo.toml b/embassy-net-esp-hosted/Cargo.toml
index e86be445..eb44a654 100644
--- a/embassy-net-esp-hosted/Cargo.toml
+++ b/embassy-net-esp-hosted/Cargo.toml
@@ -7,13 +7,13 @@ edition = "2021"
defmt = { version = "0.3", optional = true }
log = { version = "0.4.14", optional = true }
-embassy-time = { version = "0.1.5", path = "../embassy-time" }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync"}
+embassy-time = { version = "0.2", path = "../embassy-time" }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync"}
embassy-futures = { version = "0.1.0", path = "../embassy-futures"}
embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel"}
-embedded-hal = { version = "1.0.0-rc.1" }
-embedded-hal-async = { version = "=1.0.0-rc.1" }
+embedded-hal = { version = "1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
noproto = { git="https://github.com/embassy-rs/noproto", rev = "f5e6d1f325b6ad4e344f60452b09576e24671f62", default-features = false, features = ["derive"] }
#noproto = { version = "0.1", path = "/home/dirbaio/noproto", default-features = false, features = ["derive"] }
diff --git a/embassy-net-ppp/Cargo.toml b/embassy-net-ppp/Cargo.toml
index 273dccbc..33e05227 100644
--- a/embassy-net-ppp/Cargo.toml
+++ b/embassy-net-ppp/Cargo.toml
@@ -15,11 +15,11 @@ log = ["dep:log", "ppproto/log"]
defmt = { version = "0.3", optional = true }
log = { version = "0.4.14", optional = true }
-embedded-io-async = { version = "0.6.0" }
+embedded-io-async = { version = "0.6.1" }
embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel" }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
ppproto = { version = "0.1.2"}
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
[package.metadata.embassy_docs]
src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-ppp-v$VERSION/embassy-net-ppp/src/"
diff --git a/embassy-net-wiznet/Cargo.toml b/embassy-net-wiznet/Cargo.toml
index 0cc086b7..9c103ebb 100644
--- a/embassy-net-wiznet/Cargo.toml
+++ b/embassy-net-wiznet/Cargo.toml
@@ -8,10 +8,10 @@ license = "MIT OR Apache-2.0"
edition = "2021"
[dependencies]
-embedded-hal = { version = "1.0.0-rc.1" }
-embedded-hal-async = { version = "=1.0.0-rc.1" }
+embedded-hal = { version = "1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
embassy-net-driver-channel = { version = "0.2.0", path = "../embassy-net-driver-channel" }
-embassy-time = { version = "0.1.5", path = "../embassy-time" }
+embassy-time = { version = "0.2", path = "../embassy-time" }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
defmt = { version = "0.3", optional = true }
diff --git a/embassy-net-wiznet/src/lib.rs b/embassy-net-wiznet/src/lib.rs
index 21d5f46d..f26f2bbb 100644
--- a/embassy-net-wiznet/src/lib.rs
+++ b/embassy-net-wiznet/src/lib.rs
@@ -1,6 +1,5 @@
#![no_std]
-#![feature(async_fn_in_trait)]
-#![allow(stable_features, unknown_lints, async_fn_in_trait)]
+#![allow(async_fn_in_trait)]
#![doc = include_str!("../README.md")]
pub mod chip;
diff --git a/embassy-net/Cargo.toml b/embassy-net/Cargo.toml
index ef66078c..0c07e365 100644
--- a/embassy-net/Cargo.toml
+++ b/embassy-net/Cargo.toml
@@ -15,11 +15,11 @@ categories = [
[package.metadata.embassy_docs]
src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-v$VERSION/embassy-net/src/"
src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-net/src/"
-features = ["nightly", "defmt", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6", "medium-ethernet", "medium-ip", "medium-ieee802154", "igmp"]
+features = ["defmt", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6", "medium-ethernet", "medium-ip", "medium-ieee802154", "igmp"]
target = "thumbv7em-none-eabi"
[package.metadata.docs.rs]
-features = ["nightly", "defmt", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6", "medium-ethernet", "medium-ip", "medium-ieee802154", "igmp"]
+features = ["defmt", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6", "medium-ethernet", "medium-ip", "medium-ieee802154", "igmp"]
[features]
default = []
@@ -27,8 +27,6 @@ std = []
defmt = ["dep:defmt", "smoltcp/defmt", "embassy-net-driver/defmt", "heapless/defmt-03"]
-nightly = ["dep:embedded-io-async", "dep:embedded-nal-async"]
-
udp = ["smoltcp/socket-udp"]
tcp = ["smoltcp/socket-tcp"]
dns = ["smoltcp/socket-dns", "smoltcp/proto-dns"]
@@ -52,9 +50,9 @@ smoltcp = { git = "https://github.com/smoltcp-rs/smoltcp.git", rev = "b57e2f9e70
] }
embassy-net-driver = { version = "0.2.0", path = "../embassy-net-driver" }
-embassy-time = { version = "0.1.5", path = "../embassy-time" }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
-embedded-io-async = { version = "0.6.0", optional = true }
+embassy-time = { version = "0.2", path = "../embassy-time" }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
+embedded-io-async = { version = "0.6.1" }
managed = { version = "0.8.0", default-features = false, features = [ "map" ] }
heapless = { version = "0.8", default-features = false }
@@ -63,4 +61,4 @@ generic-array = { version = "0.14.4", default-features = false }
stable_deref_trait = { version = "1.2.0", default-features = false }
futures = { version = "0.3.17", default-features = false, features = [ "async-await" ] }
atomic-pool = "1.0"
-embedded-nal-async = { version = "0.7", optional = true }
+embedded-nal-async = { version = "0.7.1" }
diff --git a/embassy-net/build.rs b/embassy-net/build.rs
new file mode 100644
index 00000000..78bd27ec
--- /dev/null
+++ b/embassy-net/build.rs
@@ -0,0 +1,18 @@
+use std::env;
+use std::ffi::OsString;
+use std::process::Command;
+
+fn main() {
+ println!("cargo:rerun-if-changed=build.rs");
+
+ let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
+
+ let output = Command::new(rustc)
+ .arg("--version")
+ .output()
+ .expect("failed to run `rustc --version`");
+
+ if String::from_utf8_lossy(&output.stdout).contains("nightly") {
+ println!("cargo:rustc-cfg=nightly");
+ }
+}
diff --git a/embassy-net/src/dns.rs b/embassy-net/src/dns.rs
index 69fc5cdf..a1151d5e 100644
--- a/embassy-net/src/dns.rs
+++ b/embassy-net/src/dns.rs
@@ -72,7 +72,6 @@ where
}
}
-#[cfg(feature = "nightly")]
impl<'a, D> embedded_nal_async::Dns for DnsSocket<'a, D>
where
D: Driver + 'static,
diff --git a/embassy-net/src/lib.rs b/embassy-net/src/lib.rs
index 58310b20..bf146864 100644
--- a/embassy-net/src/lib.rs
+++ b/embassy-net/src/lib.rs
@@ -1,6 +1,7 @@
#![cfg_attr(not(feature = "std"), no_std)]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![cfg_attr(nightly, feature(async_fn_in_trait, impl_trait_projections))]
+#![cfg_attr(nightly, allow(stable_features, unknown_lints))]
+#![allow(async_fn_in_trait)]
#![warn(missing_docs)]
#![doc = include_str!("../README.md")]
diff --git a/embassy-net/src/tcp.rs b/embassy-net/src/tcp.rs
index 90fd08e9..dcfb5c96 100644
--- a/embassy-net/src/tcp.rs
+++ b/embassy-net/src/tcp.rs
@@ -515,7 +515,6 @@ impl<'d> TcpIo<'d> {
}
}
-#[cfg(feature = "nightly")]
mod embedded_io_impls {
use super::*;
@@ -584,7 +583,6 @@ mod embedded_io_impls {
}
/// TCP client compatible with `embedded-nal-async` traits.
-#[cfg(feature = "nightly")]
pub mod client {
use core::cell::{Cell, UnsafeCell};
use core::mem::MaybeUninit;
diff --git a/embassy-nrf/Cargo.toml b/embassy-nrf/Cargo.toml
index 60e03d85..a7f3cb35 100644
--- a/embassy-nrf/Cargo.toml
+++ b/embassy-nrf/Cargo.toml
@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
src_base = "https://github.com/embassy-rs/embassy/blob/embassy-nrf-v$VERSION/embassy-nrf/src/"
src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-nrf/src/"
-features = ["nightly", "time", "defmt", "unstable-pac", "unstable-traits", "gpiote", "time-driver-rtc1"]
+features = ["time", "defmt", "unstable-pac", "gpiote", "time-driver-rtc1"]
flavors = [
{ regex_feature = "nrf52.*", target = "thumbv7em-none-eabihf" },
{ regex_feature = "nrf53.*", target = "thumbv8m.main-none-eabihf" },
@@ -32,10 +32,7 @@ rt = [
time = ["dep:embassy-time"]
-defmt = ["dep:defmt", "embassy-hal-internal/defmt", "embassy-sync/defmt", "embassy-usb-driver?/defmt", "embassy-embedded-hal/defmt"]
-
-# Enable nightly-only features
-nightly = ["embedded-hal-1", "embedded-hal-async", "dep:embassy-usb-driver", "embedded-storage-async", "dep:embedded-io-async", "embassy-embedded-hal/nightly"]
+defmt = ["dep:defmt", "embassy-hal-internal/defmt", "embassy-sync/defmt", "embassy-usb-driver/defmt", "embassy-embedded-hal/defmt"]
# Reexport the PAC for the currently enabled chip at `embassy_nrf::pac`.
# This is unstable because semver-minor (non-breaking) releases of embassy-nrf may major-bump (breaking) the PAC version.
@@ -43,10 +40,6 @@ nightly = ["embedded-hal-1", "embedded-hal-async", "dep:embassy-usb-driver", "em
# There are no plans to make this stable.
unstable-pac = []
-# Implement embedded-hal 1.0 alpha traits.
-# Implement embedded-hal-async traits if `nightly` is set as well.
-unstable-traits = ["embedded-hal-1"]
-
nrf52805 = ["nrf52805-pac", "_nrf52"]
nrf52810 = ["nrf52810-pac", "_nrf52"]
nrf52811 = ["nrf52811-pac", "_nrf52"]
@@ -94,17 +87,17 @@ _gpio-p1 = []
_nrf52832_anomaly_109 = []
[dependencies]
-embassy-time = { version = "0.1.5", path = "../embassy-time", optional = true }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
+embassy-time = { version = "0.2", path = "../embassy-time", optional = true }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
embassy-hal-internal = {version = "0.1.0", path = "../embassy-hal-internal", features = ["cortex-m", "prio-bits-3"] }
embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }
-embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver", optional=true }
+embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver" }
embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.1", optional = true}
-embedded-hal-async = { version = "=1.0.0-rc.1", optional = true}
+embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.0", optional = true }
+embedded-io-async = { version = "0.6.1" }
defmt = { version = "0.3", optional = true }
log = { version = "0.4.14", optional = true }
@@ -113,8 +106,8 @@ cortex-m = "0.7.6"
critical-section = "1.1"
rand_core = "0.6.3"
fixed = "1.10.0"
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-storage = "0.3.1"
+embedded-storage-async = "0.4.0"
cfg-if = "1.0.0"
nrf52805-pac = { version = "0.12.0", optional = true }
diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte.rs
index e4b556f0..4ac622d3 100644
--- a/embassy-nrf/src/buffered_uarte.rs
+++ b/embassy-nrf/src/buffered_uarte.rs
@@ -607,7 +607,6 @@ impl<'u, 'd, U: UarteInstance, T: TimerInstance> BufferedUarteRx<'u, 'd, U, T> {
}
}
-#[cfg(feature = "nightly")]
mod _embedded_io {
use super::*;
diff --git a/embassy-nrf/src/chips/nrf52805.rs b/embassy-nrf/src/chips/nrf52805.rs
index 70e4b486..624d6613 100644
--- a/embassy-nrf/src/chips/nrf52805.rs
+++ b/embassy-nrf/src/chips/nrf52805.rs
@@ -7,6 +7,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 256;
pub const FLASH_SIZE: usize = 192 * 1024;
pub const RESET_PIN: u32 = 21;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'B';
embassy_hal_internal::peripherals! {
// RTC
diff --git a/embassy-nrf/src/chips/nrf52810.rs b/embassy-nrf/src/chips/nrf52810.rs
index 7416d391..002feab3 100644
--- a/embassy-nrf/src/chips/nrf52810.rs
+++ b/embassy-nrf/src/chips/nrf52810.rs
@@ -7,6 +7,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 256;
pub const FLASH_SIZE: usize = 192 * 1024;
pub const RESET_PIN: u32 = 21;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'E';
embassy_hal_internal::peripherals! {
// RTC
diff --git a/embassy-nrf/src/chips/nrf52811.rs b/embassy-nrf/src/chips/nrf52811.rs
index 58801068..5952907f 100644
--- a/embassy-nrf/src/chips/nrf52811.rs
+++ b/embassy-nrf/src/chips/nrf52811.rs
@@ -7,6 +7,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 256;
pub const FLASH_SIZE: usize = 192 * 1024;
pub const RESET_PIN: u32 = 21;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'B';
embassy_hal_internal::peripherals! {
// RTC
diff --git a/embassy-nrf/src/chips/nrf52820.rs b/embassy-nrf/src/chips/nrf52820.rs
index 0ecddaf3..c2f792cb 100644
--- a/embassy-nrf/src/chips/nrf52820.rs
+++ b/embassy-nrf/src/chips/nrf52820.rs
@@ -7,6 +7,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 512;
pub const FLASH_SIZE: usize = 256 * 1024;
pub const RESET_PIN: u32 = 18;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'D';
embassy_hal_internal::peripherals! {
// USB
@@ -131,7 +132,6 @@ embassy_hal_internal::peripherals! {
QDEC,
}
-#[cfg(feature = "nightly")]
impl_usb!(USBD, USBD, USBD);
impl_uarte!(UARTE0, UARTE0, UARTE0_UART0);
diff --git a/embassy-nrf/src/chips/nrf52832.rs b/embassy-nrf/src/chips/nrf52832.rs
index ae39628d..65d52364 100644
--- a/embassy-nrf/src/chips/nrf52832.rs
+++ b/embassy-nrf/src/chips/nrf52832.rs
@@ -11,6 +11,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 255;
pub const FLASH_SIZE: usize = 512 * 1024;
pub const RESET_PIN: u32 = 21;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'G';
embassy_hal_internal::peripherals! {
// RTC
diff --git a/embassy-nrf/src/chips/nrf52833.rs b/embassy-nrf/src/chips/nrf52833.rs
index b8830b33..7c9b66d6 100644
--- a/embassy-nrf/src/chips/nrf52833.rs
+++ b/embassy-nrf/src/chips/nrf52833.rs
@@ -7,6 +7,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 512;
pub const FLASH_SIZE: usize = 512 * 1024;
pub const RESET_PIN: u32 = 18;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'B';
embassy_hal_internal::peripherals! {
// USB
@@ -171,7 +172,6 @@ embassy_hal_internal::peripherals! {
I2S,
}
-#[cfg(feature = "nightly")]
impl_usb!(USBD, USBD, USBD);
impl_uarte!(UARTE0, UARTE0, UARTE0_UART0);
diff --git a/embassy-nrf/src/chips/nrf52840.rs b/embassy-nrf/src/chips/nrf52840.rs
index a490cb07..51c55cd4 100644
--- a/embassy-nrf/src/chips/nrf52840.rs
+++ b/embassy-nrf/src/chips/nrf52840.rs
@@ -7,6 +7,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 512;
pub const FLASH_SIZE: usize = 1024 * 1024;
pub const RESET_PIN: u32 = 18;
+pub const APPROTECT_MIN_BUILD_CODE: u8 = b'F';
embassy_hal_internal::peripherals! {
// USB
@@ -174,7 +175,6 @@ embassy_hal_internal::peripherals! {
I2S,
}
-#[cfg(feature = "nightly")]
impl_usb!(USBD, USBD, USBD);
impl_uarte!(UARTE0, UARTE0, UARTE0_UART0);
diff --git a/embassy-nrf/src/chips/nrf5340_app.rs b/embassy-nrf/src/chips/nrf5340_app.rs
index 5e9a8ed0..62c74bb6 100644
--- a/embassy-nrf/src/chips/nrf5340_app.rs
+++ b/embassy-nrf/src/chips/nrf5340_app.rs
@@ -382,7 +382,6 @@ embassy_hal_internal::peripherals! {
P1_15,
}
-#[cfg(feature = "nightly")]
impl_usb!(USBD, USBD, USBD);
impl_uarte!(SERIAL0, UARTE0, SERIAL0);
diff --git a/embassy-nrf/src/gpio.rs b/embassy-nrf/src/gpio.rs
index ea2b7609..cf622528 100644
--- a/embassy-nrf/src/gpio.rs
+++ b/embassy-nrf/src/gpio.rs
@@ -566,82 +566,77 @@ mod eh02 {
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
+ type Error = Infallible;
+}
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
- type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
- type Error = Infallible;
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
-
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
- type Error = Infallible;
- }
-
- /// Implement [`InputPin`] for [`Flex`];
- ///
- /// If the pin is not in input mode the result is unspecified.
- impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
-
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
+ }
+
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
+ }
+
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
+ type Error = Infallible;
+}
+
+/// Implement [`InputPin`] for [`Flex`];
+///
+/// If the pin is not in input mode the result is unspecified.
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
+ }
+
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
+ }
+
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
+ }
+
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
}
}
diff --git a/embassy-nrf/src/gpiote.rs b/embassy-nrf/src/gpiote.rs
index d16b4a43..fd629ea7 100644
--- a/embassy-nrf/src/gpiote.rs
+++ b/embassy-nrf/src/gpiote.rs
@@ -490,70 +490,60 @@ mod eh02 {
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl<'d, C: Channel, T: GpioPin> embedded_hal_1::digital::ErrorType for InputChannel<'d, C, T> {
+ type Error = Infallible;
+}
- impl<'d, C: Channel, T: GpioPin> embedded_hal_1::digital::ErrorType for InputChannel<'d, C, T> {
- type Error = Infallible;
+impl<'d, C: Channel, T: GpioPin> embedded_hal_1::digital::InputPin for InputChannel<'d, C, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.pin.is_high())
}
- impl<'d, C: Channel, T: GpioPin> embedded_hal_1::digital::InputPin for InputChannel<'d, C, T> {
- fn is_high(&self) -> Result {
- Ok(self.pin.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.pin.is_low())
- }
+ fn is_low(&self) -> Result {
+ Ok(self.pin.is_low())
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
- use super::*;
-
- impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Input<'d, T> {
- async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_high().await)
- }
-
- async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_low().await)
- }
-
- async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_rising_edge().await)
- }
-
- async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_falling_edge().await)
- }
-
- async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_any_edge().await)
- }
+impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Input<'d, T> {
+ async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_high().await)
}
- impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Flex<'d, T> {
- async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_high().await)
- }
+ async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_low().await)
+ }
- async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_low().await)
- }
+ async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_rising_edge().await)
+ }
- async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_rising_edge().await)
- }
+ async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_falling_edge().await)
+ }
- async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_falling_edge().await)
- }
-
- async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
- Ok(self.wait_for_any_edge().await)
- }
+ async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_any_edge().await)
+ }
+}
+
+impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for Flex<'d, T> {
+ async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_high().await)
+ }
+
+ async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_low().await)
+ }
+
+ async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_rising_edge().await)
+ }
+
+ async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_falling_edge().await)
+ }
+
+ async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+ Ok(self.wait_for_any_edge().await)
}
}
diff --git a/embassy-nrf/src/lib.rs b/embassy-nrf/src/lib.rs
index 71528111..3274dafb 100644
--- a/embassy-nrf/src/lib.rs
+++ b/embassy-nrf/src/lib.rs
@@ -1,6 +1,5 @@
#![no_std]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![allow(async_fn_in_trait)]
#![doc = include_str!("../README.md")]
#![warn(missing_docs)]
@@ -76,7 +75,6 @@ pub mod uarte;
feature = "nrf52833",
feature = "nrf52840"
))]
-#[cfg(feature = "nightly")]
pub mod usb;
#[cfg(not(feature = "_nrf5340"))]
pub mod wdt;
@@ -351,10 +349,11 @@ pub fn init(config: config::Config) -> Peripherals {
// Get the letter for the build code (b'A' .. b'F')
let build_code = (variant >> 8) as u8;
- if build_code >= b'F' {
- // Chips with build code F and higher (revision 3 and higher) have an
+ if build_code >= chip::APPROTECT_MIN_BUILD_CODE {
+ // Chips with a certain chip type-specific build code or higher have an
// improved APPROTECT ("hardware and software controlled access port protection")
// which needs explicit action by the firmware to keep it unlocked
+ // See https://devzone.nordicsemi.com/nordic/nordic-blog/b/blog/posts/working-with-the-nrf52-series-improved-approtect
// UICR.APPROTECT = SwDisabled
let res = uicr_write(consts::UICR_APPROTECT, consts::APPROTECT_DISABLED);
diff --git a/embassy-nrf/src/qspi.rs b/embassy-nrf/src/qspi.rs
old mode 100644
new mode 100755
index 36ee33f6..5e1a4e84
--- a/embassy-nrf/src/qspi.rs
+++ b/embassy-nrf/src/qspi.rs
@@ -391,8 +391,13 @@ impl<'d, T: Instance> Qspi<'d, T> {
///
/// The difference with `read` is that this does not do bounds checks
/// against the flash capacity. It is intended for use when QSPI is used as
- /// a raw bus, not with flash memory.
+ /// a raw bus, not with flash memory.
pub async fn read_raw(&mut self, address: u32, data: &mut [u8]) -> Result<(), Error> {
+ // Avoid blocking_wait_ready() blocking forever on zero-length buffers.
+ if data.len() == 0 {
+ return Ok(());
+ }
+
let ondrop = OnDrop::new(Self::blocking_wait_ready);
self.start_read(address, data)?;
@@ -409,6 +414,11 @@ impl<'d, T: Instance> Qspi<'d, T> {
/// against the flash capacity. It is intended for use when QSPI is used as
/// a raw bus, not with flash memory.
pub async fn write_raw(&mut self, address: u32, data: &[u8]) -> Result<(), Error> {
+ // Avoid blocking_wait_ready() blocking forever on zero-length buffers.
+ if data.len() == 0 {
+ return Ok(());
+ }
+
let ondrop = OnDrop::new(Self::blocking_wait_ready);
self.start_write(address, data)?;
@@ -425,6 +435,11 @@ impl<'d, T: Instance> Qspi<'d, T> {
/// against the flash capacity. It is intended for use when QSPI is used as
/// a raw bus, not with flash memory.
pub fn blocking_read_raw(&mut self, address: u32, data: &mut [u8]) -> Result<(), Error> {
+ // Avoid blocking_wait_ready() blocking forever on zero-length buffers.
+ if data.len() == 0 {
+ return Ok(());
+ }
+
self.start_read(address, data)?;
Self::blocking_wait_ready();
Ok(())
@@ -436,6 +451,11 @@ impl<'d, T: Instance> Qspi<'d, T> {
/// against the flash capacity. It is intended for use when QSPI is used as
/// a raw bus, not with flash memory.
pub fn blocking_write_raw(&mut self, address: u32, data: &[u8]) -> Result<(), Error> {
+ // Avoid blocking_wait_ready() blocking forever on zero-length buffers.
+ if data.len() == 0 {
+ return Ok(());
+ }
+
self.start_write(address, data)?;
Self::blocking_wait_ready();
Ok(())
@@ -585,7 +605,6 @@ impl<'d, T: Instance> NorFlash for Qspi<'d, T> {
}
}
-#[cfg(feature = "nightly")]
mod _eh1 {
use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
diff --git a/embassy-nrf/src/spim.rs b/embassy-nrf/src/spim.rs
index caf681d9..5d3c3268 100644
--- a/embassy-nrf/src/spim.rs
+++ b/embassy-nrf/src/spim.rs
@@ -495,72 +495,61 @@ mod eh02 {
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
-
- impl embedded_hal_1::spi::Error for Error {
- fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
- match *self {
- Self::TxBufferTooLong => embedded_hal_1::spi::ErrorKind::Other,
- Self::RxBufferTooLong => embedded_hal_1::spi::ErrorKind::Other,
- Self::BufferNotInRAM => embedded_hal_1::spi::ErrorKind::Other,
- }
- }
- }
-
- impl<'d, T: Instance> embedded_hal_1::spi::ErrorType for Spim<'d, T> {
- type Error = Error;
- }
-
- impl<'d, T: Instance> embedded_hal_1::spi::SpiBus for Spim<'d, T> {
- fn flush(&mut self) -> Result<(), Self::Error> {
- Ok(())
- }
-
- fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_transfer(words, &[])
- }
-
- fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(words)
- }
-
- fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
- self.blocking_transfer(read, write)
- }
-
- fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_transfer_in_place(words)
+impl embedded_hal_1::spi::Error for Error {
+ fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
+ match *self {
+ Self::TxBufferTooLong => embedded_hal_1::spi::ErrorKind::Other,
+ Self::RxBufferTooLong => embedded_hal_1::spi::ErrorKind::Other,
+ Self::BufferNotInRAM => embedded_hal_1::spi::ErrorKind::Other,
}
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
+impl<'d, T: Instance> embedded_hal_1::spi::ErrorType for Spim<'d, T> {
+ type Error = Error;
+}
- use super::*;
+impl<'d, T: Instance> embedded_hal_1::spi::SpiBus for Spim<'d, T> {
+ fn flush(&mut self) -> Result<(), Self::Error> {
+ Ok(())
+ }
- impl<'d, T: Instance> embedded_hal_async::spi::SpiBus for Spim<'d, T> {
- async fn flush(&mut self) -> Result<(), Error> {
- Ok(())
- }
+ fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_transfer(words, &[])
+ }
- async fn read(&mut self, words: &mut [u8]) -> Result<(), Error> {
- self.read(words).await
- }
+ fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(words)
+ }
- async fn write(&mut self, data: &[u8]) -> Result<(), Error> {
- self.write(data).await
- }
+ fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_transfer(read, write)
+ }
- async fn transfer(&mut self, rx: &mut [u8], tx: &[u8]) -> Result<(), Error> {
- self.transfer(rx, tx).await
- }
+ fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_transfer_in_place(words)
+ }
+}
- async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Error> {
- self.transfer_in_place(words).await
- }
+impl<'d, T: Instance> embedded_hal_async::spi::SpiBus for Spim<'d, T> {
+ async fn flush(&mut self) -> Result<(), Error> {
+ Ok(())
+ }
+
+ async fn read(&mut self, words: &mut [u8]) -> Result<(), Error> {
+ self.read(words).await
+ }
+
+ async fn write(&mut self, data: &[u8]) -> Result<(), Error> {
+ self.write(data).await
+ }
+
+ async fn transfer(&mut self, rx: &mut [u8], tx: &[u8]) -> Result<(), Error> {
+ self.transfer(rx, tx).await
+ }
+
+ async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Error> {
+ self.transfer_in_place(words).await
}
}
diff --git a/embassy-nrf/src/twim.rs b/embassy-nrf/src/twim.rs
index 919bb4ab..da8e15d0 100644
--- a/embassy-nrf/src/twim.rs
+++ b/embassy-nrf/src/twim.rs
@@ -810,81 +810,72 @@ mod eh02 {
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
-
- impl embedded_hal_1::i2c::Error for Error {
- fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
- match *self {
- Self::TxBufferTooLong => embedded_hal_1::i2c::ErrorKind::Other,
- Self::RxBufferTooLong => embedded_hal_1::i2c::ErrorKind::Other,
- Self::Transmit => embedded_hal_1::i2c::ErrorKind::Other,
- Self::Receive => embedded_hal_1::i2c::ErrorKind::Other,
- Self::BufferNotInRAM => embedded_hal_1::i2c::ErrorKind::Other,
- Self::AddressNack => {
- embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Address)
- }
- Self::DataNack => {
- embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Data)
- }
- Self::Overrun => embedded_hal_1::i2c::ErrorKind::Overrun,
- Self::Timeout => embedded_hal_1::i2c::ErrorKind::Other,
+impl embedded_hal_1::i2c::Error for Error {
+ fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
+ match *self {
+ Self::TxBufferTooLong => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::RxBufferTooLong => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::Transmit => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::Receive => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::BufferNotInRAM => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::AddressNack => {
+ embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Address)
}
- }
- }
-
- impl<'d, T: Instance> embedded_hal_1::i2c::ErrorType for Twim<'d, T> {
- type Error = Error;
- }
-
- impl<'d, T: Instance> embedded_hal_1::i2c::I2c for Twim<'d, T> {
- fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_read(address, buffer)
- }
-
- fn write(&mut self, address: u8, buffer: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(address, buffer)
- }
-
- fn write_read(&mut self, address: u8, wr_buffer: &[u8], rd_buffer: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_write_read(address, wr_buffer, rd_buffer)
- }
-
- fn transaction<'a>(
- &mut self,
- _address: u8,
- _operations: &mut [embedded_hal_1::i2c::Operation<'a>],
- ) -> Result<(), Self::Error> {
- todo!();
+ Self::DataNack => {
+ embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Data)
+ }
+ Self::Overrun => embedded_hal_1::i2c::ErrorKind::Overrun,
+ Self::Timeout => embedded_hal_1::i2c::ErrorKind::Other,
}
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
- use super::*;
- impl<'d, T: Instance> embedded_hal_async::i2c::I2c for Twim<'d, T> {
- async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
- self.read(address, read).await
- }
+impl<'d, T: Instance> embedded_hal_1::i2c::ErrorType for Twim<'d, T> {
+ type Error = Error;
+}
- async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
- self.write(address, write).await
- }
- async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
- self.write_read(address, write, read).await
- }
+impl<'d, T: Instance> embedded_hal_1::i2c::I2c for Twim<'d, T> {
+ fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_read(address, buffer)
+ }
- async fn transaction(
- &mut self,
- address: u8,
- operations: &mut [embedded_hal_1::i2c::Operation<'_>],
- ) -> Result<(), Self::Error> {
- let _ = address;
- let _ = operations;
- todo!()
- }
+ fn write(&mut self, address: u8, buffer: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(address, buffer)
+ }
+
+ fn write_read(&mut self, address: u8, wr_buffer: &[u8], rd_buffer: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_write_read(address, wr_buffer, rd_buffer)
+ }
+
+ fn transaction<'a>(
+ &mut self,
+ _address: u8,
+ _operations: &mut [embedded_hal_1::i2c::Operation<'a>],
+ ) -> Result<(), Self::Error> {
+ todo!();
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_async::i2c::I2c for Twim<'d, T> {
+ async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+ self.read(address, read).await
+ }
+
+ async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+ self.write(address, write).await
+ }
+ async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+ self.write_read(address, write, read).await
+ }
+
+ async fn transaction(
+ &mut self,
+ address: u8,
+ operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+ ) -> Result<(), Self::Error> {
+ let _ = address;
+ let _ = operations;
+ todo!()
}
}
diff --git a/embassy-rp/Cargo.toml b/embassy-rp/Cargo.toml
index eb79cfd3..cfadd9f2 100644
--- a/embassy-rp/Cargo.toml
+++ b/embassy-rp/Cargo.toml
@@ -7,7 +7,7 @@ license = "MIT OR Apache-2.0"
[package.metadata.embassy_docs]
src_base = "https://github.com/embassy-rs/embassy/blob/embassy-rp-v$VERSION/embassy-rp/src/"
src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-rp/src/"
-features = ["nightly", "defmt", "unstable-pac", "unstable-traits", "time-driver"]
+features = ["defmt", "unstable-pac", "time-driver"]
flavors = [
{ name = "rp2040", target = "thumbv6m-none-eabi" },
]
@@ -16,7 +16,7 @@ flavors = [
default = [ "rt" ]
rt = [ "rp-pac/rt" ]
-defmt = ["dep:defmt", "embassy-usb-driver?/defmt", "embassy-hal-internal/defmt"]
+defmt = ["dep:defmt", "embassy-usb-driver/defmt", "embassy-hal-internal/defmt"]
# critical section that is safe for multicore use
critical-section-impl = ["critical-section/restore-state-u8"]
@@ -51,20 +51,13 @@ qspi-as-gpio = []
# This allows the flash driver to not force pausing execution on both cores when doing flash operations.
run-from-ram = []
-# Enable nightly-only features
-nightly = ["embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "embassy-embedded-hal/nightly", "dep:embassy-usb-driver", "dep:embedded-io-async"]
-
-# Implement embedded-hal 1.0 alpha traits.
-# Implement embedded-hal-async traits if `nightly` is set as well.
-unstable-traits = ["embedded-hal-1", "embedded-hal-nb"]
-
[dependencies]
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
-embassy-time = { version = "0.1.5", path = "../embassy-time", features = [ "tick-hz-1_000_000" ] }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
+embassy-time = { version = "0.2", path = "../embassy-time", features = [ "tick-hz-1_000_000" ] }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
embassy-hal-internal = {version = "0.1.0", path = "../embassy-hal-internal", features = ["cortex-m", "prio-bits-2"] }
embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }
-embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver", optional = true }
+embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver" }
atomic-polyfill = "1.0.1"
defmt = { version = "0.3", optional = true }
log = { version = "0.4.14", optional = true }
@@ -76,18 +69,18 @@ critical-section = "1.1"
futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
chrono = { version = "0.4", default-features = false, optional = true }
embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.0", optional = true }
+embedded-io-async = { version = "0.6.1" }
embedded-storage = { version = "0.3" }
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-storage-async = { version = "0.4.1" }
rand_core = "0.6.4"
fixed = "1.23.1"
rp-pac = { version = "6" }
embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.1", optional = true}
-embedded-hal-async = { version = "=1.0.0-rc.1", optional = true}
-embedded-hal-nb = { version = "=1.0.0-rc.1", optional = true}
+embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
+embedded-hal-nb = { version = "=1.0.0-rc.2" }
pio-proc = {version= "0.2" }
pio = {version= "0.2.1" }
diff --git a/embassy-rp/src/flash.rs b/embassy-rp/src/flash.rs
index 8fb5542f..1b20561d 100644
--- a/embassy-rp/src/flash.rs
+++ b/embassy-rp/src/flash.rs
@@ -352,7 +352,6 @@ impl<'d, T: Instance, M: Mode, const FLASH_SIZE: usize> NorFlash for Flash<'d, T
}
}
-#[cfg(feature = "nightly")]
impl<'d, T: Instance, const FLASH_SIZE: usize> embedded_storage_async::nor_flash::ReadNorFlash
for Flash<'d, T, Async, FLASH_SIZE>
{
@@ -367,7 +366,6 @@ impl<'d, T: Instance, const FLASH_SIZE: usize> embedded_storage_async::nor_flash
}
}
-#[cfg(feature = "nightly")]
impl<'d, T: Instance, const FLASH_SIZE: usize> embedded_storage_async::nor_flash::NorFlash
for Flash<'d, T, Async, FLASH_SIZE>
{
diff --git a/embassy-rp/src/gpio.rs b/embassy-rp/src/gpio.rs
index ee7e03e9..9034f3f3 100644
--- a/embassy-rp/src/gpio.rs
+++ b/embassy-rp/src/gpio.rs
@@ -1,4 +1,5 @@
#![macro_use]
+use core::convert::Infallible;
use core::future::Future;
use core::pin::Pin as FuturePin;
use core::task::{Context, Poll};
@@ -1036,217 +1037,207 @@ mod eh02 {
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use core::convert::Infallible;
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
+ type Error = Infallible;
+}
- use super::*;
-
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
- type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
- type Error = Infallible;
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
-
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Output<'d, T> {
- fn toggle(&mut self) -> Result<(), Self::Error> {
- Ok(self.toggle())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d, T> {
- type Error = Infallible;
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d, T> {
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
-
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<'d, T> {
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for OutputOpenDrain<'d, T> {
- fn toggle(&mut self) -> Result<(), Self::Error> {
- Ok(self.toggle())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d, T> {
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
- type Error = Infallible;
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
-
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Flex<'d, T> {
- fn toggle(&mut self) -> Result<(), Self::Error> {
- Ok(self.toggle())
- }
- }
-
- #[cfg(feature = "nightly")]
- impl<'d, T: Pin> embedded_hal_async::digital::Wait for Flex<'d, T> {
- async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
- self.wait_for_high().await;
- Ok(())
- }
-
- async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
- self.wait_for_low().await;
- Ok(())
- }
-
- async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_rising_edge().await;
- Ok(())
- }
-
- async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_falling_edge().await;
- Ok(())
- }
-
- async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_any_edge().await;
- Ok(())
- }
- }
-
- #[cfg(feature = "nightly")]
- impl<'d, T: Pin> embedded_hal_async::digital::Wait for Input<'d, T> {
- async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
- self.wait_for_high().await;
- Ok(())
- }
-
- async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
- self.wait_for_low().await;
- Ok(())
- }
-
- async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_rising_edge().await;
- Ok(())
- }
-
- async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_falling_edge().await;
- Ok(())
- }
-
- async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_any_edge().await;
- Ok(())
- }
- }
-
- #[cfg(feature = "nightly")]
- impl<'d, T: Pin> embedded_hal_async::digital::Wait for OutputOpenDrain<'d, T> {
- async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
- self.wait_for_high().await;
- Ok(())
- }
-
- async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
- self.wait_for_low().await;
- Ok(())
- }
-
- async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_rising_edge().await;
- Ok(())
- }
-
- async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_falling_edge().await;
- Ok(())
- }
-
- async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_any_edge().await;
- Ok(())
- }
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
+ }
+
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
+ }
+
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Output<'d, T> {
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ Ok(self.toggle())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d, T> {
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
+ }
+
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<'d, T> {
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
+ }
+
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for OutputOpenDrain<'d, T> {
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ Ok(self.toggle())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
+ }
+
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
+ }
+
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
+ }
+
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
+ }
+
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Flex<'d, T> {
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ Ok(self.toggle())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_async::digital::Wait for Flex<'d, T> {
+ async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_high().await;
+ Ok(())
+ }
+
+ async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_low().await;
+ Ok(())
+ }
+
+ async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_rising_edge().await;
+ Ok(())
+ }
+
+ async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_falling_edge().await;
+ Ok(())
+ }
+
+ async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_any_edge().await;
+ Ok(())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_async::digital::Wait for Input<'d, T> {
+ async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_high().await;
+ Ok(())
+ }
+
+ async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_low().await;
+ Ok(())
+ }
+
+ async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_rising_edge().await;
+ Ok(())
+ }
+
+ async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_falling_edge().await;
+ Ok(())
+ }
+
+ async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_any_edge().await;
+ Ok(())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_async::digital::Wait for OutputOpenDrain<'d, T> {
+ async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_high().await;
+ Ok(())
+ }
+
+ async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_low().await;
+ Ok(())
+ }
+
+ async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_rising_edge().await;
+ Ok(())
+ }
+
+ async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_falling_edge().await;
+ Ok(())
+ }
+
+ async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_any_edge().await;
+ Ok(())
}
}
diff --git a/embassy-rp/src/i2c.rs b/embassy-rp/src/i2c.rs
index 4fe4b27e..15095236 100644
--- a/embassy-rp/src/i2c.rs
+++ b/embassy-rp/src/i2c.rs
@@ -588,167 +588,157 @@ impl<'d, T: Instance + 'd, M: Mode> I2c<'d, T, M> {
}
}
-mod eh02 {
- use super::*;
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::Read for I2c<'d, T, M> {
+ type Error = Error;
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::Read for I2c<'d, T, M> {
- type Error = Error;
-
- fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_read(address, buffer)
- }
+ fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_read(address, buffer)
}
+}
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::Write for I2c<'d, T, M> {
- type Error = Error;
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::Write for I2c<'d, T, M> {
+ type Error = Error;
- fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(address, bytes)
- }
+ fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(address, bytes)
}
+}
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::WriteRead for I2c<'d, T, M> {
- type Error = Error;
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::WriteRead for I2c<'d, T, M> {
+ type Error = Error;
- fn write_read(&mut self, address: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_write_read(address, bytes, buffer)
- }
+ fn write_read(&mut self, address: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_write_read(address, bytes, buffer)
}
+}
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::Transactional for I2c<'d, T, M> {
- type Error = Error;
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::i2c::Transactional for I2c<'d, T, M> {
+ type Error = Error;
- fn exec(
- &mut self,
- address: u8,
- operations: &mut [embedded_hal_02::blocking::i2c::Operation<'_>],
- ) -> Result<(), Self::Error> {
- Self::setup(address.into())?;
- for i in 0..operations.len() {
- let last = i == operations.len() - 1;
- match &mut operations[i] {
- embedded_hal_02::blocking::i2c::Operation::Read(buf) => {
- self.read_blocking_internal(buf, false, last)?
- }
- embedded_hal_02::blocking::i2c::Operation::Write(buf) => self.write_blocking_internal(buf, last)?,
+ fn exec(
+ &mut self,
+ address: u8,
+ operations: &mut [embedded_hal_02::blocking::i2c::Operation<'_>],
+ ) -> Result<(), Self::Error> {
+ Self::setup(address.into())?;
+ for i in 0..operations.len() {
+ let last = i == operations.len() - 1;
+ match &mut operations[i] {
+ embedded_hal_02::blocking::i2c::Operation::Read(buf) => {
+ self.read_blocking_internal(buf, false, last)?
}
+ embedded_hal_02::blocking::i2c::Operation::Write(buf) => self.write_blocking_internal(buf, last)?,
}
- Ok(())
+ }
+ Ok(())
+ }
+}
+
+impl embedded_hal_1::i2c::Error for Error {
+ fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
+ match *self {
+ Self::Abort(AbortReason::ArbitrationLoss) => embedded_hal_1::i2c::ErrorKind::ArbitrationLoss,
+ Self::Abort(AbortReason::NoAcknowledge) => {
+ embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Address)
+ }
+ Self::Abort(AbortReason::TxNotEmpty(_)) => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::Abort(AbortReason::Other(_)) => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::InvalidReadBufferLength => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::InvalidWriteBufferLength => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::AddressOutOfRange(_) => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::AddressReserved(_) => embedded_hal_1::i2c::ErrorKind::Other,
}
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl<'d, T: Instance, M: Mode> embedded_hal_1::i2c::ErrorType for I2c<'d, T, M> {
+ type Error = Error;
+}
- impl embedded_hal_1::i2c::Error for Error {
- fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
- match *self {
- Self::Abort(AbortReason::ArbitrationLoss) => embedded_hal_1::i2c::ErrorKind::ArbitrationLoss,
- Self::Abort(AbortReason::NoAcknowledge) => {
- embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Address)
- }
- Self::Abort(AbortReason::TxNotEmpty(_)) => embedded_hal_1::i2c::ErrorKind::Other,
- Self::Abort(AbortReason::Other(_)) => embedded_hal_1::i2c::ErrorKind::Other,
- Self::InvalidReadBufferLength => embedded_hal_1::i2c::ErrorKind::Other,
- Self::InvalidWriteBufferLength => embedded_hal_1::i2c::ErrorKind::Other,
- Self::AddressOutOfRange(_) => embedded_hal_1::i2c::ErrorKind::Other,
- Self::AddressReserved(_) => embedded_hal_1::i2c::ErrorKind::Other,
- }
- }
+impl<'d, T: Instance, M: Mode> embedded_hal_1::i2c::I2c for I2c<'d, T, M> {
+ fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_read(address, read)
}
- impl<'d, T: Instance, M: Mode> embedded_hal_1::i2c::ErrorType for I2c<'d, T, M> {
- type Error = Error;
+ fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(address, write)
}
- impl<'d, T: Instance, M: Mode> embedded_hal_1::i2c::I2c for I2c<'d, T, M> {
- fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_read(address, read)
- }
+ fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_write_read(address, write, read)
+ }
- fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(address, write)
- }
-
- fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_write_read(address, write, read)
- }
-
- fn transaction(
- &mut self,
- address: u8,
- operations: &mut [embedded_hal_1::i2c::Operation<'_>],
- ) -> Result<(), Self::Error> {
- Self::setup(address.into())?;
- for i in 0..operations.len() {
- let last = i == operations.len() - 1;
- match &mut operations[i] {
- embedded_hal_1::i2c::Operation::Read(buf) => self.read_blocking_internal(buf, false, last)?,
- embedded_hal_1::i2c::Operation::Write(buf) => self.write_blocking_internal(buf, last)?,
- }
+ fn transaction(
+ &mut self,
+ address: u8,
+ operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+ ) -> Result<(), Self::Error> {
+ Self::setup(address.into())?;
+ for i in 0..operations.len() {
+ let last = i == operations.len() - 1;
+ match &mut operations[i] {
+ embedded_hal_1::i2c::Operation::Read(buf) => self.read_blocking_internal(buf, false, last)?,
+ embedded_hal_1::i2c::Operation::Write(buf) => self.write_blocking_internal(buf, last)?,
}
- Ok(())
}
+ Ok(())
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod nightly {
- use embedded_hal_1::i2c::Operation;
- use embedded_hal_async::i2c::AddressMode;
- use super::*;
+impl<'d, A, T> embedded_hal_async::i2c::I2c for I2c<'d, T, Async>
+where
+ A: embedded_hal_async::i2c::AddressMode + Into + 'static,
+ T: Instance + 'd,
+{
+ async fn read(&mut self, address: A, read: &mut [u8]) -> Result<(), Self::Error> {
+ let addr: u16 = address.into();
- impl<'d, A, T> embedded_hal_async::i2c::I2c for I2c<'d, T, Async>
- where
- A: AddressMode + Into + 'static,
- T: Instance + 'd,
- {
- async fn read(&mut self, address: A, read: &mut [u8]) -> Result<(), Self::Error> {
- let addr: u16 = address.into();
+ Self::setup(addr)?;
+ self.read_async_internal(read, false, true).await
+ }
+ async fn write(&mut self, address: A, write: &[u8]) -> Result<(), Self::Error> {
+ let addr: u16 = address.into();
+
+ Self::setup(addr)?;
+ self.write_async_internal(write.iter().copied(), true).await
+ }
+
+ async fn write_read(&mut self, address: A, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+ let addr: u16 = address.into();
+
+ Self::setup(addr)?;
+ self.write_async_internal(write.iter().cloned(), false).await?;
+ self.read_async_internal(read, true, true).await
+ }
+
+ async fn transaction(
+ &mut self,
+ address: A,
+ operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+ ) -> Result<(), Self::Error> {
+ use embedded_hal_1::i2c::Operation;
+
+ let addr: u16 = address.into();
+
+ if operations.len() > 0 {
Self::setup(addr)?;
- self.read_async_internal(read, false, true).await
}
+ let mut iterator = operations.iter_mut();
- async fn write(&mut self, address: A, write: &[u8]) -> Result<(), Self::Error> {
- let addr: u16 = address.into();
+ while let Some(op) = iterator.next() {
+ let last = iterator.len() == 0;
- Self::setup(addr)?;
- self.write_async_internal(write.iter().copied(), true).await
- }
-
- async fn write_read(&mut self, address: A, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
- let addr: u16 = address.into();
-
- Self::setup(addr)?;
- self.write_async_internal(write.iter().cloned(), false).await?;
- self.read_async_internal(read, true, true).await
- }
-
- async fn transaction(&mut self, address: A, operations: &mut [Operation<'_>]) -> Result<(), Self::Error> {
- let addr: u16 = address.into();
-
- if operations.len() > 0 {
- Self::setup(addr)?;
- }
- let mut iterator = operations.iter_mut();
-
- while let Some(op) = iterator.next() {
- let last = iterator.len() == 0;
-
- match op {
- Operation::Read(buffer) => {
- self.read_async_internal(buffer, false, last).await?;
- }
- Operation::Write(buffer) => {
- self.write_async_internal(buffer.into_iter().cloned(), last).await?;
- }
+ match op {
+ Operation::Read(buffer) => {
+ self.read_async_internal(buffer, false, last).await?;
+ }
+ Operation::Write(buffer) => {
+ self.write_async_internal(buffer.into_iter().cloned(), last).await?;
}
}
- Ok(())
}
+ Ok(())
}
}
diff --git a/embassy-rp/src/lib.rs b/embassy-rp/src/lib.rs
index c9fe89b8..66e4cfdc 100644
--- a/embassy-rp/src/lib.rs
+++ b/embassy-rp/src/lib.rs
@@ -1,6 +1,5 @@
#![no_std]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![allow(async_fn_in_trait)]
// This mod MUST go first, so that the others see its macros.
pub(crate) mod fmt;
@@ -28,7 +27,6 @@ pub mod spi;
#[cfg(feature = "time-driver")]
pub mod timer;
pub mod uart;
-#[cfg(feature = "nightly")]
pub mod usb;
pub mod watchdog;
diff --git a/embassy-rp/src/spi.rs b/embassy-rp/src/spi.rs
index a59ce841..6ba985a6 100644
--- a/embassy-rp/src/spi.rs
+++ b/embassy-rp/src/spi.rs
@@ -511,87 +511,73 @@ impl_mode!(Async);
// ====================
-mod eh02 {
- use super::*;
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::spi::Transfer for Spi<'d, T, M> {
- type Error = Error;
- fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
- self.blocking_transfer_in_place(words)?;
- Ok(words)
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::spi::Write for Spi<'d, T, M> {
- type Error = Error;
-
- fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(words)
- }
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::spi::Transfer for Spi<'d, T, M> {
+ type Error = Error;
+ fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
+ self.blocking_transfer_in_place(words)?;
+ Ok(words)
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::spi::Write for Spi<'d, T, M> {
+ type Error = Error;
- impl embedded_hal_1::spi::Error for Error {
- fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
- match *self {}
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_1::spi::ErrorType for Spi<'d, T, M> {
- type Error = Error;
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_1::spi::SpiBus for Spi<'d, T, M> {
- fn flush(&mut self) -> Result<(), Self::Error> {
- Ok(())
- }
-
- fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_transfer(words, &[])
- }
-
- fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(words)
- }
-
- fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
- self.blocking_transfer(read, write)
- }
-
- fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_transfer_in_place(words)
- }
+ fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(words)
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
- use super::*;
+impl embedded_hal_1::spi::Error for Error {
+ fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
+ match *self {}
+ }
+}
- impl<'d, T: Instance> embedded_hal_async::spi::SpiBus for Spi<'d, T, Async> {
- async fn flush(&mut self) -> Result<(), Self::Error> {
- Ok(())
- }
+impl<'d, T: Instance, M: Mode> embedded_hal_1::spi::ErrorType for Spi<'d, T, M> {
+ type Error = Error;
+}
- async fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
- self.write(words).await
- }
+impl<'d, T: Instance, M: Mode> embedded_hal_1::spi::SpiBus for Spi<'d, T, M> {
+ fn flush(&mut self) -> Result<(), Self::Error> {
+ Ok(())
+ }
- async fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
- self.read(words).await
- }
+ fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_transfer(words, &[])
+ }
- async fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
- self.transfer(read, write).await
- }
+ fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(words)
+ }
- async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
- self.transfer_in_place(words).await
- }
+ fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_transfer(read, write)
+ }
+
+ fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_transfer_in_place(words)
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_async::spi::SpiBus for Spi<'d, T, Async> {
+ async fn flush(&mut self) -> Result<(), Self::Error> {
+ Ok(())
+ }
+
+ async fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
+ self.write(words).await
+ }
+
+ async fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+ self.read(words).await
+ }
+
+ async fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
+ self.transfer(read, write).await
+ }
+
+ async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
+ self.transfer_in_place(words).await
}
}
diff --git a/embassy-rp/src/uart/buffered.rs b/embassy-rp/src/uart/buffered.rs
index 9f638761..ca030f56 100644
--- a/embassy-rp/src/uart/buffered.rs
+++ b/embassy-rp/src/uart/buffered.rs
@@ -668,126 +668,117 @@ impl<'d, T: Instance + 'd> embedded_io::Write for BufferedUartTx<'d, T> {
}
}
-mod eh02 {
- use super::*;
+impl<'d, T: Instance> embedded_hal_02::serial::Read for BufferedUartRx<'d, T> {
+ type Error = Error;
- impl<'d, T: Instance> embedded_hal_02::serial::Read for BufferedUartRx<'d, T> {
- type Error = Error;
-
- fn read(&mut self) -> Result> {
- let r = T::regs();
- if r.uartfr().read().rxfe() {
- return Err(nb::Error::WouldBlock);
- }
-
- let dr = r.uartdr().read();
-
- if dr.oe() {
- Err(nb::Error::Other(Error::Overrun))
- } else if dr.be() {
- Err(nb::Error::Other(Error::Break))
- } else if dr.pe() {
- Err(nb::Error::Other(Error::Parity))
- } else if dr.fe() {
- Err(nb::Error::Other(Error::Framing))
- } else {
- Ok(dr.data())
- }
- }
- }
-
- impl<'d, T: Instance> embedded_hal_02::blocking::serial::Write for BufferedUartTx<'d, T> {
- type Error = Error;
-
- fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
- while !buffer.is_empty() {
- match self.blocking_write(buffer) {
- Ok(0) => panic!("zero-length write."),
- Ok(n) => buffer = &buffer[n..],
- Err(e) => return Err(e),
- }
- }
- Ok(())
+ fn read(&mut self) -> Result> {
+ let r = T::regs();
+ if r.uartfr().read().rxfe() {
+ return Err(nb::Error::WouldBlock);
}
- fn bflush(&mut self) -> Result<(), Self::Error> {
- self.blocking_flush()
- }
- }
+ let dr = r.uartdr().read();
- impl<'d, T: Instance> embedded_hal_02::serial::Read for BufferedUart<'d, T> {
- type Error = Error;
-
- fn read(&mut self) -> Result> {
- embedded_hal_02::serial::Read::read(&mut self.rx)
- }
- }
-
- impl<'d, T: Instance> embedded_hal_02::blocking::serial::Write for BufferedUart<'d, T> {
- type Error = Error;
-
- fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
- while !buffer.is_empty() {
- match self.blocking_write(buffer) {
- Ok(0) => panic!("zero-length write."),
- Ok(n) => buffer = &buffer[n..],
- Err(e) => return Err(e),
- }
- }
- Ok(())
- }
-
- fn bflush(&mut self) -> Result<(), Self::Error> {
- self.blocking_flush()
+ if dr.oe() {
+ Err(nb::Error::Other(Error::Overrun))
+ } else if dr.be() {
+ Err(nb::Error::Other(Error::Break))
+ } else if dr.pe() {
+ Err(nb::Error::Other(Error::Parity))
+ } else if dr.fe() {
+ Err(nb::Error::Other(Error::Framing))
+ } else {
+ Ok(dr.data())
}
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl<'d, T: Instance> embedded_hal_02::blocking::serial::Write for BufferedUartTx<'d, T> {
+ type Error = Error;
- impl<'d, T: Instance> embedded_hal_nb::serial::ErrorType for BufferedUartRx<'d, T> {
- type Error = Error;
+ fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
+ while !buffer.is_empty() {
+ match self.blocking_write(buffer) {
+ Ok(0) => panic!("zero-length write."),
+ Ok(n) => buffer = &buffer[n..],
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(())
}
- impl<'d, T: Instance> embedded_hal_nb::serial::ErrorType for BufferedUartTx<'d, T> {
- type Error = Error;
- }
-
- impl<'d, T: Instance> embedded_hal_nb::serial::ErrorType for BufferedUart<'d, T> {
- type Error = Error;
- }
-
- impl<'d, T: Instance> embedded_hal_nb::serial::Read for BufferedUartRx<'d, T> {
- fn read(&mut self) -> nb::Result {
- embedded_hal_02::serial::Read::read(self)
- }
- }
-
- impl<'d, T: Instance> embedded_hal_nb::serial::Write for BufferedUartTx<'d, T> {
- fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
- self.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
- }
-
- fn flush(&mut self) -> nb::Result<(), Self::Error> {
- self.blocking_flush().map_err(nb::Error::Other)
- }
- }
-
- impl<'d, T: Instance> embedded_hal_nb::serial::Read for BufferedUart<'d, T> {
- fn read(&mut self) -> Result> {
- embedded_hal_02::serial::Read::read(&mut self.rx)
- }
- }
-
- impl<'d, T: Instance> embedded_hal_nb::serial::Write for BufferedUart<'d, T> {
- fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
- self.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
- }
-
- fn flush(&mut self) -> nb::Result<(), Self::Error> {
- self.blocking_flush().map_err(nb::Error::Other)
- }
+ fn bflush(&mut self) -> Result<(), Self::Error> {
+ self.blocking_flush()
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_02::serial::Read for BufferedUart<'d, T> {
+ type Error = Error;
+
+ fn read(&mut self) -> Result> {
+ embedded_hal_02::serial::Read::read(&mut self.rx)
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_02::blocking::serial::Write for BufferedUart<'d, T> {
+ type Error = Error;
+
+ fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
+ while !buffer.is_empty() {
+ match self.blocking_write(buffer) {
+ Ok(0) => panic!("zero-length write."),
+ Ok(n) => buffer = &buffer[n..],
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(())
+ }
+
+ fn bflush(&mut self) -> Result<(), Self::Error> {
+ self.blocking_flush()
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::ErrorType for BufferedUartRx<'d, T> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::ErrorType for BufferedUartTx<'d, T> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::ErrorType for BufferedUart<'d, T> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::Read for BufferedUartRx<'d, T> {
+ fn read(&mut self) -> nb::Result {
+ embedded_hal_02::serial::Read::read(self)
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::Write for BufferedUartTx<'d, T> {
+ fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+ self.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
+ }
+
+ fn flush(&mut self) -> nb::Result<(), Self::Error> {
+ self.blocking_flush().map_err(nb::Error::Other)
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::Read for BufferedUart<'d, T> {
+ fn read(&mut self) -> Result> {
+ embedded_hal_02::serial::Read::read(&mut self.rx)
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_nb::serial::Write for BufferedUart<'d, T> {
+ fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+ self.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
+ }
+
+ fn flush(&mut self) -> nb::Result<(), Self::Error> {
+ self.blocking_flush().map_err(nb::Error::Other)
}
}
diff --git a/embassy-rp/src/uart/mod.rs b/embassy-rp/src/uart/mod.rs
index 461986c8..18705b14 100644
--- a/embassy-rp/src/uart/mod.rs
+++ b/embassy-rp/src/uart/mod.rs
@@ -17,9 +17,7 @@ use crate::interrupt::typelevel::{Binding, Interrupt};
use crate::pac::io::vals::{Inover, Outover};
use crate::{interrupt, pac, peripherals, Peripheral, RegExt};
-#[cfg(feature = "nightly")]
mod buffered;
-#[cfg(feature = "nightly")]
pub use buffered::{BufferedInterruptHandler, BufferedUart, BufferedUartRx, BufferedUartTx};
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -193,7 +191,6 @@ impl<'d, T: Instance, M: Mode> UartTx<'d, T, M> {
}
impl<'d, T: Instance> UartTx<'d, T, Blocking> {
- #[cfg(feature = "nightly")]
pub fn into_buffered(
self,
irq: impl Binding>,
@@ -307,7 +304,6 @@ impl<'d, T: Instance> UartRx<'d, T, Blocking> {
Self::new_inner(false, None)
}
- #[cfg(feature = "nightly")]
pub fn into_buffered(
self,
irq: impl Binding>,
@@ -462,7 +458,6 @@ impl<'d, T: Instance> Uart<'d, T, Blocking> {
)
}
- #[cfg(feature = "nightly")]
pub fn into_buffered(
self,
irq: impl Binding>,
@@ -709,175 +704,166 @@ impl<'d, T: Instance> Uart<'d, T, Async> {
}
}
-mod eh02 {
- use super::*;
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Read for UartRx<'d, T, M> {
- type Error = Error;
- fn read(&mut self) -> Result> {
- let r = T::regs();
- if r.uartfr().read().rxfe() {
- return Err(nb::Error::WouldBlock);
- }
-
- let dr = r.uartdr().read();
-
- if dr.oe() {
- Err(nb::Error::Other(Error::Overrun))
- } else if dr.be() {
- Err(nb::Error::Other(Error::Break))
- } else if dr.pe() {
- Err(nb::Error::Other(Error::Parity))
- } else if dr.fe() {
- Err(nb::Error::Other(Error::Framing))
- } else {
- Ok(dr.data())
- }
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Write for UartTx<'d, T, M> {
- type Error = Error;
-
- fn write(&mut self, word: u8) -> Result<(), nb::Error> {
- let r = T::regs();
- if r.uartfr().read().txff() {
- return Err(nb::Error::WouldBlock);
- }
-
- r.uartdr().write(|w| w.set_data(word));
- Ok(())
+impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Read for UartRx<'d, T, M> {
+ type Error = Error;
+ fn read(&mut self) -> Result> {
+ let r = T::regs();
+ if r.uartfr().read().rxfe() {
+ return Err(nb::Error::WouldBlock);
}
- fn flush(&mut self) -> Result<(), nb::Error> {
- let r = T::regs();
- if !r.uartfr().read().txfe() {
- return Err(nb::Error::WouldBlock);
- }
- Ok(())
- }
- }
+ let dr = r.uartdr().read();
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::serial::Write for UartTx<'d, T, M> {
- type Error = Error;
-
- fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(buffer)
- }
-
- fn bflush(&mut self) -> Result<(), Self::Error> {
- self.blocking_flush()
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Read for Uart<'d, T, M> {
- type Error = Error;
-
- fn read(&mut self) -> Result> {
- embedded_hal_02::serial::Read::read(&mut self.rx)
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Write for Uart<'d, T, M> {
- type Error = Error;
-
- fn write(&mut self, word: u8) -> Result<(), nb::Error> {
- embedded_hal_02::serial::Write::write(&mut self.tx, word)
- }
-
- fn flush(&mut self) -> Result<(), nb::Error> {
- embedded_hal_02::serial::Write::flush(&mut self.tx)
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::serial::Write for Uart<'d, T, M> {
- type Error = Error;
-
- fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(buffer)
- }
-
- fn bflush(&mut self) -> Result<(), Self::Error> {
- self.blocking_flush()
+ if dr.oe() {
+ Err(nb::Error::Other(Error::Overrun))
+ } else if dr.be() {
+ Err(nb::Error::Other(Error::Break))
+ } else if dr.pe() {
+ Err(nb::Error::Other(Error::Parity))
+ } else if dr.fe() {
+ Err(nb::Error::Other(Error::Framing))
+ } else {
+ Ok(dr.data())
}
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Write for UartTx<'d, T, M> {
+ type Error = Error;
- impl embedded_hal_nb::serial::Error for Error {
- fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
- match *self {
- Self::Framing => embedded_hal_nb::serial::ErrorKind::FrameFormat,
- Self::Break => embedded_hal_nb::serial::ErrorKind::Other,
- Self::Overrun => embedded_hal_nb::serial::ErrorKind::Overrun,
- Self::Parity => embedded_hal_nb::serial::ErrorKind::Parity,
- }
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::ErrorType for UartRx<'d, T, M> {
- type Error = Error;
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::ErrorType for UartTx<'d, T, M> {
- type Error = Error;
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::ErrorType for Uart<'d, T, M> {
- type Error = Error;
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Read for UartRx<'d, T, M> {
- fn read(&mut self) -> nb::Result {
- let r = T::regs();
- let dr = r.uartdr().read();
-
- if dr.oe() {
- Err(nb::Error::Other(Error::Overrun))
- } else if dr.be() {
- Err(nb::Error::Other(Error::Break))
- } else if dr.pe() {
- Err(nb::Error::Other(Error::Parity))
- } else if dr.fe() {
- Err(nb::Error::Other(Error::Framing))
- } else if dr.fe() {
- Ok(dr.data())
- } else {
- Err(nb::Error::WouldBlock)
- }
- }
- }
-
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Write for UartTx<'d, T, M> {
- fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
- self.blocking_write(&[char]).map_err(nb::Error::Other)
+ fn write(&mut self, word: u8) -> Result<(), nb::Error> {
+ let r = T::regs();
+ if r.uartfr().read().txff() {
+ return Err(nb::Error::WouldBlock);
}
- fn flush(&mut self) -> nb::Result<(), Self::Error> {
- self.blocking_flush().map_err(nb::Error::Other)
- }
+ r.uartdr().write(|w| w.set_data(word));
+ Ok(())
}
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Read for Uart<'d, T, M> {
- fn read(&mut self) -> Result> {
- embedded_hal_02::serial::Read::read(&mut self.rx)
+ fn flush(&mut self) -> Result<(), nb::Error> {
+ let r = T::regs();
+ if !r.uartfr().read().txfe() {
+ return Err(nb::Error::WouldBlock);
}
+ Ok(())
+ }
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::serial::Write for UartTx<'d, T, M> {
+ type Error = Error;
+
+ fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(buffer)
}
- impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Write for Uart<'d, T, M> {
- fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
- self.blocking_write(&[char]).map_err(nb::Error::Other)
- }
+ fn bflush(&mut self) -> Result<(), Self::Error> {
+ self.blocking_flush()
+ }
+}
- fn flush(&mut self) -> nb::Result<(), Self::Error> {
- self.blocking_flush().map_err(nb::Error::Other)
+impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Read for Uart<'d, T, M> {
+ type Error = Error;
+
+ fn read(&mut self) -> Result> {
+ embedded_hal_02::serial::Read::read(&mut self.rx)
+ }
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_02::serial::Write for Uart<'d, T, M> {
+ type Error = Error;
+
+ fn write(&mut self, word: u8) -> Result<(), nb::Error> {
+ embedded_hal_02::serial::Write::write(&mut self.tx, word)
+ }
+
+ fn flush(&mut self) -> Result<(), nb::Error> {
+ embedded_hal_02::serial::Write::flush(&mut self.tx)
+ }
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_02::blocking::serial::Write for Uart<'d, T, M> {
+ type Error = Error;
+
+ fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(buffer)
+ }
+
+ fn bflush(&mut self) -> Result<(), Self::Error> {
+ self.blocking_flush()
+ }
+}
+
+impl embedded_hal_nb::serial::Error for Error {
+ fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
+ match *self {
+ Self::Framing => embedded_hal_nb::serial::ErrorKind::FrameFormat,
+ Self::Break => embedded_hal_nb::serial::ErrorKind::Other,
+ Self::Overrun => embedded_hal_nb::serial::ErrorKind::Overrun,
+ Self::Parity => embedded_hal_nb::serial::ErrorKind::Parity,
}
}
}
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::ErrorType for UartRx<'d, T, M> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::ErrorType for UartTx<'d, T, M> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::ErrorType for Uart<'d, T, M> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Read for UartRx<'d, T, M> {
+ fn read(&mut self) -> nb::Result {
+ let r = T::regs();
+ let dr = r.uartdr().read();
+
+ if dr.oe() {
+ Err(nb::Error::Other(Error::Overrun))
+ } else if dr.be() {
+ Err(nb::Error::Other(Error::Break))
+ } else if dr.pe() {
+ Err(nb::Error::Other(Error::Parity))
+ } else if dr.fe() {
+ Err(nb::Error::Other(Error::Framing))
+ } else if dr.fe() {
+ Ok(dr.data())
+ } else {
+ Err(nb::Error::WouldBlock)
+ }
+ }
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Write for UartTx<'d, T, M> {
+ fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+ self.blocking_write(&[char]).map_err(nb::Error::Other)
+ }
+
+ fn flush(&mut self) -> nb::Result<(), Self::Error> {
+ self.blocking_flush().map_err(nb::Error::Other)
+ }
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Read for Uart<'d, T, M> {
+ fn read(&mut self) -> Result> {
+ embedded_hal_02::serial::Read::read(&mut self.rx)
+ }
+}
+
+impl<'d, T: Instance, M: Mode> embedded_hal_nb::serial::Write for Uart<'d, T, M> {
+ fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+ self.blocking_write(&[char]).map_err(nb::Error::Other)
+ }
+
+ fn flush(&mut self) -> nb::Result<(), Self::Error> {
+ self.blocking_flush().map_err(nb::Error::Other)
+ }
+}
+
mod sealed {
use super::*;
@@ -891,7 +877,6 @@ mod sealed {
fn regs() -> pac::uart::Uart;
- #[cfg(feature = "nightly")]
fn buffered_state() -> &'static buffered::State;
fn dma_state() -> &'static DmaState;
@@ -931,7 +916,6 @@ macro_rules! impl_instance {
pac::$inst
}
- #[cfg(feature = "nightly")]
fn buffered_state() -> &'static buffered::State {
static STATE: buffered::State = buffered::State::new();
&STATE
diff --git a/embassy-stm32-wpan/Cargo.toml b/embassy-stm32-wpan/Cargo.toml
index 607cd44c..f887b817 100644
--- a/embassy-stm32-wpan/Cargo.toml
+++ b/embassy-stm32-wpan/Cargo.toml
@@ -12,8 +12,8 @@ features = ["stm32wb55rg"]
[dependencies]
embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32" }
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
-embassy-time = { version = "0.1.5", path = "../embassy-time", optional = true }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
+embassy-time = { version = "0.2", path = "../embassy-time", optional = true }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
embassy-hal-internal = { version = "0.1.0", path = "../embassy-hal-internal" }
embassy-embedded-hal = { version = "0.1.0", path = "../embassy-embedded-hal" }
diff --git a/embassy-stm32-wpan/src/lib.rs b/embassy-stm32-wpan/src/lib.rs
index 84cf0a02..a5dbb742 100644
--- a/embassy-stm32-wpan/src/lib.rs
+++ b/embassy-stm32-wpan/src/lib.rs
@@ -1,9 +1,5 @@
#![no_std]
-#![cfg_attr(any(feature = "ble", feature = "mac"), feature(async_fn_in_trait))]
-#![cfg_attr(
- any(feature = "ble", feature = "mac"),
- allow(stable_features, unknown_lints, async_fn_in_trait)
-)]
+#![allow(async_fn_in_trait)]
// This must go FIRST so that all the other modules see its macros.
mod fmt;
diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index 292902ac..ea395c33 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
src_base = "https://github.com/embassy-rs/embassy/blob/embassy-stm32-v$VERSION/embassy-stm32/src/"
src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-stm32/src/"
-features = ["nightly", "defmt", "unstable-pac", "unstable-traits", "exti", "time-driver-any", "time"]
+features = ["defmt", "unstable-pac", "exti", "time-driver-any", "time"]
flavors = [
{ regex_feature = "stm32f0.*", target = "thumbv6m-none-eabi" },
{ regex_feature = "stm32f1.*", target = "thumbv7m-none-eabi" },
@@ -32,22 +32,22 @@ flavors = [
]
[dependencies]
-embassy-sync = { version = "0.4.0", path = "../embassy-sync" }
-embassy-time = { version = "0.1.5", path = "../embassy-time", optional = true }
+embassy-sync = { version = "0.5.0", path = "../embassy-sync" }
+embassy-time = { version = "0.2", path = "../embassy-time", optional = true }
embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
embassy-hal-internal = {version = "0.1.0", path = "../embassy-hal-internal", features = ["cortex-m", "prio-bits-4"] }
embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }
embassy-net-driver = { version = "0.2.0", path = "../embassy-net-driver" }
-embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver", optional = true }
+embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver" }
embassy-executor = { version = "0.3.3", path = "../embassy-executor", optional = true }
embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.1", optional = true}
-embedded-hal-async = { version = "=1.0.0-rc.1", optional = true}
-embedded-hal-nb = { version = "=1.0.0-rc.1", optional = true}
+embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.2" }
+embedded-hal-async = { version = "=1.0.0-rc.2" }
+embedded-hal-nb = { version = "=1.0.0-rc.2" }
-embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true }
+embedded-storage = "0.3.1"
+embedded-storage-async = { version = "0.4.1" }
defmt = { version = "0.3", optional = true }
log = { version = "0.4.14", optional = true }
@@ -65,7 +65,7 @@ nb = "1.0.0"
stm32-fmc = "0.3.0"
cfg-if = "1.0.0"
embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.0", optional = true }
+embedded-io-async = { version = "0.6.1" }
chrono = { version = "^0.4", default-features = false, optional = true}
bit_field = "0.10.2"
document-features = "0.2.7"
@@ -86,29 +86,21 @@ default = ["rt"]
rt = ["stm32-metapac/rt"]
## Use [`defmt`](https://docs.rs/defmt/latest/defmt/) for logging
-defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-internal/defmt", "embedded-io-async?/defmt-03", "embassy-usb-driver?/defmt", "embassy-net-driver/defmt", "embassy-time?/defmt"]
+defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-internal/defmt", "embedded-io-async/defmt-03", "embassy-usb-driver/defmt", "embassy-net-driver/defmt", "embassy-time?/defmt"]
exti = []
-low-power = [ "dep:embassy-executor", "embassy-executor/arch-cortex-m" ]
+low-power = [ "dep:embassy-executor", "embassy-executor?/arch-cortex-m" ]
low-power-debug-with-sleep = []
-embassy-executor = []
## Automatically generate `memory.x` file using [`stm32-metapac`](https://docs.rs/stm32-metapac/)
memory-x = ["stm32-metapac/memory-x"]
-## Enable nightly-only features
-nightly = ["embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "dep:embedded-io-async", "dep:embassy-usb-driver", "embassy-embedded-hal/nightly"]
-
## Re-export stm32-metapac at `embassy_stm32::pac`.
## This is unstable because semver-minor (non-breaking) releases of embassy-stm32 may major-bump (breaking) the stm32-metapac version.
## If this is an issue for you, you're encouraged to directly depend on a fixed version of the PAC.
## There are no plans to make this stable.
unstable-pac = []
-## Implement embedded-hal 1.0 alpha traits.
-## Implement embedded-hal-async traits if `nightly` is set as well.
-unstable-traits = ["embedded-hal-1", "dep:embedded-hal-nb"]
-
#! ## Time
## Enables additional driver features that depend on embassy-time
diff --git a/embassy-stm32/src/exti.rs b/embassy-stm32/src/exti.rs
index 07c63a2e..dbd24804 100644
--- a/embassy-stm32/src/exti.rs
+++ b/embassy-stm32/src/exti.rs
@@ -1,3 +1,4 @@
+use core::convert::Infallible;
use core::future::Future;
use core::marker::PhantomData;
use core::pin::Pin;
@@ -137,74 +138,56 @@ impl<'d, T: GpioPin> ExtiInput<'d, T> {
}
}
-mod eh02 {
- use core::convert::Infallible;
+impl<'d, T: GpioPin> embedded_hal_02::digital::v2::InputPin for ExtiInput<'d, T> {
+ type Error = Infallible;
- use super::*;
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
+ }
- impl<'d, T: GpioPin> embedded_hal_02::digital::v2::InputPin for ExtiInput<'d, T> {
- type Error = Infallible;
-
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use core::convert::Infallible;
+impl<'d, T: GpioPin> embedded_hal_1::digital::ErrorType for ExtiInput<'d, T> {
+ type Error = Infallible;
+}
- use super::*;
-
- impl<'d, T: GpioPin> embedded_hal_1::digital::ErrorType for ExtiInput<'d, T> {
- type Error = Infallible;
+impl<'d, T: GpioPin> embedded_hal_1::digital::InputPin for ExtiInput<'d, T> {
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: GpioPin> embedded_hal_1::digital::InputPin for ExtiInput<'d, T> {
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
- use super::*;
+impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for ExtiInput<'d, T> {
+ async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_high().await;
+ Ok(())
+ }
- impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for ExtiInput<'d, T> {
- async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
- self.wait_for_high().await;
- Ok(())
- }
+ async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_low().await;
+ Ok(())
+ }
- async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
- self.wait_for_low().await;
- Ok(())
- }
+ async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_rising_edge().await;
+ Ok(())
+ }
- async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_rising_edge().await;
- Ok(())
- }
+ async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_falling_edge().await;
+ Ok(())
+ }
- async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_falling_edge().await;
- Ok(())
- }
-
- async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
- self.wait_for_any_edge().await;
- Ok(())
- }
+ async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+ self.wait_for_any_edge().await;
+ Ok(())
}
}
diff --git a/embassy-stm32/src/flash/asynch.rs b/embassy-stm32/src/flash/asynch.rs
index e966e2a7..eae40c7e 100644
--- a/embassy-stm32/src/flash/asynch.rs
+++ b/embassy-stm32/src/flash/asynch.rs
@@ -55,7 +55,6 @@ impl interrupt::typelevel::Handler for Inter
}
}
-#[cfg(feature = "nightly")]
impl embedded_storage_async::nor_flash::ReadNorFlash for Flash<'_, Async> {
const READ_SIZE: usize = super::READ_SIZE;
@@ -68,7 +67,6 @@ impl embedded_storage_async::nor_flash::ReadNorFlash for Flash<'_, Async> {
}
}
-#[cfg(feature = "nightly")]
impl embedded_storage_async::nor_flash::NorFlash for Flash<'_, Async> {
const WRITE_SIZE: usize = WRITE_SIZE;
const ERASE_SIZE: usize = super::MAX_ERASE_SIZE;
@@ -158,8 +156,7 @@ foreach_flash_region! {
}
}
- #[cfg(feature = "nightly")]
- impl embedded_storage_async::nor_flash::ReadNorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
+ impl embedded_storage_async::nor_flash::ReadNorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
const READ_SIZE: usize = super::READ_SIZE;
async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
@@ -171,8 +168,7 @@ foreach_flash_region! {
}
}
- #[cfg(feature = "nightly")]
- impl embedded_storage_async::nor_flash::NorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
+ impl embedded_storage_async::nor_flash::NorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
const WRITE_SIZE: usize = $write_size;
const ERASE_SIZE: usize = $erase_size;
diff --git a/embassy-stm32/src/flash/f4.rs b/embassy-stm32/src/flash/f4.rs
index 3e5959dd..5d07020c 100644
--- a/embassy-stm32/src/flash/f4.rs
+++ b/embassy-stm32/src/flash/f4.rs
@@ -142,7 +142,6 @@ mod alt_regions {
}
}
- #[cfg(feature = "nightly")]
impl embedded_storage_async::nor_flash::ReadNorFlash for $type_name<'_, Async> {
const READ_SIZE: usize = crate::flash::READ_SIZE;
@@ -155,7 +154,6 @@ mod alt_regions {
}
}
- #[cfg(feature = "nightly")]
impl embedded_storage_async::nor_flash::NorFlash for $type_name<'_, Async> {
const WRITE_SIZE: usize = $region.write_size as usize;
const ERASE_SIZE: usize = $region.erase_size as usize;
diff --git a/embassy-stm32/src/gpio.rs b/embassy-stm32/src/gpio.rs
index 011f4c07..b863c4ff 100644
--- a/embassy-stm32/src/gpio.rs
+++ b/embassy-stm32/src/gpio.rs
@@ -772,306 +772,293 @@ pub(crate) unsafe fn init(_cs: CriticalSection) {
});
}
-mod eh02 {
- use embedded_hal_02::digital::v2::{InputPin, OutputPin, StatefulOutputPin, ToggleableOutputPin};
+impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Input<'d, T> {
+ type Error = Infallible;
- use super::*;
-
- impl<'d, T: Pin> InputPin for Input<'d, T> {
- type Error = Infallible;
-
- #[inline]
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- #[inline]
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
+ #[inline]
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> OutputPin for Output<'d, T> {
- type Error = Infallible;
-
- #[inline]
- fn set_high(&mut self) -> Result<(), Self::Error> {
- self.set_high();
- Ok(())
- }
-
- #[inline]
- fn set_low(&mut self) -> Result<(), Self::Error> {
- self.set_low();
- Ok(())
- }
- }
-
- impl<'d, T: Pin> StatefulOutputPin for Output<'d, T> {
- #[inline]
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- /// Is the output pin set as low?
- #[inline]
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> ToggleableOutputPin for Output<'d, T> {
- type Error = Infallible;
- #[inline]
- fn toggle(&mut self) -> Result<(), Self::Error> {
- self.toggle();
- Ok(())
- }
- }
-
- impl<'d, T: Pin> OutputPin for OutputOpenDrain<'d, T> {
- type Error = Infallible;
-
- #[inline]
- fn set_high(&mut self) -> Result<(), Self::Error> {
- self.set_high();
- Ok(())
- }
-
- #[inline]
- fn set_low(&mut self) -> Result<(), Self::Error> {
- self.set_low();
- Ok(())
- }
- }
-
- impl<'d, T: Pin> StatefulOutputPin for OutputOpenDrain<'d, T> {
- #[inline]
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- /// Is the output pin set as low?
- #[inline]
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> ToggleableOutputPin for OutputOpenDrain<'d, T> {
- type Error = Infallible;
- #[inline]
- fn toggle(&mut self) -> Result<(), Self::Error> {
- self.toggle();
- Ok(())
- }
- }
-
- impl<'d, T: Pin> InputPin for Flex<'d, T> {
- type Error = Infallible;
-
- #[inline]
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
-
- #[inline]
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
- }
-
- impl<'d, T: Pin> OutputPin for Flex<'d, T> {
- type Error = Infallible;
-
- #[inline]
- fn set_high(&mut self) -> Result<(), Self::Error> {
- self.set_high();
- Ok(())
- }
-
- #[inline]
- fn set_low(&mut self) -> Result<(), Self::Error> {
- self.set_low();
- Ok(())
- }
- }
-
- impl<'d, T: Pin> StatefulOutputPin for Flex<'d, T> {
- #[inline]
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
-
- /// Is the output pin set as low?
- #[inline]
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
- }
-
- impl<'d, T: Pin> ToggleableOutputPin for Flex<'d, T> {
- type Error = Infallible;
- #[inline]
- fn toggle(&mut self) -> Result<(), Self::Error> {
- self.toggle();
- Ok(())
- }
+ #[inline]
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use embedded_hal_1::digital::{ErrorType, InputPin, OutputPin, StatefulOutputPin, ToggleableOutputPin};
+impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Output<'d, T> {
+ type Error = Infallible;
- use super::*;
-
- impl<'d, T: Pin> ErrorType for Input<'d, T> {
- type Error = Infallible;
+ #[inline]
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ self.set_high();
+ Ok(())
}
- impl<'d, T: Pin> InputPin for Input<'d, T> {
- #[inline]
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
+ #[inline]
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ self.set_low();
+ Ok(())
+ }
+}
- #[inline]
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Output<'d, T> {
+ #[inline]
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
}
- impl<'d, T: Pin> ErrorType for Output<'d, T> {
- type Error = Infallible;
+ /// Is the output pin set as low?
+ #[inline]
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Output<'d, T> {
+ type Error = Infallible;
+ #[inline]
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ self.toggle();
+ Ok(())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for OutputOpenDrain<'d, T> {
+ type Error = Infallible;
+
+ #[inline]
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ self.set_high();
+ Ok(())
}
- impl<'d, T: Pin> OutputPin for Output<'d, T> {
- #[inline]
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
+ #[inline]
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ self.set_low();
+ Ok(())
+ }
+}
- #[inline]
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for OutputOpenDrain<'d, T> {
+ #[inline]
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
}
- impl<'d, T: Pin> StatefulOutputPin for Output<'d, T> {
- #[inline]
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
+ /// Is the output pin set as low?
+ #[inline]
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
- /// Is the output pin set as low?
- #[inline]
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for OutputOpenDrain<'d, T> {
+ type Error = Infallible;
+ #[inline]
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ self.toggle();
+ Ok(())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Flex<'d, T> {
+ type Error = Infallible;
+
+ #[inline]
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> ToggleableOutputPin for Output<'d, T> {
- #[inline]
- fn toggle(&mut self) -> Result<(), Self::Error> {
- Ok(self.toggle())
- }
+ #[inline]
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Flex<'d, T> {
+ type Error = Infallible;
+
+ #[inline]
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ self.set_high();
+ Ok(())
}
- impl<'d, T: Pin> ErrorType for OutputOpenDrain<'d, T> {
- type Error = Infallible;
+ #[inline]
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ self.set_low();
+ Ok(())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Flex<'d, T> {
+ #[inline]
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
}
- impl<'d, T: Pin> InputPin for OutputOpenDrain<'d, T> {
- #[inline]
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
+ /// Is the output pin set as low?
+ #[inline]
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
- #[inline]
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Flex<'d, T> {
+ type Error = Infallible;
+ #[inline]
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ self.toggle();
+ Ok(())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
+ #[inline]
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> OutputPin for OutputOpenDrain<'d, T> {
- #[inline]
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
+ #[inline]
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
- #[inline]
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
+ #[inline]
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
}
- impl<'d, T: Pin> StatefulOutputPin for OutputOpenDrain<'d, T> {
- #[inline]
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
+ #[inline]
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
- /// Is the output pin set as low?
- #[inline]
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
+ #[inline]
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
}
- impl<'d, T: Pin> ToggleableOutputPin for OutputOpenDrain<'d, T> {
- #[inline]
- fn toggle(&mut self) -> Result<(), Self::Error> {
- Ok(self.toggle())
- }
+ /// Is the output pin set as low?
+ #[inline]
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Output<'d, T> {
+ #[inline]
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ Ok(self.toggle())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d, T> {
+ #[inline]
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> InputPin for Flex<'d, T> {
- #[inline]
- fn is_high(&self) -> Result {
- Ok(self.is_high())
- }
+ #[inline]
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
- #[inline]
- fn is_low(&self) -> Result {
- Ok(self.is_low())
- }
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d, T> {
+ #[inline]
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
}
- impl<'d, T: Pin> OutputPin for Flex<'d, T> {
- #[inline]
- fn set_high(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_high())
- }
+ #[inline]
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
- #[inline]
- fn set_low(&mut self) -> Result<(), Self::Error> {
- Ok(self.set_low())
- }
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<'d, T> {
+ #[inline]
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
}
- impl<'d, T: Pin> ToggleableOutputPin for Flex<'d, T> {
- #[inline]
- fn toggle(&mut self) -> Result<(), Self::Error> {
- Ok(self.toggle())
- }
+ /// Is the output pin set as low?
+ #[inline]
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for OutputOpenDrain<'d, T> {
+ #[inline]
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ Ok(self.toggle())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
+ #[inline]
+ fn is_high(&self) -> Result {
+ Ok(self.is_high())
}
- impl<'d, T: Pin> ErrorType for Flex<'d, T> {
- type Error = Infallible;
+ #[inline]
+ fn is_low(&self) -> Result {
+ Ok(self.is_low())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
+ #[inline]
+ fn set_high(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_high())
}
- impl<'d, T: Pin> StatefulOutputPin for Flex<'d, T> {
- #[inline]
- fn is_set_high(&self) -> Result {
- Ok(self.is_set_high())
- }
+ #[inline]
+ fn set_low(&mut self) -> Result<(), Self::Error> {
+ Ok(self.set_low())
+ }
+}
- /// Is the output pin set as low?
- #[inline]
- fn is_set_low(&self) -> Result {
- Ok(self.is_set_low())
- }
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Flex<'d, T> {
+ #[inline]
+ fn toggle(&mut self) -> Result<(), Self::Error> {
+ Ok(self.toggle())
+ }
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
+ type Error = Infallible;
+}
+
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
+ #[inline]
+ fn is_set_high(&self) -> Result {
+ Ok(self.is_set_high())
+ }
+
+ /// Is the output pin set as low?
+ #[inline]
+ fn is_set_low(&self) -> Result {
+ Ok(self.is_set_low())
}
}
diff --git a/embassy-stm32/src/i2c/mod.rs b/embassy-stm32/src/i2c/mod.rs
index 19346d70..d2a50cf7 100644
--- a/embassy-stm32/src/i2c/mod.rs
+++ b/embassy-stm32/src/i2c/mod.rs
@@ -2,6 +2,7 @@
use core::marker::PhantomData;
+use crate::dma::NoDma;
use crate::interrupt;
#[cfg_attr(i2c_v1, path = "v1.rs")]
@@ -97,107 +98,92 @@ foreach_peripheral!(
};
);
-mod eh02 {
- use super::*;
+impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Read for I2c<'d, T> {
+ type Error = Error;
- impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Read for I2c<'d, T> {
- type Error = Error;
-
- fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_read(address, buffer)
- }
- }
-
- impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Write for I2c<'d, T> {
- type Error = Error;
-
- fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(address, write)
- }
- }
-
- impl<'d, T: Instance> embedded_hal_02::blocking::i2c::WriteRead for I2c<'d, T> {
- type Error = Error;
-
- fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_write_read(address, write, read)
- }
+ fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_read(address, buffer)
}
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
- use crate::dma::NoDma;
+impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Write for I2c<'d, T> {
+ type Error = Error;
- impl embedded_hal_1::i2c::Error for Error {
- fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
- match *self {
- Self::Bus => embedded_hal_1::i2c::ErrorKind::Bus,
- Self::Arbitration => embedded_hal_1::i2c::ErrorKind::ArbitrationLoss,
- Self::Nack => {
- embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Unknown)
- }
- Self::Timeout => embedded_hal_1::i2c::ErrorKind::Other,
- Self::Crc => embedded_hal_1::i2c::ErrorKind::Other,
- Self::Overrun => embedded_hal_1::i2c::ErrorKind::Overrun,
- Self::ZeroLengthTransfer => embedded_hal_1::i2c::ErrorKind::Other,
+ fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(address, write)
+ }
+}
+
+impl<'d, T: Instance> embedded_hal_02::blocking::i2c::WriteRead for I2c<'d, T> {
+ type Error = Error;
+
+ fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_write_read(address, write, read)
+ }
+}
+
+impl embedded_hal_1::i2c::Error for Error {
+ fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
+ match *self {
+ Self::Bus => embedded_hal_1::i2c::ErrorKind::Bus,
+ Self::Arbitration => embedded_hal_1::i2c::ErrorKind::ArbitrationLoss,
+ Self::Nack => {
+ embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Unknown)
}
- }
- }
-
- impl<'d, T: Instance, TXDMA, RXDMA> embedded_hal_1::i2c::ErrorType for I2c<'d, T, TXDMA, RXDMA> {
- type Error = Error;
- }
-
- impl<'d, T: Instance> embedded_hal_1::i2c::I2c for I2c<'d, T, NoDma, NoDma> {
- fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_read(address, read)
- }
-
- fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
- self.blocking_write(address, write)
- }
-
- fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
- self.blocking_write_read(address, write, read)
- }
-
- fn transaction(
- &mut self,
- _address: u8,
- _operations: &mut [embedded_hal_1::i2c::Operation<'_>],
- ) -> Result<(), Self::Error> {
- todo!();
+ Self::Timeout => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::Crc => embedded_hal_1::i2c::ErrorKind::Other,
+ Self::Overrun => embedded_hal_1::i2c::ErrorKind::Overrun,
+ Self::ZeroLengthTransfer => embedded_hal_1::i2c::ErrorKind::Other,
}
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
- use super::*;
+impl<'d, T: Instance, TXDMA, RXDMA> embedded_hal_1::i2c::ErrorType for I2c<'d, T, TXDMA, RXDMA> {
+ type Error = Error;
+}
- impl<'d, T: Instance, TXDMA: TxDma, RXDMA: RxDma> embedded_hal_async::i2c::I2c for I2c<'d, T, TXDMA, RXDMA> {
- async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
- self.read(address, read).await
- }
+impl<'d, T: Instance> embedded_hal_1::i2c::I2c for I2c<'d, T, NoDma, NoDma> {
+ fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_read(address, read)
+ }
- async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
- self.write(address, write).await
- }
+ fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+ self.blocking_write(address, write)
+ }
- async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
- self.write_read(address, write, read).await
- }
+ fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+ self.blocking_write_read(address, write, read)
+ }
- async fn transaction(
- &mut self,
- address: u8,
- operations: &mut [embedded_hal_1::i2c::Operation<'_>],
- ) -> Result<(), Self::Error> {
- let _ = address;
- let _ = operations;
- todo!()
- }
+ fn transaction(
+ &mut self,
+ _address: u8,
+ _operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+ ) -> Result<(), Self::Error> {
+ todo!();
+ }
+}
+
+impl<'d, T: Instance, TXDMA: TxDma, RXDMA: RxDma> embedded_hal_async::i2c::I2c for I2c<'d, T, TXDMA, RXDMA> {
+ async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+ self.read(address, read).await
+ }
+
+ async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+ self.write(address, write).await
+ }
+
+ async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+ self.write_read(address, write, read).await
+ }
+
+ async fn transaction(
+ &mut self,
+ address: u8,
+ operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+ ) -> Result<(), Self::Error> {
+ let _ = address;
+ let _ = operations;
+ todo!()
}
}
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index 511da917..13e189da 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -1,6 +1,5 @@
#![cfg_attr(not(test), no_std)]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![allow(async_fn_in_trait)]
//! ## Feature flags
#![doc = document_features::document_features!(feature_label = r#"{feature}"#)]
@@ -64,6 +63,8 @@ pub mod sai;
pub mod sdmmc;
#[cfg(spi)]
pub mod spi;
+#[cfg(uid)]
+pub mod uid;
#[cfg(usart)]
pub mod usart;
#[cfg(usb)]
diff --git a/embassy-stm32/src/rcc/g0.rs b/embassy-stm32/src/rcc/g0.rs
index 75613dd2..d3367b04 100644
--- a/embassy-stm32/src/rcc/g0.rs
+++ b/embassy-stm32/src/rcc/g0.rs
@@ -10,10 +10,18 @@ use crate::time::Hertz;
/// HSI speed
pub const HSI_FREQ: Hertz = Hertz(16_000_000);
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub enum HseMode {
+ /// crystal/ceramic oscillator (HSEBYP=0)
+ Oscillator,
+ /// external analog clock (low swing) (HSEBYP=1)
+ Bypass,
+}
+
/// System clock mux source
#[derive(Clone, Copy)]
pub enum ClockSrc {
- HSE(Hertz),
+ HSE(Hertz, HseMode),
HSI(HSIPrescaler),
PLL(PllConfig),
LSI,
@@ -61,7 +69,7 @@ impl Default for PllConfig {
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum PllSource {
HSI,
- HSE(Hertz),
+ HSE(Hertz, HseMode),
}
/// Clocks configutation
@@ -90,7 +98,7 @@ impl PllConfig {
pub(crate) fn init(self) -> Hertz {
let (src, input_freq) = match self.source {
PllSource::HSI => (vals::Pllsrc::HSI, HSI_FREQ),
- PllSource::HSE(freq) => (vals::Pllsrc::HSE, freq),
+ PllSource::HSE(freq, _) => (vals::Pllsrc::HSE, freq),
};
let m_freq = input_freq / self.m;
@@ -125,8 +133,11 @@ impl PllConfig {
RCC.cr().write(|w| w.set_hsion(true));
while !RCC.cr().read().hsirdy() {}
}
- PllSource::HSE(_) => {
- RCC.cr().write(|w| w.set_hseon(true));
+ PllSource::HSE(_, mode) => {
+ RCC.cr().write(|w| {
+ w.set_hsebyp(mode != HseMode::Oscillator);
+ w.set_hseon(true);
+ });
while !RCC.cr().read().hserdy() {}
}
}
@@ -177,9 +188,12 @@ pub(crate) unsafe fn init(config: Config) {
(HSI_FREQ / div, Sw::HSI)
}
- ClockSrc::HSE(freq) => {
+ ClockSrc::HSE(freq, mode) => {
// Enable HSE
- RCC.cr().write(|w| w.set_hseon(true));
+ RCC.cr().write(|w| {
+ w.set_hseon(true);
+ w.set_hsebyp(mode != HseMode::Oscillator);
+ });
while !RCC.cr().read().hserdy() {}
(freq, Sw::HSE)
diff --git a/embassy-stm32/src/rcc/h.rs b/embassy-stm32/src/rcc/h.rs
index 1a9603d0..1889eb28 100644
--- a/embassy-stm32/src/rcc/h.rs
+++ b/embassy-stm32/src/rcc/h.rs
@@ -117,6 +117,75 @@ impl From for Timpre {
}
}
+/// Power supply configuration
+/// See RM0433 Rev 4 7.4
+#[cfg(any(pwr_h7rm0399, pwr_h7rm0455, pwr_h7rm0468))]
+#[derive(PartialEq)]
+pub enum SupplyConfig {
+ /// Default power supply configuration.
+ /// V CORE Power Domains are supplied from the LDO according to VOS.
+ /// SMPS step-down converter enabled at 1.2V, may be used to supply the LDO.
+ Default,
+
+ /// Power supply configuration using the LDO.
+ /// V CORE Power Domains are supplied from the LDO according to VOS.
+ /// LDO power mode (Main, LP, Off) will follow system low-power modes.
+ /// SMPS step-down converter disabled.
+ LDO,
+
+ /// Power supply configuration directly from the SMPS step-down converter.
+ /// V CORE Power Domains are supplied from SMPS step-down converter according to VOS.
+ /// LDO bypassed.
+ /// SMPS step-down converter power mode (MR, LP, Off) will follow system low-power modes.
+ DirectSMPS,
+
+ /// Power supply configuration from the SMPS step-down converter, that supplies the LDO.
+ /// V CORE Power Domains are supplied from the LDO according to VOS
+ /// LDO power mode (Main, LP, Off) will follow system low-power modes.
+ /// SMPS step-down converter enabled according to SDLEVEL, and supplies the LDO.
+ /// SMPS step-down converter power mode (MR, LP, Off) will follow system low-power modes.
+ SMPSLDO(SMPSSupplyVoltage),
+
+ /// Power supply configuration from SMPS supplying external circuits and potentially the LDO.
+ /// V CORE Power Domains are supplied from voltage regulator according to VOS
+ /// LDO power mode (Main, LP, Off) will follow system low-power modes.
+ /// SMPS step-down converter enabled according to SDLEVEL used to supply external circuits and may supply the LDO.
+ /// SMPS step-down converter forced ON in MR mode.
+ SMPSExternalLDO(SMPSSupplyVoltage),
+
+ /// Power supply configuration from SMPS supplying external circuits and bypassing the LDO.
+ /// V CORE supplied from external source
+ /// SMPS step-down converter enabled according to SDLEVEL used to supply external circuits and may supply the external source for V CORE .
+ /// SMPS step-down converter forced ON in MR mode.
+ SMPSExternalLDOBypass(SMPSSupplyVoltage),
+
+ /// Power supply configuration from an external source, SMPS disabled and the LDO bypassed.
+ /// V CORE supplied from external source
+ /// SMPS step-down converter disabled and LDO bypassed, voltage monitoring still active.
+ SMPSDisabledLDOBypass,
+}
+
+/// SMPS step-down converter voltage output level.
+/// This is only used in certain power supply configurations:
+/// SMPSLDO, SMPSExternalLDO, SMPSExternalLDOBypass.
+#[cfg(any(pwr_h7rm0399, pwr_h7rm0455, pwr_h7rm0468))]
+#[derive(PartialEq)]
+pub enum SMPSSupplyVoltage {
+ V1_8,
+ V2_5,
+}
+
+#[cfg(any(pwr_h7rm0399, pwr_h7rm0455, pwr_h7rm0468))]
+impl SMPSSupplyVoltage {
+ /// Convert SMPSSupplyVoltage to u8 representation.
+ fn to_u8(&self) -> u8 {
+ match self {
+ SMPSSupplyVoltage::V1_8 => 0b01,
+ SMPSSupplyVoltage::V2_5 => 0b10,
+ }
+ }
+}
+
/// Configuration of the core clocks
#[non_exhaustive]
pub struct Config {
@@ -144,6 +213,9 @@ pub struct Config {
pub timer_prescaler: TimerPrescaler,
pub voltage_scale: VoltageScale,
pub ls: super::LsConfig,
+
+ #[cfg(any(pwr_h7rm0399, pwr_h7rm0455, pwr_h7rm0468))]
+ pub supply_config: SupplyConfig,
}
impl Default for Config {
@@ -177,6 +249,9 @@ impl Default for Config {
timer_prescaler: TimerPrescaler::DefaultX2,
voltage_scale: VoltageScale::Scale0,
ls: Default::default(),
+
+ #[cfg(any(pwr_h7rm0399, pwr_h7rm0455, pwr_h7rm0468))]
+ supply_config: SupplyConfig::Default,
}
}
}
@@ -195,12 +270,58 @@ pub(crate) unsafe fn init(config: Config) {
});
#[cfg(any(pwr_h7rm0399, pwr_h7rm0455, pwr_h7rm0468))]
- PWR.cr3().modify(|w| {
- // hardcode "Direct SPMS" for now, this is what works on nucleos with the
- // default solderbridge configuration.
- w.set_sden(true);
- w.set_ldoen(false);
- });
+ {
+ match config.supply_config {
+ SupplyConfig::Default => {
+ PWR.cr3().modify(|w| {
+ w.set_sdlevel(0b00);
+ w.set_sdexthp(false);
+ w.set_sden(true);
+ w.set_ldoen(true);
+ w.set_bypass(false);
+ });
+ }
+ SupplyConfig::LDO => {
+ PWR.cr3().modify(|w| {
+ w.set_sden(false);
+ w.set_ldoen(true);
+ w.set_bypass(false);
+ });
+ }
+ SupplyConfig::DirectSMPS => {
+ PWR.cr3().modify(|w| {
+ w.set_sdexthp(false);
+ w.set_sden(true);
+ w.set_ldoen(false);
+ w.set_bypass(false);
+ });
+ }
+ SupplyConfig::SMPSLDO(ref smps_supply_voltage)
+ | SupplyConfig::SMPSExternalLDO(ref smps_supply_voltage)
+ | SupplyConfig::SMPSExternalLDOBypass(ref smps_supply_voltage) => {
+ PWR.cr3().modify(|w| {
+ w.set_sdlevel(smps_supply_voltage.to_u8());
+ w.set_sdexthp(matches!(
+ config.supply_config,
+ SupplyConfig::SMPSExternalLDO(_) | SupplyConfig::SMPSExternalLDOBypass(_)
+ ));
+ w.set_sden(true);
+ w.set_ldoen(matches!(
+ config.supply_config,
+ SupplyConfig::SMPSLDO(_) | SupplyConfig::SMPSExternalLDO(_)
+ ));
+ w.set_bypass(matches!(config.supply_config, SupplyConfig::SMPSExternalLDOBypass(_)));
+ });
+ }
+ SupplyConfig::SMPSDisabledLDOBypass => {
+ PWR.cr3().modify(|w| {
+ w.set_sden(false);
+ w.set_ldoen(false);
+ w.set_bypass(true);
+ });
+ }
+ }
+ }
// Validate the supply configuration. If you are stuck here, it is
// because the voltages on your board do not match those specified
diff --git a/embassy-stm32/src/rtc/datetime.rs b/embassy-stm32/src/rtc/datetime.rs
index f3428108..f4e86dd8 100644
--- a/embassy-stm32/src/rtc/datetime.rs
+++ b/embassy-stm32/src/rtc/datetime.rs
@@ -211,7 +211,7 @@ pub enum DayOfWeek {
#[cfg(feature = "chrono")]
impl From for DayOfWeek {
fn from(weekday: Weekday) -> Self {
- day_of_week_from_u8(weekday.num_days_from_monday() as u8).unwrap()
+ day_of_week_from_u8(weekday.number_from_monday() as u8).unwrap()
}
}
diff --git a/embassy-stm32/src/spi/mod.rs b/embassy-stm32/src/spi/mod.rs
index c18b7961..2319fada 100644
--- a/embassy-stm32/src/spi/mod.rs
+++ b/embassy-stm32/src/spi/mod.rs
@@ -951,102 +951,88 @@ fn transfer_word(regs: Regs, tx_word: W) -> Result {
Ok(rx_word)
}
-mod eh02 {
- use super::*;
+// Note: It is not possible to impl these traits generically in embedded-hal 0.2 due to a conflict with
+// some marker traits. For details, see https://github.com/rust-embedded/embedded-hal/pull/289
+macro_rules! impl_blocking {
+ ($w:ident) => {
+ impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Write<$w> for Spi<'d, T, Tx, Rx> {
+ type Error = Error;
- // Note: It is not possible to impl these traits generically in embedded-hal 0.2 due to a conflict with
- // some marker traits. For details, see https://github.com/rust-embedded/embedded-hal/pull/289
- macro_rules! impl_blocking {
- ($w:ident) => {
- impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Write<$w> for Spi<'d, T, Tx, Rx> {
- type Error = Error;
-
- fn write(&mut self, words: &[$w]) -> Result<(), Self::Error> {
- self.blocking_write(words)
- }
+ fn write(&mut self, words: &[$w]) -> Result<(), Self::Error> {
+ self.blocking_write(words)
}
+ }
- impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Transfer<$w> for Spi<'d, T, Tx, Rx> {
- type Error = Error;
+ impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Transfer<$w> for Spi<'d, T, Tx, Rx> {
+ type Error = Error;
- fn transfer<'w>(&mut self, words: &'w mut [$w]) -> Result<&'w [$w], Self::Error> {
- self.blocking_transfer_in_place(words)?;
- Ok(words)
- }
+ fn transfer<'w>(&mut self, words: &'w mut [$w]) -> Result<&'w [$w], Self::Error> {
+ self.blocking_transfer_in_place(words)?;
+ Ok(words)
}
- };
- }
-
- impl_blocking!(u8);
- impl_blocking!(u16);
+ }
+ };
}
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
- use super::*;
+impl_blocking!(u8);
+impl_blocking!(u16);
- impl<'d, T: Instance, Tx, Rx> embedded_hal_1::spi::ErrorType for Spi<'d, T, Tx, Rx> {
- type Error = Error;
+impl<'d, T: Instance, Tx, Rx> embedded_hal_1::spi::ErrorType for Spi<'d, T, Tx, Rx> {
+ type Error = Error;
+}
+
+impl<'d, T: Instance, W: Word, Tx, Rx> embedded_hal_1::spi::SpiBus for Spi<'d, T, Tx, Rx> {
+ fn flush(&mut self) -> Result<(), Self::Error> {
+ Ok(())
}
- impl<'d, T: Instance, W: Word, Tx, Rx> embedded_hal_1::spi::SpiBus for Spi<'d, T, Tx, Rx> {
- fn flush(&mut self) -> Result<(), Self::Error> {
- Ok(())
- }
-
- fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
- self.blocking_read(words)
- }
-
- fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
- self.blocking_write(words)
- }
-
- fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
- self.blocking_transfer(read, write)
- }
-
- fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
- self.blocking_transfer_in_place(words)
- }
+ fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+ self.blocking_read(words)
}
- impl embedded_hal_1::spi::Error for Error {
- fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
- match *self {
- Self::Framing => embedded_hal_1::spi::ErrorKind::FrameFormat,
- Self::Crc => embedded_hal_1::spi::ErrorKind::Other,
- Self::ModeFault => embedded_hal_1::spi::ErrorKind::ModeFault,
- Self::Overrun => embedded_hal_1::spi::ErrorKind::Overrun,
- }
+ fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
+ self.blocking_write(words)
+ }
+
+ fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
+ self.blocking_transfer(read, write)
+ }
+
+ fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+ self.blocking_transfer_in_place(words)
+ }
+}
+
+impl embedded_hal_1::spi::Error for Error {
+ fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
+ match *self {
+ Self::Framing => embedded_hal_1::spi::ErrorKind::FrameFormat,
+ Self::Crc => embedded_hal_1::spi::ErrorKind::Other,
+ Self::ModeFault => embedded_hal_1::spi::ErrorKind::ModeFault,
+ Self::Overrun => embedded_hal_1::spi::ErrorKind::Overrun,
}
}
}
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
- use super::*;
+impl<'d, T: Instance, Tx: TxDma, Rx: RxDma, W: Word> embedded_hal_async::spi::SpiBus for Spi<'d, T, Tx, Rx> {
+ async fn flush(&mut self) -> Result<(), Self::Error> {
+ Ok(())
+ }
- impl<'d, T: Instance, Tx: TxDma, Rx: RxDma, W: Word> embedded_hal_async::spi::SpiBus for Spi<'d, T, Tx, Rx> {
- async fn flush(&mut self) -> Result<(), Self::Error> {
- Ok(())
- }
+ async fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
+ self.write(words).await
+ }
- async fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
- self.write(words).await
- }
+ async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+ self.read(words).await
+ }
- async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
- self.read(words).await
- }
+ async fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
+ self.transfer(read, write).await
+ }
- async fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
- self.transfer(read, write).await
- }
-
- async fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
- self.transfer_in_place(words).await
- }
+ async fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+ self.transfer_in_place(words).await
}
}
diff --git a/embassy-stm32/src/time_driver.rs b/embassy-stm32/src/time_driver.rs
index 564c9d08..e2a4cc4d 100644
--- a/embassy-stm32/src/time_driver.rs
+++ b/embassy-stm32/src/time_driver.rs
@@ -18,6 +18,17 @@ use crate::rtc::Rtc;
use crate::timer::sealed::{Basic16bitInstance as BasicInstance, GeneralPurpose16bitInstance as Instance};
use crate::{interrupt, peripherals};
+// NOTE regarding ALARM_COUNT:
+//
+// As of 2023-12-04, this driver is implemented using CC1 as the halfway rollover interrupt, and any
+// additional CC capabilities to provide timer alarms to embassy-time. embassy-time requires AT LEAST
+// one alarm to be allocatable, which means timers that only have CC1, such as TIM16/TIM17, are not
+// candidates for use as an embassy-time driver provider.
+//
+// The values of ALARM_COUNT below are not the TOTAL CC registers available, but rather the number
+// available after reserving CC1 for regular time keeping. For example, TIM2 has four CC registers:
+// CC1, CC2, CC3, and CC4, so it can provide ALARM_COUNT = 3.
+
#[cfg(not(any(time_driver_tim12, time_driver_tim15)))]
const ALARM_COUNT: usize = 3;
diff --git a/embassy-stm32/src/timer/mod.rs b/embassy-stm32/src/timer/mod.rs
index 913bfed2..2313a5b9 100644
--- a/embassy-stm32/src/timer/mod.rs
+++ b/embassy-stm32/src/timer/mod.rs
@@ -46,7 +46,10 @@ pub(crate) mod sealed {
assert!(f > 0);
let pclk_ticks_per_timer_period = timer_f / f;
let psc: u16 = unwrap!(((pclk_ticks_per_timer_period - 1) / (1 << 16)).try_into());
- let arr: u16 = unwrap!((pclk_ticks_per_timer_period / (u32::from(psc) + 1)).try_into());
+ let divide_by = pclk_ticks_per_timer_period / (u32::from(psc) + 1);
+
+ // the timer counts `0..=arr`, we want it to count `0..divide_by`
+ let arr = unwrap!(u16::try_from(divide_by - 1));
let regs = Self::regs();
regs.psc().write(|r| r.set_psc(psc));
diff --git a/embassy-stm32/src/uid.rs b/embassy-stm32/src/uid.rs
new file mode 100644
index 00000000..6dcfcb96
--- /dev/null
+++ b/embassy-stm32/src/uid.rs
@@ -0,0 +1,29 @@
+/// Get this device's unique 96-bit ID.
+pub fn uid() -> &'static [u8; 12] {
+ unsafe { &*crate::pac::UID.uid(0).as_ptr().cast::<[u8; 12]>() }
+}
+
+/// Get this device's unique 96-bit ID, encoded into a string of 24 hexadecimal ASCII digits.
+pub fn uid_hex() -> &'static str {
+ unsafe { core::str::from_utf8_unchecked(uid_hex_bytes()) }
+}
+
+/// Get this device's unique 96-bit ID, encoded into 24 hexadecimal ASCII bytes.
+pub fn uid_hex_bytes() -> &'static [u8; 24] {
+ const HEX: &[u8; 16] = b"0123456789ABCDEF";
+ static mut UID_HEX: [u8; 24] = [0; 24];
+ static mut LOADED: bool = false;
+ critical_section::with(|_| unsafe {
+ if !LOADED {
+ let uid = uid();
+ for (idx, v) in uid.iter().enumerate() {
+ let lo = v & 0x0f;
+ let hi = (v & 0xf0) >> 4;
+ UID_HEX[idx * 2] = HEX[hi as usize];
+ UID_HEX[idx * 2 + 1] = HEX[lo as usize];
+ }
+ LOADED = true;
+ }
+ });
+ unsafe { &UID_HEX }
+}
diff --git a/embassy-stm32/src/usart/buffered.rs b/embassy-stm32/src/usart/buffered.rs
index 4daddfe9..a2e4ceaa 100644
--- a/embassy-stm32/src/usart/buffered.rs
+++ b/embassy-stm32/src/usart/buffered.rs
@@ -560,172 +560,120 @@ impl<'d, T: BasicInstance> embedded_io::Write for BufferedUartTx<'d, T> {
}
}
-mod eh02 {
- use super::*;
+impl<'d, T: BasicInstance> embedded_hal_02::serial::Read for BufferedUartRx<'d, T> {
+ type Error = Error;
- impl<'d, T: BasicInstance> embedded_hal_02::serial::Read for BufferedUartRx<'d, T> {
- type Error = Error;
-
- fn read(&mut self) -> Result> {
- let r = T::regs();
- unsafe {
- let sr = sr(r).read();
- if sr.pe() {
- rdr(r).read_volatile();
- Err(nb::Error::Other(Error::Parity))
- } else if sr.fe() {
- rdr(r).read_volatile();
- Err(nb::Error::Other(Error::Framing))
- } else if sr.ne() {
- rdr(r).read_volatile();
- Err(nb::Error::Other(Error::Noise))
- } else if sr.ore() {
- rdr(r).read_volatile();
- Err(nb::Error::Other(Error::Overrun))
- } else if sr.rxne() {
- Ok(rdr(r).read_volatile())
- } else {
- Err(nb::Error::WouldBlock)
- }
+ fn read(&mut self) -> Result> {
+ let r = T::regs();
+ unsafe {
+ let sr = sr(r).read();
+ if sr.pe() {
+ rdr(r).read_volatile();
+ Err(nb::Error::Other(Error::Parity))
+ } else if sr.fe() {
+ rdr(r).read_volatile();
+ Err(nb::Error::Other(Error::Framing))
+ } else if sr.ne() {
+ rdr(r).read_volatile();
+ Err(nb::Error::Other(Error::Noise))
+ } else if sr.ore() {
+ rdr(r).read_volatile();
+ Err(nb::Error::Other(Error::Overrun))
+ } else if sr.rxne() {
+ Ok(rdr(r).read_volatile())
+ } else {
+ Err(nb::Error::WouldBlock)
}
}
}
-
- impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write for BufferedUartTx<'d, T> {
- type Error = Error;
-
- fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
- while !buffer.is_empty() {
- match self.blocking_write(buffer) {
- Ok(0) => panic!("zero-length write."),
- Ok(n) => buffer = &buffer[n..],
- Err(e) => return Err(e),
- }
- }
- Ok(())
- }
-
- fn bflush(&mut self) -> Result<(), Self::Error> {
- self.blocking_flush()
- }
- }
-
- impl<'d, T: BasicInstance> embedded_hal_02::serial::Read for BufferedUart<'d, T> {
- type Error = Error;
-
- fn read(&mut self) -> Result> {
- embedded_hal_02::serial::Read::read(&mut self.rx)
- }
- }
-
- impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write