diff --git a/examples/LoRaWAN/LoRaWAN_Reference/LoRaWAN_Reference.ino b/examples/LoRaWAN/LoRaWAN_Reference/LoRaWAN_Reference.ino
index 6cfe5dc6..54e0c2be 100644
--- a/examples/LoRaWAN/LoRaWAN_Reference/LoRaWAN_Reference.ino
+++ b/examples/LoRaWAN/LoRaWAN_Reference/LoRaWAN_Reference.ino
@@ -114,8 +114,8 @@ void loop() {
   // and also request the LinkCheck and DeviceTime MAC commands
   if(fcntUp % 64 == 0) {
     Serial.println(F("[LoRaWAN] Requesting LinkCheck and DeviceTime"));
-    node.sendMacCommandReq(RADIOLIB_LW_MAC_LINK_CHECK);
-    node.sendMacCommandReq(RADIOLIB_LW_MAC_DEVICE_TIME);
+    node.sendMacCommandReq(RADIOLIB_LORAWAN_MAC_LINK_CHECK);
+    node.sendMacCommandReq(RADIOLIB_LORAWAN_MAC_DEVICE_TIME);
     state = node.sendReceive(uplinkPayload, sizeof(uplinkPayload), Port, downlinkPayload, &downlinkSize, true, &uplinkDetails, &downlinkDetails); 
   } else {
     state = node.sendReceive(uplinkPayload, sizeof(uplinkPayload), Port, downlinkPayload, &downlinkSize);    
diff --git a/src/protocols/LoRaWAN/LoRaWAN.cpp b/src/protocols/LoRaWAN/LoRaWAN.cpp
index c28a226e..deab8209 100644
--- a/src/protocols/LoRaWAN/LoRaWAN.cpp
+++ b/src/protocols/LoRaWAN/LoRaWAN.cpp
@@ -46,7 +46,7 @@ void LoRaWANNode::setCSMA(uint8_t backoffMax, uint8_t difsSlots, bool enableCSMA
 
 void LoRaWANNode::clearNonces() {
   // clear & set all the device credentials
-  memset(this->bufferNonces, 0, RADIOLIB_LW_NONCES_BUF_SIZE);
+  memset(this->bufferNonces, 0, RADIOLIB_LORAWAN_NONCES_BUF_SIZE);
   this->keyCheckSum = 0;
   this->devNonce = 0;
   this->joinNonce = 0;
@@ -54,17 +54,17 @@ void LoRaWANNode::clearNonces() {
 }
 
 void LoRaWANNode::clearSession() {
-  memset(this->bufferSession, 0, RADIOLIB_LW_SESSION_BUF_SIZE);
+  memset(this->bufferSession, 0, RADIOLIB_LORAWAN_SESSION_BUF_SIZE);
   memset(&(this->commandsUp), 0, sizeof(LoRaWANMacCommandQueue_t));
   memset(&(this->commandsDown), 0, sizeof(LoRaWANMacCommandQueue_t));
-  this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE] = (uint8_t)false;
+  this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE] = (uint8_t)false;
   this->isActive = false;
 }
 
 uint8_t* LoRaWANNode::getBufferNonces() {
   // generate the signature of the Nonces buffer, and store it in the last two bytes of the Nonces buffer
-  uint16_t signature = LoRaWANNode::checkSum16(this->bufferNonces, RADIOLIB_LW_NONCES_BUF_SIZE - 2);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_SIGNATURE], signature);
+  uint16_t signature = LoRaWANNode::checkSum16(this->bufferNonces, RADIOLIB_LORAWAN_NONCES_BUF_SIZE - 2);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_SIGNATURE], signature);
 
   return(this->bufferNonces);
 }
@@ -75,31 +75,31 @@ int16_t LoRaWANNode::setBufferNonces(uint8_t* persistentBuffer) {
     return(RADIOLIB_ERR_NONE);
   }
 
-  int16_t state = LoRaWANNode::checkBufferCommon(persistentBuffer, RADIOLIB_LW_NONCES_BUF_SIZE);
+  int16_t state = LoRaWANNode::checkBufferCommon(persistentBuffer, RADIOLIB_LORAWAN_NONCES_BUF_SIZE);
   RADIOLIB_ASSERT(state);
 
-  bool isSameKeys = LoRaWANNode::ntoh<uint16_t>(&persistentBuffer[RADIOLIB_LW_NONCES_CHECKSUM]) == this->keyCheckSum;
-  bool isSameMode = LoRaWANNode::ntoh<uint16_t>(&persistentBuffer[RADIOLIB_LW_NONCES_MODE]) == this->lwMode;
-  bool isSameClass = LoRaWANNode::ntoh<uint8_t>(&persistentBuffer[RADIOLIB_LW_NONCES_CLASS]) == this->lwClass;
-  bool isSamePlan  = LoRaWANNode::ntoh<uint8_t>(&persistentBuffer[RADIOLIB_LW_NONCES_PLAN]) == this->band->bandNum;
+  bool isSameKeys = LoRaWANNode::ntoh<uint16_t>(&persistentBuffer[RADIOLIB_LORAWAN_NONCES_CHECKSUM]) == this->keyCheckSum;
+  bool isSameMode = LoRaWANNode::ntoh<uint16_t>(&persistentBuffer[RADIOLIB_LORAWAN_NONCES_MODE]) == this->lwMode;
+  bool isSameClass = LoRaWANNode::ntoh<uint8_t>(&persistentBuffer[RADIOLIB_LORAWAN_NONCES_CLASS]) == this->lwClass;
+  bool isSamePlan  = LoRaWANNode::ntoh<uint8_t>(&persistentBuffer[RADIOLIB_LORAWAN_NONCES_PLAN]) == this->band->bandNum;
 
   // check if Nonces buffer matches the current configuration
   if(!isSameKeys || !isSameMode || !isSameClass || !isSamePlan) {
     // if configuration did not match, discard whatever is currently in the buffers and start fresh
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Configuration mismatch (keys: %d, mode: %d, class: %d, plan: %d)", isSameKeys, isSameMode, isSameClass, isSamePlan);
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Discarding the Nonces buffer:");
-    RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(persistentBuffer, RADIOLIB_LW_NONCES_BUF_SIZE);
+    RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(persistentBuffer, RADIOLIB_LORAWAN_NONCES_BUF_SIZE);
     return(RADIOLIB_LORAWAN_NONCES_DISCARDED);
   }
 
   // copy the whole buffer over
-  memcpy(this->bufferNonces, persistentBuffer, RADIOLIB_LW_NONCES_BUF_SIZE);
+  memcpy(this->bufferNonces, persistentBuffer, RADIOLIB_LORAWAN_NONCES_BUF_SIZE);
 
-  this->devNonce  = LoRaWANNode::ntoh<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_DEV_NONCE]);
-  this->joinNonce = LoRaWANNode::ntoh<uint32_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_JOIN_NONCE], 3);
+  this->devNonce  = LoRaWANNode::ntoh<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_DEV_NONCE]);
+  this->joinNonce = LoRaWANNode::ntoh<uint32_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_JOIN_NONCE], 3);
 
   // revert to inactive as long as no session is restored
-  this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE] = (uint8_t)false;
+  this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE] = (uint8_t)false;
   this->isActive = false;
 
   return(state);
@@ -107,19 +107,19 @@ int16_t LoRaWANNode::setBufferNonces(uint8_t* persistentBuffer) {
 
 uint8_t* LoRaWANNode::getBufferSession() {
   // store all frame counters
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_A_FCNT_DOWN], this->aFCntDown);
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_N_FCNT_DOWN], this->nFCntDown);
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_CONF_FCNT_UP], this->confFCntUp);
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_CONF_FCNT_DOWN], this->confFCntDown);
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_ADR_FCNT], this->adrFCnt);
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_FCNT_UP], this->fCntUp);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_A_FCNT_DOWN], this->aFCntDown);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_N_FCNT_DOWN], this->nFCntDown);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_CONF_FCNT_UP], this->confFCntUp);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_CONF_FCNT_DOWN], this->confFCntDown);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_ADR_FCNT], this->adrFCnt);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_FCNT_UP], this->fCntUp);
 
   // save the current uplink MAC command queue
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_MAC_QUEUE_UL], &this->commandsUp, sizeof(LoRaWANMacCommandQueue_t));
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_MAC_QUEUE_UL], &this->commandsUp, sizeof(LoRaWANMacCommandQueue_t));
 
   // generate the signature of the Session buffer, and store it in the last two bytes of the Session buffer
-  uint16_t signature = LoRaWANNode::checkSum16(this->bufferSession, RADIOLIB_LW_SESSION_BUF_SIZE - 2);
-  LoRaWANNode::hton<uint16_t>(&this->bufferSession[RADIOLIB_LW_SESSION_SIGNATURE], signature);
+  uint16_t signature = LoRaWANNode::checkSum16(this->bufferSession, RADIOLIB_LORAWAN_SESSION_BUF_SIZE - 2);
+  LoRaWANNode::hton<uint16_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_SIGNATURE], signature);
   
   return(this->bufferSession);
 }
@@ -130,48 +130,48 @@ int16_t LoRaWANNode::setBufferSession(uint8_t* persistentBuffer) {
     return(RADIOLIB_ERR_NONE);
   }
 
-  int16_t state = LoRaWANNode::checkBufferCommon(persistentBuffer, RADIOLIB_LW_SESSION_BUF_SIZE);
+  int16_t state = LoRaWANNode::checkBufferCommon(persistentBuffer, RADIOLIB_LORAWAN_SESSION_BUF_SIZE);
   RADIOLIB_ASSERT(state);
 
   // the Nonces buffer holds a checksum signature - compare this to the signature that is in the session buffer
-  uint16_t signatureNonces = LoRaWANNode::ntoh<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_SIGNATURE]);
-  uint16_t signatureInSession = LoRaWANNode::ntoh<uint16_t>(&persistentBuffer[RADIOLIB_LW_SESSION_NONCES_SIGNATURE]);
+  uint16_t signatureNonces = LoRaWANNode::ntoh<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_SIGNATURE]);
+  uint16_t signatureInSession = LoRaWANNode::ntoh<uint16_t>(&persistentBuffer[RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE]);
   if(signatureNonces != signatureInSession) {
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("The supplied session buffer does not match the Nonces buffer");
     return(RADIOLIB_LORAWAN_SESSION_DISCARDED);
   }
 
   // copy the whole buffer over
-  memcpy(this->bufferSession, persistentBuffer, RADIOLIB_LW_SESSION_BUF_SIZE);
+  memcpy(this->bufferSession, persistentBuffer, RADIOLIB_LORAWAN_SESSION_BUF_SIZE);
 
   //// this code can be used in case breaking chances must be caught:
-  // uint8_t nvm_table_version = this->bufferNonces[RADIOLIB_LW_NONCES_VERSION];
-  // if (RADIOLIB_LW_NONCES_VERSION_VAL > nvm_table_version) {
+  // uint8_t nvm_table_version = this->bufferNonces[RADIOLIB_LORAWAN_NONCES_VERSION];
+  // if (RADIOLIB_LORAWAN_NONCES_VERSION_VAL > nvm_table_version) {
   //  // set default values for variables that are new or something
   // }
 
   // pull all authentication keys from persistent storage
-  this->devAddr = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_DEV_ADDR]);
-  memcpy(this->appSKey,     &this->bufferSession[RADIOLIB_LW_SESSION_APP_SKEY],      RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(this->nwkSEncKey,  &this->bufferSession[RADIOLIB_LW_SESSION_NWK_SENC_KEY],  RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(this->fNwkSIntKey, &this->bufferSession[RADIOLIB_LW_SESSION_FNWK_SINT_KEY], RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(this->sNwkSIntKey, &this->bufferSession[RADIOLIB_LW_SESSION_SNWK_SINT_KEY], RADIOLIB_AES128_BLOCK_SIZE);
+  this->devAddr = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_DEV_ADDR]);
+  memcpy(this->appSKey,     &this->bufferSession[RADIOLIB_LORAWAN_SESSION_APP_SKEY],      RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(this->nwkSEncKey,  &this->bufferSession[RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY],  RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(this->fNwkSIntKey, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY], RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(this->sNwkSIntKey, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY], RADIOLIB_AES128_BLOCK_SIZE);
 
   // restore session parameters
-  this->rev          = LoRaWANNode::ntoh<uint8_t>(&this->bufferSession[RADIOLIB_LW_SESSION_VERSION]);
+  this->rev          = LoRaWANNode::ntoh<uint8_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_VERSION]);
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("LoRaWAN session: v1.%d", this->rev);
-  this->homeNetId    = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_HOMENET_ID]);
-  this->aFCntDown    = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_A_FCNT_DOWN]);
-  this->nFCntDown    = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_N_FCNT_DOWN]);
-  this->confFCntUp   = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_CONF_FCNT_UP]);
-  this->confFCntDown = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_CONF_FCNT_DOWN]);
-  this->adrFCnt      = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_ADR_FCNT]);
-  this->fCntUp       = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_FCNT_UP]);
+  this->homeNetId    = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_HOMENET_ID]);
+  this->aFCntDown    = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_A_FCNT_DOWN]);
+  this->nFCntDown    = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_N_FCNT_DOWN]);
+  this->confFCntUp   = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_CONF_FCNT_UP]);
+  this->confFCntDown = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_CONF_FCNT_DOWN]);
+  this->adrFCnt      = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_ADR_FCNT]);
+  this->fCntUp       = LoRaWANNode::ntoh<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_FCNT_UP]);
   
   // restore the complete MAC state
 
   // all-zero buffer used for checking if MAC commands are set
-  uint8_t bufferZeroes[RADIOLIB_LW_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
+  uint8_t bufferZeroes[RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
 
   LoRaWANMacCommand_t cmd = {
     .cid = 0,
@@ -182,17 +182,17 @@ int16_t LoRaWANNode::setBufferSession(uint8_t* persistentBuffer) {
 
   // for dynamic bands, first restore the defined channels before restoring ADR
   // this is because the ADR command acts as a mask for the enabled channels
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     // setup the default channels
     state = this->setupChannelsDyn();
     RADIOLIB_ASSERT(state);
 
     // restore the session channels
-    uint8_t *startChannelsUp = &this->bufferSession[RADIOLIB_LW_SESSION_UL_CHANNELS];
+    uint8_t *startChannelsUp = &this->bufferSession[RADIOLIB_LORAWAN_SESSION_UL_CHANNELS];
 
-    cmd.cid = RADIOLIB_LW_MAC_NEW_CHANNEL;
-    for(int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-      cmd.len = MacTable[RADIOLIB_LW_MAC_NEW_CHANNEL].lenDn;
+    cmd.cid = RADIOLIB_LORAWAN_MAC_NEW_CHANNEL;
+    for(int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+      cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_NEW_CHANNEL].lenDn;
       memcpy(cmd.payload, startChannelsUp + (i * cmd.len), cmd.len);
       if(memcmp(cmd.payload, bufferZeroes, cmd.len) != 0) { // only execute if it is not all zeroes
         cmd.repeat = 1;
@@ -200,11 +200,11 @@ int16_t LoRaWANNode::setBufferSession(uint8_t* persistentBuffer) {
       }
     }
 
-    uint8_t *startChannelsDown = &this->bufferSession[RADIOLIB_LW_SESSION_DL_CHANNELS];
+    uint8_t *startChannelsDown = &this->bufferSession[RADIOLIB_LORAWAN_SESSION_DL_CHANNELS];
 
-    cmd.cid = RADIOLIB_LW_MAC_DL_CHANNEL;
-    for(int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-      cmd.len = MacTable[RADIOLIB_LW_MAC_DL_CHANNEL].lenDn;
+    cmd.cid = RADIOLIB_LORAWAN_MAC_DL_CHANNEL;
+    for(int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+      cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_DL_CHANNEL].lenDn;
       memcpy(cmd.payload, startChannelsDown + (i * cmd.len), cmd.len);
       if(memcmp(cmd.payload, bufferZeroes, cmd.len) != 0) { // only execute if it is not all zeroes
         (void)execMacCommand(&cmd);
@@ -212,29 +212,29 @@ int16_t LoRaWANNode::setBufferSession(uint8_t* persistentBuffer) {
     }
   }
 
-  cmd.cid = RADIOLIB_LW_MAC_TX_PARAM_SETUP,
-  cmd.len = MacTable[RADIOLIB_LW_MAC_TX_PARAM_SETUP].lenDn,
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_TX_PARAM_SETUP], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP,
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP].lenDn,
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_TX_PARAM_SETUP], cmd.len);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_LINK_ADR;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn;
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_LINK_ADR], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_LINK_ADR;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn;
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_LINK_ADR], cmd.len);
   (void)execMacCommand(&cmd);
 
   // for fixed bands, first restore ADR, then the defined channels
-  if(this->band->bandType == RADIOLIB_LW_BAND_FIXED) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_FIXED) {
     // setup the default channels
     state = this->setupChannelsFix(this->subBand);
     RADIOLIB_ASSERT(state);
 
     // restore the session channels
-    uint8_t *startMACpayload = &this->bufferSession[RADIOLIB_LW_SESSION_UL_CHANNELS];
+    uint8_t *startMACpayload = &this->bufferSession[RADIOLIB_LORAWAN_SESSION_UL_CHANNELS];
     
     // there are at most 8 channel masks present
-    cmd.cid = RADIOLIB_LW_MAC_LINK_ADR;
+    cmd.cid = RADIOLIB_LORAWAN_MAC_LINK_ADR;
     for(int i = 0; i < 8; i++) {
-      cmd.len = MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn;
+      cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn;
       memcpy(cmd.payload, startMACpayload + (i * cmd.len), cmd.len);
       // there COULD, according to spec, be an all zeroes ADR command - meh
       if(memcmp(cmd.payload, bufferZeroes, cmd.len) == 0) {
@@ -246,36 +246,36 @@ int16_t LoRaWANNode::setBufferSession(uint8_t* persistentBuffer) {
 
   }
 
-  cmd.cid = RADIOLIB_LW_MAC_DUTY_CYCLE;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_DUTY_CYCLE].lenDn;
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_DUTY_CYCLE], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_DUTY_CYCLE;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_DUTY_CYCLE].lenDn;
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_DUTY_CYCLE], cmd.len);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_RX_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_RX_PARAM_SETUP].lenDn;
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_RX_PARAM_SETUP], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP].lenDn;
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_RX_PARAM_SETUP], cmd.len);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_RX_TIMING_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_RX_TIMING_SETUP].lenDn;
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_RX_TIMING_SETUP], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP].lenDn;
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_RX_TIMING_SETUP], cmd.len);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_ADR_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_ADR_PARAM_SETUP].lenDn;
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_ADR_PARAM_SETUP], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP].lenDn;
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_ADR_PARAM_SETUP], cmd.len);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP].lenDn;
-  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LW_SESSION_REJOIN_PARAM_SETUP], cmd.len);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP].lenDn;
+  memcpy(cmd.payload, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_REJOIN_PARAM_SETUP], cmd.len);
   (void)execMacCommand(&cmd);
 
   // copy uplink MAC command queue back in place
-  memcpy(&this->commandsUp, &this->bufferSession[RADIOLIB_LW_SESSION_MAC_QUEUE_UL], sizeof(LoRaWANMacCommandQueue_t));
+  memcpy(&this->commandsUp, &this->bufferSession[RADIOLIB_LORAWAN_SESSION_MAC_QUEUE_UL], sizeof(LoRaWANMacCommandQueue_t));
 
   // as both the Nonces and session are restored, revert to active session
-  this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE] = (uint8_t)true;
+  this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE] = (uint8_t)true;
 
   return(state);
 }
