LoRaWAN.h

#if !defined(_RADIOLIB_LORAWAN_H) && !RADIOLIB_EXCLUDE_LORAWAN
#define _RADIOLIB_LORAWAN_H
 
#include "../../TypeDef.h"
#include "../PhysicalLayer/PhysicalLayer.h"
#include "../../utils/Cryptography.h"
 
// activation mode
#define RADIOLIB_LORAWAN_MODE_OTAA                              (0x07AA)
#define RADIOLIB_LORAWAN_MODE_ABP                               (0x0AB9)
#define RADIOLIB_LORAWAN_MODE_NONE                              (0x0000)
 
// operation mode
#define RADIOLIB_LORAWAN_CLASS_A                                (0x00)
#define RADIOLIB_LORAWAN_CLASS_B                                (0x01)
#define RADIOLIB_LORAWAN_CLASS_C                                (0x02)
 
// preamble format
#define RADIOLIB_LORAWAN_LORA_SYNC_WORD                         (0x34)
#define RADIOLIB_LORAWAN_LORA_PREAMBLE_LEN                      (8)
#define RADIOLIB_LORAWAN_GFSK_SYNC_WORD                         (0xC194C1)
#define RADIOLIB_LORAWAN_GFSK_PREAMBLE_LEN                      (5)
#define RADIOLIB_LORAWAN_LR_FHSS_SYNC_WORD                      (0x2C0F7995)
 
// MAC header field encoding                                                    MSB   LSB   DESCRIPTION
#define RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_REQUEST                (0x00 << 5) //  7     5     message type: join request
#define RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_ACCEPT                 (0x01 << 5) //  7     5                   join accept
#define RADIOLIB_LORAWAN_MHDR_MTYPE_UNCONF_DATA_UP              (0x02 << 5) //  7     5                   unconfirmed data up
#define RADIOLIB_LORAWAN_MHDR_MTYPE_UNCONF_DATA_DOWN            (0x03 << 5) //  7     5                   unconfirmed data down
#define RADIOLIB_LORAWAN_MHDR_MTYPE_CONF_DATA_UP                (0x04 << 5) //  7     5                   confirmed data up
#define RADIOLIB_LORAWAN_MHDR_MTYPE_CONF_DATA_DOWN              (0x05 << 5) //  7     5                   confirmed data down
#define RADIOLIB_LORAWAN_MHDR_MTYPE_PROPRIETARY                 (0x07 << 5) //  7     5                   proprietary
#define RADIOLIB_LORAWAN_MHDR_MTYPE_MASK                        (0x07 << 5) //  7     5                   bitmask of all possible options
#define RADIOLIB_LORAWAN_MHDR_MAJOR_R1                          (0x00 << 0) //  1     0     major version: LoRaWAN R1
 
// frame control field encoding
#define RADIOLIB_LORAWAN_FCTRL_ADR_ENABLED                      (0x01 << 7) //  7     7     adaptive data rate: enabled
#define RADIOLIB_LORAWAN_FCTRL_ADR_DISABLED                     (0x00 << 7) //  7     7                         disabled
#define RADIOLIB_LORAWAN_FCTRL_ADR_ACK_REQ                      (0x01 << 6) //  6     6     adaptive data rate ACK request
#define RADIOLIB_LORAWAN_FCTRL_ACK                              (0x01 << 5) //  5     5     confirmed message acknowledge
#define RADIOLIB_LORAWAN_FCTRL_FRAME_PENDING                    (0x01 << 4) //  4     4     downlink frame is pending
 
// fPort field
#define RADIOLIB_LORAWAN_FPORT_MAC_COMMAND                      (0x00 << 0) //  7     0     payload contains MAC commands only
#define RADIOLIB_LORAWAN_FPORT_PAYLOAD_MIN                      (0x01 << 0) //  7     0     start of user-allowed fPort range
#define RADIOLIB_LORAWAN_FPORT_PAYLOAD_MAX                      (0xDF << 0) //  7     0     end of user-allowed fPort range
#define RADIOLIB_LORAWAN_FPORT_RESERVED                         (0xE0 << 0) //  7     0     fPort values equal to and larger than this are reserved
 
// data rate encoding
#define RADIOLIB_LORAWAN_DATA_RATE_UNUSED                       (0x0F << 0) // reserved / unused data rate
#define RADIOLIB_LORAWAN_TX_POWER_UNUSED                        (0x0F << 0) // reserved / unused Tx power
 
// channels and channel plans
#define RADIOLIB_LORAWAN_UPLINK                                 (0x00 << 0)
#define RADIOLIB_LORAWAN_DOWNLINK                               (0x01 << 0)
#define RADIOLIB_LORAWAN_RX1                                    (0x01 << 0)
#define RADIOLIB_LORAWAN_RX2                                    (0x02 << 0)
#define RADIOLIB_LORAWAN_RX_BC                                  (0x03 << 0)
#define RADIOLIB_LORAWAN_BAND_DYNAMIC                           (0)
#define RADIOLIB_LORAWAN_BAND_FIXED                             (1)
#define RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES                  (15)
 
// recommended default settings
#define RADIOLIB_LORAWAN_RECEIVE_DELAY_1_MS                     (1000)
#define RADIOLIB_LORAWAN_RECEIVE_DELAY_2_MS                     ((RADIOLIB_LORAWAN_RECEIVE_DELAY_1_MS) + 1000)
#define RADIOLIB_LORAWAN_RX1_DR_OFFSET                          (0)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_DELAY_1_MS                 (5000)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_DELAY_2_MS                 (6000)
#define RADIOLIB_LORAWAN_ADR_ACK_LIMIT_EXP                      (0x06)
#define RADIOLIB_LORAWAN_ADR_ACK_DELAY_EXP                      (0x05)
#define RADIOLIB_LORAWAN_RETRANSMIT_TIMEOUT_MIN_MS              (1000)
#define RADIOLIB_LORAWAN_RETRANSMIT_TIMEOUT_MAX_MS              (3000)
#define RADIOLIB_LORAWAN_POWER_STEP_SIZE_DBM                    (-2)
#define RADIOLIB_LORAWAN_REJOIN_MAX_COUNT_N                     (10)  // send rejoin request 16384 uplinks
#define RADIOLIB_LORAWAN_REJOIN_MAX_TIME_N                      (15)  // once every year, not actually implemented
 
