diff --git a/src/BuildOpt.h b/src/BuildOpt.h
index 4609a1da..a7adfbbc 100644
--- a/src/BuildOpt.h
+++ b/src/BuildOpt.h
@@ -7,14 +7,18 @@
  * Debug output enable.
  * Warning: Debug output will slow down the whole system significantly.
  *          Also, it will result in larger compiled binary.
- * Levels: debug - only main info
- *         verbose - full transcript of all SPI communication
+ * Levels: basic - only main info
+ *         protocol - mainly LoRaWAN stuff, but other protocols as well
+ *         SPI - full transcript of all SPI communication
  */
-#if !defined(RADIOLIB_DEBUG)
-  #define RADIOLIB_DEBUG (0)
+#if !defined(RADIOLIB_DEBUG_BASIC)
+  #define RADIOLIB_DEBUG_BASIC (0)
 #endif
-#if !defined(RADIOLIB_VERBOSE)
-  #define RADIOLIB_VERBOSE (0)
+#if !defined(RADIOLIB_DEBUG_PROTOCOL)
+  #define RADIOLIB_DEBUG_PROTOCOL (0)
+#endif
+#if !defined(RADIOLIB_DEBUG_SPI)
+  #define RADIOLIB_DEBUG_SPI (0)
 #endif
 
 // set which output port should be used for debug output
@@ -469,23 +473,35 @@
   #define RADIOLIB_EXCLUDE_STM32WLX (1)
 #endif
 
+// set the global debug mode flag
+#if RADIOLIB_DEBUG_BASIC || RADIOLIB_DEBUG_PROTOCOL || RADIOLIB_DEBUG_SPI
+  #define RADIOLIB_DEBUG  (1)
+#else
+  #define RADIOLIB_DEBUG  (0)
+#endif
+
 #if RADIOLIB_DEBUG
   #if defined(RADIOLIB_BUILD_ARDUINO)
     #define RADIOLIB_DEBUG_PRINT(...) Module::serialPrintf(__VA_ARGS__)
     #define RADIOLIB_DEBUG_PRINTLN(M, ...) Module::serialPrintf(M "\n", ##__VA_ARGS__)
+    #define RADIOLIB_DEBUG_PRINT_LVL(LEVEL, M, ...) Module::serialPrintf(LEVEL "" M, ##__VA_ARGS__)
+    #define RADIOLIB_DEBUG_PRINTLN_LVL(LEVEL, M, ...) Module::serialPrintf(LEVEL "" M "\n", ##__VA_ARGS__)
 
     // some platforms do not support printf("%f"), so it has to be done this way
-    #define RADIOLIB_DEBUG_PRINT_FLOAT(VAL, DECIMALS) RADIOLIB_DEBUG_PORT.print(VAL, DECIMALS)
+    #define RADIOLIB_DEBUG_PRINT_FLOAT(LEVEL, VAL, DECIMALS) RADIOLIB_DEBUG_PRINT(LEVEL); RADIOLIB_DEBUG_PORT.print(VAL, DECIMALS)
   #else
     #if !defined(RADIOLIB_DEBUG_PRINT)
       #define RADIOLIB_DEBUG_PRINT(...) fprintf(RADIOLIB_DEBUG_PORT, __VA_ARGS__)
+      #define RADIOLIB_DEBUG_PRINT_LVL(LEVEL, M, ...) fprintf(RADIOLIB_DEBUG_PORT, LEVEL "" M, ##__VA_ARGS__)
     #endif
     #if !defined(RADIOLIB_DEBUG_PRINTLN)
       #define RADIOLIB_DEBUG_PRINTLN(M, ...) fprintf(RADIOLIB_DEBUG_PORT, M "\n", ##__VA_ARGS__)
+      #define RADIOLIB_DEBUG_PRINTLN_LVL(LEVEL, M, ...) fprintf(RADIOLIB_DEBUG_PORT, LEVEL "" M "\n", ##__VA_ARGS__)
     #endif
-    #define RADIOLIB_DEBUG_PRINT_FLOAT(VAL, DECIMALS) RADIOLIB_DEBUG_PRINT("%.3f", VAL)
+    #define RADIOLIB_DEBUG_PRINT_FLOAT(LEVEL, VAL, DECIMALS) RADIOLIB_DEBUG_PRINT(LEVEL "%.3f", VAL)
   #endif
-  #define RADIOLIB_DEBUG_HEXDUMP(...) Module::hexdump(__VA_ARGS__)
+
+  #define RADIOLIB_DEBUG_HEXDUMP(LEVEL, ...) RADIOLIB_DEBUG_PRINT(LEVEL); Module::hexdump(__VA_ARGS__)
 #else
   #define RADIOLIB_DEBUG_PRINT(...) {}
   #define RADIOLIB_DEBUG_PRINTLN(...) {}
@@ -493,14 +509,49 @@
   #define RADIOLIB_DEBUG_HEXDUMP(...) {}
 #endif
 
-#if RADIOLIB_VERBOSE
-  #define RADIOLIB_VERBOSE_PRINT(...) RADIOLIB_DEBUG_PRINT(__VA_ARGS__)
-  #define RADIOLIB_VERBOSE_PRINTLN(...) RADIOLIB_DEBUG_PRINTLN(__VA_ARGS__)
+#if RADIOLIB_DEBUG_BASIC
+  #define RADIOLIB_DEBUG_BASIC_PRINT(...) RADIOLIB_DEBUG_PRINT_LVL("RLB_DBG: ", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_BASIC_PRINT_NOTAG(...) RADIOLIB_DEBUG_PRINT_LVL("", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_BASIC_PRINTLN(...) RADIOLIB_DEBUG_PRINTLN_LVL("RLB_DBG: ", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_BASIC_PRINT_FLOAT(...) RADIOLIB_DEBUG_PRINT_FLOAT("RLB_DBG: ", __VA_ARGS__);
+  #define RADIOLIB_DEBUG_BASIC_HEXDUMP(...) RADIOLIB_DEBUG_HEXDUMP("RLB_DBG: ", __VA_ARGS__);
 #else
-  #define RADIOLIB_VERBOSE_PRINT(...) {}
-  #define RADIOLIB_VERBOSE_PRINTLN(...) {}
+  #define RADIOLIB_DEBUG_BASIC_PRINT(...) {}
+  #define RADIOLIB_DEBUG_BASIC_PRINT_NOTAG(...) {}
+  #define RADIOLIB_DEBUG_BASIC_PRINTLN(...) {}
+  #define RADIOLIB_DEBUG_BASIC_PRINT_FLOAT(...) {}
+  #define RADIOLIB_DEBUG_BASIC_HEXDUMP(...) {}
 #endif
 
+#if RADIOLIB_DEBUG_PROTOCOL
+  #define RADIOLIB_DEBUG_PROTOCOL_PRINT(...) RADIOLIB_DEBUG_PRINT_LVL("RLB_PRO: ", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_PROTOCOL_PRINTLN(...) RADIOLIB_DEBUG_PRINTLN_LVL("RLB_PRO: ", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_PROTOCOL_PRINT_FLOAT(...) RADIOLIB_DEBUG_PRINT_FLOAT("RLB_PRO: ", __VA_ARGS__);
+  #define RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(...) RADIOLIB_DEBUG_HEXDUMP("RLB_PRO: ", __VA_ARGS__);
+#else
+  #define RADIOLIB_DEBUG_PROTOCOL_PRINT(...) {}
+  #define RADIOLIB_DEBUG_PROTOCOL_PRINTLN(...) {}
+  #define RADIOLIB_DEBUG_PROTOCOL_PRINT_FLOAT(...) {}
+  #define RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(...) {}
+#endif
+
+#if RADIOLIB_DEBUG_SPI
+  #define RADIOLIB_DEBUG_SPI_PRINT(...) RADIOLIB_DEBUG_PRINT_LVL("RLB_SPI: ", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_SPI_PRINT_NOTAG(...) RADIOLIB_DEBUG_PRINT_LVL("", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_SPI_PRINTLN(...) RADIOLIB_DEBUG_PRINTLN_LVL("RLB_SPI: ", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_SPI_PRINTLN_NOTAG(...) RADIOLIB_DEBUG_PRINTLN_LVL("", __VA_ARGS__)
+  #define RADIOLIB_DEBUG_SPI_PRINT_FLOAT(...) RADIOLIB_DEBUG_PRINT_FLOAT("RLB_SPI: ", __VA_ARGS__);
+  #define RADIOLIB_DEBUG_SPI_HEXDUMP(...) RADIOLIB_DEBUG_HEXDUMP("RLB_SPI: ", __VA_ARGS__);
+#else
+  #define RADIOLIB_DEBUG_SPI_PRINT(...) {}
+  #define RADIOLIB_DEBUG_SPI_PRINT_NOTAG(...) {}
+  #define RADIOLIB_DEBUG_SPI_PRINTLN(...) {}
+  #define RADIOLIB_DEBUG_SPI_PRINTLN_NOTAG(...) {}
+  #define RADIOLIB_DEBUG_SPI_PRINT_FLOAT(...) {}
+  #define RADIOLIB_DEBUG_SPI_HEXDUMP(...) {}
+#endif
+
+
 /*!
   \brief A simple assert macro, will return on error.
 */
diff --git a/src/BuildOptUser.h b/src/BuildOptUser.h
index fc1a5657..d81104d7 100644
--- a/src/BuildOptUser.h
+++ b/src/BuildOptUser.h
@@ -5,7 +5,8 @@
 // most commonly, RADIOLIB_EXCLUDE_* macros
 // or enabling debug output
 
-//#define RADIOLIB_DEBUG    (1)
-//#define RADIOLIB_VERBOSE  (1)
+//#define RADIOLIB_DEBUG_BASIC        (1)   // basic debugging (e.g. reporting GPIO timeouts or module not being found)
+//#define RADIOLIB_DEBUG_PROTOCOL     (1)   // protocol information (e.g. LoRaWAN internal information)
+//#define RADIOLIB_DEBUG_SPI          (1)   // verbose transcription of all SPI communication - produces large debug logs!
 
 #endif