@@ -304,46 +304,46 @@ int16_t LoRaWANNode::checkBufferCommon(uint8_t *buffer, uint16_t size) {
 
 void LoRaWANNode::activateCommon(uint8_t initialDr) {
   uint8_t drUp = 0;
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     // if join datarate is user-specified and valid, select that value
-    if(initialDr != RADIOLIB_LW_DATA_RATE_UNUSED) {
+    if(initialDr != RADIOLIB_LORAWAN_DATA_RATE_UNUSED) {
       if(initialDr >= this->band->txFreqs[0].drMin && initialDr <= this->band->txFreqs[0].drMax) {
         drUp = initialDr;
       } else {
         // if there is no channel that allowed the user-specified datarate, revert to default datarate
         RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Datarate %d is not valid - using default", initialDr);
-        initialDr = RADIOLIB_LW_DATA_RATE_UNUSED;
+        initialDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED;
       }
     }
     
     // if there is no (channel that allowed the) user-specified datarate, use a default datarate
     // we use the floor of the average datarate of the first default channel
-    if(initialDr == RADIOLIB_LW_DATA_RATE_UNUSED) {
+    if(initialDr == RADIOLIB_LORAWAN_DATA_RATE_UNUSED) {
       drUp = (this->band->txFreqs[0].drMin + this->band->txFreqs[0].drMax) / 2;
     }
 
   } else {
     // if the user specified a certain datarate, check if any of the configured channels allows it
-    if(initialDr != RADIOLIB_LW_DATA_RATE_UNUSED) {
+    if(initialDr != RADIOLIB_LORAWAN_DATA_RATE_UNUSED) {
       uint8_t i = 0; 
-      for(; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-        if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled) {
-          if(initialDr >= this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMin
-            && initialDr <= this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMax) {
+      for(; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+        if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled) {
+          if(initialDr >= this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMin
+            && initialDr <= this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMax) {
               break;
           }
         }
       }
       // if there is no channel that allowed the user-specified datarate, revert to default datarate
-      if(i == RADIOLIB_LW_NUM_AVAILABLE_CHANNELS) {
+      if(i == RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS) {
         RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Datarate %d is not valid - using default", initialDr);
-        initialDr = RADIOLIB_LW_DATA_RATE_UNUSED;
+        initialDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED;
       }
     }
 
     // if there is no (channel that allowed the) user-specified datarate, use a default datarate
     // we use the join-request datarate for one of the available channels
-    if(initialDr == RADIOLIB_LW_DATA_RATE_UNUSED) {
+    if(initialDr == RADIOLIB_LORAWAN_DATA_RATE_UNUSED) {
       // randomly select one of 8 or 9 channels and find corresponding datarate
       uint8_t numChannels = this->band->numTxSpans == 1 ? 8 : 9;
       uint8_t rand = this->phyLayer->random(numChannels) + 1;     // range 1-8 or 1-9
@@ -357,9 +357,9 @@ void LoRaWANNode::activateCommon(uint8_t initialDr) {
   }
 
   LoRaWANMacCommand_t cmd = {
-    .cid = RADIOLIB_LW_MAC_LINK_ADR,
+    .cid = RADIOLIB_LORAWAN_MAC_LINK_ADR,
     .payload = { 0 }, 
-    .len = MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn,
+    .len = MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn,
     .repeat = 0,
   };
   cmd.payload[0]  = (drUp << 4);      // set uplink datarate
@@ -367,8 +367,8 @@ void LoRaWANNode::activateCommon(uint8_t initialDr) {
   cmd.payload[3]  = (1 << 7);         // set the RFU bit, which means that the channel mask gets ignored
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_DUTY_CYCLE;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_DUTY_CYCLE].lenDn;
+  cmd.cid = RADIOLIB_LORAWAN_MAC_DUTY_CYCLE;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_DUTY_CYCLE].lenDn;
   uint8_t maxDCyclePower;
   switch(this->band->dutyCycle) {
     case(0):
@@ -387,21 +387,21 @@ void LoRaWANNode::activateCommon(uint8_t initialDr) {
   cmd.payload[0]  = maxDCyclePower;
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_RX_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_RX_PARAM_SETUP].lenDn;
-  cmd.payload[0]  = (RADIOLIB_LW_RX1_DR_OFFSET << 4);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP].lenDn;
+  cmd.payload[0]  = (RADIOLIB_LORAWAN_RX1_DR_OFFSET << 4);
   cmd.payload[0] |= this->rx2.drMax; // may be set by user, otherwise band's default upon initialization
   uint32_t rx2Freq = uint32_t(this->rx2.freq * 10000);
   LoRaWANNode::hton<uint32_t>(&cmd.payload[1], rx2Freq, 3);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_RX_TIMING_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_RX_TIMING_SETUP].lenDn;
-  cmd.payload[0]  = (RADIOLIB_LW_RECEIVE_DELAY_1_MS / 1000);
+  cmd.cid = RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP].lenDn;
+  cmd.payload[0]  = (RADIOLIB_LORAWAN_RECEIVE_DELAY_1_MS / 1000);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_TX_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_TX_PARAM_SETUP].lenDn;
+  cmd.cid = RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP].lenDn;
   cmd.payload[0]  = (this->band->dwellTimeDn > 0 ? 1 : 0) << 5;
   cmd.payload[0] |= (this->band->dwellTimeUp > 0 ? 1 : 0) << 4;
   uint8_t maxEIRPRaw;
@@ -428,16 +428,16 @@ void LoRaWANNode::activateCommon(uint8_t initialDr) {
   cmd.payload[0] |= maxEIRPRaw;
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_ADR_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_ADR_PARAM_SETUP].lenDn;
-  cmd.payload[0]  = (RADIOLIB_LW_ADR_ACK_LIMIT_EXP << 4);
-  cmd.payload[0] |= RADIOLIB_LW_ADR_ACK_DELAY_EXP;
+  cmd.cid = RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP].lenDn;
+  cmd.payload[0]  = (RADIOLIB_LORAWAN_ADR_ACK_LIMIT_EXP << 4);
+  cmd.payload[0] |= RADIOLIB_LORAWAN_ADR_ACK_DELAY_EXP;
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP].lenDn;
-  cmd.payload[0]  = (RADIOLIB_LW_REJOIN_MAX_TIME_N << 4);
-  cmd.payload[0] |= RADIOLIB_LW_REJOIN_MAX_COUNT_N;
+  cmd.cid = RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP].lenDn;
+  cmd.payload[0]  = (RADIOLIB_LORAWAN_REJOIN_MAX_TIME_N << 4);
+  cmd.payload[0] |= RADIOLIB_LORAWAN_REJOIN_MAX_COUNT_N;
   (void)execMacCommand(&cmd);
 }
 
@@ -454,8 +454,8 @@ void LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKey,
   this->keyCheckSum ^= LoRaWANNode::checkSum16(appKey, 16);
 
   this->clearNonces();
-  this->lwMode = RADIOLIB_LW_MODE_OTAA;
-  this->lwClass = RADIOLIB_LW_CLASS_A;
+  this->lwMode = RADIOLIB_LORAWAN_MODE_OTAA;
+  this->lwClass = RADIOLIB_LORAWAN_CLASS_A;
 }
 
 int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent) {
@@ -464,7 +464,7 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
     // already activated, don't do anything
     return(RADIOLIB_ERR_NONE);
   }
-  if(this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE]) {
+  if(this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE]) {
     // session restored but not yet activated - do so now
     this->isActive = true;
     return(RADIOLIB_LORAWAN_SESSION_RESTORED);
@@ -483,7 +483,7 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   }
 
   // setup join-request uplink/downlink frequencies and datarates
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     state = this->setupChannelsDyn(true);
   } else {
     state = this->setupChannelsFix(this->subBand);
@@ -492,8 +492,8 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
 
   // on fixed bands, the join-datarate is specified per specification
   // therefore, we ignore the value that was specified by the user
-  if(this->band->bandType == RADIOLIB_LW_BAND_FIXED) {
-    joinDr = RADIOLIB_LW_DATA_RATE_UNUSED;
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_FIXED) {
+    joinDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED;
   }
   // setup all MAC properties to default values
   this->activateCommon(joinDr);
@@ -503,51 +503,51 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   RADIOLIB_ASSERT(state);
 
   // set the physical layer configuration for uplink
-  state = this->setPhyProperties(RADIOLIB_LW_CHANNEL_DIR_UPLINK);
+  state = this->setPhyProperties(RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK);
   RADIOLIB_ASSERT(state);
 
   // copy devNonce currently in use
   uint16_t devNonceUsed = this->devNonce;
 
   // build the join-request message
-  uint8_t joinRequestMsg[RADIOLIB_LW_JOIN_REQUEST_LEN];
+  uint8_t joinRequestMsg[RADIOLIB_LORAWAN_JOIN_REQUEST_LEN];
   
   // set the packet fields
-  joinRequestMsg[0] = RADIOLIB_LW_MHDR_MTYPE_JOIN_REQUEST | RADIOLIB_LW_MHDR_MAJOR_R1;
-  LoRaWANNode::hton<uint64_t>(&joinRequestMsg[RADIOLIB_LW_JOIN_REQUEST_JOIN_EUI_POS], this->joinEUI);
-  LoRaWANNode::hton<uint64_t>(&joinRequestMsg[RADIOLIB_LW_JOIN_REQUEST_DEV_EUI_POS], this->devEUI);
-  LoRaWANNode::hton<uint16_t>(&joinRequestMsg[RADIOLIB_LW_JOIN_REQUEST_DEV_NONCE_POS], devNonceUsed);
+  joinRequestMsg[0] = RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_REQUEST | RADIOLIB_LORAWAN_MHDR_MAJOR_R1;
+  LoRaWANNode::hton<uint64_t>(&joinRequestMsg[RADIOLIB_LORAWAN_JOIN_REQUEST_JOIN_EUI_POS], this->joinEUI);
+  LoRaWANNode::hton<uint64_t>(&joinRequestMsg[RADIOLIB_LORAWAN_JOIN_REQUEST_DEV_EUI_POS], this->devEUI);
+  LoRaWANNode::hton<uint16_t>(&joinRequestMsg[RADIOLIB_LORAWAN_JOIN_REQUEST_DEV_NONCE_POS], devNonceUsed);
 
   // add the authentication code
-  uint32_t mic = this->generateMIC(joinRequestMsg, RADIOLIB_LW_JOIN_REQUEST_LEN - sizeof(uint32_t), this->nwkKey);
-  LoRaWANNode::hton<uint32_t>(&joinRequestMsg[RADIOLIB_LW_JOIN_REQUEST_LEN - sizeof(uint32_t)], mic);
+  uint32_t mic = this->generateMIC(joinRequestMsg, RADIOLIB_LORAWAN_JOIN_REQUEST_LEN - sizeof(uint32_t), this->nwkKey);
+  LoRaWANNode::hton<uint32_t>(&joinRequestMsg[RADIOLIB_LORAWAN_JOIN_REQUEST_LEN - sizeof(uint32_t)], mic);
 
   // send it
   Module* mod = this->phyLayer->getMod();
-  state = this->phyLayer->transmit(joinRequestMsg, RADIOLIB_LW_JOIN_REQUEST_LEN);
+  state = this->phyLayer->transmit(joinRequestMsg, RADIOLIB_LORAWAN_JOIN_REQUEST_LEN);
   this->rxDelayStart = mod->hal->millis();
   RADIOLIB_ASSERT(state);
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Join-request sent <-- Rx Delay start");
 
   // join-request successfully sent, so increase & save devNonce
   this->devNonce += 1;
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_DEV_NONCE], this->devNonce);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_DEV_NONCE], this->devNonce);
 
   // configure Rx delay for join-accept message - these are re-configured once a valid join-request is received
-  this->rxDelays[0] = RADIOLIB_LW_JOIN_ACCEPT_DELAY_1_MS;
-  this->rxDelays[1] = RADIOLIB_LW_JOIN_ACCEPT_DELAY_2_MS;
+  this->rxDelays[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_DELAY_1_MS;
+  this->rxDelays[1] = RADIOLIB_LORAWAN_JOIN_ACCEPT_DELAY_2_MS;
 
   // handle Rx1 and Rx2 windows - returns RADIOLIB_ERR_NONE if a downlink is received
   state = downlinkCommon();
   RADIOLIB_ASSERT(state);
 
   // build the buffer for the reply data
-  uint8_t joinAcceptMsgEnc[RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN];
+  uint8_t joinAcceptMsgEnc[RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN];
 
   // check received length
   size_t lenRx = this->phyLayer->getPacketLength(true);
-  if((lenRx != RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN) && (lenRx != RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN - RADIOLIB_LW_JOIN_ACCEPT_CFLIST_LEN)) {
-    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("joinAccept reply length mismatch, expected %dB got %luB", RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN, lenRx);
+  if((lenRx != RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN) && (lenRx != RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN - RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_LEN)) {
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("joinAccept reply length mismatch, expected %dB got %luB", RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN, lenRx);
     return(RADIOLIB_ERR_DOWNLINK_MALFORMED);
   }
 
@@ -560,24 +560,24 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   }
 
   // check reply message type
-  if((joinAcceptMsgEnc[0] & RADIOLIB_LW_MHDR_MTYPE_MASK) != RADIOLIB_LW_MHDR_MTYPE_JOIN_ACCEPT) {
-    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("joinAccept reply message type invalid, expected 0x%02x got 0x%02x", RADIOLIB_LW_MHDR_MTYPE_JOIN_ACCEPT, joinAcceptMsgEnc[0]);
+  if((joinAcceptMsgEnc[0] & RADIOLIB_LORAWAN_MHDR_MTYPE_MASK) != RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_ACCEPT) {
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("joinAccept reply message type invalid, expected 0x%02x got 0x%02x", RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_ACCEPT, joinAcceptMsgEnc[0]);
     return(RADIOLIB_ERR_DOWNLINK_MALFORMED);
   }
 
   // decrypt the join accept message
   // this is done by encrypting again in ECB mode
   // the first byte is the MAC header which is not encrypted
-  uint8_t joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN];
+  uint8_t joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN];
   joinAcceptMsg[0] = joinAcceptMsgEnc[0];
   RadioLibAES128Instance.init(this->nwkKey);
-  RadioLibAES128Instance.encryptECB(&joinAcceptMsgEnc[1], RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN - 1, &joinAcceptMsg[1]);
+  RadioLibAES128Instance.encryptECB(&joinAcceptMsgEnc[1], RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN - 1, &joinAcceptMsg[1]);
   
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("joinAcceptMsg:");
   RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(joinAcceptMsg, lenRx);
 
   // get current JoinNonce from downlink and previous JoinNonce from persistent storage
-  uint32_t joinNonceNew = LoRaWANNode::ntoh<uint32_t>(&joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_JOIN_NONCE_POS], 3);
+  uint32_t joinNonceNew = LoRaWANNode::ntoh<uint32_t>(&joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_JOIN_NONCE_POS], 3);
 
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("JoinNoncePrev: %d, JoinNonce: %d", this->joinNonce, joinNonceNew);
   // JoinNonce received must be greater than the last JoinNonce heard, else error
@@ -586,26 +586,26 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   }
   this->joinNonce = joinNonceNew;
 
-  this->homeNetId = LoRaWANNode::ntoh<uint32_t>(&joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_HOME_NET_ID_POS], 3);
-  this->devAddr = LoRaWANNode::ntoh<uint32_t>(&joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_DEV_ADDR_POS]);
+  this->homeNetId = LoRaWANNode::ntoh<uint32_t>(&joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_HOME_NET_ID_POS], 3);
+  this->devAddr = LoRaWANNode::ntoh<uint32_t>(&joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_DEV_ADDR_POS]);
 
   // check LoRaWAN revision (the MIC verification depends on this)
-  uint8_t dlSettings = joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_DL_SETTINGS_POS];
-  this->rev = (dlSettings & RADIOLIB_LW_JOIN_ACCEPT_R_1_1) >> 7;
+  uint8_t dlSettings = joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_DL_SETTINGS_POS];
+  this->rev = (dlSettings & RADIOLIB_LORAWAN_JOIN_ACCEPT_R_1_1) >> 7;
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("LoRaWAN revision: 1.%d", this->rev);
 
   // verify MIC
   if(this->rev == 1) {
     // 1.1 version, first we need to derive the join accept integrity key
     uint8_t keyDerivationBuff[RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_JS_INT_KEY;
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_JS_INT_KEY;
     LoRaWANNode::hton<uint64_t>(&keyDerivationBuff[1], this->devEUI);
     RadioLibAES128Instance.init(this->nwkKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->jSIntKey);
 
     // prepare the buffer for MIC calculation
     uint8_t micBuff[3*RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
-    micBuff[0] = RADIOLIB_LW_JOIN_REQUEST_TYPE;
+    micBuff[0] = RADIOLIB_LORAWAN_JOIN_REQUEST_TYPE;
     LoRaWANNode::hton<uint64_t>(&micBuff[1], this->joinEUI);
     LoRaWANNode::hton<uint16_t>(&micBuff[9], devNonceUsed);
     memcpy(&micBuff[11], joinAcceptMsg, lenRx);
@@ -623,9 +623,9 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   }
 
   LoRaWANMacCommand_t cmd = {
-    .cid = RADIOLIB_LW_MAC_RX_PARAM_SETUP,
+    .cid = RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP,
     .payload = { 0 }, 
-    .len = MacTable[RADIOLIB_LW_MAC_RX_PARAM_SETUP].lenDn,
+    .len = MacTable[RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP].lenDn,
     .repeat = 0,
   };
   cmd.payload[0] = dlSettings & 0x7F;
@@ -633,68 +633,68 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   LoRaWANNode::hton<uint32_t>(&cmd.payload[1], rx2Freq, 3);
   (void)execMacCommand(&cmd);
 
-  cmd.cid = RADIOLIB_LW_MAC_RX_TIMING_SETUP;
-  cmd.len = MacTable[RADIOLIB_LW_MAC_RX_TIMING_SETUP].lenDn;
-  cmd.payload[0] = joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_RX_DELAY_POS];
+  cmd.cid = RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP;
+  cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP].lenDn;
+  cmd.payload[0] = joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_RX_DELAY_POS];
   (void)execMacCommand(&cmd);
   
   // in case of dynamic band, setup the default channels first
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     this->setupChannelsDyn(false);
   }
   // process CFlist if present
-  if(lenRx == RADIOLIB_LW_JOIN_ACCEPT_MAX_LEN) {
-    uint8_t cfList[RADIOLIB_LW_JOIN_ACCEPT_CFLIST_LEN] = { 0 };
-    memcpy(&cfList[0], &joinAcceptMsg[RADIOLIB_LW_JOIN_ACCEPT_CFLIST_POS], RADIOLIB_LW_JOIN_ACCEPT_CFLIST_LEN);
+  if(lenRx == RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN) {
+    uint8_t cfList[RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_LEN] = { 0 };
+    memcpy(&cfList[0], &joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_POS], RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_LEN);
     this->processCFList(cfList);
   } 
   // if no CFList was received, default or subband are already setup so don't need to do anything else
 
   // prepare buffer for key derivation
   uint8_t keyDerivationBuff[RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
-  LoRaWANNode::hton<uint32_t>(&keyDerivationBuff[RADIOLIB_LW_JOIN_ACCEPT_JOIN_NONCE_POS], joinNonce, 3);
+  LoRaWANNode::hton<uint32_t>(&keyDerivationBuff[RADIOLIB_LORAWAN_JOIN_ACCEPT_JOIN_NONCE_POS], joinNonce, 3);
 
   // check protocol version (1.0 vs 1.1)
   if(this->rev == 1) {
     // 1.1 version, derive the keys
-    LoRaWANNode::hton<uint64_t>(&keyDerivationBuff[RADIOLIB_LW_JOIN_ACCEPT_JOIN_EUI_POS], this->joinEUI);
-    LoRaWANNode::hton<uint16_t>(&keyDerivationBuff[RADIOLIB_LW_JOIN_ACCEPT_DEV_NONCE_POS], devNonceUsed);
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_APP_S_KEY;
+    LoRaWANNode::hton<uint64_t>(&keyDerivationBuff[RADIOLIB_LORAWAN_JOIN_ACCEPT_JOIN_EUI_POS], this->joinEUI);
+    LoRaWANNode::hton<uint16_t>(&keyDerivationBuff[RADIOLIB_LORAWAN_JOIN_ACCEPT_DEV_NONCE_POS], devNonceUsed);
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_APP_S_KEY;
 
     RadioLibAES128Instance.init(this->appKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->appSKey);
 
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_F_NWK_S_INT_KEY;
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_F_NWK_S_INT_KEY;
     RadioLibAES128Instance.init(this->nwkKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->fNwkSIntKey);
 
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_S_NWK_S_INT_KEY;
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_S_NWK_S_INT_KEY;
     RadioLibAES128Instance.init(this->nwkKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->sNwkSIntKey);
 
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_NWK_S_ENC_KEY;
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_NWK_S_ENC_KEY;
     RadioLibAES128Instance.init(this->nwkKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->nwkSEncKey);
 
     // enqueue the RekeyInd MAC command to be sent in the next uplink
     LoRaWANMacCommand_t cmd = {
-      .cid = RADIOLIB_LW_MAC_REKEY,
+      .cid = RADIOLIB_LORAWAN_MAC_REKEY,
       .payload = { this->rev },
       .len = sizeof(uint8_t),
-      .repeat = 0x01 << RADIOLIB_LW_ADR_ACK_LIMIT_EXP,
+      .repeat = 0x01 << RADIOLIB_LORAWAN_ADR_ACK_LIMIT_EXP,
     };
     state = pushMacCommand(&cmd, &this->commandsUp);
     RADIOLIB_ASSERT(state);
   
   } else {
     // 1.0 version, just derive the keys
-    LoRaWANNode::hton<uint32_t>(&keyDerivationBuff[RADIOLIB_LW_JOIN_ACCEPT_HOME_NET_ID_POS], this->homeNetId, 3);
-    LoRaWANNode::hton<uint16_t>(&keyDerivationBuff[RADIOLIB_LW_JOIN_ACCEPT_DEV_ADDR_POS], devNonceUsed);
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_APP_S_KEY;
+    LoRaWANNode::hton<uint32_t>(&keyDerivationBuff[RADIOLIB_LORAWAN_JOIN_ACCEPT_HOME_NET_ID_POS], this->homeNetId, 3);
+    LoRaWANNode::hton<uint16_t>(&keyDerivationBuff[RADIOLIB_LORAWAN_JOIN_ACCEPT_DEV_ADDR_POS], devNonceUsed);
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_APP_S_KEY;
     RadioLibAES128Instance.init(this->nwkKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->appSKey);
 
-    keyDerivationBuff[0] = RADIOLIB_LW_JOIN_ACCEPT_F_NWK_S_INT_KEY;
+    keyDerivationBuff[0] = RADIOLIB_LORAWAN_JOIN_ACCEPT_F_NWK_S_INT_KEY;
     RadioLibAES128Instance.init(this->nwkKey);
     RadioLibAES128Instance.encryptECB(keyDerivationBuff, RADIOLIB_AES128_BLOCK_SIZE, this->fNwkSIntKey);
 
@@ -707,37 +707,37 @@ int16_t LoRaWANNode::activateOTAA(uint8_t joinDr, LoRaWANJoinEvent_t *joinEvent)
   this->fCntUp = 0;
   this->aFCntDown = 0;
   this->nFCntDown = 0;
-  this->confFCntUp = RADIOLIB_LW_FCNT_NONE;
-  this->confFCntDown = RADIOLIB_LW_FCNT_NONE;
+  this->confFCntUp = RADIOLIB_LORAWAN_FCNT_NONE;
+  this->confFCntDown = RADIOLIB_LORAWAN_FCNT_NONE;
   this->adrFCnt = 0;
 
   // save the activation keys checksum, device address & keys as well as JoinAccept values; these are only ever set when joining
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_VERSION], RADIOLIB_LW_NONCES_VERSION_VAL);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_MODE], RADIOLIB_LW_MODE_OTAA);
-  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_CLASS], RADIOLIB_LW_CLASS_A);
-  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_PLAN], this->band->bandNum);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_CHECKSUM], this->keyCheckSum);
-  LoRaWANNode::hton<uint32_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_JOIN_NONCE], this->joinNonce, 3);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_VERSION], RADIOLIB_LORAWAN_NONCES_VERSION_VAL);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_MODE], RADIOLIB_LORAWAN_MODE_OTAA);
+  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_CLASS], RADIOLIB_LORAWAN_CLASS_A);
+  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_PLAN], this->band->bandNum);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_CHECKSUM], this->keyCheckSum);
+  LoRaWANNode::hton<uint32_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_JOIN_NONCE], this->joinNonce, 3);
 
-  this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE] = (uint8_t)true;
+  this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE] = (uint8_t)true;
 
   // generate the signature of the Nonces buffer, and store it in the last two bytes of the Nonces buffer
-  uint16_t signature = LoRaWANNode::checkSum16(this->bufferNonces, RADIOLIB_LW_NONCES_BUF_SIZE - 2);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_SIGNATURE], signature);
+  uint16_t signature = LoRaWANNode::checkSum16(this->bufferNonces, RADIOLIB_LORAWAN_NONCES_BUF_SIZE - 2);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_SIGNATURE], signature);
 
   // store DevAddr and all keys
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_DEV_ADDR], this->devAddr);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_APP_SKEY], this->appSKey, RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_NWK_SENC_KEY], this->nwkSEncKey, RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_FNWK_SINT_KEY], this->fNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_SNWK_SINT_KEY], this->sNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_DEV_ADDR], this->devAddr);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_APP_SKEY], this->appSKey, RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY], this->nwkSEncKey, RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY], this->fNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY], this->sNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
   
   // set the signature of the Nonces buffer in the Session buffer
