Struct dw1000::hl::DW1000

pub struct DW1000<SPI, CS, State> { /* fields omitted */ }

Entry point to the DW1000 driver API

Implementations

impl<SPI, CS, State> DW1000<SPI, CS, State> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin,
    State: Awake, 

pub fn get_tx_antenna_delay(&mut self) -> Result<Duration, Error<SPI, CS>>

Returns the TX antenna delay

pub fn get_rx_antenna_delay(&mut self) -> Result<Duration, Error<SPI, CS>>

Returns the RX antenna delay

pub fn get_address(&mut self) -> Result<Address, Error<SPI, CS>>

Returns the network id and address used for sending and receiving

pub fn sys_time(&mut self) -> Result<Instant, Error<SPI, CS>>

Returns the current system time

pub fn ll(&mut self) -> &mut DW1000<SPI, CS>

Provides direct access to the register-level API

Be aware that by using the register-level API, you can invalidate various assumptions that the high-level API makes about the operation of the DW1000. Don’t use the register-level and high-level APIs in tandem, unless you know what you’re doing.

impl<SPI, CS> DW1000<SPI, CS, Ready> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

pub fn set_antenna_delay(
    &mut self,
    rx_delay: u16,
    tx_delay: u16
) -> Result<(), Error<SPI, CS>>

Sets the RX and TX antenna delays

pub fn set_address(
    &mut self,
    pan_id: PanId,
    addr: ShortAddress
) -> Result<(), Error<SPI, CS>>

Sets the network id and address used for sending and receiving

pub fn set_sync_behaviour(
    &mut self,
    behaviour: SyncBehaviour
) -> Result<(), Error<SPI, CS>>

Sets up the sync pin functionality

After init, it is set to None

pub fn set_irq_polarity(
    &mut self,
    polarity: IrqPolarity
) -> Result<(), Error<SPI, CS>>

Set the polarity of the interrupt pin.

The default is ActiveHigh, which is also recommended for power savings.

pub fn send(
    self,
    data: &[u8],
    destination: Option<Address>,
    send_time: SendTime,
    config: TxConfig
) -> Result<DW1000<SPI, CS, Sending>, Error<SPI, CS>>

Send an IEEE 802.15.4 MAC frame

The data argument is wrapped into an IEEE 802.15.4 MAC frame and sent to destination.

This operation can be delayed to aid in distance measurement, by setting delayed_time to Some(instant). If you want to send the frame as soon as possible, just pass None instead.

The config parameter struct allows for setting the channel, bitrate, and more. This configuration needs to be the same as the configuration used by the receiver, or the message may not be received. The defaults are a sane starting point.

This method starts the transmission and returns immediately thereafter. It consumes this instance of DW1000 and returns another instance which is in the Sending state, and can be used to wait for the transmission to finish and check its result.

pub fn receive(
    self,
    config: RxConfig
) -> Result<DW1000<SPI, CS, SingleBufferReceiving>, Error<SPI, CS>>

Attempt to receive a single IEEE 802.15.4 MAC frame

Initializes the receiver. The method consumes this instance of DW1000 and returns another instance which is in the SingleBufferReceiving state, and can be used to wait for a message.

The config parameter allows for the configuration of bitrate, channel and more. Make sure that the values used are the same as of the frames that are transmitted. The default works with the TxConfig’s default and is a sane starting point.

pub fn receive_auto_double_buffered(
    self,
    config: RxConfig
) -> Result<DW1000<SPI, CS, AutoDoubleBufferReceiving>, Error<SPI, CS>>

Attempt to receive many IEEE 802.15.4 MAC frames. This is done in double buffered mode and auto re-enable. This means that once a message has been received, the radio will switch receive buffer and continue receiving.

If the double buffer is full while another message comes in, then the buffers will be corrupted. In that case, you will get the radio back in the Ready state and have to manually call this function again.

Initializes the receiver. The method consumes this instance of DW1000 and returns another instance which is in the AutoDoubleBufferReceiving state, and can be used to wait for a message.

The config parameter allows for the configuration of bitrate, channel and more. Make sure that the values used are the same as of the frames that are transmitted. The default works with the TxConfig’s default and is a sane starting point.

pub fn enable_tx_interrupts(&mut self) -> Result<(), Error<SPI, CS>>

Enables transmit interrupts for the events that wait checks

Overwrites any interrupt flags that were previously set.

pub fn enable_rx_interrupts(&mut self) -> Result<(), Error<SPI, CS>>

Enables receive interrupts for the events that wait checks

Overwrites any interrupt flags that were previously set.

pub fn disable_interrupts(&mut self) -> Result<(), Error<SPI, CS>>

Disables all interrupts

pub fn configure_leds(
    &mut self,
    enable_rx_ok: bool,
    enable_sfd: bool,
    enable_rx: bool,
    enable_tx: bool,
    blink_time: u8
) -> Result<(), Error<SPI, CS>>

Configures the gpio pins to operate as LED output.

• Note: This means that the function of the gpio pins change
• Note: Both the kilohertz and debounce clock will be turned on or off

