Update rtic-echo from branch master

Author: datdenkikniet

examples/rtic-echo.rs

@@ -10,14 +10,12 @@
 use defmt_rtt as _;
 use panic_probe as _;
 
-use smoltcp::{
-    iface::{self, SocketStorage},
-    wire::{self, IpAddress, Ipv4Address},
-};
+use smoltcp::wire::{IpAddress, Ipv4Address};
 
 mod common;
 
-const ADDRESS: (IpAddress, u16) = (IpAddress::Ipv4(Ipv4Address::new(10, 0, 0, 1)), 1337);
+const IP_ADDRESS: Ipv4Address = Ipv4Address::new(10, 0, 0, 1);
+const SOCKET_ADDRESS: (IpAddress, u16) = (IpAddress::Ipv4(IP_ADDRESS), 1337);
 const MAC: [u8; 6] = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05];
 
 #[rtic::app(device = stm32_eth::stm32, dispatchers = [SPI1])]
@@ -28,25 +26,20 @@ mod app {
     use ieee802_3_miim::{phy::PhySpeed, Phy};
     use systick_monotonic::Systick;
 
-    use stm32_eth::{
-        dma::{EthernetDMA, RxDescriptor, RxDescriptorRing, TxDescriptor, TxDescriptorRing},
-        mac::Speed,
-        Parts,
-    };
+    use stm32_eth::{dma::EthernetDMA, mac::Speed, Parts};
 
     use smoltcp::{
-        iface::{self, Interface, SocketHandle},
-        socket::TcpSocket,
-        socket::{TcpSocketBuffer, TcpState},
-        wire::EthernetAddress,
+        iface::{self, Interface, SocketHandle, SocketSet, SocketStorage},
+        socket::tcp::{Socket as TcpSocket, SocketBuffer as TcpSocketBuffer, State as TcpState},
+        wire::{EthernetAddress, IpCidr, Ipv4Cidr},
     };
 
-    use crate::NetworkStorage;
-
     #[local]
     struct Local {
-        interface: Interface<'static, &'static mut EthernetDMA<'static, 'static>>,
+        interface: Interface,
         tcp_handle: SocketHandle,
+        dma: EthernetDMA<'static, 'static>,
+        sockets: SocketSet<'static>,
     }
 
     #[shared]
@@ -61,69 +54,70 @@ mod app {
     }
 
     #[init(local = [
-        rx_desc: [RxDescriptor; 2] = [RxDescriptor::new(); 2],
-        tx_desc: [TxDescriptor; 2] = [TxDescriptor::new(); 2],
-        rx_buffers: [[u8; 1522]; 2] = [[0u8; stm32_eth::MTU]; 2],
-        tx_buffers: [[u8; 1522]; 2] = [[0u8; stm32_eth::MTU]; 2],
-        storage: NetworkStorage = NetworkStorage::new(),
-        dma: core::mem::MaybeUninit<EthernetDMA<'static, 'static>> = core::mem::MaybeUninit::uninit(),
+        rx_storage: [u8; 512] = [0u8; 512],
+        tx_storage: [u8; 512] = [0u8; 512],
+        socket_storage: [SocketStorage<'static>; 1] = [SocketStorage::EMPTY; 1],
     ])]
     fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         defmt::info!("Pre-init");
         let core = cx.core;
         let p = cx.device;
 
-        let rx_ring = RxDescriptorRing::new(cx.local.rx_desc, cx.local.rx_buffers);
-        let tx_ring = TxDescriptorRing::new(cx.local.tx_desc, cx.local.tx_buffers);
+        let (tx_ring, rx_ring) = crate::common::setup_rings();
 
         let (clocks, gpio, ethernet) = crate::common::setup_peripherals(p);
         let mono = Systick::new(core.SYST, clocks.hclk().raw());
 
+        let (rx_storage, tx_storage, socket_storage) = (
+            cx.local.rx_storage,
+            cx.local.tx_storage,
+            cx.local.socket_storage,
+        );
+
         defmt::info!("Setting up pins");
         let (pins, mdio, mdc, _) = crate::common::setup_pins(gpio);
 
         defmt::info!("Configuring ethernet");
 
         let Parts {
-            dma,
+            mut dma,
             mac,
             #[cfg(feature = "ptp")]
                 ptp: _,
         } = stm32_eth::new_with_mii(ethernet, rx_ring, tx_ring, clocks, pins, mdio, mdc).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 mut routes = smoltcp::iface::Routes::new(&mut store.routes_cache[..]);