-  LoRaWANNode::hton<uint16_t>(&this->bufferSession[RADIOLIB_LW_SESSION_NONCES_SIGNATURE], signature);
+  LoRaWANNode::hton<uint16_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE], signature);
 
   // store network parameters
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_HOMENET_ID], this->homeNetId);
-  LoRaWANNode::hton<uint8_t>(&this->bufferSession[RADIOLIB_LW_SESSION_VERSION], this->rev);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_HOMENET_ID], this->homeNetId);
+  LoRaWANNode::hton<uint8_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_VERSION], this->rev);
 
   this->isActive = true;
 
@@ -772,8 +772,8 @@ void LoRaWANNode::beginABP(uint32_t addr, uint8_t* fNwkSIntKey, uint8_t* sNwkSIn
 
   // clear & set all the device credentials
   this->clearNonces();
-  this->lwMode = RADIOLIB_LW_MODE_ABP;
-  this->lwClass = RADIOLIB_LW_CLASS_A;
+  this->lwMode = RADIOLIB_LORAWAN_MODE_ABP;
+  this->lwClass = RADIOLIB_LORAWAN_CLASS_A;
 }
 
 int16_t LoRaWANNode::activateABP(uint8_t initialDr) {
@@ -782,7 +782,7 @@ int16_t LoRaWANNode::activateABP(uint8_t initialDr) {
     // already activated, don't do anything
     return(RADIOLIB_ERR_NONE);
   }
-  if(this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE]) {
+  if(this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE]) {
     // session restored but not yet activated - do so now
     this->isActive = true;
     return(RADIOLIB_LORAWAN_SESSION_RESTORED);
@@ -792,7 +792,7 @@ int16_t LoRaWANNode::activateABP(uint8_t initialDr) {
   this->clearSession();
 
   // setup the uplink/downlink channels and initial datarate
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     this->setupChannelsDyn();
   } else {
     this->setupChannelsFix(this->subBand);
@@ -805,37 +805,37 @@ int16_t LoRaWANNode::activateABP(uint8_t initialDr) {
   this->fCntUp = 0;
   this->aFCntDown = 0;
   this->nFCntDown = 0;
-  this->confFCntUp = RADIOLIB_LW_FCNT_NONE;
-  this->confFCntDown = RADIOLIB_LW_FCNT_NONE;
+  this->confFCntUp = RADIOLIB_LORAWAN_FCNT_NONE;
+  this->confFCntDown = RADIOLIB_LORAWAN_FCNT_NONE;
   this->adrFCnt = 0;
 
   // save the activation keys checksum, mode, class, frequency plan
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_VERSION], RADIOLIB_LW_NONCES_VERSION_VAL);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_MODE], RADIOLIB_LW_MODE_ABP);
-  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_CLASS], RADIOLIB_LW_CLASS_A);
-  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_PLAN], this->band->bandNum);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_CHECKSUM], this->keyCheckSum);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_VERSION], RADIOLIB_LORAWAN_NONCES_VERSION_VAL);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_MODE], RADIOLIB_LORAWAN_MODE_ABP);
+  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_CLASS], RADIOLIB_LORAWAN_CLASS_A);
+  LoRaWANNode::hton<uint8_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_PLAN], this->band->bandNum);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_CHECKSUM], this->keyCheckSum);
 
   // new session all good, so set active-bit to true
-  this->bufferNonces[RADIOLIB_LW_NONCES_ACTIVE] = (uint8_t)true;
+  this->bufferNonces[RADIOLIB_LORAWAN_NONCES_ACTIVE] = (uint8_t)true;
 
   // generate the signature of the Nonces buffer, and store it in the last two bytes of the Nonces buffer
-  uint16_t signature = LoRaWANNode::checkSum16(this->bufferNonces, RADIOLIB_LW_NONCES_BUF_SIZE - 2);
-  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LW_NONCES_SIGNATURE], signature);
+  uint16_t signature = LoRaWANNode::checkSum16(this->bufferNonces, RADIOLIB_LORAWAN_NONCES_BUF_SIZE - 2);
+  LoRaWANNode::hton<uint16_t>(&this->bufferNonces[RADIOLIB_LORAWAN_NONCES_SIGNATURE], signature);
 
   // store DevAddr and all keys
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_DEV_ADDR], this->devAddr);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_APP_SKEY], this->appSKey, RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_NWK_SENC_KEY], this->nwkSEncKey, RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_FNWK_SINT_KEY], this->fNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
-  memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_SNWK_SINT_KEY], this->sNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_DEV_ADDR], this->devAddr);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_APP_SKEY], this->appSKey, RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY], this->nwkSEncKey, RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY], this->fNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
+  memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY], this->sNwkSIntKey, RADIOLIB_AES128_BLOCK_SIZE);
   
   // set the signature of the Nonces buffer in the Session buffer
-  LoRaWANNode::hton<uint16_t>(&this->bufferSession[RADIOLIB_LW_SESSION_NONCES_SIGNATURE], signature);
+  LoRaWANNode::hton<uint16_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE], signature);
   
   // store network parameters
-  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LW_SESSION_HOMENET_ID], this->homeNetId);
-  LoRaWANNode::hton<uint8_t>(&this->bufferSession[RADIOLIB_LW_SESSION_VERSION], this->rev);
+  LoRaWANNode::hton<uint32_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_HOMENET_ID], this->homeNetId);
+  LoRaWANNode::hton<uint8_t>(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_VERSION], this->rev);
 
   this->isActive = true;
 
@@ -881,7 +881,7 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
     return(RADIOLIB_ERR_INVALID_PORT);
   }
   // fPort 0 is only allowed for MAC-only payloads
-  if(fPort == RADIOLIB_LW_FPORT_MAC_COMMAND) {
+  if(fPort == RADIOLIB_LORAWAN_FPORT_MAC_COMMAND) {
     if (!this->isMACPayload) {
       return(RADIOLIB_ERR_INVALID_PORT);
     }
@@ -893,16 +893,16 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
 
   // check if there are some MAC commands to piggyback (only when piggybacking onto a application-frame)
   uint8_t fOptsLen = 0;
-  if(this->commandsUp.numCommands > 0 && fPort != RADIOLIB_LW_FPORT_MAC_COMMAND) {
+  if(this->commandsUp.numCommands > 0 && fPort != RADIOLIB_LORAWAN_FPORT_MAC_COMMAND) {
     // there are, assume the maximum possible FOpts len for buffer allocation
     fOptsLen = this->commandsUp.len;
   }
 
   // check maximum payload len as defined in phy
-  if(len > this->band->payloadLenMax[this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK]]) {
+  if(len > this->band->payloadLenMax[this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK]]) {
     return(RADIOLIB_ERR_PACKET_TOO_LONG);
     // if testing with TS009 specification verification protocol, don't throw error but clip the message
-    // len = this->band->payloadLenMax[this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK]];
+    // len = this->band->payloadLenMax[this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK]];
   }
 
   bool adrAckReq = false;
@@ -936,8 +936,8 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
             break;
           case(2): {
               // try to decrease the datarate
-              if(this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK] > 0) {
-                if(this->setDatarate(this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK] - 1) == RADIOLIB_ERR_NONE) {
+              if(this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] > 0) {
+                if(this->setDatarate(this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] - 1) == RADIOLIB_ERR_NONE) {
                   adrStage = 0;                         // successfully did some ADR stuff
                 }
               }
@@ -947,7 +947,7 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
             }
             break;
           case(3): {
-              if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+              if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
                 this->setupChannelsDyn(false);          // revert to default frequencies
               } else {
                 // go back to default selected subband
@@ -967,17 +967,17 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
 
   // set the physical layer configuration for uplink
   this->selectChannels();
-  state = this->setPhyProperties(RADIOLIB_LW_CHANNEL_DIR_UPLINK);
+  state = this->setPhyProperties(RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK);
   RADIOLIB_ASSERT(state);
 
   // if dwell time is imposed, calculated expected time on air and cancel if exceeds
-  if(this->dwellTimeEnabledUp && this->phyLayer->getTimeOnAir(RADIOLIB_LW_FRAME_LEN(len, fOptsLen) - 16)/1000 > this->dwellTimeUp) {
+  if(this->dwellTimeEnabledUp && this->phyLayer->getTimeOnAir(RADIOLIB_LORAWAN_FRAME_LEN(len, fOptsLen) - 16)/1000 > this->dwellTimeUp) {
     return(RADIOLIB_ERR_DWELL_TIME_EXCEEDED);
   }
 
   // build the uplink message
   // the first 16 bytes are reserved for MIC calculation blocks
-  size_t uplinkMsgLen = RADIOLIB_LW_FRAME_LEN(len, fOptsLen);
+  size_t uplinkMsgLen = RADIOLIB_LORAWAN_FRAME_LEN(len, fOptsLen);
   #if RADIOLIB_STATIC_ONLY
   uint8_t uplinkMsg[RADIOLIB_STATIC_ARRAY_SIZE];
   #else
@@ -986,36 +986,36 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
   
   // set the packet fields
   if(isConfirmed) {
-    uplinkMsg[RADIOLIB_LW_FHDR_LEN_START_OFFS] = RADIOLIB_LW_MHDR_MTYPE_CONF_DATA_UP;
+    uplinkMsg[RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS] = RADIOLIB_LORAWAN_MHDR_MTYPE_CONF_DATA_UP;
     this->confFCntUp = this->fCntUp;
   } else {
-    uplinkMsg[RADIOLIB_LW_FHDR_LEN_START_OFFS] = RADIOLIB_LW_MHDR_MTYPE_UNCONF_DATA_UP;
+    uplinkMsg[RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS] = RADIOLIB_LORAWAN_MHDR_MTYPE_UNCONF_DATA_UP;
   }
-  uplinkMsg[RADIOLIB_LW_FHDR_LEN_START_OFFS] |= RADIOLIB_LW_MHDR_MAJOR_R1;
-  LoRaWANNode::hton<uint32_t>(&uplinkMsg[RADIOLIB_LW_FHDR_DEV_ADDR_POS], this->devAddr);
+  uplinkMsg[RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS] |= RADIOLIB_LORAWAN_MHDR_MAJOR_R1;
+  LoRaWANNode::hton<uint32_t>(&uplinkMsg[RADIOLIB_LORAWAN_FHDR_DEV_ADDR_POS], this->devAddr);
 
   // length of fOpts will be added later
-  uplinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] = 0x00;
+  uplinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] = 0x00;
   if(this->adrEnabled) {
-    uplinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] |= RADIOLIB_LW_FCTRL_ADR_ENABLED;
+    uplinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] |= RADIOLIB_LORAWAN_FCTRL_ADR_ENABLED;
     if(adrAckReq) {
-      uplinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] |= RADIOLIB_LW_FCTRL_ADR_ACK_REQ;
+      uplinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] |= RADIOLIB_LORAWAN_FCTRL_ADR_ACK_REQ;
     }
   }
 
   // if the saved confirm-fCnt is set, set the ACK bit
   bool isConfirmingDown = false;
-  if(this->confFCntDown != RADIOLIB_LW_FCNT_NONE) {
+  if(this->confFCntDown != RADIOLIB_LORAWAN_FCNT_NONE) {
     isConfirmingDown = true;
-    uplinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] |= RADIOLIB_LW_FCTRL_ACK;
+    uplinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] |= RADIOLIB_LORAWAN_FCTRL_ACK;
   }
 
-  LoRaWANNode::hton<uint16_t>(&uplinkMsg[RADIOLIB_LW_FHDR_FCNT_POS], (uint16_t)this->fCntUp);
+  LoRaWANNode::hton<uint16_t>(&uplinkMsg[RADIOLIB_LORAWAN_FHDR_FCNT_POS], (uint16_t)this->fCntUp);
 
   // check if we have some MAC commands to append
   if(fOptsLen > 0) {
     // assume maximum possible buffer size
-    uint8_t fOptsBuff[RADIOLIB_LW_FHDR_FOPTS_MAX_LEN];
+    uint8_t fOptsBuff[RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN];
     uint8_t* fOptsPtr = fOptsBuff;
 
     // append all MAC replies into fOpts buffer
@@ -1037,41 +1037,41 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
       }
     }
 
-    uplinkMsgLen = RADIOLIB_LW_FRAME_LEN(len, fOptsLen);
-    uplinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] |= fOptsLen;
+    uplinkMsgLen = RADIOLIB_LORAWAN_FRAME_LEN(len, fOptsLen);
+    uplinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] |= fOptsLen;
 
     // encrypt it
-    processAES(fOptsBuff, fOptsLen, this->nwkSEncKey, &uplinkMsg[RADIOLIB_LW_FHDR_FOPTS_POS], this->fCntUp, RADIOLIB_LW_CHANNEL_DIR_UPLINK, 0x01, true);
+    processAES(fOptsBuff, fOptsLen, this->nwkSEncKey, &uplinkMsg[RADIOLIB_LORAWAN_FHDR_FOPTS_POS], this->fCntUp, RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK, 0x01, true);
     
   }
 
   // set the fPort
-  uplinkMsg[RADIOLIB_LW_FHDR_FPORT_POS(fOptsLen)] = fPort;
+  uplinkMsg[RADIOLIB_LORAWAN_FHDR_FPORT_POS(fOptsLen)] = fPort;
 
   // select encryption key based on the target fPort
   uint8_t* encKey = this->appSKey;
-  if(fPort == RADIOLIB_LW_FPORT_MAC_COMMAND) {
+  if(fPort == RADIOLIB_LORAWAN_FPORT_MAC_COMMAND) {
     encKey = this->nwkSEncKey;
   }
 
   // encrypt the frame payload
-  processAES(data, len, encKey, &uplinkMsg[RADIOLIB_LW_FRAME_PAYLOAD_POS(fOptsLen)], this->fCntUp, RADIOLIB_LW_CHANNEL_DIR_UPLINK, 0x00, true);
+  processAES(data, len, encKey, &uplinkMsg[RADIOLIB_LORAWAN_FRAME_PAYLOAD_POS(fOptsLen)], this->fCntUp, RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK, 0x00, true);
 
   // create blocks for MIC calculation
   uint8_t block0[RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
-  block0[RADIOLIB_LW_BLOCK_MAGIC_POS] = RADIOLIB_LW_MIC_BLOCK_MAGIC;
-  block0[RADIOLIB_LW_BLOCK_DIR_POS] = RADIOLIB_LW_CHANNEL_DIR_UPLINK;
-  LoRaWANNode::hton<uint32_t>(&block0[RADIOLIB_LW_BLOCK_DEV_ADDR_POS], this->devAddr);
-  LoRaWANNode::hton<uint32_t>(&block0[RADIOLIB_LW_BLOCK_FCNT_POS], this->fCntUp);
-  block0[RADIOLIB_LW_MIC_BLOCK_LEN_POS] = uplinkMsgLen - RADIOLIB_AES128_BLOCK_SIZE - sizeof(uint32_t);
+  block0[RADIOLIB_LORAWAN_BLOCK_MAGIC_POS] = RADIOLIB_LORAWAN_MIC_BLOCK_MAGIC;
+  block0[RADIOLIB_LORAWAN_BLOCK_DIR_POS] = RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK;
+  LoRaWANNode::hton<uint32_t>(&block0[RADIOLIB_LORAWAN_BLOCK_DEV_ADDR_POS], this->devAddr);
+  LoRaWANNode::hton<uint32_t>(&block0[RADIOLIB_LORAWAN_BLOCK_FCNT_POS], this->fCntUp);
+  block0[RADIOLIB_LORAWAN_MIC_BLOCK_LEN_POS] = uplinkMsgLen - RADIOLIB_AES128_BLOCK_SIZE - sizeof(uint32_t);
 
   uint8_t block1[RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
   memcpy(block1, block0, RADIOLIB_AES128_BLOCK_SIZE);
-  if(this->confFCntDown != RADIOLIB_LW_FCNT_NONE) {
-    LoRaWANNode::hton<uint16_t>(&block1[RADIOLIB_LW_BLOCK_CONF_FCNT_POS], (uint16_t)this->confFCntDown);
+  if(this->confFCntDown != RADIOLIB_LORAWAN_FCNT_NONE) {
+    LoRaWANNode::hton<uint16_t>(&block1[RADIOLIB_LORAWAN_BLOCK_CONF_FCNT_POS], (uint16_t)this->confFCntDown);
   }
-  block1[RADIOLIB_LW_MIC_DATA_RATE_POS] = this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK];
-  block1[RADIOLIB_LW_MIC_CH_INDEX_POS] = this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK].idx;
+  block1[RADIOLIB_LORAWAN_MIC_DATA_RATE_POS] = this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK];
+  block1[RADIOLIB_LORAWAN_MIC_CH_INDEX_POS] = this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK].idx;
   
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Uplink (FCntUp = %d) decoded:", this->fCntUp);
 
@@ -1097,14 +1097,14 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
   }
 
   // send it (without the MIC calculation blocks)
-  state = this->phyLayer->transmit(&uplinkMsg[RADIOLIB_LW_FHDR_LEN_START_OFFS], uplinkMsgLen - RADIOLIB_LW_FHDR_LEN_START_OFFS);
+  state = this->phyLayer->transmit(&uplinkMsg[RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS], uplinkMsgLen - RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS);
 
   // set the timestamp so that we can measure when to start receiving
   this->rxDelayStart = mod->hal->millis();
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Uplink sent <-- Rx Delay start");
 
   // calculate Time on Air of this uplink in milliseconds
-  this->lastToA = this->phyLayer->getTimeOnAir(uplinkMsgLen - RADIOLIB_LW_FHDR_LEN_START_OFFS) / 1000;
+  this->lastToA = this->phyLayer->getTimeOnAir(uplinkMsgLen - RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS) / 1000;
 
   #if !RADIOLIB_STATIC_ONLY
   delete[] uplinkMsg;
@@ -1112,14 +1112,14 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t fPort, bool isCon
   RADIOLIB_ASSERT(state);
   
   // the downlink confirmation was acknowledged, so clear the counter value
-  this->confFCntDown = RADIOLIB_LW_FCNT_NONE;
+  this->confFCntDown = RADIOLIB_LORAWAN_FCNT_NONE;
 
   // pass the extra info if requested
   if(event) {
-    event->dir = RADIOLIB_LW_CHANNEL_DIR_UPLINK;
+    event->dir = RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK;
     event->confirmed = isConfirmed;
     event->confirming = isConfirmingDown;
-    event->datarate = this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK];
+    event->datarate = this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK];
     event->freq = currentChannels[event->dir].freq;
     event->power = this->txPowerMax - this->txPowerSteps * 2;
     event->fCnt = this->fCntUp;
@@ -1153,7 +1153,7 @@ int16_t LoRaWANNode::downlinkCommon() {
   }
 
   // set the physical layer configuration for downlink
-  int16_t state = this->setPhyProperties(RADIOLIB_LW_CHANNEL_DIR_DOWNLINK);
+  int16_t state = this->setPhyProperties(RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK);
   RADIOLIB_ASSERT(state);
 
   // create the masks that are required for receiving downlinks
@@ -1299,7 +1299,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
 
   // check the minimum required frame length
   // an extra byte is subtracted because downlink frames may not have a fPort
-  if(downlinkMsgLen < RADIOLIB_LW_FRAME_LEN(0, 0) - 1 - RADIOLIB_AES128_BLOCK_SIZE) {
+  if(downlinkMsgLen < RADIOLIB_LORAWAN_FRAME_LEN(0, 0) - 1 - RADIOLIB_AES128_BLOCK_SIZE) {
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Downlink message too short (%lu bytes)", downlinkMsgLen);
     return(RADIOLIB_ERR_DOWNLINK_MALFORMED);
   }
@@ -1328,7 +1328,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   }
 
   // check the address
-  uint32_t addr = LoRaWANNode::ntoh<uint32_t>(&downlinkMsg[RADIOLIB_LW_FHDR_DEV_ADDR_POS]);
+  uint32_t addr = LoRaWANNode::ntoh<uint32_t>(&downlinkMsg[RADIOLIB_LORAWAN_FHDR_DEV_ADDR_POS]);
   if(addr != this->devAddr) {
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Device address mismatch, expected 0x%08X, got 0x%08X", this->devAddr, addr);
     #if !RADIOLIB_STATIC_ONLY
@@ -1338,11 +1338,11 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   }
 
   // calculate length of FOpts and payload
-  uint8_t fOptsLen = downlinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] & RADIOLIB_LW_FHDR_FOPTS_LEN_MASK;
+  uint8_t fOptsLen = downlinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] & RADIOLIB_LORAWAN_FHDR_FOPTS_LEN_MASK;
 
   // check if the ACK bit is set, indicating this frame acknowledges the previous uplink
   bool isConfirmingUp = false;
-  if((downlinkMsg[RADIOLIB_LW_FHDR_FCTRL_POS] & RADIOLIB_LW_FCTRL_ACK)) {
+  if((downlinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] & RADIOLIB_LORAWAN_FCTRL_ACK)) {
     isConfirmingUp = true;
   }
 
@@ -1351,19 +1351,19 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   uint8_t payLen = downlinkMsgLen - 1 - 4 - 1 - 2 - fOptsLen - 4;
 
   // get the frame counter
-  uint16_t fCnt16 = LoRaWANNode::ntoh<uint16_t>(&downlinkMsg[RADIOLIB_LW_FHDR_FCNT_POS]);
+  uint16_t fCnt16 = LoRaWANNode::ntoh<uint16_t>(&downlinkMsg[RADIOLIB_LORAWAN_FHDR_FCNT_POS]);
 
   // set the MIC calculation blocks
   memset(downlinkMsg, 0x00, RADIOLIB_AES128_BLOCK_SIZE);
-  downlinkMsg[RADIOLIB_LW_BLOCK_MAGIC_POS] = RADIOLIB_LW_MIC_BLOCK_MAGIC;
+  downlinkMsg[RADIOLIB_LORAWAN_BLOCK_MAGIC_POS] = RADIOLIB_LORAWAN_MIC_BLOCK_MAGIC;
   // if this downlink is confirming an uplink, the MIC was generated with the least-significant 16 bits of that fCntUp
   if(isConfirmingUp && (this->rev == 1)) {
-    LoRaWANNode::hton<uint16_t>(&downlinkMsg[RADIOLIB_LW_BLOCK_CONF_FCNT_POS], (uint16_t)this->confFCntUp);
+    LoRaWANNode::hton<uint16_t>(&downlinkMsg[RADIOLIB_LORAWAN_BLOCK_CONF_FCNT_POS], (uint16_t)this->confFCntUp);
   }
