aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--tests/nrf/Cargo.toml1
-rw-r--r--tests/nrf/src/bin/ethernet_enc28j60_perf.rs182
-rw-r--r--tests/nrf/src/bin/wifi_esp_hosted_perf.rs190
-rw-r--r--tests/perf-client/Cargo.toml12
-rw-r--r--tests/perf-client/src/lib.rs179
-rw-r--r--tests/rp/Cargo.toml1
-rw-r--r--tests/rp/src/bin/cyw43-perf.rs189
-rw-r--r--tests/rp/src/bin/ethernet_w5100s_perf.rs182
8 files changed, 248 insertions, 688 deletions
diff --git a/tests/nrf/Cargo.toml b/tests/nrf/Cargo.toml
index b3d214684..08fe1a4b5 100644
--- a/tests/nrf/Cargo.toml
+++ b/tests/nrf/Cargo.toml
@@ -19,6 +19,7 @@ embassy-net-enc28j60 = { version = "0.1.0", path = "../../embassy-net-enc28j60",
19embedded-hal-async = { version = "1.0.0-rc.1" } 19embedded-hal-async = { version = "1.0.0-rc.1" }
20embedded-hal-bus = { version = "0.1.0-rc.1", features = ["async"] } 20embedded-hal-bus = { version = "0.1.0-rc.1", features = ["async"] }
21static_cell = { version = "1.1", features = [ "nightly" ] } 21static_cell = { version = "1.1", features = [ "nightly" ] }
22perf-client = { path = "../perf-client" }
22 23
23defmt = "0.3" 24defmt = "0.3"
24defmt-rtt = "0.4" 25defmt-rtt = "0.4"
diff --git a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
index 0446d39ac..60d30a2ff 100644
--- a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
+++ b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
@@ -4,17 +4,15 @@
4teleprobe_meta::target!(b"ak-gwe-r7"); 4teleprobe_meta::target!(b"ak-gwe-r7");
5teleprobe_meta::timeout!(120); 5teleprobe_meta::timeout!(120);
6 6
7use defmt::{error, info, unwrap}; 7use defmt::{info, unwrap};
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_enc28j60::Enc28j60; 10use embassy_net_enc28j60::Enc28j60;
13use embassy_nrf::gpio::{Level, Output, OutputDrive}; 11use embassy_nrf::gpio::{Level, Output, OutputDrive};
14use embassy_nrf::rng::Rng; 12use embassy_nrf::rng::Rng;
15use embassy_nrf::spim::{self, Spim}; 13use embassy_nrf::spim::{self, Spim};
16use embassy_nrf::{bind_interrupts, peripherals}; 14use embassy_nrf::{bind_interrupts, peripherals};
17use embassy_time::{with_timeout, Delay, Duration, Timer}; 15use embassy_time::Delay;
18use embedded_hal_bus::spi::ExclusiveDevice; 16use embedded_hal_bus::spi::ExclusiveDevice;
19use static_cell::make_static; 17use static_cell::make_static;
20use {defmt_rtt as _, panic_probe as _}; 18use {defmt_rtt as _, panic_probe as _};
@@ -79,172 +77,16 @@ async fn main(spawner: Spawner) {
79 77
80 unwrap!(spawner.spawn(net_task(stack))); 78 unwrap!(spawner.spawn(net_task(stack)));
81 79
82 info!("Waiting for DHCP up..."); 80 perf_client::run(
83 while stack.config_v4().is_none() { 81 stack,
84 Timer::after(Duration::from_millis(100)).await; 82 perf_client::Expected {
85 } 83 down_kbps: 200,
86 info!("IP addressing up!"); 84 up_kbps: 200,
87 85 updown_kbps: 150,
88 let down = test_download(stack).await; 86 },
89 let up = test_upload(stack).await; 87 )
90 let updown = test_upload_download(stack).await; 88 .await;
91
92 assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
93 assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
94 assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
95 89
96 info!("Test OK"); 90 info!("Test OK");
97 cortex_m::asm::bkpt(); 91 cortex_m::asm::bkpt();
98} 92}
99
100const TEST_DURATION: usize = 10;
101const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 200;
102const TEST_EXPECTED_UPLOAD_KBPS: usize = 200;
103const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 150;
104const RX_BUFFER_SIZE: usize = 4096;
105const TX_BUFFER_SIZE: usize = 4096;
106const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
107const DOWNLOAD_PORT: u16 = 4321;
108const UPLOAD_PORT: u16 = 4322;
109const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
110
111async fn test_download(stack: &'static Stack<MyDriver>) -> usize {
112 info!("Testing download...");
113
114 let mut rx_buffer = [0; RX_BUFFER_SIZE];
115 let mut tx_buffer = [0; TX_BUFFER_SIZE];
116 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
117 socket.set_timeout(Some(Duration::from_secs(10)));
118
119 info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
120 if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
121 error!("connect error: {:?}", e);
122 return 0;
123 }
124 info!("connected, testing...");
125
126 let mut rx_buf = [0; 4096];
127 let mut total: usize = 0;
128 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
129 loop {
130 match socket.read(&mut rx_buf).await {
131 Ok(0) => {
132 error!("read EOF");
133 return 0;
134 }
135 Ok(n) => total += n,
136 Err(e) => {
137 error!("read error: {:?}", e);
138 return 0;
139 }
140 }
141 }
142 })
143 .await
144 .ok();
145
146 let kbps = (total + 512) / 1024 / TEST_DURATION;
147 info!("download: {} kB/s", kbps);
148 kbps
149}
150
151async fn test_upload(stack: &'static Stack<MyDriver>) -> usize {
152 info!("Testing upload...");
153
154 let mut rx_buffer = [0; RX_BUFFER_SIZE];
155 let mut tx_buffer = [0; TX_BUFFER_SIZE];
156 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
157 socket.set_timeout(Some(Duration::from_secs(10)));
158
159 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
160 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
161 error!("connect error: {:?}", e);
162 return 0;
163 }
164 info!("connected, testing...");
165
166 let buf = [0; 4096];
167 let mut total: usize = 0;
168 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
169 loop {
170 match socket.write(&buf).await {
171 Ok(0) => {
172 error!("write zero?!??!?!");
173 return 0;
174 }
175 Ok(n) => total += n,
176 Err(e) => {
177 error!("write error: {:?}", e);
178 return 0;
179 }
180 }
181 }
182 })
183 .await
184 .ok();
185
186 let kbps = (total + 512) / 1024 / TEST_DURATION;
187 info!("upload: {} kB/s", kbps);
188 kbps
189}
190
191async fn test_upload_download(stack: &'static Stack<MyDriver>) -> usize {
192 info!("Testing upload+download...");
193
194 let mut rx_buffer = [0; RX_BUFFER_SIZE];
195 let mut tx_buffer = [0; TX_BUFFER_SIZE];
196 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
197 socket.set_timeout(Some(Duration::from_secs(10)));
198
199 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
200 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
201 error!("connect error: {:?}", e);
202 return 0;
203 }
204 info!("connected, testing...");
205
206 let (mut reader, mut writer) = socket.split();
207
208 let tx_buf = [0; 4096];
209 let mut rx_buf = [0; 4096];
210 let mut total: usize = 0;
211 let tx_fut = async {
212 loop {
213 match writer.write(&tx_buf).await {
214 Ok(0) => {
215 error!("write zero?!??!?!");
216 return 0;
217 }
218 Ok(_) => {}
219 Err(e) => {
220 error!("write error: {:?}", e);
221 return 0;
222 }
223 }
224 }
225 };
226
227 let rx_fut = async {
228 loop {
229 match reader.read(&mut rx_buf).await {
230 Ok(0) => {
231 error!("read EOF");
232 return 0;
233 }
234 Ok(n) => total += n,
235 Err(e) => {
236 error!("read error: {:?}", e);
237 return 0;
238 }
239 }
240 }
241 };
242
243 with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
244 .await
245 .ok();
246
247 let kbps = (total + 512) / 1024 / TEST_DURATION;
248 info!("upload+download: {} kB/s", kbps);
249 kbps
250}
diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
index 97ebafec8..9eee39ccf 100644
--- a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -4,16 +4,14 @@
4teleprobe_meta::target!(b"nrf52840-dk"); 4teleprobe_meta::target!(b"nrf52840-dk");
5teleprobe_meta::timeout!(120); 5teleprobe_meta::timeout!(120);
6 6
7use defmt::{error, info, unwrap}; 7use defmt::{info, unwrap};
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_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull}; 10use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull};
13use embassy_nrf::rng::Rng; 11use embassy_nrf::rng::Rng;
14use embassy_nrf::spim::{self, Spim}; 12use embassy_nrf::spim::{self, Spim};
15use embassy_nrf::{bind_interrupts, peripherals}; 13use embassy_nrf::{bind_interrupts, peripherals};
16use embassy_time::{with_timeout, Delay, Duration, Timer}; 14use embassy_time::Delay;
17use embedded_hal_bus::spi::ExclusiveDevice; 15use embedded_hal_bus::spi::ExclusiveDevice;
18use static_cell::make_static; 16use static_cell::make_static;
19use {defmt_rtt as _, embassy_net_esp_hosted as hosted, panic_probe as _}; 17use {defmt_rtt as _, embassy_net_esp_hosted as hosted, panic_probe as _};
@@ -23,6 +21,10 @@ bind_interrupts!(struct Irqs {
23 RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>; 21 RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
24}); 22});
25 23
24// Test-only wifi network, no internet access!
25const WIFI_NETWORK: &str = "EmbassyTest";
26const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
27
26#[embassy_executor::task] 28#[embassy_executor::task]
27async fn wifi_task( 29async fn wifi_task(
28 runner: hosted::Runner< 30 runner: hosted::Runner<
@@ -92,176 +94,16 @@ async fn main(spawner: Spawner) {
92 94
93 unwrap!(spawner.spawn(net_task(stack))); 95 unwrap!(spawner.spawn(net_task(stack)));
94 96
95 info!("Waiting for DHCP up..."); 97 perf_client::run(
96 while stack.config_v4().is_none() { 98 stack,
97 Timer::after(Duration::from_millis(100)).await; 99 perf_client::Expected {
98 } 100 down_kbps: 50,
99 info!("IP addressing up!"); 101 up_kbps: 50,
100 102 updown_kbps: 50,
101 let down = test_download(stack).await; 103 },
102 let up = test_upload(stack).await; 104 )
103 let updown = test_upload_download(stack).await; 105 .await;
104
105 assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
106 assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
107 assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
108 106
109 info!("Test OK"); 107 info!("Test OK");
110 cortex_m::asm::bkpt(); 108 cortex_m::asm::bkpt();
111} 109}
112
113// Test-only wifi network, no internet access!
114const WIFI_NETWORK: &str = "EmbassyTest";
115const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
116
117const TEST_DURATION: usize = 10;
118const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 50;
119const TEST_EXPECTED_UPLOAD_KBPS: usize = 50;
120const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 50;
121const RX_BUFFER_SIZE: usize = 4096;
122const TX_BUFFER_SIZE: usize = 4096;
123const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
124const DOWNLOAD_PORT: u16 = 4321;
125const UPLOAD_PORT: u16 = 4322;
126const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
127
128async fn test_download(stack: &'static Stack<MyDriver>) -> usize {
129 info!("Testing download...");
130
131 let mut rx_buffer = [0; RX_BUFFER_SIZE];
132 let mut tx_buffer = [0; TX_BUFFER_SIZE];
133 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
134 socket.set_timeout(Some(Duration::from_secs(10)));
135
136 info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
137 if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
138 error!("connect error: {:?}", e);
139 return 0;
140 }
141 info!("connected, testing...");
142
143 let mut rx_buf = [0; 4096];
144 let mut total: usize = 0;
145 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
146 loop {
147 match socket.read(&mut rx_buf).await {
148 Ok(0) => {
149 error!("read EOF");
150 return 0;
151 }
152 Ok(n) => total += n,
153 Err(e) => {
154 error!("read error: {:?}", e);
155 return 0;
156 }
157 }
158 }
159 })
160 .await
161 .ok();
162
163 let kbps = (total + 512) / 1024 / TEST_DURATION;
164 info!("download: {} kB/s", kbps);
165 kbps
166}
167
168async fn test_upload(stack: &'static Stack<MyDriver>) -> usize {
169 info!("Testing upload...");
170
171 let mut rx_buffer = [0; RX_BUFFER_SIZE];
172 let mut tx_buffer = [0; TX_BUFFER_SIZE];
173 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
174 socket.set_timeout(Some(Duration::from_secs(10)));
175
176 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
177 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
178 error!("connect error: {:?}", e);
179 return 0;
180 }
181 info!("connected, testing...");
182
183 let buf = [0; 4096];
184 let mut total: usize = 0;
185 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
186 loop {
187 match socket.write(&buf).await {
188 Ok(0) => {
189 error!("write zero?!??!?!");
190 return 0;
191 }
192 Ok(n) => total += n,
193 Err(e) => {
194 error!("write error: {:?}", e);
195 return 0;
196 }
197 }
198 }
199 })
200 .await
201 .ok();
202
203 let kbps = (total + 512) / 1024 / TEST_DURATION;
204 info!("upload: {} kB/s", kbps);
205 kbps
206}
207
208async fn test_upload_download(stack: &'static Stack<MyDriver>) -> usize {
209 info!("Testing upload+download...");
210
211 let mut rx_buffer = [0; RX_BUFFER_SIZE];
212 let mut tx_buffer = [0; TX_BUFFER_SIZE];
213 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
214 socket.set_timeout(Some(Duration::from_secs(10)));
215
216 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
217 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
218 error!("connect error: {:?}", e);
219 return 0;
220 }
221 info!("connected, testing...");
222
223 let (mut reader, mut writer) = socket.split();
224
225 let tx_buf = [0; 4096];
226 let mut rx_buf = [0; 4096];
227 let mut total: usize = 0;
228 let tx_fut = async {
229 loop {
230 match writer.write(&tx_buf).await {
231 Ok(0) => {
232 error!("write zero?!??!?!");
233 return 0;
234 }
235 Ok(_) => {}
236 Err(e) => {
237 error!("write error: {:?}", e);
238 return 0;
239 }
240 }
241 }
242 };
243
244 let rx_fut = async {
245 loop {
246 match reader.read(&mut rx_buf).await {
247 Ok(0) => {
248 error!("read EOF");
249 return 0;
250 }
251 Ok(n) => total += n,
252 Err(e) => {
253 error!("read error: {:?}", e);
254 return 0;
255 }
256 }
257 }
258 };
259
260 with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
261 .await
262 .ok();
263
264 let kbps = (total + 512) / 1024 / TEST_DURATION;
265 info!("upload+download: {} kB/s", kbps);
266 kbps
267}
diff --git a/tests/perf-client/Cargo.toml b/tests/perf-client/Cargo.toml
new file mode 100644
index 000000000..3284664d9
--- /dev/null
+++ b/tests/perf-client/Cargo.toml
@@ -0,0 +1,12 @@
1[package]
2name = "perf-client"
3version = "0.1.0"
4edition = "2021"
5
6# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7
8[dependencies]
9embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4"] }
10embassy-time = { version = "0.1.3", path = "../../embassy-time", features = ["defmt", "nightly", "unstable-traits"] }
11embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
12defmt = "0.3.0"
diff --git a/tests/perf-client/src/lib.rs b/tests/perf-client/src/lib.rs
new file mode 100644
index 000000000..a36147dbb
--- /dev/null
+++ b/tests/perf-client/src/lib.rs
@@ -0,0 +1,179 @@
1#![no_std]
2
3use defmt::{assert, *};
4use embassy_futures::join::join;
5use embassy_net::driver::Driver;
6use embassy_net::tcp::TcpSocket;
7use embassy_net::{Ipv4Address, Stack};
8use embassy_time::{with_timeout, Duration, Timer};
9
10pub struct Expected {
11 pub down_kbps: usize,
12 pub up_kbps: usize,
13 pub updown_kbps: usize,
14}
15
16pub async fn run<D: Driver>(stack: &Stack<D>, expected: Expected) {
17 info!("Waiting for DHCP up...");
18 while stack.config_v4().is_none() {
19 Timer::after(Duration::from_millis(100)).await;
20 }
21 info!("IP addressing up!");
22
23 let down = test_download(stack).await;
24 let up = test_upload(stack).await;
25 let updown = test_upload_download(stack).await;
26
27 assert!(down > expected.down_kbps);
28 assert!(up > expected.up_kbps);
29 assert!(updown > expected.updown_kbps);
30}
31
32const TEST_DURATION: usize = 10;
33const RX_BUFFER_SIZE: usize = 4096;
34const TX_BUFFER_SIZE: usize = 4096;
35const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
36const DOWNLOAD_PORT: u16 = 4321;
37const UPLOAD_PORT: u16 = 4322;
38const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
39
40async fn test_download<D: Driver>(stack: &Stack<D>) -> usize {
41 info!("Testing download...");
42
43 let mut rx_buffer = [0; RX_BUFFER_SIZE];
44 let mut tx_buffer = [0; TX_BUFFER_SIZE];
45 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
46 socket.set_timeout(Some(Duration::from_secs(10)));
47
48 info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
49 if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
50 error!("connect error: {:?}", e);
51 return 0;
52 }
53 info!("connected, testing...");
54
55 let mut rx_buf = [0; 4096];
56 let mut total: usize = 0;
57 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
58 loop {
59 match socket.read(&mut rx_buf).await {
60 Ok(0) => {
61 error!("read EOF");
62 return 0;
63 }
64 Ok(n) => total += n,
65 Err(e) => {
66 error!("read error: {:?}", e);
67 return 0;
68 }
69 }
70 }
71 })
72 .await
73 .ok();
74
75 let kbps = (total + 512) / 1024 / TEST_DURATION;
76 info!("download: {} kB/s", kbps);
77 kbps
78}
79
80async fn test_upload<D: Driver>(stack: &Stack<D>) -> usize {
81 info!("Testing upload...");
82
83 let mut rx_buffer = [0; RX_BUFFER_SIZE];
84 let mut tx_buffer = [0; TX_BUFFER_SIZE];
85 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
86 socket.set_timeout(Some(Duration::from_secs(10)));
87
88 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
89 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
90 error!("connect error: {:?}", e);
91 return 0;
92 }
93 info!("connected, testing...");
94
95 let buf = [0; 4096];
96 let mut total: usize = 0;
97 with_timeout(Duration::from_secs(TEST_DURATION as _), async {
98 loop {
99 match socket.write(&buf).await {
100 Ok(0) => {
101 error!("write zero?!??!?!");
102 return 0;
103 }
104 Ok(n) => total += n,
105 Err(e) => {
106 error!("write error: {:?}", e);
107 return 0;
108 }
109 }
110 }
111 })
112 .await
113 .ok();
114
115 let kbps = (total + 512) / 1024 / TEST_DURATION;
116 info!("upload: {} kB/s", kbps);
117 kbps
118}
119
120async fn test_upload_download<D: Driver>(stack: &Stack<D>) -> usize {
121 info!("Testing upload+download...");
122
123 let mut rx_buffer = [0; RX_BUFFER_SIZE];
124 let mut tx_buffer = [0; TX_BUFFER_SIZE];
125 let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
126 socket.set_timeout(Some(Duration::from_secs(10)));
127
128 info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
129 if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
130 error!("connect error: {:?}", e);
131 return 0;
132 }
133 info!("connected, testing...");
134
135 let (mut reader, mut writer) = socket.split();
136
137 let tx_buf = [0; 4096];
138 let mut rx_buf = [0; 4096];
139 let mut total: usize = 0;
140 let tx_fut = async {
141 loop {
142 match writer.write(&tx_buf).await {
143 Ok(0) => {
144 error!("write zero?!??!?!");
145 return 0;
146 }
147 Ok(_) => {}
148 Err(e) => {
149 error!("write error: {:?}", e);
150 return 0;
151 }
152 }
153 }
154 };
155
156 let rx_fut = async {
157 loop {
158 match reader.read(&mut rx_buf).await {
159 Ok(0) => {
160 error!("read EOF");
161 return 0;
162 }
163 Ok(n) => total += n,
164 Err(e) => {
165 error!("read error: {:?}", e);
166 return 0;
167 }
168 }
169 }
170 };
171
172 with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
173 .await
174 .ok();
175
176 let kbps = (total + 512) / 1024 / TEST_DURATION;
177 info!("upload+download: {} kB/s", kbps);
178 kbps
179}
diff --git a/tests/rp/Cargo.toml b/tests/rp/Cargo.toml
index 26e2473c7..8bb0de6c6 100644
--- a/tests/rp/Cargo.toml
+++ b/tests/rp/Cargo.toml
@@ -16,6 +16,7 @@ embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defm
16embassy-net-wiznet = { version = "0.1.0", path = "../../embassy-net-wiznet", features = ["defmt"] } 16embassy-net-wiznet = { version = "0.1.0", path = "../../embassy-net-wiznet", features = ["defmt"] }
17cyw43 = { path = "../../cyw43", features = ["defmt", "firmware-logs"] } 17cyw43 = { path = "../../cyw43", features = ["defmt", "firmware-logs"] }
18cyw43-pio = { path = "../../cyw43-pio", features = ["defmt", "overclock"] } 18cyw43-pio = { path = "../../cyw43-pio", features = ["defmt", "overclock"] }
19perf-client = { path = "../perf-client" }
19 20
20defmt = "0.3.0" 21defmt = "0.3.0"
21defmt-rtt = "0.4" 22defmt-rtt = "0.4"
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-05 20:16:20 +0000