aboutsummaryrefslogtreecommitdiff
path: root/tests/rp/src
diff options
context:
space:
mode:
authorDario Nieuwenhuis <[email protected]>2023-09-28 03:46:33 +0200
committerDario Nieuwenhuis <[email protected]>2023-09-28 03:47:14 +0200
commitd9eae79f3eea8bf968f61e476b599e9f8dc97aa8 (patch)
treee85f0fffe523aa863e9269812982ce2fd1ca8b97 /tests/rp/src
parent3d1b4116eccec80ecdaacb1fab9f2a6dbe5800f4 (diff)
test: deduplicate net perf test code.
Diffstat (limited to 'tests/rp/src')
-rw-r--r--tests/rp/src/bin/cyw43-perf.rs189
-rw-r--r--tests/rp/src/bin/ethernet_w5100s_perf.rs182
2 files changed, 27 insertions, 344 deletions
diff --git a/tests/rp/src/bin/cyw43-perf.rs b/tests/rp/src/bin/cyw43-perf.rs
index 1c665f95d..de29c06dd 100644
--- a/tests/rp/src/bin/cyw43-perf.rs
+++ b/tests/rp/src/bin/cyw43-perf.rs
@@ -4,16 +4,13 @@
4teleprobe_meta::target!(b"rpi-pico"); 4teleprobe_meta::target!(b"rpi-pico");
5 5
6use cyw43_pio::PioSpi; 6use cyw43_pio::PioSpi;
7use defmt::{assert, panic, *}; 7use defmt::{panic, *};
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_futures::join::join; 9use embassy_net::{Config, Stack, StackResources};
10use embassy_net::tcp::TcpSocket;
11use embassy_net::{Config, Ipv4Address, Stack, StackResources};
12use embassy_rp::gpio::{Level, Output}; 10use embassy_rp::gpio::{Level, Output};
13use embassy_rp::peripherals::{DMA_CH0, PIN_23, PIN_25, PIO0}; 11use embassy_rp::peripherals::{DMA_CH0, PIN_23, PIN_25, PIO0};
14use embassy_rp::pio::{InterruptHandler, Pio}; 12use embassy_rp::pio::{InterruptHandler, Pio};
15use embassy_rp::{bind_interrupts, rom_data}; 13use embassy_rp::{bind_interrupts, rom_data};
16use embassy_time::{with_timeout, Duration, Timer};
17use static_cell::make_static; 14use static_cell::make_static;
18use {defmt_rtt as _, panic_probe as _}; 15use {defmt_rtt as _, panic_probe as _};
19 16
@@ -23,6 +20,10 @@ bind_interrupts!(struct Irqs {
23 20
24teleprobe_meta::timeout!(120); 21teleprobe_meta::timeout!(120);
25 22
23// Test-only wifi network, no internet access!
24const WIFI_NETWORK: &str = "EmbassyTest";
25const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
26
26#[embassy_executor::task] 27#[embassy_executor::task]
27async fn wifi_task( 28async fn wifi_task(
28 runner: cyw43::Runner<'static, Output<'static, PIN_23>, PioSpi<'static, PIN_25, PIO0, 0, DMA_CH0>>, 29 runner: cyw43::Runner<'static, Output<'static, PIN_23>, PioSpi<'static, PIN_25, PIO0, 0, DMA_CH0>>,
@@ -88,176 +89,16 @@ async fn main(spawner: Spawner) {
88 } 89 }
89 } 90 }
90 91
91 info!("Waiting for DHCP up..."); 92 perf_client::run(
92 while stack.config_v4().is_none() { 93 stack,
93 Timer::after(Duration::from_millis(100)).await; 94 perf_client::Expected {
94 } 95 down_kbps: 300,
95 info!("IP addressing up!"); 96 up_kbps: 300,
96 97 updown_kbps: 300,
97 let down = test_download(stack).await; 98 },
98 let up = test_upload(stack).await; 99 )
99 let updown = test_upload_download(stack).await; 100 .await;
100
101 assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
102 assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
103 assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
104 101
105 info!("Test OK"); 102 info!("Test OK");
106 cortex_m::asm::bkpt(); 103 cortex_m::asm::bkpt();
107} 104}
108
109// Test-only wifi network, no internet access!
110const WIFI_NETWORK: &str = "EmbassyTest";
111const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
112
113const TEST_DURATION: usize = 10;
114const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 300;
115const TEST_EXPECTED_UPLOAD_KBPS: usize = 300;
116const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 300;
117const RX_BUFFER_SIZE: usize = 4096;
118const TX_BUFFER_SIZE: usize = 4096;
119const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
120const DOWNLOAD_PORT: u16 = 4321;
121const UPLOAD_PORT: u16 = 4322;
122const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
123
124async fn test_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
125 info!("Testing download...");
126
127 let mut rx_buffer = [0; RX_BUFFER_SIZE];
128 let mut tx_buffer = [0; TX_BUFFER_SIZE];
129 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
130 socket.set_timeout(Some(Duration::from_secs(10)));
131
132 info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
133 if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
134 error!("connect error: {:?}", e);
135 return 0;
136 }
137 info!("connected, testing...");
138
139 let mut rx_buf = [0; 4096];
140 let mut total: usize = 0;
141 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
142 loop {
143 match socket.read(&mut rx_buf).await {
144 Ok(0) => {
145 error!("read EOF");
146 return 0;
147 }
148 Ok(n) => total += n,
149 Err(e) => {
150 error!("read error: {:?}", e);
151 return 0;
152 }
153 }
154 }
155 })
156 .await
157 .ok();
158
159 let kbps = (total + 512) / 1024 / TEST_DURATION;
160 info!("download: {} kB/s", kbps);
161 kbps
162}
163
164async fn test_upload(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
165 info!("Testing upload...");
166
167 let mut rx_buffer = [0; RX_BUFFER_SIZE];
168 let mut tx_buffer = [0; TX_BUFFER_SIZE];
169 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
170 socket.set_timeout(Some(Duration::from_secs(10)));
171
172 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
173 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
174 error!("connect error: {:?}", e);
175 return 0;
176 }
177 info!("connected, testing...");
178
179 let buf = [0; 4096];
180 let mut total: usize = 0;
181 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
182 loop {
183 match socket.write(&buf).await {
184 Ok(0) => {
185 error!("write zero?!??!?!");
186 return 0;
187 }
188 Ok(n) => total += n,
189 Err(e) => {
190 error!("write error: {:?}", e);
191 return 0;
192 }
193 }
194 }
195 })
196 .await
197 .ok();
198
199 let kbps = (total + 512) / 1024 / TEST_DURATION;
200 info!("upload: {} kB/s", kbps);
201 kbps
202}
203
204async fn test_upload_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
205 info!("Testing upload+download...");
206
207 let mut rx_buffer = [0; RX_BUFFER_SIZE];
208 let mut tx_buffer = [0; TX_BUFFER_SIZE];
209 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
210 socket.set_timeout(Some(Duration::from_secs(10)));
211
212 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
213 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
214 error!("connect error: {:?}", e);
215 return 0;
216 }
217 info!("connected, testing...");
218
219 let (mut reader, mut writer) = socket.split();
220
221 let tx_buf = [0; 4096];
222 let mut rx_buf = [0; 4096];
223 let mut total: usize = 0;
224 let tx_fut = async {
225 loop {
226 match writer.write(&tx_buf).await {
227 Ok(0) => {
228 error!("write zero?!??!?!");
229 return 0;
230 }
231 Ok(_) => {}
232 Err(e) => {
233 error!("write error: {:?}", e);
234 return 0;
235 }
236 }
237 }
238 };
239
240 let rx_fut = async {
241 loop {
242 match reader.read(&mut rx_buf).await {
243 Ok(0) => {
244 error!("read EOF");
245 return 0;
246 }
247 Ok(n) => total += n,
248 Err(e) => {
249 error!("read error: {:?}", e);
250 return 0;
251 }
252 }
253 }
254 };
255
256 with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
257 .await
258 .ok();
259
260 let kbps = (total + 512) / 1024 / TEST_DURATION;
261 info!("upload+download: {} kB/s", kbps);
262 kbps
263}
diff --git a/tests/rp/src/bin/ethernet_w5100s_perf.rs b/tests/rp/src/bin/ethernet_w5100s_perf.rs
index faa8638c0..a4d253b3c 100644
--- a/tests/rp/src/bin/ethernet_w5100s_perf.rs
+++ b/tests/rp/src/bin/ethernet_w5100s_perf.rs
@@ -4,18 +4,16 @@
4teleprobe_meta::target!(b"w5100s-evb-pico"); 4teleprobe_meta::target!(b"w5100s-evb-pico");
5teleprobe_meta::timeout!(120); 5teleprobe_meta::timeout!(120);
6 6
7use defmt::{assert, *}; 7use defmt::*;
8use embassy_executor::Spawner; 8use embassy_executor::Spawner;
9use embassy_futures::join::join; 9use embassy_net::{Stack, StackResources};
10use embassy_net::tcp::TcpSocket;
11use embassy_net::{Ipv4Address, Stack, StackResources};
12use embassy_net_wiznet::chip::W5100S; 10use embassy_net_wiznet::chip::W5100S;
13use embassy_net_wiznet::*; 11use embassy_net_wiznet::*;
14use embassy_rp::clocks::RoscRng; 12use embassy_rp::clocks::RoscRng;
15use embassy_rp::gpio::{Input, Level, Output, Pull}; 13use embassy_rp::gpio::{Input, Level, Output, Pull};
16use embassy_rp::peripherals::{PIN_17, PIN_20, PIN_21, SPI0}; 14use embassy_rp::peripherals::{PIN_17, PIN_20, PIN_21, SPI0};
17use embassy_rp::spi::{Async, Config as SpiConfig, Spi}; 15use embassy_rp::spi::{Async, Config as SpiConfig, Spi};
18use embassy_time::{with_timeout, Delay, Duration, Timer}; 16use embassy_time::Delay;
19use embedded_hal_bus::spi::ExclusiveDevice; 17use embedded_hal_bus::spi::ExclusiveDevice;
20use rand::RngCore; 18use rand::RngCore;
21use static_cell::make_static; 19use static_cell::make_static;
@@ -78,172 +76,16 @@ async fn main(spawner: Spawner) {
78 // Launch network task 76 // Launch network task
79 unwrap!(spawner.spawn(net_task(&stack))); 77 unwrap!(spawner.spawn(net_task(&stack)));
80 78
81 info!("Waiting for DHCP up..."); 79 perf_client::run(
82 while stack.config_v4().is_none() { 80 stack,
83 Timer::after(Duration::from_millis(100)).await; 81 perf_client::Expected {
84 } 82 down_kbps: 500,
85 info!("IP addressing up!"); 83 up_kbps: 500,
86 84 updown_kbps: 300,
87 let down = test_download(stack).await; 85 },
88 let up = test_upload(stack).await; 86 )
89 let updown = test_upload_download(stack).await; 87 .await;
90
91 assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
92 assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
93 assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
94 88
95 info!("Test OK"); 89 info!("Test OK");
96 cortex_m::asm::bkpt(); 90 cortex_m::asm::bkpt();
97} 91}
98
99const TEST_DURATION: usize = 10;
100const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 500;
101const TEST_EXPECTED_UPLOAD_KBPS: usize = 500;
102const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 300;
103const RX_BUFFER_SIZE: usize = 4096;
104const TX_BUFFER_SIZE: usize = 4096;
105const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
106const DOWNLOAD_PORT: u16 = 4321;
107const UPLOAD_PORT: u16 = 4322;
108const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
109
110async fn test_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
111 info!("Testing download...");
112
113 let mut rx_buffer = [0; RX_BUFFER_SIZE];
114 let mut tx_buffer = [0; TX_BUFFER_SIZE];
115 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
116 socket.set_timeout(Some(Duration::from_secs(10)));
117
118 info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
119 if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
120 error!("connect error: {:?}", e);
121 return 0;
122 }
123 info!("connected, testing...");
124
125 let mut rx_buf = [0; 4096];
126 let mut total: usize = 0;
127 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
128 loop {
129 match socket.read(&mut rx_buf).await {
130 Ok(0) => {
131 error!("read EOF");
132 return 0;
133 }
134 Ok(n) => total += n,
135 Err(e) => {
136 error!("read error: {:?}", e);
137 return 0;
138 }
139 }
140 }
141 })
142 .await
143 .ok();
144
145 let kbps = (total + 512) / 1024 / TEST_DURATION;
146 info!("download: {} kB/s", kbps);
147 kbps
148}
149
150async fn test_upload(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
151 info!("Testing upload...");
152
153 let mut rx_buffer = [0; RX_BUFFER_SIZE];
154 let mut tx_buffer = [0; TX_BUFFER_SIZE];
155 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
156 socket.set_timeout(Some(Duration::from_secs(10)));
157
158 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
159 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
160 error!("connect error: {:?}", e);
161 return 0;
162 }
163 info!("connected, testing...");
164
165 let buf = [0; 4096];
166 let mut total: usize = 0;
167 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
168 loop {
169 match socket.write(&buf).await {
170 Ok(0) => {
171 error!("write zero?!??!?!");
172 return 0;
173 }
174 Ok(n) => total += n,
175 Err(e) => {
176 error!("write error: {:?}", e);
177 return 0;
178 }
179 }
180 }
181 })
182 .await
183 .ok();
184
185 let kbps = (total + 512) / 1024 / TEST_DURATION;
186 info!("upload: {} kB/s", kbps);
187 kbps
188}
189
190async fn test_upload_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
191 info!("Testing upload+download...");
192
193 let mut rx_buffer = [0; RX_BUFFER_SIZE];
194 let mut tx_buffer = [0; TX_BUFFER_SIZE];
195 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
196 socket.set_timeout(Some(Duration::from_secs(10)));
197
198 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
199 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
200 error!("connect error: {:?}", e);
201 return 0;
202 }
203 info!("connected, testing...");
204
205 let (mut reader, mut writer) = socket.split();
206
207 let tx_buf = [0; 4096];
208 let mut rx_buf = [0; 4096];
209 let mut total: usize = 0;
210 let tx_fut = async {
211 loop {
212 match writer.write(&tx_buf).await {
213 Ok(0) => {
214 error!("write zero?!??!?!");
215 return 0;
216 }
217 Ok(_) => {}
218 Err(e) => {
219 error!("write error: {:?}", e);
220 return 0;
221 }
222 }
223 }
224 };
225
226 let rx_fut = async {
227 loop {
228 match reader.read(&mut rx_buf).await {
229 Ok(0) => {
230 error!("read EOF");
231 return 0;
232 }
233 Ok(n) => total += n,
234 Err(e) => {
235 error!("read error: {:?}", e);
236 return 0;
237 }
238 }
239 }
240 };
241
242 with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
243 .await
244 .ok();
245
246 let kbps = (total + 512) / 1024 / TEST_DURATION;
247 info!("upload+download: {} kB/s", kbps);
248 kbps
249}
generated by cgit (git 2.34.1) at 2026-04-06 03:46:46 +0000