-  downlinkMsg[RADIOLIB_LW_BLOCK_DIR_POS] = RADIOLIB_LW_CHANNEL_DIR_DOWNLINK;
-  LoRaWANNode::hton<uint32_t>(&downlinkMsg[RADIOLIB_LW_BLOCK_DEV_ADDR_POS], this->devAddr);
-  LoRaWANNode::hton<uint16_t>(&downlinkMsg[RADIOLIB_LW_BLOCK_FCNT_POS], fCnt16);
-  downlinkMsg[RADIOLIB_LW_MIC_BLOCK_LEN_POS] = downlinkMsgLen - sizeof(uint32_t);
+  downlinkMsg[RADIOLIB_LORAWAN_BLOCK_DIR_POS] = RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK;
+  LoRaWANNode::hton<uint32_t>(&downlinkMsg[RADIOLIB_LORAWAN_BLOCK_DEV_ADDR_POS], this->devAddr);
+  LoRaWANNode::hton<uint16_t>(&downlinkMsg[RADIOLIB_LORAWAN_BLOCK_FCNT_POS], fCnt16);
+  downlinkMsg[RADIOLIB_LORAWAN_MIC_BLOCK_LEN_POS] = downlinkMsgLen - sizeof(uint32_t);
  
   // check the MIC
   if(!verifyMIC(downlinkMsg, RADIOLIB_AES128_BLOCK_SIZE + downlinkMsgLen, this->sNwkSIntKey)) {
@@ -1375,15 +1375,15 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
 
   // in LoRaWAN v1.1, a frame is a Network frame if there is no Application payload
   // i.e.: either no payload at all (empty frame or FOpts only), or MAC only payload (FPort = 0)
-  uint8_t fPort = RADIOLIB_LW_FPORT_MAC_COMMAND;
+  uint8_t fPort = RADIOLIB_LORAWAN_FPORT_MAC_COMMAND;
   bool isAppDownlink = false;
   if(this->rev == 0) {
     isAppDownlink = true;
   }
   if(payLen > 0) {
     payLen -= 1;  // subtract one as fPort is set
-    fPort = downlinkMsg[RADIOLIB_LW_FHDR_FPORT_POS(fOptsLen)];
-    if(fPort > RADIOLIB_LW_FPORT_MAC_COMMAND) {
+    fPort = downlinkMsg[RADIOLIB_LORAWAN_FHDR_FPORT_POS(fOptsLen)];
+    if(fPort > RADIOLIB_LORAWAN_FPORT_MAC_COMMAND) {
       isAppDownlink = true;
     } else {
       fOptsLen = payLen;
@@ -1406,7 +1406,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   // if that isn't the case and the received fCnt is smaller or equal to the last heard fCnt, then error
   uint32_t fCnt32 = fCnt16;
   if(fCntDownPrev > 0) {
-    if((fCnt16 <= fCntDownPrev) && ((0xFFFF - (uint16_t)fCntDownPrev + fCnt16) > RADIOLIB_LW_MAX_FCNT_GAP)) {
+    if((fCnt16 <= fCntDownPrev) && ((0xFFFF - (uint16_t)fCntDownPrev + fCnt16) > RADIOLIB_LORAWAN_MAX_FCNT_GAP)) {
       #if !RADIOLIB_STATIC_ONLY
         delete[] downlinkMsg;
       #endif
@@ -1430,7 +1430,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
 
   // if this is a confirmed frame, save the downlink number (only app frames can be confirmed)
   bool isConfirmedDown = false;
-  if((downlinkMsg[RADIOLIB_LW_FHDR_LEN_START_OFFS] & 0xFE) == RADIOLIB_LW_MHDR_MTYPE_CONF_DATA_DOWN) {
+  if((downlinkMsg[RADIOLIB_LORAWAN_FHDR_LEN_START_OFFS] & 0xFE) == RADIOLIB_LORAWAN_MHDR_MTYPE_CONF_DATA_DOWN) {
     this->confFCntDown = this->aFCntDown;
     isConfirmedDown = true;
   }
@@ -1439,7 +1439,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   if(fOptsLen > 0) {
     // there are some Fopts, decrypt them
     #if !RADIOLIB_STATIC_ONLY
-      uint8_t* fOpts = new uint8_t[RADIOLIB_MAX(RADIOLIB_LW_FHDR_FOPTS_LEN_MASK, (int)fOptsLen)];
+      uint8_t* fOpts = new uint8_t[RADIOLIB_MAX(RADIOLIB_LORAWAN_FHDR_FOPTS_LEN_MASK, (int)fOptsLen)];
     #else
       uint8_t fOpts[RADIOLIB_STATIC_ARRAY_SIZE];
     #endif
@@ -1447,11 +1447,11 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
     // TODO it COULD be the case that the assumed FCnt rollover is incorrect, if possible figure out a way to catch this and retry with just fCnt16
     // if there are <= 15 bytes of FOpts, they are in the FHDR, otherwise they are in the payload
     // in case of the latter, process AES is if it were a normal payload but using the NwkSEncKey
-    if(fOptsLen <= RADIOLIB_LW_FHDR_FOPTS_LEN_MASK) {
+    if(fOptsLen <= RADIOLIB_LORAWAN_FHDR_FOPTS_LEN_MASK) {
       uint8_t ctrId = 0x01 + isAppDownlink; // see LoRaWAN v1.1 errata
-      processAES(&downlinkMsg[RADIOLIB_LW_FHDR_FOPTS_POS], (size_t)fOptsLen, this->nwkSEncKey, fOpts, fCnt32, RADIOLIB_LW_CHANNEL_DIR_DOWNLINK, ctrId, true);
+      processAES(&downlinkMsg[RADIOLIB_LORAWAN_FHDR_FOPTS_POS], (size_t)fOptsLen, this->nwkSEncKey, fOpts, fCnt32, RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK, ctrId, true);
     } else {
-      processAES(&downlinkMsg[RADIOLIB_LW_FRAME_PAYLOAD_POS(0)], (size_t)fOptsLen, this->nwkSEncKey, fOpts, fCnt32, RADIOLIB_LW_CHANNEL_DIR_DOWNLINK, 0x00, true);
+      processAES(&downlinkMsg[RADIOLIB_LORAWAN_FRAME_PAYLOAD_POS(0)], (size_t)fOptsLen, this->nwkSEncKey, fOpts, fCnt32, RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK, 0x00, true);
     }
 
     bool hasADR = false;
@@ -1464,9 +1464,9 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
     while(remLen > 0) {
       uint8_t cid = *fOptsPtr;
       uint8_t macLen = getMacPayloadLength(cid);
-      if(cid == RADIOLIB_LW_MAC_LINK_ADR) {
+      if(cid == RADIOLIB_LORAWAN_MAC_LINK_ADR) {
         // if there was an earlier ADR command but it was not the last, ignore it
-        if(hasADR && lastCID != RADIOLIB_LW_MAC_LINK_ADR) {
+        if(hasADR && lastCID != RADIOLIB_LORAWAN_MAC_LINK_ADR) {
           RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Encountered non-consecutive block of ADR commands - skipping");
           remLen -= (macLen + 1);
           fOptsPtr += (macLen + 1);
@@ -1483,7 +1483,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
         .cid = cid,
         .payload = { 0 },
         .len = macLen,
-        .repeat = (cid == RADIOLIB_LW_MAC_LINK_ADR ? numADR : (uint8_t)0),
+        .repeat = (cid == RADIOLIB_LORAWAN_MAC_LINK_ADR ? numADR : (uint8_t)0),
       };
       memcpy(cmd.payload, fOptsPtr + 1, macLen);
 
@@ -1504,7 +1504,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
     #endif
 
     // if fOptsLen for the next uplink is larger than can be piggybacked onto an uplink, send separate uplink
-    if(this->commandsUp.len > RADIOLIB_LW_FHDR_FOPTS_MAX_LEN) {
+    if(this->commandsUp.len > RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN) {
       size_t fOptsBufSize = this->commandsUp.len;
       #if RADIOLIB_STATIC_ONLY
         uint8_t fOptsBuff[RADIOLIB_STATIC_ARRAY_SIZE];
@@ -1536,7 +1536,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       bool prevDC = this->dutyCycleEnabled;
       this->dutyCycleEnabled = false;
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Sending MAC-only uplink .. ");
-      state = this->uplink(fOptsBuff, fOptsBufSize, RADIOLIB_LW_FPORT_MAC_COMMAND);
+      state = this->uplink(fOptsBuff, fOptsBufSize, RADIOLIB_LORAWAN_FPORT_MAC_COMMAND);
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN(" .. state: %d", state);
       this->dutyCycleEnabled = prevDC;
 
@@ -1547,7 +1547,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       #if RADIOLIB_STATIC_ONLY
         uint8_t strDown[RADIOLIB_STATIC_ARRAY_SIZE];
       #else
-        uint8_t* strDown = new uint8_t[this->band->payloadLenMax[this->dataRates[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK]]];
+        uint8_t* strDown = new uint8_t[this->band->payloadLenMax[this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK]]];
       #endif
       size_t lenDown = 0;
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Receiving after MAC-only uplink .. ");
@@ -1566,10 +1566,10 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
 
   // pass the extra info if requested
   if(event) {
-    event->dir = RADIOLIB_LW_CHANNEL_DIR_DOWNLINK;
+    event->dir = RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK;
     event->confirmed = isConfirmedDown;
     event->confirming = isConfirmingUp;
-    event->datarate = this->dataRates[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK];
+    event->datarate = this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK];
     event->freq = currentChannels[event->dir].freq;
     event->power = this->txPowerMax - this->txPowerSteps * 2;
     event->fCnt = isAppDownlink ? this->aFCntDown : this->nFCntDown;
@@ -1577,7 +1577,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   }
 
   // if MAC-only payload, return now
-  if(fPort == RADIOLIB_LW_FPORT_MAC_COMMAND) {
+  if(fPort == RADIOLIB_LORAWAN_FPORT_MAC_COMMAND) {
     // no payload
     *len = 0;
     #if !RADIOLIB_STATIC_ONLY
@@ -1591,7 +1591,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
   *len = payLen;
 
   // TODO it COULD be the case that the assumed rollover is incorrect, then figure out a way to catch this and retry with just fCnt16
-  processAES(&downlinkMsg[RADIOLIB_LW_FRAME_PAYLOAD_POS(fOptsLen)], payLen, this->appSKey, data, fCnt32, RADIOLIB_LW_CHANNEL_DIR_DOWNLINK, 0x00, true);
+  processAES(&downlinkMsg[RADIOLIB_LORAWAN_FRAME_PAYLOAD_POS(fOptsLen)], payLen, this->appSKey, data, fCnt32, RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK, 0x00, true);
   
   #if !RADIOLIB_STATIC_ONLY
     delete[] downlinkMsg;
@@ -1704,7 +1704,7 @@ int16_t LoRaWANNode::setPhyProperties(uint8_t dir) {
   RADIOLIB_ASSERT(state);
 
   // if this channel is an FSK channel, toggle the FSK switch
-  if(this->band->dataRates[this->dataRates[dir]] == RADIOLIB_LW_DATA_RATE_FSK_50_K) {
+  if(this->band->dataRates[this->dataRates[dir]] == RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K) {
     this->FSK = true;
   } else {
     this->FSK = false;
@@ -1733,7 +1733,7 @@ int16_t LoRaWANNode::setPhyProperties(uint8_t dir) {
   }
 
   // downlink messages are sent with inverted IQ
-  if(dir == RADIOLIB_LW_CHANNEL_DIR_DOWNLINK) {
+  if(dir == RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK) {
     if(!this->FSK) {
       state = this->phyLayer->invertIQ(true);
       RADIOLIB_ASSERT(state);
@@ -1745,15 +1745,15 @@ int16_t LoRaWANNode::setPhyProperties(uint8_t dir) {
   uint8_t syncWordLen = 0;
   size_t preLen = 0;
   if(this->FSK) {
-    preLen = 8*RADIOLIB_LW_GFSK_PREAMBLE_LEN;
-    syncWord[0] = (uint8_t)(RADIOLIB_LW_GFSK_SYNC_WORD >> 16);
-    syncWord[1] = (uint8_t)(RADIOLIB_LW_GFSK_SYNC_WORD >> 8);
-    syncWord[2] = (uint8_t)RADIOLIB_LW_GFSK_SYNC_WORD;
+    preLen = 8*RADIOLIB_LORAWAN_GFSK_PREAMBLE_LEN;
+    syncWord[0] = (uint8_t)(RADIOLIB_LORAWAN_GFSK_SYNC_WORD >> 16);
+    syncWord[1] = (uint8_t)(RADIOLIB_LORAWAN_GFSK_SYNC_WORD >> 8);
+    syncWord[2] = (uint8_t)RADIOLIB_LORAWAN_GFSK_SYNC_WORD;
     syncWordLen = 3;
   
   } else {
-    preLen = RADIOLIB_LW_LORA_PREAMBLE_LEN;
-    syncWord[0] = RADIOLIB_LW_LORA_SYNC_WORD;
+    preLen = RADIOLIB_LORAWAN_LORA_PREAMBLE_LEN;
+    syncWord[0] = RADIOLIB_LORAWAN_LORA_SYNC_WORD;
     syncWordLen = 1;
   
   }
@@ -1771,38 +1771,38 @@ int16_t LoRaWANNode::setupChannelsDyn(bool joinRequest) {
   size_t num = 0;
   // copy the default defined channels into the first slots (where Tx = Rx)
   for(; num < 3 && this->band->txFreqs[num].enabled; num++) {
-    this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][num] = this->band->txFreqs[num];
-    this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][num] = this->band->txFreqs[num];
+    this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][num] = this->band->txFreqs[num];
+    this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][num] = this->band->txFreqs[num];
   }
 
   // if we're about to send a join-request, copy the join-request channels to the next slots
   if(joinRequest) {
     size_t numJR = 0;
     for(; numJR < 3 && this->band->txJoinReq[num].enabled; numJR++, num++) {
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][num] = this->band->txFreqs[num];
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][num] = this->band->txFreqs[num];
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][num] = this->band->txFreqs[num];
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][num] = this->band->txFreqs[num];
     }
   }
 
   // clear all remaining channels
-  for(; num < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; num++) {
-    this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][num] = RADIOLIB_LW_CHANNEL_NONE;
+  for(; num < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; num++) {
+    this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][num] = RADIOLIB_LORAWAN_CHANNEL_NONE;
   }
 
-  for (int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled) {
+  for (int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled) {
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %3d %d %7.3f (%d - %d) | DL: %3d %d %7.3f (%d - %d)",
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMax,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMax,
 
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].drMax
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].drMax
                             );
     }
   }
@@ -1816,8 +1816,8 @@ int16_t LoRaWANNode::setupChannelsFix(uint8_t subBand) {
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Setting up fixed channels (subband %d)", subBand);
 
   // clear all existing channels
-  for(size_t i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LW_CHANNEL_NONE;
+  for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LORAWAN_CHANNEL_NONE;
   }
 
   // if no subband is selected by user, cycle through banks of 8 using devNonce value
@@ -1853,18 +1853,18 @@ int16_t LoRaWANNode::setupChannelsFix(uint8_t subBand) {
 int16_t LoRaWANNode::processCFList(uint8_t* cfList) {
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Processing CFList");
   
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     // retrieve number of existing (default) channels
     size_t num = 0;
-    for(int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-      if(!this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled) {
+    for(int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+      if(!this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled) {
         break;
       }
       num++;
     }
 
     LoRaWANMacCommand_t cmd = {
-      .cid = RADIOLIB_LW_MAC_NEW_CHANNEL,
+      .cid = RADIOLIB_LORAWAN_MAC_NEW_CHANNEL,
       .payload = { 0 }, 
       .len = 0,
       .repeat = 0,
@@ -1872,19 +1872,19 @@ int16_t LoRaWANNode::processCFList(uint8_t* cfList) {
     // datarate range for all new channels is equal to the default channels
     cmd.payload[4] = (this->band->txFreqs[0].drMax << 4) | this->band->txFreqs[0].drMin;
     for(uint8_t i = 0; i < 5; i++, num++) {
-      cmd.len = MacTable[RADIOLIB_LW_MAC_NEW_CHANNEL].lenDn;
+      cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_NEW_CHANNEL].lenDn;
       cmd.payload[0] = num;
       memcpy(&cmd.payload[1], &cfList[i*3], 3);
       (void)execMacCommand(&cmd);
     }
-  } else {                // RADIOLIB_LW_BAND_FIXED
+  } else {                // RADIOLIB_LORAWAN_BAND_FIXED
     // complete channel mask received, so clear all existing channels
-    for(int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LW_CHANNEL_NONE;
+    for(int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LORAWAN_CHANNEL_NONE;
     }
 
     LoRaWANMacCommand_t cmd = {
-      .cid = RADIOLIB_LW_MAC_LINK_ADR,
+      .cid = RADIOLIB_LORAWAN_MAC_LINK_ADR,
       .payload = { 0 }, 
       .len = 0,
       .repeat = 0,
@@ -1893,7 +1893,7 @@ int16_t LoRaWANNode::processCFList(uint8_t* cfList) {
     // in case of mask-type bands, copy those frequencies that are masked true into the available TX channels
     size_t numChMasks = 3 + this->band->numTxSpans;       // 4 masks for bands with 2 spans, 5 spans for bands with 1 span
     for(size_t chMaskCntl = 0; chMaskCntl < numChMasks; chMaskCntl++) {
-      cmd.len = MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn;
+      cmd.len = MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn;
       cmd.payload[0] = 0xFF;                              // same datarate and payload
       memcpy(&cmd.payload[1], &cfList[chMaskCntl*2], 2);  // copy mask
       cmd.payload[3] = chMaskCntl << 4;                   // set chMaskCntl, set NbTrans = 0 -> keep the same
@@ -1908,11 +1908,11 @@ int16_t LoRaWANNode::processCFList(uint8_t* cfList) {
 int16_t LoRaWANNode::selectChannels() {
   // figure out which channel IDs are enabled (chMask may have disabled some) and are valid for the current datarate
   uint8_t numChannels = 0;
-  uint8_t channelsEnabled[RADIOLIB_LW_NUM_AVAILABLE_CHANNELS];
-  for(uint8_t i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled) {
-      if(this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK] >= this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMin
-         && this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK] <= this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMax) {
+  uint8_t channelsEnabled[RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS];
+  for(uint8_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled) {
+      if(this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] >= this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMin
+         && this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] <= this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMax) {
           channelsEnabled[numChannels] = i;
           numChannels++;
       }
@@ -1924,26 +1924,26 @@ int16_t LoRaWANNode::selectChannels() {
   }
   // select a random ID & channel from the list of enabled and possible channels
   uint8_t channelID = channelsEnabled[this->phyLayer->random(numChannels)];
-  this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK] = this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][channelID];
+  this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] = this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][channelID];
   
-  if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+  if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     // for dynamic bands, the downlink channel is the one matched to the uplink channel
-    this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK] = this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][channelID];
+    this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK] = this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][channelID];
   
-  } else {                // RADIOLIB_LW_BAND_FIXED
+  } else {                // RADIOLIB_LORAWAN_BAND_FIXED
     // for fixed bands, the downlink channel is the uplink channel ID `modulo` number of downlink channels
     LoRaWANChannel_t channelDn;
     channelDn.enabled = true;
-    channelDn.idx = this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK].idx % this->band->rx1Span.numChannels;
+    channelDn.idx = this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK].idx % this->band->rx1Span.numChannels;
     channelDn.freq = this->band->rx1Span.freqStart + channelDn.idx*this->band->rx1Span.freqStep;
     channelDn.drMin = this->band->rx1Span.drMin;
     channelDn.drMax = this->band->rx1Span.drMax;
-    this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK] = channelDn;
+    this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK] = channelDn;
 
   }
-  uint8_t drDown = getDownlinkDataRate(this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK], this->rx1DrOffset, this->band->rx1DataRateBase, 
-                                       this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].drMin, this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].drMax);
-  this->dataRates[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK] = drDown;
+  uint8_t drDown = getDownlinkDataRate(this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK], this->rx1DrOffset, this->band->rx1DataRateBase, 
+                                       this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].drMin, this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].drMax);
+  this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK] = drDown;
 
   return(RADIOLIB_ERR_NONE);
 }
@@ -1951,8 +1951,8 @@ int16_t LoRaWANNode::selectChannels() {
 int16_t LoRaWANNode::setDatarate(uint8_t drUp) {
   // scan through all enabled channels and check if the requested datarate is available
   bool isValidDR = false;
-  for(size_t i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    LoRaWANChannel_t *chnl = &(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i]);
+  for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    LoRaWANChannel_t *chnl = &(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i]);
     if(chnl->enabled) {
       if(drUp >= chnl->drMin && drUp <= chnl->drMax) {
         isValidDR = true;
@@ -1966,9 +1966,9 @@ int16_t LoRaWANNode::setDatarate(uint8_t drUp) {
   }
 
   LoRaWANMacCommand_t cmd = {
-    .cid = RADIOLIB_LW_MAC_LINK_ADR,
+    .cid = RADIOLIB_LORAWAN_MAC_LINK_ADR,
     .payload = { 0 }, 
-    .len = MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn,
+    .len = MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn,
     .repeat = 0,
   };
   cmd.payload[0]  = (drUp << 4);
@@ -2035,7 +2035,7 @@ uint8_t LoRaWANNode::maxPayloadDwellTime() {
   // configure current datarate
   DataRate_t dr;
   // TODO this may fail horribly?
-  (void)findDataRate(this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK], &dr);
+  (void)findDataRate(this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK], &dr);
   (void)this->phyLayer->setDataRate(dr);
   uint8_t minPayLen = 0;
   uint8_t maxPayLen = 255;
@@ -2060,12 +2060,12 @@ int16_t LoRaWANNode::setTxPower(int8_t txPower) {
   // Tx Power is set in steps of two
   // the selected value is rounded down to nearest multiple of two away from txPowerMax
   // e.g. on EU868, max is 16; if 13 is selected then we set to 12
-  uint8_t numSteps = (this->txPowerMax - txPower + 1) / (-RADIOLIB_LW_POWER_STEP_SIZE_DBM);
+  uint8_t numSteps = (this->txPowerMax - txPower + 1) / (-RADIOLIB_LORAWAN_POWER_STEP_SIZE_DBM);
 
   LoRaWANMacCommand_t cmd = {
-    .cid = RADIOLIB_LW_MAC_LINK_ADR,
+    .cid = RADIOLIB_LORAWAN_MAC_LINK_ADR,
     .payload = { 0 }, 
-    .len = MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn,
+    .len = MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn,
     .repeat = 0,
   };
   cmd.payload[0]  = 0xF0;               // keep datarate the same
@@ -2087,20 +2087,20 @@ int16_t LoRaWANNode::findDataRate(uint8_t dr, DataRate_t* dataRate) {
 
   uint8_t dataRateBand = this->band->dataRates[dr];
 
-  if(dataRateBand & RADIOLIB_LW_DATA_RATE_FSK_50_K) {
+  if(dataRateBand & RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K) {
     dataRate->fsk.bitRate = 50;
     dataRate->fsk.freqDev = 25;
   
   } else {
     uint8_t bw = dataRateBand & 0x0C;
     switch(bw) {
-      case(RADIOLIB_LW_DATA_RATE_BW_125_KHZ):
+      case(RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ):
         dataRate->lora.bandwidth = 125.0;
         break;
-      case(RADIOLIB_LW_DATA_RATE_BW_250_KHZ):
+      case(RADIOLIB_LORAWAN_DATA_RATE_BW_250_KHZ):
         dataRate->lora.bandwidth = 250.0;
         break;
-      case(RADIOLIB_LW_DATA_RATE_BW_500_KHZ):
+      case(RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ):
         dataRate->lora.bandwidth = 500.0;
         break;
       default:
@@ -2118,7 +2118,7 @@ int16_t LoRaWANNode::findDataRate(uint8_t dr, DataRate_t* dataRate) {
 
 int16_t LoRaWANNode::sendMacCommandReq(uint8_t cid) {
   bool valid = false;
-  for(size_t i = 0; i < RADIOLIB_LW_NUM_MAC_COMMANDS; i++) {
+  for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_MAC_COMMANDS; i++) {
     if(MacTable[i].cid == cid) {
       valid = MacTable[i].user;
     }
@@ -2129,11 +2129,11 @@ int16_t LoRaWANNode::sendMacCommandReq(uint8_t cid) {
   }
 
   // if there are already 15 MAC bytes in the uplink queue, we can't add a new one
-  if(this->commandsUp.len + 1 > RADIOLIB_LW_FHDR_FOPTS_MAX_LEN) {
+  if(this->commandsUp.len + 1 > RADIOLIB_LORAWAN_FHDR_FOPTS_MAX_LEN) {
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("The maximum number of FOpts payload was reached");
     return(RADIOLIB_ERR_COMMAND_QUEUE_FULL);
   }
-  if(this->commandsUp.numCommands > RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE) {
+  if(this->commandsUp.numCommands > RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE) {
     RADIOLIB_DEBUG_PROTOCOL_PRINTLN("The RadioLib internal MAC command queue was full");
     return(RADIOLIB_ERR_COMMAND_QUEUE_FULL);
   }
@@ -2152,7 +2152,7 @@ int16_t LoRaWANNode::sendMacCommandReq(uint8_t cid) {
 }
 
 int16_t LoRaWANNode::pushMacCommand(LoRaWANMacCommand_t* cmd, LoRaWANMacCommandQueue_t* queue) {
-  if(queue->numCommands >= RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE) {
+  if(queue->numCommands >= RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE) {
     return(RADIOLIB_ERR_COMMAND_QUEUE_FULL);
   }
 
@@ -2172,11 +2172,11 @@ int16_t LoRaWANNode::deleteMacCommand(uint8_t cid, LoRaWANMacCommandQueue_t* que
       }
       queue->len -= (1 + queue->commands[index].len); // 1 byte for command ID, len for payload
       // move all subsequent commands one forward in the queue
-      if(index < RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE - 1) {
-        memmove(&queue->commands[index], &queue->commands[index + 1], (RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE - index - 1) * sizeof(LoRaWANMacCommand_t));
+      if(index < RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE - 1) {
+        memmove(&queue->commands[index], &queue->commands[index + 1], (RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE - index - 1) * sizeof(LoRaWANMacCommand_t));
       }
       // set the latest element to all 0
-      memset(&queue->commands[RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE - 1], 0x00, sizeof(LoRaWANMacCommand_t));
+      memset(&queue->commands[RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE - 1], 0x00, sizeof(LoRaWANMacCommand_t));
       queue->numCommands--;
       return(RADIOLIB_ERR_NONE);
     }
@@ -2189,34 +2189,34 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
   RADIOLIB_DEBUG_PROTOCOL_PRINTLN("[MAC] 0x%02X", cmd->cid);
   RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(cmd->payload, cmd->len);
 
-  if(cmd->cid >= RADIOLIB_LW_MAC_PROPRIETARY) {
+  if(cmd->cid >= RADIOLIB_LORAWAN_MAC_PROPRIETARY) {
     // TODO call user-provided callback for proprietary MAC commands?
     return(false);
   }
 
   switch(cmd->cid) {
-    case(RADIOLIB_LW_MAC_RESET): {
+    case(RADIOLIB_LORAWAN_MAC_RESET): {
       // get the server version
       uint8_t srvVersion = cmd->payload[0];
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ResetConf: server version 1.%d", srvVersion);
       if(srvVersion == this->rev) {
         // valid server version, stop sending the ResetInd MAC command
-        deleteMacCommand(RADIOLIB_LW_MAC_RESET, &this->commandsUp);
+        deleteMacCommand(RADIOLIB_LORAWAN_MAC_RESET, &this->commandsUp);
       }
       return(false);
     } break;
 
-    case(RADIOLIB_LW_MAC_LINK_CHECK): {
+    case(RADIOLIB_LORAWAN_MAC_LINK_CHECK): {
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("LinkCheckAns: [user]");
       // delete any existing response (does nothing if there is none)
-      deleteMacCommand(RADIOLIB_LW_MAC_LINK_CHECK, &this->commandsDown);
+      deleteMacCommand(RADIOLIB_LORAWAN_MAC_LINK_CHECK, &this->commandsDown);
 
       // insert response into MAC downlink queue
       pushMacCommand(cmd, &this->commandsDown);
       return(false);
     } break;
 
-    case(RADIOLIB_LW_MAC_LINK_ADR): {
+    case(RADIOLIB_LORAWAN_MAC_LINK_ADR): {
       int16_t state = RADIOLIB_ERR_UNKNOWN;
       // get the ADR configuration
       uint8_t drUp = (cmd->payload[0] & 0xF0) >> 4;
@@ -2233,16 +2233,16 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       if(drUp == 0x0F) {  // keep the same
         drAck = 1;
 
-      } else if (this->band->dataRates[drUp] != RADIOLIB_LW_DATA_RATE_UNUSED) {
+      } else if (this->band->dataRates[drUp] != RADIOLIB_LORAWAN_DATA_RATE_UNUSED) {
         // check if the module supports this data rate
         DataRate_t dr;
         state = findDataRate(drUp, &dr);
         if(state == RADIOLIB_ERR_NONE) {
           uint8_t drDown = getDownlinkDataRate(drUp, this->rx1DrOffset, this->band->rx1DataRateBase,
-                                               this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].drMin,
-                                               this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].drMax);
-          this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK] = drUp;
-          this->dataRates[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK] = drDown;
+                                               this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].drMin,
+                                               this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].drMax);
+          this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] = drUp;
+          this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK] = drDown;
           drAck = 1;
         } else {
           RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR failed to configure dataRate %d, code %d!", drUp, state);
@@ -2274,22 +2274,22 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       // only apply channel mask when the RFU bit is not set
       // (which is only set in internal MAC commands for changing Tx/Dr)
       if(!isInternalTxDr) {
-        if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+        if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
           chMaskAck = (uint8_t)this->applyChannelMaskDyn(chMaskCntl, chMask);
 
-        } else {                // RADIOLIB_LW_BAND_FIXED
+        } else {                // RADIOLIB_LORAWAN_BAND_FIXED
           if(cmd->repeat == 1) {
             // if this is the first ADR command in the queue, clear all saved channels
             // so we can apply the new channel mask
             RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR mask: clearing channels");
-            for(size_t i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LW_CHANNEL_NONE;
+            for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LORAWAN_CHANNEL_NONE;
             }
             // clear all previous channel masks
-            memset(&this->bufferSession[RADIOLIB_LW_SESSION_UL_CHANNELS], 0, 16*8);
+            memset(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_UL_CHANNELS], 0, 16*8);
           } else {
             // if this is not the first ADR command, clear the ADR response that was in the queue
-            (void)deleteMacCommand(RADIOLIB_LW_MAC_LINK_ADR, &this->commandsUp);
+            (void)deleteMacCommand(RADIOLIB_LORAWAN_MAC_LINK_ADR, &this->commandsUp);
           }
           chMaskAck = (uint8_t)this->applyChannelMaskFix(chMaskCntl, chMask);
 
@@ -2304,7 +2304,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       // per spec, all these configuration should only be set if all ACKs are set, otherwise retain previous state
       // but we don't bother and try to set each individual command
       if(drUp == 0x0F || !drAck) {
-        cmd->payload[0] = (cmd->payload[0] & 0x0F) | (this->dataRates[RADIOLIB_LW_CHANNEL_DIR_UPLINK] << 4);
+        cmd->payload[0] = (cmd->payload[0] & 0x0F) | (this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK] << 4);
       }
       if(txSteps == 0x0F || !pwrAck) {
         cmd->payload[0] = (cmd->payload[0] & 0xF0) | this->txPowerSteps;
@@ -2313,10 +2313,10 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
         cmd->payload[3] = (cmd->payload[3] & 0xF0) | this->nbTrans;
       }
 
-      if(this->band->bandType == RADIOLIB_LW_BAND_DYNAMIC) {
+      if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
         // if RFU bit is set, this is just a change in Datarate or TxPower, so read ADR command and overwrite first byte
         if(isInternalTxDr) {
-          memcpy(&(cmd->payload[1]), &this->bufferSession[RADIOLIB_LW_SESSION_LINK_ADR] + 1, 3);
+          memcpy(&(cmd->payload[1]), &this->bufferSession[RADIOLIB_LORAWAN_SESSION_LINK_ADR] + 1, 3);
         }
         
         // if there was no channel mask (all zeroes), we should never apply that channel mask, so set RFU bit again
@@ -2325,24 +2325,24 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
         }
 
         // save to the single ADR MAC location
-        memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_LINK_ADR], &(cmd->payload[0]), cmd->len);
+        memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_LINK_ADR], &(cmd->payload[0]), cmd->len);
       
-      } else {                // RADIOLIB_LW_BAND_FIXED
+      } else {                // RADIOLIB_LORAWAN_BAND_FIXED
 
         // save Tx/Dr to the Link ADR position in the session buffer 
-        uint8_t bufTxDr[RADIOLIB_LW_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
+        uint8_t bufTxDr[RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
         bufTxDr[0] = cmd->payload[0];
         bufTxDr[3] = 1 << 7;
-        memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_LINK_ADR], bufTxDr, cmd->len);
+        memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_LINK_ADR], bufTxDr, cmd->len);
         
         // if RFU bit is set, this is just a change in Datarate or TxPower, in which case we don't save the channel masks
         // if the RFU bit is not set, we must save this channel mask
         if(!isInternalTxDr) {
           // save the channel mask to the uplink channels position in session buffer, with Tx and DR set to 'same'
           cmd->payload[0] = 0xFF;
-          memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_UL_CHANNELS] + (cmd->repeat - 1) * cmd->len, cmd->payload, cmd->len);
+          memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_UL_CHANNELS] + (cmd->repeat - 1) * cmd->len, cmd->payload, cmd->len);
           RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Saving mask to ULChannels[%d]:", (cmd->repeat - 1) * cmd->len);
-          RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(&this->bufferSession[RADIOLIB_LW_SESSION_UL_CHANNELS] + (cmd->repeat - 1) * cmd->len, cmd->len);
+          RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_UL_CHANNELS] + (cmd->repeat - 1) * cmd->len, cmd->len);
         }
 
       }
@@ -2355,7 +2355,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_DUTY_CYCLE): {
+    case(RADIOLIB_LORAWAN_MAC_DUTY_CYCLE): {
       uint8_t maxDutyCycle = cmd->payload[0] & 0x0F;
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("DutyCycleReq: max duty cycle = 1/2^%d", maxDutyCycle);
       if(maxDutyCycle == 0) {
@@ -2364,13 +2364,13 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
         this->dutyCycle = (RadioLibTime_t)60 * (RadioLibTime_t)60 * (RadioLibTime_t)1000 / (RadioLibTime_t)(1UL << maxDutyCycle);
       }
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_DUTY_CYCLE], cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_DUTY_CYCLE], cmd->payload, cmd->len);
 
       cmd->len = 0;
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_RX_PARAM_SETUP): {
+    case(RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP): {
       // get the configuration
       this->rx1DrOffset = (cmd->payload[0] & 0x70) >> 4;
       uint8_t rx1OffsAck = 1;
@@ -2384,10 +2384,10 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       uint8_t chanAck = 0;
       if(this->phyLayer->setFrequency(this->rx2.freq) == RADIOLIB_ERR_NONE) {
         chanAck = 1;
-        this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].freq);
+        this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].freq);
       }
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_RX_PARAM_SETUP], cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_RX_PARAM_SETUP], cmd->payload, cmd->len);
 
       // TODO this should be sent repeatedly until the next downlink
       cmd->len = 1;
