aboutsummaryrefslogtreecommitdiff
path: root/tests/nrf/src
diff options
context:
space:
mode:
Diffstat (limited to 'tests/nrf/src')
-rw-r--r--tests/nrf/src/bin/buffered_uart.rs78
-rw-r--r--tests/nrf/src/bin/buffered_uart_full.rs71
-rw-r--r--tests/nrf/src/bin/buffered_uart_spam.rs91
-rw-r--r--tests/nrf/src/bin/ethernet_enc28j60_perf.rs90
-rw-r--r--tests/nrf/src/bin/timer.rs25
-rw-r--r--tests/nrf/src/bin/wifi_esp_hosted_perf.rs111
6 files changed, 0 insertions, 466 deletions
diff --git a/tests/nrf/src/bin/buffered_uart.rs b/tests/nrf/src/bin/buffered_uart.rs
deleted file mode 100644
index 354d787b4..000000000
--- a/tests/nrf/src/bin/buffered_uart.rs
+++ /dev/null
@@ -1,78 +0,0 @@
1#![no_std]
2#![no_main]
3teleprobe_meta::target!(b"nrf52840-dk");
4
5use defmt::{assert_eq, *};
6use embassy_executor::Spawner;
7use embassy_futures::join::join;
8use embassy_nrf::buffered_uarte::{self, BufferedUarte};
9use embassy_nrf::{bind_interrupts, peripherals, uarte};
10use {defmt_rtt as _, panic_probe as _};
11
12bind_interrupts!(struct Irqs {
13 UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
14});
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::BAUD1M;
22
23 let mut tx_buffer = [0u8; 1024];
24 let mut rx_buffer = [0u8; 1024];
25
26 let mut u = BufferedUarte::new(
27 p.UARTE0,
28 p.TIMER0,
29 p.PPI_CH0,
30 p.PPI_CH1,
31 p.PPI_GROUP0,
32 Irqs,
33 p.P1_03,
34 p.P1_02,
35 config.clone(),
36 &mut rx_buffer,
37 &mut tx_buffer,
38 );
39
40 info!("uarte initialized!");
41
42 let (mut rx, mut tx) = u.split();
43
44 const COUNT: usize = 40_000;
45
46 let tx_fut = async {
47 let mut tx_buf = [0; 215];
48 let mut i = 0;
49 while i < COUNT {
50 let n = tx_buf.len().min(COUNT - i);
51 let tx_buf = &mut tx_buf[..n];
52 for (j, b) in tx_buf.iter_mut().enumerate() {
53 *b = (i + j) as u8;
54 }
55 let n = unwrap!(tx.write(tx_buf).await);
56 i += n;
57 }
58 };
59 let rx_fut = async {
60 let mut i = 0;
61 while i < COUNT {
62 let buf = unwrap!(rx.fill_buf().await);
63
64 for &b in buf {
65 assert_eq!(b, i as u8);
66 i = i + 1;
67 }
68
69 let n = buf.len();
70 rx.consume(n);
71 }
72 };
73
74 join(rx_fut, tx_fut).await;
75
76 info!("Test OK");
77 cortex_m::asm::bkpt();
78}
diff --git a/tests/nrf/src/bin/buffered_uart_full.rs b/tests/nrf/src/bin/buffered_uart_full.rs
deleted file mode 100644
index e59c75ba9..000000000
--- a/tests/nrf/src/bin/buffered_uart_full.rs
+++ /dev/null
@@ -1,71 +0,0 @@
1#![no_std]
2#![no_main]
3teleprobe_meta::target!(b"nrf52840-dk");
4
5use defmt::{assert_eq, *};
6use embassy_executor::Spawner;
7use embassy_nrf::buffered_uarte::{self, BufferedUarte};
8use embassy_nrf::{bind_interrupts, peripherals, uarte};
9use embedded_io_async::{Read, Write};
10use {defmt_rtt as _, panic_probe as _};
11
12bind_interrupts!(struct Irqs {
13 UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
14});
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::BAUD1M;
22
23 let mut tx_buffer = [0u8; 1024];
24 let mut rx_buffer = [0u8; 1024];
25
26 let mut u = BufferedUarte::new(
27 p.UARTE0,
28 p.TIMER0,
29 p.PPI_CH0,
30 p.PPI_CH1,
31 p.PPI_GROUP0,
32 Irqs,
33 p.P1_03,
34 p.P1_02,
35 config.clone(),
36 &mut rx_buffer,
37 &mut tx_buffer,
38 );
39
40 info!("uarte initialized!");
41
42 let (mut rx, mut tx) = u.split();
43
44 let mut buf = [0; 1024];
45 for (j, b) in buf.iter_mut().enumerate() {
46 *b = j as u8;
47 }
48
49 // Write 1024b. This causes the rx buffer to get exactly full.
50 unwrap!(tx.write_all(&buf).await);
51 unwrap!(tx.flush().await);
52
53 // Read those 1024b.
54 unwrap!(rx.read_exact(&mut buf).await);
55 for (j, b) in buf.iter().enumerate() {
56 assert_eq!(*b, j as u8);
57 }
58
59 // The buffer should now be unclogged. Write 1024b again.
60 unwrap!(tx.write_all(&buf).await);
61 unwrap!(tx.flush().await);
62
63 // Read should work again.
64 unwrap!(rx.read_exact(&mut buf).await);
65 for (j, b) in buf.iter().enumerate() {
66 assert_eq!(*b, j as u8);
67 }
68
69 info!("Test OK");
70 cortex_m::asm::bkpt();
71}
diff --git a/tests/nrf/src/bin/buffered_uart_spam.rs b/tests/nrf/src/bin/buffered_uart_spam.rs
deleted file mode 100644
index 400c0df99..000000000
--- a/tests/nrf/src/bin/buffered_uart_spam.rs
+++ /dev/null
@@ -1,91 +0,0 @@
1#![no_std]
2#![no_main]
3teleprobe_meta::target!(b"nrf52840-dk");
4
5use core::mem;
6use core::ptr::NonNull;
7
8use defmt::{assert_eq, *};
9use embassy_executor::Spawner;
10use embassy_nrf::buffered_uarte::{self, BufferedUarte};
11use embassy_nrf::gpio::{Level, Output, OutputDrive};
12use embassy_nrf::ppi::{Event, Ppi, Task};
13use embassy_nrf::uarte::Uarte;
14use embassy_nrf::{bind_interrupts, pac, peripherals, uarte};
15use embassy_time::Timer;
16use {defmt_rtt as _, panic_probe as _};
17
18bind_interrupts!(struct Irqs {
19 UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
20 UARTE1 => uarte::InterruptHandler<peripherals::UARTE1>;
21});
22
23#[embassy_executor::main]
24async fn main(_spawner: Spawner) {
25 let mut p = embassy_nrf::init(Default::default());
26 let mut config = uarte::Config::default();
27 config.parity = uarte::Parity::EXCLUDED;
28 config.baudrate = uarte::Baudrate::BAUD1M;
29
30 let mut tx_buffer = [0u8; 1024];
31 let mut rx_buffer = [0u8; 1024];
32
33 mem::forget(Output::new(&mut p.P1_02, Level::High, OutputDrive::Standard));
34
35 let mut u = BufferedUarte::new(
36 p.UARTE0,
37 p.TIMER0,
38 p.PPI_CH0,
39 p.PPI_CH1,
40 p.PPI_GROUP0,
41 Irqs,
42 p.P1_03,
43 p.P1_04,
44 config.clone(),
45 &mut rx_buffer,
46 &mut tx_buffer,
47 );
48
49 info!("uarte initialized!");
50
51 // uarte needs some quiet time to start rxing properly.
52 Timer::after_millis(10).await;
53
54 // Tx spam in a loop.
55 const NSPAM: usize = 17;
56 static mut TX_BUF: [u8; NSPAM] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
57 let _spam = Uarte::new(p.UARTE1, Irqs, p.P1_01, p.P1_02, config.clone());
58 let spam_peri: pac::UARTE1 = unsafe { mem::transmute(()) };
59 let event = unsafe { Event::new_unchecked(NonNull::new_unchecked(&spam_peri.events_endtx as *const _ as _)) };
60 let task = unsafe { Task::new_unchecked(NonNull::new_unchecked(&spam_peri.tasks_starttx as *const _ as _)) };
61 let mut spam_ppi = Ppi::new_one_to_one(p.PPI_CH2, event, task);
62 spam_ppi.enable();
63 let p = unsafe { TX_BUF.as_mut_ptr() };
64 spam_peri.txd.ptr.write(|w| unsafe { w.ptr().bits(p as u32) });
65 spam_peri.txd.maxcnt.write(|w| unsafe { w.maxcnt().bits(NSPAM as _) });
66 spam_peri.tasks_starttx.write(|w| unsafe { w.bits(1) });
67
68 let mut i = 0;
69 let mut total = 0;
70 while total < 256 * 1024 {
71 let buf = unwrap!(u.fill_buf().await);
72 //info!("rx {}", buf);
73
74 for &b in buf {
75 assert_eq!(b, unsafe { TX_BUF[i] });
76
77 i = i + 1;
78 if i == NSPAM {
79 i = 0;
80 }
81 }
82
83 // Read bytes have to be explicitly consumed, otherwise fill_buf() will return them again
84 let n = buf.len();
85 u.consume(n);
86 total += n;
87 }
88
89 info!("Test OK");
90 cortex_m::asm::bkpt();
91}
diff --git a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
deleted file mode 100644
index 33c2f4235..000000000
--- a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
+++ /dev/null
@@ -1,90 +0,0 @@
1#![no_std]
2#![no_main]
3teleprobe_meta::target!(b"ak-gwe-r7");
4teleprobe_meta::timeout!(120);
5
6use defmt::{info, unwrap};
7use embassy_executor::Spawner;
8use embassy_net::{Stack, StackResources};
9use embassy_net_enc28j60::Enc28j60;
10use embassy_nrf::gpio::{Level, Output, OutputDrive};
11use embassy_nrf::rng::Rng;
12use embassy_nrf::spim::{self, Spim};
13use embassy_nrf::{bind_interrupts, peripherals};
14use embassy_time::Delay;
15use embedded_hal_bus::spi::ExclusiveDevice;
16use static_cell::StaticCell;
17use {defmt_rtt as _, panic_probe as _};
18
19bind_interrupts!(struct Irqs {
20 SPIM3 => spim::InterruptHandler<peripherals::SPI3>;
21 RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
22});
23
24type MyDriver = Enc28j60<ExclusiveDevice<Spim<'static, peripherals::SPI3>, Output<'static>, Delay>, Output<'static>>;
25
26#[embassy_executor::task]
27async fn net_task(stack: &'static Stack<MyDriver>) -> ! {
28 stack.run().await
29}
30
31#[embassy_executor::main]
32async fn main(spawner: Spawner) {
33 let p = embassy_nrf::init(Default::default());
34 info!("running!");
35
36 let eth_sck = p.P0_20;
37 let eth_mosi = p.P0_22;
38 let eth_miso = p.P0_24;
39 let eth_cs = p.P0_15;
40 let eth_rst = p.P0_13;
41 let _eth_irq = p.P0_12;
42
43 let mut config = spim::Config::default();
44 config.frequency = spim::Frequency::M16;
45 let spi = spim::Spim::new(p.SPI3, Irqs, eth_sck, eth_miso, eth_mosi, config);
46 let cs = Output::new(eth_cs, Level::High, OutputDrive::Standard);
47 let spi = ExclusiveDevice::new(spi, cs, Delay);
48
49 let rst = Output::new(eth_rst, Level::High, OutputDrive::Standard);
50 let mac_addr = [2, 3, 4, 5, 6, 7];
51 let device = Enc28j60::new(spi, Some(rst), mac_addr);
52
53 let config = embassy_net::Config::dhcpv4(Default::default());
54 // let config = embassy_net::Config::ipv4_static(embassy_net::StaticConfigV4 {
55 // address: Ipv4Cidr::new(Ipv4Address::new(10, 42, 0, 61), 24),
56 // dns_servers: Vec::new(),
57 // gateway: Some(Ipv4Address::new(10, 42, 0, 1)),
58 // });
59
60 // Generate random seed
61 let mut rng = Rng::new(p.RNG, Irqs);
62 let mut seed = [0; 8];
63 rng.blocking_fill_bytes(&mut seed);
64 let seed = u64::from_le_bytes(seed);
65
66 // Init network stack
67 static STACK: StaticCell<Stack<MyDriver>> = StaticCell::new();
68 static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
69 let stack = &*STACK.init(Stack::new(
70 device,
71 config,
72 RESOURCES.init(StackResources::<2>::new()),
73 seed,
74 ));
75
76 unwrap!(spawner.spawn(net_task(stack)));
77
78 perf_client::run(
79 stack,
80 perf_client::Expected {
81 down_kbps: 200,
82 up_kbps: 200,
83 updown_kbps: 150,
84 },
85 )
86 .await;
87
88 info!("Test OK");
89 cortex_m::asm::bkpt();
90}
diff --git a/tests/nrf/src/bin/timer.rs b/tests/nrf/src/bin/timer.rs
deleted file mode 100644
index 2a147e7ba..000000000
--- a/tests/nrf/src/bin/timer.rs
+++ /dev/null
@@ -1,25 +0,0 @@
1#![no_std]
2#![no_main]
3teleprobe_meta::target!(b"nrf52840-dk");
4
5use defmt::{assert, info};
6use embassy_executor::Spawner;
7use embassy_time::{Instant, Timer};
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 info!("Hello World!");
14
15 let start = Instant::now();
16 Timer::after_millis(100).await;
17 let end = Instant::now();
18 let ms = (end - start).as_millis();
19 info!("slept for {} ms", ms);
20 assert!(ms >= 99);
21 assert!(ms < 110);
22
23 info!("Test OK");
24 cortex_m::asm::bkpt();
25}
diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
deleted file mode 100644
index b83edddc4..000000000
--- a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
+++ /dev/null
@@ -1,111 +0,0 @@
1#![no_std]
2#![no_main]
3teleprobe_meta::target!(b"nrf52840-dk");
4teleprobe_meta::timeout!(120);
5
6use defmt::{info, unwrap};
7use embassy_executor::Spawner;
8use embassy_net::{Config, Stack, StackResources};
9use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
10use embassy_nrf::rng::Rng;
11use embassy_nrf::spim::{self, Spim};
12use embassy_nrf::{bind_interrupts, peripherals};
13use embassy_time::Delay;
14use embedded_hal_bus::spi::ExclusiveDevice;
15use static_cell::StaticCell;
16use {defmt_rtt as _, embassy_net_esp_hosted as hosted, panic_probe as _};
17
18bind_interrupts!(struct Irqs {
19 SPIM3 => spim::InterruptHandler<peripherals::SPI3>;
20 RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
21});
22
23// Test-only wifi network, no internet access!
24const WIFI_NETWORK: &str = "EmbassyTest";
25const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
26
27#[embassy_executor::task]
28async fn wifi_task(
29 runner: hosted::Runner<
30 'static,
31 ExclusiveDevice<Spim<'static, peripherals::SPI3>, Output<'static>, Delay>,
32 Input<'static>,
33 Output<'static>,
34 >,
35) -> ! {
36 runner.run().await
37}
38
39type MyDriver = hosted::NetDriver<'static>;
40
41#[embassy_executor::task]
42async fn net_task(stack: &'static Stack<MyDriver>) -> ! {
43 stack.run().await
44}
45
46#[embassy_executor::main]
47async fn main(spawner: Spawner) {
48 info!("Hello World!");
49
50 let p = embassy_nrf::init(Default::default());
51
52 let miso = p.P0_28;
53 let sck = p.P0_29;
54 let mosi = p.P0_30;
55 let cs = Output::new(p.P0_31, Level::High, OutputDrive::HighDrive);
56 let handshake = Input::new(p.P1_01, Pull::Up);
57 let ready = Input::new(p.P1_04, Pull::None);
58 let reset = Output::new(p.P1_05, Level::Low, OutputDrive::Standard);
59
60 let mut config = spim::Config::default();
61 config.frequency = spim::Frequency::M32;
62 config.mode = spim::MODE_2; // !!!
63 let spi = spim::Spim::new(p.SPI3, Irqs, sck, miso, mosi, config);
64 let spi = ExclusiveDevice::new(spi, cs, Delay);
65
66 static STATE: StaticCell<embassy_net_esp_hosted::State> = StaticCell::new();
67 let (device, mut control, runner) = embassy_net_esp_hosted::new(
68 STATE.init(embassy_net_esp_hosted::State::new()),
69 spi,
70 handshake,
71 ready,
72 reset,
73 )
74 .await;
75
76 unwrap!(spawner.spawn(wifi_task(runner)));
77
78 unwrap!(control.init().await);
79 unwrap!(control.connect(WIFI_NETWORK, WIFI_PASSWORD).await);
80
81 // Generate random seed
82 let mut rng = Rng::new(p.RNG, Irqs);
83 let mut seed = [0; 8];
84 rng.blocking_fill_bytes(&mut seed);
85 let seed = u64::from_le_bytes(seed);
86
87 // Init network stack
88 static STACK: StaticCell<Stack<MyDriver>> = StaticCell::new();
89 static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
90 let stack = &*STACK.init(Stack::new(
91 device,
92 Config::dhcpv4(Default::default()),
93 RESOURCES.init(StackResources::<2>::new()),
94 seed,
95 ));
96
97 unwrap!(spawner.spawn(net_task(stack)));
98
99 perf_client::run(
100 stack,
101 perf_client::Expected {
102 down_kbps: 50,
103 up_kbps: 50,
104 updown_kbps: 50,
105 },
106 )
107 .await;
108
109 info!("Test OK");
110 cortex_m::asm::bkpt();
111}
generated by cgit (git 2.34.1) at 2026-04-05 23:36:34 +0000