aboutsummaryrefslogtreecommitdiff
path: root/examples/nrf5340/src
diff options
context:
space:
mode:
Diffstat (limited to 'examples/nrf5340/src')
-rw-r--r--examples/nrf5340/src/bin/awaitable_timer.rs26
-rw-r--r--examples/nrf5340/src/bin/buffered_uart.rs57
-rw-r--r--examples/nrf5340/src/bin/channel.rs43
-rw-r--r--examples/nrf5340/src/bin/channel_sender_receiver.rs50
-rw-r--r--examples/nrf5340/src/bin/gpiote_port.rs34
-rw-r--r--examples/nrf5340/src/bin/uart_idle.rs35
-rw-r--r--examples/nrf5340/src/bin/uart_split.rs60
7 files changed, 0 insertions, 305 deletions
diff --git a/examples/nrf5340/src/bin/awaitable_timer.rs b/examples/nrf5340/src/bin/awaitable_timer.rs
deleted file mode 100644
index b32af236c..000000000
--- a/examples/nrf5340/src/bin/awaitable_timer.rs
+++ /dev/null
@@ -1,26 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::info;
6use embassy_executor::Spawner;
7use embassy_nrf::interrupt;
8use embassy_nrf::timer::Timer;
9use {defmt_rtt as _, panic_probe as _};
10
11#[embassy_executor::main]
12async fn main(_spawner: Spawner) {
13 let p = embassy_nrf::init(Default::default());
14 let mut t = Timer::new_awaitable(p.TIMER0, interrupt::take!(TIMER0));
15 // default frequency is 1MHz, so this triggers every second
16 t.cc(0).write(1_000_000);
17 // clear the timer value on cc[0] compare match
18 t.cc(0).short_compare_clear();
19 t.start();
20
21 loop {
22 // wait for compare match
23 t.cc(0).wait().await;
24 info!("hardware timer tick");
25 }
26}
diff --git a/examples/nrf5340/src/bin/buffered_uart.rs b/examples/nrf5340/src/bin/buffered_uart.rs
deleted file mode 100644
index 25a0ca237..000000000
--- a/examples/nrf5340/src/bin/buffered_uart.rs
+++ /dev/null
@@ -1,57 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::*;
6use embassy_executor::Spawner;
7use embassy_nrf::buffered_uarte::{BufferedUarte, State};
8use embassy_nrf::{interrupt, uarte};
9use embedded_io::asynch::{BufRead, Write};
10use futures::pin_mut;
11use {defmt_rtt as _, panic_probe as _};
12
13#[embassy_executor::main]
14async fn main(_spawner: Spawner) {
15 let p = embassy_nrf::init(Default::default());
16 let mut config = uarte::Config::default();
17 config.parity = uarte::Parity::EXCLUDED;
18 config.baudrate = uarte::Baudrate::BAUD115200;
19
20 let mut tx_buffer = [0u8; 4096];
21 let mut rx_buffer = [0u8; 4096];
22
23 let irq = interrupt::take!(SERIAL0);
24 let mut state = State::new();
25 // Please note - important to have hardware flow control (https://github.com/embassy-rs/embassy/issues/536)
26 let u = BufferedUarte::new(
27 &mut state,
28 p.UARTETWISPI0,
29 p.TIMER0,
30 p.PPI_CH0,
31 p.PPI_CH1,
32 irq,
33 p.P0_08,
34 p.P0_06,
35 p.P0_07,
36 p.P0_05,
37 config,
38 &mut rx_buffer,
39 &mut tx_buffer,
40 );
41 pin_mut!(u);
42
43 info!("uarte initialized!");
44
45 unwrap!(u.write_all(b"Hello!\r\n").await);
46 info!("wrote hello in uart!");
47
48 loop {
49 info!("reading...");
50 let buf = unwrap!(u.fill_buf().await);
51 info!("read done, got {}", buf);
52
53 // Read bytes have to be explicitly consumed, otherwise fill_buf() will return them again
54 let n = buf.len();
55 u.consume(n);
56 }
57}
diff --git a/examples/nrf5340/src/bin/channel.rs b/examples/nrf5340/src/bin/channel.rs
deleted file mode 100644
index 425d43051..000000000
--- a/examples/nrf5340/src/bin/channel.rs
+++ /dev/null
@@ -1,43 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::unwrap;
6use embassy_executor::Spawner;
7use embassy_nrf::gpio::{Level, Output, OutputDrive};
8use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
9use embassy_sync::channel::Channel;
10use embassy_time::{Duration, Timer};
11use {defmt_rtt as _, panic_probe as _};
12
13enum LedState {
14 On,
15 Off,
16}
17
18static CHANNEL: Channel<ThreadModeRawMutex, LedState, 1> = Channel::new();
19
20#[embassy_executor::task]
21async fn my_task() {
22 loop {
23 CHANNEL.send(LedState::On).await;
24 Timer::after(Duration::from_secs(1)).await;
25 CHANNEL.send(LedState::Off).await;
26 Timer::after(Duration::from_secs(1)).await;
27 }
28}
29
30#[embassy_executor::main]
31async fn main(spawner: Spawner) {
32 let p = embassy_nrf::init(Default::default());
33 let mut led = Output::new(p.P0_28, Level::Low, OutputDrive::Standard);
34
35 unwrap!(spawner.spawn(my_task()));
36
37 loop {
38 match CHANNEL.recv().await {
39 LedState::On => led.set_high(),
40 LedState::Off => led.set_low(),
41 }
42 }
43}
diff --git a/examples/nrf5340/src/bin/channel_sender_receiver.rs b/examples/nrf5340/src/bin/channel_sender_receiver.rs
deleted file mode 100644
index 9628c0525..000000000
--- a/examples/nrf5340/src/bin/channel_sender_receiver.rs
+++ /dev/null
@@ -1,50 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::unwrap;
6use embassy_executor::Spawner;
7use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
8use embassy_sync::blocking_mutex::raw::NoopRawMutex;
9use embassy_sync::channel::{Channel, Receiver, Sender};
10use embassy_time::{Duration, Timer};
11use static_cell::StaticCell;
12use {defmt_rtt as _, panic_probe as _};
13
14enum LedState {
15 On,
16 Off,
17}
18
19static CHANNEL: StaticCell<Channel<NoopRawMutex, LedState, 1>> = StaticCell::new();
20
21#[embassy_executor::task]
22async fn send_task(sender: Sender<'static, NoopRawMutex, LedState, 1>) {
23 loop {
24 sender.send(LedState::On).await;
25 Timer::after(Duration::from_secs(1)).await;
26 sender.send(LedState::Off).await;
27 Timer::after(Duration::from_secs(1)).await;
28 }
29}
30
31#[embassy_executor::task]
32async fn recv_task(led: AnyPin, receiver: Receiver<'static, NoopRawMutex, LedState, 1>) {
33 let mut led = Output::new(led, Level::Low, OutputDrive::Standard);
34
35 loop {
36 match receiver.recv().await {
37 LedState::On => led.set_high(),
38 LedState::Off => led.set_low(),
39 }
40 }
41}
42
43#[embassy_executor::main]
44async fn main(spawner: Spawner) {
45 let p = embassy_nrf::init(Default::default());
46 let channel = CHANNEL.init(Channel::new());
47
48 unwrap!(spawner.spawn(send_task(channel.sender())));
49 unwrap!(spawner.spawn(recv_task(p.P0_28.degrade(), channel.receiver())));
50}
diff --git a/examples/nrf5340/src/bin/gpiote_port.rs b/examples/nrf5340/src/bin/gpiote_port.rs
deleted file mode 100644
index 0cc911ad2..000000000
--- a/examples/nrf5340/src/bin/gpiote_port.rs
+++ /dev/null
@@ -1,34 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::{info, unwrap};
6use embassy_executor::Spawner;
7use embassy_nrf::gpio::{AnyPin, Input, Pin as _, Pull};
8use {defmt_rtt as _, panic_probe as _};
9
10#[embassy_executor::task(pool_size = 4)]
11async fn button_task(n: usize, mut pin: Input<'static, AnyPin>) {
12 loop {
13 pin.wait_for_low().await;
14 info!("Button {:?} pressed!", n);
15 pin.wait_for_high().await;
16 info!("Button {:?} released!", n);
17 }
18}
19
20#[embassy_executor::main]
21async fn main(spawner: Spawner) {
22 let p = embassy_nrf::init(Default::default());
23 info!("Starting!");
24
25 let btn1 = Input::new(p.P0_23.degrade(), Pull::Up);
26 let btn2 = Input::new(p.P0_24.degrade(), Pull::Up);
27 let btn3 = Input::new(p.P0_08.degrade(), Pull::Up);
28 let btn4 = Input::new(p.P0_09.degrade(), Pull::Up);
29
30 unwrap!(spawner.spawn(button_task(1, btn1)));
31 unwrap!(spawner.spawn(button_task(2, btn2)));
32 unwrap!(spawner.spawn(button_task(3, btn3)));
33 unwrap!(spawner.spawn(button_task(4, btn4)));
34}
diff --git a/examples/nrf5340/src/bin/uart_idle.rs b/examples/nrf5340/src/bin/uart_idle.rs
deleted file mode 100644
index 327fc4b23..000000000
--- a/examples/nrf5340/src/bin/uart_idle.rs
+++ /dev/null
@@ -1,35 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::*;
6use embassy_executor::Spawner;
7use embassy_nrf::{interrupt, uarte};
8use {defmt_rtt as _, panic_probe as _};
9
10#[embassy_executor::main]
11async fn main(_spawner: Spawner) {
12 let p = embassy_nrf::init(Default::default());
13 let mut config = uarte::Config::default();
14 config.parity = uarte::Parity::EXCLUDED;
15 config.baudrate = uarte::Baudrate::BAUD115200;
16
17 let irq = interrupt::take!(SERIAL0);
18 let uart = uarte::Uarte::new(p.UARTETWISPI0, irq, p.P0_08, p.P0_06, config);
19 let (mut tx, mut rx) = uart.split_with_idle(p.TIMER0, p.PPI_CH0, p.PPI_CH1);
20
21 info!("uarte initialized!");
22
23 // Message must be in SRAM
24 let mut buf = [0; 8];
25 buf.copy_from_slice(b"Hello!\r\n");
26
27 unwrap!(tx.write(&buf).await);
28 info!("wrote hello in uart!");
29
30 loop {
31 info!("reading...");
32 let n = unwrap!(rx.read_until_idle(&mut buf).await);
33 info!("got {} bytes", n);
34 }
35}
diff --git a/examples/nrf5340/src/bin/uart_split.rs b/examples/nrf5340/src/bin/uart_split.rs
deleted file mode 100644
index 0bbbfeaa5..000000000
--- a/examples/nrf5340/src/bin/uart_split.rs
+++ /dev/null
@@ -1,60 +0,0 @@
1#![no_std]
2#![no_main]
3#![feature(type_alias_impl_trait)]
4
5use defmt::*;
6use embassy_executor::Spawner;
7use embassy_nrf::peripherals::UARTETWISPI0;
8use embassy_nrf::uarte::UarteRx;
9use embassy_nrf::{interrupt, uarte};
10use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
11use embassy_sync::channel::Channel;
12use {defmt_rtt as _, panic_probe as _};
13
14static CHANNEL: Channel<ThreadModeRawMutex, [u8; 8], 1> = Channel::new();
15
16#[embassy_executor::main]
17async fn main(spawner: Spawner) {
18 let p = embassy_nrf::init(Default::default());
19 let mut config = uarte::Config::default();
20 config.parity = uarte::Parity::EXCLUDED;
21 config.baudrate = uarte::Baudrate::BAUD115200;
22
23 let irq = interrupt::take!(SERIAL0);
24 let uart = uarte::Uarte::new(p.UARTETWISPI0, irq, p.P1_00, p.P1_01, config);
25 let (mut tx, rx) = uart.split();
26
27 info!("uarte initialized!");
28
29 // Spawn a task responsible purely for reading
30
31 unwrap!(spawner.spawn(reader(rx)));
32
33 // Message must be in SRAM
34 {
35 let mut buf = [0; 23];
36 buf.copy_from_slice(b"Type 8 chars to echo!\r\n");
37
38 unwrap!(tx.write(&buf).await);
39 info!("wrote hello in uart!");
40 }
41
42 // Continue reading in this main task and write
43 // back out the buffer we receive from the read
44 // task.
45 loop {
46 let buf = CHANNEL.recv().await;
47 info!("writing...");
48 unwrap!(tx.write(&buf).await);
49 }
50}
51
52#[embassy_executor::task]
53async fn reader(mut rx: UarteRx<'static, UARTETWISPI0>) {
54 let mut buf = [0; 8];
55 loop {
56 info!("reading...");
57 unwrap!(rx.read(&mut buf).await);
58 CHANNEL.send(buf).await;
59 }
60}
generated by cgit (git 2.34.1) at 2026-04-05 22:20:15 +0000