@@ -2396,7 +2396,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_DEV_STATUS): {
+    case(RADIOLIB_LORAWAN_MAC_DEV_STATUS): {
       // set the uplink reply
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("DevStatusReq");
       cmd->len = 2;
@@ -2408,7 +2408,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_NEW_CHANNEL): {
+    case(RADIOLIB_LORAWAN_MAC_NEW_CHANNEL): {
       // get the configuration
       uint8_t chIndex = cmd->payload[0];
       uint32_t freqRaw = LoRaWANNode::ntoh<uint32_t>(&cmd->payload[1], 3);
@@ -2419,38 +2419,38 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       uint8_t newChAck = 0;
       uint8_t freqAck = 0;
 
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].enabled = true;
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].idx   = chIndex;
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].freq  = freq;
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].drMin = minDr;
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].drMax = maxDr;
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].enabled = true;
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].idx   = chIndex;
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].freq  = freq;
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].drMin = minDr;
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].drMax = maxDr;
       
       // downlink channel is identical to uplink channel
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][chIndex] = this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex];
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][chIndex] = this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex];
       newChAck = 1;
       
       // check if the frequency is possible
-      if(this->phyLayer->setFrequency(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].freq) == RADIOLIB_ERR_NONE) {
+      if(this->phyLayer->setFrequency(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].freq) == RADIOLIB_ERR_NONE) {
         freqAck = 1;
-        this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].freq);
+        this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].freq);
       }
       
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("NewChannelReq:");
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %3d %d %7.3f (%d - %d) | DL: %3d %d %7.3f (%d - %d)", 
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][chIndex].drMax,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][chIndex].drMax,
 
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][chIndex].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][chIndex].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][chIndex].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][chIndex].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][chIndex].drMax
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][chIndex].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][chIndex].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][chIndex].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][chIndex].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][chIndex].drMax
                             );
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_UL_CHANNELS] + chIndex * cmd->len, cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_UL_CHANNELS] + chIndex * cmd->len, cmd->payload, cmd->len);
 
       // send the reply
       cmd->len = 1;
@@ -2460,7 +2460,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_DL_CHANNEL): {
+    case(RADIOLIB_LORAWAN_MAC_DL_CHANNEL): {
       // get the configuration
       uint8_t chIndex = cmd->payload[0];
       uint32_t freqRaw = LoRaWANNode::ntoh<uint32_t>(&cmd->payload[1], 3);
@@ -2472,21 +2472,21 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       // check if the frequency is possible
       if(this->phyLayer->setFrequency(freq) == RADIOLIB_ERR_NONE) {
         freqDlAck = 1;
-        this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK].freq);
+        this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].freq);
       }
       
       // update the downlink frequency
-      for(int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-        if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].idx == chIndex) {
-          this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].freq = freq;
+      for(int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+        if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].idx == chIndex) {
+          this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].freq = freq;
           // check if the corresponding uplink frequency is actually set
-          if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].freq > 0) {
+          if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].freq > 0) {
             freqUlAck = 1;
           }
         }
       }
       
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_DL_CHANNELS] + chIndex * cmd->len, cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_DL_CHANNELS] + chIndex * cmd->len, cmd->payload, cmd->len);
 
       // TODO send this repeatedly until a downlink is received
       cmd->len = 1;
@@ -2496,7 +2496,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_RX_TIMING_SETUP): {
+    case(RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP): {
       // get the configuration
       uint8_t delay = cmd->payload[0] & 0x0F;
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("RXTimingSetupReq: delay = %d sec", delay);
@@ -2508,7 +2508,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       this->rxDelays[0] = delay * 1000;
       this->rxDelays[1] = this->rxDelays[0] + 1000;
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_RX_TIMING_SETUP], cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_RX_TIMING_SETUP], cmd->payload, cmd->len);
 
       // send the reply
       cmd->len = 0;
@@ -2517,7 +2517,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_TX_PARAM_SETUP): {
+    case(RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP): {
       uint8_t dlDwell = (cmd->payload[0] & 0x20) >> 5;
       uint8_t ulDwell = (cmd->payload[0] & 0x10) >> 4;
       uint8_t maxEirpRaw = cmd->payload[0] & 0x0F;
@@ -2528,50 +2528,50 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("TxParamSetupReq: dlDwell = %d, ulDwell = %d, maxEirp = %d dBm", dlDwell, ulDwell, eirpEncoding[maxEirpRaw]);
 
       this->dwellTimeEnabledUp = ulDwell ? true : false;
-      this->dwellTimeUp = ulDwell ? RADIOLIB_LW_DWELL_TIME : 0;
+      this->dwellTimeUp = ulDwell ? RADIOLIB_LORAWAN_DWELL_TIME : 0;
 
       this->dwellTimeEnabledDn = dlDwell ? true : false;
-      this->dwellTimeDn = dlDwell ? RADIOLIB_LW_DWELL_TIME : 0;
+      this->dwellTimeDn = dlDwell ? RADIOLIB_LORAWAN_DWELL_TIME : 0;
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_TX_PARAM_SETUP], cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_TX_PARAM_SETUP], cmd->payload, cmd->len);
 
       cmd->len = 0;
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_REKEY): {
+    case(RADIOLIB_LORAWAN_MAC_REKEY): {
       // get the server version
       uint8_t srvVersion = cmd->payload[0];
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("RekeyConf: server version = 1.%d", srvVersion);
       if((srvVersion > 0) && (srvVersion <= this->rev)) {
         // valid server version, stop sending the ReKey MAC command
-        deleteMacCommand(RADIOLIB_LW_MAC_REKEY, &this->commandsUp);
+        deleteMacCommand(RADIOLIB_LORAWAN_MAC_REKEY, &this->commandsUp);
       }
       return(false);
     } break;
 
-    case(RADIOLIB_LW_MAC_ADR_PARAM_SETUP): {
+    case(RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP): {
       this->adrLimitExp = (cmd->payload[0] & 0xF0) >> 4;
       this->adrDelayExp = cmd->payload[0] & 0x0F;
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADRParamSetupReq: limitExp = %d, delayExp = %d", this->adrLimitExp, this->adrDelayExp);
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_ADR_PARAM_SETUP], cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_ADR_PARAM_SETUP], cmd->payload, cmd->len);
 
       cmd->len = 0;
       return(true);
     } break;
 
-    case(RADIOLIB_LW_MAC_DEVICE_TIME): {
+    case(RADIOLIB_LORAWAN_MAC_DEVICE_TIME): {
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("DeviceTimeAns: [user]");
       // delete any existing response (does nothing if there is none)
-      deleteMacCommand(RADIOLIB_LW_MAC_DEVICE_TIME, &this->commandsDown);
+      deleteMacCommand(RADIOLIB_LORAWAN_MAC_DEVICE_TIME, &this->commandsDown);
 
       // insert response into MAC downlink queue
       pushMacCommand(cmd, &this->commandsDown);
       return(false);
     } break;
 
-    case(RADIOLIB_LW_MAC_FORCE_REJOIN): {
+    case(RADIOLIB_LORAWAN_MAC_FORCE_REJOIN): {
       // TODO implement this
       uint16_t rejoinReq = LoRaWANNode::ntoh<uint16_t>(cmd->payload);
       uint8_t period = (rejoinReq & 0x3800) >> 11;
@@ -2586,13 +2586,13 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
       return(false);
     } break;
 
-    case(RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP): {
+    case(RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP): {
       // TODO implement this
       uint8_t maxTime = (cmd->payload[0] & 0xF0) >> 4;
       uint8_t maxCount = cmd->payload[0] & 0x0F;
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("RejoinParamSetupReq: maxTime = %d, maxCount = %d", maxTime, maxCount);
 
-      memcpy(&this->bufferSession[RADIOLIB_LW_SESSION_REJOIN_PARAM_SETUP], cmd->payload, cmd->len);
+      memcpy(&this->bufferSession[RADIOLIB_LORAWAN_SESSION_REJOIN_PARAM_SETUP], cmd->payload, cmd->len);
 
       cmd->len = 0;
       cmd->payload[0] = (1 << 1) | 1;
@@ -2608,42 +2608,42 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd) {
 }
 
 bool LoRaWANNode::applyChannelMaskDyn(uint8_t chMaskCntl, uint16_t chMask) {
-  for(size_t i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
+  for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
     if(chMaskCntl == 0) {
       // apply the mask by looking at each channel bit
       if(chMask & (1UL << i)) {
         // if it should be enabled but is not currently defined, stop immediately
-        if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].idx == RADIOLIB_LW_CHANNEL_INDEX_NONE) {
+        if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].idx == RADIOLIB_LORAWAN_CHANNEL_INDEX_NONE) {
           return(false);
         }
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled = true;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled = true;
       } else {
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled = false;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled = false;
       }
 
     } else if(chMaskCntl == 6) {
       // enable all defined channels
-      if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].idx != RADIOLIB_LW_CHANNEL_INDEX_NONE) {
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled = true;
+      if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].idx != RADIOLIB_LORAWAN_CHANNEL_INDEX_NONE) {
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled = true;
       }
     }
     
   }
 
-  for (int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled) {
+  for (int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled) {
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %3d %d %7.3f (%d - %d) | DL: %3d %d %7.3f (%d - %d)",
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMax,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMax,
 
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].drMax
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].drMax
                             );
     }
   }
@@ -2656,8 +2656,8 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
 
   // find out how many channels have already been configured
   uint8_t idx = 0;
-  for(size_t i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].freq > 0) {
+  for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].freq > 0) {
       idx++;
     }
   }
@@ -2675,7 +2675,7 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
         chnl.freq  = this->band->txSpans[0].freqStart + chNum*this->band->txSpans[0].freqStep;
         chnl.drMin = this->band->txSpans[0].drMin;
         chnl.drMax = this->band->txSpans[0].drMax;
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][idx++] = chnl;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][idx++] = chnl;
       }
     }
 
@@ -2697,7 +2697,7 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
         chnl.freq  = this->band->txSpans[1].freqStart + i*this->band->txSpans[1].freqStep;
         chnl.drMin = this->band->txSpans[1].drMin;
         chnl.drMax = this->band->txSpans[1].drMax;
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][idx++] = chnl;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][idx++] = chnl;
       }
     }
 
@@ -2716,7 +2716,7 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
           chnl.freq  = this->band->txSpans[0].freqStart + chNum*this->band->txSpans[0].freqStep;
           chnl.drMin = this->band->txSpans[0].drMin;
           chnl.drMax = this->band->txSpans[0].drMax;
