nrf_to_nrf.h

Go to the documentation of this file.

#ifndef __nrf52840_nrf24l01_H__
#define __nrf52840_nrf24l01_H__
#include <Arduino.h>
#if defined(USE_TINYUSB)
    // Needed for Serial.print on non-MBED enabled or adafruit-based nRF52 cores
    #include "Adafruit_TinyUSB.h"
#endif
 
#if defined(NRF52811_XXAA) || defined(NRF52820_XXAA) || defined(NRF52833_XXAA) || defined(NRF52840_XXAA)
    #define NRF_HAS_ENERGY_DETECT
#endif
 
#define NRF52_RADIO_LIBRARY
#define DEFAULT_MAX_PAYLOAD_SIZE   32
#define ACTUAL_MAX_PAYLOAD_SIZE    258
#define ACK_TIMEOUT_1MBPS          600 // 300 with static payloads
#define ACK_TIMEOUT_2MBPS          400 // 265 with static payloads
#define ACK_TIMEOUT_250KBPS        800 // 500 with staticPayloads
#define ACK_TIMEOUT_1MBPS_OFFSET   300
#define ACK_TIMEOUT_2MBPS_OFFSET   135
#define ACK_TIMEOUT_250KBPS_OFFSET 300
#define ACK_PAYLOAD_TIMEOUT_OFFSET 750
 
// AES CCM ENCRYPTION
// The nRF54L15 CCM is a different peripheral with no NRF_CCM; with the nrf54l15clean core
// (https://github.com/lolren/nrf54-arduino-core) encryption uses its Ccm and CracenRng classes
#if defined(ARDUINO_NRF54L15) && defined(ARDUINO_ARCH_NRF54L15CLEAN)
    #define NRF54_CCM_ENCRYPTION
#endif
#if defined NRF_CCM || defined NRF54_CCM_ENCRYPTION || defined(DOXYGEN)
    #define CCM_ENCRYPTION_ENABLED
#endif
#if defined CCM_ENCRYPTION_ENABLED || defined(DOXYGEN)
    #define MAX_PACKET_SIZE          ACTUAL_MAX_PAYLOAD_SIZE // Max Payload Size
    #define CCM_KEY_SIZE             16
    #define CCM_IV_SIZE              5
    #define CCM_IV_SIZE_ACTUAL       8
    #define CCM_COUNTER_SIZE         3
    #define CCM_MIC_SIZE             4
    #define CCM_START_SIZE           3
    #define CCM_MODE_LENGTH_EXTENDED 16
#endif
 
typedef enum
{
    NRF_PA_MIN = 0,
    NRF_PA_LOW,
    NRF_PA_HIGH,
    NRF_PA_MAX,
    NRF_PA_ERROR
} nrf_pa_dbm_e;

typedef enum
{
    NRF_1MBPS = 0,
    NRF_2MBPS,
    NRF_250KBPS
#ifdef ARDUINO_NRF54L15
        ,
    NRF_4MBPS_OBT4,
    NRF_4MBPS_OBT6
#endif
} nrf_datarate_e;

typedef enum
{
    NRF_CRC_DISABLED = 0,
    NRF_CRC_8,
    NRF_CRC_16,
    NRF_CRC_24
} nrf_crclength_e;

 
class nrf_to_nrf
{
 
public:

    nrf_to_nrf();

    bool begin();

    bool available();

    bool available(uint8_t* pipe_num);

    void read(void* buf, uint8_t len);

    bool write(void* buf, uint8_t len, bool multicast = false, bool doEncryption = true);

    void startListening(bool resetAddresses = true);

    void stopListening(bool setWritingPipe = true, bool resetAddresses = true);
 
    void stopListening(const uint8_t* txAddress, bool setWritingPipe = true, bool resetAddresses = true);

    void openReadingPipe(uint8_t child, const uint8_t* address);

    void openWritingPipe(const uint8_t* address);

    bool isChipConnected();


    uint8_t radioData[ACTUAL_MAX_PAYLOAD_SIZE + 2];

    bool writeFast(void* buf, uint8_t len, bool multicast = 0);

    bool startWrite(void* buf, uint8_t len, bool multicast, bool doEncryption = true);

    bool writeAckPayload(uint8_t pipe, void* buf, uint8_t len);