+        let mut routes = smoltcp::iface::Routes::new();
         routes
             .add_default_ipv4_route(smoltcp::wire::Ipv4Address::UNSPECIFIED)
             .ok();
 
-        let neighbor_cache = smoltcp::iface::NeighborCache::new(&mut store.neighbor_cache[..]);
-
-        let rx_buffer = TcpSocketBuffer::new(&mut store.tcp_socket_storage.rx_storage[..]);
-        let tx_buffer = TcpSocketBuffer::new(&mut store.tcp_socket_storage.tx_storage[..]);
+        let rx_buffer = TcpSocketBuffer::new(&mut rx_storage[..]);
+        let tx_buffer = TcpSocketBuffer::new(&mut tx_storage[..]);
 
         let socket = TcpSocket::new(rx_buffer, tx_buffer);
 
-        let mut interface = iface::InterfaceBuilder::new(dma, &mut store.sockets[..])
-            .hardware_addr(EthernetAddress::from_bytes(&crate::MAC).into())
-            .neighbor_cache(neighbor_cache)
-            .ip_addrs(&mut store.ip_addrs[..])
-            .routes(routes)
-            .finalize();
+        let mut config = iface::Config::new();
+        config.hardware_addr = Some(EthernetAddress::from_bytes(&crate::MAC).into());
 
-        let tcp_handle = interface.add_socket(socket);
+        let mut interface = Interface::new(config, &mut &mut dma);
+        interface.update_ip_addrs(|addr| {
+            addr.push(IpCidr::Ipv4(Ipv4Cidr::new(crate::IP_ADDRESS, 24)))
+                .ok();
+        });
 
-        let socket = interface.get_socket::<TcpSocket>(tcp_handle);
-        socket.listen(crate::ADDRESS).ok();
+        let mut sockets = SocketSet::new(&mut socket_storage[..]);
 
-        interface.poll(now_fn()).unwrap();
+        let tcp_handle = sockets.add(socket);
+
+        let socket = sockets.get_mut::<TcpSocket>(tcp_handle);
+        socket.listen(crate::SOCKET_ADDRESS).ok();
+
+        interface.poll(now_fn(), &mut &mut dma, &mut sockets);
 
         if let Ok(mut phy) = EthernetPhy::from_miim(mac, 0) {
             defmt::info!(
@@ -154,28 +148,36 @@ mod app {
             defmt::info!("Not resetting unsupported PHY. Cannot detect link speed.");
         }
 
-        defmt::info!("Setup done. Listening at {}", crate::ADDRESS);
+        defmt::info!("Setup done. Listening at {}", crate::SOCKET_ADDRESS);
 
         (
             Shared {},
             Local {
                 interface,
                 tcp_handle,
+                dma,
+                sockets,
             },
             init::Monotonics(mono),
         )
     }
 
-    #[task(binds = ETH, local = [interface, tcp_handle, data: [u8; 512] = [0u8; 512]], priority = 2)]
+    #[task(binds = ETH, local = [interface, tcp_handle, dma, sockets, 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);
 
-        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();
@@ -185,50 +187,10 @@ mod app {
 
         if !socket.is_listening() && !socket.is_open() || socket.state() == TcpState::CloseWait {
             socket.abort();
-            socket.listen(crate::ADDRESS).ok();
+            socket.listen(crate::SOCKET_ADDRESS).ok();
             defmt::warn!("Disconnected... Reopening listening socket.");
         }
 
-        iface.poll(now_fn()).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],
-}
-
-impl NetworkStorage {
-    const IP_INIT: wire::IpCidr =
-        wire::IpCidr::Ipv4(wire::Ipv4Cidr::new(wire::Ipv4Address::new(10, 0, 0, 1), 24));
-
-    pub const fn new() -> Self {
-        NetworkStorage {
-            ip_addrs: [Self::IP_INIT],
-            neighbor_cache: [None; 8],
-            routes_cache: [None; 8],
-            sockets: [SocketStorage::EMPTY; 1],
-            tcp_socket_storage: TcpSocketStorage::new(),
-        }
-    }
-}
-
-/// Storage of TCP sockets
-#[derive(Copy, Clone)]
-pub struct TcpSocketStorage {
-    rx_storage: [u8; 512],
-    tx_storage: [u8; 512],
-}
-
-impl TcpSocketStorage {
-    const fn new() -> Self {
-        Self {
-            rx_storage: [0; 512],
-            tx_storage: [0; 512],
-        }
+        iface.poll(now_fn(), &mut dma, sockets);
     }
 }