Struct NRF24L01

pub struct NRF24L01<E: Debug, CE: OutputPin<Error = E>, SPI: SpiDevice<u8>> {
    pub spi: SPI,
    /* private fields */
}

Driver for the nRF24L01+

Never deal with this directly. Instead, you store one of the following types:

• StandbyMode<D>
• RxMode<D>
• TxMode<D>

where D: Device

Fields

spi: SPI

核心对象spi

Implementations

impl<E: Debug, CE: OutputPin<Error = E>, SPI: SpiDevice<u8, Error = SPIE>, SPIE: Debug> NRF24L01<E, CE, SPI>

pub async fn new(ce: CE, spi: SPI) -> Result<StandbyMode<Self>, Error<SPIE>>

Construct a new driver instance.

pub async fn is_connected(&mut self) -> Result<bool, Error<SPIE>>

Reads and validates content of the SETUP_AW register.

Trait Implementations

impl<E: Debug, CE: OutputPin<Error = E>, SPI: SpiDevice<u8, Error = SPIE>, SPIE: Debug> Debug for NRF24L01<E, CE, SPI>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Debug, CE: OutputPin<Error = E>, SPI: SpiDevice<u8, Error = SPIE>, SPIE: Debug> Device for NRF24L01<E, CE, SPI>

type Error = Error<SPIE>

Error from the SPI implementation

fn ce_enable(&mut self)

Set CE pin high

fn ce_disable(&mut self)

Set CE pin low

async fn send_command<C: Command>( &mut self, command: &C, ) -> Result<(Status, C::Response), Self::Error>

Send a command via SPI

async fn write_register<R: Register>( &mut self, register: R, ) -> Result<Status, Self::Error>

Send W_REGISTER command

async fn read_register<R: Register>( &mut self, ) -> Result<(Status, R), Self::Error>

Send R_REGISTER command

async fn update_config<F, R>(&mut self, f: F) -> Result<R, Self::Error>

where F: FnOnce(&mut Config) -> R,

Modify the (cached) CONFIG register and write if it has changed.

fn with_ce_disabled<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Self) -> R,

Helper; the receiving during RX and sending during TX require CE to be low.

async fn update_register<Reg, F, R>(&mut self, f: F) -> Result<R, Self::Error>

where Reg: Register + PartialEq + Clone, F: FnOnce(&mut Reg) -> R,

Read, and modify a register, and write it back if it has been changed.