    void enableAckPayload();

    void disableAckPayload();

    void enableDynamicAck();

    uint8_t getDynamicPayloadSize();

    bool isValid();

    void setChannel(uint8_t channel, bool map = 0);

    uint8_t getChannel();

    bool setDataRate(uint8_t speed);

    void setPALevel(uint8_t level, bool lnaEnable = true);

    uint8_t getPALevel();

    void setAutoAck(bool enable);

    void setAutoAck(uint8_t pipe, bool enable);

    void enableDynamicPayloads(uint8_t payloadSize = DEFAULT_MAX_PAYLOAD_SIZE);

    void disableDynamicPayloads();

    void setPayloadSize(uint8_t size);

    uint8_t getPayloadSize();

    void setCRCLength(nrf_crclength_e length);

    nrf_crclength_e getCRCLength();

    void disableCRC();

    void setRetries(uint8_t retryVar, uint8_t attempts);

    void openReadingPipe(uint8_t child, uint64_t address);

    void openWritingPipe(uint64_t address);

    void setAddressWidth(uint8_t a_width);

    void printDetails();

    void powerUp();

    void powerDown();

    bool failureDetected;

    bool txStandBy();

    bool txStandBy(uint32_t timeout, bool startTx = 0);

    bool testCarrier(uint8_t RSSI = 65);

    bool testRPD(uint8_t RSSI = 65);

    uint8_t getRSSI();

    uint8_t getARC();

    uint8_t flush_rx();

    uint16_t interframeSpacing;
 
#ifdef NRF_HAS_ENERGY_DETECT
    uint8_t sample_ed(void);
#endif


    uint32_t addrConv32(uint32_t addr);
#if defined CCM_ENCRYPTION_ENABLED || defined(DOXYGEN)

    uint8_t encrypt(void* bufferIn, uint8_t size);

    uint8_t decrypt(void* bufferIn, uint8_t size);

    uint8_t outBuffer[MAX_PACKET_SIZE + CCM_MIC_SIZE + CCM_START_SIZE];

    void setKey(uint8_t key[CCM_KEY_SIZE]);

    void setCounter(uint64_t counter);

    void setIV(uint8_t IV[CCM_IV_SIZE]);

    bool enableEncryption;
#endif
 
private:
    bool acksEnabled(uint8_t pipe);
    bool acksPerPipe[8];
    uint8_t retries;
    uint8_t retryDuration;
    uint8_t rxBuffer[ACTUAL_MAX_PAYLOAD_SIZE + 1];
    uint8_t ackBuffer[ACTUAL_MAX_PAYLOAD_SIZE + 1];
    uint8_t rxFifoAvailable;
    bool DPL;
    bool ackPayloadsEnabled;
    bool inRxMode;
    uint8_t staticPayloadSize;
    uint8_t ackPID;
    uint8_t ackPipe;
    bool lastTxResult;
    uint32_t rxBase;
    uint32_t rxPrefix;
    uint32_t txBase;
    uint32_t txPrefix;
    bool ackPayloadAvailable;
    uint8_t ackAvailablePipeNo;
    uint8_t lastPacketCounter;
    uint16_t lastData;
    bool dynamicAckEnabled;
    uint8_t arcCounter;
    uint16_t ackTimeout;
    bool payloadAvailable;
    bool restartReturnRx();
    void openReadingPipe(uint8_t child, uint32_t base, uint32_t prefix);
    void openWritingPipe(uint32_t base, uint32_t prefix);
#if defined CCM_ENCRYPTION_ENABLED
    uint8_t inBuffer[MAX_PACKET_SIZE + CCM_MIC_SIZE + CCM_START_SIZE];
    uint8_t scratchPTR[MAX_PACKET_SIZE + CCM_MODE_LENGTH_EXTENDED];
    typedef struct
    {
        uint8_t key[CCM_KEY_SIZE];
        uint64_t counter;
        uint8_t direction;
        uint8_t iv[CCM_IV_SIZE_ACTUAL];
    } ccmData_t;
    ccmData_t ccmData;
    uint32_t packetCounter;
    bool generateIV(uint8_t iv[CCM_IV_SIZE]);
#endif
};














 
#endif //__nrf52840_nrf24l01_H__