// join request message layout
#define RADIOLIB_LORAWAN_JOIN_REQUEST_LEN                       (23)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_JOIN_EUI_POS              (1)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_DEV_EUI_POS               (9)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_DEV_NONCE_POS             (17)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_TYPE                      (0xFF)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_TYPE_0                    (0x00)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_TYPE_1                    (0x01)
#define RADIOLIB_LORAWAN_JOIN_REQUEST_TYPE_2                    (0x02)
 
// join accept message layout
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN                    (33)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_JOIN_NONCE_POS             (1)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_HOME_NET_ID_POS            (4)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_DEV_ADDR_POS               (7)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_DL_SETTINGS_POS            (11)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_RX_DELAY_POS               (12)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_POS                 (13)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_LEN                 (16)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_TYPE_POS            (RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_POS + RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_LEN - 1)
 
// join accept key derivation layout
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_AES_JOIN_NONCE_POS         (1)   // regular keys
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_AES_JOIN_EUI_POS           (4)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_AES_DEV_NONCE_POS          (12)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_AES_DEV_ADDR_POS           (1)   // relay keys
 
// join accept message variables
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_R_1_0                      (0x00 << 7) //  7     7     LoRaWAN revision: 1.0
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_R_1_1                      (0x01 << 7) //  7     7                       1.1
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_F_NWK_S_INT_KEY            (0x01)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_APP_S_KEY                  (0x02)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_S_NWK_S_INT_KEY            (0x03)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_NWK_S_ENC_KEY              (0x04)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_JS_ENC_KEY                 (0x05)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_JS_INT_KEY                 (0x06)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_ROOT_WOR_S_KEY             (0x01)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_WOR_S_INT_KEY              (0x01)
#define RADIOLIB_LORAWAN_JOIN_ACCEPT_WOR_S_ENC_KEY              (0x02)
 
// frame header layout
#define RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS                    (16)
#define RADIOLIB_LORAWAN_FHDR_DEV_ADDR_POS                      (RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS + 1)
#define RADIOLIB_LORAWAN_FHDR_FCTRL_POS                         (RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS + 5)
#define RADIOLIB_LORAWAN_FHDR_FCNT_POS                          (RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS + 6)
#define RADIOLIB_LORAWAN_FHDR_FOPTS_POS                         (RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS + 8)
#define RADIOLIB_LORAWAN_FHDR_FOPTS_LEN_MASK                    (0x0F)
#define RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN                     (15)
#define RADIOLIB_LORAWAN_FHDR_FPORT_POS(FOPTS)                  (RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS + 8 + (FOPTS))
#define RADIOLIB_LORAWAN_FRAME_PAYLOAD_POS(FOPTS)               (RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS + 9 + (FOPTS))
#define RADIOLIB_LORAWAN_FRAME_LEN(PAYLOAD, FOPTS)              (16 + 13 + (PAYLOAD) + (FOPTS))
 
// payload encryption/MIC blocks common layout
#define RADIOLIB_LORAWAN_BLOCK_MAGIC_POS                        (0)
#define RADIOLIB_LORAWAN_BLOCK_CONF_FCNT_POS                    (1)
#define RADIOLIB_LORAWAN_BLOCK_DIR_POS                          (5)
#define RADIOLIB_LORAWAN_BLOCK_DEV_ADDR_POS                     (6)
#define RADIOLIB_LORAWAN_BLOCK_FCNT_POS                         (10)
 
// payload encryption block layout
#define RADIOLIB_LORAWAN_ENC_BLOCK_MAGIC                        (0x01)
#define RADIOLIB_LORAWAN_ENC_BLOCK_COUNTER_ID_POS               (4)
#define RADIOLIB_LORAWAN_ENC_BLOCK_COUNTER_POS                  (15)
 
// payload MIC blocks layout
#define RADIOLIB_LORAWAN_MIC_BLOCK_MAGIC                        (0x49)
#define RADIOLIB_LORAWAN_MIC_BLOCK_LEN_POS                      (15)
#define RADIOLIB_LORAWAN_MIC_DATA_RATE_POS                      (3)
#define RADIOLIB_LORAWAN_MIC_CH_INDEX_POS                       (4)
 
// maximum allowed dwell time on bands that implement dwell time limitations
#define RADIOLIB_LORAWAN_DWELL_TIME                             (400)
 
// unused frame counter value
#define RADIOLIB_LORAWAN_FCNT_NONE                              (0xFFFFFFFF)
 
// TR013 CSMA recommended values
#define RADIOLIB_LORAWAN_DIFS_DEFAULT                           (2)
#define RADIOLIB_LORAWAN_BACKOFF_MAX_DEFAULT                    (6)
#define RADIOLIB_LORAWAN_MAX_CHANGES_DEFAULT                    (4)
 
// MAC commands
#define RADIOLIB_LORAWAN_NUM_MAC_COMMANDS                       (24)
 
#define RADIOLIB_LORAWAN_MAC_RESET                              (0x01)
#define RADIOLIB_LORAWAN_MAC_LINK_CHECK                         (0x02)
#define RADIOLIB_LORAWAN_MAC_LINK_ADR                           (0x03)
#define RADIOLIB_LORAWAN_MAC_DUTY_CYCLE                         (0x04)
#define RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP                     (0x05)
#define RADIOLIB_LORAWAN_MAC_DEV_STATUS                         (0x06)
#define RADIOLIB_LORAWAN_MAC_NEW_CHANNEL                        (0x07)
#define RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP                    (0x08)
#define RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP                     (0x09)
#define RADIOLIB_LORAWAN_MAC_DL_CHANNEL                         (0x0A)
#define RADIOLIB_LORAWAN_MAC_REKEY                              (0x0B)
#define RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP                    (0x0C)
#define RADIOLIB_LORAWAN_MAC_DEVICE_TIME                        (0x0D)
#define RADIOLIB_LORAWAN_MAC_FORCE_REJOIN                       (0x0E)
#define RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP                 (0x0F)
#define RADIOLIB_LORAWAN_MAC_DEVICE_MODE                        (0x20)
#define RADIOLIB_LORAWAN_MAC_PROPRIETARY                        (0x80)
 
