NaxdyOrg/embassy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove jewel dependency

Browse source
This commit is contained in:
Guilherme S. Salustiano 2024-02-07 18:04:29 +01:00
parent d408056a66
commit 5f1b80d40b
5 changed files with 86 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
embassy-nrf/Cargo.toml
View file

@ -58,7 +58,7 @@ unstable-pac = []
gpiote = []
## Enable radio driver
radio = ["dep:jewel"]
radio = []
## Use RTC1 as the time driver for `embassy-time`, with a tick rate of 32.768khz
time-driver-rtc1 = ["_time-driver"]
@ -153,8 +153,6 @@ embedded-storage-async = "0.4.0"
cfg-if = "1.0.0"
document-features = "0.2.7"
jewel = { version = "0.1.0", git = "https://github.com/jewel-rs/jewel", optional = true }
nrf51-pac = { version = "0.12.0", optional = true }
nrf52805-pac = { version = "0.12.0", optional = true }
nrf52810-pac = { version = "0.12.0", optional = true }

160
embassy-nrf/src/radio/ble.rs
View file

@ -17,11 +17,10 @@ use core::task::Poll;
use embassy_hal_internal::drop::OnDrop;
use embassy_hal_internal::{into_ref, PeripheralRef};
use jewel::phy::{Channel, ChannelTrait, HeaderSize, Mode, Radio as BleRadio, CRC_POLY, MAX_PDU_LENGTH};
use pac::radio::mode::MODE_A as PacMode;
pub use pac::radio::mode::MODE_A as Mode;
use pac::radio::pcnf0::PLEN_A as PreambleLength;
// Re-export SVD variants to allow user to directly set values.
pub use pac::radio::{state::STATE_A as RadioState, txpower::TXPOWER_A as TxPower};
use pac::radio::state::STATE_A as RadioState;
pub use pac::radio::txpower::TXPOWER_A as TxPower;
use crate::interrupt::typelevel::Interrupt;
use crate::radio::*;
@ -51,11 +50,6 @@ impl<'d, T: Instance> Radio<'d, T> {
radio: impl Peripheral<P = T> + 'd,
_irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'd,
) -> Self {
// From 5.4.1 of the nRF52840 Product Specification:
// > The HFXO must be running to use the RADIO or the calibration mechanism associated with the 32.768 kHz RC oscillator.
// Currently the jewel crate don't implement the calibration mechanism, so we need to ensure that the HFXO is running
utils::check_xtal();
into_ref!(radio);
let r = T::regs();
@ -113,18 +107,6 @@ impl<'d, T: Instance> Radio<'d, T> {
.three()
});
r.crcpoly.write(|w| unsafe {
// Configure the CRC polynomial
// Each term in the CRC polynomial is mapped to a bit in this
// register which index corresponds to the term's exponent.
// The least significant term/bit is hard-wired internally to
// 1, and bit number 0 of the register content is ignored by
// the hardware. The following example is for an 8 bit CRC
// polynomial: x8 + x7 + x3 + x2 + 1 = 1 1000 1101 .
w.crcpoly().bits(CRC_POLY & 0xFFFFFF)
});
// The CRC initial value varies depending of the PDU type
// Ch map between 2400 MHZ .. 2500 MHz
// All modes use this range
r.frequency.write(|w| w.map().default());
@ -140,9 +122,7 @@ impl<'d, T: Instance> Radio<'d, T> {
T::Interrupt::unpend();
unsafe { T::Interrupt::enable() };
let mut radio = Self { _p: radio };
radio
Self { _p: radio }
}
#[allow(dead_code)]
@ -186,7 +166,6 @@ impl<'d, T: Instance> Radio<'d, T> {
trace!("radio drop: stopped");
});
/* Config interrupt */
// trace!("radio:enable interrupt");
// Clear some remnant side-effects (I'm unsure if this is needed)
r.events_end.reset();
@ -238,34 +217,34 @@ impl<'d, T: Instance> Radio<'d, T> {
r.events_disabled.reset();
}
}
}
impl<'d, T: Instance> BleRadio for Radio<'d, T> {
type Error = Error;
fn set_mode(&mut self, mode: Mode) {
/// Set the radio mode
///
/// The radio must be disabled before calling this function
pub fn set_mode(&mut self, mode: Mode) {
let r = T::regs();
r.mode.write(|w| {
w.mode().variant(match mode {
Mode::Ble1mbit => PacMode::BLE_1MBIT,
//Mode::Ble2mbit => PacMode::BLE_2MBIT,
})
});
r.mode.write(|w| w.mode().variant(mode));
r.pcnf0.write(|w| {
w.plen().variant(match mode {
Mode::Ble1mbit => PreambleLength::_8BIT,
//Mode::Ble2mbit => PreambleLength::_16BIT,
Mode::BLE_1MBIT => PreambleLength::_8BIT,
Mode::BLE_2MBIT => PreambleLength::_16BIT,
Mode::BLE_LR125KBIT | Mode::BLE_LR500KBIT => PreambleLength::LONG_RANGE,
_ => unimplemented!(),
})
});
}
fn set_header_size(&mut self, header_size: HeaderSize) {
/// Set the header size changing the S1 field
///
/// The radio must be disabled before calling this function
pub fn set_header_expansion(&mut self, use_s1_field: bool) {
let r = T::regs();
let s1len: u8 = match header_size {
HeaderSize::TwoBytes => 0,
HeaderSize::ThreeBytes => 8, // bits
// s1 len in bits
let s1len: u8 = match use_s1_field {
false => 0,
true => 8,
};
r.pcnf0.write(|w| unsafe {
@ -283,16 +262,36 @@ impl<'d, T: Instance> BleRadio for Radio<'d, T> {
});
}
fn set_channel(&mut self, channel: Channel) {
/// Set initial data whitening value
/// Data whitening is used to avoid long sequences of zeros or ones, e.g., 0b0000000 or 0b1111111, in the data bit stream
/// On BLE the initial value is the channel index | 0x40
///
/// The radio must be disabled before calling this function
pub fn set_whitening_init(&mut self, whitening_init: u8) {
let r = T::regs();
r.datawhiteiv.write(|w| unsafe { w.datawhiteiv().bits(whitening_init) });
}
/// Set the central frequency to be used
/// It should be in the range 2400..2500
///
/// The radio must be disabled before calling this function
pub fn set_frequency(&mut self, frequency: u32) {
assert!(2400 <= frequency && frequency <= 2500);
let r = T::regs();
r.frequency
.write(|w| unsafe { w.frequency().bits((channel.central_frequency() - 2400) as u8) });
r.datawhiteiv
.write(|w| unsafe { w.datawhiteiv().bits(channel.whitening_init()) });
.write(|w| unsafe { w.frequency().bits((frequency - 2400) as u8) });
}
fn set_access_address(&mut self, access_address: u32) {
/// Set the acess address
/// This address is always constants for advertising
/// And a random value generate on each connection
/// It is used to filter the packages
///
/// The radio must be disabled before calling this function
pub fn set_access_address(&mut self, access_address: u32) {
let r = T::regs();
// Configure logical address
@ -327,44 +326,55 @@ impl<'d, T: Instance> BleRadio for Radio<'d, T> {
});
}
fn set_crc_init(&mut self, crc_init: u32) {
/// Set the CRC polynomial
/// It only uses the 24 least significant bits
///
/// The radio must be disabled before calling this function
pub fn set_crc_poly(&mut self, crc_poly: u32) {
let r = T::regs();
r.crcpoly.write(|w| unsafe {
// Configure the CRC polynomial
// Each term in the CRC polynomial is mapped to a bit in this
// register which index corresponds to the term's exponent.
// The least significant term/bit is hard-wired internally to
// 1, and bit number 0 of the register content is ignored by
// the hardware. The following example is for an 8 bit CRC
// polynomial: x8 + x7 + x3 + x2 + 1 = 1 1000 1101 .
w.crcpoly().bits(crc_poly & 0xFFFFFF)
});
}
/// Set the CRC init value
/// It only uses the 24 least significant bits
/// The CRC initial value varies depending of the PDU type
///
/// The radio must be disabled before calling this function
pub fn set_crc_init(&mut self, crc_init: u32) {
let r = T::regs();
r.crcinit.write(|w| unsafe { w.crcinit().bits(crc_init & 0xFFFFFF) });
}
fn set_tx_power(&mut self, power_db: i8) {
/// Set the radio tx power
///
/// The radio must be disabled before calling this function
pub fn set_tx_power(&mut self, tx_power: TxPower) {
let r = T::regs();
let tx_power: TxPower = match power_db {
8..=i8::MAX => TxPower::POS8D_BM,
7 => TxPower::POS7D_BM,
6 => TxPower::POS6D_BM,
5 => TxPower::POS5D_BM,
4 => TxPower::POS4D_BM,
3 => TxPower::POS3D_BM,
1..=2 => TxPower::POS2D_BM,
-3..=0 => TxPower::_0D_BM,
-7..=-4 => TxPower::NEG4D_BM,
-11..=-8 => TxPower::NEG8D_BM,
-15..=-12 => TxPower::NEG12D_BM,
-19..=-16 => TxPower::NEG16D_BM,
-29..=-20 => TxPower::NEG20D_BM,
-39..=-30 => TxPower::NEG30D_BM,
i8::MIN..=-40 => TxPower::NEG40D_BM,
};
r.txpower.write(|w| w.txpower().variant(tx_power));
}
fn set_buffer(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
/// Set buffer to read/write
///
/// This method is unsound. You should guarantee that the buffer will live
/// for the life time of the transmission or if the buffer will be modified.
/// Also if the buffer is smaller than the packet length, the radio will
/// read/write memory out of the buffer bounds.
pub fn set_buffer(&mut self, buffer: &[u8]) -> Result<(), Error> {
// Because we are serializing the buffer, we should always have the buffer in RAM
slice_in_ram_or(buffer, Error::BufferNotInRAM)?;
if buffer.len() > MAX_PDU_LENGTH {
return Err(Error::BufferTooLong);
}
let r = T::regs();
// Here we are considering that the length of the packet is
@ -379,7 +389,7 @@ impl<'d, T: Instance> BleRadio for Radio<'d, T> {
}
/// Send packet
async fn transmit(&mut self) {
pub async fn transmit(&mut self) {
let r = T::regs();
self.trigger_and_wait_end(move || {
@ -390,8 +400,8 @@ impl<'d, T: Instance> BleRadio for Radio<'d, T> {
.await;
}
/// Send packet
async fn receive(&mut self) {
/// Receive packet
pub async fn receive(&mut self) {
let r = T::regs();
self.trigger_and_wait_end(move || {

14
embassy-nrf/src/radio/mod.rs
View file

@ -29,20 +29,6 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
}
}
pub(crate) mod utils {
use super::*;
// Check if the HFCLK is XTAL is enabled
pub fn check_xtal() {
// safe: only reading the value
let is_xtal = unsafe {
let r = &*pac::CLOCK::ptr();
r.hfclkstat.read().src().is_xtal()
};
assert!(is_xtal, "HFCLK must be XTAL");
}
}
pub(crate) mod sealed {
use embassy_sync::waitqueue::AtomicWaker;

4
examples/nrf52840/Cargo.toml
View file

@ -35,10 +35,6 @@ embedded-hal-async = { version = "1.0" }
embedded-hal-bus = { version = "0.1", features = ["async"] }
num-integer = { version = "0.1.45", default-features = false }
microfft = "0.5.0"
jewel = { version = "0.1.0", git = "https://github.com/jewel-rs/jewel"}
[patch.crates-io]
embassy-time = { version = "0.3.0", path = "../../embassy-time"}
[profile.release]
debug = 2

42
examples/nrf52840/src/bin/radio_ble_advertising.rs
View file

@ -1,42 +0,0 @@
#![no_std]
#![no_main]
use defmt::{info, unwrap};
use embassy_executor::Spawner;
use embassy_nrf::{bind_interrupts, peripherals, radio};
use embassy_time::Timer;
use jewel::phy::Radio;
use {defmt_rtt as _, panic_probe as _};
bind_interrupts!(struct Irqs {
RADIO => radio::InterruptHandler<peripherals::RADIO>;
});
// For a high-level API look on jewel examples
#[embassy_executor::main]
async fn main(_spawner: Spawner) {
let mut config = embassy_nrf::config::Config::default();
config.hfclk_source = embassy_nrf::config::HfclkSource::ExternalXtal;
let p = embassy_nrf::init(config);
info!("Starting BLE radio");
let mut radio = radio::ble::Radio::new(p.RADIO, Irqs);
let pdu = [
0x46u8, // ADV_NONCONN_IND, Random address,
0x18, // Length of payload
0x27, 0xdc, 0xd0, 0xe8, 0xe1, 0xff, // Adress
0x02, 0x01, 0x06, // Flags
0x03, 0x03, 0x09, 0x18, // Complete list of 16-bit UUIDs available
0x0A, 0x09, // Length, Type: Device name
b'H', b'e', b'l', b'l', b'o', b'R', b'u', b's', b't',
];
unwrap!(radio.set_buffer(pdu.as_ref()));
loop {
info!("Sending packet");
radio.transmit().await;
Timer::after_millis(500).await;
}
}