style: remove _ prefix from private members

Field and variable names prefixed with `_` tells the rust linter ("clippy" tool) that unused dead code shall be explicitly ignored. This does not bode well for static analysis on production code.

Coming from Arduino, this isn't the case. Arduino lib convention suggests to prefix private members with a `_` for readability. Many C++ linters don't treat the `_` prefix of member/variable/parameter names in any special way (excluding `#include` guards).

Author: 2bndy5

bindings/node/src/radio/config.rs

@@ -8,7 +8,7 @@ use napi::{bindgen_prelude::Buffer, JsNumber, Result};
 #[derive(Debug, Clone, Copy)]
 pub struct RadioConfig {
     inner: rf24::radio::RadioConfig,
-    _addr_buf: [u8; 5],
+    addr_buf: [u8; 5],
 }
 
 #[napi]
@@ -53,7 +53,7 @@ impl RadioConfig {
     pub fn new() -> Self {
         Self {
             inner: rf24::radio::RadioConfig::default(),
-            _addr_buf: [0u8; 5],
+            addr_buf: [0u8; 5],
         }
     }
 
@@ -344,8 +344,8 @@ impl RadioConfig {
     /// Get the address for a specified `pipe` set by {@link RadioConfig.setRxAddress}.
     #[napi]
     pub fn get_rx_address(&mut self, pipe: u8) -> Buffer {
-        self.inner.rx_address(pipe, &mut self._addr_buf);
-        Buffer::from(self._addr_buf.to_vec())
+        self.inner.rx_address(pipe, &mut self.addr_buf);
+        Buffer::from(self.addr_buf.to_vec())
     }
 
     /// Set the TX address.
@@ -359,8 +359,8 @@ impl RadioConfig {
 
     #[napi(getter, js_name = "txAddress")]
     pub fn get_tx_address(&mut self) -> Buffer {
-        self.inner.tx_address(&mut self._addr_buf);
-        Buffer::from(self._addr_buf.to_vec())
+        self.inner.tx_address(&mut self.addr_buf);
+        Buffer::from(self.addr_buf.to_vec())
     }
 
     /// Close a RX pipe from receiving data.
@@ -381,7 +381,7 @@ impl RadioConfig {
     pub fn from_inner(config: rf24::radio::RadioConfig) -> Self {
         Self {
             inner: config,
-            _addr_buf: [0u8; 5],
+            addr_buf: [0u8; 5],
         }
     }
 }

bindings/python/src/radio/config.rs

@@ -44,7 +44,7 @@ use std::borrow::Cow;
 #[derive(Debug, Clone, Copy)]
 pub struct RadioConfig {
     inner: rf24::radio::RadioConfig,
-    _addr_buf: [u8; 5],
+    addr_buf: [u8; 5],
 }
 
 #[pymethods]
@@ -53,7 +53,7 @@ impl RadioConfig {
     pub fn new() -> Self {
         Self {
             inner: rf24::radio::RadioConfig::default(),
-            _addr_buf: [0u8; 5],
+            addr_buf: [0u8; 5],
         }
     }
 
@@ -305,17 +305,17 @@ impl RadioConfig {
 
     /// Get the address for a specified `pipe` set by [`RadioConfig.set_rx_address()`][rf24_py.RadioConfig.set_rx_address].
     pub fn get_rx_address(&mut self, pipe: u8) -> Cow<[u8]> {
-        self.inner.rx_address(pipe, &mut self._addr_buf);
-        Cow::from(&self._addr_buf)
+        self.inner.rx_address(pipe, &mut self.addr_buf);
+        Cow::from(&self.addr_buf)
     }
 
     /// Set the TX address.
     ///
     /// Only pipe 0 can be used for TX operations (including auto-ACK packets during RX operations).
     #[getter]
     pub fn get_tx_address(&mut self) -> Cow<[u8]> {
-        self.inner.tx_address(&mut self._addr_buf);
-        Cow::from(&self._addr_buf)
+        self.inner.tx_address(&mut self.addr_buf);
+        Cow::from(&self.addr_buf)
     }
 
     #[setter]
@@ -339,7 +339,7 @@ impl RadioConfig {
     pub fn from_inner(config: rf24::radio::RadioConfig) -> Self {
         Self {
             inner: config,
-            _addr_buf: [0u8; 5],
+            addr_buf: [0u8; 5],
         }
     }
 }

crates/rf24-rs/src/radio/config.rs

@@ -1,4 +1,4 @@
-use crate::radio::rf24::bit_fields::{Config, Feature, SetupRetry, SetupRfAw};
+use crate::radio::rf24::bit_fields::{ConfigReg, Feature, SetupRetry, SetupRfAw};
 use crate::{CrcLength, DataRate, PaLevel};
 
 /// A struct to contain configuration about pipe addresses.
@@ -95,7 +95,7 @@ impl EsbPipeConfig {
 /// ```
 #[derive(Debug, Clone, Copy)]
 pub struct RadioConfig {
-    pub(crate) config_reg: Config,
+    pub(crate) config_reg: ConfigReg,
     pub(crate) auto_retries: SetupRetry,
     pub(crate) setup_rf_aw: SetupRfAw,
     pub(crate) feature: Feature,
@@ -150,7 +150,7 @@ impl Default for RadioConfig {
                - powered down
                - inactive TX (StandBy-I) mode
             */
-            config_reg: Config::default(),
+            config_reg: ConfigReg::default(),
             /*
                - 5 * 250 + 250 = 1500 us delay between attempts
                - 15 max attempts

crates/rf24-rs/src/radio/prelude.rs

@@ -336,7 +336,7 @@ pub trait EsbAutoAck: EsbPayloadLength {
     /// Both parameters are clamped to range [0, 15].
     /// - `delay`: How long to wait between each retry, in multiples of
     ///   250 us (microseconds). The minimum value of 0 means 250 us, and
-    ///   the maximum valueof 15 means 4000 us.
+    ///   the maximum value of 15 means 4000 us.
     ///   The default value of 5 means 1500us (`5 * 250 + 250`).
     /// - `count`: How many retries before giving up. The default/maximum is 15. Use
     ///   0 to disable the auto-retry feature.

crates/rf24-rs/src/radio/rf24/auto_ack.rs

@@ -13,14 +13,14 @@ where
     type AutoAckErrorType = Nrf24Error<SPI::Error, DO::Error>;
 
     fn set_ack_payloads(&mut self, enable: bool) -> Result<(), Self::AutoAckErrorType> {
-        if self._feature.ack_payloads() != enable {
+        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])
+            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,
+                self.feature.into_bits() & Feature::REG_MASK,
             )?;
 
             if enable {
@@ -33,13 +33,13 @@ where
     }
 
     fn get_ack_payloads(&self) -> bool {
-        self._feature.ack_payloads()
+        self.feature.ack_payloads()
     }
 
     fn set_auto_ack(&mut self, enable: bool) -> Result<(), Self::AutoAckErrorType> {
         self.spi_write_byte(registers::EN_AA, 0x3F * enable as u8)?;
         // accommodate ACK payloads feature
-        if !enable && self._feature.ack_payloads() {
+        if !enable && self.feature.ack_payloads() {
             self.set_ack_payloads(false)?;
         }
         Ok(())
@@ -51,23 +51,23 @@ where
         }
         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 {
+        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::AutoAckErrorType> {
         self.spi_read(1, registers::FEATURE)?;
-        self.spi_write_byte(registers::FEATURE, self._buf[1] & !1 | enable as u8)
+        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::AutoAckErrorType> {
-        if self._feature.ack_payloads() && pipe <= 5 {
+        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());
+            return Ok(!self.status.tx_full());
         }
         Ok(false)
     }

crates/rf24-rs/src/radio/rf24/bit_fields.rs

@@ -5,7 +5,7 @@ use crate::{CrcLength, DataRate, PaLevel};
 use super::mnemonics;
 
 #[bitfield(u8, order = Msb)]
-pub(crate) struct Config {
+pub(crate) struct ConfigReg {
     #[bits(1)]
     _padding: u8,
 
@@ -29,7 +29,7 @@ pub(crate) struct Config {
     pub is_rx: bool,
 }
 
-impl Config {
+impl ConfigReg {
     pub(crate) const CRC_MASK: u8 = 0b1100;
 
     pub const fn crc_length(&self) -> CrcLength {

crates/rf24-rs/src/radio/rf24/channel.rs

@@ -19,7 +19,7 @@ where
     /// See also [`RF24::set_channel()`].
     fn get_channel(&mut self) -> Result<u8, Self::ChannelErrorType> {
         self.spi_read(1, registers::RF_CH)?;
-        Ok(self._buf[1])
+        Ok(self.buf[1])
     }
 }
 

crates/rf24-rs/src/radio/rf24/crc_length.rs

@@ -1,6 +1,6 @@
 use embedded_hal::{delay::DelayNs, digital::OutputPin, spi::SpiDevice};
 
-use super::{registers, Config};
+use super::{registers, ConfigReg};
 use crate::radio::{prelude::EsbCrcLength, Nrf24Error, RF24};
 use crate::CrcLength;
 
@@ -14,17 +14,17 @@ where
 
     fn get_crc_length(&mut self) -> Result<CrcLength, Self::CrcLengthErrorType> {
         self.spi_read(1, registers::CONFIG)?;
-        if self._buf[1] & Config::CRC_MASK == 4 {
+        if self.buf[1] & ConfigReg::CRC_MASK == 4 {
             return Err(Nrf24Error::BinaryCorruption);
         }
-        self._config_reg = Config::from_bits(self._buf[1]);
-        Ok(self._config_reg.crc_length())
+        self.config_reg = ConfigReg::from_bits(self.buf[1]);
+        Ok(self.config_reg.crc_length())
     }
 
     fn set_crc_length(&mut self, crc_length: CrcLength) -> Result<(), Self::CrcLengthErrorType> {
         self.spi_read(1, registers::CONFIG)?;
-        self._config_reg = self._config_reg.with_crc_length(crc_length);
-        self.spi_write_byte(registers::CONFIG, self._config_reg.into_bits())
+        self.config_reg = self.config_reg.with_crc_length(crc_length);
+        self.spi_write_byte(registers::CONFIG, self.config_reg.into_bits())
     }
 }
 

crates/rf24-rs/src/radio/rf24/data_rate.rs

@@ -25,7 +25,7 @@ where
 
     fn get_data_rate(&mut self) -> Result<DataRate, Self::DataRateErrorType> {
         self.spi_read(1, registers::RF_SETUP)?;
-        let da_bin = self._buf[1] & DataRate::MASK;
+        let da_bin = self.buf[1] & DataRate::MASK;
         if da_bin == DataRate::MASK {
             return Err(Nrf24Error::BinaryCorruption);
         }
@@ -36,7 +36,7 @@ where
         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;
+        let out = self.buf[1] & !DataRate::MASK | da_bin;
         self.spi_write_byte(registers::RF_SETUP, out)
     }
 }

crates/rf24-rs/src/radio/rf24/details.rs

@@ -164,7 +164,7 @@ where
     #[cfg(not(target_os = "none"))]
     #[cfg(feature = "std")]
     fn print_details(&mut self) -> Result<(), Self::DetailsErrorType> {
-        use crate::radio::rf24::Config;
+        use crate::radio::rf24::ConfigReg;
 
         std::println!("Is a plus variant_________{}", self.is_plus_variant());
 
@@ -178,7 +178,7 @@ where
         std::println!("RF Power Amplifier________{}", self.get_pa_level()?);
 
         self.spi_read(1, registers::RF_SETUP)?;
-        let rf_setup = self._buf[1];
+        let rf_setup = self.buf[1];
         std::println!("RF LNA enabled____________{}", rf_setup & 1 > 0);
 
         std::println!("CRC Length________________{}", self.get_crc_length()?);
@@ -194,70 +194,70 @@ where
         );
 
         self.spi_read(1, registers::SETUP_RETR)?;
-        let retry_setup = self._buf[1];
+        let retry_setup = self.buf[1];
         std::println!(
             "Auto retry delay__________{} microseconds",
             (retry_setup >> 4) as u16 * 250 + 250
         );
         std::println!("Auto retry attempts_______{} maximum", retry_setup & 0x0F);
 
         self.spi_read(1, registers::FIFO_STATUS)?;
-        std::println!("Re-use TX FIFO____________{}", (self._buf[1] & 0x80) > 0);
+        std::println!("Re-use TX FIFO____________{}", (self.buf[1] & 0x80) > 0);
 
         self.spi_read(1, registers::OBSERVE_TX)?;
-        let observer = self._buf[1];
+        let observer = self.buf[1];
         std::println!("Packets lost\n    on current channel____{}", observer >> 4);
         std::println!(
             "Retry attempts made\n    for last transmission_{}",
             observer & 0xF
         );
 
         self.spi_read(1, registers::CONFIG)?;
-        self._config_reg = Config::from_bits(self._buf[1]);
-        std::println!("IRQ on Data Ready_________{}", self._config_reg.rx_dr());
-        std::println!("    Data Ready triggered__{}", self._status.rx_dr());
-        std::println!("IRQ on Data Sent__________{}", self._config_reg.tx_ds());
-        std::println!("    Data Sent triggered___{}", self._status.tx_ds());
-        std::println!("IRQ on Data Fail__________{}", self._config_reg.tx_df());
-        std::println!("    Data Fail triggered___{}", self._status.tx_df());
+        self.config_reg = ConfigReg::from_bits(self.buf[1]);
+        std::println!("IRQ on Data Ready_________{}", self.config_reg.rx_dr());
+        std::println!("    Data Ready triggered__{}", self.status.rx_dr());
+        std::println!("IRQ on Data Sent__________{}", self.config_reg.tx_ds());
+        std::println!("    Data Sent triggered___{}", self.status.tx_ds());
+        std::println!("IRQ on Data Fail__________{}", self.config_reg.tx_df());
+        std::println!("    Data Fail triggered___{}", self.status.tx_df());
 
         let fifo = self.get_fifo_state(true)?;
         std::println!("TX FIFO___________________{}", fifo);
         let fifo = self.get_fifo_state(false)?;
         std::println!("RX FIFO___________________{}", fifo);
 
         self.spi_read(1, registers::FEATURE)?;
-        let features = self._buf[1];
+        let features = self.buf[1];
         std::println!("Ask no ACK allowed________{}", features & 1 > 0);
         std::println!("ACK Payload enabled_______{}", features & 2 > 0);
 
         self.spi_read(1, registers::DYNPD)?;
-        std::println!("Dynamic Payloads__________{:#010b}", self._buf[1]);
+        std::println!("Dynamic Payloads__________{:#010b}", self.buf[1]);
 
         self.spi_read(1, registers::EN_AA)?;
-        std::println!("Auto Acknowledgment_______{:#010b}", self._buf[1]);
+        std::println!("Auto Acknowledgment_______{:#010b}", self.buf[1]);
 
         std::println!(
             "Primary Mode______________{}X",
-            if self._config_reg.is_rx() { "R" } else { "T" }
+            if self.config_reg.is_rx() { "R" } else { "T" }
         );
         std::println!("Powered Up________________{}", self.is_powered());
 
         // print pipe addresses
         self.spi_read(5, registers::TX_ADDR)?;
         let mut address = [0u8; 4];
-        address.copy_from_slice(&self._buf[2..6]);
+        address.copy_from_slice(&self.buf[2..6]);
         std::println!(
             "TX address_______________{:#08X}{:02X}",
             u32::from_le_bytes(address),
-            self._buf[1]
+            self.buf[1]
         );
         self.spi_read(1, registers::EN_RXADDR)?;
-        let open_pipes = self._buf[1];
+        let open_pipes = self.buf[1];
         for pipe in 0..=5 {
             self.spi_read(if pipe < 2 { 5 } else { 1 }, registers::RX_ADDR_P0 + pipe)?;
             if pipe < 2 {
-                address.copy_from_slice(&self._buf[2..6]);
+                address.copy_from_slice(&self.buf[2..6]);
             }
             std::println!(
                 "Pipe {pipe} ({}) bound to {:#08X}{:02X}",
@@ -268,7 +268,7 @@ where
                 },
                 // reverse the bytes read to represent how memory is stored
                 u32::from_le_bytes(address),
-                self._buf[1],
+                self.buf[1],
             );
         }
         Ok(())