---

• RXOKLED will change GPIO0
• SFDLED will change GPIO1
• RXLED will change GPIO2
• TXLED will change GPIO3

blink_time is in units of 14 ms

pub fn enter_sleep(
    self,
    irq_on_wakeup: bool,
    sleep_duration: Option<u16>
) -> Result<DW1000<SPI, CS, Sleeping>, Error<SPI, CS>>

Puts the dw1000 into sleep mode.

• irq_on_wakeup: When set to true, the IRQ pin will be asserted when the radio wakes up
• sleep_duration: When None, the radio will not wake up by itself and go into the deep sleep mode. When Some, then the radio will wake itself up after the given time. Every tick is ~431ms, but there may be a significant deviation from this due to the chip’s manufacturing process.

Note: The SPI speed may be at most 3 Mhz when calling this function.

impl<SPI, CS, RECEIVING> DW1000<SPI, CS, RECEIVING> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin,
    RECEIVING: Receiving, 

pub fn wait_receive<'b>(
    &mut self,
    buffer: &'b mut [u8]
) -> Result<Message<'b>, Error<SPI, CS>>

Wait for receive operation to finish

This method returns an nb::Result to indicate whether the transmission has finished, or whether it is still ongoing. You can use this to busily wait for the transmission to finish, for example using nb’s block! macro, or you can use it in tandem with DW1000::enable_rx_interrupts and the DW1000 IRQ output to wait in a more energy-efficient manner.

Handling the DW1000’s IRQ output line is out of the scope of this driver, but please note that if you’re using the DWM1001 module or DWM1001-Dev board, that the dwm1001 crate has explicit support for this.

pub fn read_rx_quality(&mut self) -> Result<RxQuality, Error<SPI, CS>>

Reads the quality of the received message.

This must be called after the DW1000::wait_receive function has successfully returned.

pub fn read_external_sync_time(
    &mut self
) -> Result<(u32, u8, u64), Error<SPI, CS>>

Gets the external sync values from the registers.

The tuple contains (cycles_since_sync, nanos_until_tick, raw_timestamp). See the user manual at 6.1.3 to see how to calculate the actual time value. In the manual, the return values are named (N, T1, RX_RAWST) This is left to the user so the precision of the calculations are left to the user to decide.

pub fn finish_receiving(
    self
) -> Result<DW1000<SPI, CS, Ready>, (Self, Error<SPI, CS>)>

Finishes receiving and returns to the Ready state

If the receive operation has finished, as indicated by wait, this is a no-op. If the receive operation is still ongoing, it will be aborted.

impl<SPI, CS> DW1000<SPI, CS, AutoDoubleBufferReceiving> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

pub fn continue_receiving(
    self
) -> Result<DW1000<SPI, CS, AutoDoubleBufferReceiving>, Result<DW1000<SPI, CS, Ready>, (Self, Error<SPI, CS>)>>

Try to continue receiving

impl<SPI, CS> DW1000<SPI, CS, Sending> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

pub fn wait_transmit(&mut self) -> Result<Instant, Error<SPI, CS>>

Wait for the transmission to finish

This method returns an nb::Result to indicate whether the transmission has finished, or whether it is still ongoing. You can use this to busily wait for the transmission to finish, for example using nb’s block! macro, or you can use it in tandem with DW1000::enable_tx_interrupts and the DW1000 IRQ output to wait in a more energy-efficient manner.

Handling the DW1000’s IRQ output line is out of the scope of this driver, but please note that if you’re using the DWM1001 module or DWM1001-Dev board, that the dwm1001 crate has explicit support for this.

pub fn finish_sending(
    self
) -> Result<DW1000<SPI, CS, Ready>, (Self, Error<SPI, CS>)>

Finishes sending and returns to the Ready state

If the send operation has finished, as indicated by wait, this is a no-op. If the send operation is still ongoing, it will be aborted.

impl<SPI, CS> DW1000<SPI, CS, Sleeping> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

pub fn wake_up<DELAY: DelayUs<u16>>(
    self,
    delay: &mut DELAY
) -> Result<DW1000<SPI, CS, Ready>, Error<SPI, CS>>

Wakes the radio up.

impl<SPI, CS> DW1000<SPI, CS, Uninitialized> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

pub fn new(spi: SPI, chip_select: CS) -> Self

Create a new instance of DW1000

Requires the SPI peripheral and the chip select pin that are connected to the DW1000.

pub fn init<D: DelayMs<u8>>(
    self,
    delay: &mut D
) -> Result<DW1000<SPI, CS, Ready>, Error<SPI, CS>>

Initialize the DW1000

The DW1000’s default configuration is somewhat inconsistent, and the user manual (section 2.5.5) has a long list of default configuration values that should be changed to guarantee everything works correctly. This method does just that.

Please note that this method assumes that you kept the default configuration. It is generally recommended not to change configuration before calling this method.

Trait Implementations

impl<SPI, CS, State> Debug for DW1000<SPI, CS, State> where
    State: Debug, 

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

Formats the value using the given formatter.