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

Split embassy crate into embassy-executor, embassy-util.

Browse Source
This commit is contained in:
Dario Nieuwenhuis
2022-07-29 21:58:35 +02:00
parent 8745d646f0
commit a0f1b0ee01
319 changed files with 1159 additions and 998 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
examples/boot/application/nrf/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-nrf-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util" }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly"] }
embassy-nrf = { version = "0.1.0", path = "../../../../embassy-nrf", features = ["time-driver-rtc1", "gpiote", "nightly", "nrf52840"] }
embassy-boot-nrf = { version = "0.1.0", path = "../../../../embassy-boot/nrf" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

4
examples/boot/application/nrf/src/bin/a.rs
View File

@ -13,8 +13,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let mut button = Input::new(p.P0_11, Pull::Up);
let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
//let mut led = Output::new(p.P1_10, Level::Low, OutputDrive::Standard);

6
examples/boot/application/nrf/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#![feature(generic_associated_types)]
#![feature(type_alias_impl_trait)]
use embassy::time::{Duration, Timer};
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::gpio::{Level, Output, OutputDrive};
use embassy_nrf::Peripherals;
use panic_reset as _;
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
//let mut led = Output::new(p.P1_10, Level::Low, OutputDrive::Standard);

3
examples/boot/application/stm32f3/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32f3-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32f303re", "time-driver-any", "exti"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

4
examples/boot/application/stm32f3/src/bin/a.rs
View File

@ -14,8 +14,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32f3/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PA5, Level::High, Speed::Low);

3
examples/boot/application/stm32f7/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32f7-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32f767zi", "time-driver-any", "exti"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

4
examples/boot/application/stm32f7/src/bin/a.rs
View File

@ -14,8 +14,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32f7/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
Timer::after(Duration::from_millis(300)).await;
let mut led = Output::new(p.PB7, Level::High, Speed::Low);

3
examples/boot/application/stm32h7/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32h7-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32h743zi", "time-driver-any", "exti"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

4
examples/boot/application/stm32h7/src/bin/a.rs
View File

@ -14,8 +14,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32h7/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
Timer::after(Duration::from_millis(300)).await;
let mut led = Output::new(p.PB14, Level::High, Speed::Low);

3
examples/boot/application/stm32l0/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32l0-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32l072cz", "time-driver-any", "exti", "memory-x"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

6
examples/boot/application/stm32l0/src/bin/a.rs
View File

@ -4,9 +4,9 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::time::{Duration, Timer};
use embassy_boot_stm32::FirmwareUpdater;
use embassy_embedded_hal::adapter::BlockingAsync;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::exti::ExtiInput;
use embassy_stm32::flash::Flash;
use embassy_stm32::gpio::{Input, Level, Output, Pull, Speed};
@ -15,8 +15,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32l0/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PB6, Level::High, Speed::Low);

3
examples/boot/application/stm32l1/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32l1-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32l151cb-a", "time-driver-any", "exti"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

6
examples/boot/application/stm32l1/src/bin/a.rs
View File

@ -4,9 +4,9 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::time::{Duration, Timer};
use embassy_boot_stm32::FirmwareUpdater;
use embassy_embedded_hal::adapter::BlockingAsync;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::exti::ExtiInput;
use embassy_stm32::flash::Flash;
use embassy_stm32::gpio::{Input, Level, Output, Pull, Speed};
@ -15,8 +15,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32l1/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PB6, Level::High, Speed::Low);

3
examples/boot/application/stm32l4/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32l4-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32l475vg", "time-driver-any", "exti"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

4
examples/boot/application/stm32l4/src/bin/a.rs
View File

@ -14,8 +14,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32l4/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PA5, Level::High, Speed::Low);

