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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224

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

use crate::radio::{prelude::EsbAutoAck, RF24};

use super::{commands, registers, Feature};

impl<SPI, DO, DELAY> EsbAutoAck for RF24<SPI, DO, DELAY>
where
    SPI: SpiDevice,
    DO: OutputPin,
    DELAY: DelayNs,
{
    fn set_ack_payloads(&mut self, enable: bool) -> Result<(), Self::Error> {
        if self.feature.ack_payloads() != enable {
            self.spi_read(1, registers::FEATURE)?;
            self.feature =
                Feature::from_bits(self.feature.into_bits() & !Feature::REG_MASK | self.buf[1])
                    .with_ack_payloads(enable);
            self.spi_write_byte(
                registers::FEATURE,
                self.feature.into_bits() & Feature::REG_MASK,
            )?;

            if enable {
                // Enable dynamic payload on all pipes
                self.spi_write_byte(registers::DYNPD, 0x3F)?;
            }
            // else disable ack payloads, but leave dynamic payload features as is
        }
        Ok(())
    }

    fn get_ack_payloads(&self) -> bool {
        self.feature.ack_payloads()
    }

    fn set_auto_ack(&mut self, enable: bool) -> Result<(), Self::Error> {
        self.spi_write_byte(registers::EN_AA, 0x3F * enable as u8)?;
        // accommodate ACK payloads feature
        if !enable && self.feature.ack_payloads() {
            self.set_ack_payloads(false)?;
        }
        Ok(())
    }

    fn set_auto_ack_pipe(&mut self, enable: bool, pipe: u8) -> Result<(), Self::Error> {
        if pipe > 5 {
            return Ok(());
        }
        self.spi_read(1, registers::EN_AA)?;
        let mask = 1 << pipe;
        let reg_val = self.buf[1];
        if !enable && self.feature.ack_payloads() && pipe == 0 {
            self.set_ack_payloads(enable)?;
        }
        self.spi_write_byte(registers::EN_AA, reg_val & !mask | (mask * enable as u8))
    }

    fn allow_ask_no_ack(&mut self, enable: bool) -> Result<(), Self::Error> {
        self.spi_read(1, registers::FEATURE)?;
        self.spi_write_byte(registers::FEATURE, self.buf[1] & !1 | enable as u8)
    }

    fn write_ack_payload(&mut self, pipe: u8, buf: &[u8]) -> Result<bool, Self::Error> {
        if self.feature.ack_payloads() && pipe <= 5 {
            let len = buf.len().min(32);
            self.spi_write_buf(commands::W_ACK_PAYLOAD | pipe, &buf[..len])?;
            return Ok(!self.status.tx_full());
        }
        Ok(false)
    }

    fn set_auto_retries(&mut self, delay: u8, count: u8) -> Result<(), Self::Error> {
        self.spi_write_byte(registers::SETUP_RETR, count.min(15) | (delay.min(15) << 4))
    }
}

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

    const EN_ACK_PAY: u8 = 1 << 1;
    const EN_DPL: u8 = 1 << 2;

    #[test]
    pub fn allow_ack_payloads() {
        let mut ack_buf = [0x55; 3];
        let valid_pipe = 2;
        ack_buf[0] = commands::W_ACK_PAYLOAD | valid_pipe;

        let spi_expectations = spi_test_expects![
            // enable ACK payloads
            // read/write FEATURE register
            (vec![registers::FEATURE, 0u8], vec![0xEu8, 0u8]),
            (
                vec![
                    registers::FEATURE | commands::W_REGISTER,
                    EN_ACK_PAY | EN_DPL,
                ],
                vec![0xEu8, 0u8],
            ),
            // write DYNPD register
            (
                vec![registers::DYNPD | commands::W_REGISTER, 0x3Fu8],
                vec![0xEu8, 0u8],
            ),
            // write_ack_payload()
            (ack_buf.to_vec(), vec![0u8; 3]),
            // write_ack_payload() again but with TX FIFO as full
            (ack_buf.to_vec(), vec![1u8; 3]),
            // read EN_AA register value
            (vec![registers::EN_AA, 1u8], vec![0u8, 0x3Fu8]),
            // disable ACK payloads in FEATURE register
            (
                vec![registers::FEATURE, 0x3Fu8],
                vec![0u8, EN_ACK_PAY | EN_DPL | 1]
            ),
            (
                vec![registers::FEATURE | commands::W_REGISTER, EN_DPL | 1],
                vec![0xEu8, 0u8],
            ),
            // set EN_AA register with pipe 0 disabled
            (
                vec![registers::EN_AA | commands::W_REGISTER, 0x3Eu8],
                vec![0xEu8, 0u8],
            ),
            // read EN_AA register value
            (vec![registers::EN_AA, 0u8], vec![0u8, 0x3Eu8]),
            // set EN_AA register with pipes 0 and 1 disabled
            (
                vec![registers::EN_AA | commands::W_REGISTER, 0x3Cu8],
                vec![0xEu8, 0u8],
            ),
        ];
        let mocks = mk_radio(&[], &spi_expectations);
        let (mut radio, mut spi, mut ce_pin) = (mocks.0, mocks.1, mocks.2);
        radio.set_ack_payloads(true).unwrap();
        // do again for region coverage (should result in Ok non-op)
        radio.set_ack_payloads(true).unwrap();
        let buf = &ack_buf[1..3];
        // write ACK payload to invalid pipe (results in Ok non-op)
        assert!(!radio.write_ack_payload(9, buf).unwrap());
        // write ACK payload to valid pipe (test will also mark TX FIFO as full)
        assert!(radio.write_ack_payload(valid_pipe, buf).unwrap());
        // write ACK payload to valid pipe with TX FIFO full
        assert!(!radio.write_ack_payload(valid_pipe, buf).unwrap());
        // disable invalid pipe number (results in Ok non-op)
        radio.set_auto_ack_pipe(false, 9).unwrap();
        // disable auto-ack on pipe 0 (also disables ack_payloads)
        radio.set_auto_ack_pipe(false, 0).unwrap();
        // disable pipe 1 for region coverage
        radio.set_auto_ack_pipe(false, 1).unwrap();
        spi.done();
        ce_pin.done();
    }

    #[test]
    pub fn set_auto_ack() {
        let spi_expectations = spi_test_expects![
            // enable ACK payloads
            // read/write FEATURE register
            (vec![registers::FEATURE, 0u8], vec![0xEu8, 0u8]),
            (
                vec![
                    registers::FEATURE | commands::W_REGISTER,
                    EN_ACK_PAY | EN_DPL,
                ],
                vec![0xEu8, 0u8],
            ),
            // write DYNPD register
            (
                vec![registers::DYNPD | commands::W_REGISTER, 0x3Fu8],
                vec![0xEu8, 0u8],
            ),
            // write EN_AA register value
            (
                vec![registers::EN_AA | commands::W_REGISTER, 0u8],
                vec![0xEu8, 0u8],
            ),
            // disable ACK payloads in FEATURE register
            (
                vec![registers::FEATURE, 0u8],
                vec![0u8, EN_ACK_PAY | EN_DPL]
            ),
            (
                vec![registers::FEATURE | commands::W_REGISTER, EN_DPL],
                vec![0xEu8, 0u8],
            ),
            // read RX_PL_WID
            (vec![commands::R_RX_PL_WID, 0u8], vec![0xEu8, 32]),
        ];
        let mocks = mk_radio(&[], &spi_expectations);
        let (mut radio, mut spi, mut ce_pin) = (mocks.0, mocks.1, mocks.2);
        radio.set_ack_payloads(true).unwrap();
        assert!(radio.get_ack_payloads());
        radio.set_auto_ack(false).unwrap();
        assert_eq!(radio.get_dynamic_payload_length().unwrap(), 32u8);
        spi.done();
        ce_pin.done();
    }

    #[test]
    pub fn allow_ask_no_ack() {
        let spi_expectations = spi_test_expects![
            // disable EN_DYN_ACK flag in FEATURE register
            (vec![registers::FEATURE, 0u8], vec![0u8, EN_ACK_PAY]),
            (
                vec![registers::FEATURE | commands::W_REGISTER, EN_ACK_PAY | 1],
                vec![0xEu8, 0u8],
            ),
        ];
        let mocks = mk_radio(&[], &spi_expectations);
        let (mut radio, mut spi, mut ce_pin) = (mocks.0, mocks.1, mocks.2);
        radio.allow_ask_no_ack(true).unwrap();
        spi.done();
        ce_pin.done();
    }
}