remove StatusFlags struct

Author: 2bndy5

RF24.cpp

@@ -12,50 +12,6 @@
 
 /****************************************************************************/
 
-int StatusFlags::toString(char* buf) const
-{
-    return sprintf(buf, "rx_dr: %s, tx_ds: %s, tx_df: %s, rx_pipe: %d, tx_full: %s",
-                   rx_dr() ? "true" : "false", tx_ds() ? "true" : "false",
-                   tx_df() ? "true" : "false", rx_pipe(), tx_full() ? "true" : "false");
-}
-
-/****************************************************************************/
-
-const bool StatusFlags::tx_full() const
-{
-    return value & _BV(TX_FULL);
-}
-
-/****************************************************************************/
-
-const uint8_t StatusFlags::rx_pipe() const
-{
-    return (value >> RX_P_NO) & 7;
-}
-
-/****************************************************************************/
-
-const bool StatusFlags::tx_df() const
-{
-    return value & RF24_TX_DF;
-}
-
-/****************************************************************************/
-
-const bool StatusFlags::tx_ds() const
-{
-    return value & RF24_TX_DS;
-}
-
-/****************************************************************************/
-
-const bool StatusFlags::rx_dr() const
-{
-    return value & RF24_RX_DR;
-}
-
-/****************************************************************************/
-
 void RF24::csn(bool mode)
 {
 #if defined(RF24_TINY)

RF24.h

@@ -152,67 +152,6 @@ typedef enum
     RF24_IRQ_ALL = (1 << MASK_MAX_RT) | (1 << TX_DS) | (1 << RX_DR),
 } rf24_irq_flags_e;
 
