[Request] Move REGISTER_MASK to print_byte_register() & replace spiTrans() with write_register()

[2bndy5]

I'm trying to reduce the code size of getDynamicPayloadSize() by using the read_register() function, but the use of REGISTER_MASK is the only thing in my way. In fact it would only be useful in the print_byte_register() as that is the only time that a macro defined in nRF24L01.h is not passed to read_register(). So, this line would be changed to:

        printf_P(PSTR(" 0x%02x"), read_register(reg++ & REGISTER_MASK));

Same thing applies to write_register(); every call to write_register() passes a macro defined from nRF24L01.h, so REGISTER_MASK is completely useless.

I'd also like to get rid of RF24::spiTrans() because we can get the same job done with write_register() by adding a bool is_cmd_only=false parameter to the write_register() declaration. This would affect:

1. flush_tx()
2. flush_rx()
3. reUseTX()
4. get_status()

I don't really see the usefulness of returning the status byte for the first 2 affected functions (see also the additional context below). Its completely useless in the python wrapper because the macros in nRF24L01.h aren't exposed to python. In fact, reUseTX() ignores the returned status byte already, but I will modify flush_tx(), flush_rx(), and get_status() to continue returning the status byte for backward compatibility.

Of course write_register() would need some tweaking:

void RF24::write_register(uint8_t reg, uint8_t value, bool is_cmd_only)
{
    if (is_cmd_only) {
        IF_SERIAL_DEBUG(printf_P(PSTR("write_register(%02x)\r\n"), reg));
        beginTransaction();
        status = _SPI.transfer(W_REGISTER | reg);
        endTransaction();
    }
    else {
        IF_SERIAL_DEBUG(printf_P(PSTR("write_register(%02x,%02x)\r\n"), reg, value));
        #if defined(RF24_LINUX)
        beginTransaction();
        uint8_t * prx = spi_rxbuff;
        uint8_t * ptx = spi_txbuff;
        *ptx++ = (W_REGISTER | reg);
        *ptx = value;

        _SPI.transfernb((char *)spi_txbuff, (char *)spi_rxbuff, 2);
        status = *prx++; // status is 1st byte of receive buffer
        endTransaction();
        #else // !defined(RF24_LINUX)

        beginTransaction();
        status = _SPI.transfer(W_REGISTER | reg);
        _SPI.transfer(value);
        endTransaction();
        #endif // !defined(RF24_LINUX)
    }
}

Additional context

• Remember [Request] writeBlocking(), writeFast(), & txStandBy() functions could be slightly faster #678 proposes that the status byte be saved in every SPI transaction, meaning any RF24::function can access the status byte after any SPI transaction.
• Notice from the datasheet that W_REGISTER | reg will not affect the SPI cmds as the bit that is asserted by W_REGISTER is already asserted in all of the SPI cmds. Only exception is the ACTIVATE cmd, but that is only used by the toggle_features() function which already directly accesses the SPI bus.
• Before raising this issue, I've already reduced writeAckPayload() to use

  write_payload(current, len, W_ACK_PAYLOAD | (pipe & 0x07))`.

  There was nothing special about writeAckPayload() that made it differ from write_payload().
• I've also taken liberty with not truncating dynamic payloads according to the static payloads setting. Both read_payload() & write_payload() now use:

  uint8_t blank_len = 0;
  if (!dynamic_payloads_enabled) {
      data_len = rf24_min(data_len, payload_size);
      blank_len = payload_size - data_len;
  }
  else {
      data_len = rf24_min(data_len, 32);
  }

  Although care should be taken to not read/write any payload with a length of 0 (per datasheet) before even calling read_payload() & write_payload()

[TMRh20]

Pretty detailed but seems to make sense & if it all works, it works. 👍

[2bndy5]

Pretty detailed

Sorry it started out simple, but I kept finding small changes that needed a thread for changelog reasons