// the maximum number of simultaneously available channels
#define RADIOLIB_LORAWAN_MAX_NUM_DYNAMIC_CHANNELS               (24)
#define RADIOLIB_LORAWAN_MAX_NUM_SUBBANDS                       (12)
#define RADIOLIB_LORAWAN_MAX_NUM_FIXED_CHANNELS                 (96)
 
// maximum MAC command sizes
#define RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_DOWN               (5)
#define RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_UP                 (2)
#define RADIOLIB_LORAWAN_MAX_NUM_ADR_COMMANDS                   (8)
 
#define RADIOLIB_LORAWAN_MAX_PAYLOAD_SIZE                      (242)
 
// maximum PHYPayload size (MHDR + MACPayload + MIC)
#define RADIOLIB_LORAWAN_MAX_PHY_PAYLOAD_SIZE                  (255)
 
// session states
#define RADIOLIB_LORAWAN_SESSION_NONE                           (0x00)
#define RADIOLIB_LORAWAN_SESSION_ACTIVATING                     (0x01)
#define RADIOLIB_LORAWAN_SESSION_PENDING                        (0x02)
#define RADIOLIB_LORAWAN_SESSION_ACTIVE                         (0x03)
 
// threshold at which sleeping via user callback enabled, in ms
#define RADIOLIB_LORAWAN_DELAY_SLEEP_THRESHOLD                  (10)

struct LoRaWANMacCommand_t {
  const uint8_t cid;
  
  const uint8_t lenDn;
  
  const uint8_t lenUp;

  const bool persist;
  
  const bool user;
};
 
#define RADIOLIB_LORAWAN_MAC_COMMAND_NONE { .cid = 0, .lenDn = 0, .lenUp = 0, .persist = false, .user = false }
 
// maximum number of simultaneously available multicast groups
#define RADIOLIB_LORAWAN_MAX_NUM_MC_GROUPS (4)
 
struct MulticastGroup_t {
  uint8_t cls;
  
  uint32_t mcAddr;
  
  uint8_t mcAppSKey[RADIOLIB_AES128_KEY_SIZE];
  
  uint8_t mcNwkSKey[RADIOLIB_AES128_KEY_SIZE];
  
  uint32_t mcFCnt;
  
  uint32_t mcFCntMax;

  uint32_t rxFCnt;

  uint32_t mcFreq;
  
  uint8_t mcDr;
};
 
#define RADIOLIB_MULTICAST_GROUP_NONE \
  { .cls = RADIOLIB_LORAWAN_CLASS_A, .mcAddr = 0, .mcAppSKey = { 0 }, .mcNwkSKey = { 0 }, \
  .mcFCnt = 0, .mcFCntMax = 0xFFFFFFFF, .rxFCnt = 0, .mcFreq = 0, .mcDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED }
 
// currently known packages with reserved FPorts:
// TS007 (MultiPackage), TS009 (Certification), TS011 (Relay)
#define RADIOLIB_LORAWAN_NUM_RESERVED_PACKAGES (3)

struct LoRaWANPackage_t {
  bool enabled;
  
  bool isAppPack;
};
 
#define RADIOLIB_LORAWAN_NONCES_VERSION_VAL (0x0004)
 
enum LoRaWANSchemePersistence_t {
  RADIOLIB_LORAWAN_NONCES_START           = 0x00,
  RADIOLIB_LORAWAN_PERSISTENCE_SIZE       = RADIOLIB_LORAWAN_NONCES_START,
  RADIOLIB_LORAWAN_PERSISTENCE_VERSION    = RADIOLIB_LORAWAN_PERSISTENCE_SIZE + 1,
  RADIOLIB_LORAWAN_PERSISTENCE_KEYS       = RADIOLIB_LORAWAN_PERSISTENCE_VERSION + 2,
  RADIOLIB_LORAWAN_PERSISTENCE_JOIN_NONCE = RADIOLIB_LORAWAN_PERSISTENCE_KEYS + 4,
  RADIOLIB_LORAWAN_PERSISTENCE_DEV_NONCE  = RADIOLIB_LORAWAN_PERSISTENCE_JOIN_NONCE + 3,
  RADIOLIB_LORAWAN_PERSISTENCE_RJ_COUNT   = RADIOLIB_LORAWAN_PERSISTENCE_DEV_NONCE + 2,
  RADIOLIB_LORAWAN_PERSISTENCE_TS004      = RADIOLIB_LORAWAN_PERSISTENCE_RJ_COUNT + 2,
  RADIOLIB_LORAWAN_PERSISTENCE_TS009      = RADIOLIB_LORAWAN_PERSISTENCE_TS004 + 8,
  RADIOLIB_LORAWAN_PERSISTENCE_RFU        = RADIOLIB_LORAWAN_PERSISTENCE_TS009 + 1,
  RADIOLIB_LORAWAN_PERSISTENCE_SIGNATURE  = RADIOLIB_LORAWAN_PERSISTENCE_RFU + 5,
  RADIOLIB_LORAWAN_PERSISTENCE_BUF_SIZE   = RADIOLIB_LORAWAN_PERSISTENCE_SIGNATURE + 4
};
 
