NRF24Stream.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/CoreAudio/BaseStream.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "RF24.h"  // https://github.com/nRF24/RF24
 
namespace audio_tools {
 
struct NRF24Config : public AudioInfo {
  NRF24Config() {
    sample_rate = 0;
    channels = 0;
    bits_per_sample = 0;
  }
  int pin_ce = 9;
  int pin_csn = 10;
  uint8_t channel = 124;
  rf24_datarate_e data_rate = RF24_2MBPS;
  rf24_pa_dbm_e pa_level = RF24_PA_MAX;
  uint8_t payload_size = 32;
  uint64_t address = 0xF0F0F0F0E1LL;
  RxTxMode mode = TX_MODE;
  bool auto_ack = false;
  rf24_crclength_e crc_length = RF24_CRC_DISABLED;
  bool use_write_fast = true;
  int max_begin_retry = 10;
};
 
class NRF24Stream : public AudioStream {
 public:
  NRF24Stream() = default;
 
  NRF24Stream(RF24 &radio) : p_radio(&radio) {}
 
  NRF24Stream(BaseBuffer<uint8_t> &buffer) : p_rx_buffer(&buffer) {}
 
  NRF24Stream(RF24 &radio, BaseBuffer<uint8_t> &buffer)
      : p_radio(&radio), p_rx_buffer(&buffer) {}
 
  void setBuffer(BaseBuffer<uint8_t> &buffer) { p_rx_buffer = &buffer; }
 
  NRF24Config defaultConfig(RxTxMode mode = TX_MODE) {
    NRF24Config rc;
    rc.mode = mode;
    return rc;
  }
 
  void setAudioInfo(AudioInfo info) override {
    cfg.sample_rate = info.sample_rate;
    cfg.channels = info.channels;
    cfg.bits_per_sample = info.bits_per_sample;
    AudioStream::setAudioInfo(info);
  }
 
  bool begin(NRF24Config config) {
    cfg = config;
    AudioStream::setAudioInfo(config);
    return begin();
  }
 
  bool begin() override {
    TRACEI();
 
    if (p_radio == nullptr) {
      p_own_radio = new RF24(cfg.pin_ce, cfg.pin_csn);
      p_radio = p_own_radio;
    }
 
    bool rc = false;
    for (int count = 0; count < cfg.max_begin_retry; count++) {
      rc = p_radio->begin();
      if (rc) break;
      LOGI("NRF24 begin failed, retrying...");
      delay(500);
    }
    if (!rc) {
      LOGE("NRF24 begin failed after %d retries", cfg.max_begin_retry);
      return false;
    }
 
    p_radio->setChannel(cfg.channel);
    p_radio->setDataRate(cfg.data_rate);
    p_radio->setPALevel(cfg.pa_level);
    p_radio->setPayloadSize(cfg.payload_size);
    p_radio->setCRCLength(cfg.crc_length);
    p_radio->setAutoAck(cfg.auto_ack);
 
    if (cfg.mode == TX_MODE) {
      p_radio->openWritingPipe(cfg.address);
      p_radio->stopListening();
    } else {
      p_radio->openReadingPipe(1, cfg.address);
      p_radio->startListening();
    }
 
    tx_buffer.resize(cfg.payload_size);
 
    if (cfg.mode == RX_MODE && p_rx_buffer == nullptr) {
      default_rx_buffer.resize(cfg.payload_size * 16);
      p_rx_buffer = &default_rx_buffer;
    }
 
    LOGI("NRF24 begin success (mode: %s, channel: %d, payload: %d)",
         RxTxModeNames[cfg.mode], cfg.channel, cfg.payload_size);
    return true;
  }
 
  void end() override {
    TRACEI();
    if (p_radio != nullptr) {
      p_radio->stopListening();
      p_radio->powerDown();
    }
    if (p_own_radio != nullptr) {
      delete p_own_radio;
      p_own_radio = nullptr;
      p_radio = nullptr;
    }
    tx_buffer.resize(0);
  }
 
  size_t readBytes(uint8_t *data, size_t len) override {
    if (cfg.mode == TX_MODE || p_radio == nullptr) return 0;
    fillBuffer();
    return p_rx_buffer->readArray(data, len);
  }
 
  int available() override {
    if (cfg.mode == TX_MODE || p_radio == nullptr) return 0;
    fillBuffer();
    return p_rx_buffer->available();
  }
 
  int availableForWrite() override {
    if (cfg.mode == RX_MODE || p_radio == nullptr) return 0;
    return cfg.payload_size;
  }
 
  size_t write(const uint8_t *data, size_t len) override {
    if (cfg.mode == RX_MODE || p_radio == nullptr) return 0;
 
    for (size_t j = 0; j < len; j++) {
      tx_buffer.write(data[j]);
      if (tx_buffer.isFull()) {
        if (cfg.use_write_fast) {
          p_radio->writeFast(tx_buffer.data(), tx_buffer.available());
        } else {
          p_radio->write(tx_buffer.data(), tx_buffer.available());
        }
        tx_buffer.clear();
      }
    }
    return len;
  }
 
  RF24 *radio() { return p_radio; }
 
 protected:
  NRF24Config cfg;
  RF24 *p_radio = nullptr;
  RF24 *p_own_radio = nullptr;
  BaseBuffer<uint8_t> *p_rx_buffer = nullptr;
  RingBuffer<uint8_t> default_rx_buffer{0};
  SingleBuffer<uint8_t> tx_buffer;
 
  void fillBuffer() {
    if (p_rx_buffer == nullptr || p_radio == nullptr) return;
    while (p_radio->available()) {
      uint8_t tmp[32];
      p_radio->read(tmp, cfg.payload_size);
      p_rx_buffer->writeArray(tmp, cfg.payload_size);
    }
  }
};
 
}  // namespace audio_tools