feat: embassy-net driver for nrf radio

Author: Remmirad

embassy-net-nrf-802154/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "embassy-net-nrf-802154"
+version = "0.1.0"
+edition = "2021"
+description = "embassy-net driver for nrf52 802.15.4 radio"
+keywords = ["embedded", "802.15.4", "embassy-net", "embedded-hal-async"]
+categories = ["embedded", "hardware-support", "no-std", "network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/embassy-rs/embassy"
+documentation = "https://docs.embassy.dev/embassy-net-nrf-802154"
+
+[package.metadata.embassy_docs]
+src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-nrf-802154-v$VERSION/embassy-net-nrf-802154/src/"
+src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-net-nrf-802154/src/"
+features = ["defmt","nrf52840"]
+target = "thumbv7em-none-eabi"
+
+[package.metadata.docs.rs]
+features = ["defmt","nrf52840"]
+
+[dependencies]
+embassy-time = { version = "0.4.0", path = "../embassy-time" }
+embassy-futures = { version = "0.1.1", path = "../embassy-futures"}
+embassy-net-driver-channel = { version = "0.3.0", path = "../embassy-net-driver-channel"}
+
+embassy-nrf = { version = "0.3.1", path = "../embassy-nrf"}
+
+[features]
+defmt = ["embassy-time/defmt", "embassy-futures/defmt", "embassy-net-driver-channel/defmt", "embassy-nrf/defmt"]
+
+nrf51 = ["embassy-nrf/nrf51"]
+
+nrf52805 = ["embassy-nrf/nrf52805"]
+nrf52810 = ["embassy-nrf/nrf52810"]
+nrf52811 = ["embassy-nrf/nrf52811"]
+nrf52820 = ["embassy-nrf/nrf52820"]
+nrf52832 = ["embassy-nrf/nrf52832"]
+nrf52833 = ["embassy-nrf/nrf52833"]
+nrf52840 = ["embassy-nrf/nrf52840"]

embassy-net-nrf-802154/README.md

@@ -0,0 +1,5 @@
+# nrf52 802.15.4 radio `embassy-net` integration
+
+[`embassy-net`](https://crates.io/crates/embassy-net) driver for nrf52 802.15.4 radio.
+
+See [`examples`](https://github.com/embassy-rs/embassy/tree/main/examples/nrf52840/src/bin) directory `sixlowpan` example.

embassy-net-nrf-802154/src/lib.rs

@@ -0,0 +1,120 @@
+#![no_std]
+#![warn(missing_docs)]
+#![doc = include_str!("../README.md")]
+
+#[cfg(not(any(
+    feature = "nrf51",
+    feature = "nrf52805",
+    feature = "nrf52810",
+    feature = "nrf52811",
+    feature = "nrf52820",
+    feature = "nrf52832",
+    feature = "nrf52833",
+    feature = "nrf52840",
+)))]
+compile_error!(
+    "No chip feature activated. You must activate exactly one of the following features:
+    nrf51,
+    nrf52805,
+    nrf52810,
+    nrf52811,
+    nrf52820,
+    nrf52832,
+    nrf52833,
+    nrf52840,
+    "
+);
+
+use embassy_futures::select::{select3, Either3};
+use embassy_net_driver_channel::driver::LinkState;
+use embassy_net_driver_channel::{self as ch};
+use embassy_nrf::radio::ieee802154::{Packet, Radio};
+use embassy_nrf::radio::InterruptHandler;
+use embassy_nrf::{self as nrf, interrupt};
+use embassy_time::{Duration, Ticker};
+
+/// MTU for the nrf radio.
+pub const MTU: usize = Packet::CAPACITY as usize;
+
+/// embassy-net device for the driver.
+pub type Device<'d> = embassy_net_driver_channel::Device<'d, MTU>;
+
+/// Internal state for the embassy-net driver.
+pub struct State<const N_RX: usize, const N_TX: usize> {
+    ch_state: ch::State<MTU, N_RX, N_TX>,
+}
+
+impl<const N_RX: usize, const N_TX: usize> State<N_RX, N_TX> {
+    /// Create a new `State`.
+    pub const fn new() -> Self {
+        Self {
+            ch_state: ch::State::new(),
+        }
+    }
+}
+
+/// Background runner for the driver.
+///
+/// You must call `.run()` in a background task for the driver to operate.
+pub struct Runner<'d, T: nrf::radio::Instance> {
+    radio: nrf::radio::ieee802154::Radio<'d, T>,
+    ch: ch::Runner<'d, MTU>,
+}
+
+impl<'d, T: nrf::radio::Instance> Runner<'d, T> {
+    /// Drives the radio. Needs to run to use the driver.
+    pub async fn run(mut self) -> ! {
+        let (state_chan, mut rx_chan, mut tx_chan) = self.ch.split();
+        let mut tick = Ticker::every(Duration::from_millis(500));
+        let mut packet = Packet::new();
+        state_chan.set_link_state(LinkState::Up);
+        loop {
+            match select3(
+                async {
+                    let rx_buf = rx_chan.rx_buf().await;
+                    self.radio.receive(&mut packet).await.ok().map(|_| rx_buf)
+                },
+                tx_chan.tx_buf(),
+                tick.next(),
+            )
+            .await
+            {
+                Either3::First(Some(rx_buf)) => {
+                    let len = rx_buf.len().min(packet.len() as usize);
+                    (&mut rx_buf[..len]).copy_from_slice(&*packet);
+                    rx_chan.rx_done(len);
+                }
+                Either3::Second(tx_buf) => {
+                    let len = tx_buf.len().min(Packet::CAPACITY as usize);
+                    packet.copy_from_slice(&tx_buf[..len]);
+                    self.radio.try_send(&mut packet).await.ok().unwrap();
+                    tx_chan.tx_done();
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+/// Make sure to use `HfclkSource::ExternalXtal` as the `hfclk_source`
+/// to use the radio (nrf52840 product spec v1.11 5.4.1)
+/// ```
+/// # use embassy_nrf::config::*;
+/// let mut config = Config::default();
+/// config.hfclk_source = HfclkSource::ExternalXtal;
+/// ```
+pub async fn new<'a, const N_RX: usize, const N_TX: usize, T: nrf::radio::Instance, Irq>(
+    mac_addr: [u8; 8],
+    radio: nrf::Peri<'a, T>,
+    irq: Irq,
+    state: &'a mut State<N_RX, N_TX>,
+) -> Result<(Device<'a>, Runner<'a, T>), ()>
+where
+    Irq: interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'a,
+{
+    let radio = Radio::new(radio, irq);
+
+    let (runner, device) = ch::new(&mut state.ch_state, ch::driver::HardwareAddress::Ieee802154(mac_addr));
+
+    Ok((device, Runner { ch: runner, radio }))
+}

examples/nrf52840/Cargo.toml

@@ -10,13 +10,15 @@ embassy-sync = { version = "0.7.0", path = "../../embassy-sync", features = ["de
 embassy-executor = { version = "0.7.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "executor-interrupt", "defmt"] }
 embassy-time = { version = "0.4.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime"] }
 embassy-nrf = { version = "0.3.1", path = "../../embassy-nrf", features = ["defmt", "nrf52840", "time-driver-rtc1", "gpiote", "unstable-pac", "time"] }
-embassy-net = { version = "0.7.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet"] }
+embassy-net = { version = "0.7.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet", "udp","medium-ieee802154", "proto-ipv6"] }
 embassy-usb = { version = "0.4.0", path = "../../embassy-usb", features = ["defmt"] }
 embedded-io = { version = "0.6.0", features = ["defmt-03"]  }
 embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
 embassy-net-esp-hosted = { version = "0.2.0", path = "../../embassy-net-esp-hosted", features = ["defmt"] }
 embassy-net-enc28j60 = { version = "0.2.0", path = "../../embassy-net-enc28j60", features = ["defmt"] }
 
+embassy-net-nrf-802154 = { version = "0.1.0", path = "../../embassy-net-nrf-802154", features = ["defmt", "nrf52840"]}
+
 defmt = "1.0.1"
 defmt-rtt = "1.0.0"
 

examples/nrf52840/src/bin/sixlowpan.rs

@@ -0,0 +1,124 @@
+#![no_std]
+#![no_main]
+
+use core::net::Ipv6Addr;
+
+use defmt::{info, unwrap, warn};
+use embassy_executor::Spawner;
+use embassy_net::udp::{PacketMetadata, UdpMetadata, UdpSocket};
+use embassy_net::{IpAddress, IpEndpoint, IpListenEndpoint, Ipv6Cidr, StackResources, StaticConfigV6};
+use embassy_nrf::config::{Config, HfclkSource};
+use embassy_nrf::rng::Rng;
+use embassy_nrf::{bind_interrupts, peripherals, radio};
+use embassy_time::Delay;
+use embedded_hal_async::delay::DelayNs;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    RADIO => radio::InterruptHandler<peripherals::RADIO>;
+    RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
+});
+
+#[embassy_executor::task]
+async fn ieee802154_task(runner: embassy_net_nrf_802154::Runner<'static, peripherals::RADIO>) -> ! {
+    runner.run().await
+}
+
+#[embassy_executor::task]
+async fn net_task(mut runner: embassy_net::Runner<'static, embassy_net_nrf_802154::Device<'static>>) -> ! {
+    runner.run().await
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let mut config = Config::default();
+    // Necessary to run the radio nrf52840 v1.11 5.4.1
+    config.hfclk_source = HfclkSource::ExternalXtal;
+    let p = embassy_nrf::init(config);
+
+    let mac_addr: [u8; 8] = [2, 3, 4, 5, 6, 7, 8, 9];
+    static NRF802154_STATE: StaticCell<embassy_net_nrf_802154::State<20, 20>> = StaticCell::new();
+    let (device, runner) = embassy_net_nrf_802154::new(
+        mac_addr,
+        p.RADIO,
+        Irqs,
+        NRF802154_STATE.init(embassy_net_nrf_802154::State::new()),
+    )
+    .await
+    .unwrap();
+
+    unwrap!(spawner.spawn(ieee802154_task(runner)));
+
+    let peer = Ipv6Addr::new(0xfe80, 0, 0, 0, 0xd701, 0xda3f, 0x3955, 0x82a4);
+    let local = Ipv6Addr::new(0xfe80, 0, 0, 0, 0xd701, 0xda3f, 0x3955, 0x82a5);
+
+    let config = embassy_net::Config::ipv6_static(StaticConfigV6 {
+        address: Ipv6Cidr::new(local, 64),
+        gateway: None,
+        dns_servers: Default::default(),
+    });
+
+    // Generate random seed
+    let mut rng = Rng::new(p.RNG, Irqs);
+    let mut seed = [0; 8];
+    rng.blocking_fill_bytes(&mut seed);
+    let seed = u64::from_le_bytes(seed);
+
+    // Init network stack
+    static RESOURCES: StaticCell<StackResources<3>> = StaticCell::new();
+    let (stack, runner) = embassy_net::new(device, config, RESOURCES.init(StackResources::new()), seed);
+
+    unwrap!(spawner.spawn(net_task(runner)));
+
+    let mut rx_buffer = [0; 2096];
+    let mut tx_buffer = [0; 2096];
+    let mut tx_m_buffer = [PacketMetadata::EMPTY; 5];
+    let mut rx_m_buffer = [PacketMetadata::EMPTY; 5];
+
+    let mut delay = Delay;
+    loop {
+        let mut socket = UdpSocket::new(
+            stack,
+            &mut tx_m_buffer,
+            &mut rx_buffer,
+            &mut rx_m_buffer,
+            &mut tx_buffer,
+        );
+        socket
+            .bind(IpListenEndpoint {
+                addr: Some(IpAddress::Ipv6(local)),
+                port: 1234,
+            })
+            .unwrap();
+        let rep = UdpMetadata {
+            endpoint: IpEndpoint {
+                addr: IpAddress::Ipv6(peer),
+                port: 1234,
+            },
+            local_address: Some(IpAddress::Ipv6(local)),
+            meta: Default::default(),
+        };
+
+        info!("Listening on {:?} UDP:1234...", local);
+
+        let mut recv_buf = [0; 12];
+        loop {
+            delay.delay_ms(2000).await;
+            if socket.may_recv() {
+                let n = match socket.recv_from(&mut recv_buf).await {
+                    Ok((0, _)) => panic!(),
+                    Ok((n, _)) => n,
+                    Err(e) => {
+                        warn!("read error: {:?}", e);
+                        break;
+                    }
+                };
+                info!("Received {:02x}", &recv_buf[..n]);
+            }
+
+            info!("Sending");
+            socket.send_to(b"Hello World", rep).await.unwrap();
+        }
+    }
+}