enum LoRaWANSchemeSession_t {
  RADIOLIB_LORAWAN_SESSION_START              = 0x00,
  RADIOLIB_LORAWAN_SESSION_STATUS             = RADIOLIB_LORAWAN_SESSION_START,                             // 1 byte
  RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY       = RADIOLIB_LORAWAN_SESSION_STATUS + 1,                        // 16 bytes
  RADIOLIB_LORAWAN_SESSION_APP_SKEY           = RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY + RADIOLIB_AES128_KEY_SIZE,   // 16 bytes
  RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY      = RADIOLIB_LORAWAN_SESSION_APP_SKEY + RADIOLIB_AES128_KEY_SIZE,       // 16 bytes
  RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY      = RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY + RADIOLIB_AES128_KEY_SIZE,  // 16 bytes
  RADIOLIB_LORAWAN_SESSION_DEV_ADDR           = RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY + RADIOLIB_AES128_KEY_SIZE,  // 4 bytes
  RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE   = RADIOLIB_LORAWAN_SESSION_DEV_ADDR + sizeof(uint32_t),               // 4 bytes
  RADIOLIB_LORAWAN_SESSION_FCNT_UP            = RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE + sizeof(uint32_t),       // 4 bytes
  RADIOLIB_LORAWAN_SESSION_N_FCNT_DOWN        = RADIOLIB_LORAWAN_SESSION_FCNT_UP + sizeof(uint32_t),        // 4 bytes
  RADIOLIB_LORAWAN_SESSION_A_FCNT_DOWN        = RADIOLIB_LORAWAN_SESSION_N_FCNT_DOWN + sizeof(uint32_t),    // 4 bytes
  RADIOLIB_LORAWAN_SESSION_ADR_FCNT           = RADIOLIB_LORAWAN_SESSION_A_FCNT_DOWN + sizeof(uint32_t),    // 4 bytes
  RADIOLIB_LORAWAN_SESSION_CONF_FCNT_UP       = RADIOLIB_LORAWAN_SESSION_ADR_FCNT + sizeof(uint32_t),       // 4 bytes
  RADIOLIB_LORAWAN_SESSION_CONF_FCNT_DOWN     = RADIOLIB_LORAWAN_SESSION_CONF_FCNT_UP + sizeof(uint32_t),   // 4 bytes
  RADIOLIB_LORAWAN_SESSION_RX_A_FCNT          = RADIOLIB_LORAWAN_SESSION_CONF_FCNT_DOWN + sizeof(uint32_t), // 4 bytes
  RADIOLIB_LORAWAN_SESSION_VERSION            = RADIOLIB_LORAWAN_SESSION_RX_A_FCNT + sizeof(uint32_t),      // 1 byte
  RADIOLIB_LORAWAN_SESSION_BAND               = RADIOLIB_LORAWAN_SESSION_VERSION + 1,                       // 1 byte
  RADIOLIB_LORAWAN_SESSION_CLASS              = RADIOLIB_LORAWAN_SESSION_BAND + 1,                          // 1 byte
  RADIOLIB_LORAWAN_SESSION_LINK_ADR           = RADIOLIB_LORAWAN_SESSION_CLASS + sizeof(uint8_t),           // 14 bytes
  RADIOLIB_LORAWAN_SESSION_DUTY_CYCLE         = RADIOLIB_LORAWAN_SESSION_LINK_ADR + 14,                     // 1 byte
  RADIOLIB_LORAWAN_SESSION_RX_PARAM_SETUP     = RADIOLIB_LORAWAN_SESSION_DUTY_CYCLE + 1,                    // 4 bytes
  RADIOLIB_LORAWAN_SESSION_RX_TIMING_SETUP    = RADIOLIB_LORAWAN_SESSION_RX_PARAM_SETUP + 4,                // 1 byte
  RADIOLIB_LORAWAN_SESSION_TX_PARAM_SETUP     = RADIOLIB_LORAWAN_SESSION_RX_TIMING_SETUP + 1,               // 1 byte
  RADIOLIB_LORAWAN_SESSION_ADR_PARAM_SETUP    = RADIOLIB_LORAWAN_SESSION_TX_PARAM_SETUP + 1,                // 1 byte
  RADIOLIB_LORAWAN_SESSION_REJOIN_PARAM_SETUP = RADIOLIB_LORAWAN_SESSION_ADR_PARAM_SETUP + 1,               // 1 byte
  RADIOLIB_LORAWAN_SESSION_UL_CHANNELS        = RADIOLIB_LORAWAN_SESSION_REJOIN_PARAM_SETUP + 1,            // 16*5 bytes
  RADIOLIB_LORAWAN_SESSION_DL_CHANNELS        = RADIOLIB_LORAWAN_SESSION_UL_CHANNELS + RADIOLIB_LORAWAN_MAX_NUM_DYNAMIC_CHANNELS*5, // 16*4 bytes
  RADIOLIB_LORAWAN_SESSION_AVAILABLE_CHANNELS = RADIOLIB_LORAWAN_SESSION_DL_CHANNELS + RADIOLIB_LORAWAN_MAX_NUM_DYNAMIC_CHANNELS*4, // 2 bytes
  RADIOLIB_LORAWAN_SESSION_MAC_QUEUE          = RADIOLIB_LORAWAN_SESSION_AVAILABLE_CHANNELS + RADIOLIB_LORAWAN_MAX_NUM_SUBBANDS,    // 12 bytes                   // 15 bytes
  RADIOLIB_LORAWAN_SESSION_MAC_QUEUE_LEN      = RADIOLIB_LORAWAN_SESSION_MAC_QUEUE + RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN,           // 1 byte
  RADIOLIB_LORAWAN_SESSION_SIGNATURE          = RADIOLIB_LORAWAN_SESSION_MAC_QUEUE_LEN + sizeof(uint8_t),   // 4 bytes
  RADIOLIB_LORAWAN_SESSION_BUF_SIZE           = RADIOLIB_LORAWAN_SESSION_SIGNATURE + sizeof(uint32_t)       // Session buffer size
};

struct LoRaWANChannel_t {
  uint8_t idx;

  uint32_t freq;

  uint8_t drMin;

  uint8_t drMax;

  uint8_t dr;
};
 
// alias for unused channel
#define RADIOLIB_LORAWAN_CHANNEL_NONE    { .idx = 0, .freq = 0, .drMin = 0, .drMax = 0, \
                                           .dr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED }

struct LoRaWANChannelSpan_t {
  uint8_t numChannels;

  uint32_t freqStart;

  uint32_t freqStep;

  uint8_t drMin;

  uint8_t drMax;
  
  uint8_t drJoinRequest;
};
 
// alias for unused channel span
#define RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE    { .numChannels = 0, .freqStart = 0, .freqStep = 0, .drMin = 0, .drMax = 0, .drJoinRequest = RADIOLIB_LORAWAN_DATA_RATE_UNUSED }
 
