modify streamingData and IRQconfig examples

Author: 2bndy5

examples/InterruptConfigure/InterruptConfigure.ino

@@ -49,6 +49,9 @@ uint8_t pl_iterator = 0;
 char tx_payloads[][tx_pl_size + 1] = { "Ping ", "Pong ", "Radio", "1FAIL" };
 char ack_payloads[][ack_pl_size + 1] = { "Yak ", "Back", " ACK" };
 
+// A variable to interpret and manipulate the radio's IRQ pin.
+StatusFlags flags;
+
 void interruptHandler();  // prototype to handle IRQ events
 void printRxFifo();       // prototype to print RX FIFO with 1 buffer
 
@@ -150,21 +153,31 @@ void loop() {
       // Test the "data ready" event with the IRQ pin
 
       Serial.println(F("\nConfiguring IRQ pin to ignore the 'data sent' event"));
-      radio.maskIRQ(true, false, false);  // args = "data_sent", "data_fail", "data_ready"
+      flags.rx_dr = true;
+      flags.tx_ds = false;
+      flags.tx_df = true;
+      radio.setStatusFlags(flags);
       Serial.println(F("   Pinging RX node for 'data ready' event..."));
 
     } else if (pl_iterator == 1) {
       // Test the "data sent" event with the IRQ pin
 
       Serial.println(F("\nConfiguring IRQ pin to ignore the 'data ready' event"));
-      radio.maskIRQ(false, false, true);  // args = "data_sent", "data_fail", "data_ready"
+      flags.rx_dr = false;
+      flags.tx_ds = true;
+      flags.tx_df = true;
+      radio.setStatusFlags(flags);
       Serial.println(F("   Pinging RX node for 'data sent' event..."));
 
     } else if (pl_iterator == 2) {
       // Use this iteration to fill the RX node's FIFO which sets us up for the next test.
 
       // write() uses virtual interrupt flags that work despite the masking of the IRQ pin
-      radio.maskIRQ(1, 1, 1);  // disable IRQ masking for this step
+      // disable IRQ pin for this step
+      flags.rx_dr = false;
+      flags.tx_ds = false;
+      flags.tx_df = false;
+      radio.setStatusFlags(flags);
 
       Serial.println(F("\nSending 1 payload to fill RX node's FIFO. IRQ pin is neglected."));
       // write() will call flush_tx() on 'data fail' events
@@ -183,7 +196,10 @@ void loop() {
       // test the "data fail" event with the IRQ pin
 
       Serial.println(F("\nConfiguring IRQ pin to reflect all events"));
-      radio.maskIRQ(0, 0, 0);  // args = "data_sent", "data_fail", "data_ready"
+      flags.rx_dr = true;
+      flags.tx_ds = true;
+      flags.tx_df = true;
+      radio.setStatusFlags(flags);
       Serial.println(F("   Pinging inactive RX node for 'data fail' event..."));
     }
 
@@ -266,7 +282,11 @@ void loop() {
 
       role = false;
 
-      radio.maskIRQ(0, 0, 0);  // the IRQ pin should only trigger on "data ready" event
+      // let IRQ pin only trigger on "data_ready" event in RX mode
+      flags.rx_dr = true;
+      flags.tx_ds = false;
+      flags.tx_df = false;
+      radio.setStatusFlags(flags);
 
       // Fill the TX FIFO with 3 ACK payloads for the first 3 received
       // transmissions on pipe 1
@@ -298,33 +318,29 @@ void assessInterruptEvent() {
 
   Serial.println(F("\tIRQ pin is actively LOW"));  // show that this function was called
   delayMicroseconds(250);
-  bool tx_ds, tx_df, rx_dr;                 // declare variables for IRQ masks
-  radio.whatHappened(tx_ds, tx_df, rx_dr);  // get values for IRQ masks
-  // whatHappened() clears the IRQ masks also. This is required for
+  StatusFlags status = radio.clearStatusFlags();
+  // Resetting the tx_df flag is required for
   // continued TX operations when a transmission fails.
-  // clearing the IRQ masks resets the IRQ pin to its inactive state (HIGH)
+  // clearing the status flags resets the IRQ pin to its inactive state (HIGH)
 
-  Serial.print(F("\tdata_sent: "));
-  Serial.print(tx_ds);  // print "data sent" mask state
-  Serial.print(F(", data_fail: "));
-  Serial.print(tx_df);  // print "data fail" mask state
-  Serial.print(F(", data_ready: "));
-  Serial.println(rx_dr);  // print "data ready" mask state
+  char buf[69];
+  status.toString(buf);
+  Serial.println(buf);  // print "status flags info
 
-  if (tx_df)           // if TX payload failed
+  if (status.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(rx_dr ? F("passed") : F("failed"));
+    Serial.println(status.rx_dr ? F("passed") : F("failed"));
   } else if (pl_iterator == 2) {
     Serial.print(F("   'Data Sent' event test "));
-    Serial.println(tx_ds ? F("passed") : F("failed"));
+    Serial.println(status.tx_ds ? F("passed") : F("failed"));
   } else if (pl_iterator == 4) {
     Serial.print(F("   'Data Fail' event test "));
-    Serial.println(tx_df ? F("passed") : F("failed"));
+    Serial.println(status.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

@@ -106,15 +106,23 @@ void loop() {
   if (role) {
     // This device is a TX node
 
+    StatusFlags flags;
     radio.flush_tx();
     uint8_t i = 0;
     uint8_t failures = 0;
     unsigned long start_timer = micros();  // start the timer
     while (i < SIZE) {
       makePayload(i);  // make the payload
       if (!radio.writeFast(&buffer, SIZE)) {
-        failures++;
-        radio.reUseTX();
+        radio.getStatusFlags(flags);
+        if (flags.tx_df) {
+          failures++;
+          // now we need to reset the tx_df flag and the radio's CE pin
+          radio.ce(LOW);
+          radio.clearStatusFlags(flags);
+          radio.ce(HIGH);
+        }
+        // else the TX FIFO is full; just continue loop.
       } else {
         i++;
       }

examples_linux/interruptConfigure.cpp

@@ -63,6 +63,9 @@ uint8_t pl_iterator = 0;
 char tx_payloads[4][tx_pl_size + 1] = {"Ping ", "Pong ", "Radio", "1FAIL"};
 char ack_payloads[3][ack_pl_size + 1] = {"Yak ", "Back", " ACK"};
 
+// A variable used to interpret and manipulate the IRQ pin.
+StatusFlags flags;
+
 void interruptHandler();         // prototype to handle the interrupt request (IRQ) pin
 void setRole();                  // prototype to set the node's role
 void master();                   // prototype of the TX node's behavior
@@ -158,7 +161,7 @@ void setRole()
                 cout << input[0] << " is an invalid input. Please try again." << endl;
         }
         input = ""; // stay in the while loop
-    }               // while
+    } // while
 } // setRole
 
 /**
@@ -174,22 +177,32 @@ void master()
 
     // Test the "data ready" event with the IRQ pin
     cout << "\nConfiguring IRQ pin to ignore the 'data sent' event\n";
-    radio.maskIRQ(true, false, false); // args = "data_sent", "data_fail", "data_ready"
+    flags.rx_dr = true;
+    flags.tx_ds = false;
+    flags.tx_df = true;
+    radio.setStatusFlags(flags);
     cout << "   Pinging RX node for 'data ready' event..." << endl;
     ping_n_wait(); // transmit a payload and detect the IRQ pin
     pl_iterator++; // increment iterator for next test
 
     // Test the "data sent" event with the IRQ pin
     cout << "\nConfiguring IRQ pin to ignore the 'data ready' event\n";
-    radio.maskIRQ(false, false, true); // args = "data_sent", "data_fail", "data_ready"
+    flags.rx_dr = false;
+    flags.tx_ds = true;
+    flags.tx_df = true;
+    radio.setStatusFlags(flags);
     cout << "   Pinging RX node for 'data sent' event..." << endl;
     radio.flush_tx(); // flush payloads from any failed prior test
     ping_n_wait();    // transmit a payload and detect the IRQ pin
     pl_iterator++;    // increment iterator for next test
 
     // Use this iteration to fill the RX node's FIFO which sets us up for the next test.
-    // write() uses virtual interrupt flags that work despite the masking of the IRQ pin
-    radio.maskIRQ(1, 1, 1); // disable IRQ masking for this step
+    // write() uses virtual interrupt flags that work despite the masking of the IRQ pin.
+    // disable IRQ pin for this step
+    flags.rx_dr = false;
+    flags.tx_ds = false;
+    flags.tx_df = false;
+    radio.setStatusFlags(flags);
 
     cout << "\nSending 1 payload to fill RX node's FIFO. IRQ pin is neglected.\n";
     // write() will call flush_tx() on 'data fail' events
@@ -203,7 +216,10 @@ void master()
 
     // test the "data fail" event with the IRQ pin
     cout << "\nConfiguring IRQ pin to reflect all events\n";
-    radio.maskIRQ(0, 0, 0); // args = "data_sent", "data_fail", "data_ready"
+    flags.rx_dr = true;
+    flags.tx_ds = true;
+    flags.tx_df = true;
+    radio.setStatusFlags(flags);
     cout << "   Pinging inactive RX node for 'data fail' event..." << endl;
     ping_n_wait(); // transmit a payload and detect the IRQ pin
 
@@ -223,7 +239,10 @@ void slave()
 {
 
     // let IRQ pin only trigger on "data_ready" event in RX mode
-    radio.maskIRQ(1, 1, 0); // args = "data_sent", "data_fail", "data_ready"
+    flags.rx_dr = true;
+    flags.tx_ds = false;
+    flags.tx_df = false;
+    radio.setStatusFlags(flags);
 
     // Fill the TX FIFO with 3 ACK payloads for the first 3 received
     // transmissions on pipe 0.
@@ -277,26 +296,24 @@ void ping_n_wait()
 
     cout << "\tIRQ pin is actively LOW" << endl; // show that this function was called
 
-    bool tx_ds, tx_df, rx_dr;                // declare variables for IRQ masks
-    radio.whatHappened(tx_ds, tx_df, rx_dr); // get values for IRQ masks
-    // whatHappened() clears the IRQ masks also. This is required for
+    StatusFlags status = radio.clearStatusFlags();
+    // Resetting the tx_df flag is required for
     // continued TX operations when a transmission fails.
-    // clearing the IRQ masks resets the IRQ pin to its inactive state (HIGH)
-
-    cout << "\tdata_sent: " << tx_ds;          // print "data sent" mask state
-    cout << ", data_fail: " << tx_df;          // print "data fail" mask state
-    cout << ", data_ready: " << rx_dr << endl; // print "data ready" mask state
+    // clearing the status flags resets the IRQ pin to its inactive state (HIGH)
+    char buf[69];
+    status.toString(buf);
+    cout << "\t" << buf << endl; // print StatusFlags description
 
-    if (tx_df)            // if TX payload failed
+    if (status.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 " << (rx_dr ? "passed" : "failed") << endl;
+        cout << "   'Data Ready' event test " << (status.rx_dr ? "passed" : "failed") << endl;
     else if (pl_iterator == 1)
-        cout << "   'Data Sent' event test " << (tx_ds ? "passed" : "failed") << endl;
+        cout << "   'Data Sent' event test " << (status.tx_ds ? "passed" : "failed") << endl;
     else if (pl_iterator == 3)
-        cout << "   'Data Fail' event test " << (tx_df ? "passed" : "failed") << endl;
+        cout << "   'Data Fail' event test " << (status.tx_df ? "passed" : "failed") << endl;
 
     got_interrupt = false;
 }

examples_linux/interrupt_configure.py

@@ -6,7 +6,7 @@
 """
 
 import time
-from RF24 import RF24, RF24_PA_LOW, RF24_DRIVER
+from RF24 import RF24, RF24_PA_LOW, RF24_DRIVER, StatusFlags
 
 try:
     import gpiod
@@ -93,18 +93,24 @@
 tx_payloads = (b"Ping ", b"Pong ", b"Radio", b"1FAIL")
 ack_payloads = (b"Yak ", b"Back", b" ACK")
 
+# a variable used interpret and manipulate the IRQ pin
+flags = StatusFlags()
+
 
 def interrupt_handler():
     """This function is called when IRQ pin is detected active LOW"""
     print("\tIRQ pin went active LOW.")
-    tx_ds, tx_df, rx_dr = radio.whatHappened()  # update IRQ status flags
-    print(f"\ttx_ds: {tx_ds}, tx_df: {tx_df}, rx_dr: {rx_dr}")
+    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}")
     if pl_iterator[0] == 0:
-        print("    'data ready' event test", ("passed" if rx_dr else "failed"))
+        print("    'data ready' event test", ("passed" if flags.rx_dr else "failed"))
     elif pl_iterator[0] == 1:
-        print("    'data sent' event test", ("passed" if tx_ds else "failed"))
+        print("    'data sent' event test", ("passed" if flags.tx_ds else "failed"))
     elif pl_iterator[0] == 2:
-        print("    'data fail' event test", ("passed" if tx_df else "failed"))
+        print("    'data fail' event test", ("passed" if flags.tx_df else "failed"))
 
 
 # setup IRQ GPIO pin
@@ -143,7 +149,10 @@ def master():
 
     # on data ready test
     print("\nConfiguring IRQ pin to only ignore 'on data sent' event")
-    radio.maskIRQ(True, False, False)  # args = tx_ds, tx_df, rx_dr
+    flags.tx_df = True
+    flags.tx_ds = False
+    flags.rx_dr = True
+    radio.setStatusFlags(flags)
     print("    Pinging slave node for an ACK payload...")
     pl_iterator[0] = 0
     radio.startFastWrite(tx_payloads[0], False)  # False means expecting an ACK
@@ -152,7 +161,10 @@ def master():
 
     # on "data sent" test
     print("\nConfiguring IRQ pin to only ignore 'on data ready' event")
-    radio.maskIRQ(False, False, True)  # args = tx_ds, tx_df, rx_dr
+    flags.tx_df = True
+    flags.tx_ds = True
+    flags.rx_dr = False
+    radio.setStatusFlags(flags)
     print("    Pinging slave node again...")
     pl_iterator[0] = 1
     radio.startFastWrite(tx_payloads[1], False)  # False means expecting an ACK
@@ -162,15 +174,21 @@ def master():
     # trigger slave node to exit by filling the slave node's RX FIFO
     print("\nSending one extra payload to fill RX FIFO on slave node.")
     print("Disabling IRQ pin for all events.")
-    radio.maskIRQ(True, True, True)  # args = tx_ds, tx_df, rx_dr
+    flags.tx_df = False
+    flags.tx_ds = False
+    flags.rx_dr = False
+    radio.setStatusFlags(flags)
     if radio.write(tx_payloads[2]):
         print("Slave node should not be listening anymore.")
     else:
         print("Slave node was unresponsive.")
 
     # on "data fail" test
     print("\nConfiguring IRQ pin to go active for all events.")
-    radio.maskIRQ(False, False, False)  # args = tx_ds, tx_df, rx_dr
+    flags.tx_df = True
+    flags.tx_ds = True
+    flags.rx_dr = True
+    radio.setStatusFlags(flags)
     print("    Sending a ping to inactive slave node...")
     radio.flush_tx()  # just in case any previous tests failed
     pl_iterator[0] = 2
@@ -189,7 +207,10 @@ def slave(timeout=6):  # will listen for 6 seconds before timing out
     # the "data sent" or "data fail" events will trigger when we
     # receive with ACK payloads enabled (& loaded in TX FIFO)
     print("\nDisabling IRQ pin for all events.")
-    radio.maskIRQ(True, True, True)  # args = tx_ds, tx_df, rx_dr
+    flags.tx_df = False
+    flags.tx_ds = False
+    flags.rx_dr = False
+    radio.setStatusFlags(flags)
     # setup radio to receive pings, fill TX FIFO with ACK payloads
     radio.writeAckPayload(1, ack_payloads[0])
     radio.writeAckPayload(1, ack_payloads[1])