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

* 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.

esp-wifi/CHANGELOG.md

@@ -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
 

esp-wifi/Cargo.toml

@@ -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 }

esp-wifi/src/wifi/mod.rs

@@ -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))
     }
 }
 

examples/Cargo.toml

@@ -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             = { version = "0.12.0", default-features = false, features = [ "medium-ethernet", "socket-raw"] }
-smoltcp-nal         = "0.5.1"
 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"}

examples/src/bin/wifi_access_point_with_sta.rs

@@ -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

examples/src/bin/wifi_bench.rs

@@ -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...");

examples/src/bin/wifi_coex.rs

@@ -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

examples/src/bin/wifi_dhcp.rs

@@ -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

examples/src/bin/wifi_dhcp_smoltcp_nal.rs

@@ -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
-        ))
-    }
-}

examples/src/bin/wifi_embassy_access_point.rs

@@ -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!(
+    let (stack, runner) = embassy_net::new(
-        Stack<WifiDevice<'_, WifiApDevice>>,
+        wifi_interface,
-        Stack::new(
+        config,
-            wifi_interface,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
-            config,
+        seed,
-            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();
-    spawner.spawn(run_dhcp(&stack, gw_ip_addr_str)).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(
+async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
-    stack: &'static Stack<WifiDevice<'static, WifiApDevice>>,
-    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>>) {
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiApDevice>>) {
-    stack.run().await
+    runner.run().await
 }

examples/src/bin/wifi_embassy_access_point_with_sta.rs

@@ -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),
+        address: Ipv4Cidr::new(Ipv4Addr::new(192, 168, 2, 1), 24),
-        gateway: Some(Ipv4Address::from_bytes(&[192, 168, 2, 1])),
+        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!(
+    let (ap_stack, ap_runner) = embassy_net::new(
-        Stack<WifiDevice<'_, WifiApDevice>>,
+        wifi_ap_interface,
-        Stack::new(
+        ap_config,
-            wifi_ap_interface,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
-            ap_config,
+        seed,
-            mk_static!(StackResources<3>, StackResources::<3>::new()),
-            seed
-        )
     );
-    let sta_stack = &*mk_static!(
+    let (sta_stack, sta_runner) = embassy_net::new(
-        Stack<WifiDevice<'_, WifiStaDevice>>,
+        wifi_sta_interface,
-        Stack::new(
+        sta_config,
-            wifi_sta_interface,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
-            sta_config,
+        seed,
-            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(ap_task(ap_runner)).ok();
-    spawner.spawn(sta_task(&sta_stack)).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>>) {
+async fn ap_task(mut runner: Runner<'static, WifiDevice<'static, WifiApDevice>>) {
-    stack.run().await
+    runner.run().await
 }
 
 #[embassy_executor::task]
-async fn sta_task(stack: &'static Stack<WifiDevice<'static, WifiStaDevice>>) {
+async fn sta_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
-    stack.run().await
+    runner.run().await
 }

examples/src/bin/wifi_embassy_bench.rs

@@ -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!(
+    let (stack, runner) = embassy_net::new(
-        Stack<WifiDevice<'_, WifiStaDevice>>,
+        wifi_interface,
-        Stack::new(
+        config,
-            wifi_interface,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
-            config,
+        seed,
-            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>>) {
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
-    stack.run().await
+    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();

examples/src/bin/wifi_embassy_dhcp.rs

@@ -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!(
+    let (stack, runner) = embassy_net::new(
-        Stack<WifiDevice<'_, WifiStaDevice>>,
+        wifi_interface,
-        Stack::new(
+        config,
-            wifi_interface,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
-            config,
+        seed,
-            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>>) {
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
-    stack.run().await
+    runner.run().await
 }