struct LoRaWANDataRate_t {
  ModemType_t modem;
  DataRate_t dr;
  PacketConfig_t pc;
};
 
#define RADIOLIB_DATARATE_NONE { .modem = RADIOLIB_MODEM_NONE, .dr = {.lora = {0, 0, 0}}, .pc = {.lora = { 8, 0, 0, 0}}}

struct LoRaWANBand_t {
  uint8_t bandNum;

  uint8_t bandType;

  uint32_t freqMin;

  uint32_t freqMax;

  uint8_t payloadLenMax[RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES];

  int8_t powerMax;

  int8_t powerNumSteps;

  RadioLibTime_t dutyCycle;

  RadioLibTime_t dwellTimeUp;

  RadioLibTime_t dwellTimeDn;

  bool txParamSupported;

  LoRaWANChannel_t txFreqs[3];

  uint8_t numTxSpans;

  LoRaWANChannelSpan_t txSpans[2];

  LoRaWANChannelSpan_t rx1Span;
 
  uint8_t rx1DrTable[RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES][8];

  LoRaWANChannel_t rx2;

  LoRaWANChannel_t txWoR[2];

  LoRaWANChannel_t txAck[2];
  
  LoRaWANDataRate_t dataRates[RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES];
};
 
// supported bands
extern const LoRaWANBand_t EU868;
extern const LoRaWANBand_t US915;
extern const LoRaWANBand_t EU433;
extern const LoRaWANBand_t AU915;
extern const LoRaWANBand_t CN470;
extern const LoRaWANBand_t AS923;
extern const LoRaWANBand_t AS923_2;
extern const LoRaWANBand_t AS923_3;
extern const LoRaWANBand_t AS923_4;
extern const LoRaWANBand_t KR920;
extern const LoRaWANBand_t IN865;

enum LoRaWANBandNum_t {
  BandEU868,
  BandUS915,
  BandEU433,
  BandAU915,
  BandCN470,
  BandAS923,
  BandAS923_2,
  BandAS923_3,
  BandAS923_4,
  BandKR920,
  BandIN865,
  BandLast
};
 
// provide easy access to the number of currently supported bands
#define RADIOLIB_LORAWAN_NUM_SUPPORTED_BANDS      (BandLast - BandEU868)
 
// array of currently supported bands
extern const LoRaWANBand_t* LoRaWANBands[];

struct LoRaWANJoinEvent_t {
  bool newSession = false;

  uint16_t devNonce = 0;

  uint32_t joinNonce = 0;
};

struct LoRaWANEvent_t {
  uint8_t dir;
  
  bool confirmed;
  
  bool confirming;

  bool frmPending;

  uint8_t datarate;
  
  uint32_t freq;
  
  int16_t power;
  
  uint32_t fCnt;
  
  uint8_t fPort;

  uint8_t nbTrans;

  bool multicast;

  uint8_t mcGroupId;
};

class LoRaWANNode {
  public:

    LoRaWANNode(PhysicalLayer* phy, const LoRaWANBand_t* band, uint8_t subBand = 0);

    void clearSession();

    typedef void (*BufferCb_t)(uint8_t* buf, size_t len);

    void setCallbackStorePersistence(BufferCb_t cb);

    void setCallbackRestorePersistence(BufferCb_t cb);

    void setCallbackStoreSession(BufferCb_t cb);

    void setCallbackRestoreSession(BufferCb_t cb);

    int16_t loadBuffers();

    int16_t beginOTAA(uint64_t joinEUI, uint64_t devEUI, const uint8_t* nwkKey, const uint8_t* appKey);

    int16_t beginABP(uint32_t addr, const uint8_t* fNwkSIntKey, const uint8_t* sNwkSIntKey, const uint8_t* nwkSEncKey, const uint8_t* appSKey);

    int16_t activateOTAA(LoRaWANJoinEvent_t *joinEvent = NULL);

    int16_t activateABP();

    bool isActivated();

    int16_t setClass(uint8_t cls);

    int16_t startMulticastSession(uint8_t cls, uint32_t mcAddr, const uint8_t* mcAppSKey, const uint8_t* mcNwkSKey, 
                                  uint32_t mcFCntMin = 0, uint32_t mcFCntMax = 0xFFFFFFFF, uint32_t mcFreq = 0, 
                                  uint8_t mcDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED);

    int16_t startMulticastSession(uint8_t id, MulticastGroup_t* mcGroup);

    bool stopMulticastSession(uint8_t id, bool addRxFCnt = false);
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    virtual int16_t sendReceive(const String& strUp, uint8_t fPort, String& strDown, bool isConfirmed = false, LoRaWANEvent_t* eventUp = NULL, LoRaWANEvent_t* eventDown = NULL);
    #endif

    virtual int16_t sendReceive(const char* strUp, uint8_t fPort, bool isConfirmed = false, LoRaWANEvent_t* eventUp = NULL, LoRaWANEvent_t* eventDown = NULL);

    virtual int16_t sendReceive(const char* strUp, uint8_t fPort, uint8_t* dataDown, size_t* lenDown, bool isConfirmed = false, LoRaWANEvent_t* eventUp = NULL, LoRaWANEvent_t* eventDown = NULL);

    virtual int16_t sendReceive(const uint8_t* dataUp, size_t lenUp, uint8_t fPort = 1, bool isConfirmed = false, LoRaWANEvent_t* eventUp = NULL, LoRaWANEvent_t* eventDown = NULL);

    virtual int16_t sendReceive(const uint8_t* dataUp, size_t lenUp, uint8_t fPort, uint8_t* dataDown, size_t* lenDown, bool isConfirmed = false, LoRaWANEvent_t* eventUp = NULL, LoRaWANEvent_t* eventDown = NULL);

    int16_t getDownlinkClassC(uint8_t* dataDown, size_t* lenDown, LoRaWANEvent_t* eventDown = NULL);

    int16_t sendMacCommandReq(uint8_t cid);

    int16_t getMacLinkCheckAns(uint8_t* margin, uint8_t* gwCnt);

    int16_t getMacDeviceTimeAns(uint32_t* timestamp, uint16_t* milliseconds, bool returnUnix = true);