-          this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][idx++] = chnl;
+          this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][idx++] = chnl;
         }
         // enable single channel from second span
         uint8_t chNum = 64 + i;
@@ -2725,7 +2725,7 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
         chnl.freq  = this->band->txSpans[1].freqStart + i*this->band->txSpans[1].freqStep;
         chnl.drMin = this->band->txSpans[1].drMin;
         chnl.drMax = this->band->txSpans[1].drMax;
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][idx++] = chnl;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][idx++] = chnl;
       }
     }
 
@@ -2746,16 +2746,16 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
         chnl.freq  = this->band->txSpans[1].freqStart + i*this->band->txSpans[1].freqStep;
         chnl.drMin = this->band->txSpans[1].drMin;
         chnl.drMax = this->band->txSpans[1].drMax;
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][idx++] = chnl;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][idx++] = chnl;
       }
     }
 
   }
   if(this->band->numTxSpans == 2 && chMaskCntl == 7) {
     // all channels off (clear all channels)
-    LoRaWANChannel_t chnl = RADIOLIB_LW_CHANNEL_NONE;
-    for(int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-      this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i] = chnl;
+    LoRaWANChannel_t chnl = RADIOLIB_LORAWAN_CHANNEL_NONE;
+    for(int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+      this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i] = chnl;
       // downlink channels are not defined so don't need to reset
     }
     idx = 0;
@@ -2770,26 +2770,26 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask) {
         chnl.freq  = this->band->txSpans[1].freqStart + i*this->band->txSpans[1].freqStep;
         chnl.drMin = this->band->txSpans[1].drMin;
         chnl.drMax = this->band->txSpans[1].drMax;
-        this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][idx++] = chnl;
+        this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][idx++] = chnl;
       }
     }
 
   }
 
-  for (int i = 0; i < RADIOLIB_LW_NUM_AVAILABLE_CHANNELS; i++) {
-    if(this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled) {
+  for (int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
+    if(this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled) {
       RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %3d %d %7.3f (%d - %d) | DL: %3d %d %7.3f (%d - %d)",
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_UPLINK][i].drMax,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i].drMax,
 
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].idx,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].enabled,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].freq,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].drMin,
-                              this->availableChannels[RADIOLIB_LW_CHANNEL_DIR_DOWNLINK][i].drMax
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].idx,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].enabled,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].freq,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].drMin,
+                              this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK][i].drMax
                             );
     }
   }
