Struct dw1000::ranging::Response

#[repr(C)]pub struct Response {
    pub ping_reply_time: Duration,
    pub ping_round_trip_time: Duration,
    pub request_tx_time: Instant,
    pub request_reply_time: Duration,
}

Ranging response message

This message is typically sent in response to a ranging request, to wrap up the range measurement transaction.. See module documentation for more info.

Fields

ping_reply_time: Duration

The time between the ping being received and the reply being sent

ping_round_trip_time: Duration

The time between the ping being sent and the reply being received

request_tx_time: Instant

The time the ranging request was sent, in local sender time

request_reply_time: Duration

The time between the request being received and a reply being sent

Methods

impl Response

pub fn new<SPI, CS>(
    dw1000: &mut DW1000<SPI, CS, Ready>,
    request: &RxMessage<Request>
) -> Result<TxMessage<Self>, Error<SPI, CS>> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

Creates a new ranging response message

Only creates the message, but doesn't yet send it. Sets the transmission time to 10 milliseconds in the future. Make sure to send the message within that time frame, or the distance measurement will be negatively affected.

Trait Implementations

impl Debug for Response

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Response

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Message for Response

const PRELUDE: Prelude

A prelude that identifies the message

const PRELUDE_LEN: usize

The length of the message's prelude

const LEN: usize

The length of the whole message, including prelude and data

fn decode<SPI, CS>(
    message: &Message
) -> Result<Option<RxMessage<Self>>, Error<SPI, CS>> where
    SPI: Transfer<u8> + Write<u8>,
    CS: OutputPin, 

Decodes a received message of this type

impl Serialize for Response

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.