embassy-nrf 0.10.0

Embassy Hardware Abstraction Layer (HAL) for nRF series microcontrollers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! embassy-net IEEE 802.15.4 driver

use embassy_futures::select::{Either3, select3};
use embassy_net_driver_channel::driver::LinkState;
use embassy_net_driver_channel::{self as ch};
use embassy_time::{Duration, Ticker};

use crate::radio::InterruptHandler;
use crate::radio::ieee802154::{Packet, Radio};
use crate::{self as nrf, interrupt};

/// 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> {
    radio: nrf::radio::ieee802154::Radio<'d>,
    ch: ch::Runner<'d, MTU>,
}

impl<'d> Runner<'d> {
    /// 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>), ()>
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 }))
}