replace migrate internal API and expose printStatus()

Author: 2bndy5

RF24.cpp

@@ -37,21 +37,21 @@ const uint8_t StatusFlags::rx_pipe() const
 
 const bool StatusFlags::tx_df() const
 {
-    return value & _BV(MAX_RT);
+    return value & RF24_TX_DF;
 }
 
 /****************************************************************************/
 
 const bool StatusFlags::tx_ds() const
 {
-    return value & _BV(TX_DS);
+    return value & RF24_TX_DS;
 }
 
 /****************************************************************************/
 
 const bool StatusFlags::rx_dr() const
 {
-    return value & _BV(RX_DR);
+    return value & RF24_RX_DR;
 }
 
 /****************************************************************************/
@@ -527,21 +527,13 @@ uint8_t RF24::flush_tx(void)
     return status;
 }
 
-/****************************************************************************/
-
-uint8_t RF24::get_status(void)
-{
-    read_register(RF24_NOP, (uint8_t*)nullptr, 0);
-    return status;
-}
-
 /****************************************************************************/
 #if !defined(MINIMAL)
 
-void RF24::print_status(uint8_t _status)
+void RF24::printStatus(uint8_t flags)
 {
-    printf_P(PSTR("STATUS\t\t= 0x%02x RX_DR=%x TX_DS=%x MAX_RT=%x RX_P_NO=%x TX_FULL=%x\r\n"), _status, (_status & _BV(RX_DR)) ? 1 : 0,
-             (_status & _BV(TX_DS)) ? 1 : 0, (_status & _BV(MAX_RT)) ? 1 : 0, ((_status >> RX_P_NO) & 0x07), (_status & _BV(TX_FULL)) ? 1 : 0);
+    printf_P(PSTR("STATUS\t\t= 0x%02x RX_DR=%x TX_DS=%x TX_DF=%x RX_PIPE=%x TX_FULL=%x\r\n"), flags, (flags & RF24_RX_DR) ? 1 : 0,
+             (flags & RF24_TX_DS) ? 1 : 0, (flags & RF24_TX_DF) ? 1 : 0, ((flags >> RX_P_NO) & 0x07), (flags & _BV(TX_FULL)) ? 1 : 0);
 }
 
 /****************************************************************************/
@@ -755,7 +747,7 @@ void RF24::printDetails(void)
     printf("================ NRF Configuration ================\n");
     #endif // defined(RF24_LINUX)
 
-    print_status(get_status());
+    printStatus(update());
 
     print_address_register(PSTR("RX_ADDR_P0-1"), RX_ADDR_P0, 2);
     print_byte_register(PSTR("RX_ADDR_P2-5"), RX_ADDR_P2, 4);
@@ -1151,7 +1143,7 @@ bool RF24::_init_radio()
 
     // Reset current status
     // Notice reset and flush is the last thing we do
-    write_register(NRF_STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT));
+    write_register(NRF_STATUS, RF24_IRQ_ALL);
 
     // Flush buffers
     flush_rx();
@@ -1196,7 +1188,7 @@ void RF24::startListening(void)
 #endif
     config_reg |= _BV(PRIM_RX);
     write_register(NRF_CONFIG, config_reg);
-    write_register(NRF_STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT));
+    write_register(NRF_STATUS, RF24_IRQ_ALL);
     ce(HIGH);
 
     // Restore the pipe0 address, if exists
@@ -1292,7 +1284,7 @@ bool RF24::write(const void* buf, uint8_t len, const bool multicast)
     uint32_t timer = millis();
 #endif // defined(FAILURE_HANDLING) || defined(RF24_LINUX)
 
