itsscb/esp-hal
1
0
Fork 0
mirror of https://github.com/esp-rs/esp-hal.git synced 2025-09-30 05:40:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update smoltcp to 0.12.0 and embassy-net to 0.5.0 (#2849)

Browse Source 
* chore: Update smoltcp to `0.12.0` and embassy-net to `0.5.0`

* Add CHANGELOG entry

* Remove `wifi_dhcp_smoltcp_nal.rs` example

`smoltcp-nal`, a core dependency on which this example depends on doesn't receive the desired amount of maintainability needed to keep up to date with new dependencies releases.
This commit is contained in:
Anthony Grondin 2025-01-02 04:41:31 -05:00 committed by GitHub
parent 36095e447e
commit 0f384992cf
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 96 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
esp-wifi/CHANGELOG.md
View File

@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Changed
- Bump MSRV to 1.83 (#2615)
- Bump smoltcp to 0.12.0 (#2849)
### Fixed

2
esp-wifi/Cargo.toml
View File

@ -18,7 +18,7 @@ log = { version = "0.4.22", optional = true }
document-features = "0.2.10"
esp-alloc = { version = "0.5.0", path = "../esp-alloc", optional = true }
esp-hal = { version = "0.22.0", path = "../esp-hal", default-features = false }
smoltcp = { version = "0.11.0", default-features = false, features = [
smoltcp = { version = "0.12.0", default-features = false, features = [
"medium-ethernet",
"socket-raw",
], optional = true }

4
esp-wifi/src/wifi/mod.rs
View File

@ -2686,9 +2686,9 @@ impl<Dm: Sealed> WifiRxToken<Dm> {
impl<Dm: Sealed> RxToken for WifiRxToken<Dm> {
fn consume<R, F>(self, f: F) -> R
where
F: FnOnce(&mut [u8]) -> R,
F: FnOnce(&[u8]) -> R,
{
self.consume_token(f)
self.consume_token(|t| f(t))
}
}

12
examples/Cargo.toml
View File

@ -8,13 +8,13 @@ publish = false
[dependencies]
aligned = { version = "0.4.2", optional = true }
bleps = { git = "https://github.com/bjoernQ/bleps", package = "bleps", rev = "a5148d8ae679e021b78f53fd33afb8bb35d0b62e", features = [ "macros", "async"] }
blocking-network-stack = { git = "https://github.com/bjoernQ/blocking-network-stack.git", rev = "1c581661d78e0cf0f17b936297179b993fb149d7" }
blocking-network-stack = { git = "https://github.com/bjoernQ/blocking-network-stack.git", rev = "b3ecefc222d8806edd221f266999ca339c52d34e" }
bt-hci = "0.1.1"
cfg-if = "1.0.0"
critical-section = "1.1.3"
embassy-executor = { version = "0.6.0", features = ["task-arena-size-20480"] }
embassy-futures = "0.1.1"
embassy-net = { version = "0.4.0", features = [ "tcp", "udp", "dhcpv4", "medium-ethernet"] }
embassy-net = { version = "0.5.0", features = [ "tcp", "udp", "dhcpv4", "medium-ethernet"] }
embassy-sync = "0.6.0"
embassy-time = "0.3.2"
embassy-usb = { version = "0.2.0", default-features = false }
@ -40,8 +40,7 @@ log = "0.4.22"
nb = "1.1.0"
portable-atomic = { version = "1.9.0", default-features = false }
sha2 = { version = "0.10.8", default-features = false }
smoltcp = { version = "0.11.0", default-features = false, features = [ "medium-ethernet", "socket-raw"] }
smoltcp-nal = "0.5.1"
smoltcp = { version = "0.12.0", default-features = false, features = [ "medium-ethernet", "socket-raw"] }
embedded-time = "=0.12.1"
static_cell = { version = "2.1.0", features = ["nightly"] }
trouble-host = { git = "https://github.com/embassy-rs/trouble", package = "trouble-host", rev = "4f1114ce58e96fe54f5ed7e726f66e1ad8d9ce54", features = [ "log", "gatt" ] }
@ -74,3 +73,8 @@ incremental = false
opt-level = 3
lto = 'fat'
overflow-checks = false
[patch.crates-io]
# Patch until https://github.com/ivmarkov/edge-net/pull/50 is merged
edge-nal = { git = "https://github.com/ivmarkov/edge-net", rev = "5a85bcc8b8726e8b7044e9526f01cdba1fd684da"}
edge-nal-embassy = { git = "https://github.com/ivmarkov/edge-net", rev = "5a85bcc8b8726e8b7044e9526f01cdba1fd684da"}

6
examples/src/bin/wifi_access_point_with_sta.rs
View File

@ -15,6 +15,8 @@
#![no_std]
#![no_main]
use core::net::Ipv4Addr;
use blocking_network_stack::Stack;
use embedded_io::*;
use esp_alloc as _;
@ -38,7 +40,7 @@ use esp_wifi::{
};
use smoltcp::{
iface::{SocketSet, SocketStorage},
wire::{IpAddress, Ipv4Address},
wire::IpAddress,
};
const SSID: &str = env!("SSID");
@ -183,7 +185,7 @@ fn main() -> ! {
sta_socket.work();
sta_socket
.open(IpAddress::Ipv4(Ipv4Address::new(142, 250, 185, 115)), 80)
.open(IpAddress::Ipv4(Ipv4Addr::new(142, 250, 185, 115)), 80)
.unwrap();
sta_socket

12
examples/src/bin/wifi_bench.rs
View File

@ -14,6 +14,8 @@
#![no_std]
#![no_main]
use core::net::Ipv4Addr;
use blocking_network_stack::Stack;
use embedded_io::*;
use esp_alloc as _;
@ -40,7 +42,7 @@ use esp_wifi::{
};
use smoltcp::{
iface::{SocketSet, SocketStorage},
wire::{DhcpOption, IpAddress, Ipv4Address},
wire::{DhcpOption, IpAddress},
};
const SSID: &str = env!("SSID");
@ -63,7 +65,7 @@ fn main() -> ! {
esp_alloc::heap_allocator!(72 * 1024);
let server_address: Ipv4Address = HOST_IP.parse().expect("Invalid HOST_IP address");
let server_address: Ipv4Addr = HOST_IP.parse().expect("Invalid HOST_IP address");
let timg0 = TimerGroup::new(peripherals.TIMG0);
@ -155,7 +157,7 @@ fn main() -> ! {
}
fn test_download<'a, D: smoltcp::phy::Device>(
server_address: Ipv4Address,
server_address: Ipv4Addr,
socket: &mut blocking_network_stack::Socket<'a, 'a, D>,
) {
println!("Testing download...");
@ -189,7 +191,7 @@ fn test_download<'a, D: smoltcp::phy::Device>(
}
fn test_upload<'a, D: smoltcp::phy::Device>(
server_address: Ipv4Address,
server_address: Ipv4Addr,
socket: &mut blocking_network_stack::Socket<'a, 'a, D>,
) {
println!("Testing upload...");
@ -223,7 +225,7 @@ fn test_upload<'a, D: smoltcp::phy::Device>(
}
fn test_upload_download<'a, D: smoltcp::phy::Device>(
server_address: Ipv4Address,
server_address: Ipv4Addr,
socket: &mut blocking_network_stack::Socket<'a, 'a, D>,
) {
println!("Testing upload+download...");

6
examples/src/bin/wifi_coex.rs
View File

@ -15,6 +15,8 @@
#![no_std]
#![no_main]
use core::net::Ipv4Addr;
use bleps::{
ad_structure::{
create_advertising_data,
@ -45,7 +47,7 @@ use esp_wifi::{
};
use smoltcp::{
iface::{SocketSet, SocketStorage},
wire::{DhcpOption, IpAddress, Ipv4Address},
wire::{DhcpOption, IpAddress},
};
const SSID: &str = env!("SSID");
@ -172,7 +174,7 @@ fn main() -> ! {
socket.work();
socket
.open(IpAddress::Ipv4(Ipv4Address::new(142, 250, 185, 115)), 80)
.open(IpAddress::Ipv4(Ipv4Addr::new(142, 250, 185, 115)), 80)
.unwrap();
socket

5
examples/src/bin/wifi_dhcp.rs
View File

@ -13,6 +13,7 @@
#![no_main]
extern crate alloc;
use core::net::Ipv4Addr;
use blocking_network_stack::Stack;
use embedded_io::*;
@ -39,7 +40,7 @@ use esp_wifi::{
};
use smoltcp::{
iface::{SocketSet, SocketStorage},
wire::{DhcpOption, IpAddress, Ipv4Address},
wire::{DhcpOption, IpAddress},
};
const SSID: &str = env!("SSID");
@ -134,7 +135,7 @@ fn main() -> ! {
socket.work();
socket
.open(IpAddress::Ipv4(Ipv4Address::new(142, 250, 185, 115)), 80)
.open(IpAddress::Ipv4(Ipv4Addr::new(142, 250, 185, 115)), 80)
.unwrap();
socket

222
examples/src/bin/wifi_dhcp_smoltcp_nal.rs
View File

@ -1,222 +0,0 @@
//! DHCP Example using [smoltcp-nal](https://crates.io/crates/smoltcp-nal)
//!
//!
//! Set SSID and PASSWORD env variable before running this example.
//!
//! This gets an ip address via DHCP then performs an HTTP get request to some "random" server
//! When using USB-SERIAL-JTAG you may have to activate the feature `phy-enable-usb` in the esp-wifi crate.
//% FEATURES: esp-wifi esp-wifi/wifi esp-wifi/utils esp-hal/unstable
//% CHIPS: esp32 esp32s2 esp32s3 esp32c2 esp32c3 esp32c6
#![no_std]
#![no_main]
extern crate alloc;
use esp_alloc as _;
use esp_backtrace as _;
use esp_hal::{
clock::CpuClock,
entry,
rng::Rng,
time::{self, Duration},
timer::timg::TimerGroup,
};
use esp_println::{print, println};
use esp_wifi::{
init,
wifi::{
utils::create_network_interface,
AccessPointInfo,
ClientConfiguration,
Configuration,
WifiError,
WifiStaDevice,
},
};
use smoltcp::{
iface::{SocketSet, SocketStorage},
wire::DhcpOption,
};
use smoltcp_nal::{
embedded_nal::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpClientStack},
NetworkStack,
};
const SSID: &str = env!("SSID");
const PASSWORD: &str = env!("PASSWORD");
#[entry]
fn main() -> ! {
esp_println::logger::init_logger_from_env();
let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
let peripherals = esp_hal::init(config);
esp_alloc::heap_allocator!(72 * 1024);
let timg0 = TimerGroup::new(peripherals.TIMG0);
let init = init(
timg0.timer0,
Rng::new(peripherals.RNG),
peripherals.RADIO_CLK,
)
.unwrap();
let mut wifi = peripherals.WIFI;
let (iface, device, mut controller) =
create_network_interface(&init, &mut wifi, WifiStaDevice).unwrap();
let mut socket_set_entries: [SocketStorage; 3] = Default::default();
let mut sockets = SocketSet::new(&mut socket_set_entries[..]);
let mut rx_buffer = [0u8; 128];
let mut tx_buffer = [0u8; 128];
sockets.add(smoltcp::socket::tcp::Socket::new(
smoltcp::socket::tcp::SocketBuffer::new(&mut rx_buffer[..]),
smoltcp::socket::tcp::SocketBuffer::new(&mut tx_buffer[..]),
));
let mut dhcp_socket = smoltcp::socket::dhcpv4::Socket::new();
// we can set a hostname here (or add other DHCP options)
dhcp_socket.set_outgoing_options(&[DhcpOption {
kind: 12,
data: b"esp-wifi",
}]);
sockets.add(dhcp_socket);
let mut network_stack = NetworkStack::new(iface, device, sockets, StackClock);
let client_config = Configuration::Client(ClientConfiguration {
ssid: SSID.try_into().unwrap(),
password: PASSWORD.try_into().unwrap(),
..Default::default()
});
let res = controller.set_configuration(&client_config);
println!("wifi_set_configuration returned {:?}", res);
controller.start().unwrap();
println!("is wifi started: {:?}", controller.is_started());
println!("Start Wifi Scan");
let res: Result<(heapless::Vec<AccessPointInfo, 10>, usize), WifiError> = controller.scan_n();
if let Ok((res, _count)) = res {
for ap in res {
println!("{:?}", ap);
}
}
println!("{:?}", controller.capabilities());
println!("wifi_connect {:?}", controller.connect());
// wait to get connected
println!("Wait to get connected");
loop {
match controller.is_connected() {
Ok(true) => break,
Ok(false) => {}
Err(err) => {
println!("{:?}", err);
loop {}
}
}
}
println!("{:?}", controller.is_connected());
// wait for getting an ip address
println!("Wait to get an ip address");
loop {
network_stack.poll().unwrap();
if let Some(ip) = network_stack.interface().ipv4_addr() {
if !ip.is_unspecified() {
println!("got ip {:?}", ip);
break;
}
}
}
println!("Start busy loop on main");
let mut socket = network_stack.socket().unwrap();
loop {
println!("Making HTTP request");
while network_stack.poll().unwrap() {}
with_network_stack(&mut network_stack, |network_stack| {
network_stack.connect(
&mut socket,
SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(142, 250, 185, 115), 80)),
)
})
.unwrap();
println!("connected");
with_network_stack(&mut network_stack, |network_stack| {
network_stack.send(
&mut socket,
b"GET / HTTP/1.0\r\nHost: www.mobile-j.de\r\n\r\n",
)
})
.unwrap();
let deadline = time::now() + Duration::secs(20);
let mut buffer = [0u8; 512];
while let Ok(len) = with_network_stack(&mut network_stack, |network_stack| {
network_stack.receive(&mut socket, &mut buffer)
}) {
let to_print = unsafe { core::str::from_utf8_unchecked(&buffer[..len]) };
print!("{}", to_print);
if time::now() > deadline {
println!("Timeout");
break;
}
network_stack.poll().unwrap();
}
println!();
network_stack.close_sockets();
let deadline = time::now() + Duration::secs(5);
while time::now() < deadline {
network_stack.poll().unwrap();
}
}
}
fn with_network_stack<'a, D: smoltcp::phy::Device, C: embedded_time::Clock<T = u32>, R>(
network_stack: &mut smoltcp_nal::NetworkStack<'a, D, C>,
mut f: impl FnMut(
&mut smoltcp_nal::NetworkStack<'a, D, C>,
) -> smoltcp_nal::embedded_nal::nb::Result<R, smoltcp_nal::NetworkError>,
) -> smoltcp_nal::embedded_nal::nb::Result<R, smoltcp_nal::NetworkError> {
let res = loop {
let res = f(network_stack);
if let nb::Result::Err(nb::Error::WouldBlock) = res {
network_stack.poll().unwrap();
continue;
}
break res;
};
res
}
struct StackClock;
impl embedded_time::Clock for StackClock {
type T = u32;
const SCALING_FACTOR: embedded_time::rate::Fraction =
embedded_time::rate::Fraction::new(1, 1_000_000);
fn try_now(&self) -> Result<embedded_time::Instant<Self>, embedded_time::clock::Error> {
Ok(embedded_time::Instant::new(
esp_hal::time::now().ticks() as u32
))
}
}

34
examples/src/bin/wifi_embassy_access_point.rs
View File

@ -15,14 +15,14 @@
#![no_std]
#![no_main]
use core::str::FromStr;
use core::{net::Ipv4Addr, str::FromStr};
use embassy_executor::Spawner;
use embassy_net::{
tcp::TcpSocket,
IpListenEndpoint,
Ipv4Address,
Ipv4Cidr,
Runner,
Stack,
StackResources,
StaticConfigV4,
@ -90,7 +90,7 @@ async fn main(spawner: Spawner) -> ! {
}
let gw_ip_addr_str = GW_IP_ADDR_ENV.unwrap_or("192.168.2.1");
let gw_ip_addr = Ipv4Address::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
address: Ipv4Cidr::new(gw_ip_addr, 24),
@ -101,19 +101,16 @@ async fn main(spawner: Spawner) -> ! {
let seed = (rng.random() as u64) << 32 | rng.random() as u64;
// Init network stack
let stack = &*mk_static!(
Stack<WifiDevice<'_, WifiApDevice>>,
Stack::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed
)
let (stack, runner) = embassy_net::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed,
);
spawner.spawn(connection(controller)).ok();
spawner.spawn(net_task(&stack)).ok();
spawner.spawn(run_dhcp(&stack, gw_ip_addr_str)).ok();
spawner.spawn(net_task(runner)).ok();
spawner.spawn(run_dhcp(stack, gw_ip_addr_str)).ok();
let mut rx_buffer = [0; 1536];
let mut tx_buffer = [0; 1536];
@ -135,7 +132,7 @@ async fn main(spawner: Spawner) -> ! {
.config_v4()
.inspect(|c| println!("ipv4 config: {c:?}"));
let mut socket = TcpSocket::new(&stack, &mut rx_buffer, &mut tx_buffer);
let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
socket.set_timeout(Some(embassy_time::Duration::from_secs(10)));
loop {
println!("Wait for connection...");
@ -210,10 +207,7 @@ async fn main(spawner: Spawner) -> ! {
}
#[embassy_executor::task]
async fn run_dhcp(
stack: &'static Stack<WifiDevice<'static, WifiApDevice>>,
gw_ip_addr: &'static str,
) {
async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
use core::net::{Ipv4Addr, SocketAddrV4};
use edge_dhcp::{
@ -279,6 +273,6 @@ async fn connection(mut controller: WifiController<'static>) {
}
#[embassy_executor::task]
async fn net_task(stack: &'static Stack<WifiDevice<'static, WifiApDevice>>) {
stack.run().await
async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiApDevice>>) {
runner.run().await
}

53
examples/src/bin/wifi_embassy_access_point_with_sta.rs
View File

@ -18,13 +18,14 @@
#![no_std]
#![no_main]
use core::net::Ipv4Addr;
use embassy_executor::Spawner;
use embassy_net::{
tcp::TcpSocket,
IpListenEndpoint,
Ipv4Address,
Ipv4Cidr,
Stack,
Runner,
StackResources,
StaticConfigV4,
};
@ -94,8 +95,8 @@ async fn main(spawner: Spawner) -> ! {
}
let ap_config = embassy_net::Config::ipv4_static(StaticConfigV4 {
address: Ipv4Cidr::new(Ipv4Address::new(192, 168, 2, 1), 24),
gateway: Some(Ipv4Address::from_bytes(&[192, 168, 2, 1])),
address: Ipv4Cidr::new(Ipv4Addr::new(192, 168, 2, 1), 24),
gateway: Some(Ipv4Addr::new(192, 168, 2, 1)),
dns_servers: Default::default(),
});
let sta_config = embassy_net::Config::dhcpv4(Default::default());
@ -103,23 +104,17 @@ async fn main(spawner: Spawner) -> ! {
let seed = (rng.random() as u64) << 32 | rng.random() as u64;
// Init network stacks
let ap_stack = &*mk_static!(
Stack<WifiDevice<'_, WifiApDevice>>,
Stack::new(
wifi_ap_interface,
ap_config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed
)
let (ap_stack, ap_runner) = embassy_net::new(
wifi_ap_interface,
ap_config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed,
);
let sta_stack = &*mk_static!(
Stack<WifiDevice<'_, WifiStaDevice>>,
Stack::new(
wifi_sta_interface,
sta_config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed
)
let (sta_stack, sta_runner) = embassy_net::new(
wifi_sta_interface,
sta_config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed,
);
let client_config = Configuration::Mixed(
@ -136,8 +131,8 @@ async fn main(spawner: Spawner) -> ! {
controller.set_configuration(&client_config).unwrap();
spawner.spawn(connection(controller)).ok();
spawner.spawn(ap_task(&ap_stack)).ok();
spawner.spawn(sta_task(&sta_stack)).ok();
spawner.spawn(ap_task(ap_runner)).ok();
spawner.spawn(sta_task(sta_runner)).ok();
loop {
if sta_stack.is_link_up() {
@ -158,13 +153,13 @@ async fn main(spawner: Spawner) -> ! {
let mut ap_rx_buffer = [0; 1536];
let mut ap_tx_buffer = [0; 1536];
let mut ap_socket = TcpSocket::new(&ap_stack, &mut ap_rx_buffer, &mut ap_tx_buffer);
let mut ap_socket = TcpSocket::new(ap_stack, &mut ap_rx_buffer, &mut ap_tx_buffer);
ap_socket.set_timeout(Some(embassy_time::Duration::from_secs(10)));
let mut sta_rx_buffer = [0; 1536];
let mut sta_tx_buffer = [0; 1536];
let mut sta_socket = TcpSocket::new(&sta_stack, &mut sta_rx_buffer, &mut sta_tx_buffer);
let mut sta_socket = TcpSocket::new(sta_stack, &mut sta_rx_buffer, &mut sta_tx_buffer);
sta_socket.set_timeout(Some(embassy_time::Duration::from_secs(10)));
loop {
@ -212,7 +207,7 @@ async fn main(spawner: Spawner) -> ! {
}
if sta_stack.is_link_up() {
let remote_endpoint = (Ipv4Address::new(142, 250, 185, 115), 80);
let remote_endpoint = (Ipv4Addr::new(142, 250, 185, 115), 80);
println!("connecting...");
let r = sta_socket.connect(remote_endpoint).await;
if let Err(e) = r {
@ -334,11 +329,11 @@ async fn connection(mut controller: WifiController<'static>) {
}
#[embassy_executor::task]
async fn ap_task(stack: &'static Stack<WifiDevice<'static, WifiApDevice>>) {
stack.run().await
async fn ap_task(mut runner: Runner<'static, WifiDevice<'static, WifiApDevice>>) {
runner.run().await
}
#[embassy_executor::task]
async fn sta_task(stack: &'static Stack<WifiDevice<'static, WifiStaDevice>>) {
stack.run().await
async fn sta_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
runner.run().await
}

31
examples/src/bin/wifi_embassy_bench.rs
View File

@ -17,9 +17,11 @@
#![no_std]
#![no_main]
use core::net::Ipv4Addr;
use embassy_executor::Spawner;
use embassy_futures::join::join;
use embassy_net::{tcp::TcpSocket, Ipv4Address, Stack, StackResources};
use embassy_net::{tcp::TcpSocket, Runner, StackResources};
use embassy_time::{with_timeout, Duration, Timer};
use esp_alloc as _;
use esp_backtrace as _;
@ -91,7 +93,7 @@ async fn main(spawner: Spawner) -> ! {
));
}
let server_address: Ipv4Address = HOST_IP.parse().expect("Invalid HOST_IP address");
let server_address: Ipv4Addr = HOST_IP.parse().expect("Invalid HOST_IP address");
let timg0 = TimerGroup::new(peripherals.TIMG0);
let mut rng = Rng::new(peripherals.RNG);
@ -121,18 +123,15 @@ async fn main(spawner: Spawner) -> ! {
let seed = (rng.random() as u64) << 32 | rng.random() as u64;
// Init network stack
let stack = &*mk_static!(
Stack<WifiDevice<'_, WifiStaDevice>>,
Stack::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed
)
let (stack, runner) = embassy_net::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed,
);
spawner.spawn(connection(controller)).ok();
spawner.spawn(net_task(&stack)).ok();
spawner.spawn(net_task(runner)).ok();
loop {
if stack.is_link_up() {
@ -202,11 +201,11 @@ async fn connection(mut controller: WifiController<'static>) {
}
#[embassy_executor::task]
async fn net_task(stack: &'static Stack<WifiDevice<'static, WifiStaDevice>>) {
stack.run().await
async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
runner.run().await
}
async fn test_download(server_address: Ipv4Address, socket: &mut TcpSocket<'_>) -> usize {
async fn test_download(server_address: Ipv4Addr, socket: &mut TcpSocket<'_>) -> usize {
println!("Testing download...");
socket.abort();
@ -244,7 +243,7 @@ async fn test_download(server_address: Ipv4Address, socket: &mut TcpSocket<'_>)
kbps
}
async fn test_upload(server_address: Ipv4Address, socket: &mut TcpSocket<'_>) -> usize {
async fn test_upload(server_address: Ipv4Addr, socket: &mut TcpSocket<'_>) -> usize {
println!("Testing upload...");
socket.abort();
socket.set_timeout(Some(Duration::from_secs(10)));
@ -281,7 +280,7 @@ async fn test_upload(server_address: Ipv4Address, socket: &mut TcpSocket<'_>) ->
kbps
}
async fn test_upload_download(server_address: Ipv4Address, socket: &mut TcpSocket<'_>) -> usize {
async fn test_upload_download(server_address: Ipv4Addr, socket: &mut TcpSocket<'_>) -> usize {
println!("Testing upload+download...");
socket.abort();

27
examples/src/bin/wifi_embassy_dhcp.rs
View File

@ -13,8 +13,10 @@
#![no_std]
#![no_main]
use core::net::Ipv4Addr;
use embassy_executor::Spawner;
use embassy_net::{tcp::TcpSocket, Ipv4Address, Stack, StackResources};
use embassy_net::{tcp::TcpSocket, Runner, StackResources};
use embassy_time::{Duration, Timer};
use esp_alloc as _;
use esp_backtrace as _;
@ -83,18 +85,15 @@ async fn main(spawner: Spawner) -> ! {
let seed = (rng.random() as u64) << 32 | rng.random() as u64;
// Init network stack
let stack = &*mk_static!(
Stack<WifiDevice<'_, WifiStaDevice>>,
Stack::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed
)
let (stack, runner) = embassy_net::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed,
);
spawner.spawn(connection(controller)).ok();
spawner.spawn(net_task(&stack)).ok();
spawner.spawn(net_task(runner)).ok();
let mut rx_buffer = [0; 4096];
let mut tx_buffer = [0; 4096];
@ -118,11 +117,11 @@ async fn main(spawner: Spawner) -> ! {
loop {
Timer::after(Duration::from_millis(1_000)).await;
let mut socket = TcpSocket::new(&stack, &mut rx_buffer, &mut tx_buffer);
let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
socket.set_timeout(Some(embassy_time::Duration::from_secs(10)));
let remote_endpoint = (Ipv4Address::new(142, 250, 185, 115), 80);
let remote_endpoint = (Ipv4Addr::new(142, 250, 185, 115), 80);
println!("connecting...");
let r = socket.connect(remote_endpoint).await;
if let Err(e) = r {
@ -194,6 +193,6 @@ async fn connection(mut controller: WifiController<'static>) {
}
#[embassy_executor::task]
async fn net_task(stack: &'static Stack<WifiDevice<'static, WifiStaDevice>>) {
stack.run().await
async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
runner.run().await
}