rf24-rs 0.3.1

A pure-rust driver for the nRF24L01 wireless transceiver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use embedded_hal::{delay::DelayNs, digital::OutputPin, spi::SpiDevice};

use super::registers;
use crate::radio::{prelude::EsbDataRate, Nrf24Error, RF24};
use crate::DataRate;

/// A function to set the [`RF24::tx_delay`] in accordance with the desired [`DataRate`].
///
/// This function is only public to the crate::radio::rf24 module.
pub(super) fn set_tx_delay(data_rate: DataRate) -> u32 {
    match data_rate {
        DataRate::Mbps1 => 280,
        DataRate::Mbps2 => 240,
        DataRate::Kbps250 => 505,
    }
}

impl<SPI, DO, DELAY> EsbDataRate for RF24<SPI, DO, DELAY>
where
    SPI: SpiDevice,
    DO: OutputPin,
    DELAY: DelayNs,
{
    fn get_data_rate(&mut self) -> Result<DataRate, Self::Error> {
        self.spi_read(1, registers::RF_SETUP)?;
        let da_bin = self.buf[1] & DataRate::MASK;
        if da_bin == DataRate::MASK {
            return Err(Nrf24Error::BinaryCorruption);
        }
        Ok(DataRate::from_bits(da_bin))
    }

    fn set_data_rate(&mut self, data_rate: DataRate) -> Result<(), Self::Error> {
        self.tx_delay = set_tx_delay(data_rate);
        self.spi_read(1, registers::RF_SETUP)?;
        let da_bin = data_rate.into_bits();
        let out = self.buf[1] & !DataRate::MASK | da_bin;
        self.spi_write_byte(registers::RF_SETUP, out)
    }
}

/////////////////////////////////////////////////////////////////////////////////
/// unit tests
#[cfg(test)]
mod test {
    extern crate std;
    use super::{registers, DataRate, EsbDataRate, Nrf24Error};
    use crate::{radio::rf24::commands, spi_test_expects, test::mk_radio};
    use embedded_hal_mock::eh1::spi::Transaction as SpiTransaction;
    use std::vec;

    #[test]
    pub fn get_data_rate() {
        let spi_expectations = spi_test_expects![
            // get the RF_SETUP register value for each possible result
            (vec![registers::RF_SETUP, 0], vec![0xEu8, 0]),
            (vec![registers::RF_SETUP, 0], vec![0xEu8, 8]),
            (vec![registers::RF_SETUP, 8], vec![0xEu8, 0x20]),
            (vec![registers::RF_SETUP, 0x20], vec![0xEu8, DataRate::MASK]),
        ];
        let mocks = mk_radio(&[], &spi_expectations);
        let (mut radio, mut spi, mut ce_pin) = (mocks.0, mocks.1, mocks.2);
        assert_eq!(radio.get_data_rate(), Ok(DataRate::Mbps1));
        assert_eq!(radio.get_data_rate(), Ok(DataRate::Mbps2));
        assert_eq!(radio.get_data_rate(), Ok(DataRate::Kbps250));
        assert_eq!(radio.get_data_rate(), Err(Nrf24Error::BinaryCorruption));
        spi.done();
        ce_pin.done();
    }

    #[test]
    pub fn set_data_rate() {
        let spi_expectations = spi_test_expects![
            // set the RF_SETUP register value for each possible enumeration of CrcLength
            (vec![registers::RF_SETUP, 0], vec![0xEu8, DataRate::MASK]),
            (
                vec![registers::RF_SETUP | commands::W_REGISTER, 0],
                vec![0xEu8, 0],
            ),
            (vec![registers::RF_SETUP, 0], vec![0xEu8, DataRate::MASK]),
            (
                vec![registers::RF_SETUP | commands::W_REGISTER, 0x8],
                vec![0xEu8, 0],
            ),
            (vec![registers::RF_SETUP, 0], vec![0xEu8, DataRate::MASK]),
            (
                vec![registers::RF_SETUP | commands::W_REGISTER, 0x20],
                vec![0xEu8, 0],
            ),
        ];
        let mocks = mk_radio(&[], &spi_expectations);
        let (mut radio, mut spi, mut ce_pin) = (mocks.0, mocks.1, mocks.2);
        radio.set_data_rate(DataRate::Mbps1).unwrap();
        radio.set_data_rate(DataRate::Mbps2).unwrap();
        radio.set_data_rate(DataRate::Kbps250).unwrap();
        spi.done();
        ce_pin.done();
    }
}