Fix rtic-echo example

Author: Johannes Cornelis Draaijer

Cargo.toml

@@ -71,7 +71,7 @@ example-nucleo-pins = [ ]
 rtic-echo-example = [ "defmt", "smoltcp-phy", "smoltcp/defmt", "smoltcp/medium-ethernet", "smoltcp/socket-tcp" ]
 
 [dev-dependencies]
-cortex-m = "0.7"
+cortex-m = { version = "0.7", features = [ "critical-section-single-core" ] }
 cortex-m-rt = "0.7"
 fugit = "0.3"
 cortex-m-rtic = "1.0"

examples/rtic-echo.rs

@@ -11,7 +11,7 @@ use defmt_rtt as _;
 use panic_probe as _;
 
 use smoltcp::{
-    iface::{self, SocketStorage},
+    iface::{self},
     wire::{self, IpAddress, Ipv4Address},
 };
 
@@ -27,21 +27,25 @@ mod app {
 
     use systick_monotonic::Systick;
 
+    use core::mem::MaybeUninit;
+
     use stm32_eth::{EthernetDMA, RxRingEntry, TxRingEntry};
 
     use smoltcp::{
-        iface::{self, Interface, SocketHandle},
-        socket::TcpSocket,
-        socket::{TcpSocketBuffer, TcpState},
+        iface::{self, Interface, SocketHandle, SocketSet, SocketStorage},
+        socket::tcp::Socket as TcpSocket,
+        socket::tcp::{SocketBuffer as TcpSocketBuffer, State as TcpState},
         wire::EthernetAddress,
     };
 
     use crate::NetworkStorage;
 
     #[local]
     struct Local {
-        interface: Interface<'static, &'static mut EthernetDMA<'static, 'static>>,
+        interface: Interface<'static>,
         tcp_handle: SocketHandle,
+        sockets: SocketSet<'static>,
+        dma: EthernetDMA<'static, 'static>,
     }
 
     #[shared]
@@ -58,8 +62,8 @@ mod app {
     #[init(local = [
         rx_ring: [RxRingEntry; 2] = [RxRingEntry::new(),RxRingEntry::new()],
         tx_ring: [TxRingEntry; 2] = [TxRingEntry::new(),TxRingEntry::new()],
-        storage: NetworkStorage = NetworkStorage::new(),
-        dma: core::mem::MaybeUninit<EthernetDMA<'static, 'static>> = core::mem::MaybeUninit::uninit(),
+        socket_storage: [SocketStorage<'static>; 4] = [SocketStorage::EMPTY, SocketStorage::EMPTY, SocketStorage::EMPTY, SocketStorage::EMPTY],
+        storage_store: MaybeUninit<NetworkStorage> = MaybeUninit::uninit(),
     ])]
     fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         defmt::info!("Pre-init");