   int16_t setBand(const LoRaWANBand_t* band, uint8_t subBand = 0);
    
    int16_t setDatarate(uint8_t drUp);

    int16_t setTxPower(int8_t txPower);

    int16_t setRx2Dr(uint8_t dr);

    void setADR(bool enable = true);

    void setDutyCycle(bool enable = true, RadioLibTime_t msPerHour = 0);

    void setDwellTime(bool enable, RadioLibTime_t msPerUplink = 0);

    void setCSMA(bool csmaEnabled, uint8_t maxChanges = 4, uint8_t backoffMax = 0, uint8_t difsSlots = 2);

    void setDeviceStatus(uint8_t battLevel);

    void setActivityLeds(const uint32_t pins[4]);

    void getPersistencePackage(uint8_t pIndex, uint8_t* buff);

    void setPersistencePackage(uint8_t pIndex, const uint8_t* buff);

    void scheduleTransmission(RadioLibTime_t tUplink);

    const LoRaWANBand_t* getBand();

    uint8_t getUnicastClass();

    uint8_t getMulticastClass();
    
    uint8_t getClass();

    uint8_t getVersionMajor();

    uint32_t getFCntUp();

    uint32_t getNFCntDown();

    uint32_t getAFCntDown();

    uint32_t getRxFCnt();

    uint32_t getRxFCntMulticast(uint8_t mcGroupId);

    uint32_t getDevAddr();

    RadioLibTime_t getLastToA();

    RadioLibTime_t getLastDuration(bool seconds = false);
    
    RadioLibTime_t timeUntilUplink(bool seconds = false);

    void syncClock();
    
    uint8_t getMacUplinkLen();

    RadioLibTime_t dutyCycleInterval(RadioLibTime_t msPerHour, RadioLibTime_t airtime);

    virtual uint8_t getMaxPayloadLen();

    virtual int16_t testPayloadLength(uint8_t len);

    typedef void (*SleepCb_t)(RadioLibTime_t ms);

    void setSleepFunction(SleepCb_t cb); 

    int16_t addAppPackage(uint8_t fPort);

    int16_t addNwkPackage(uint8_t fPort);

    void removePackage(uint8_t fPort);

    RadioLibTime_t scanGuardA = 0;

    RadioLibTime_t scanGuardC = 50;
 
#if !RADIOLIB_GODMODE
  protected:
#endif
    PhysicalLayer* phyLayer = NULL;
    const LoRaWANBand_t* band = NULL;
 
    // a buffer that holds all LW base parameters that should persist at all times!
    uint8_t bufferPersist[RADIOLIB_LORAWAN_PERSISTENCE_BUF_SIZE] = { 0 };
 
    // a buffer that holds all LW session parameters that preferably persist, but can be afforded to get lost
    uint8_t bufferSession[RADIOLIB_LORAWAN_SESSION_BUF_SIZE] = { 0 };
 
    // a buffer shared by all uplink, downlink and join frames
    // the first 16 bytes are reserved for MIC calculation blocks
    uint8_t bufferFrame[RADIOLIB_AES128_BLOCK_SIZE + RADIOLIB_LORAWAN_MAX_PHY_PAYLOAD_SIZE] = { 0 };
    uint8_t frameLength = 0;
 
    uint8_t fOptsUp[RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN] = { 0 };
    uint8_t fOptsDown[RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN] = { 0 };
    uint8_t fOptsUpLen = 0;
    uint8_t fOptsDownLen = 0;
 
    uint16_t lwMode = RADIOLIB_LORAWAN_MODE_NONE;
    uint8_t lwClass = RADIOLIB_LORAWAN_CLASS_A;
    uint8_t sessionStatus = RADIOLIB_LORAWAN_SESSION_NONE;
 
    uint64_t joinEUI = 0;
    uint64_t devEUI = 0;
    uint8_t nwkKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
    uint8_t appKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
 
    // the following is either provided by the network server (OTAA)
    // or directly entered by the user (ABP)
    uint32_t devAddr = 0;
    uint8_t appSKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
    uint8_t fNwkSIntKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
    uint8_t sNwkSIntKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
    uint8_t nwkSEncKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
    uint8_t jSIntKey[RADIOLIB_AES128_KEY_SIZE] = { 0 };
 
    uint32_t keyCheckSum = 0;
    
    // device-specific parameters, persistent through sessions
    uint16_t devNonce = 0;
    uint32_t joinNonce = 0;
 
    // session-specific parameters
    uint8_t adrLimitExp = RADIOLIB_LORAWAN_ADR_ACK_LIMIT_EXP;
    uint8_t adrDelayExp = RADIOLIB_LORAWAN_ADR_ACK_DELAY_EXP;
    uint8_t nbTrans = 1;            // Number of allowed frame retransmissions
    uint8_t txPowerSteps = 0;
    uint8_t txPowerMax = 0;
    uint32_t fCntUp = 0;
    uint32_t aFCntDown = 0;
    uint32_t nFCntDown = 0;
    uint32_t confFCntUp = RADIOLIB_LORAWAN_FCNT_NONE;
    uint32_t confFCntDown = RADIOLIB_LORAWAN_FCNT_NONE;
    uint32_t adrFCnt = 0;
    uint32_t rxAFCnt = 0;           // Number of received downlinks
 
    // ADR is enabled by default
    bool adrEnabled = true;
 
    // duty cycle is set upon initialization and activated in regions that impose this
    bool dutyCycleEnabled = false;
    uint32_t dutyCycle = 0;
 
    // dwell time is set upon initialization and activated in regions that impose this
    uint16_t dwellTimeUp = 0;
    uint16_t dwellTimeDn = 0;
 
    RadioLibTime_t tUplink = 0;   // scheduled uplink transmission time (internal clock)
    bool uplinkScheduled = false; // set by scheduleTransmission(), cleared after the uplink
    RadioLibTime_t tDownlink = 0; // time at end of downlink reception
    RadioLibTime_t tDone = 0;     // track time spent during sendReceive
 
    // multicast groups
    MulticastGroup_t mcGroups[RADIOLIB_LORAWAN_MAX_NUM_MC_GROUPS];
 