@@ -2808,8 +2808,8 @@ uint8_t LoRaWANNode::getMacPayloadLength(uint8_t cid) {
 }
 
 int16_t LoRaWANNode::getMacLinkCheckAns(uint8_t* margin, uint8_t* gwCnt) {
-  uint8_t payload[RADIOLIB_LW_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
-  int16_t state = deleteMacCommand(RADIOLIB_LW_LINK_CHECK_REQ, &this->commandsDown, payload);
+  uint8_t payload[RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
+  int16_t state = deleteMacCommand(RADIOLIB_LORAWAN_LINK_CHECK_REQ, &this->commandsDown, payload);
   RADIOLIB_ASSERT(state);
 
   if(margin) { *margin = payload[0]; }
@@ -2819,8 +2819,8 @@ int16_t LoRaWANNode::getMacLinkCheckAns(uint8_t* margin, uint8_t* gwCnt) {
 }
 
 int16_t LoRaWANNode::getMacDeviceTimeAns(uint32_t* gpsEpoch, uint8_t* fraction, bool returnUnix) {
-  uint8_t payload[RADIOLIB_LW_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
-  int16_t state = deleteMacCommand(RADIOLIB_LW_MAC_DEVICE_TIME, &this->commandsDown, payload);
+  uint8_t payload[RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
+  int16_t state = deleteMacCommand(RADIOLIB_LORAWAN_MAC_DEVICE_TIME, &this->commandsDown, payload);
   RADIOLIB_ASSERT(state);
 
   if(gpsEpoch) { 
@@ -2897,11 +2897,11 @@ void LoRaWANNode::processAES(uint8_t* in, size_t len, uint8_t* key, uint8_t* out
   // generate the encryption blocks
   uint8_t encBuffer[RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
   uint8_t encBlock[RADIOLIB_AES128_BLOCK_SIZE] = { 0 };
-  encBlock[RADIOLIB_LW_BLOCK_MAGIC_POS] = RADIOLIB_LW_ENC_BLOCK_MAGIC;
-  encBlock[RADIOLIB_LW_ENC_BLOCK_COUNTER_ID_POS] = ctrId;
-  encBlock[RADIOLIB_LW_BLOCK_DIR_POS] = dir;
-  LoRaWANNode::hton<uint32_t>(&encBlock[RADIOLIB_LW_BLOCK_DEV_ADDR_POS], this->devAddr);
-  LoRaWANNode::hton<uint32_t>(&encBlock[RADIOLIB_LW_BLOCK_FCNT_POS], fCnt);
+  encBlock[RADIOLIB_LORAWAN_BLOCK_MAGIC_POS] = RADIOLIB_LORAWAN_ENC_BLOCK_MAGIC;
+  encBlock[RADIOLIB_LORAWAN_ENC_BLOCK_COUNTER_ID_POS] = ctrId;
+  encBlock[RADIOLIB_LORAWAN_BLOCK_DIR_POS] = dir;
+  LoRaWANNode::hton<uint32_t>(&encBlock[RADIOLIB_LORAWAN_BLOCK_DEV_ADDR_POS], this->devAddr);
+  LoRaWANNode::hton<uint32_t>(&encBlock[RADIOLIB_LORAWAN_BLOCK_FCNT_POS], fCnt);
 
   // now encrypt the input
   // on downlink frames, this has a decryption effect because server actually "decrypts" the plaintext
@@ -2909,7 +2909,7 @@ void LoRaWANNode::processAES(uint8_t* in, size_t len, uint8_t* key, uint8_t* out
   for(size_t i = 0; i < numBlocks; i++) {
 
     if(counter) {
-      encBlock[RADIOLIB_LW_ENC_BLOCK_COUNTER_POS] = i + 1;
+      encBlock[RADIOLIB_LORAWAN_ENC_BLOCK_COUNTER_POS] = i + 1;
     }
 
     // encrypt the buffer
diff --git a/src/protocols/LoRaWAN/LoRaWAN.h b/src/protocols/LoRaWAN/LoRaWAN.h
index 7a97705d..72395506 100644
--- a/src/protocols/LoRaWAN/LoRaWAN.h
+++ b/src/protocols/LoRaWAN/LoRaWAN.h
@@ -1,200 +1,200 @@
-#if !defined(_RADIOLIB_LW_H) && !RADIOLIB_EXCLUDE_LORAWAN
-#define _RADIOLIB_LW_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_LW_MODE_OTAA                              (0x07AA)
-#define RADIOLIB_LW_MODE_ABP                               (0x0AB9)
-#define RADIOLIB_LW_MODE_NONE                              (0x0000)
+#define RADIOLIB_LORAWAN_MODE_OTAA                              (0x07AA)
+#define RADIOLIB_LORAWAN_MODE_ABP                               (0x0AB9)
+#define RADIOLIB_LORAWAN_MODE_NONE                              (0x0000)
 
 // operation mode
-#define RADIOLIB_LW_CLASS_A                                (0x0A)
-#define RADIOLIB_LW_CLASS_B                                (0x0B)
-#define RADIOLIB_LW_CLASS_C                                (0x0C)
+#define RADIOLIB_LORAWAN_CLASS_A                                (0x0A)
+#define RADIOLIB_LORAWAN_CLASS_B                                (0x0B)
+#define RADIOLIB_LORAWAN_CLASS_C                                (0x0C)
 
 // preamble format
-#define RADIOLIB_LW_LORA_SYNC_WORD                         (0x34)
-#define RADIOLIB_LW_LORA_PREAMBLE_LEN                      (8)
-#define RADIOLIB_LW_GFSK_SYNC_WORD                         (0xC194C1)
-#define RADIOLIB_LW_GFSK_PREAMBLE_LEN                      (5)
+#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)
 
 // MAC header field encoding                                                    MSB   LSB   DESCRIPTION
-#define RADIOLIB_LW_MHDR_MTYPE_JOIN_REQUEST                (0x00 << 5) //  7     5     message type: join request
-#define RADIOLIB_LW_MHDR_MTYPE_JOIN_ACCEPT                 (0x01 << 5) //  7     5                   join accept
-#define RADIOLIB_LW_MHDR_MTYPE_UNCONF_DATA_UP              (0x02 << 5) //  7     5                   unconfirmed data up
-#define RADIOLIB_LW_MHDR_MTYPE_UNCONF_DATA_DOWN            (0x03 << 5) //  7     5                   unconfirmed data down
-#define RADIOLIB_LW_MHDR_MTYPE_CONF_DATA_UP                (0x04 << 5) //  7     5                   confirmed data up
-#define RADIOLIB_LW_MHDR_MTYPE_CONF_DATA_DOWN              (0x05 << 5) //  7     5                   confirmed data down
-#define RADIOLIB_LW_MHDR_MTYPE_PROPRIETARY                 (0x07 << 5) //  7     5                   proprietary
-#define RADIOLIB_LW_MHDR_MTYPE_MASK                        (0x07 << 5) //  7     5                   bitmask of all possible options
-#define RADIOLIB_LW_MHDR_MAJOR_R1                          (0x00 << 0) //  1     0     major version: LoRaWAN R1
+#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_LW_FCTRL_ADR_ENABLED                      (0x01 << 7) //  7     7     adaptive data rate: enabled
-#define RADIOLIB_LW_FCTRL_ADR_DISABLED                     (0x00 << 7) //  7     7                         disabled
-#define RADIOLIB_LW_FCTRL_ADR_ACK_REQ                      (0x01 << 6) //  6     6     adaptive data rate ACK request
-#define RADIOLIB_LW_FCTRL_ACK                              (0x01 << 5) //  5     5     confirmed message acknowledge
-#define RADIOLIB_LW_FCTRL_FRAME_PENDING                    (0x01 << 4) //  4     4     downlink frame is pending
+#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_LW_FPORT_MAC_COMMAND                      (0x00 << 0) //  7     0     payload contains MAC commands only
-#define RADIOLIB_LW_FPORT_RESERVED                         (0xE0 << 0) //  7     0     reserved fPort values
+#define RADIOLIB_LORAWAN_FPORT_MAC_COMMAND                      (0x00 << 0) //  7     0     payload contains MAC commands only
+#define RADIOLIB_LORAWAN_FPORT_RESERVED                         (0xE0 << 0) //  7     0     reserved fPort values
 
 // MAC commands - only those sent from end-device to gateway
-#define RADIOLIB_LW_LINK_CHECK_REQ                         (0x02 << 0) //  7     0     MAC command: request to check connectivity to network
-#define RADIOLIB_LW_LINK_ADR_ANS                           (0x03 << 0) //  7     0                  answer to ADR change
-#define RADIOLIB_LW_DUTY_CYCLE_ANS                         (0x04 << 0) //  7     0                  answer to duty cycle change
-#define RADIOLIB_LW_RX_PARAM_SETUP_ANS                     (0x05 << 0) //  7     0                  answer to reception slot setup request
-#define RADIOLIB_LW_DEV_STATUS_ANS                         (0x06 << 0) //  7     0                  device status information
-#define RADIOLIB_LW_NEW_CHANNEL_ANS                        (0x07 << 0) //  7     0                  acknowledges change of a radio channel
-#define RADIOLIB_LW_RX_TIMING_SETUP_ANS                    (0x08 << 0) //  7     0                  acknowledges change of a reception slots timing
+#define RADIOLIB_LORAWAN_LINK_CHECK_REQ                         (0x02 << 0) //  7     0     MAC command: request to check connectivity to network
+#define RADIOLIB_LORAWAN_LINK_ADR_ANS                           (0x03 << 0) //  7     0                  answer to ADR change
+#define RADIOLIB_LORAWAN_DUTY_CYCLE_ANS                         (0x04 << 0) //  7     0                  answer to duty cycle change
+#define RADIOLIB_LORAWAN_RX_PARAM_SETUP_ANS                     (0x05 << 0) //  7     0                  answer to reception slot setup request
+#define RADIOLIB_LORAWAN_DEV_STATUS_ANS                         (0x06 << 0) //  7     0                  device status information
+#define RADIOLIB_LORAWAN_NEW_CHANNEL_ANS                        (0x07 << 0) //  7     0                  acknowledges change of a radio channel
+#define RADIOLIB_LORAWAN_RX_TIMING_SETUP_ANS                    (0x08 << 0) //  7     0                  acknowledges change of a reception slots timing
 
-#define RADIOLIB_LW_NOPTS_LEN                              (8)
+#define RADIOLIB_LORAWAN_NOPTS_LEN                              (8)
 
 // data rate encoding
-#define RADIOLIB_LW_DATA_RATE_FSK_50_K                     (0x01 << 7) //  7     7     FSK @ 50 kbps
-#define RADIOLIB_LW_DATA_RATE_SF_12                        (0x06 << 4) //  6     4     LoRa spreading factor: SF12
-#define RADIOLIB_LW_DATA_RATE_SF_11                        (0x05 << 4) //  6     4                             SF11
-#define RADIOLIB_LW_DATA_RATE_SF_10                        (0x04 << 4) //  6     4                             SF10
-#define RADIOLIB_LW_DATA_RATE_SF_9                         (0x03 << 4) //  6     4                             SF9
-#define RADIOLIB_LW_DATA_RATE_SF_8                         (0x02 << 4) //  6     4                             SF8
-#define RADIOLIB_LW_DATA_RATE_SF_7                         (0x01 << 4) //  6     4                             SF7
-#define RADIOLIB_LW_DATA_RATE_BW_500_KHZ                   (0x00 << 2) //  3     2     LoRa bandwidth: 500 kHz
-#define RADIOLIB_LW_DATA_RATE_BW_250_KHZ                   (0x01 << 2) //  3     2                     250 kHz
-#define RADIOLIB_LW_DATA_RATE_BW_125_KHZ                   (0x02 << 2) //  3     2                     125 kHz
-#define RADIOLIB_LW_DATA_RATE_BW_RESERVED                  (0x03 << 2) //  3     2                     reserved value
-#define RADIOLIB_LW_DATA_RATE_CR_4_5                       (0x00 << 0) //  1     0     LoRa coding rate: 4/5
-#define RADIOLIB_LW_DATA_RATE_CR_4_6                       (0x01 << 0) //  1     0                       4/6
-#define RADIOLIB_LW_DATA_RATE_CR_4_7                       (0x02 << 0) //  1     0                       4/7
-#define RADIOLIB_LW_DATA_RATE_CR_4_8                       (0x03 << 0) //  1     0                       4/8
-#define RADIOLIB_LW_DATA_RATE_UNUSED                       (0xFF << 0) //  7     0     unused data rate
+#define RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K                     (0x01 << 7) //  7     7     FSK @ 50 kbps
+#define RADIOLIB_LORAWAN_DATA_RATE_SF_12                        (0x06 << 4) //  6     4     LoRa spreading factor: SF12
+#define RADIOLIB_LORAWAN_DATA_RATE_SF_11                        (0x05 << 4) //  6     4                             SF11
+#define RADIOLIB_LORAWAN_DATA_RATE_SF_10                        (0x04 << 4) //  6     4                             SF10
+#define RADIOLIB_LORAWAN_DATA_RATE_SF_9                         (0x03 << 4) //  6     4                             SF9
+#define RADIOLIB_LORAWAN_DATA_RATE_SF_8                         (0x02 << 4) //  6     4                             SF8
+#define RADIOLIB_LORAWAN_DATA_RATE_SF_7                         (0x01 << 4) //  6     4                             SF7
+#define RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ                   (0x00 << 2) //  3     2     LoRa bandwidth: 500 kHz
+#define RADIOLIB_LORAWAN_DATA_RATE_BW_250_KHZ                   (0x01 << 2) //  3     2                     250 kHz
+#define RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ                   (0x02 << 2) //  3     2                     125 kHz
+#define RADIOLIB_LORAWAN_DATA_RATE_BW_RESERVED                  (0x03 << 2) //  3     2                     reserved value
+#define RADIOLIB_LORAWAN_DATA_RATE_CR_4_5                       (0x00 << 0) //  1     0     LoRa coding rate: 4/5
+#define RADIOLIB_LORAWAN_DATA_RATE_CR_4_6                       (0x01 << 0) //  1     0                       4/6
+#define RADIOLIB_LORAWAN_DATA_RATE_CR_4_7                       (0x02 << 0) //  1     0                       4/7
+#define RADIOLIB_LORAWAN_DATA_RATE_CR_4_8                       (0x03 << 0) //  1     0                       4/8
+#define RADIOLIB_LORAWAN_DATA_RATE_UNUSED                       (0xFF << 0) //  7     0     unused data rate
 
-#define RADIOLIB_LW_CHANNEL_DIR_UPLINK                     (0x00 << 0)
-#define RADIOLIB_LW_CHANNEL_DIR_DOWNLINK                   (0x01 << 0)
-#define RADIOLIB_LW_CHANNEL_DIR_BOTH                       (0x02 << 0)
-#define RADIOLIB_LW_CHANNEL_DIR_NONE                       (0x03 << 0)
-#define RADIOLIB_LW_BAND_DYNAMIC                           (0)
-#define RADIOLIB_LW_BAND_FIXED                             (1)
-#define RADIOLIB_LW_CHANNEL_NUM_DATARATES                  (15)
-#define RADIOLIB_LW_CHANNEL_INDEX_NONE                     (0xFF >> 0)
+#define RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK                     (0x00 << 0)
+#define RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK                   (0x01 << 0)
+#define RADIOLIB_LORAWAN_CHANNEL_DIR_BOTH                       (0x02 << 0)
+#define RADIOLIB_LORAWAN_CHANNEL_DIR_NONE                       (0x03 << 0)
+#define RADIOLIB_LORAWAN_BAND_DYNAMIC                           (0)
+#define RADIOLIB_LORAWAN_BAND_FIXED                             (1)
+#define RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES                  (15)
+#define RADIOLIB_LORAWAN_CHANNEL_INDEX_NONE                     (0xFF >> 0)
 
 // recommended default settings
-#define RADIOLIB_LW_RECEIVE_DELAY_1_MS                     (1000)
-#define RADIOLIB_LW_RECEIVE_DELAY_2_MS                     ((RADIOLIB_LW_RECEIVE_DELAY_1_MS) + 1000)
-#define RADIOLIB_LW_RX1_DR_OFFSET                          (0)
-#define RADIOLIB_LW_JOIN_ACCEPT_DELAY_1_MS                 (5000)
-#define RADIOLIB_LW_JOIN_ACCEPT_DELAY_2_MS                 (6000)
-#define RADIOLIB_LW_MAX_FCNT_GAP                           (16384)
-#define RADIOLIB_LW_ADR_ACK_LIMIT_EXP                      (0x06)
-#define RADIOLIB_LW_ADR_ACK_DELAY_EXP                      (0x05)
-#define RADIOLIB_LW_RETRANSMIT_TIMEOUT_MIN_MS              (1000)
-#define RADIOLIB_LW_RETRANSMIT_TIMEOUT_MAX_MS              (3000)
-#define RADIOLIB_LW_POWER_STEP_SIZE_DBM                    (-2)
-#define RADIOLIB_LW_REJOIN_MAX_COUNT_N                     (10)  // send rejoin request 16384 uplinks
-#define RADIOLIB_LW_REJOIN_MAX_TIME_N                      (15)  // once every year, not actually implemented
+#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_MAX_FCNT_GAP                           (16384)
+#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_LW_JOIN_REQUEST_LEN                       (23)
-#define RADIOLIB_LW_JOIN_REQUEST_JOIN_EUI_POS              (1)
-#define RADIOLIB_LW_JOIN_REQUEST_DEV_EUI_POS               (9)
-#define RADIOLIB_LW_JOIN_REQUEST_DEV_NONCE_POS             (17)
-#define RADIOLIB_LW_JOIN_REQUEST_TYPE                      (0xFF)
-#define RADIOLIB_LW_JOIN_REQUEST_TYPE_0                    (0x00)
-#define RADIOLIB_LW_JOIN_REQUEST_TYPE_1                    (0x01)
-#define RADIOLIB_LW_JOIN_REQUEST_TYPE_2                    (0x02)
+#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_LW_JOIN_ACCEPT_MAX_LEN                    (33)
-#define RADIOLIB_LW_JOIN_ACCEPT_JOIN_NONCE_POS             (1)
-#define RADIOLIB_LW_JOIN_ACCEPT_HOME_NET_ID_POS            (4)
-#define RADIOLIB_LW_JOIN_ACCEPT_DEV_ADDR_POS               (7)
-#define RADIOLIB_LW_JOIN_ACCEPT_JOIN_EUI_POS               (4)
-#define RADIOLIB_LW_JOIN_ACCEPT_DL_SETTINGS_POS            (11)
-#define RADIOLIB_LW_JOIN_ACCEPT_RX_DELAY_POS               (12)
-#define RADIOLIB_LW_JOIN_ACCEPT_DEV_NONCE_POS              (12)
-#define RADIOLIB_LW_JOIN_ACCEPT_CFLIST_POS                 (13)
-#define RADIOLIB_LW_JOIN_ACCEPT_CFLIST_LEN                 (16)
-#define RADIOLIB_LW_JOIN_ACCEPT_CFLIST_TYPE_POS            (RADIOLIB_LW_JOIN_ACCEPT_CFLIST_POS + RADIOLIB_LW_JOIN_ACCEPT_CFLIST_LEN - 1)
+#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_JOIN_EUI_POS               (4)
+#define RADIOLIB_LORAWAN_JOIN_ACCEPT_DL_SETTINGS_POS            (11)
+#define RADIOLIB_LORAWAN_JOIN_ACCEPT_RX_DELAY_POS               (12)
+#define RADIOLIB_LORAWAN_JOIN_ACCEPT_DEV_NONCE_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 message variables
-#define RADIOLIB_LW_JOIN_ACCEPT_R_1_0                      (0x00 << 7) //  7     7     LoRaWAN revision: 1.0
-#define RADIOLIB_LW_JOIN_ACCEPT_R_1_1                      (0x01 << 7) //  7     7                       1.1
-#define RADIOLIB_LW_JOIN_ACCEPT_F_NWK_S_INT_KEY            (0x01)
-#define RADIOLIB_LW_JOIN_ACCEPT_APP_S_KEY                  (0x02)
-#define RADIOLIB_LW_JOIN_ACCEPT_S_NWK_S_INT_KEY            (0x03)
-#define RADIOLIB_LW_JOIN_ACCEPT_NWK_S_ENC_KEY              (0x04)
-#define RADIOLIB_LW_JOIN_ACCEPT_JS_ENC_KEY                 (0x05)
-#define RADIOLIB_LW_JOIN_ACCEPT_JS_INT_KEY                 (0x06)
+#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)
 
 // frame header layout
-#define RADIOLIB_LW_FHDR_LEN_START_OFFS                    (16)
-#define RADIOLIB_LW_FHDR_DEV_ADDR_POS                      (RADIOLIB_LW_FHDR_LEN_START_OFFS + 1)
-#define RADIOLIB_LW_FHDR_FCTRL_POS                         (RADIOLIB_LW_FHDR_LEN_START_OFFS + 5)
-#define RADIOLIB_LW_FHDR_FCNT_POS                          (RADIOLIB_LW_FHDR_LEN_START_OFFS + 6)
-#define RADIOLIB_LW_FHDR_FOPTS_POS                         (RADIOLIB_LW_FHDR_LEN_START_OFFS + 8)
-#define RADIOLIB_LW_FHDR_FOPTS_LEN_MASK                    (0x0F)
-#define RADIOLIB_LW_FHDR_FOPTS_MAX_LEN                     (15)
-#define RADIOLIB_LW_FHDR_FPORT_POS(FOPTS)                  (RADIOLIB_LW_FHDR_LEN_START_OFFS + 8 + (FOPTS))
-#define RADIOLIB_LW_FRAME_PAYLOAD_POS(FOPTS)               (RADIOLIB_LW_FHDR_LEN_START_OFFS + 9 + (FOPTS))
-#define RADIOLIB_LW_FRAME_LEN(PAYLOAD, FOPTS)              (16 + 13 + (PAYLOAD) + (FOPTS))
+#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_LW_BLOCK_MAGIC_POS                        (0)
-#define RADIOLIB_LW_BLOCK_CONF_FCNT_POS                    (1)
-#define RADIOLIB_LW_BLOCK_DIR_POS                          (5)
-#define RADIOLIB_LW_BLOCK_DEV_ADDR_POS                     (6)
-#define RADIOLIB_LW_BLOCK_FCNT_POS                         (10)
+#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_LW_ENC_BLOCK_MAGIC                        (0x01)
-#define RADIOLIB_LW_ENC_BLOCK_COUNTER_ID_POS               (4)
-#define RADIOLIB_LW_ENC_BLOCK_COUNTER_POS                  (15)
+#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_LW_MIC_BLOCK_MAGIC                        (0x49)
-#define RADIOLIB_LW_MIC_BLOCK_LEN_POS                      (15)
-#define RADIOLIB_LW_MIC_DATA_RATE_POS                      (3)
-#define RADIOLIB_LW_MIC_CH_INDEX_POS                       (4)
+#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_LW_DWELL_TIME                             (400)
+#define RADIOLIB_LORAWAN_DWELL_TIME                             (400)
 
 // unused frame counter value
-#define RADIOLIB_LW_FCNT_NONE                              (0xFFFFFFFF)
+#define RADIOLIB_LORAWAN_FCNT_NONE                              (0xFFFFFFFF)
 
 // MAC commands
-#define RADIOLIB_LW_NUM_MAC_COMMANDS                       (16)
+#define RADIOLIB_LORAWAN_NUM_MAC_COMMANDS                       (16)
 
-#define RADIOLIB_LW_MAC_RESET                              (0x01)
-#define RADIOLIB_LW_MAC_LINK_CHECK                         (0x02)
-#define RADIOLIB_LW_MAC_LINK_ADR                           (0x03)
-#define RADIOLIB_LW_MAC_DUTY_CYCLE                         (0x04)
-#define RADIOLIB_LW_MAC_RX_PARAM_SETUP                     (0x05)
-#define RADIOLIB_LW_MAC_DEV_STATUS                         (0x06)
-#define RADIOLIB_LW_MAC_NEW_CHANNEL                        (0x07)
-#define RADIOLIB_LW_MAC_RX_TIMING_SETUP                    (0x08)
-#define RADIOLIB_LW_MAC_TX_PARAM_SETUP                     (0x09)
-#define RADIOLIB_LW_MAC_DL_CHANNEL                         (0x0A)
-#define RADIOLIB_LW_MAC_REKEY                              (0x0B)
-#define RADIOLIB_LW_MAC_ADR_PARAM_SETUP                    (0x0C)
-#define RADIOLIB_LW_MAC_DEVICE_TIME                        (0x0D)
-#define RADIOLIB_LW_MAC_FORCE_REJOIN                       (0x0E)
-#define RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP                 (0x0F)
-#define RADIOLIB_LW_MAC_PROPRIETARY                        (0x80)
+#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_PROPRIETARY                        (0x80)
 
 // the length of internal MAC command queue - hopefully this is enough for most use cases
-#define RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE                 (9)
+#define RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE                 (9)
 
 // the maximum number of simultaneously available channels
-#define RADIOLIB_LW_NUM_AVAILABLE_CHANNELS                 (16)
+#define RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS                 (16)
 
 // maximum MAC command sizes
-#define RADIOLIB_LW_MAX_MAC_COMMAND_LEN_DOWN               (5)
-#define RADIOLIB_LW_MAX_MAC_COMMAND_LEN_UP                 (2)
-#define RADIOLIB_LW_MAX_NUM_ADR_COMMANDS                   (8)
+#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)
 
 /*!
   \struct LoRaWANMacSpec_t
@@ -214,24 +214,24 @@ struct LoRaWANMacSpec_t {
   const bool user;
 };
 
-constexpr LoRaWANMacSpec_t MacTable[RADIOLIB_LW_NUM_MAC_COMMANDS + 1] = {
+constexpr LoRaWANMacSpec_t MacTable[RADIOLIB_LORAWAN_NUM_MAC_COMMANDS + 1] = {
   { 0x00, 0, 0, false }, // not an actual MAC command, exists for index offsetting
-  { RADIOLIB_LW_MAC_RESET,               1, 1, false },
-  { RADIOLIB_LW_MAC_LINK_CHECK,          2, 0, true  },
-  { RADIOLIB_LW_MAC_LINK_ADR,            4, 1, false },
-  { RADIOLIB_LW_MAC_DUTY_CYCLE,          1, 0, false },
-  { RADIOLIB_LW_MAC_RX_PARAM_SETUP,      4, 1, false },
-  { RADIOLIB_LW_MAC_DEV_STATUS,          0, 2, false },
-  { RADIOLIB_LW_MAC_NEW_CHANNEL,         5, 1, false },
-  { RADIOLIB_LW_MAC_RX_TIMING_SETUP,     1, 0, false },
-  { RADIOLIB_LW_MAC_TX_PARAM_SETUP,      1, 0, false },
-  { RADIOLIB_LW_MAC_DL_CHANNEL,          4, 1, false },
-  { RADIOLIB_LW_MAC_REKEY,               1, 1, false },
-  { RADIOLIB_LW_MAC_ADR_PARAM_SETUP,     1, 0, false },
-  { RADIOLIB_LW_MAC_DEVICE_TIME,         5, 0, true  },
-  { RADIOLIB_LW_MAC_FORCE_REJOIN,        2, 0, false },
-  { RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP,  1, 1, false },
-  { RADIOLIB_LW_MAC_PROPRIETARY,         5, 0, true  } 
+  { RADIOLIB_LORAWAN_MAC_RESET,               1, 1, false },
+  { RADIOLIB_LORAWAN_MAC_LINK_CHECK,          2, 0, true  },
+  { RADIOLIB_LORAWAN_MAC_LINK_ADR,            4, 1, false },
+  { RADIOLIB_LORAWAN_MAC_DUTY_CYCLE,          1, 0, false },
+  { RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP,      4, 1, false },
+  { RADIOLIB_LORAWAN_MAC_DEV_STATUS,          0, 2, false },
+  { RADIOLIB_LORAWAN_MAC_NEW_CHANNEL,         5, 1, false },
+  { RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP,     1, 0, false },
+  { RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP,      1, 0, false },
+  { RADIOLIB_LORAWAN_MAC_DL_CHANNEL,          4, 1, false },
+  { RADIOLIB_LORAWAN_MAC_REKEY,               1, 1, false },
+  { RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP,     1, 0, false },
+  { RADIOLIB_LORAWAN_MAC_DEVICE_TIME,         5, 0, true  },
+  { RADIOLIB_LORAWAN_MAC_FORCE_REJOIN,        2, 0, false },
+  { RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP,  1, 1, false },
+  { RADIOLIB_LORAWAN_MAC_PROPRIETARY,         5, 0, true  } 
 };
 
 /*!
@@ -264,59 +264,59 @@ struct LoRaWANMacCommandQueue_t {
   uint8_t len;
 
   /*! \brief MAC command buffer */
-  LoRaWANMacCommand_t commands[RADIOLIB_LW_MAC_COMMAND_QUEUE_SIZE];
+  LoRaWANMacCommand_t commands[RADIOLIB_LORAWAN_MAC_COMMAND_QUEUE_SIZE];
 };
 
-#define RADIOLIB_LW_NONCES_VERSION_VAL (0x0001)
+#define RADIOLIB_LORAWAN_NONCES_VERSION_VAL (0x0001)
 
 enum LoRaWANSchemeBase_t {
-  RADIOLIB_LW_NONCES_START       = 0x00,
-  RADIOLIB_LW_NONCES_VERSION     = RADIOLIB_LW_NONCES_START,                        // 2 bytes
-  RADIOLIB_LW_NONCES_MODE        = RADIOLIB_LW_NONCES_VERSION + sizeof(uint16_t),   // 2 bytes
-  RADIOLIB_LW_NONCES_CLASS       = RADIOLIB_LW_NONCES_MODE + sizeof(uint16_t),      // 1 byte
-  RADIOLIB_LW_NONCES_PLAN        = RADIOLIB_LW_NONCES_CLASS + sizeof(uint8_t),      // 1 byte
-  RADIOLIB_LW_NONCES_CHECKSUM    = RADIOLIB_LW_NONCES_PLAN + sizeof(uint8_t),       // 2 bytes
-  RADIOLIB_LW_NONCES_DEV_NONCE   = RADIOLIB_LW_NONCES_CHECKSUM + sizeof(uint16_t),  // 2 bytes
-  RADIOLIB_LW_NONCES_JOIN_NONCE  = RADIOLIB_LW_NONCES_DEV_NONCE + sizeof(uint16_t), // 3 bytes
-  RADIOLIB_LW_NONCES_ACTIVE      = RADIOLIB_LW_NONCES_JOIN_NONCE + 3,               // 1 byte
-  RADIOLIB_LW_NONCES_SIGNATURE   = RADIOLIB_LW_NONCES_ACTIVE + sizeof(uint8_t),     // 2 bytes
-  RADIOLIB_LW_NONCES_BUF_SIZE    = RADIOLIB_LW_NONCES_SIGNATURE + sizeof(uint16_t)  // Nonces buffer size
+  RADIOLIB_LORAWAN_NONCES_START       = 0x00,
+  RADIOLIB_LORAWAN_NONCES_VERSION     = RADIOLIB_LORAWAN_NONCES_START,                        // 2 bytes
+  RADIOLIB_LORAWAN_NONCES_MODE        = RADIOLIB_LORAWAN_NONCES_VERSION + sizeof(uint16_t),   // 2 bytes
+  RADIOLIB_LORAWAN_NONCES_CLASS       = RADIOLIB_LORAWAN_NONCES_MODE + sizeof(uint16_t),      // 1 byte
+  RADIOLIB_LORAWAN_NONCES_PLAN        = RADIOLIB_LORAWAN_NONCES_CLASS + sizeof(uint8_t),      // 1 byte
+  RADIOLIB_LORAWAN_NONCES_CHECKSUM    = RADIOLIB_LORAWAN_NONCES_PLAN + sizeof(uint8_t),       // 2 bytes
+  RADIOLIB_LORAWAN_NONCES_DEV_NONCE   = RADIOLIB_LORAWAN_NONCES_CHECKSUM + sizeof(uint16_t),  // 2 bytes
+  RADIOLIB_LORAWAN_NONCES_JOIN_NONCE  = RADIOLIB_LORAWAN_NONCES_DEV_NONCE + sizeof(uint16_t), // 3 bytes
+  RADIOLIB_LORAWAN_NONCES_ACTIVE      = RADIOLIB_LORAWAN_NONCES_JOIN_NONCE + 3,               // 1 byte
+  RADIOLIB_LORAWAN_NONCES_SIGNATURE   = RADIOLIB_LORAWAN_NONCES_ACTIVE + sizeof(uint8_t),     // 2 bytes
+  RADIOLIB_LORAWAN_NONCES_BUF_SIZE    = RADIOLIB_LORAWAN_NONCES_SIGNATURE + sizeof(uint16_t)  // Nonces buffer size
 };
 
 enum LoRaWANSchemeSession_t {
-  RADIOLIB_LW_SESSION_START              = 0x00,
-  RADIOLIB_LW_SESSION_NWK_SENC_KEY       = RADIOLIB_LW_SESSION_START,                 // 16 bytes
-  RADIOLIB_LW_SESSION_APP_SKEY           = RADIOLIB_LW_SESSION_NWK_SENC_KEY + RADIOLIB_AES128_BLOCK_SIZE,   // 16 bytes
-  RADIOLIB_LW_SESSION_FNWK_SINT_KEY      = RADIOLIB_LW_SESSION_APP_SKEY + RADIOLIB_AES128_BLOCK_SIZE,       // 16 bytes
-  RADIOLIB_LW_SESSION_SNWK_SINT_KEY      = RADIOLIB_LW_SESSION_FNWK_SINT_KEY + RADIOLIB_AES128_BLOCK_SIZE,  // 16 bytes
-  RADIOLIB_LW_SESSION_DEV_ADDR           = RADIOLIB_LW_SESSION_SNWK_SINT_KEY + RADIOLIB_AES128_BLOCK_SIZE,  // 4 bytes
-  RADIOLIB_LW_SESSION_NONCES_SIGNATURE   = RADIOLIB_LW_SESSION_DEV_ADDR + sizeof(uint32_t),         // 2 bytes
-  RADIOLIB_LW_SESSION_A_FCNT_DOWN        = RADIOLIB_LW_SESSION_NONCES_SIGNATURE + sizeof(uint16_t), // 4 bytes
-  RADIOLIB_LW_SESSION_CONF_FCNT_UP       = RADIOLIB_LW_SESSION_A_FCNT_DOWN + sizeof(uint32_t), 	    // 4 bytes
-  RADIOLIB_LW_SESSION_CONF_FCNT_DOWN     = RADIOLIB_LW_SESSION_CONF_FCNT_UP + sizeof(uint32_t), 	  // 4 bytes
-  RADIOLIB_LW_SESSION_RJ_COUNT0          = RADIOLIB_LW_SESSION_CONF_FCNT_DOWN + sizeof(uint32_t), 	// 2 bytes
-  RADIOLIB_LW_SESSION_RJ_COUNT1          = RADIOLIB_LW_SESSION_RJ_COUNT0 + sizeof(uint16_t), 	      // 2 bytes
-  RADIOLIB_LW_SESSION_HOMENET_ID         = RADIOLIB_LW_SESSION_RJ_COUNT1 + sizeof(uint16_t), 	      // 4 bytes
-  RADIOLIB_LW_SESSION_VERSION            = RADIOLIB_LW_SESSION_HOMENET_ID + sizeof(uint32_t), 	    // 1 byte
-  RADIOLIB_LW_SESSION_DUTY_CYCLE         = RADIOLIB_LW_SESSION_VERSION + sizeof(uint8_t), 	        // 1 byte
-  RADIOLIB_LW_SESSION_RX_PARAM_SETUP     = RADIOLIB_LW_SESSION_DUTY_CYCLE + MacTable[RADIOLIB_LW_MAC_DUTY_CYCLE].lenDn, 	// 4 bytes
-  RADIOLIB_LW_SESSION_RX_TIMING_SETUP    = RADIOLIB_LW_SESSION_RX_PARAM_SETUP + MacTable[RADIOLIB_LW_MAC_RX_PARAM_SETUP].lenDn, 	// 1 byte
-  RADIOLIB_LW_SESSION_TX_PARAM_SETUP     = RADIOLIB_LW_SESSION_RX_TIMING_SETUP + MacTable[RADIOLIB_LW_MAC_RX_TIMING_SETUP].lenDn, 	// 1 byte
-  RADIOLIB_LW_SESSION_ADR_PARAM_SETUP    = RADIOLIB_LW_SESSION_TX_PARAM_SETUP + MacTable[RADIOLIB_LW_MAC_TX_PARAM_SETUP].lenDn, 	// 1 byte
-  RADIOLIB_LW_SESSION_REJOIN_PARAM_SETUP = RADIOLIB_LW_SESSION_ADR_PARAM_SETUP + MacTable[RADIOLIB_LW_MAC_ADR_PARAM_SETUP].lenDn, 	// 1 byte
-  RADIOLIB_LW_SESSION_BEACON_FREQ        = RADIOLIB_LW_SESSION_REJOIN_PARAM_SETUP + MacTable[RADIOLIB_LW_MAC_REJOIN_PARAM_SETUP].lenDn, 	// 3 bytes
-  RADIOLIB_LW_SESSION_PING_SLOT_CHANNEL  = RADIOLIB_LW_SESSION_BEACON_FREQ + 3, 	    // 4 bytes
-  RADIOLIB_LW_SESSION_PERIODICITY        = RADIOLIB_LW_SESSION_PING_SLOT_CHANNEL + 4, // 1 byte
-  RADIOLIB_LW_SESSION_LAST_TIME          = RADIOLIB_LW_SESSION_PERIODICITY + 1, 	    // 4 bytes
-  RADIOLIB_LW_SESSION_UL_CHANNELS        = RADIOLIB_LW_SESSION_LAST_TIME + 4, 	      // 16*5 bytes
-  RADIOLIB_LW_SESSION_DL_CHANNELS        = RADIOLIB_LW_SESSION_UL_CHANNELS + 16*MacTable[RADIOLIB_LW_MAC_NEW_CHANNEL].lenDn, // 16*4 bytes
-  RADIOLIB_LW_SESSION_MAC_QUEUE_UL       = RADIOLIB_LW_SESSION_DL_CHANNELS + 16*MacTable[RADIOLIB_LW_MAC_DL_CHANNEL].lenDn,  // 9*8+2 bytes
-  RADIOLIB_LW_SESSION_N_FCNT_DOWN        = RADIOLIB_LW_SESSION_MAC_QUEUE_UL + sizeof(LoRaWANMacCommandQueue_t), // 4 bytes
-  RADIOLIB_LW_SESSION_ADR_FCNT           = RADIOLIB_LW_SESSION_N_FCNT_DOWN + sizeof(uint32_t),      // 4 bytes
-  RADIOLIB_LW_SESSION_LINK_ADR           = RADIOLIB_LW_SESSION_ADR_FCNT + sizeof(uint32_t),         // 4 bytes
-  RADIOLIB_LW_SESSION_FCNT_UP            = RADIOLIB_LW_SESSION_LINK_ADR + MacTable[RADIOLIB_LW_MAC_LINK_ADR].lenDn,  // 4 bytes
-  RADIOLIB_LW_SESSION_SIGNATURE          = RADIOLIB_LW_SESSION_FCNT_UP + sizeof(uint32_t),          // 2 bytes
-  RADIOLIB_LW_SESSION_BUF_SIZE           = RADIOLIB_LW_SESSION_SIGNATURE + sizeof(uint16_t)         // Session buffer size
+  RADIOLIB_LORAWAN_SESSION_START              = 0x00,
+  RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY       = RADIOLIB_LORAWAN_SESSION_START,                 // 16 bytes
+  RADIOLIB_LORAWAN_SESSION_APP_SKEY           = RADIOLIB_LORAWAN_SESSION_NWK_SENC_KEY + RADIOLIB_AES128_BLOCK_SIZE,   // 16 bytes
+  RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY      = RADIOLIB_LORAWAN_SESSION_APP_SKEY + RADIOLIB_AES128_BLOCK_SIZE,       // 16 bytes
+  RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY      = RADIOLIB_LORAWAN_SESSION_FNWK_SINT_KEY + RADIOLIB_AES128_BLOCK_SIZE,  // 16 bytes
+  RADIOLIB_LORAWAN_SESSION_DEV_ADDR           = RADIOLIB_LORAWAN_SESSION_SNWK_SINT_KEY + RADIOLIB_AES128_BLOCK_SIZE,  // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE   = RADIOLIB_LORAWAN_SESSION_DEV_ADDR + sizeof(uint32_t),         // 2 bytes
+  RADIOLIB_LORAWAN_SESSION_A_FCNT_DOWN        = RADIOLIB_LORAWAN_SESSION_NONCES_SIGNATURE + sizeof(uint16_t), // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_CONF_FCNT_UP       = RADIOLIB_LORAWAN_SESSION_A_FCNT_DOWN + 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_RJ_COUNT0          = RADIOLIB_LORAWAN_SESSION_CONF_FCNT_DOWN + sizeof(uint32_t), 	// 2 bytes
+  RADIOLIB_LORAWAN_SESSION_RJ_COUNT1          = RADIOLIB_LORAWAN_SESSION_RJ_COUNT0 + sizeof(uint16_t), 	      // 2 bytes
+  RADIOLIB_LORAWAN_SESSION_HOMENET_ID         = RADIOLIB_LORAWAN_SESSION_RJ_COUNT1 + sizeof(uint16_t), 	      // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_VERSION            = RADIOLIB_LORAWAN_SESSION_HOMENET_ID + sizeof(uint32_t), 	    // 1 byte
+  RADIOLIB_LORAWAN_SESSION_DUTY_CYCLE         = RADIOLIB_LORAWAN_SESSION_VERSION + sizeof(uint8_t), 	        // 1 byte
+  RADIOLIB_LORAWAN_SESSION_RX_PARAM_SETUP     = RADIOLIB_LORAWAN_SESSION_DUTY_CYCLE + MacTable[RADIOLIB_LORAWAN_MAC_DUTY_CYCLE].lenDn, 	// 4 bytes
+  RADIOLIB_LORAWAN_SESSION_RX_TIMING_SETUP    = RADIOLIB_LORAWAN_SESSION_RX_PARAM_SETUP + MacTable[RADIOLIB_LORAWAN_MAC_RX_PARAM_SETUP].lenDn, 	// 1 byte
+  RADIOLIB_LORAWAN_SESSION_TX_PARAM_SETUP     = RADIOLIB_LORAWAN_SESSION_RX_TIMING_SETUP + MacTable[RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP].lenDn, 	// 1 byte
+  RADIOLIB_LORAWAN_SESSION_ADR_PARAM_SETUP    = RADIOLIB_LORAWAN_SESSION_TX_PARAM_SETUP + MacTable[RADIOLIB_LORAWAN_MAC_TX_PARAM_SETUP].lenDn, 	// 1 byte
+  RADIOLIB_LORAWAN_SESSION_REJOIN_PARAM_SETUP = RADIOLIB_LORAWAN_SESSION_ADR_PARAM_SETUP + MacTable[RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP].lenDn, 	// 1 byte
+  RADIOLIB_LORAWAN_SESSION_BEACON_FREQ        = RADIOLIB_LORAWAN_SESSION_REJOIN_PARAM_SETUP + MacTable[RADIOLIB_LORAWAN_MAC_REJOIN_PARAM_SETUP].lenDn, 	// 3 bytes
+  RADIOLIB_LORAWAN_SESSION_PING_SLOT_CHANNEL  = RADIOLIB_LORAWAN_SESSION_BEACON_FREQ + 3, 	    // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_PERIODICITY        = RADIOLIB_LORAWAN_SESSION_PING_SLOT_CHANNEL + 4, // 1 byte
+  RADIOLIB_LORAWAN_SESSION_LAST_TIME          = RADIOLIB_LORAWAN_SESSION_PERIODICITY + 1, 	    // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_UL_CHANNELS        = RADIOLIB_LORAWAN_SESSION_LAST_TIME + 4, 	      // 16*5 bytes
+  RADIOLIB_LORAWAN_SESSION_DL_CHANNELS        = RADIOLIB_LORAWAN_SESSION_UL_CHANNELS + 16*MacTable[RADIOLIB_LORAWAN_MAC_NEW_CHANNEL].lenDn, // 16*4 bytes
+  RADIOLIB_LORAWAN_SESSION_MAC_QUEUE_UL       = RADIOLIB_LORAWAN_SESSION_DL_CHANNELS + 16*MacTable[RADIOLIB_LORAWAN_MAC_DL_CHANNEL].lenDn,  // 9*8+2 bytes
+  RADIOLIB_LORAWAN_SESSION_N_FCNT_DOWN        = RADIOLIB_LORAWAN_SESSION_MAC_QUEUE_UL + sizeof(LoRaWANMacCommandQueue_t), // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_ADR_FCNT           = RADIOLIB_LORAWAN_SESSION_N_FCNT_DOWN + sizeof(uint32_t),      // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_LINK_ADR           = RADIOLIB_LORAWAN_SESSION_ADR_FCNT + sizeof(uint32_t),         // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_FCNT_UP            = RADIOLIB_LORAWAN_SESSION_LINK_ADR + MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn,  // 4 bytes
+  RADIOLIB_LORAWAN_SESSION_SIGNATURE          = RADIOLIB_LORAWAN_SESSION_FCNT_UP + sizeof(uint32_t),          // 2 bytes
+  RADIOLIB_LORAWAN_SESSION_BUF_SIZE           = RADIOLIB_LORAWAN_SESSION_SIGNATURE + sizeof(uint16_t)         // Session buffer size
 };
 
 /*!
@@ -342,7 +342,7 @@ struct LoRaWANChannel_t {
 };
 
 // alias for unused channel
-#define RADIOLIB_LW_CHANNEL_NONE    { .enabled = false, .idx = RADIOLIB_LW_CHANNEL_INDEX_NONE, .freq = 0, .drMin = 0, .drMax = 0 }
+#define RADIOLIB_LORAWAN_CHANNEL_NONE    { .enabled = false, .idx = RADIOLIB_LORAWAN_CHANNEL_INDEX_NONE, .freq = 0, .drMin = 0, .drMax = 0 }
 
 /*!
   \struct LoRaWANChannelSpan_t
@@ -370,7 +370,7 @@ struct LoRaWANChannelSpan_t {
 };
 
 // alias for unused channel span
-#define RADIOLIB_LW_CHANNEL_SPAN_NONE    { .numChannels = 0, .freqStart = 0, .freqStep = 0, .drMin = 0, .drMax = 0, .joinRequestDataRate = RADIOLIB_LW_DATA_RATE_UNUSED }
+#define RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE    { .numChannels = 0, .freqStart = 0, .freqStep = 0, .drMin = 0, .drMax = 0, .joinRequestDataRate = RADIOLIB_LORAWAN_DATA_RATE_UNUSED }
 
 /*!
   \struct LoRaWANBand_t
@@ -384,7 +384,7 @@ struct LoRaWANBand_t {
   uint8_t bandType;
 
   /*! \brief Array of allowed maximum payload lengths for each data rate */
-  uint8_t payloadLenMax[RADIOLIB_LW_CHANNEL_NUM_DATARATES];
+  uint8_t payloadLenMax[RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES];
 
   /*! \brief Maximum allowed output power in this band in dBm */
   int8_t powerMax;
@@ -423,7 +423,7 @@ struct LoRaWANBand_t {
   LoRaWANChannel_t rx2;
   
   /*! \brief The corresponding datarates, bandwidths and coding rates for DR index */
-  uint8_t dataRates[RADIOLIB_LW_CHANNEL_NUM_DATARATES];
+  uint8_t dataRates[RADIOLIB_LORAWAN_CHANNEL_NUM_DATARATES];
 };
 
 // supported bands
@@ -455,7 +455,7 @@ enum LoRaWANBandNum_t {
 };
 
 // provide easy access to the number of currently supported bands
-#define RADIOLIB_LW_NUM_SUPPORTED_BANDS      (BandLast - BandEU868)
+#define RADIOLIB_LORAWAN_NUM_SUPPORTED_BANDS      (BandLast - BandEU868)
 
 // array of currently supported bands
 extern const LoRaWANBand_t* LoRaWANBands[];
@@ -480,7 +480,7 @@ struct LoRaWANJoinEvent_t {
   \brief Structure to save extra information about uplink/downlink event.
 */
 struct LoRaWANEvent_t {
-  /*! \brief Event direction, one of RADIOLIB_LW_CHANNEL_DIR_* */
+  /*! \brief Event direction, one of RADIOLIB_LORAWAN_CHANNEL_DIR_* */
   uint8_t dir;
   
   /*! \brief Whether the event is confirmed or not (e.g., confirmed uplink sent by user application) */
@@ -534,7 +534,7 @@ class LoRaWANNode {
 
     /*!
       \brief Returns the pointer to the internal buffer that holds the LW base parameters
-      \returns Pointer to uint8_t array of size RADIOLIB_LW_NONCES_BUF_SIZE
+      \returns Pointer to uint8_t array of size RADIOLIB_LORAWAN_NONCES_BUF_SIZE
     */
     uint8_t* getBufferNonces();
 
@@ -547,7 +547,7 @@ class LoRaWANNode {
 
     /*!
       \brief Returns the pointer to the internal buffer that holds the LW session parameters
-      \returns Pointer to uint8_t array of size RADIOLIB_LW_SESSION_BUF_SIZE
+      \returns Pointer to uint8_t array of size RADIOLIB_LORAWAN_SESSION_BUF_SIZE
     */
     uint8_t* getBufferSession();
 
@@ -573,7 +573,7 @@ class LoRaWANNode {
       \param joinDr The datarate at which to send the join-request and any subsequent uplinks (unless ADR is enabled)
       \returns \ref status_codes
     */
-    int16_t activateOTAA(uint8_t initialDr = RADIOLIB_LW_DATA_RATE_UNUSED, LoRaWANJoinEvent_t *joinEvent = NULL);
+    int16_t activateOTAA(uint8_t initialDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED, LoRaWANJoinEvent_t *joinEvent = NULL);
 
     /*!
       \brief Set the device credentials and activation configuration
@@ -592,7 +592,7 @@ class LoRaWANNode {
       \param initialDr The datarate at which to send the first uplink and any subsequent uplinks (unless ADR is enabled)
       \returns \ref status_codes
     */
-    int16_t activateABP(uint8_t initialDr = RADIOLIB_LW_DATA_RATE_UNUSED);
+    int16_t activateABP(uint8_t initialDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED);
 
     /*! \brief Whether there is an ongoing session active */
     bool isActivated();
@@ -863,10 +863,10 @@ class LoRaWANNode {
     void activateCommon(uint8_t initialDr);
 
     // a buffer that holds all LW base parameters that should persist at all times!
-    uint8_t bufferNonces[RADIOLIB_LW_NONCES_BUF_SIZE] = { 0 };
+    uint8_t bufferNonces[RADIOLIB_LORAWAN_NONCES_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_LW_SESSION_BUF_SIZE] = { 0 };
+    uint8_t bufferSession[RADIOLIB_LORAWAN_SESSION_BUF_SIZE] = { 0 };
 
     LoRaWANMacCommandQueue_t commandsUp = { 
       .numCommands = 0,
@@ -879,8 +879,8 @@ class LoRaWANNode {
       .commands = { { .cid = 0, .payload = { 0 }, .len = 0, .repeat = 0, } },
     };
 
-    uint16_t lwMode = RADIOLIB_LW_MODE_NONE;
-    uint8_t lwClass = RADIOLIB_LW_CLASS_A;
+    uint16_t lwMode = RADIOLIB_LORAWAN_MODE_NONE;
+    uint8_t lwClass = RADIOLIB_LORAWAN_CLASS_A;
     bool isActive = false;
 
     uint64_t joinEUI = 0;
@@ -905,16 +905,16 @@ class LoRaWANNode {
 
     // session-specific parameters
     uint32_t homeNetId = 0;
-    uint8_t adrLimitExp = RADIOLIB_LW_ADR_ACK_LIMIT_EXP;
-    uint8_t adrDelayExp = RADIOLIB_LW_ADR_ACK_DELAY_EXP;
+    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_LW_FCNT_NONE;
-    uint32_t confFCntDown = RADIOLIB_LW_FCNT_NONE;
+    uint32_t confFCntUp = RADIOLIB_LORAWAN_FCNT_NONE;
+    uint32_t confFCntDown = RADIOLIB_LORAWAN_FCNT_NONE;
     uint32_t adrFCnt = 0;
 
     // whether the current configured channel is in FSK mode
@@ -945,13 +945,13 @@ class LoRaWANNode {
     uint8_t difsSlots;
 
     // available channel frequencies from list passed during OTA activation
-    LoRaWANChannel_t availableChannels[2][RADIOLIB_LW_NUM_AVAILABLE_CHANNELS];
+    LoRaWANChannel_t availableChannels[2][RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS];
 
     // currently configured channels for TX and RX1
-    LoRaWANChannel_t currentChannels[2] = { RADIOLIB_LW_CHANNEL_NONE, RADIOLIB_LW_CHANNEL_NONE };
+    LoRaWANChannel_t currentChannels[2] = { RADIOLIB_LORAWAN_CHANNEL_NONE, RADIOLIB_LORAWAN_CHANNEL_NONE };
 
     // currently configured datarates for TX and RX1
-    uint8_t dataRates[2] = { RADIOLIB_LW_DATA_RATE_UNUSED, RADIOLIB_LW_DATA_RATE_UNUSED };
+    uint8_t dataRates[2] = { RADIOLIB_LORAWAN_DATA_RATE_UNUSED, RADIOLIB_LORAWAN_DATA_RATE_UNUSED };
 
     // LoRaWAN revision (1.0 vs 1.1)
     uint8_t rev = 0;
@@ -966,7 +966,7 @@ class LoRaWANNode {
     RadioLibTime_t rxDelayEnd = 0;
 
     // delays between the uplink and RX1/2 windows
-    RadioLibTime_t rxDelays[2] = { RADIOLIB_LW_RECEIVE_DELAY_1_MS, RADIOLIB_LW_RECEIVE_DELAY_2_MS };
+    RadioLibTime_t rxDelays[2] = { RADIOLIB_LORAWAN_RECEIVE_DELAY_1_MS, RADIOLIB_LORAWAN_RECEIVE_DELAY_2_MS };
 
     // device status - battery level
     uint8_t battLevel = 0xFF;
diff --git a/src/protocols/LoRaWAN/LoRaWANBands.cpp b/src/protocols/LoRaWAN/LoRaWANBands.cpp
index 2c927f3e..eaeb0841 100644
--- a/src/protocols/LoRaWAN/LoRaWANBands.cpp
+++ b/src/protocols/LoRaWAN/LoRaWANBands.cpp
@@ -3,7 +3,7 @@
 #if !RADIOLIB_EXCLUDE_LORAWAN
 
 // array of pointers to currently supported LoRaWAN bands
-const LoRaWANBand_t* LoRaWANBands[RADIOLIB_LW_NUM_SUPPORTED_BANDS] = {
+const LoRaWANBand_t* LoRaWANBands[RADIOLIB_LORAWAN_NUM_SUPPORTED_BANDS] = {
   &EU868,
   &US915,
   &CN780,
@@ -17,7 +17,7 @@ const LoRaWANBand_t* LoRaWANBands[RADIOLIB_LW_NUM_SUPPORTED_BANDS] = {
 
 const LoRaWANBand_t EU868 = {
   .bandNum = BandEU868,
-  .bandType = RADIOLIB_LW_BAND_DYNAMIC,
+  .bandType = RADIOLIB_LORAWAN_BAND_DYNAMIC,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230, 230, 230,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 16,
   .powerNumSteps = 7,
@@ -30,55 +30,55 @@ const LoRaWANBand_t EU868 = {
     { .enabled = true, .idx = 2, .freq = 868.500, .drMin = 0, .drMax = 5},
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 0,
   .txSpans = {
-    RADIOLIB_LW_CHANNEL_SPAN_NONE,
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
-  .rx1Span = RADIOLIB_LW_CHANNEL_SPAN_NONE,
+  .rx1Span = RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 869.525, .drMin = 0, .drMax = 0 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_250_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_FSK_50_K,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_250_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t US915 = {
   .bandNum = BandUS915,
-  .bandType = RADIOLIB_LW_BAND_FIXED,
+  .bandType = RADIOLIB_LORAWAN_BAND_FIXED,
   .payloadLenMax = {  19,  61, 133, 250, 250,   0,   0,   0,  41, 117, 230, 230, 230, 230,   0 },
   .powerMax = 30,
   .powerNumSteps = 10,
   .dutyCycle = 0,
-  .dwellTimeUp = RADIOLIB_LW_DWELL_TIME,
+  .dwellTimeUp = RADIOLIB_LORAWAN_DWELL_TIME,
   .dwellTimeDn = 0,
   .txFreqs = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 2,
   .txSpans = {
@@ -105,32 +105,32 @@ const LoRaWANBand_t US915 = {
     .freqStep = 0.600,
     .drMin = 8,
     .drMax = 13,
-    .joinRequestDataRate = RADIOLIB_LW_DATA_RATE_UNUSED 
+    .joinRequestDataRate = RADIOLIB_LORAWAN_DATA_RATE_UNUSED 
   },
   .rx1DataRateBase = 10,
   .rx2 = { .enabled = true, .idx = 0, .freq = 923.300, .drMin = 8, .drMax = 8 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t CN780 = {
   .bandNum = BandCN780,
-  .bandType = RADIOLIB_LW_BAND_DYNAMIC,
+  .bandType = RADIOLIB_LORAWAN_BAND_DYNAMIC,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230, 250, 230,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 12,
   .powerNumSteps = 5,
@@ -149,34 +149,34 @@ const LoRaWANBand_t CN780 = {
   },
   .numTxSpans = 0,
   .txSpans = {
-    RADIOLIB_LW_CHANNEL_SPAN_NONE,
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
-  .rx1Span = RADIOLIB_LW_CHANNEL_SPAN_NONE,
+  .rx1Span = RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 786.000, .drMin = 0, .drMax = 0 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_250_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_FSK_50_K,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_250_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t EU433 = {
   .bandNum = BandEU433,
-  .bandType = RADIOLIB_LW_BAND_DYNAMIC,
+  .bandType = RADIOLIB_LORAWAN_BAND_DYNAMIC,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230, 230, 230,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 12,
   .powerNumSteps = 5,
@@ -189,40 +189,40 @@ const LoRaWANBand_t EU433 = {
     { .enabled = true, .idx = 2, .freq = 433.575, .drMin = 0, .drMax = 5},
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 0,
   .txSpans = {
-    RADIOLIB_LW_CHANNEL_SPAN_NONE,
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
-  .rx1Span = RADIOLIB_LW_CHANNEL_SPAN_NONE,
+  .rx1Span = RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 434.665, .drMin = 0, .drMax = 0 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_250_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_FSK_50_K,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_250_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t AU915 = {
   .bandNum = BandAU915,
-  .bandType = RADIOLIB_LW_BAND_FIXED,
+  .bandType = RADIOLIB_LORAWAN_BAND_FIXED,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230, 230,   0,  41, 117, 230, 230, 230, 230,   0 },
   .powerMax = 30,
   .powerNumSteps = 10,
@@ -230,14 +230,14 @@ const LoRaWANBand_t AU915 = {
   .dwellTimeUp = 0,
   .dwellTimeDn = 0,
   .txFreqs = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 2,
   .txSpans = {
@@ -264,32 +264,32 @@ const LoRaWANBand_t AU915 = {
     .freqStep = 0.600,
     .drMin = 8,
     .drMax = 13,
-    .joinRequestDataRate = RADIOLIB_LW_DATA_RATE_UNUSED 
+    .joinRequestDataRate = RADIOLIB_LORAWAN_DATA_RATE_UNUSED 
   },
   .rx1DataRateBase = 8,
   .rx2 = { .enabled = true, .idx = 0, .freq = 923.300, .drMin = 8, .drMax = 8 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_9  | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8  | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7  | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8  | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_9  | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8  | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7  | RADIOLIB_LW_DATA_RATE_BW_500_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9  | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8  | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7  | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8  | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9  | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8  | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7  | RADIOLIB_LORAWAN_DATA_RATE_BW_500_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t CN500 = {
   .bandNum = BandCN500,
-  .bandType = RADIOLIB_LW_BAND_FIXED,
+  .bandType = RADIOLIB_LORAWAN_BAND_FIXED,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230,   0,   0,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 19,
   .powerNumSteps = 7,
@@ -297,14 +297,14 @@ const LoRaWANBand_t CN500 = {
   .dwellTimeUp = 0,
   .dwellTimeDn = 0,
   .txFreqs = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 1,
   .txSpans = {
@@ -316,7 +316,7 @@ const LoRaWANBand_t CN500 = {
       .drMax = 5,
       .joinRequestDataRate = 0
     },
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
   .rx1Span = {
     .numChannels = 48,
@@ -324,78 +324,78 @@ const LoRaWANBand_t CN500 = {
     .freqStep = 0.200,
     .drMin = 0,
     .drMax = 5,
-    .joinRequestDataRate = RADIOLIB_LW_DATA_RATE_UNUSED 
+    .joinRequestDataRate = RADIOLIB_LORAWAN_DATA_RATE_UNUSED 
   },
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 505.300, .drMin = 0, .drMax = 0 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_9  | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_8  | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_SF_7  | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_5,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9  | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8  | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7  | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_5,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t AS923 = {
   .bandNum = BandAS923,
-  .bandType = RADIOLIB_LW_BAND_DYNAMIC,
+  .bandType = RADIOLIB_LORAWAN_BAND_DYNAMIC,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230, 230, 230,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 16,
   .powerNumSteps = 7,
   .dutyCycle = 36000,
-  .dwellTimeUp = RADIOLIB_LW_DWELL_TIME,
-  .dwellTimeDn = RADIOLIB_LW_DWELL_TIME,
+  .dwellTimeUp = RADIOLIB_LORAWAN_DWELL_TIME,
+  .dwellTimeDn = RADIOLIB_LORAWAN_DWELL_TIME,
   .txFreqs = {
     { .enabled = true, .idx = 0, .freq = 923.200, .drMin = 0, .drMax = 5},
     { .enabled = true, .idx = 1, .freq = 923.400, .drMin = 0, .drMax = 5},
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 0,
   .txSpans = {
-    RADIOLIB_LW_CHANNEL_SPAN_NONE,
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
-  .rx1Span = RADIOLIB_LW_CHANNEL_SPAN_NONE,
+  .rx1Span = RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 923.200, .drMin = 2, .drMax = 2 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_250_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_FSK_50_K,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_250_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t KR920 = {
   .bandNum = BandKR920,
-  .bandType = RADIOLIB_LW_BAND_DYNAMIC,
+  .bandType = RADIOLIB_LORAWAN_BAND_DYNAMIC,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230,   0,   0,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 14,
   .powerNumSteps = 7,
@@ -408,40 +408,40 @@ const LoRaWANBand_t KR920 = {
     { .enabled = true, .idx = 2, .freq = 922.500, .drMin = 0, .drMax = 5}
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 0,
   .txSpans = {
-    RADIOLIB_LW_CHANNEL_SPAN_NONE,
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
-  .rx1Span = RADIOLIB_LW_CHANNEL_SPAN_NONE,
+  .rx1Span = RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 921.900, .drMin = 0, .drMax = 0 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };
 
 const LoRaWANBand_t IN865 = {
   .bandNum = BandIN865,
-  .bandType = RADIOLIB_LW_BAND_DYNAMIC,
+  .bandType = RADIOLIB_LORAWAN_BAND_DYNAMIC,
   .payloadLenMax = {  59,  59,  59, 123, 230, 230, 230, 230,   0,   0,   0,   0,   0,   0,   0 },
   .powerMax = 30,
   .powerNumSteps = 10,
@@ -454,34 +454,34 @@ const LoRaWANBand_t IN865 = {
     { .enabled = true, .idx = 2, .freq = 865.9850, .drMin = 0, .drMax = 5}
   },
   .txJoinReq = {
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE,
-    RADIOLIB_LW_CHANNEL_NONE
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_NONE
   },
   .numTxSpans = 0,
   .txSpans = {
-    RADIOLIB_LW_CHANNEL_SPAN_NONE,
-    RADIOLIB_LW_CHANNEL_SPAN_NONE
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
+    RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE
   },
-  .rx1Span = RADIOLIB_LW_CHANNEL_SPAN_NONE,
+  .rx1Span = RADIOLIB_LORAWAN_CHANNEL_SPAN_NONE,
   .rx1DataRateBase = 0,
   .rx2 = { .enabled = true, .idx = 0, .freq = 866.550, .drMin = 2, .drMax = 2 },
   .dataRates = {
-    RADIOLIB_LW_DATA_RATE_SF_12 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_11 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_10 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_9 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_8 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_SF_7 | RADIOLIB_LW_DATA_RATE_BW_125_KHZ | RADIOLIB_LW_DATA_RATE_CR_4_7,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_FSK_50_K,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED,
-    RADIOLIB_LW_DATA_RATE_UNUSED
+    RADIOLIB_LORAWAN_DATA_RATE_SF_12 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_11 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_10 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_9 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_8 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_SF_7 | RADIOLIB_LORAWAN_DATA_RATE_BW_125_KHZ | RADIOLIB_LORAWAN_DATA_RATE_CR_4_7,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_FSK_50_K,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED,
+    RADIOLIB_LORAWAN_DATA_RATE_UNUSED
   }
 };