use embassy_futures::select::Either;
use embassy_futures::select::select;
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::signal::Signal;
use embassy_time::Timer;
use esp_hal::efuse;
use esp_radio::ieee802154::Config;
use esp_radio::ieee802154::Error as Ieee802154Error;
use esp_radio::ieee802154::Ieee802154;
use esp_radio::ieee802154::ReceivedFrame;
use crate::mlme::MacError;
#[derive(Clone, Copy)]
enum TxEvent {
Done,
Failed,
}
static TX_SIGNAL: Signal<CriticalSectionRawMutex, TxEvent> = Signal::new();
static RX_SIGNAL: Signal<CriticalSectionRawMutex, ()> = Signal::new();
const TX_DONE_TIMEOUT_MS: u64 = 250;
fn eui48_to_eui64(mac: [u8; 6]) -> u64 {
u64::from_be_bytes([mac[0], mac[1], mac[2], 0xFF, 0xFE, mac[3], mac[4], mac[5]])
}
pub(crate) async fn wait_rx_signal() {
RX_SIGNAL.wait().await;
}
pub struct Ieee802154Driver<'a> {
driver: Ieee802154<'a>,
config: Config,
ieee_address: ieee802154::mac::ExtendedAddress,
}
impl<'a> Ieee802154Driver<'a> {
pub fn new(ieee802154: Ieee802154<'a>, config: Config) -> Self {
let mac_bytes: [u8; 6] = efuse::base_mac_address()
.as_bytes()
.try_into()
.expect("6-byte MAC");
let ieee_address = ieee802154::mac::ExtendedAddress(eui48_to_eui64(mac_bytes));
let mut driver = Self {
driver: ieee802154,
config,
ieee_address,
};
driver
.driver
.set_rx_available_callback_fn(Self::rx_callback);
driver.driver.set_tx_done_callback_fn(Self::tx_callback);
driver
.driver
.set_tx_failed_callback_fn(Self::tx_failed_callback);
driver.config.rx_when_idle = true;
driver.config.ext_addr = Some(ieee_address.0);
driver.update_driver_config(|_| {});
driver
}
pub fn ieee_address(&self) -> ieee802154::mac::ExtendedAddress {
self.ieee_address
}
pub fn short_address(&self) -> Option<u16> {
self.config.short_addr
}
pub fn update_driver_config(&mut self, update_fn: impl Fn(&mut Config)) {
update_fn(&mut self.config);
self.config.rx_when_idle = true;
self.config.ext_addr = Some(self.ieee_address.0);
self.driver.set_config(self.config);
}
fn rx_callback() {
RX_SIGNAL.signal(());
}
fn tx_callback() {
TX_SIGNAL.signal(TxEvent::Done);
}
fn tx_failed_callback() {
TX_SIGNAL.signal(TxEvent::Failed);
}
pub async fn transmit(&mut self, frame: &[u8]) -> Result<(), MacError> {
TX_SIGNAL.reset();
self.driver.transmit_raw(frame, true)?;
match select(Timer::after_millis(TX_DONE_TIMEOUT_MS), TX_SIGNAL.wait()).await {
Either::First(_) => Err(MacError::TxTimeout),
Either::Second(TxEvent::Done) => Ok(()),
Either::Second(TxEvent::Failed) => Err(MacError::TxFailed),
}
}
pub fn last_tx_acked(&self) -> bool {
self.driver.get_ack_frame().is_some()
}
pub fn last_ack_frame_pending(&self) -> Option<bool> {
self.driver
.get_ack_frame()
.and_then(|ack| ack.data.get(1).map(|fcf| fcf & 0x10 != 0))
}
pub fn poll_received(&mut self) -> Option<Result<ReceivedFrame, Ieee802154Error>> {
self.driver.received()
}
pub fn reset_rx_signal(&self) {
RX_SIGNAL.reset();
}
pub async fn wait_rx_available(&self) {
RX_SIGNAL.wait().await;
}
pub fn start_receive(&mut self) {
self.driver.start_receive();
}
}