@@ -72,12 +76,15 @@ mod app {
         let (clocks, gpio, ethernet) = crate::common::setup_peripherals(p);
         let mono = Systick::new(core.SYST, clocks.hclk().raw());
 
+        let sockets = cx.local.socket_storage;
+        let mut sockets = SocketSet::new(&mut sockets[..]);
+
         defmt::info!("Setting up pins");
         let (pins, mdio, mdc) = crate::common::setup_pins(gpio);
 
         defmt::info!("Configuring ethernet");
 
-        let (dma, mac) = stm32_eth::new_with_mii(
+        let (mut dma, mac) = stm32_eth::new_with_mii(
             ethernet.mac,
             ethernet.mmc,
             ethernet.dma,
@@ -92,13 +99,11 @@ mod app {
         )
         .unwrap();
 
-        let dma = cx.local.dma.write(dma);
-
         defmt::info!("Enabling interrupts");
         dma.enable_interrupt();
 
         defmt::info!("Setting up smoltcp");
-        let store = cx.local.storage;
+        let store = cx.local.storage_store.write(NetworkStorage::new());
 
         let mut routes = smoltcp::iface::Routes::new(&mut store.routes_cache[..]);
         routes
@@ -112,19 +117,21 @@ mod app {
 
         let socket = TcpSocket::new(rx_buffer, tx_buffer);
 
-        let mut interface = iface::InterfaceBuilder::new(dma, &mut store.sockets[..])
+        let mut interface = iface::InterfaceBuilder::new()
             .hardware_addr(EthernetAddress::from_bytes(&crate::MAC).into())
             .neighbor_cache(neighbor_cache)
             .ip_addrs(&mut store.ip_addrs[..])
             .routes(routes)
-            .finalize();
+            .finalize(&mut &mut dma);
 
-        let tcp_handle = interface.add_socket(socket);
+        let tcp_handle = sockets.add(socket);
 
-        let socket = interface.get_socket::<TcpSocket>(tcp_handle);
+        let socket = sockets.get_mut::<TcpSocket>(tcp_handle);
         socket.listen(crate::ADDRESS).ok();
 
-        interface.poll(now_fn()).unwrap();
+        interface
+            .poll(now_fn(), &mut &mut dma, &mut sockets)
+            .unwrap();
 
         if let Ok(mut phy) = EthernetPhy::from_miim(mac, 0) {
             defmt::info!(
@@ -144,21 +151,29 @@ mod app {
             Local {
                 interface,
                 tcp_handle,
+                sockets,
+                dma,
             },
             init::Monotonics(mono),
         )
     }
 
-    #[task(binds = ETH, local = [interface, tcp_handle, data: [u8; 512] = [0u8; 512]], priority = 2)]
+    #[task(binds = ETH, local = [interface, tcp_handle, sockets, dma, data: [u8; 512] = [0u8; 512]], priority = 2)]
     fn eth_interrupt(cx: eth_interrupt::Context) {
-        let (iface, tcp_handle, buffer) = (cx.local.interface, cx.local.tcp_handle, cx.local.data);
-
-        let interrupt_reason = iface.device_mut().interrupt_handler();
+        let (iface, tcp_handle, buffer, sockets, mut dma) = (
+            cx.local.interface,
+            cx.local.tcp_handle,
+            cx.local.data,
+            cx.local.sockets,
+            cx.local.dma,
+        );
+
+        let interrupt_reason = dma.interrupt_handler();
         defmt::debug!("Got an ethernet interrupt! Reason: {}", interrupt_reason);
 
-        iface.poll(now_fn()).ok();
+        iface.poll(now_fn(), &mut dma, sockets).ok();
 
-        let socket = iface.get_socket::<TcpSocket>(*tcp_handle);
+        let socket = sockets.get_mut::<TcpSocket>(*tcp_handle);
         if let Ok(recv_bytes) = socket.recv_slice(buffer) {
             if recv_bytes > 0 {
                 socket.send_slice(&buffer[..recv_bytes]).ok();
@@ -172,14 +187,13 @@ mod app {
             defmt::warn!("Disconnected... Reopening listening socket.");
         }
 
-        iface.poll(now_fn()).ok();
+        iface.poll(now_fn(), &mut dma, sockets).ok();
     }
 }
 
 /// All storage required for networking
 pub struct NetworkStorage {
     pub ip_addrs: [wire::IpCidr; 1],
-    pub sockets: [iface::SocketStorage<'static>; 1],
     pub tcp_socket_storage: TcpSocketStorage,
     pub neighbor_cache: [Option<(wire::IpAddress, iface::Neighbor)>; 8],
     pub routes_cache: [Option<(wire::IpCidr, iface::Route)>; 8],
@@ -194,7 +208,6 @@ impl NetworkStorage {
             ip_addrs: [Self::IP_INIT],
             neighbor_cache: [None; 8],
             routes_cache: [None; 8],
-            sockets: [SocketStorage::EMPTY; 1],
             tcp_socket_storage: TcpSocketStorage::new(),
         }
     }