3
examples/boot/application/stm32wl/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-boot-stm32wl-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../../../embassy", features = ["nightly", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../../../embassy-executor", features = ["nightly", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../../../embassy-stm32", features = ["unstable-traits", "nightly", "stm32wl55jc-cm4", "time-driver-any", "exti"] }
embassy-boot-stm32 = { version = "0.1.0", path = "../../../../embassy-boot/stm32" }
embassy-embedded-hal = { version = "0.1.0", path = "../../../../embassy-embedded-hal" }

4
examples/boot/application/stm32wl/src/bin/a.rs
View File

@ -14,8 +14,8 @@ use panic_reset as _;
static APP_B: &[u8] = include_bytes!("../../b.bin");
#[embassy::main]
async fn main(_s: embassy::executor::Spawner, p: Peripherals) {
#[embassy_executor::main]
async fn main(_s: embassy_executor::executor::Spawner, p: Peripherals) {
let flash = Flash::unlock(p.FLASH);
let mut flash = BlockingAsync::new(flash);

6
examples/boot/application/stm32wl/src/bin/b.rs
View File

@ -4,13 +4,13 @@
#[cfg(feature = "defmt-rtt")]
use defmt_rtt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use panic_reset as _;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PB15, Level::High, Speed::Low);

1
examples/boot/bootloader/nrf/Cargo.toml
View File

@ -8,7 +8,6 @@ description = "Bootloader for nRF chips"
defmt = { version = "0.3", optional = true }
defmt-rtt = { version = "0.3", optional = true }
embassy = { path = "../../../../embassy", default-features = false }
embassy-nrf = { path = "../../../../embassy-nrf", default-features = false, features = ["nightly"] }
embassy-boot-nrf = { path = "../../../../embassy-boot/nrf", default-features = false }
cortex-m = { version = "0.7" }

1
examples/boot/bootloader/stm32/Cargo.toml
View File

@ -8,7 +8,6 @@ description = "Example bootloader for STM32 chips"
defmt = { version = "0.3", optional = true }
defmt-rtt = { version = "0.3", optional = true }
embassy = { path = "../../../../embassy", default-features = false }
embassy-stm32 = { path = "../../../../embassy-stm32", default-features = false, features = ["nightly"] }
embassy-boot-stm32 = { path = "../../../../embassy-boot/stm32", default-features = false }
cortex-m = { version = "0.7" }

5
examples/nrf/Cargo.toml
View File

@ -5,10 +5,11 @@ version = "0.1.0"
[features]
default = ["nightly"]
nightly = ["embassy-nrf/nightly", "embassy-nrf/unstable-traits", "embassy-usb", "embassy-usb-serial", "embassy-usb-hid", "embassy-usb-ncm", "embedded-io/async", "embassy-net"]
nightly = ["embassy-executor/nightly", "embassy-nrf/nightly", "embassy-nrf/unstable-traits", "embassy-usb", "embassy-usb-serial", "embassy-usb-hid", "embassy-usb-ncm", "embedded-io/async", "embassy-net"]
[dependencies]
embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["defmt", "defmt-timestamp-uptime"] }
embassy-nrf = { version = "0.1.0", path = "../../embassy-nrf", features = ["defmt", "nrf52840", "time-driver-rtc1", "gpiote", "unstable-pac"] }
embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet", "pool-16"], optional = true }
embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"], optional = true }

4
examples/nrf/src/bin/awaitable_timer.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::timer::Timer;
use embassy_nrf::{interrupt, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut t = Timer::new_awaitable(p.TIMER0, interrupt::take!(TIMER0));
// default frequency is 1MHz, so this triggers every second

6
examples/nrf/src/bin/blinky.rs
View File

@ -2,13 +2,13 @@
#![no_main]
#![feature(type_alias_impl_trait)]
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::gpio::{Level, Output, OutputDrive};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);

4
examples/nrf/src/bin/buffered_uart.rs
View File

@ -3,14 +3,14 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::buffered_uarte::{BufferedUarte, State};
use embassy_nrf::{interrupt, uarte, Peripherals};
use embedded_io::asynch::{BufRead, Write};
use futures::pin_mut;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut config = uarte::Config::default();
config.parity = uarte::Parity::EXCLUDED;

12
examples/nrf/src/bin/channel.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::unwrap;
use embassy::blocking_mutex::raw::ThreadModeRawMutex;
use embassy::channel::mpmc::Channel;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::gpio::{Level, Output, OutputDrive};
use embassy_nrf::Peripherals;
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_util::channel::mpmc::Channel;
use {defmt_rtt as _, panic_probe as _};
enum LedState {
@ -18,7 +18,7 @@ enum LedState {
static CHANNEL: Channel<ThreadModeRawMutex, LedState, 1> = Channel::new();
#[embassy::task]
#[embassy_executor::task]
async fn my_task() {
loop {
CHANNEL.send(LedState::On).await;
@ -28,7 +28,7 @@ async fn my_task() {
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);

16
examples/nrf/src/bin/channel_sender_receiver.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::unwrap;
use embassy::blocking_mutex::raw::NoopRawMutex;
use embassy::channel::mpmc::{Channel, Receiver, Sender};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy::util::Forever;
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
use embassy_nrf::Peripherals;
use embassy_util::blocking_mutex::raw::NoopRawMutex;
use embassy_util::channel::mpmc::{Channel, Receiver, Sender};
use embassy_util::Forever;
use {defmt_rtt as _, panic_probe as _};
enum LedState {
@ -19,7 +19,7 @@ enum LedState {
static CHANNEL: Forever<Channel<NoopRawMutex, LedState, 1>> = Forever::new();
#[embassy::task]
#[embassy_executor::task]
async fn send_task(sender: Sender<'static, NoopRawMutex, LedState, 1>) {
loop {
sender.send(LedState::On).await;
@ -29,7 +29,7 @@ async fn send_task(sender: Sender<'static, NoopRawMutex, LedState, 1>) {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn recv_task(led: AnyPin, receiver: Receiver<'static, NoopRawMutex, LedState, 1>) {
let mut led = Output::new(led, Level::Low, OutputDrive::Standard);
@ -41,7 +41,7 @@ async fn recv_task(led: AnyPin, receiver: Receiver<'static, NoopRawMutex, LedSta
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
let channel = CHANNEL.put(Channel::new());

12
examples/nrf/src/bin/executor_fairness_test.rs
View File

@ -5,12 +5,12 @@
use core::task::Poll;
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy::time::{Duration, Instant, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Instant, Timer};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task]
#[embassy_executor::task]
async fn run1() {
loop {
info!("DING DONG");
@ -18,14 +18,14 @@ async fn run1() {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run2() {
loop {
Timer::at(Instant::from_ticks(0)).await;
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run3() {
futures::future::poll_fn(|cx| {
cx.waker().wake_by_ref();
@ -34,7 +34,7 @@ async fn run3() {
.await;
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, _p: Peripherals) {
unwrap!(spawner.spawn(run1()));
unwrap!(spawner.spawn(run2()));

4
examples/nrf/src/bin/gpiote_channel.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{Input, Pull};
use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Starting!");

6
examples/nrf/src/bin/gpiote_port.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{AnyPin, Input, Pin as _, Pull};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task(pool_size = 4)]
#[embassy_executor::task(pool_size = 4)]
async fn button_task(n: usize, mut pin: Input<'static, AnyPin>) {
loop {
pin.wait_for_low().await;
@ -18,7 +18,7 @@ async fn button_task(n: usize, mut pin: Input<'static, AnyPin>) {
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
info!("Starting!");

10
examples/nrf/src/bin/multiprio.rs
View File

@ -59,14 +59,14 @@
use cortex_m_rt::entry;
use defmt::{info, unwrap};
use embassy::time::{Duration, Instant, Timer};
use embassy::util::Forever;
use embassy_executor::time::{Duration, Instant, Timer};
use embassy_nrf::executor::{Executor, InterruptExecutor};
use embassy_nrf::interrupt;
use embassy_nrf::interrupt::InterruptExt;
use embassy_util::Forever;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task]
#[embassy_executor::task]
async fn run_high() {
loop {
info!(" [high] tick!");
@ -74,7 +74,7 @@ async fn run_high() {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run_med() {
loop {
let start = Instant::now();
@ -91,7 +91,7 @@ async fn run_med() {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run_low() {
loop {
let start = Instant::now();

12
examples/nrf/src/bin/mutex.rs
View File

@ -3,16 +3,16 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::blocking_mutex::raw::ThreadModeRawMutex;
use embassy::executor::Spawner;
use embassy::mutex::Mutex;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::Peripherals;
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_util::mutex::Mutex;
use {defmt_rtt as _, panic_probe as _};
static MUTEX: Mutex<ThreadModeRawMutex, u32> = Mutex::new(0);
#[embassy::task]
#[embassy_executor::task]
async fn my_task() {
loop {
{
@ -29,7 +29,7 @@ async fn my_task() {
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, _p: Peripherals) {
unwrap!(spawner.spawn(my_task()));

6
examples/nrf/src/bin/nvmc.rs
View File

@ -3,14 +3,14 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::nvmc::Nvmc;
use embassy_nrf::Peripherals;
use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello NVMC!");

4
examples/nrf/src/bin/ppi.rs
View File

@ -5,7 +5,7 @@
use core::future::pending;
use defmt::info;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
use embassy_nrf::gpiote::{self, InputChannel, InputChannelPolarity};
use embassy_nrf::ppi::Ppi;
@ -13,7 +13,7 @@ use embassy_nrf::Peripherals;
use gpiote::{OutputChannel, OutputChannelPolarity};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Starting!");

16
examples/nrf/src/bin/pubsub.rs
View File

@ -3,10 +3,10 @@
#![feature(type_alias_impl_trait)]
use defmt::unwrap;
use embassy::blocking_mutex::raw::ThreadModeRawMutex;
use embassy::channel::pubsub::{DynSubscriber, PubSubChannel, Subscriber};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_util::channel::pubsub::{DynSubscriber, PubSubChannel, Subscriber};
use {defmt_rtt as _, panic_probe as _};
/// Create the message bus. It has a queue of 4, supports 3 subscribers and 1 publisher
@ -19,7 +19,7 @@ enum Message {
C,
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, _p: embassy_nrf::Peripherals) {
defmt::info!("Hello World!");
@ -64,7 +64,7 @@ async fn main(spawner: Spawner, _p: embassy_nrf::Peripherals) {
/// A logger task that just awaits the messages it receives
///
/// This takes the generic `Subscriber`. This is most performant, but requires you to write down all of the generics
#[embassy::task]
#[embassy_executor::task]
async fn fast_logger(mut messages: Subscriber<'static, ThreadModeRawMutex, Message, 4, 3, 1>) {
loop {
let message = messages.next_message().await;
@ -76,7 +76,7 @@ async fn fast_logger(mut messages: Subscriber<'static, ThreadModeRawMutex, Messa
/// Because of this, depeding on how the messages were published, the subscriber might miss some messages
///
/// This takes the dynamic `DynSubscriber`. This is not as performant as the generic version, but let's you ignore some of the generics
#[embassy::task]
#[embassy_executor::task]
async fn slow_logger(mut messages: DynSubscriber<'static, Message>) {
loop {
// Do some work
@ -93,7 +93,7 @@ async fn slow_logger(mut messages: DynSubscriber<'static, Message>) {
}
/// Same as `slow_logger` but it ignores lag results
#[embassy::task]
#[embassy_executor::task]
async fn slow_logger_pure(mut messages: DynSubscriber<'static, Message>) {
loop {
// Do some work

6
examples/nrf/src/bin/pwm.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::pwm::{Prescaler, SimplePwm};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
@ -70,7 +70,7 @@ static DUTY: [u16; 1024] = [
7255, 7331, 7407, 7484, 7561, 7638, 7716, 7794, 7873, 7952, 8031, 8111,
];
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut pwm = SimplePwm::new_4ch(p.PWM0, p.P0_13, p.P0_14, p.P0_16, p.P0_15);
pwm.set_prescaler(Prescaler::Div1);

6
examples/nrf/src/bin/pwm_double_sequence.rs
View File

@ -3,15 +3,15 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::pwm::{
Config, Prescaler, Sequence, SequenceConfig, SequenceMode, SequencePwm, Sequencer, StartSequence,
};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let seq_words_0: [u16; 5] = [1000, 250, 100, 50, 0];
let seq_words_1: [u16; 4] = [50, 100, 250, 1000];

6
examples/nrf/src/bin/pwm_sequence.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::pwm::{Config, Prescaler, SequenceConfig, SequencePwm, SingleSequenceMode, SingleSequencer};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let seq_words: [u16; 5] = [1000, 250, 100, 50, 0];

4
examples/nrf/src/bin/pwm_sequence_ppi.rs
View File

@ -5,7 +5,7 @@
use core::future::pending;
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{Input, Pull};
use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
use embassy_nrf::ppi::Ppi;
@ -13,7 +13,7 @@ use embassy_nrf::pwm::{Config, Prescaler, SequenceConfig, SequencePwm, SingleSeq
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let seq_words: [u16; 5] = [1000, 250, 100, 50, 0];

6
examples/nrf/src/bin/pwm_sequence_ws2812b.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::pwm::{
Config, Prescaler, SequenceConfig, SequenceLoad, SequencePwm, SingleSequenceMode, SingleSequencer,
};
@ -26,7 +26,7 @@ const RES: u16 = 0x8000;
// Provides data to a WS2812b (Neopixel) LED and makes it go blue. The data
// line is assumed to be P1_05.
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut config = Config::default();
config.sequence_load = SequenceLoad::Common;

6
examples/nrf/src/bin/pwm_servo.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::pwm::{Prescaler, SimplePwm};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut pwm = SimplePwm::new_1ch(p.PWM0, p.P0_05);
// sg90 microervo requires 50hz or 20ms period

4
examples/nrf/src/bin/qdec.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::qdec::{self, Qdec};
use embassy_nrf::{interrupt, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let irq = interrupt::take!(QDEC);
let config = qdec::Config::default();

4
examples/nrf/src/bin/qspi.rs
View File

@ -3,7 +3,7 @@
#![feature(type_alias_impl_trait)]
use defmt::{assert_eq, info, unwrap};
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::{interrupt, qspi, Peripherals};
use {defmt_rtt as _, panic_probe as _};
@ -14,7 +14,7 @@ const PAGE_SIZE: usize = 4096;
#[repr(C, align(4))]
struct AlignedBuf([u8; 4096]);
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
// Config for the MX25R64 present in the nRF52840 DK
let mut config = qspi::Config::default();

6
examples/nrf/src/bin/qspi_lowpower.rs
View File

@ -5,8 +5,8 @@
use core::mem;
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::{interrupt, qspi, Peripherals};
use {defmt_rtt as _, panic_probe as _};
@ -15,7 +15,7 @@ use {defmt_rtt as _, panic_probe as _};
#[repr(C, align(4))]
struct AlignedBuf([u8; 64]);
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, mut p: Peripherals) {
let mut irq = interrupt::take!(QSPI);

8
examples/nrf/src/bin/raw_spawn.rs
View File

@ -5,10 +5,10 @@ use core::mem;
use cortex_m_rt::entry;
use defmt::{info, unwrap};
use embassy::executor::raw::TaskStorage;
use embassy::executor::Executor;
use embassy::time::{Duration, Timer};
use embassy::util::Forever;
use embassy_executor::executor::raw::TaskStorage;
use embassy_executor::executor::Executor;
use embassy_executor::time::{Duration, Timer};
use embassy_util::Forever;
use {defmt_rtt as _, panic_probe as _};
async fn run1() {

4
examples/nrf/src/bin/rng.rs
View File

@ -2,13 +2,13 @@
#![no_main]
#![feature(type_alias_impl_trait)]
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::rng::Rng;
use embassy_nrf::{interrupt, Peripherals};
use rand::Rng as _;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut rng = Rng::new(p.RNG, interrupt::take!(RNG));

6
examples/nrf/src/bin/saadc.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::saadc::{ChannelConfig, Config, Saadc};
use embassy_nrf::{interrupt, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, mut p: Peripherals) {
let config = Config::default();
let channel_config = ChannelConfig::single_ended(&mut p.P0_02);

8
examples/nrf/src/bin/saadc_continuous.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy::time::Duration;
use embassy_executor::executor::Spawner;
use embassy_executor::time::Duration;
use embassy_nrf::saadc::{ChannelConfig, Config, Saadc, SamplerState};
use embassy_nrf::timer::Frequency;
use embassy_nrf::{interrupt, Peripherals};
@ -12,7 +12,7 @@ use {defmt_rtt as _, panic_probe as _};
// Demonstrates both continuous sampling and scanning multiple channels driven by a PPI linked timer
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, mut p: Peripherals) {
let config = Config::default();
let channel_1_config = ChannelConfig::single_ended(&mut p.P0_02);
@ -27,7 +27,7 @@ async fn main(_spawner: Spawner, mut p: Peripherals) {
// This delay demonstrates that starting the timer prior to running
// the task sampler is benign given the calibration that follows.
embassy::time::Timer::after(Duration::from_millis(500)).await;
embassy_executor::time::Timer::after(Duration::from_millis(500)).await;
saadc.calibrate().await;
let mut bufs = [[[0; 3]; 500]; 2];

8
examples/nrf/src/bin/self_spawn.rs
View File

@ -3,19 +3,19 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task(pool_size = 2)]
#[embassy_executor::task(pool_size = 2)]
async fn my_task(spawner: Spawner, n: u32) {
Timer::after(Duration::from_secs(1)).await;
info!("Spawning self! {}", n);
unwrap!(spawner.spawn(my_task(spawner, n + 1)));
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, _p: Peripherals) {
info!("Hello World!");
unwrap!(spawner.spawn(my_task(spawner, 0)));

8
examples/nrf/src/bin/self_spawn_current_executor.rs
View File

@ -3,19 +3,19 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task(pool_size = 2)]
#[embassy_executor::task(pool_size = 2)]
async fn my_task(n: u32) {
Timer::after(Duration::from_secs(1)).await;
info!("Spawning self! {}", n);
unwrap!(Spawner::for_current_executor().await.spawn(my_task(n + 1)));
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, _p: Peripherals) {
info!("Hello World!");
unwrap!(spawner.spawn(my_task(0)));

4
examples/nrf/src/bin/spim.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{Level, Output, OutputDrive};
use embassy_nrf::{interrupt, spim, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("running!");

6
examples/nrf/src/bin/temp.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::temp::Temp;
use embassy_nrf::{interrupt, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let irq = interrupt::take!(TEMP);
let mut temp = Temp::new(p.TEMP, irq);

10
examples/nrf/src/bin/timer.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task]
#[embassy_executor::task]
async fn run1() {
loop {
info!("BIG INFREQUENT TICK");
@ -16,7 +16,7 @@ async fn run1() {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run2() {
loop {
info!("tick");
@ -24,7 +24,7 @@ async fn run2() {
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, _p: Peripherals) {
unwrap!(spawner.spawn(run1()));
unwrap!(spawner.spawn(run2()));

4
examples/nrf/src/bin/twim.rs
View File

@ -7,14 +7,14 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::twim::{self, Twim};
use embassy_nrf::{interrupt, Peripherals};
use {defmt_rtt as _, panic_probe as _};
const ADDRESS: u8 = 0x50;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Initializing TWI...");
let config = twim::Config::default();

6
examples/nrf/src/bin/twim_lowpower.rs
View File

@ -11,15 +11,15 @@
use core::mem;
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::twim::{self, Twim};
use embassy_nrf::{interrupt, Peripherals};
use {defmt_rtt as _, panic_probe as _};
const ADDRESS: u8 = 0x50;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, mut p: Peripherals) {
info!("Started!");
let mut irq = interrupt::take!(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0);

4
examples/nrf/src/bin/uart.rs
View File

@ -3,11 +3,11 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::{interrupt, uarte, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut config = uarte::Config::default();
config.parity = uarte::Parity::EXCLUDED;

4
examples/nrf/src/bin/uart_idle.rs
View File

@ -3,11 +3,11 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::{interrupt, uarte, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut config = uarte::Config::default();
config.parity = uarte::Parity::EXCLUDED;

10
examples/nrf/src/bin/uart_split.rs
View File

@ -3,17 +3,17 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::blocking_mutex::raw::ThreadModeRawMutex;
use embassy::channel::mpmc::Channel;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::peripherals::UARTE0;
use embassy_nrf::uarte::UarteRx;
use embassy_nrf::{interrupt, uarte, Peripherals};
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_util::channel::mpmc::Channel;
use {defmt_rtt as _, panic_probe as _};
static CHANNEL: Channel<ThreadModeRawMutex, [u8; 8], 1> = Channel::new();
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
let mut config = uarte::Config::default();
config.parity = uarte::Parity::EXCLUDED;
@ -48,7 +48,7 @@ async fn main(spawner: Spawner, p: Peripherals) {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn reader(mut rx: UarteRx<'static, UARTE0>) {
let mut buf = [0; 8];
loop {

18
examples/nrf/src/bin/usb_ethernet.rs
View File

@ -8,10 +8,7 @@ use core::sync::atomic::{AtomicBool, Ordering};
use core::task::Waker;
use defmt::*;
use embassy::blocking_mutex::raw::ThreadModeRawMutex;
use embassy::channel::mpmc::Channel;
use embassy::executor::Spawner;
use embassy::util::Forever;
use embassy_executor::executor::Spawner;
use embassy_net::tcp::TcpSocket;
use embassy_net::{PacketBox, PacketBoxExt, PacketBuf, Stack, StackResources};
use embassy_nrf::rng::Rng;
@ -19,6 +16,9 @@ use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, peripherals, Peripherals};
use embassy_usb::{Builder, Config, UsbDevice};
use embassy_usb_ncm::{CdcNcmClass, Receiver, Sender, State};
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_util::channel::mpmc::Channel;
use embassy_util::Forever;
use embedded_io::asynch::{Read, Write};
use {defmt_rtt as _, panic_probe as _};
@ -32,12 +32,12 @@ macro_rules! forever {
}};
}
#[embassy::task]
#[embassy_executor::task]
async fn usb_task(mut device: UsbDevice<'static, MyDriver>) -> ! {
device.run().await
}
#[embassy::task]
#[embassy_executor::task]
async fn usb_ncm_rx_task(mut class: Receiver<'static, MyDriver>) {
loop {
warn!("WAITING for connection");
@ -66,7 +66,7 @@ async fn usb_ncm_rx_task(mut class: Receiver<'static, MyDriver>) {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn usb_ncm_tx_task(mut class: Sender<'static, MyDriver>) {
loop {
let pkt = TX_CHANNEL.recv().await;
@ -76,12 +76,12 @@ async fn usb_ncm_tx_task(mut class: Sender<'static, MyDriver>) {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn net_task(stack: &'static Stack<Device>) -> ! {
stack.run().await
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };

13
examples/nrf/src/bin/usb_hid_keyboard.rs
View File

@ -7,23 +7,22 @@ use core::mem;
use core::sync::atomic::{AtomicBool, Ordering};
use defmt::*;
use embassy::channel::signal::Signal;
use embassy::executor::Spawner;
use embassy::time::Duration;
use embassy::util::{select, Either};
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{Input, Pin, Pull};
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, Peripherals};
use embassy_usb::control::OutResponse;
use embassy_usb::{Builder, Config, DeviceStateHandler};
use embassy_usb_hid::{HidReaderWriter, ReportId, RequestHandler, State};
use embassy_util::channel::signal::Signal;
use embassy_util::{select, Either};
use futures::future::join;
use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
use {defmt_rtt as _, panic_probe as _};
static SUSPENDED: AtomicBool = AtomicBool::new(false);
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
@ -154,11 +153,11 @@ impl RequestHandler for MyRequestHandler {
OutResponse::Accepted
}
fn set_idle(&self, id: Option<ReportId>, dur: Duration) {
fn set_idle_ms(&self, id: Option<ReportId>, dur: u32) {
info!("Set idle rate for {:?} to {:?}", id, dur);
}
fn get_idle(&self, id: Option<ReportId>) -> Option<Duration> {
fn get_idle_ms(&self, id: Option<ReportId>) -> Option<u32> {
info!("Get idle rate for {:?}", id);
None
}

10
examples/nrf/src/bin/usb_hid_mouse.rs
View File

@ -6,8 +6,8 @@
use core::mem;
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, Peripherals};
use embassy_usb::control::OutResponse;
@ -17,7 +17,7 @@ use futures::future::join;
use usbd_hid::descriptor::{MouseReport, SerializedDescriptor};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };
@ -113,11 +113,11 @@ impl RequestHandler for MyRequestHandler {
OutResponse::Accepted
}
fn set_idle(&self, id: Option<ReportId>, dur: Duration) {
fn set_idle_ms(&self, id: Option<ReportId>, dur: u32) {
info!("Set idle rate for {:?} to {:?}", id, dur);
}
fn get_idle(&self, id: Option<ReportId>) -> Option<Duration> {
fn get_idle_ms(&self, id: Option<ReportId>) -> Option<u32> {
info!("Get idle rate for {:?}", id);
None
}

4
examples/nrf/src/bin/usb_serial.rs
View File

@ -6,7 +6,7 @@
use core::mem;
use defmt::{info, panic};
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::usb::{Driver, Instance, PowerUsb, UsbSupply};
use embassy_nrf::{interrupt, pac, Peripherals};
use embassy_usb::driver::EndpointError;
@ -15,7 +15,7 @@ use embassy_usb_serial::{CdcAcmClass, State};
use futures::future::join;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };

10
examples/nrf/src/bin/usb_serial_multitask.rs
View File

@ -6,23 +6,23 @@
use core::mem;
use defmt::{info, panic, unwrap};
use embassy::executor::Spawner;
use embassy::util::Forever;
use embassy_executor::executor::Spawner;
use embassy_nrf::usb::{Driver, PowerUsb};
use embassy_nrf::{interrupt, pac, peripherals, Peripherals};
use embassy_usb::driver::EndpointError;
use embassy_usb::{Builder, Config, UsbDevice};
use embassy_usb_serial::{CdcAcmClass, State};
use embassy_util::Forever;
use {defmt_rtt as _, panic_probe as _};
type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
#[embassy::task]
#[embassy_executor::task]
async fn usb_task(mut device: UsbDevice<'static, MyDriver>) {
device.run().await;
}
#[embassy::task]
#[embassy_executor::task]
async fn echo_task(mut class: CdcAcmClass<'static, MyDriver>) {
loop {
class.wait_connection().await;
@ -32,7 +32,7 @@ async fn echo_task(mut class: CdcAcmClass<'static, MyDriver>) {
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
let clock: pac::CLOCK = unsafe { mem::transmute(()) };

4
examples/nrf/src/bin/wdt.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_nrf::gpio::{Input, Pull};
use embassy_nrf::wdt::{Config, Watchdog};
use embassy_nrf::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

3
examples/rp/Cargo.toml
View File

@ -5,7 +5,8 @@ version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["defmt", "defmt-timestamp-uptime"] }
embassy-rp = { version = "0.1.0", path = "../../embassy-rp", features = ["defmt", "unstable-traits", "nightly", "unstable-pac"] }
atomic-polyfill = "0.1.5"

6
examples/rp/src/bin/blinky.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_rp::{gpio, Peripherals};
use gpio::{Level, Output};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PIN_25, Level::Low);

4
examples/rp/src/bin/button.rs
View File

@ -2,12 +2,12 @@
#![no_main]
#![feature(type_alias_impl_trait)]
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_rp::gpio::{Input, Level, Output, Pull};
use embassy_rp::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let button = Input::new(p.PIN_28, Pull::Up);
let mut led = Output::new(p.PIN_25, Level::Low);

6
examples/rp/src/bin/gpio_async.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_rp::{gpio, Peripherals};
use gpio::{Input, Level, Output, Pull};
use {defmt_rtt as _, panic_probe as _};
@ -19,7 +19,7 @@ use {defmt_rtt as _, panic_probe as _};
/// high signal on PIN 16. Once the high event/signal occurs the program will
/// continue and turn off the LED, and then wait for 2 seconds before completing
/// the loop and starting over again.
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut led = Output::new(p.PIN_25, Level::Low);
let mut async_input = Input::new(p.PIN_16, Pull::None);

4
examples/rp/src/bin/spi.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_rp::spi::Spi;
use embassy_rp::{gpio, spi, Peripherals};
use gpio::{Level, Output};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

6
examples/rp/src/bin/spi_display.rs
View File

@ -5,8 +5,8 @@
use core::cell::RefCell;
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::Delay;
use embassy_executor::executor::Spawner;
use embassy_executor::time::Delay;
use embassy_rp::gpio::{Level, Output};
use embassy_rp::spi::Spi;
use embassy_rp::{spi, Peripherals};
@ -27,7 +27,7 @@ use crate::touch::Touch;
//const DISPLAY_FREQ: u32 = 64_000_000;
const TOUCH_FREQ: u32 = 200_000;
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

4
examples/rp/src/bin/uart.rs
View File

@ -2,11 +2,11 @@
#![no_main]
#![feature(type_alias_impl_trait)]
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_rp::{uart, Peripherals};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let config = uart::Config::default();
let mut uart = uart::Uart::new(p.UART0, p.PIN_0, p.PIN_1, p.PIN_2, p.PIN_3, config);

3
examples/std/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-std-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../embassy", features = ["log", "std", "time", "nightly"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["log"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["log", "std", "time", "nightly"] }
embassy-net = { version = "0.1.0", path = "../../embassy-net", features=[ "std", "log", "medium-ethernet", "tcp", "dhcpv4", "pool-16"] }
embedded-io = { version = "0.3.0", features = ["async", "std", "futures"] }

8
examples/std/src/bin/net.rs
View File

@ -1,10 +1,10 @@
#![feature(type_alias_impl_trait)]
use clap::Parser;
use embassy::executor::{Executor, Spawner};
use embassy::util::Forever;
use embassy_executor::executor::{Executor, Spawner};
use embassy_net::tcp::TcpSocket;
use embassy_net::{ConfigStrategy, Ipv4Address, Ipv4Cidr, Stack, StackResources};
use embassy_util::Forever;
use embedded_io::asynch::Write;
use heapless::Vec;
use log::*;
@ -34,12 +34,12 @@ struct Opts {
static_ip: bool,
}
#[embassy::task]
#[embassy_executor::task]
async fn net_task(stack: &'static Stack<TunTapDevice>) -> ! {
stack.run().await
}
#[embassy::task]
#[embassy_executor::task]
async fn main_task(spawner: Spawner) {
let opts: Opts = Opts::parse();

6
examples/std/src/bin/serial.rs
View File

@ -4,15 +4,15 @@
mod serial_port;
use async_io::Async;
use embassy::executor::Executor;
use embassy::util::Forever;
use embassy_executor::executor::Executor;
use embassy_util::Forever;
use embedded_io::asynch::Read;
use log::*;
use nix::sys::termios;
use self::serial_port::SerialPort;
#[embassy::task]
#[embassy_executor::task]
async fn run() {
// Open the serial port.
let baudrate = termios::BaudRate::B115200;

8
examples/std/src/bin/tick.rs
View File

@ -1,10 +1,10 @@
#![feature(type_alias_impl_trait)]
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use log::*;
#[embassy::task]
#[embassy_executor::task]
async fn run() {
loop {
info!("tick");
@ -12,7 +12,7 @@ async fn run() {
}
}
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner) {
env_logger::builder()
.filter_level(log::LevelFilter::Debug)

3
examples/stm32f0/Cargo.toml
View File

@ -11,6 +11,7 @@ cortex-m-rt = "0.7.0"
defmt = "0.3"
defmt-rtt = "0.3"
panic-probe = "0.3"
embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "memory-x", "stm32f030f4", "time-driver-any"] }

6
examples/stm32f0/src/bin/hello.rs
View File

@ -3,12 +3,12 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, _p: Peripherals) -> ! {
loop {
Timer::after(Duration::from_secs(1)).await;

3
examples/stm32f1/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-stm32f1-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f103c8", "unstable-pac", "memory-x", "time-driver-any"] }
embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
embassy-usb-serial = { version = "0.1.0", path = "../../embassy-usb-serial", features = ["defmt"] }

6
examples/stm32f1/src/bin/adc.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Delay, Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Delay, Duration, Timer};
use embassy_stm32::adc::Adc;
use embassy_stm32::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

6
examples/stm32f1/src/bin/blinky.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

6
examples/stm32f1/src/bin/hello.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::time::Hertz;
use embassy_stm32::{Config, Peripherals};
use {defmt_rtt as _, panic_probe as _};
@ -15,7 +15,7 @@ fn config() -> Config {
config
}
#[embassy::main(config = "config()")]
#[embassy_executor::main(config = "config()")]
async fn main(_spawner: Spawner, _p: Peripherals) -> ! {
loop {
info!("Hello World!");

6
examples/stm32f1/src/bin/usb_serial.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::{panic, *};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::time::Hertz;
use embassy_stm32::usb::{Driver, Instance};
@ -23,7 +23,7 @@ fn config() -> Config {
config
}
#[embassy::main(config = "config()")]
#[embassy_executor::main(config = "config()")]
async fn main(_spawner: Spawner, mut p: Peripherals) {
info!("Hello World!");

3
examples/stm32f2/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-stm32f2-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f207zg", "unstable-pac", "memory-x", "time-driver-any", "exti"] }
defmt = "0.3"

6
examples/stm32f2/src/bin/blinky.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

6
examples/stm32f2/src/bin/pll.rs
View File

@ -5,8 +5,8 @@
use core::convert::TryFrom;
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::rcc::{
APBPrescaler, ClockSrc, HSEConfig, HSESrc, PLL48Div, PLLConfig, PLLMainDiv, PLLMul, PLLPreDiv, PLLSrc,
};
@ -43,7 +43,7 @@ fn config() -> Config {
config
}
#[embassy::main(config = "config()")]
#[embassy_executor::main(config = "config()")]
async fn main(_spawner: Spawner, _p: Peripherals) {
loop {
Timer::after(Duration::from_millis(1000)).await;

3
examples/stm32f3/Cargo.toml
View File

@ -4,7 +4,8 @@ name = "embassy-stm32f3-examples"
version = "0.1.0"
[dependencies]
embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-util = { version = "0.1.0", path = "../../embassy-util", features = ["defmt"] }
embassy-executor = { version = "0.1.0", path = "../../embassy-executor", features = ["defmt", "defmt-timestamp-uptime", "time-tick-32768hz"] }
embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f303ze", "unstable-pac", "memory-x", "time-driver-any", "exti"] }
embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
embassy-usb-serial = { version = "0.1.0", path = "../../embassy-usb-serial", features = ["defmt"] }

6
examples/stm32f3/src/bin/blinky.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

14
examples/stm32f3/src/bin/button_events.rs
View File

@ -11,14 +11,14 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::blocking_mutex::raw::ThreadModeRawMutex;
use embassy::channel::mpmc::Channel;
use embassy::executor::Spawner;
use embassy::time::{with_timeout, Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{with_timeout, Duration, Timer};
use embassy_stm32::exti::ExtiInput;
use embassy_stm32::gpio::{AnyPin, Input, Level, Output, Pin, Pull, Speed};
use embassy_stm32::peripherals::PA0;
use embassy_stm32::Peripherals;
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_util::channel::mpmc::Channel;
use {defmt_rtt as _, panic_probe as _};
struct Leds<'a> {
@ -99,7 +99,7 @@ enum ButtonEvent {
static CHANNEL: Channel<ThreadModeRawMutex, ButtonEvent, 4> = Channel::new();
#[embassy::main]
#[embassy_executor::main]
async fn main(spawner: Spawner, p: Peripherals) {
let button = Input::new(p.PA0, Pull::Down);
let button = ExtiInput::new(button, p.EXTI0);
@ -120,14 +120,14 @@ async fn main(spawner: Spawner, p: Peripherals) {
spawner.spawn(led_blinker(leds)).unwrap();
}
#[embassy::task]
#[embassy_executor::task]
async fn led_blinker(mut leds: Leds<'static>) {
loop {
leds.show().await;
}
}
#[embassy::task]
#[embassy_executor::task]
async fn button_waiter(mut button: ExtiInput<'static, PA0>) {
const DOUBLE_CLICK_DELAY: u64 = 250;
const HOLD_DELAY: u64 = 1000;

4
examples/stm32f3/src/bin/button_exti.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_stm32::exti::ExtiInput;
use embassy_stm32::gpio::{Input, Pull};
use embassy_stm32::Peripherals;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

4
examples/stm32f3/src/bin/flash.rs
View File

@ -3,13 +3,13 @@
#![feature(type_alias_impl_trait)]
use defmt::{info, unwrap};
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_stm32::flash::Flash;
use embassy_stm32::Peripherals;
use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello Flash!");

6
examples/stm32f3/src/bin/hello.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::info;
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::time::Hertz;
use embassy_stm32::{Config, Peripherals};
use {defmt_rtt as _, panic_probe as _};
@ -16,7 +16,7 @@ fn config() -> Config {
config
}
#[embassy::main(config = "config()")]
#[embassy_executor::main(config = "config()")]
async fn main(_spawner: Spawner, _p: Peripherals) -> ! {
loop {
info!("Hello World!");

10
examples/stm32f3/src/bin/multiprio.rs
View File

@ -59,14 +59,14 @@
use cortex_m_rt::entry;
use defmt::*;
use embassy::time::{Duration, Instant, Timer};
use embassy::util::Forever;
use embassy_executor::time::{Duration, Instant, Timer};
use embassy_stm32::executor::{Executor, InterruptExecutor};
use embassy_stm32::interrupt;
use embassy_stm32::interrupt::InterruptExt;
use embassy_util::Forever;
use {defmt_rtt as _, panic_probe as _};
#[embassy::task]
#[embassy_executor::task]
async fn run_high() {
loop {
info!(" [high] tick!");
@ -74,7 +74,7 @@ async fn run_high() {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run_med() {
loop {
let start = Instant::now();
@ -91,7 +91,7 @@ async fn run_med() {
}
}
#[embassy::task]
#[embassy_executor::task]
async fn run_low() {
loop {
let start = Instant::now();

4
examples/stm32f3/src/bin/spi_dma.rs
View File

@ -6,14 +6,14 @@ use core::fmt::Write;
use core::str::from_utf8;
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_stm32::spi::{Config, Spi};
use embassy_stm32::time::Hertz;
use embassy_stm32::Peripherals;
use heapless::String;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

4
examples/stm32f3/src/bin/usart_dma.rs
View File

@ -5,14 +5,14 @@
use core::fmt::Write;
use defmt::*;
use embassy::executor::Spawner;
use embassy_executor::executor::Spawner;
use embassy_stm32::dma::NoDma;
use embassy_stm32::usart::{Config, Uart};
use embassy_stm32::Peripherals;
use heapless::String;
use {defmt_rtt as _, panic_probe as _};
#[embassy::main]
#[embassy_executor::main]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

6
examples/stm32f3/src/bin/usb_serial.rs
View File

@ -3,8 +3,8 @@
#![feature(type_alias_impl_trait)]
use defmt::{panic, *};
use embassy::executor::Spawner;
use embassy::time::{Duration, Timer};
use embassy_executor::executor::Spawner;
use embassy_executor::time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::time::mhz;
use embassy_stm32::usb::{Driver, Instance};
@ -27,7 +27,7 @@ fn config() -> Config {
config
}
#[embassy::main(config = "config()")]
#[embassy_executor::main(config = "config()")]
async fn main(_spawner: Spawner, p: Peripherals) {
info!("Hello World!");

Some files were not shown because too many files have changed in this diff Show More