-/**
- * @brief A bit-field struct to represent the radio's STATUS byte.
- */
-struct StatusFlags
-{
-    // starting with bit 0 at the top...
-    /// Signifies that the TX FIFO is fully occupied.
-    const bool tx_full() const;
-    /// @brief Represents the pipe number that received the first available payload in the RX FIFO.
-    /// @remark This data shall be considered invalid if the @ref StatusFlags::rx_dr flag is `false`.
-    const uint8_t rx_pipe() const;
-    /// Represents an event where TX Data Failed to send.
-    const bool tx_df() const;
-    /// Represents an event where TX Data Sent successfully.
-    const bool tx_ds() const;
-    /// Represents an event where RX Data is Ready to `RF24::read()`.
-    const bool rx_dr() const;
-
-    /**
-     * @brief Convert this struct to a human understandable string.
-     *
-     * ```cpp
-     * char buf[69] = {0};
-     * StatusFlags flags;
-     * flags.toString(buf);
-     * ```
-     *
-     * Afterward, printing the string in `buf` should read something similar to:
-     *
-     * > rx_dr: false, tx_ds: false, tx_df: false, rx_pipe: 7, tx_full: false
-     *
-     * @param[out] buf The string buffer into which the StatusFlags description is stored.
-     * This buffer needs to be at least 69 bytes long.
-     * @returns The amount of bytes altered in the given `buf` parameter.
-     */
-    int toString(char* buf) const;
-
-    /// The default initializer constructor.
-    /// @see Details about `StatusFlags::toString()` show an example output of default values.
-    StatusFlags() : value(0x0E) {};
-
-    /**
-     * @brief Set the StatusFlags using constants defined by @ref rf24_irq_flags_e
-     *
-     * @param bits This value shall be a value of @ref rf24_irq_flags_e.
-     * Enabling multiple flags can be done with bitwise OR operator (`|`).
-     *
-     * ```cpp
-     * // only enable the "RX Data Ready" event
-     * StatusFlags flags(RF24_RX_DR);
-     *
-     * // only enable the "TX Data Sent" and "TX Data Fail" events
-     * flags = StatusFlags(RF24_TX_DF | RF24_TX_DS);
-     * ```
-     */
-    StatusFlags(uint8_t bits) : value(bits) {};
-
-private:
-    const uint8_t value;
-};
-
 /**
  * @}
  * @brief Driver class for nRF24L01(+) 2.4GHz Wireless Transceiver

examples/InterruptConfigure/InterruptConfigure.ino

@@ -300,32 +300,36 @@ void assessInterruptEvent() {
 
   Serial.println(F("\tIRQ pin is actively LOW"));  // show that this function was called
   delayMicroseconds(250);
-  StatusFlags flags(radio.clearStatusFlags());
+  uint8_t flags = radio.clearStatusFlags();
   // Resetting the tx_df flag is required for
   // continued TX operations when a transmission fails.
   // clearing the status flags resets the IRQ pin to its inactive state (HIGH)
-
+#ifdef printf_P
+  Serial.print(F("\t"));
+  radio.printStatus(flags);
+#else
   Serial.print(F("\tdata_sent: "));
-  Serial.print(flags.tx_ds());  // print "data sent" flag state
+  Serial.print((flags & RF24_TX_DS) > 0);  // print "data sent" flag state
   Serial.print(F(", data_fail: "));
-  Serial.print(flags.tx_df());  // print "data fail" flag state
+  Serial.print((flags & RF24_TX_DF) > 0);  // print "data fail" flag state
   Serial.print(F(", data_ready: "));
-  Serial.println(flags.rx_dr());  // print "data ready" flag state
+  Serial.println((flags & RF24_RX_DR) > 0);  // print "data ready" flag state
+#endif
 
-  if (flags.tx_df())   // if TX payload failed
-    radio.flush_tx();  // clear all payloads from the TX FIFO
+  if (flags & RF24_TX_DF)  // if TX payload failed
+    radio.flush_tx();      // clear all payloads from the TX FIFO
 
   // print if test passed or failed. Unintentional fails mean the RX node was not listening.
   // pl_iterator has already been incremented by now
   if (pl_iterator <= 1) {
     Serial.print(F("   'Data Ready' event test "));
-    Serial.println(flags.rx_dr() ? F("passed") : F("failed"));
+    Serial.println(flags & RF24_RX_DR ? F("passed") : F("failed"));
   } else if (pl_iterator == 2) {
     Serial.print(F("   'Data Sent' event test "));
-    Serial.println(flags.tx_ds() ? F("passed") : F("failed"));
+    Serial.println(flags & RF24_TX_DS ? F("passed") : F("failed"));
   } else if (pl_iterator == 4) {
     Serial.print(F("   'Data Fail' event test "));
-    Serial.println(flags.tx_df() ? F("passed") : F("failed"));
+    Serial.println(flags & RF24_TX_DF ? F("passed") : F("failed"));
   }
   got_interrupt = false;   // reset this flag to prevent calling this function from loop()
   wait_for_event = false;  // ready to continue with loop() operations

examples/StreamingData/StreamingData.ino

@@ -113,8 +113,8 @@ void loop() {
     while (i < SIZE) {
       makePayload(i);  // make the payload
       if (!radio.writeFast(&buffer, SIZE)) {
-        StatusFlags flags(radio.getStatusFlags());
-        if (flags.tx_df()) {
+        uint8_t flags = radio.getStatusFlags();
+        if (flags & RF24_TX_DF) {
           failures++;
           // now we need to reset the tx_df flag and the radio's CE pin
           radio.ce(LOW);

examples_linux/interruptConfigure.cpp

@@ -278,24 +278,24 @@ void ping_n_wait()
 
     cout << "\tIRQ pin is actively LOW" << endl; // show that this function was called
 
-    StatusFlags flags(radio.clearStatusFlags());
+    uint8_t flags = radio.clearStatusFlags();
     // Resetting the tx_df flag is required for
     // continued TX operations when a transmission fails.
     // clearing the status flags resets the IRQ pin to its inactive state (HIGH)
-    char buf[69];
-    flags.toString(buf);
-    cout << "\t" << buf << endl; // print StatusFlags description
 
-    if (flags.tx_df())    // if TX payload failed
-        radio.flush_tx(); // clear all payloads from the TX FIFO
+    cout << "\t";
+    radio.printStatus(flags); // print StatusFlags description
+
+    if (flags & RF24_TX_DF) // if TX payload failed
+        radio.flush_tx();   // clear all payloads from the TX FIFO
 
     // print if test passed or failed. Unintentional fails mean the RX node was not listening.
     if (pl_iterator == 0)
-        cout << "   'Data Ready' event test " << (flags.rx_dr() ? "passed" : "failed") << endl;
+        cout << "   'Data Ready' event test " << (flags & RF24_RX_DR ? "passed" : "failed") << endl;
     else if (pl_iterator == 1)
-        cout << "   'Data Sent' event test " << (flags.tx_ds() ? "passed" : "failed") << endl;
+        cout << "   'Data Sent' event test " << (flags & RF24_TX_DS ? "passed" : "failed") << endl;
     else if (pl_iterator == 3)
-        cout << "   'Data Fail' event test " << (flags.tx_df() ? "passed" : "failed") << endl;
+        cout << "   'Data Fail' event test " << (flags & RF24_TX_DF ? "passed" : "failed") << endl;
 
     got_interrupt = false;
 }

examples_linux/interrupt_configure.py

@@ -10,7 +10,6 @@
     RF24,
     RF24_PA_LOW,
     RF24_DRIVER,
-    StatusFlags,
     RF24_TX_DF,
     RF24_TX_DS,
     RF24_RX_DR,
@@ -106,17 +105,25 @@
 def interrupt_handler():
     """This function is called when IRQ pin is detected active LOW"""
     print("\tIRQ pin went active LOW.")
-    flags = StatusFlags(radio.clearStatusFlags())
+    flags = radio.clearStatusFlags()
     # Resetting the tx_df flag is required for
     # continued TX operations when a transmission fails.
     # clearing the status flags resets the IRQ pin to its inactive state (HIGH)
-    print(f"\t{flags}")
+    print("\t", end="")
+    radio.printStatus(flags)
     if pl_iterator[0] == 0:
-        print("    'data ready' event test", ("passed" if flags.rx_dr else "failed"))
+        print(
+            "    'data ready' event test",
+            ("passed" if flags & RF24_RX_DR else "failed"),
+        )
     elif pl_iterator[0] == 1:
-        print("    'data sent' event test", ("passed" if flags.tx_ds else "failed"))
+        print(
+            "    'data sent' event test", ("passed" if flags & RF24_TX_DS else "failed")
+        )
     elif pl_iterator[0] == 2:
-        print("    'data fail' event test", ("passed" if flags.tx_df else "failed"))
+        print(
+            "    'data fail' event test", ("passed" if flags & RF24_TX_DF else "failed")
+        )
 
 
 # setup IRQ GPIO pin

examples_linux/streamingData.cpp

@@ -208,8 +208,8 @@ void master()
     while (i < SIZE) {
         makePayload(i);
         if (!radio.writeFast(&buffer, SIZE)) {
-            StatusFlags flags(radio.getStatusFlags());
-            if (flags.tx_df()) {
+            uint8_t flags = radio.getStatusFlags();
+            if (flags & RF24_TX_DF) {
                 failures++;
                 // failed to transmit a previous payload.
                 // Now we need to reset the tx_df flag and the CE pin

examples_linux/streaming_data.py

@@ -7,7 +7,7 @@
 """
 
 import time
-from RF24 import RF24, RF24_PA_LOW, RF24_DRIVER, StatusFlags, RF24_TX_DF
+from RF24 import RF24, RF24_PA_LOW, RF24_DRIVER, RF24_TX_DF
 
 print(__file__)  # print example name
 
@@ -101,8 +101,8 @@ def master(count: int = 1):
             buffer = make_buffer(buf_iter)  # make a payload
 
             if not radio.writeFast(buffer):  # transmission failed
-                flags = StatusFlags(radio.getStatusFlags())
-                if flags.tx_df:
+                flags = radio.getStatusFlags()
+                if flags & RF24_TX_DF:
                     failures += 1  # increment manual retry count
                     # now we need to reset the tx_df flag and the radio's CE pin
                     radio.ce(False)

examples_pico/interruptConfigure.cpp

@@ -304,28 +304,27 @@ void assessInterruptEvent()
 {
     // print IRQ status and all masking flags' states
     printf("\tIRQ pin is actively LOW\n"); // show that this function was called
-    StatusFlags flags(radio.clearStatusFlags());
+    uint8_t flags = radio.clearStatusFlags();
     // Resetting the tx_df flag is required for
     // continued TX operations when a transmission fails.
     // clearing the status flags resets the IRQ pin to its inactive state (HIGH)
-    char buf[69];
-    flags.toString(buf);
 
-    printf("\t%s\n", buf); // print status flags info
+    printf("\t");
+    radio.printStatus(flags); // print status flags info
 
-    if (flags.tx_df())    // if TX payload failed
-        radio.flush_tx(); // clear all payloads from the TX FIFO
+    if (flags & RF24_TX_DF) // if TX payload failed
+        radio.flush_tx();   // clear all payloads from the TX FIFO
 
     // print if test passed or failed. Unintentional fails mean the RX node was not listening.
     // pl_iterator has already been incremented by now
     if (pl_iterator <= 1) {
-        printf("   'Data Ready' event test %s\n", flags.rx_dr() ? "passed" : "failed");
+        printf("   'Data Ready' event test %s\n", flags & RF24_RX_DR ? "passed" : "failed");
     }
     else if (pl_iterator == 2) {
-        printf("   'Data Sent' event test %s\n", flags.tx_ds() ? "passed" : "failed");
+        printf("   'Data Sent' event test %s\n", flags & RF24_TX_DS ? "passed" : "failed");
     }
     else if (pl_iterator == 4) {
-        printf("   'Data Fail' event test %s\n", flags.tx_df() ? "passed" : "failed");
+        printf("   'Data Fail' event test %s\n", flags & RF24_TX_DF ? "passed" : "failed");
     }
     got_interrupt = false;  // reset this flag to prevent calling this function from loop()
     wait_for_event = false; // ready to continue with loop() operations

examples_pico/streamingData.cpp

@@ -110,8 +110,8 @@ void loop()
         while (i < SIZE) {
             makePayload(i); // make the payload
             if (!radio.writeFast(&buffer, SIZE)) {
-                StatusFlags flags(radio.getStatusFlags());
-                if (flags.tx_df()) {
+                uint8_t flags = radio.getStatusFlags();
+                if (flags & RF24_TX_DF) {
                     failures++;
                     // now we need to reset the tx_df flag and the radio's CE pin.
                     radio.ce(LOW);

pyRF24/pyRF24.cpp

@@ -113,17 +113,6 @@ bp::tuple whatHappened_wrap(RF24& ref)
     return bp::make_tuple(tx_ok, tx_fail, tx_ready);
 }
 
-std::string reprStatusFlags(StatusFlags& self)
-{
-    char* buf = new char[69];
-    self.toString(buf);
-    std::string result = "<StatusFlags ";
-    result += buf;
-    result += ">";
-    delete[] buf;
-    return result;
-}
-
 bp::tuple available_wrap(RF24& ref)
 {
     bool result;
@@ -306,15 +295,6 @@ BOOST_PYTHON_MODULE(RF24)
         .value("RF24_IRQ_NONE", RF24_IRQ_NONE)
         .export_values();
 
-    bp::class_<StatusFlags>("StatusFlags", bp::init<>())
-        .def(bp::init<uint8_t>((bp::arg("bits"))))
-        .add_property("rx_dr", &StatusFlags::rx_dr)
-        .add_property("tx_ds", &StatusFlags::tx_ds)
-        .add_property("tx_df", &StatusFlags::tx_df)
-        .add_property("tx_full", &StatusFlags::tx_full)
-        .add_property("rx_pipe", &StatusFlags::rx_pipe)
-        .def("__repr__", &reprStatusFlags);
-
     // ******************** RF24 class  **************************
     bp::class_<RF24>("RF24", bp::init<uint16_t, uint16_t>((bp::arg("_cepin"), bp::arg("_cspin"))))
 #if defined(RF24_LINUX) && !defined(MRAA)