diff --git a/src/Module.cpp b/src/Module.cpp
index b6f8583d..ee170584 100644
--- a/src/Module.cpp
+++ b/src/Module.cpp
@@ -44,10 +44,10 @@ void Module::init() {
   this->hal->init();
   this->hal->pinMode(csPin, this->hal->GpioModeOutput);
   this->hal->digitalWrite(csPin, this->hal->GpioLevelHigh);
-  RADIOLIB_DEBUG_PRINTLN("\nRadioLib Debug Info");
-  RADIOLIB_DEBUG_PRINTLN("Version:  %d.%d.%d.%d", RADIOLIB_VERSION_MAJOR, RADIOLIB_VERSION_MINOR, RADIOLIB_VERSION_PATCH, RADIOLIB_VERSION_EXTRA);
-  RADIOLIB_DEBUG_PRINTLN("Platform: " RADIOLIB_PLATFORM);
-  RADIOLIB_DEBUG_PRINTLN("Compiled: " __DATE__ " " __TIME__ "\n");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("RadioLib Debug Info");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Version:  %d.%d.%d.%d", RADIOLIB_VERSION_MAJOR, RADIOLIB_VERSION_MINOR, RADIOLIB_VERSION_PATCH, RADIOLIB_VERSION_EXTRA);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Platform: " RADIOLIB_PLATFORM);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Compiled: " __DATE__ " " __TIME__ "\n");
 }
 
 void Module::term() {
@@ -89,14 +89,14 @@ int16_t Module::SPIsetRegValue(uint16_t reg, uint8_t value, uint8_t msb, uint8_t
     }
 
     // check failed, print debug info
-    RADIOLIB_DEBUG_PRINTLN();
-    RADIOLIB_DEBUG_PRINTLN("address:\t0x%X", reg);
-    RADIOLIB_DEBUG_PRINTLN("bits:\t\t%d %d", msb, lsb);
-    RADIOLIB_DEBUG_PRINTLN("value:\t\t0x%X", value);
-    RADIOLIB_DEBUG_PRINTLN("current:\t0x%X", currentValue);
-    RADIOLIB_DEBUG_PRINTLN("mask:\t\t0x%X", mask);
-    RADIOLIB_DEBUG_PRINTLN("new:\t\t0x%X", newValue);
-    RADIOLIB_DEBUG_PRINTLN("read:\t\t0x%X", readValue);
+    RADIOLIB_DEBUG_SPI_PRINTLN();
+    RADIOLIB_DEBUG_SPI_PRINTLN("address:\t0x%X", reg);
+    RADIOLIB_DEBUG_SPI_PRINTLN("bits:\t\t%d %d", msb, lsb);
+    RADIOLIB_DEBUG_SPI_PRINTLN("value:\t\t0x%X", value);
+    RADIOLIB_DEBUG_SPI_PRINTLN("current:\t0x%X", currentValue);
+    RADIOLIB_DEBUG_SPI_PRINTLN("mask:\t\t0x%X", mask);
+    RADIOLIB_DEBUG_SPI_PRINTLN("new:\t\t0x%X", newValue);
+    RADIOLIB_DEBUG_SPI_PRINTLN("read:\t\t0x%X", readValue);
 
     return(RADIOLIB_ERR_SPI_WRITE_FAILED);
   #else
@@ -182,19 +182,19 @@ void Module::SPItransfer(uint8_t cmd, uint16_t reg, uint8_t* dataOut, uint8_t* d
   }
 
   // print debug information
-  #if RADIOLIB_VERBOSE
+  #if RADIOLIB_DEBUG_SPI
     uint8_t* debugBuffPtr = NULL;
     if(cmd == SPIwriteCommand) {
-      RADIOLIB_VERBOSE_PRINT("W\t%X\t", reg);
+      RADIOLIB_DEBUG_SPI_PRINT("W\t%X\t", reg);
       debugBuffPtr = &buffOut[this->SPIaddrWidth/8];
     } else if(cmd == SPIreadCommand) {
-      RADIOLIB_VERBOSE_PRINT("R\t%X\t", reg);
+      RADIOLIB_DEBUG_SPI_PRINT("R\t%X\t", reg);
       debugBuffPtr = &buffIn[this->SPIaddrWidth/8];
     }
     for(size_t n = 0; n < numBytes; n++) {
-      RADIOLIB_VERBOSE_PRINT("%X\t", debugBuffPtr[n]);
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("%X\t", debugBuffPtr[n]);
     }
-    RADIOLIB_VERBOSE_PRINTLN();
+    RADIOLIB_DEBUG_SPI_PRINTLN_NOTAG();
   #endif
 
   #if !RADIOLIB_STATIC_ONLY
@@ -291,7 +291,7 @@ int16_t Module::SPItransferStream(uint8_t* cmd, uint8_t cmdLen, bool write, uint
     while(this->hal->digitalRead(this->gpioPin)) {
       this->hal->yield();
       if(this->hal->millis() - start >= timeout) {
-        RADIOLIB_DEBUG_PRINTLN("GPIO pre-transfer timeout, is it connected?");
+        RADIOLIB_DEBUG_BASIC_PRINTLN("GPIO pre-transfer timeout, is it connected?");
         #if !RADIOLIB_STATIC_ONLY
           delete[] buffOut;
           delete[] buffIn;
@@ -318,7 +318,7 @@ int16_t Module::SPItransferStream(uint8_t* cmd, uint8_t cmdLen, bool write, uint
       while(this->hal->digitalRead(this->gpioPin)) {
         this->hal->yield();
         if(this->hal->millis() - start >= timeout) {
-          RADIOLIB_DEBUG_PRINTLN("GPIO post-transfer timeout, is it connected?");
+          RADIOLIB_DEBUG_BASIC_PRINTLN("GPIO post-transfer timeout, is it connected?");
           #if !RADIOLIB_STATIC_ONLY
             delete[] buffOut;
             delete[] buffIn;
@@ -342,31 +342,34 @@ int16_t Module::SPItransferStream(uint8_t* cmd, uint8_t cmdLen, bool write, uint
   }
 
   // print debug information
-  #if RADIOLIB_VERBOSE
+  #if RADIOLIB_DEBUG_SPI
     // print command byte(s)
-    RADIOLIB_VERBOSE_PRINT("CMD");
+    RADIOLIB_DEBUG_SPI_PRINT("CMD");
     if(write) {
-      RADIOLIB_VERBOSE_PRINT("W\t");
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("W\t");
     } else {
-      RADIOLIB_VERBOSE_PRINT("R\t");
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("R\t");
     }
     size_t n = 0;
     for(; n < cmdLen; n++) {
-      RADIOLIB_VERBOSE_PRINT("%X\t", cmd[n]);
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("%X\t", cmd[n]);
     }
-    RADIOLIB_VERBOSE_PRINTLN();
+    RADIOLIB_DEBUG_SPI_PRINTLN_NOTAG();
 
     // print data bytes
-    RADIOLIB_VERBOSE_PRINT("SI\t");
+    RADIOLIB_DEBUG_SPI_PRINT("SI\t");
+    for(n = 0; n < cmdLen; n++) {
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("\t");
+    }
     for(; n < buffLen; n++) {
-      RADIOLIB_VERBOSE_PRINT("%X\t", buffOut[n]);
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("%X\t", buffOut[n]);
     }
-    RADIOLIB_VERBOSE_PRINTLN();
-    RADIOLIB_VERBOSE_PRINT("SO\t");
-    for(n = cmdLen; n < buffLen; n++) {
-      RADIOLIB_VERBOSE_PRINT("%X\t", buffIn[n]);
+    RADIOLIB_DEBUG_SPI_PRINTLN_NOTAG();
+    RADIOLIB_DEBUG_SPI_PRINT("SO\t");
+    for(n = 0; n < buffLen; n++) {
+      RADIOLIB_DEBUG_SPI_PRINT_NOTAG("%X\t", buffIn[n]);
     }
-    RADIOLIB_VERBOSE_PRINTLN();
+    RADIOLIB_DEBUG_SPI_PRINTLN_NOTAG();
   #endif
 
   #if !RADIOLIB_STATIC_ONLY
diff --git a/src/modules/CC1101/CC1101.cpp b/src/modules/CC1101/CC1101.cpp
index fbfa212b..447e0420 100644
--- a/src/modules/CC1101/CC1101.cpp
+++ b/src/modules/CC1101/CC1101.cpp
@@ -21,18 +21,18 @@ int16_t CC1101::begin(float freq, float br, float freqDev, float rxBw, int8_t pw
     if((version == RADIOLIB_CC1101_VERSION_CURRENT) || (version == RADIOLIB_CC1101_VERSION_LEGACY) || (version == RADIOLIB_CC1101_VERSION_CLONE)) {
       flagFound = true;
     } else {
-      RADIOLIB_DEBUG_PRINTLN("CC1101 not found! (%d of 10 tries) RADIOLIB_CC1101_REG_VERSION == 0x%04X, expected 0x0004/0x0014", i + 1, version);
+      RADIOLIB_DEBUG_BASIC_PRINTLN("CC1101 not found! (%d of 10 tries) RADIOLIB_CC1101_REG_VERSION == 0x%04X, expected 0x0004/0x0014", i + 1, version);
       this->mod->hal->delay(10);
       i++;
     }
   }
 
   if(!flagFound) {
-    RADIOLIB_DEBUG_PRINTLN("No CC1101 found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No CC1101 found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   } else {
-    RADIOLIB_DEBUG_PRINTLN("M\tCC1101");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("M\tCC1101");
   }
 
   // configure settings not accessible by API
@@ -916,7 +916,6 @@ void CC1101::setRfSwitchTable(const uint32_t (&pins)[Module::RFSWITCH_MAX_PINS],
 uint8_t CC1101::randomByte() {
   // set mode to Rx
   SPIsendCommand(RADIOLIB_CC1101_CMD_RX);
-  RADIOLIB_DEBUG_PRINTLN("CC1101::randomByte");
 
   // wait a bit for the RSSI reading to stabilise
   this->mod->hal->delay(10);
@@ -1113,7 +1112,7 @@ void CC1101::SPIsendCommand(uint8_t cmd) {
   // stop transfer
   this->mod->hal->spiEndTransaction();
   this->mod->hal->digitalWrite(this->mod->getCs(), this->mod->hal->GpioLevelHigh);
-  RADIOLIB_VERBOSE_PRINTLN("CMD\tW\t%02X\t%02X", cmd, status);
+  RADIOLIB_DEBUG_SPI_PRINTLN("CMD\tW\t%02X\t%02X", cmd, status);
   (void)status;
 }
 
diff --git a/src/modules/RF69/RF69.cpp b/src/modules/RF69/RF69.cpp
index 54e6cc74..a934898e 100644
--- a/src/modules/RF69/RF69.cpp
+++ b/src/modules/RF69/RF69.cpp
@@ -23,18 +23,18 @@ int16_t RF69::begin(float freq, float br, float freqDev, float rxBw, int8_t pwr,
     if(version == RADIOLIB_RF69_CHIP_VERSION) {
       flagFound = true;
     } else {
-      RADIOLIB_DEBUG_PRINTLN("RF69 not found! (%d of 10 tries) RADIOLIB_RF69_REG_VERSION == 0x%04X, expected 0x0024", i + 1, version);
+      RADIOLIB_DEBUG_BASIC_PRINTLN("RF69 not found! (%d of 10 tries) RADIOLIB_RF69_REG_VERSION == 0x%04X, expected 0x0024", i + 1, version);
       this->mod->hal->delay(10);
       i++;
     }
   }
 
   if(!flagFound) {
-    RADIOLIB_DEBUG_PRINTLN("No RF69 found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No RF69 found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   } else {
-    RADIOLIB_DEBUG_PRINTLN("M\tRF69");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("M\tRF69");
   }
 
   // configure settings not accessible by API
diff --git a/src/modules/SX123x/SX1231.cpp b/src/modules/SX123x/SX1231.cpp
index 44ff904d..11424eed 100644
--- a/src/modules/SX123x/SX1231.cpp
+++ b/src/modules/SX123x/SX1231.cpp
@@ -21,23 +21,23 @@ int16_t SX1231::begin(float freq, float br, float freqDev, float rxBw, int8_t po
       flagFound = true;
       this->chipRevision = version;
     } else {
-      RADIOLIB_DEBUG_PRINTLN("SX1231 not found! (%d of 10 tries) RF69_REG_VERSION == 0x%04X, expected 0x0021 / 0x0022 / 0x0023", i + 1, version);
+      RADIOLIB_DEBUG_BASIC_PRINTLN("SX1231 not found! (%d of 10 tries) RF69_REG_VERSION == 0x%04X, expected 0x0021 / 0x0022 / 0x0023", i + 1, version);
       mod->hal->delay(10);
       i++;
     }
   }
 
   if(!flagFound) {
-    RADIOLIB_DEBUG_PRINTLN("No SX1231 found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No SX1231 found!");
     mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tSX1231");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX1231");
 
   // configure settings not accessible by API
   int16_t state = config();
   RADIOLIB_ASSERT(state);
-  RADIOLIB_DEBUG_PRINTLN("M\tRF69");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tRF69");
 
   // configure publicly accessible settings
   state = setFrequency(freq);
diff --git a/src/modules/SX123x/SX1233.cpp b/src/modules/SX123x/SX1233.cpp
index ab8808f9..16c4bca1 100644
--- a/src/modules/SX123x/SX1233.cpp
+++ b/src/modules/SX123x/SX1233.cpp
@@ -22,23 +22,23 @@ int16_t SX1233::begin(float freq, float br, float freqDev, float rxBw, int8_t po
       flagFound = true;
       this->chipRevision = version;
     } else {
-      RADIOLIB_DEBUG_PRINTLN("SX1231 not found! (%d of 10 tries) RF69_REG_VERSION == 0x%04X, expected 0x0021 / 0x0022 / 0x0023", i + 1, version);
+      RADIOLIB_DEBUG_BASIC_PRINTLN("SX1231 not found! (%d of 10 tries) RF69_REG_VERSION == 0x%04X, expected 0x0021 / 0x0022 / 0x0023", i + 1, version);
       mod->hal->delay(10);
       i++;
     }
   }
 
   if(!flagFound) {
-    RADIOLIB_DEBUG_PRINTLN("No SX1233 found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No SX1233 found!");
     mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tSX1233");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX1233");
 
   // configure settings not accessible by API
   int16_t state = config();
   RADIOLIB_ASSERT(state);
-  RADIOLIB_DEBUG_PRINTLN("M\tRF69");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tRF69");
 
   // configure publicly accessible settings
   state = setFrequency(freq);
diff --git a/src/modules/SX126x/SX126x.cpp b/src/modules/SX126x/SX126x.cpp
index 8ba17ac0..716971c5 100644
--- a/src/modules/SX126x/SX126x.cpp
+++ b/src/modules/SX126x/SX126x.cpp
@@ -22,11 +22,11 @@ int16_t SX126x::begin(uint8_t cr, uint8_t syncWord, uint16_t preambleLength, flo
   
   // try to find the SX126x chip
   if(!SX126x::findChip(this->chipType)) {
-    RADIOLIB_DEBUG_PRINTLN("No SX126x found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No SX126x found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tSX126x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX126x");
 
   // BW in kHz and SF are required in order to calculate LDRO for setModulationParams
   // set the defaults, this will get overwritten later anyway
@@ -107,11 +107,11 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL
   
   // try to find the SX126x chip
   if(!SX126x::findChip(this->chipType)) {
-    RADIOLIB_DEBUG_PRINTLN("No SX126x found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No SX126x found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tSX126x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX126x");
 
   // initialize configuration variables (will be overwritten during public settings configuration)
   this->bitRate = 21333;                                  // 48.0 kbps
@@ -246,7 +246,7 @@ int16_t SX126x::transmit(uint8_t* data, size_t len, uint8_t addr) {
     return(RADIOLIB_ERR_UNKNOWN);
   }
 
-  RADIOLIB_DEBUG_PRINTLN("Timeout in %lu us", timeout);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Timeout in %lu us", timeout);
 
   // start transmission
   state = startTransmit(data, len, addr);
@@ -295,7 +295,7 @@ int16_t SX126x::receive(uint8_t* data, size_t len) {
     return(RADIOLIB_ERR_UNKNOWN);
   }
 
-  RADIOLIB_DEBUG_PRINTLN("Timeout in %lu us", timeout);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Timeout in %lu us", timeout);
 
   // start reception
   uint32_t timeoutValue = (uint32_t)((float)timeout / 15.625);
@@ -643,7 +643,7 @@ int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_
 
   uint32_t symbolLength = ((uint32_t)(10 * 1000) << this->spreadingFactor) / (10 * this->bandwidthKhz);
   uint32_t sleepPeriod = symbolLength * sleepSymbols;
-  RADIOLIB_DEBUG_PRINTLN("Auto sleep period: %lu", sleepPeriod);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Auto sleep period: %lu", sleepPeriod);
 
   // when the unit detects a preamble, it starts a timer that will timeout if it doesn't receive a header in time.
   // the duration is sleepPeriod + 2 * wakePeriod.
@@ -654,7 +654,7 @@ int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_
   uint32_t wakePeriod = RADIOLIB_MAX(
     (symbolLength * (senderPreambleLength + 1) - (sleepPeriod - 1000)) / 2, // (A)
     symbolLength * (minSymbols + 1)); //(B)
-  RADIOLIB_DEBUG_PRINTLN("Auto wake period: %lu", wakePeriod);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Auto wake period: %lu", wakePeriod);
 
   // If our sleep period is shorter than our transition time, just use the standard startReceive
   if(sleepPeriod < this->tcxoDelay + 1016) {
@@ -1580,10 +1580,10 @@ int16_t SX126x::uploadPatch(const uint32_t* patch, size_t len, bool nonvolatile)
   RADIOLIB_ASSERT(state);
 
   // check the version
-  #if RADIOLIB_DEBUG
+  #if RADIOLIB_DEBUG_BASIC
   char ver_pre[16];
   this->mod->SPIreadRegisterBurst(RADIOLIB_SX126X_REG_VERSION_STRING, 16, (uint8_t*)ver_pre);
-  RADIOLIB_DEBUG_PRINTLN("Pre-update version string: %s", ver_pre);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Pre-update version string: %s", ver_pre);
   #endif
 
   // enable patch update
@@ -1612,10 +1612,10 @@ int16_t SX126x::uploadPatch(const uint32_t* patch, size_t len, bool nonvolatile)
   this->mod->SPIwriteStream(RADIOLIB_SX126X_CMD_PRAM_UPDATE, NULL, 0);
 
   // check the version again
-  #if RADIOLIB_DEBUG
+  #if RADIOLIB_DEBUG_BASIC
   char ver_post[16];
   this->mod->SPIreadRegisterBurst(RADIOLIB_SX126X_REG_VERSION_STRING, 16, (uint8_t*)ver_post);
-  RADIOLIB_DEBUG_PRINTLN("Post-update version string: %s", ver_post);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Post-update version string: %s", ver_post);
   #endif
 
   return(state);
@@ -1857,12 +1857,12 @@ int16_t SX126x::calibrateImage(float freqMin, float freqMax) {
   int16_t state = this->mod->SPIwriteStream(RADIOLIB_SX126X_CMD_CALIBRATE_IMAGE, data, 2);
 
   // if something failed, show the device errors
-  #if RADIOLIB_DEBUG
+  #if RADIOLIB_DEBUG_BASIC
   if(state != RADIOLIB_ERR_NONE) {
     // unless mode is forced to standby, device errors will be 0
     standby();
     uint16_t errors = getDeviceErrors();
-    RADIOLIB_DEBUG_PRINTLN("Calibration failed, device errors: 0x%X", errors);
+    RADIOLIB_DEBUG_BASIC_PRINTLN("Calibration failed, device errors: 0x%X", errors);
   }
   #endif
   return(state);
@@ -2121,12 +2121,12 @@ int16_t SX126x::config(uint8_t modem) {
   state = this->mod->SPIcheckStream();
 
   // if something failed, show the device errors
-  #if RADIOLIB_DEBUG
+  #if RADIOLIB_DEBUG_BASIC
   if(state != RADIOLIB_ERR_NONE) {
     // unless mode is forced to standby, device errors will be 0
     standby();
     uint16_t errors = getDeviceErrors();
-    RADIOLIB_DEBUG_PRINTLN("Calibration failed, device errors: 0x%X", errors);
+    RADIOLIB_DEBUG_BASIC_PRINTLN("Calibration failed, device errors: 0x%X", errors);
   }
   #endif
 
@@ -2159,15 +2159,15 @@ bool SX126x::findChip(const char* verStr) {
 
     // check version register
     if(strncmp(verStr, version, 6) == 0) {
-      RADIOLIB_DEBUG_PRINTLN("Found SX126x: RADIOLIB_SX126X_REG_VERSION_STRING:");
-      RADIOLIB_DEBUG_HEXDUMP((uint8_t*)version, 16, RADIOLIB_SX126X_REG_VERSION_STRING);
-      RADIOLIB_DEBUG_PRINTLN();
+      RADIOLIB_DEBUG_BASIC_PRINTLN("Found SX126x: RADIOLIB_SX126X_REG_VERSION_STRING:");
+      RADIOLIB_DEBUG_BASIC_HEXDUMP((uint8_t*)version, 16, RADIOLIB_SX126X_REG_VERSION_STRING);
+      RADIOLIB_DEBUG_BASIC_PRINTLN();
       flagFound = true;
     } else {
-      #if RADIOLIB_DEBUG
-        RADIOLIB_DEBUG_PRINTLN("SX126x not found! (%d of 10 tries) RADIOLIB_SX126X_REG_VERSION_STRING:", i + 1);
-        RADIOLIB_DEBUG_HEXDUMP((uint8_t*)version, 16, RADIOLIB_SX126X_REG_VERSION_STRING);
-        RADIOLIB_DEBUG_PRINTLN("Expected string: %s", verStr);
+      #if RADIOLIB_DEBUG_BASIC
+        RADIOLIB_DEBUG_BASIC_PRINTLN("SX126x not found! (%d of 10 tries) RADIOLIB_SX126X_REG_VERSION_STRING:", i + 1);
+        RADIOLIB_DEBUG_BASIC_HEXDUMP((uint8_t*)version, 16, RADIOLIB_SX126X_REG_VERSION_STRING);
+        RADIOLIB_DEBUG_BASIC_PRINTLN("Expected string: %s", verStr);
       #endif
       this->mod->hal->delay(10);
       i++;
diff --git a/src/modules/SX127x/SX127x.cpp b/src/modules/SX127x/SX127x.cpp
index bdf4bae5..7606f001 100644
--- a/src/modules/SX127x/SX127x.cpp
+++ b/src/modules/SX127x/SX127x.cpp
@@ -14,11 +14,11 @@ int16_t SX127x::begin(uint8_t* chipVersions, uint8_t numVersions, uint8_t syncWo
 
   // try to find the SX127x chip
   if(!SX127x::findChip(chipVersions, numVersions)) {
-    RADIOLIB_DEBUG_PRINTLN("No SX127x found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No SX127x found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tSX127x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX127x");
 
   // set mode to standby
   int16_t state = standby();
@@ -65,11 +65,11 @@ int16_t SX127x::beginFSK(uint8_t* chipVersions, uint8_t numVersions, float freqD
 
   // try to find the SX127x chip
   if(!SX127x::findChip(chipVersions, numVersions)) {
-    RADIOLIB_DEBUG_PRINTLN("No SX127x found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No SX127x found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tSX127x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX127x");
 
   // set mode to standby
   int16_t state = standby();
@@ -1554,7 +1554,7 @@ bool SX127x::findChip(uint8_t* vers, uint8_t num) {
     }
 
     if(!flagFound) {
-      RADIOLIB_DEBUG_PRINTLN("SX127x not found! (%d of 10 tries) RADIOLIB_SX127X_REG_VERSION == 0x%04X", i + 1, version);
+      RADIOLIB_DEBUG_BASIC_PRINTLN("SX127x not found! (%d of 10 tries) RADIOLIB_SX127X_REG_VERSION == 0x%04X", i + 1, version);
       this->mod->hal->delay(10);
       i++;
     }
diff --git a/src/modules/SX128x/SX128x.cpp b/src/modules/SX128x/SX128x.cpp
index 07d8661b..55b18dd9 100644
--- a/src/modules/SX128x/SX128x.cpp
+++ b/src/modules/SX128x/SX128x.cpp
@@ -17,7 +17,7 @@ int16_t SX128x::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
   this->mod->SPIstatusCommand = RADIOLIB_SX128X_CMD_GET_STATUS;
   this->mod->SPIstreamType = true;
   this->mod->SPIparseStatusCb = SPIparseStatus;
-  RADIOLIB_DEBUG_PRINTLN("M\tSX128x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX128x");
 
   // initialize LoRa modulation variables
   this->bandwidthKhz = bw;
@@ -78,7 +78,7 @@ int16_t SX128x::beginGFSK(float freq, uint16_t br, float freqDev, int8_t pwr, ui
   this->mod->SPIstatusCommand = RADIOLIB_SX128X_CMD_GET_STATUS;
   this->mod->SPIstreamType = true;
   this->mod->SPIparseStatusCb = SPIparseStatus;
-  RADIOLIB_DEBUG_PRINTLN("M\tSX128x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX128x");
 
   // initialize GFSK modulation variables
   this->bitRateKbps = br;
@@ -147,7 +147,7 @@ int16_t SX128x::beginBLE(float freq, uint16_t br, float freqDev, int8_t pwr, uin
   this->mod->SPIstatusCommand = RADIOLIB_SX128X_CMD_GET_STATUS;
   this->mod->SPIstreamType = true;
   this->mod->SPIparseStatusCb = SPIparseStatus;
-  RADIOLIB_DEBUG_PRINTLN("M\tSX128x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX128x");
 
   // initialize BLE modulation variables
   this->bitRateKbps = br;
@@ -202,7 +202,7 @@ int16_t SX128x::beginFLRC(float freq, uint16_t br, uint8_t cr, int8_t pwr, uint1
   this->mod->SPIstatusCommand = RADIOLIB_SX128X_CMD_GET_STATUS;
   this->mod->SPIstreamType = true;
   this->mod->SPIparseStatusCb = SPIparseStatus;
-  RADIOLIB_DEBUG_PRINTLN("M\tSX128x");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSX128x");
 
   // initialize FLRC modulation variables
   this->bitRateKbps = br;
@@ -308,7 +308,7 @@ int16_t SX128x::transmit(uint8_t* data, size_t len, uint8_t addr) {
   // calculate timeout (500% of expected time-on-air)
   uint32_t timeout = getTimeOnAir(len) * 5;
 
-  RADIOLIB_DEBUG_PRINTLN("Timeout in %lu us", timeout);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Timeout in %lu us", timeout);
 
   // start transmission
   state = startTransmit(data, len, addr);
@@ -341,7 +341,7 @@ int16_t SX128x::receive(uint8_t* data, size_t len) {
   // calculate timeout (1000% of expected time-on-air)
   uint32_t timeout = getTimeOnAir(len) * 10;
 
-  RADIOLIB_DEBUG_PRINTLN("Timeout in %lu us", timeout);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("Timeout in %lu us", timeout);
 
   // start reception
   uint32_t timeoutValue = (uint32_t)((float)timeout / 15.625);
diff --git a/src/modules/Si443x/Si4430.cpp b/src/modules/Si443x/Si4430.cpp
index 45b55356..7f9ed5fb 100644
--- a/src/modules/Si443x/Si4430.cpp
+++ b/src/modules/Si443x/Si4430.cpp
@@ -9,7 +9,7 @@ int16_t Si4430::begin(float freq, float br, float freqDev, float rxBw, int8_t po
   // execute common part
   int16_t state = Si443x::begin(br, freqDev, rxBw, preambleLen);
   RADIOLIB_ASSERT(state);
-  RADIOLIB_DEBUG_PRINTLN("M\tSi4430");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSi4430");
 
   // configure publicly accessible settings
   state = setFrequency(freq);
diff --git a/src/modules/Si443x/Si4431.cpp b/src/modules/Si443x/Si4431.cpp
index 799cec76..c603e6f1 100644
--- a/src/modules/Si443x/Si4431.cpp
+++ b/src/modules/Si443x/Si4431.cpp
@@ -9,7 +9,7 @@ int16_t Si4431::begin(float freq, float br, float freqDev, float rxBw, int8_t po
   // execute common part
   int16_t state = Si443x::begin(br, freqDev, rxBw, preambleLen);
   RADIOLIB_ASSERT(state);
-  RADIOLIB_DEBUG_PRINTLN("M\tSi4431");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSi4431");
 
   // configure publicly accessible settings
   state = setFrequency(freq);
diff --git a/src/modules/Si443x/Si4432.cpp b/src/modules/Si443x/Si4432.cpp
index 40a97226..56690862 100644
--- a/src/modules/Si443x/Si4432.cpp
+++ b/src/modules/Si443x/Si4432.cpp
@@ -9,7 +9,7 @@ int16_t Si4432::begin(float freq, float br, float freqDev, float rxBw, int8_t po
   // execute common part
   int16_t state = Si443x::begin(br, freqDev, rxBw, preambleLen);
   RADIOLIB_ASSERT(state);
-  RADIOLIB_DEBUG_PRINTLN("M\tSi4432");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSi4432");
 
   // configure publicly accessible settings
   state = setFrequency(freq);
diff --git a/src/modules/Si443x/Si443x.cpp b/src/modules/Si443x/Si443x.cpp
index 2097ee58..541f3eb7 100644
--- a/src/modules/Si443x/Si443x.cpp
+++ b/src/modules/Si443x/Si443x.cpp
@@ -15,11 +15,11 @@ int16_t Si443x::begin(float br, float freqDev, float rxBw, uint8_t preambleLen)
 
   // try to find the Si443x chip
   if(!Si443x::findChip()) {
-    RADIOLIB_DEBUG_PRINTLN("No Si443x found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No Si443x found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   } else {
-    RADIOLIB_DEBUG_PRINTLN("M\tSi443x");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("M\tSi443x");
   }
 
   // reset the device
@@ -700,7 +700,7 @@ bool Si443x::findChip() {
     if(version == RADIOLIB_SI443X_DEVICE_VERSION) {
       flagFound = true;
     } else {
-      RADIOLIB_DEBUG_PRINTLN("Si443x not found! (%d of 10 tries) RADIOLIB_SI443X_REG_DEVICE_VERSION == 0x%02X, expected 0x0%X", i + 1, version, RADIOLIB_SI443X_DEVICE_VERSION);
+      RADIOLIB_DEBUG_BASIC_PRINTLN("Si443x not found! (%d of 10 tries) RADIOLIB_SI443X_REG_DEVICE_VERSION == 0x%02X, expected 0x0%X", i + 1, version, RADIOLIB_SI443X_DEVICE_VERSION);
       this->mod->hal->delay(10);
       i++;
     }
@@ -769,9 +769,9 @@ int16_t Si443x::updateClockRecovery() {
   uint16_t rxOsr_fixed = (uint16_t)rxOsr;
 
   // print that whole mess
-  RADIOLIB_DEBUG_PRINTLN("%X\n%X\n%X", bypass, decRate, manch);
-  RADIOLIB_DEBUG_PRINT_FLOAT(rxOsr, 2);
-  RADIOLIB_DEBUG_PRINTLN("\t%d\t%X\n%lu\t%lX\n%d\t%X", rxOsr_fixed, rxOsr_fixed, ncoOff, ncoOff, crGain, crGain);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("%X\n%X\n%X", bypass, decRate, manch);
+  RADIOLIB_DEBUG_BASIC_PRINT_FLOAT(rxOsr, 2);
+  RADIOLIB_DEBUG_BASIC_PRINTLN("\t%d\t%X\n%lu\t%lX\n%d\t%X", rxOsr_fixed, rxOsr_fixed, ncoOff, ncoOff, crGain, crGain);
 
   // update oversampling ratio
   int16_t state = this->mod->SPIsetRegValue(RADIOLIB_SI443X_REG_CLOCK_REC_OFFSET_2, (uint8_t)((rxOsr_fixed & 0x0700) >> 3), 7, 5);
diff --git a/src/modules/nRF24/nRF24.cpp b/src/modules/nRF24/nRF24.cpp
index 3f64f27f..a5429884 100644
--- a/src/modules/nRF24/nRF24.cpp
+++ b/src/modules/nRF24/nRF24.cpp
@@ -23,11 +23,11 @@ int16_t nRF24::begin(int16_t freq, int16_t dr, int8_t pwr, uint8_t addrWidth) {
   // check SPI connection
   int16_t val = this->mod->SPIgetRegValue(RADIOLIB_NRF24_REG_SETUP_AW);
   if(!((val >= 0) && (val <= 3))) {
-    RADIOLIB_DEBUG_PRINTLN("No nRF24 found!");
+    RADIOLIB_DEBUG_BASIC_PRINTLN("No nRF24 found!");
     this->mod->term();
     return(RADIOLIB_ERR_CHIP_NOT_FOUND);
   }
-  RADIOLIB_DEBUG_PRINTLN("M\tnRF24");
+  RADIOLIB_DEBUG_BASIC_PRINTLN("M\tnRF24");
 
   // configure settings inaccessible by public API
   int16_t state = config();
diff --git a/src/protocols/LoRaWAN/LoRaWAN.cpp b/src/protocols/LoRaWAN/LoRaWAN.cpp
index cbbe15a1..fef8ff81 100644
--- a/src/protocols/LoRaWAN/LoRaWAN.cpp
+++ b/src/protocols/LoRaWAN/LoRaWAN.cpp
@@ -71,12 +71,12 @@ int16_t LoRaWANNode::restore() {
   // check the mode value
   uint16_t lwMode = mod->hal->getPersistentParameter<uint16_t>(RADIOLIB_EEPROM_LORAWAN_MODE_ID);
   if(lwMode == RADIOLIB_LORAWAN_MODE_NONE) {
-    #if RADIOLIB_DEBUG
-      RADIOLIB_DEBUG_PRINTLN("mode value not set (no saved session)");
-      RADIOLIB_DEBUG_PRINTLN("first 16 bytes of NVM:");
+    #if RADIOLIB_DEBUG_PROTOCOL
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("mode value not set (no saved session)");
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("first 16 bytes of NVM:");
       uint8_t nvmBuff[16];
       mod->hal->readPersistentStorage(mod->hal->getPersistentAddr(0), nvmBuff, 16);
-      RADIOLIB_DEBUG_HEXDUMP(nvmBuff, 16);
+      RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(nvmBuff, 16);
     #endif
     // the mode value is not set, user will have to do perform the join procedure
     return(RADIOLIB_ERR_NETWORK_NOT_JOINED);
@@ -95,7 +95,7 @@ int16_t LoRaWANNode::restore() {
 
   // get session parameters
   this->rev          = mod->hal->getPersistentParameter<uint8_t>(RADIOLIB_EEPROM_LORAWAN_VERSION_ID);
-  RADIOLIB_DEBUG_PRINTLN("LoRaWAN session: v1.%d", this->rev);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("LoRaWAN session: v1.%d", this->rev);
   this->devNonce     = mod->hal->getPersistentParameter<uint16_t>(RADIOLIB_EEPROM_LORAWAN_DEV_NONCE_ID);
   this->joinNonce    = mod->hal->getPersistentParameter<uint32_t>(RADIOLIB_EEPROM_LORAWAN_JOIN_NONCE_ID);
   this->aFcntDown    = mod->hal->getPersistentParameter<uint32_t>(RADIOLIB_EEPROM_LORAWAN_A_FCNT_DOWN_ID);
@@ -158,7 +158,7 @@ int16_t LoRaWANNode::restore() {
   uint8_t queueBuff[sizeof(LoRaWANMacCommandQueue_t)] = { 0 };
   mod->hal->readPersistentStorage(mod->hal->getPersistentAddr(RADIOLIB_EEPROM_LORAWAN_MAC_QUEUE_UL_ID), queueBuff, sizeof(LoRaWANMacCommandQueue_t));
   memcpy(&this->commandsUp, queueBuff, sizeof(LoRaWANMacCommandQueue_t));
-  RADIOLIB_DEBUG_PRINTLN("Number of MAC commands: %d", this->commandsUp.numCommands);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Number of MAC commands: %d", this->commandsUp.numCommands);
 
   state = this->setPhyProperties();
   RADIOLIB_ASSERT(state);
@@ -257,7 +257,7 @@ int16_t LoRaWANNode::restoreChannels() {
 
   } else {  // RADIOLIB_LORAWAN_BAND_FIXED
     uint8_t numADRCommands = mod->hal->getPersistentParameter<uint8_t>(RADIOLIB_EEPROM_LORAWAN_NUM_ADR_MASKS_ID);
-    RADIOLIB_DEBUG_PRINTLN("Restoring %d stored channel masks", numADRCommands);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Restoring %d stored channel masks", numADRCommands);
     uint8_t numBytes = numADRCommands * MacTable[RADIOLIB_LORAWAN_MAC_LINK_ADR].lenDn;
     uint8_t buffer[RADIOLIB_LORAWAN_MAX_NUM_ADR_COMMANDS * RADIOLIB_LORAWAN_MAX_MAC_COMMAND_LEN_DOWN] = { 0 };
     mod->hal->readPersistentStorage(mod->hal->getPersistentAddr(RADIOLIB_EEPROM_LORAWAN_UL_CHANNELS_ID), buffer, numBytes);
@@ -342,7 +342,7 @@ void LoRaWANNode::beginCommon(uint8_t joinDr) {
       if(joinDr >= this->band->txFreqs[0].drMin && joinDr <= this->band->txFreqs[0].drMax) {
         drUp = joinDr;
       } else {
-        RADIOLIB_DEBUG_PRINTLN("Datarate %d is not valid (min: %d, max %d) - using default", 
+        RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Datarate %d is not valid (min: %d, max %d) - using default", 
                                 joinDr, this->band->txFreqs[0].drMin, this->band->txFreqs[0].drMax);
         joinDr = RADIOLIB_LORAWAN_DATA_RATE_UNUSED;
       }
@@ -464,13 +464,13 @@ int16_t LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKe
     this->joinNonce = mod->hal->getPersistentParameter<uint32_t>(RADIOLIB_EEPROM_LORAWAN_JOIN_NONCE_ID);
   } else {
     // either invalid key checksum or mode, so wipe either way
-    #if RADIOLIB_DEBUG
-      RADIOLIB_DEBUG_PRINTLN("Didn't restore session (checksum: %d, mode: %d)", isValidCheckSum, isValidMode);
-      RADIOLIB_DEBUG_PRINTLN("First 16 bytes of NVM:");
+    #if RADIOLIB_DEBUG_PROTOCOL
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Didn't restore session (checksum: %d, mode: %d)", isValidCheckSum, isValidMode);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("First 16 bytes of NVM:");
       uint8_t nvmBuff[16];
       mod->hal->readPersistentStorage(mod->hal->getPersistentAddr(0), nvmBuff, 16);
-      RADIOLIB_DEBUG_HEXDUMP(nvmBuff, 16);
-      RADIOLIB_DEBUG_PRINTLN("Wiping EEPROM and starting a clean session");
+      RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(nvmBuff, 16);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Wiping EEPROM and starting a clean session");
     #endif
 
     this->wipe();
@@ -529,7 +529,7 @@ int16_t LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKe
   // send it
   state = this->phyLayer->transmit(joinRequestMsg, RADIOLIB_LORAWAN_JOIN_REQUEST_LEN);
   this->rxDelayStart = mod->hal->millis();
-  RADIOLIB_DEBUG_PRINTLN("Join-request sent <-- Rx Delay start");
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Join-request sent <-- Rx Delay start");
   RADIOLIB_ASSERT(state);
 
   // configure Rx delay for join-accept message - these are re-configured once a valid join-request is received
@@ -546,7 +546,7 @@ int16_t LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKe
   // check received length
   size_t lenRx = this->phyLayer->getPacketLength(true);
   if((lenRx != RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN) && (lenRx != RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN - RADIOLIB_LORAWAN_JOIN_ACCEPT_CFLIST_LEN)) {
-    RADIOLIB_DEBUG_PRINTLN("joinAccept reply length mismatch, expected %luB got %luB", RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN, lenRx);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("joinAccept reply length mismatch, expected %luB got %luB", RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN, lenRx);
     return(RADIOLIB_ERR_DOWNLINK_MALFORMED);
   }
 
@@ -560,7 +560,7 @@ int16_t LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKe
 
   // check reply message type
   if((joinAcceptMsgEnc[0] & RADIOLIB_LORAWAN_MHDR_MTYPE_MASK) != RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_ACCEPT) {
-    RADIOLIB_DEBUG_PRINTLN("joinAccept reply message type invalid, expected 0x%02x got 0x%02x", RADIOLIB_LORAWAN_MHDR_MTYPE_JOIN_ACCEPT, joinAcceptMsgEnc[0]);
+    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);
   }
 
@@ -572,13 +572,13 @@ int16_t LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKe
   RadioLibAES128Instance.init(nwkKey);
   RadioLibAES128Instance.encryptECB(&joinAcceptMsgEnc[1], RADIOLIB_LORAWAN_JOIN_ACCEPT_MAX_LEN - 1, &joinAcceptMsg[1]);
   
-  RADIOLIB_DEBUG_PRINTLN("joinAcceptMsg:");
-  RADIOLIB_DEBUG_HEXDUMP(joinAcceptMsg, lenRx);
+  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_LORAWAN_JOIN_ACCEPT_JOIN_NONCE_POS], 3);
 
-  RADIOLIB_DEBUG_PRINTLN("JoinNoncePrev: %d, JoinNonce: %d", this->joinNonce, joinNonceNew);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("JoinNoncePrev: %d, JoinNonce: %d", this->joinNonce, joinNonceNew);
     // JoinNonce received must be greater than the last JoinNonce heard, else error
   if((this->joinNonce > 0) && (joinNonceNew <= this->joinNonce)) {
     return(RADIOLIB_ERR_JOIN_NONCE_INVALID);
@@ -591,7 +591,7 @@ int16_t LoRaWANNode::beginOTAA(uint64_t joinEUI, uint64_t devEUI, uint8_t* nwkKe
   // check LoRaWAN revision (the MIC verification depends on this)
   uint8_t dlSettings = joinAcceptMsg[RADIOLIB_LORAWAN_JOIN_ACCEPT_DL_SETTINGS_POS];
   this->rev = (dlSettings & RADIOLIB_LORAWAN_JOIN_ACCEPT_R_1_1) >> 7;
-  RADIOLIB_DEBUG_PRINTLN("LoRaWAN revision: 1.%d", this->rev);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("LoRaWAN revision: 1.%d", this->rev);
 
   // verify MIC
   if(this->rev == 1) {
@@ -753,13 +753,13 @@ int16_t LoRaWANNode::beginABP(uint32_t addr, uint8_t* nwkSKey, uint8_t* appSKey,
     this->clearSession();
   } else {
     // either invalid key checksum or mode, so wipe either way
-    #if RADIOLIB_DEBUG
-      RADIOLIB_DEBUG_PRINTLN("Didn't restore session (checksum: %d, mode: %d)", isValidCheckSum, isValidMode);
-      RADIOLIB_DEBUG_PRINTLN("First 16 bytes of NVM:");
+    #if RADIOLIB_DEBUG_PROTOCOL
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Didn't restore session (checksum: %d, mode: %d)", isValidCheckSum, isValidMode);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("First 16 bytes of NVM:");
       uint8_t nvmBuff[16];
       mod->hal->readPersistentStorage(mod->hal->getPersistentAddr(0), nvmBuff, 16);
-      RADIOLIB_DEBUG_HEXDUMP(nvmBuff, 16);
-      RADIOLIB_DEBUG_PRINTLN("Wiping EEPROM and starting a clean session");
+      RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(nvmBuff, 16);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Wiping EEPROM and starting a clean session");
     #endif
 
     this->wipe();
@@ -1106,8 +1106,8 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t port, bool isConf
       memcpy(foptsPtr, &cmd, 1 + cmd.len);
       foptsPtr += cmd.len + 1;
     }
-    RADIOLIB_DEBUG_PRINTLN("Uplink MAC payload (%d commands):", this->commandsUp.numCommands);
-    RADIOLIB_DEBUG_HEXDUMP(foptsBuff, foptsLen);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Uplink MAC payload (%d commands):", this->commandsUp.numCommands);
+    RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(foptsBuff, foptsLen);
 
     // pop the commands from back to front
     for (; i >= 0; i--) {
@@ -1154,10 +1154,10 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t port, bool isConf
   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_PRINTLN("FcntUp: %d", this->fcntUp);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("FcntUp: %d", this->fcntUp);
 
-  RADIOLIB_DEBUG_PRINTLN("uplinkMsg pre-MIC:");
-  RADIOLIB_DEBUG_HEXDUMP(uplinkMsg, uplinkMsgLen);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("uplinkMsg pre-MIC:");
+  RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(uplinkMsg, uplinkMsgLen);
 
   // calculate authentication codes
   memcpy(uplinkMsg, block1, RADIOLIB_AES128_BLOCK_SIZE);
@@ -1183,7 +1183,7 @@ int16_t LoRaWANNode::uplink(uint8_t* data, size_t len, uint8_t port, bool isConf
 
   // set the timestamp so that we can measure when to start receiving
   this->rxDelayStart = mod->hal->millis();
-  RADIOLIB_DEBUG_PRINTLN("Uplink sent <-- Rx Delay start");
+  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_LORAWAN_FHDR_LEN_START_OFFS) / 1000;
@@ -1267,11 +1267,11 @@ int16_t LoRaWANNode::downlinkCommon() {
 
     // open Rx window by starting receive with specified timeout
     state = this->phyLayer->startReceive(timeoutMod, irqFlags, irqMask, 0);
-    RADIOLIB_DEBUG_PRINTLN("Opening Rx%d window (%d us timeout)... <-- Rx Delay end ", i+1, timeoutHost);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Opening Rx%d window (%d us timeout)... <-- Rx Delay end ", i+1, timeoutHost);
     
     // wait for the timeout to complete (and a small additional delay)
     mod->hal->delay(timeoutHost / 1000 + scanGuard / 2);
-    RADIOLIB_DEBUG_PRINTLN("Closing Rx%d window", i+1);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Closing Rx%d window", i+1);
 
     // check if the IRQ bit for Rx Timeout is set
     if(!this->phyLayer->isRxTimeout()) {
@@ -1280,7 +1280,7 @@ int16_t LoRaWANNode::downlinkCommon() {
     } else if(i == 0) {
       // nothing in the first window, configure for the second
       this->phyLayer->standby();
-      RADIOLIB_DEBUG_PRINTLN("PHY: Frequency %cL = %6.3f MHz", 'D', this->rx2.freq);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("PHY: Frequency %cL = %6.3f MHz", 'D', this->rx2.freq);
       state = this->phyLayer->setFrequency(this->rx2.freq);
       RADIOLIB_ASSERT(state);
 
@@ -1364,12 +1364,12 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
 
   // get the packet length
   size_t downlinkMsgLen = this->phyLayer->getPacketLength();
-  RADIOLIB_DEBUG_PRINTLN("Downlink message length: %d", downlinkMsgLen);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Downlink message length: %d", downlinkMsgLen);
 
   // check the minimum required frame length
   // an extra byte is subtracted because downlink frames may not have a port
   if(downlinkMsgLen < RADIOLIB_LORAWAN_FRAME_LEN(0, 0) - 1 - RADIOLIB_AES128_BLOCK_SIZE) {
-    RADIOLIB_DEBUG_PRINTLN("Downlink message too short (%lu bytes)", downlinkMsgLen);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Downlink message too short (%lu bytes)", downlinkMsgLen);
     return(RADIOLIB_ERR_DOWNLINK_MALFORMED);
   }
 
@@ -1414,14 +1414,14 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
     LoRaWANNode::hton<uint16_t>(&downlinkMsg[RADIOLIB_LORAWAN_BLOCK_CONF_FCNT_POS], (uint16_t)this->confFcntUp);
   }
   
-  RADIOLIB_DEBUG_PRINTLN("downlinkMsg:");
-  RADIOLIB_DEBUG_HEXDUMP(downlinkMsg, RADIOLIB_AES128_BLOCK_SIZE + downlinkMsgLen);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("downlinkMsg:");
+  RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(downlinkMsg, RADIOLIB_AES128_BLOCK_SIZE + downlinkMsgLen);
 
   // calculate length of FOpts and payload
   uint8_t foptsLen = downlinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS] & RADIOLIB_LORAWAN_FHDR_FOPTS_LEN_MASK;
   int payLen = downlinkMsgLen - 8 - foptsLen - sizeof(uint32_t);
 
-  RADIOLIB_DEBUG_PRINTLN("FOpts: %02X", downlinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS]);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("FOpts: %02X", downlinkMsg[RADIOLIB_LORAWAN_FHDR_FCTRL_POS]);
 
   // in LoRaWAN v1.1, a frame can be a network frame if there is no Application payload
   // i.e., no payload at all (empty frame or FOpts only), or MAC only payload (FPort = 0)
@@ -1439,7 +1439,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       isAppDownlink = false;
     }
   }
-  RADIOLIB_DEBUG_PRINTLN("FOptsLen: %d", foptsLen);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("FOptsLen: %d", foptsLen);
 
   // check the FcntDown value (Network or Application)
   uint32_t fcntDownPrev = 0;
@@ -1449,7 +1449,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
     fcntDownPrev = this->nFcntDown;
   }
 
-  RADIOLIB_DEBUG_PRINTLN("fcnt: %d, fcntPrev: %d, isAppDownlink: %d", fcnt16, fcntDownPrev, (int)isAppDownlink);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("fcnt: %d, fcntPrev: %d, isAppDownlink: %d", fcnt16, fcntDownPrev, (int)isAppDownlink);
 
   // if this is not the first downlink...
   // assume a 16-bit to 32-bit rollover if difference between counters in LSB is smaller than MAX_FCNT_GAP
@@ -1496,7 +1496,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_LORAWAN_FHDR_DEV_ADDR_POS]);
   if(addr != this->devAddr) {
-    RADIOLIB_DEBUG_PRINTLN("Device address mismatch, expected 0x%08X, got 0x%08X", this->devAddr, addr);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Device address mismatch, expected 0x%08X, got 0x%08X", this->devAddr, addr);
     #if !RADIOLIB_STATIC_ONLY
       delete[] downlinkMsg;
     #endif
@@ -1522,8 +1522,8 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       processAES(&downlinkMsg[RADIOLIB_LORAWAN_FRAME_PAYLOAD_POS(0)], (size_t)foptsLen, this->nwkSEncKey, fopts, fcnt32, RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK, 0x00, true);
     }
 
-    RADIOLIB_DEBUG_PRINTLN("fopts:");
-    RADIOLIB_DEBUG_HEXDUMP(fopts, foptsLen);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("fopts:");
+    RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(fopts, foptsLen);
 
     bool hasADR = false;
     uint8_t numADR = 0;
@@ -1538,7 +1538,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       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_LORAWAN_MAC_LINK_ADR) {
-          RADIOLIB_DEBUG_PRINTLN("Encountered non-consecutive block of ADR commands - skipping");
+          RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Encountered non-consecutive block of ADR commands - skipping");
           remLen -= (macLen + 1);
           foptsPtr += (macLen + 1);
           lastCID = cid;
@@ -1557,7 +1557,7 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
         .repeat = (cid == RADIOLIB_LORAWAN_MAC_LINK_ADR ? numADR : (uint8_t)0),
       };
       memcpy(cmd.payload, foptsPtr + 1, macLen);
-      RADIOLIB_DEBUG_PRINTLN("[%02X]: %02X %02X %02X %02X %02X (%d)",
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("[%02X]: %02X %02X %02X %02X %02X (%d)",
                               cmd.cid, cmd.payload[0], cmd.payload[1], cmd.payload[2], cmd.payload[3], cmd.payload[4], cmd.len);
 
       // process the MAC command
@@ -1570,16 +1570,16 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       remLen -= (macLen + 1);
       foptsPtr += (macLen + 1);
       lastCID = cid;
-      RADIOLIB_DEBUG_PRINTLN("Processed: %d, remaining: %d", (macLen + 1), remLen);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Processed: %d, remaining: %d", (macLen + 1), remLen);
     }
 
     #if !RADIOLIB_STATIC_ONLY
       delete[] fopts;
     #endif
 
-    RADIOLIB_DEBUG_PRINTLN("MAC response:");
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("MAC response:");
     for (int i = 0; i < this->commandsUp.numCommands; i++) {
-      RADIOLIB_DEBUG_HEXDUMP(&(this->commandsUp.commands[i].cid), sizeof(LoRaWANMacCommand_t));
+      RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(&(this->commandsUp.commands[i].cid), sizeof(LoRaWANMacCommand_t));
     }
 
     // if FOptsLen for the next uplink is larger than can be piggybacked onto an uplink, send separate uplink
@@ -1598,8 +1598,8 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
         memcpy(foptsPtr, &cmd, 1 + cmd.len);
         foptsPtr += cmd.len + 1;
       }
-      RADIOLIB_DEBUG_PRINTLN("Uplink MAC payload (%d commands):", this->commandsUp.numCommands);
-      RADIOLIB_DEBUG_HEXDUMP(foptsBuff, foptsBufSize);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Uplink MAC payload (%d commands):", this->commandsUp.numCommands);
+      RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(foptsBuff, foptsBufSize);
 
       // pop the commands from back to front
       for (; i >= 0; i--) {
@@ -1614,9 +1614,9 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
       // temporarily lift dutyCycle restrictions to allow immediate MAC response
       bool prevDC = this->dutyCycleEnabled;
       this->dutyCycleEnabled = false;
-      RADIOLIB_DEBUG_PRINTLN("Sending MAC-only uplink .. ");
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Sending MAC-only uplink .. ");
       state = this->uplink(foptsBuff, foptsBufSize, RADIOLIB_LORAWAN_FPORT_MAC_COMMAND);
-      RADIOLIB_DEBUG_PRINTLN(" .. state: %d", state);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN(" .. state: %d", state);
       this->dutyCycleEnabled = prevDC;
 
       #if !RADIOLIB_STATIC_ONLY
@@ -1629,9 +1629,9 @@ int16_t LoRaWANNode::downlink(uint8_t* data, size_t* len, LoRaWANEvent_t* event)
         uint8_t* strDown = new uint8_t[this->band->payloadLenMax[this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK]]];
       #endif
       size_t lenDown = 0;
-      RADIOLIB_DEBUG_PRINTLN("Receiving after MAC-only uplink .. ");
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Receiving after MAC-only uplink .. ");
       state = this->downlink(strDown, &lenDown);
-      RADIOLIB_DEBUG_PRINTLN(" .. state: %d", state);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN(" .. state: %d", state);
       #if !RADIOLIB_STATIC_ONLY
         delete[] strDown;
       #endif
@@ -1767,7 +1767,7 @@ bool LoRaWANNode::verifyMIC(uint8_t* msg, size_t len, uint8_t* key) {
   // calculate the expected value and compare
   uint32_t micCalculated = generateMIC(msg, len - sizeof(uint32_t), key);
   if(micCalculated != micReceived) {
-    RADIOLIB_DEBUG_PRINTLN("MIC mismatch, expected %08x, got %08x", micCalculated, micReceived);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("MIC mismatch, expected %08x, got %08x", micCalculated, micReceived);
     return(false);
   }
 
@@ -1809,7 +1809,7 @@ int16_t LoRaWANNode::setPhyProperties() {
 }
 
 int16_t LoRaWANNode::setupChannelsDyn(bool joinRequest) {
-  RADIOLIB_DEBUG_PRINTLN("Setting up dynamic channels");
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Setting up dynamic channels");
   
   size_t num = 0;
   // copy the default defined channels into the first slots (where Tx = Rx)
@@ -1833,7 +1833,7 @@ int16_t LoRaWANNode::setupChannelsDyn(bool joinRequest) {
   }
 
   for (int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
-    RADIOLIB_DEBUG_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)",
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)",
                             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,
@@ -1854,7 +1854,7 @@ int16_t LoRaWANNode::setupChannelsDyn(bool joinRequest) {
 // setup a subband and its corresponding join-request datarate
 // WARNING: subBand starts at 1 (corresponds to all populair schemes)
 int16_t LoRaWANNode::setupChannelsFix(uint8_t subBand) {
-  RADIOLIB_DEBUG_PRINTLN("Setting up fixed channels (subband %d)", subBand);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Setting up fixed channels (subband %d)", subBand);
   // 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
@@ -1918,7 +1918,7 @@ int16_t LoRaWANNode::setupChannelsFix(uint8_t subBand) {
 }
 
 int16_t LoRaWANNode::processCFList(uint8_t* cfList) {
-  RADIOLIB_DEBUG_PRINTLN("Processing CFList");
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Processing CFList");
   
   if(this->band->bandType == RADIOLIB_LORAWAN_BAND_DYNAMIC) {
     // retrieve number of existing (default) channels
@@ -1987,7 +1987,7 @@ int16_t LoRaWANNode::selectChannels() {
     }
   }
   if(numChannels == 0) {
-    RADIOLIB_DEBUG_PRINTLN("There are no channels defined - are you in ABP mode with no defined subband?");
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("There are no channels defined - are you in ABP mode with no defined subband?");
     return(RADIOLIB_ERR_INVALID_CHANNEL);
   }
   // select a random ID & channel from the list of enabled and possible channels
@@ -2029,7 +2029,7 @@ int16_t LoRaWANNode::setDatarate(uint8_t drUp, bool saveToEeprom) {
     }
   }
   if(!isValidDR) {
-    RADIOLIB_DEBUG_PRINTLN("No defined channel allows datarate %d", drUp);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("No defined channel allows datarate %d", drUp);
     return(RADIOLIB_ERR_INVALID_DATA_RATE);
   }
 
@@ -2171,7 +2171,7 @@ int16_t LoRaWANNode::findDataRate(uint8_t dr, DataRate_t* dataRate) {
     
     dataRate->lora.spreadingFactor = ((dataRateBand & 0x70) >> 4) + 6;
     dataRate->lora.codingRate = (dataRateBand & 0x03) + 5;
-    RADIOLIB_DEBUG_PRINTLN("PHY: SF = %d, BW = %6.3f kHz, CR = 4/%d", 
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("PHY: SF = %d, BW = %6.3f kHz, CR = 4/%d", 
                             dataRate->lora.spreadingFactor, dataRate->lora.bandwidth, dataRate->lora.codingRate);
   }
 
@@ -2180,8 +2180,8 @@ int16_t LoRaWANNode::findDataRate(uint8_t dr, DataRate_t* dataRate) {
 
 int16_t LoRaWANNode::configureChannel(uint8_t dir) {
   // set the frequency
-  RADIOLIB_DEBUG_PRINTLN("");
-  RADIOLIB_DEBUG_PRINTLN("PHY: Frequency %cL = %6.3f MHz", dir ? 'D' : 'U', this->currentChannels[dir].freq);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("");
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("PHY: Frequency %cL = %6.3f MHz", dir ? 'D' : 'U', this->currentChannels[dir].freq);
   int state = this->phyLayer->setFrequency(this->currentChannels[dir].freq);
   RADIOLIB_ASSERT(state);
 
@@ -2265,7 +2265,7 @@ int16_t LoRaWANNode::deleteMacCommand(uint8_t cid, LoRaWANMacCommandQueue_t* que
 }
 
 bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
-  RADIOLIB_DEBUG_PRINTLN("exe MAC CID = %02x, len = %d", cmd->cid, cmd->len);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("exe MAC CID = %02x, len = %d", cmd->cid, cmd->len);
 
   Module* mod = this->phyLayer->getMod();
 #if defined(RADIOLIB_EEPROM_UNSUPPORTED)
@@ -2282,7 +2282,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
     case(RADIOLIB_LORAWAN_MAC_RESET): {
       // get the server version
       uint8_t srvVersion = cmd->payload[0];
-      RADIOLIB_DEBUG_PRINTLN("Server version: 1.%d", srvVersion);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Server version: 1.%d", srvVersion);
       if(srvVersion == this->rev) {
         // valid server version, stop sending the ResetInd MAC command
         deleteMacCommand(RADIOLIB_LORAWAN_MAC_RESET, &this->commandsUp);
@@ -2309,7 +2309,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       uint16_t chMask = LoRaWANNode::ntoh<uint16_t>(&cmd->payload[1]);
       uint8_t chMaskCntl = (cmd->payload[3] & 0x70) >> 4;
       uint8_t nbTrans = cmd->payload[3] & 0x0F;
-      RADIOLIB_DEBUG_PRINTLN("ADR REQ: dataRate = %d, txPower = %d, chMask = 0x%04x, chMaskCntl = %02x, nbTrans = %d", drUp, txPower, chMask, chMaskCntl, nbTrans);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR REQ: dataRate = %d, txPower = %d, chMask = 0x%04x, chMaskCntl = %02x, nbTrans = %d", drUp, txPower, chMask, chMaskCntl, nbTrans);
 
       // apply the configuration
       uint8_t drAck = 0;
@@ -2332,7 +2332,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
           this->dataRates[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK] = drDown;
           drAck = 1;
         } else {
-          RADIOLIB_DEBUG_PRINTLN("ADR failed to configure dataRate %d, code %d!", drUp, state);
+          RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR failed to configure dataRate %d, code %d!", drUp, state);
         }
       
       }
@@ -2373,7 +2373,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
             // if this is the first ADR command in the queue, clear all saved channels
             // so we can apply the new channel mask
             clearChannels = true;
-            RADIOLIB_DEBUG_PRINTLN("ADR mask: clearing channels");
+            RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR mask: clearing channels");
           } else {
             // if this is not the first ADR command, clear the ADR response that was in the queue
             (void)deleteMacCommand(RADIOLIB_LORAWAN_MAC_LINK_ADR, &this->commandsUp);
@@ -2430,13 +2430,13 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       cmd->len = 1;
       cmd->payload[0] = (pwrAck << 2) | (drAck << 1) | (chMaskAck << 0);
       cmd->repeat = 0;  // discard any repeat value that may have been set
-      RADIOLIB_DEBUG_PRINTLN("ADR ANS: status = 0x%02x", cmd->payload[0]);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR ANS: status = 0x%02x", cmd->payload[0]);
       return(true);
     } break;
 
     case(RADIOLIB_LORAWAN_MAC_DUTY_CYCLE): {
       uint8_t maxDutyCycle = cmd->payload[0] & 0x0F;
-      RADIOLIB_DEBUG_PRINTLN("Max duty cycle: 1/2^%d", maxDutyCycle);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Max duty cycle: 1/2^%d", maxDutyCycle);
       if(maxDutyCycle == 0) {
         this->dutyCycle = this->band->dutyCycle;
       } else {
@@ -2462,7 +2462,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       uint8_t rx2Ack = 1;
       uint32_t freqRaw = LoRaWANNode::ntoh<uint32_t>(&cmd->payload[1], 3);
       this->rx2.freq = (float)freqRaw/10000.0;
-      RADIOLIB_DEBUG_PRINTLN("Rx param REQ: rx1DrOffset = %d, rx2DataRate = %d, freq = %f", this->rx1DrOffset, this->rx2.drMax, this->rx2.freq);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Rx param REQ: rx1DrOffset = %d, rx2DataRate = %d, freq = %f", this->rx1DrOffset, this->rx2.drMax, this->rx2.freq);
       
       // apply the configuration
       uint8_t chanAck = 0;
@@ -2482,7 +2482,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       // TODO this should be sent repeatedly until the next downlink
       cmd->len = 1;
       cmd->payload[0] = (rx1OffsAck << 2) | (rx2Ack << 1) | (chanAck << 0);
-      RADIOLIB_DEBUG_PRINTLN("Rx param ANS: status = 0x%02x", cmd->payload[0]);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Rx param ANS: status = 0x%02x", cmd->payload[0]);
       return(true);
     } break;
 
@@ -2493,7 +2493,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       int8_t snr = this->phyLayer->getSNR();
       cmd->payload[0] = snr & 0x3F;
 
-      RADIOLIB_DEBUG_PRINTLN("DevStatus ANS: status = 0x%02x%02x", cmd->payload[0], cmd->payload[1]);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("DevStatus ANS: status = 0x%02x%02x", cmd->payload[0], cmd->payload[1]);
       return(true);
     } break;
 
@@ -2504,7 +2504,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       float freq = (float)freqRaw/10000.0;
       uint8_t maxDr = (cmd->payload[4] & 0xF0) >> 4;
       uint8_t minDr = cmd->payload[4] & 0x0F;
-      RADIOLIB_DEBUG_PRINTLN("New channel: index = %d, freq = %f MHz, maxDr = %d, minDr = %d", chIndex, freq, maxDr, minDr);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("New channel: index = %d, freq = %f MHz, maxDr = %d, minDr = %d", chIndex, freq, maxDr, minDr);
       uint8_t newChAck = 0;
       uint8_t freqAck = 0;
 
@@ -2524,7 +2524,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
         this->phyLayer->setFrequency(this->currentChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_DOWNLINK].freq);
       }
       
-      RADIOLIB_DEBUG_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)", 
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)", 
                               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,
@@ -2542,8 +2542,8 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
     if(saveToEeprom) {
       // save to uplink channels location, to the chIndex-th slot of 5 bytes
       uint8_t payLen = MacTable[RADIOLIB_LORAWAN_MAC_NEW_CHANNEL].lenDn;
-      RADIOLIB_DEBUG_PRINTLN("Saving channel:");
-      RADIOLIB_DEBUG_HEXDUMP(&(cmd->payload[0]), payLen);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Saving channel:");
+      RADIOLIB_DEBUG_PROTOCOL_HEXDUMP(&(cmd->payload[0]), payLen);
       mod->hal->writePersistentStorage(mod->hal->getPersistentAddr(RADIOLIB_EEPROM_LORAWAN_UL_CHANNELS_ID) + chIndex * payLen, &(cmd->payload[0]), payLen);
 
     }
@@ -2561,7 +2561,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       uint8_t chIndex = cmd->payload[0];
       uint32_t freqRaw = LoRaWANNode::ntoh<uint32_t>(&cmd->payload[1], 3);
       float freq = (float)freqRaw/10000.0;
-      RADIOLIB_DEBUG_PRINTLN("DL channel: index = %d, freq = %f MHz", chIndex, freq);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("DL channel: index = %d, freq = %f MHz", chIndex, freq);
       uint8_t freqDlAck = 0;
       uint8_t freqUlAck = 0;
       
@@ -2601,7 +2601,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
     case(RADIOLIB_LORAWAN_MAC_RX_TIMING_SETUP): {
       // get the configuration
       uint8_t delay = cmd->payload[0] & 0x0F;
-      RADIOLIB_DEBUG_PRINTLN("RX timing: delay = %d sec", delay);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("RX timing: delay = %d sec", delay);
       
       // apply the configuration
       if(delay == 0) {
@@ -2632,7 +2632,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       // who the f came up with this ...
       const uint8_t eirpEncoding[] = { 8, 10, 12, 13, 14, 16, 18, 20, 21, 24, 26, 27, 29, 30, 33, 36 };
       this->txPowerMax = eirpEncoding[maxEirpRaw];
-      RADIOLIB_DEBUG_PRINTLN("TX timing: dlDwell = %d, ulDwell = %d, maxEirp = %d dBm", dlDwell, ulDwell, this->txPowerMax);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("TX timing: dlDwell = %d, ulDwell = %d, maxEirp = %d dBm", dlDwell, ulDwell, this->txPowerMax);
 
       this->dwellTimeEnabledUp = ulDwell ? true : false;
       this->dwellTimeUp = ulDwell ? RADIOLIB_LORAWAN_DWELL_TIME : 0;
@@ -2654,7 +2654,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
     case(RADIOLIB_LORAWAN_MAC_REKEY): {
       // get the server version
       uint8_t srvVersion = cmd->payload[0];
-      RADIOLIB_DEBUG_PRINTLN("Server version: 1.%d", srvVersion);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Server version: 1.%d", srvVersion);
       if((srvVersion > 0) && (srvVersion <= this->rev)) {
         // valid server version, stop sending the ReKey MAC command
         deleteMacCommand(RADIOLIB_LORAWAN_MAC_REKEY, &this->commandsUp);
@@ -2665,7 +2665,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
     case(RADIOLIB_LORAWAN_MAC_ADR_PARAM_SETUP): {
       this->adrLimitExp = (cmd->payload[0] & 0xF0) >> 4;
       this->adrDelayExp = cmd->payload[0] & 0x0F;
-      RADIOLIB_DEBUG_PRINTLN("ADR param setup: limitExp = %d, delayExp = %d", this->adrLimitExp, this->adrDelayExp);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("ADR param setup: limitExp = %d, delayExp = %d", this->adrLimitExp, this->adrDelayExp);
 
 #if !defined(RADIOLIB_EEPROM_UNSUPPORTED)
     if(saveToEeprom) {
@@ -2694,7 +2694,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       uint8_t maxRetries = (rejoinReq & 0x0700) >> 8;
       uint8_t rejoinType = (rejoinReq & 0x0070) >> 4;
       uint8_t dr = rejoinReq & 0x000F;
-      RADIOLIB_DEBUG_PRINTLN("Force rejoin: period = %d, maxRetries = %d, rejoinType = %d, dr = %d", period, maxRetries, rejoinType, dr);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Force rejoin: period = %d, maxRetries = %d, rejoinType = %d, dr = %d", period, maxRetries, rejoinType, dr);
       (void)period;
       (void)maxRetries;
       (void)rejoinType;
@@ -2706,7 +2706,7 @@ bool LoRaWANNode::execMacCommand(LoRaWANMacCommand_t* cmd, bool saveToEeprom) {
       // TODO implement this
       uint8_t maxTime = (cmd->payload[0] & 0xF0) >> 4;
       uint8_t maxCount = cmd->payload[0] & 0x0F;
-      RADIOLIB_DEBUG_PRINTLN("Rejoin setup: maxTime = %d, maxCount = %d", maxTime, maxCount);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("Rejoin setup: maxTime = %d, maxCount = %d", maxTime, maxCount);
 
 #if !defined(RADIOLIB_EEPROM_UNSUPPORTED)
     if(saveToEeprom) {
@@ -2751,7 +2751,7 @@ bool LoRaWANNode::applyChannelMaskDyn(uint8_t chMaskCntl, uint16_t chMask) {
   }
 
   for (int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
-    RADIOLIB_DEBUG_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)",
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)",
                             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,
@@ -2770,7 +2770,7 @@ bool LoRaWANNode::applyChannelMaskDyn(uint8_t chMaskCntl, uint16_t chMask) {
 }
 
 bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask, bool clear) {
-  RADIOLIB_DEBUG_PRINTLN("mask[%d] = 0x%04x", chMaskCntl, chMask);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("mask[%d] = 0x%04x", chMaskCntl, chMask);
   if(clear) {
     for(size_t i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
       this->availableChannels[RADIOLIB_LORAWAN_CHANNEL_DIR_UPLINK][i] = RADIOLIB_LORAWAN_CHANNEL_NONE;
@@ -2900,7 +2900,7 @@ bool LoRaWANNode::applyChannelMaskFix(uint8_t chMaskCntl, uint16_t chMask, bool
   }
 
   for (int i = 0; i < RADIOLIB_LORAWAN_NUM_AVAILABLE_CHANNELS; i++) {
-    RADIOLIB_DEBUG_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)",
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("UL: %d %d %6.3f (%d - %d) | DL: %d %d %6.3f (%d - %d)",
                             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,
@@ -2974,7 +2974,7 @@ void LoRaWANNode::performCSMA() {
         bool channelFreeDuringDIFS = true;
         for (uint8_t i = 0; i < this->difsSlots; i++) {
             if (performCAD()) {
-                RADIOLIB_DEBUG_PRINTLN("OCCUPIED CHANNEL DURING DIFS");
+                RADIOLIB_DEBUG_PROTOCOL_PRINTLN("OCCUPIED CHANNEL DURING DIFS");
                 channelFreeDuringDIFS = false;
                 // Channel is occupied during DIFS, hop to another.
                 this->selectChannels();
@@ -2986,7 +2986,7 @@ void LoRaWANNode::performCSMA() {
             // Continue decrementing BO with per each CAD reporting free channel.
             while (BO > 0) {
                 if (performCAD()) {
-                    RADIOLIB_DEBUG_PRINTLN("OCCUPIED CHANNEL DURING BO");
+                    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("OCCUPIED CHANNEL DURING BO");
                     // Channel is busy during CAD, hop to another and return to DIFS state again.
                     this->selectChannels();
                     break;  // Exit loop. Go back to DIFS state.
diff --git a/src/protocols/Morse/Morse.cpp b/src/protocols/Morse/Morse.cpp
index 8ec0c469..90cc2a68 100644
--- a/src/protocols/Morse/Morse.cpp
+++ b/src/protocols/Morse/Morse.cpp
@@ -85,7 +85,7 @@ int MorseClient::read(uint8_t* symbol, uint8_t* len, float low, float high) {
     if((pauseLen >= low*(float)letterSpace) && (pauseLen <= high*(float)letterSpace)) {
       return(RADIOLIB_MORSE_CHAR_COMPLETE);
     } else if(pauseLen > wordSpace) {
-      RADIOLIB_DEBUG_PRINTLN("\n<space>");
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("\n<space>");
       return(RADIOLIB_MORSE_WORD_COMPLETE);
     }
 
@@ -96,15 +96,15 @@ int MorseClient::read(uint8_t* symbol, uint8_t* len, float low, float high) {
     uint32_t signalLen = mod->hal->millis() - signalStart;
 
     if((signalLen >= low*(float)dotLength) && (signalLen <= high*(float)dotLength)) {
-      RADIOLIB_DEBUG_PRINT(".");
+      RADIOLIB_DEBUG_PROTOCOL_PRINT(".");
       (*symbol) |= (RADIOLIB_MORSE_DOT << (*len));
       (*len)++;
     } else if((signalLen >= low*(float)dashLength) && (signalLen <= high*(float)dashLength)) {
-      RADIOLIB_DEBUG_PRINT("-");
+      RADIOLIB_DEBUG_PROTOCOL_PRINT("-");
       (*symbol) |= (RADIOLIB_MORSE_DASH << (*len));
       (*len)++;
     } else {
-      RADIOLIB_DEBUG_PRINTLN("<len=%lums>", signalLen);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("<len=%lums>", signalLen);
     }
   }
 
@@ -122,7 +122,7 @@ size_t MorseClient::write(uint8_t b) {
 
   // inter-word pause (space)
   if(b == ' ') {
-    RADIOLIB_DEBUG_PRINTLN("space");
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("space");
     standby();
     mod->waitForMicroseconds(mod->hal->micros(), wordSpace*1000);
     return(1);
@@ -141,11 +141,11 @@ size_t MorseClient::write(uint8_t b) {
 
     // send dot or dash
     if (code & RADIOLIB_MORSE_DASH) {
-      RADIOLIB_DEBUG_PRINT("-");
+      RADIOLIB_DEBUG_PROTOCOL_PRINT("-");
       transmitDirect(baseFreq, baseFreqHz);
       mod->waitForMicroseconds(mod->hal->micros(), dashLength*1000);
     } else {
-      RADIOLIB_DEBUG_PRINT(".");
+      RADIOLIB_DEBUG_PROTOCOL_PRINT(".");
       transmitDirect(baseFreq, baseFreqHz);
       mod->waitForMicroseconds(mod->hal->micros(), dotLength*1000);
     }
@@ -161,7 +161,7 @@ size_t MorseClient::write(uint8_t b) {
   // letter space
   standby();
   mod->waitForMicroseconds(mod->hal->micros(), letterSpace*1000 - dotLength*1000);
-  RADIOLIB_DEBUG_PRINTLN();
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN();
 
   return(1);
 }
diff --git a/src/protocols/Pager/Pager.cpp b/src/protocols/Pager/Pager.cpp
index 989338c8..1db47da6 100644
--- a/src/protocols/Pager/Pager.cpp
+++ b/src/protocols/Pager/Pager.cpp
@@ -554,7 +554,7 @@ uint32_t PagerClient::read() {
     codeWord = ~codeWord;
   }
 
-  RADIOLIB_VERBOSE_PRINTLN("R\t%lX", codeWord);
+  RADIOLIB_DEBUG_PROTOCOL_PRINTLN("R\t%lX", codeWord);
   // TODO BCH error correction here
   return(codeWord);
 }
diff --git a/src/protocols/PhysicalLayer/PhysicalLayer.cpp b/src/protocols/PhysicalLayer/PhysicalLayer.cpp
index f5ca56ca..a1b51730 100644
--- a/src/protocols/PhysicalLayer/PhysicalLayer.cpp
+++ b/src/protocols/PhysicalLayer/PhysicalLayer.cpp
@@ -413,7 +413,7 @@ void PhysicalLayer::updateDirectBuffer(uint8_t bit) {
     this->syncBuffer <<= 1;
     this->syncBuffer |= bit;
 
-    RADIOLIB_VERBOSE_PRINTLN("S\t%lu", this->syncBuffer);
+    RADIOLIB_DEBUG_PROTOCOL_PRINTLN("S\t%lu", this->syncBuffer);
 
     if((this->syncBuffer & this->directSyncWordMask) == this->directSyncWord) {
       this->gotSync = true;
@@ -434,7 +434,7 @@ void PhysicalLayer::updateDirectBuffer(uint8_t bit) {
     // check complete byte
     if(this->bufferBitPos == 8) {
       this->buffer[this->bufferWritePos] = Module::reflect(this->buffer[this->bufferWritePos], 8);
-      RADIOLIB_VERBOSE_PRINTLN("R\t%X", this->buffer[this->bufferWritePos]);
+      RADIOLIB_DEBUG_PROTOCOL_PRINTLN("R\t%X", this->buffer[this->bufferWritePos]);
 
       this->bufferWritePos++;
       this->bufferBitPos = 0;