    // enabled app/nwk packages in the Reserved FPort range
    LoRaWANPackage_t packages[RADIOLIB_LORAWAN_NUM_RESERVED_PACKAGES];
 
    // enable/disable CSMA for LoRaWAN
    bool csmaEnabled = false;
 
    // maximum number of channel hops during CSMA
    uint8_t maxChanges = RADIOLIB_LORAWAN_MAX_CHANGES_DEFAULT;
 
    // number of backoff slots to be checked after DIFS phase.
    // A random BO avoids collisions in the case where two or more nodes start the CSMA
    // process at the same time. 
    uint8_t backoffMax = RADIOLIB_LORAWAN_BACKOFF_MAX_DEFAULT;
    
    // number of CADs to estimate a clear channel
    uint8_t difsSlots = RADIOLIB_LORAWAN_DIFS_DEFAULT;
 
    // dynamic channels
    LoRaWANChannel_t dynamicChannels[2][RADIOLIB_LORAWAN_MAX_NUM_DYNAMIC_CHANNELS];
 
    // masks: which channels are defined/active; flags: which should be used next
    uint16_t channelMasks[RADIOLIB_LORAWAN_MAX_NUM_FIXED_CHANNELS / 16] = { 0 };
    uint16_t channelFlags[RADIOLIB_LORAWAN_MAX_NUM_FIXED_CHANNELS / 16] = { 0 };
 
    // currently configured channels for Tx, Rx1, Rx2, RxBC
    LoRaWANChannel_t channels[4] = { RADIOLIB_LORAWAN_CHANNEL_NONE, RADIOLIB_LORAWAN_CHANNEL_NONE,
                                     RADIOLIB_LORAWAN_CHANNEL_NONE, RADIOLIB_LORAWAN_CHANNEL_NONE };
 
    // delays between the uplink and Rx windows
    // the first field is meaningless, but is used for offsetting the Rx windows
    RadioLibTime_t rxDelays[4] = { 0, 
                                   RADIOLIB_LORAWAN_RECEIVE_DELAY_1_MS, 
                                   RADIOLIB_LORAWAN_RECEIVE_DELAY_2_MS,
                                   0 };
 
    uint32_t ledPins[4] = { RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC };
 
    // offset between Tx and Rx1 (such that Rx1 has equal or lower DR)
    uint8_t rx1DrOffset = 0;
 
    // LoRaWAN revision (1.0 vs 1.1)
    uint8_t rev = 0;
 
    // Time on Air of last uplink
    RadioLibTime_t lastToA = 0;
 
    // timestamp to measure the Rx1/2 delay (from uplink end)
    RadioLibTime_t tUplinkEnd = 0;
 
    // duration of SPI transaction for phyLayer->launchMode()
    RadioLibTime_t launchDuration = 0;
 
    // device status - battery level
    uint8_t battLevel = 0xFF;
 
    // indicates whether an uplink has MAC commands as payload
    bool isMACPayload = false;
 
    // save the selected sub-band in case this must be restored in ADR control
    uint8_t subBand = 0;
 
    // user-provided sleep callback
    SleepCb_t sleepCb = nullptr;
 
    // user-provided buffer callbacks
    BufferCb_t storePersistenceBufferCb = nullptr;
    BufferCb_t restorePersistenceBufferCb = nullptr;
    BufferCb_t storeSessionBufferCb = nullptr;
    BufferCb_t restoreSessionBufferCb = nullptr;
 
    // this will reset the device credentials, so the device starts completely new
    void clearPersistence();
 
    // trigger a save of the persistence buffer
    void savePersistenceBuffer();
 
    // load the persistence buffer from non-volatile storage.
    int16_t loadPersistenceBuffer();
 
    // setup an empty session with default parameters
    void createSession();
 
    // returns the pointer to the internal buffer that holds the LW session parameters
    void saveSessionBuffer();
 
    // fill the internal buffer that holds the LW session parameters with a supplied buffer
    int16_t loadSessionBuffer();
 
    // setup Join-Request payload
    void composeJoinRequest(uint8_t* joinRequestMsg);
 
    // extract Join-Accept payload and start a new session
    int16_t processJoinAccept(LoRaWANJoinEvent_t *joinEvent);
 
    // a join-accept can piggy-back a set of channels or channel masks
    void processCFList(const uint8_t* cfList);
 
    // check whether payload length and fport are allowed
    int16_t isValidUplink(size_t len, uint8_t fPort);
    
    // perform ADR backoff
    void adrBackoff();
 
    // create an encrypted uplink buffer, composing metadata, user data and MAC data
    // the plaintext frame payload must already be at its final position in the buffer, and is encrypted in-place
    void composeUplink(uint8_t* out, uint8_t lenIn, uint8_t fPort, bool isConfirmed);
 
    // generate and set the MIC of an uplink buffer (depends on selected channels)
    void micUplink(uint8_t* inOut, size_t lenInOut);
 
    // transmit uplink buffer on a specified channel
    int16_t transmitUplink(const LoRaWANChannel_t* chnl, uint8_t* in, uint8_t len);
 
    // handle one of the Class A receive windows with a given channel and certain timestamps
    int16_t receiveClassA(uint8_t dir, const LoRaWANChannel_t* dlChannel, uint8_t window, const RadioLibTime_t dlDelay, RadioLibTime_t tReference);
 
    // handle a Class C receive window with timeout (between Class A windows) or without (between uplinks)
    int16_t receiveClassC(RadioLibTime_t tWindowEnd = 0);
 
    // open a series of Class A (and C) downlinks
    virtual int16_t receiveDownlink();
 
    // read the downlink and check its length and DevAddr
    int16_t checkDownlink(uint8_t window, uint8_t dr);
 
    // extract downlink payload and process MAC commands
    int16_t parseDownlink(uint8_t* data, size_t* len, uint8_t window, LoRaWANEvent_t* event = NULL);
 
    // execute mac command, return the number of processed bytes for sequential processing
    bool execMacCommand(uint8_t cid, uint8_t* optIn, uint8_t lenIn);
    bool execMacCommand(uint8_t cid, uint8_t* optIn, uint8_t lenIn, uint8_t* optOut);
 