-    while (!(get_status() & (_BV(TX_DS) | _BV(MAX_RT)))) {
+    while (!(update() & (RF24_TX_DS | RF24_TX_DF))) {
 #if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
         if (millis() - timer > 95) {
             errNotify();
@@ -1307,10 +1299,10 @@ bool RF24::write(const void* buf, uint8_t len, const bool multicast)
 
     ce(LOW);
 
-    write_register(NRF_STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT));
+    write_register(NRF_STATUS, RF24_IRQ_ALL);
 
     //Max retries exceeded
-    if (status & _BV(MAX_RT)) {
+    if (status & RF24_TX_DF) {
         flush_tx(); // Only going to be 1 packet in the FIFO at a time using this method, so just flush
         return 0;
     }
@@ -1335,10 +1327,10 @@ bool RF24::writeBlocking(const void* buf, uint8_t len, uint32_t timeout)
 
     uint32_t timer = millis(); // Get the time that the payload transmission started
 
-    while ((get_status() & (_BV(TX_FULL)))) { // Blocking only if FIFO is full. This will loop and block until TX is successful or timeout
+    while ((update() & (_BV(TX_FULL)))) { // Blocking only if FIFO is full. This will loop and block until TX is successful or timeout
 
-        if (status & _BV(MAX_RT)) { // If MAX Retries have been reached
-            reUseTX();              // Set re-transmit and clear the MAX_RT interrupt flag
+        if (status & RF24_TX_DF) { // If MAX Retries have been reached
+            reUseTX();             // Set re-transmit and clear the MAX_RT interrupt flag
             if (millis() - timer > timeout) {
                 return 0; // If this payload has exceeded the user-defined timeout, exit and return 0
             }
@@ -1364,7 +1356,7 @@ bool RF24::writeBlocking(const void* buf, uint8_t len, uint32_t timeout)
 void RF24::reUseTX()
 {
     ce(LOW);
-    write_register(NRF_STATUS, _BV(MAX_RT)); //Clear max retry flag
+    write_register(NRF_STATUS, RF24_TX_DF); //Clear max retry flag
     read_register(REUSE_TX_PL, (uint8_t*)nullptr, 0);
     IF_RF24_DEBUG(printf_P("[Reusing payload in TX FIFO]"););
     ce(HIGH); //Re-Transfer packet
@@ -1384,8 +1376,8 @@ bool RF24::writeFast(const void* buf, uint8_t len, const bool multicast)
 #endif
 
     //Blocking only if FIFO is full. This will loop and block until TX is successful or fail
-    while ((get_status() & (_BV(TX_FULL)))) {
-        if (status & _BV(MAX_RT)) {
+    while ((update() & (_BV(TX_FULL)))) {
+        if (status & RF24_TX_DF) {
             return 0; //Return 0. The previous payload has not been retransmitted
             // From the user perspective, if you get a 0, call txStandBy()
         }
@@ -1477,8 +1469,8 @@ bool RF24::txStandBy()
     uint32_t timeout = millis();
 #endif
     while (!(read_register(FIFO_STATUS) & _BV(TX_EMPTY))) {
-        if (status & _BV(MAX_RT)) {
-            write_register(NRF_STATUS, _BV(MAX_RT));
+        if (status & RF24_TX_DF) {
+            write_register(NRF_STATUS, RF24_TX_DF);
             ce(LOW);
             flush_tx(); //Non blocking, flush the data
             return 0;
@@ -1509,8 +1501,8 @@ bool RF24::txStandBy(uint32_t timeout, bool startTx)
     uint32_t start = millis();
 
     while (!(read_register(FIFO_STATUS) & _BV(TX_EMPTY))) {
-        if (status & _BV(MAX_RT)) {
-            write_register(NRF_STATUS, _BV(MAX_RT));
+        if (status & RF24_TX_DF) {
+            write_register(NRF_STATUS, RF24_TX_DF);
             ce(LOW); // Set re-transmit
             ce(HIGH);
             if (millis() - start >= timeout) {
@@ -1570,7 +1562,7 @@ bool RF24::available(void)
 bool RF24::available(uint8_t* pipe_num)
 {
     if (available()) { // if RX FIFO is not empty
-        *pipe_num = (get_status() >> RX_P_NO) & 0x07;
+        *pipe_num = (update() >> RX_P_NO) & 0x07;
         return 1;
     }
     return 0;
@@ -1585,7 +1577,7 @@ void RF24::read(void* buf, uint8_t len)
     read_payload(buf, len);
 
     //Clear the only applicable interrupt flags
-    write_register(NRF_STATUS, _BV(RX_DR));
+    write_register(NRF_STATUS, RF24_RX_DR);
 }
 
 /****************************************************************************/
@@ -1594,12 +1586,12 @@ void RF24::whatHappened(bool& tx_ok, bool& tx_fail, bool& rx_ready)
 {
     // Read the status & reset the status in one easy call
     // Or is that such a good idea?
-    write_register(NRF_STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT));
+    write_register(NRF_STATUS, RF24_IRQ_ALL);
 
     // Report to the user what happened
-    tx_ok = status & _BV(TX_DS);
-    tx_fail = status & _BV(MAX_RT);
-    rx_ready = status & _BV(RX_DR);
+    tx_ok = status & RF24_TX_DS;
+    tx_fail = status & RF24_TX_DF;
+    rx_ready = status & RF24_RX_DR;
 }
 
 /****************************************************************************/

RF24.h

@@ -713,6 +713,16 @@ class RF24
      */
     void printDetails(void);
 
+    /**
+     * Decode and print the given STATUS byte to stdout.
+     *
+     * @param flags The STATUS byte to print.
+     * This value is fetched with update() or getStatusFlags().
+     *
+     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+     */
+    void printStatus(uint8_t flags);
+
     /**
      * Print a giant block of debugging information to stdout. This function
      * differs from printDetails() because it makes the information more
@@ -2136,24 +2146,8 @@ class RF24
      */
     void read_payload(void* buf, uint8_t len);
 
-    /**
-     * Retrieve the current status of the chip
-     *
-     * @return Current value of status register
-     */
-    uint8_t get_status(void);
-
 #if !defined(MINIMAL)
 
-    /**
-     * Decode and print the given status to stdout
-     *
-     * @param status Status value to print
-     *
-     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
-     */
-    void print_status(uint8_t status);
-
     /**
      * Decode and print the given 'observe_tx' value to stdout
      *

pyRF24/pyRF24.cpp

@@ -303,6 +303,7 @@ BOOST_PYTHON_MODULE(RF24)
         .value("RF24_TX_DS", RF24_TX_DS)
         .value("RF24_RX_DR", RF24_RX_DR)
         .value("RF24_IRQ_ALL", RF24_IRQ_ALL)
+        .value("RF24_IRQ_NONE", RF24_IRQ_NONE)
         .export_values();
 
     bp::class_<StatusFlags>("StatusFlags", bp::init<>())
@@ -350,6 +351,7 @@ BOOST_PYTHON_MODULE(RF24)
         .def("powerDown", &RF24::powerDown)
         .def("powerUp", &RF24::powerUp)
         .def("printDetails", &RF24::printDetails)
+        .def("printStatus", &RF24::printStatus)
         .def("printPrettyDetails", &RF24::printPrettyDetails)
         .def("sprintfPrettyDetails", &sprintfPrettyDetails_wrap)
         .def("reUseTX", &RF24::reUseTX)