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    127
#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
#if defined NRF_CCM || 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
} nrf_datarate_e;
 
typedef enum
{
    NRF_CRC_DISABLED = 0,
    NRF_CRC_8,
    NRF_CRC_16
} 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 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);
 
    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();
 
#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;
    bool overWrite;
    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 ARC;
    uint8_t addressWidth;
    uint16_t ackTimeout;
    bool payloadAvailable;
#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;
#endif
};
 
#endif //__nrf52840_nrf24l01_H__