Struct embassy_net::Stack

pub struct Stack<D: Driver> { /* private fields */ }

A network stack.

This is the main entry point for the network stack.

Implementations

impl<D: Driver> Stack<D>

pub fn new<const SOCK: usize>( device: D, config: Config, resources: &'static mut StackResources<SOCK>, random_seed: u64 ) -> Self

Create a new network stack.

pub fn hardware_address(&self) -> HardwareAddress

Get the hardware address of the network interface.

pub fn is_link_up(&self) -> bool

Get whether the link is up.

pub fn is_config_up(&self) -> bool

Get whether the network stack has a valid IP configuration. This is true if the network stack has a static IP configuration or if DHCP has completed

pub async fn wait_config_up(&self)

Wait for the network stack to obtain a valid IP configuration.

Notes:

• Ensure Stack::run has been called before using this function.

• This function may never return (e.g. if no configuration is obtained through DHCP). The caller is supposed to handle a timeout for this case.

Example

let config = embassy_net::Config::dhcpv4(Default::default());
static RESOURCES: StaticCell<embassy_net::StackResources<2> = StaticCell::new();
static STACK: StaticCell<embassy_net::Stack> = StaticCell::new();
let stack = &*STACK.init(embassy_net::Stack::new(
   device,
   config,
   RESOURCES.init(embassy_net::StackResources::new()),
   seed
));
// Launch network task that runs `stack.run().await`
spawner.spawn(net_task(stack)).unwrap();
// Wait for DHCP config
stack.wait_config_up().await;
// use the network stack
// ...

pub fn config_v4(&self) -> Option<StaticConfigV4>

Get the current IPv4 configuration.

If using DHCP, this will be None if DHCP hasn’t been able to acquire an IP address, or Some if it has.

pub fn config_v6(&self) -> Option<StaticConfigV6>

Get the current IPv6 configuration.

pub fn set_config_v4(&self, config: ConfigV4)

Set the IPv4 configuration.

pub fn set_config_v6(&self, config: ConfigV6)

Set the IPv6 configuration.

pub async fn run(&self) -> !

Run the network stack.

You must call this in a background task, to process network events.

pub async fn dns_query( &self, name: &str, qtype: DnsQueryType ) -> Result<Vec<IpAddress, { smoltcp::config::DNS_MAX_RESULT_COUNT }>, Error>

Make a query for a given name and return the corresponding IP addresses.

impl<D: Driver> Stack<D>

pub async fn join_multicast_group<T>( &self, addr: T ) -> Result<bool, MulticastError>

where T: Into<IpAddress>,

Join a multicast group.

pub fn poll_join_multicast_group<T>( &self, addr: T, cx: &mut Context<'_> ) -> Poll<Result<bool, MulticastError>>

where T: Into<IpAddress>,

Join a multicast group.

When the send queue is full, this method will return Poll::Pending and register the current task to be notified when the queue has space available.

pub async fn leave_multicast_group<T>( &self, addr: T ) -> Result<bool, MulticastError>

where T: Into<IpAddress>,

Leave a multicast group.

pub fn poll_leave_multicast_group<T>( &self, addr: T, cx: &mut Context<'_> ) -> Poll<Result<bool, MulticastError>>

where T: Into<IpAddress>,

Leave a multicast group.

When the send queue is full, this method will return Poll::Pending and register the current task to be notified when the queue has space available.

pub fn has_multicast_group<T: Into<IpAddress>>(&self, addr: T) -> bool

Get whether the network stack has joined the given multicast group.