    // possible override for additional MAC commands that are not in the base specification
    virtual bool derivedMacHandler(uint8_t cid, uint8_t* optIn, uint8_t lenIn, uint8_t* optOut);
 
    // pre-process a (set of) LinkAdrReq commands into one super-channel-mask + Tx/Dr/NbTrans fields
    void preprocessMacLinkAdr(uint8_t* mPtr, uint8_t cLen, uint8_t* mAdrOpt);
 
    // post-process a (set of) LinkAdrAns commands depending on LoRaWAN version
    void postprocessMacLinkAdr(uint8_t* ack, uint8_t cLen);
 
    // get the properties of a MAC command given a certain command ID
    int16_t getMacCommand(uint8_t cid, LoRaWANMacCommand_t* cmd);
 
    // possible override for additional MAC commands that are not in the base specification
    virtual int16_t derivedMacFinder(uint8_t cid, LoRaWANMacCommand_t* cmd);
 
    // get the length of a certain MAC command in a specific direction (up/down)
    // if inclusive is true, add one for the CID byte
    // include payload in case the MAC command has a dynamic length
    virtual int16_t getMacLen(uint8_t cid, uint8_t* len, uint8_t dir, bool inclusive = false, uint8_t* payload = NULL);
 
    // find out of a MAC command should persist destruction
    // in uplink direction, some commands must persist if no downlink is received
    // in downlink direction, the user-accessible MAC commands remain available for retrieval
    bool isPersistentMacCommand(uint8_t cid, uint8_t dir);
 
    // push MAC command to queue, done by copy
    int16_t pushMacCommand(uint8_t cid, const uint8_t* cOcts, uint8_t* out, uint8_t* lenOut, uint8_t dir);
 
    // retrieve the payload of a certain MAC command, if present in the buffer
    int16_t getMacPayload(uint8_t cid, const uint8_t* in, uint8_t lenIn, uint8_t* out, uint8_t dir);
 
    // delete a specific MAC command from queue, indicated by the command ID
    int16_t deleteMacCommand(uint8_t cid, uint8_t* inOut, uint8_t* lenInOut, uint8_t dir);
 
    // clear a MAC buffer, possible retaining persistent MAC commands
    void clearMacCommands(uint8_t* inOut, uint8_t* lenInOut, uint8_t dir);
 
    // configure the common physical layer properties (frequency, sync word etc.)
    int16_t setPhyProperties(const LoRaWANChannel_t* chnl, uint8_t dir, int8_t pwr, size_t pre = 0);
 
    // Performs CSMA as per LoRa Alliance Technical Recommendation 13 (TR-013).
    bool csmaChannelClear(uint8_t difs, uint8_t numBackoff);
 
    // perform a single CAD operation for the under SF/CH combination. Returns either busy or otherwise.
    bool cadChannelClear();
 
    // enable all default channels on top of the current channels
    void enableDefaultChannels(bool addDynamic = false);
 
    // calculate which channels are available given the current datarate
    // returns true if there is any such channel, false otherwise
    bool calculateChannelFlags();
 
    // select a set of random TX/RX channels for up- and downlink
    int16_t selectChannels();
 
    // get the properties of the first active multicast session, if any
    uint32_t getMulticastFrequency();
    uint8_t getMulticastDatarate();
    bool isMulticastDevAddr(uint32_t devAddr, uint8_t* mcGroupId);
 
    // method to generate message integrity code
    uint32_t generateMIC(const uint8_t* msg, size_t len, uint8_t* key);
 
    // method to verify message integrity code
    // it assumes that the MIC is the last 4 bytes of the message
    bool verifyMIC(uint8_t* msg, size_t len, uint8_t* key);
 
    // function to encrypt and decrypt payloads (regular uplink/downlink)
    void processAES(const uint8_t* in, size_t len, uint8_t* key, uint8_t* out, uint32_t addr, uint32_t fCnt, uint8_t dir, uint8_t ctrId, bool counter);
 
    // common function add an app/nwk package, used by both addAppPackage and addNwkPackage
    int16_t addPackage(uint8_t fPort, bool isApp);
 
    // function that allows sleeping via user-provided callback
    void smartDelayUntil(RadioLibTime_t waitEnd, bool wfi);
 
    // checksum over a byte array, XOR-ing sizeof(T)-byte big-endian words
    template<typename T>
    static T checkSum(const uint8_t* buff, size_t size);
 
    // check the integrity of a buffer using a 32-bit checksum located in the last four bytes of the buffer
    static int16_t checkBufferCommon(const uint8_t *buffer, uint16_t size);
 
    // network-to-host conversion method - takes data from network packet and converts it to the host endians
    template<typename T>
    static T ntoh(const uint8_t* buff, size_t size = 0);
 
    // host-to-network conversion method - takes data from host variable and and converts it to network packet endians
    template<typename T>
    static void hton(uint8_t* buff, T val, size_t size = 0);
};
 
template<typename T>
T LoRaWANNode::ntoh(const uint8_t* buff, size_t size) {
  const uint8_t* buffPtr = buff;
  size_t targetSize = sizeof(T);
  if(size != 0) {
    targetSize = size;
  }
  T res = 0;
  for(size_t i = 0; i < targetSize; i++) {
    res |= (uint32_t)(*(buffPtr++)) << 8*i;
  }
  return(res);
}
 
template<typename T>
void LoRaWANNode::hton(uint8_t* buff, T val, size_t size) {
  uint8_t* buffPtr = buff;
  size_t targetSize = sizeof(T);
  if(size != 0) {
    targetSize = size;
  }
  for(size_t i = 0; i < targetSize; i++) {
    *(buffPtr++) = val >> 8*i;
  }
}
 
template<typename T>
T LoRaWANNode::checkSum(const uint8_t* buff, size_t size) {
  T result = 0;
  for(size_t i = 0; i < size; i += sizeof(T)) {
    T word = 0;
    for(size_t j = 0; j < sizeof(T); j++) {
      word <<= 8;
      if(i + j < size) {
        word |= buff[i + j];
      }
    }
    result ^= word;
  }
  return(result);
}
 
#endif