diff --git a/examples/SX128x/SX128x_BLE_Modem/SX128x_BLE_Modem.ino b/examples/SX128x/SX128x_BLE_Modem/SX128x_BLE_Modem.ino
index 96a96ffa..3d9f5abd 100644
--- a/examples/SX128x/SX128x_BLE_Modem/SX128x_BLE_Modem.ino
+++ b/examples/SX128x/SX128x_BLE_Modem/SX128x_BLE_Modem.ino
@@ -38,7 +38,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.beginBLE();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -59,7 +59,7 @@ void setup() {
   state = radio.setOutputPower(5);
   state = radio.setDataShaping(1.0);
   state = radio.setAccessAddress(0x12345678);
-  if (state != ERR_NONE) {
+  if (state != RADIOLIB_ERR_NONE) {
     Serial.print(F("Unable to set configuration, code "));
     Serial.println(state);
     while (true);
@@ -79,11 +79,11 @@ void loop() {
                       0x89, 0xAB, 0xCD, 0xEF};
     int state = radio.transmit(byteArr, 8);
   */
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("[SX1280] Packet transmitted successfully!"));
-  } else if (state == ERR_PACKET_TOO_LONG) {
+  } else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
     Serial.println(F("[SX1280] Packet too long!"));
-  } else if (state == ERR_TX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_TX_TIMEOUT) {
     Serial.println(F("[SX1280] Timed out while transmitting!"));
   } else {
     Serial.print(F("[SX1280] Failed to transmit packet, code "));
@@ -97,11 +97,11 @@ void loop() {
     byte byteArr[8];
     int state = radio.receive(byteArr, 8);
   */
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("[SX1280] Received packet!"));
     Serial.print(F("[SX1280] Data:\t"));
     Serial.println(str);
-  } else if (state == ERR_RX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
     Serial.println(F("[SX1280] Timed out while waiting for packet!"));
   } else {
     Serial.print(F("[SX1280] Failed to receive packet, code "));
diff --git a/examples/SX128x/SX128x_Channel_Activity_Detection/SX128x_Channel_Activity_Detection.ino b/examples/SX128x/SX128x_Channel_Activity_Detection/SX128x_Channel_Activity_Detection.ino
index cec1560a..96b1cb72 100644
--- a/examples/SX128x/SX128x_Channel_Activity_Detection/SX128x_Channel_Activity_Detection.ino
+++ b/examples/SX128x/SX128x_Channel_Activity_Detection/SX128x_Channel_Activity_Detection.ino
@@ -33,7 +33,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -48,11 +48,11 @@ void loop() {
   // start scanning current channel
   int state = radio.scanChannel();
 
-  if (state == LORA_DETECTED) {
+  if (state == RADIOLIB_LORA_DETECTED) {
     // LoRa preamble was detected
     Serial.println(F("detected!"));
 
-  } else if (state == CHANNEL_FREE) {
+  } else if (state == RADIOLIB_CHANNEL_FREE) {
     // no preamble was detected, channel is free
     Serial.println(F("channel is free!"));
 
diff --git a/examples/SX128x/SX128x_FLRC_Modem/SX128x_FLRC_Modem.ino b/examples/SX128x/SX128x_FLRC_Modem/SX128x_FLRC_Modem.ino
index cf2d0e7c..168ab510 100644
--- a/examples/SX128x/SX128x_FLRC_Modem/SX128x_FLRC_Modem.ino
+++ b/examples/SX128x/SX128x_FLRC_Modem/SX128x_FLRC_Modem.ino
@@ -36,7 +36,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.beginFLRC();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -58,7 +58,7 @@ void setup() {
   state = radio.setDataShaping(1.0);
   uint8_t syncWord[] = {0x01, 0x23, 0x45, 0x67};
   state = radio.setSyncWord(syncWord, 4);
-  if (state != ERR_NONE) {
+  if (state != RADIOLIB_ERR_NONE) {
     Serial.print(F("Unable to set configuration, code "));
     Serial.println(state);
     while (true);
@@ -78,11 +78,11 @@ void loop() {
                       0x89, 0xAB, 0xCD, 0xEF};
     int state = radio.transmit(byteArr, 8);
   */
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("[SX1280] Packet transmitted successfully!"));
-  } else if (state == ERR_PACKET_TOO_LONG) {
+  } else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
     Serial.println(F("[SX1280] Packet too long!"));
-  } else if (state == ERR_TX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_TX_TIMEOUT) {
     Serial.println(F("[SX1280] Timed out while transmitting!"));
   } else {
     Serial.println(F("[SX1280] Failed to transmit packet, code "));
@@ -96,11 +96,11 @@ void loop() {
     byte byteArr[8];
     int state = radio.receive(byteArr, 8);
   */
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("[SX1280] Received packet!"));
     Serial.print(F("[SX1280] Data:\t"));
     Serial.println(str);
-  } else if (state == ERR_RX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
     Serial.println(F("[SX1280] Timed out while waiting for packet!"));
   } else {
     Serial.print(F("[SX1280] Failed to receive packet, code "));
diff --git a/examples/SX128x/SX128x_GFSK_Modem/SX128x_GFSK_Modem.ino b/examples/SX128x/SX128x_GFSK_Modem/SX128x_GFSK_Modem.ino
index 2df0d6ac..13412b49 100644
--- a/examples/SX128x/SX128x_GFSK_Modem/SX128x_GFSK_Modem.ino
+++ b/examples/SX128x/SX128x_GFSK_Modem/SX128x_GFSK_Modem.ino
@@ -36,7 +36,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.beginGFSK();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -58,7 +58,7 @@ void setup() {
   state = radio.setDataShaping(RADIOLIB_SHAPING_1_0);
   uint8_t syncWord[] = {0x01, 0x23, 0x45, 0x67, 0x89};
   state = radio.setSyncWord(syncWord, 5);
-  if (state != ERR_NONE) {
+  if (state != RADIOLIB_ERR_NONE) {
     Serial.print(F("Unable to set configuration, code "));
     Serial.println(state);
     while (true);
@@ -78,11 +78,11 @@ void loop() {
                       0x89, 0xAB, 0xCD, 0xEF};
     int state = radio.transmit(byteArr, 8);
   */
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("[SX1280] Packet transmitted successfully!"));
-  } else if (state == ERR_PACKET_TOO_LONG) {
+  } else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
     Serial.println(F("[SX1280] Packet too long!"));
-  } else if (state == ERR_TX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_TX_TIMEOUT) {
     Serial.println(F("[SX1280] Timed out while transmitting!"));
   } else {
     Serial.println(F("[SX1280] Failed to transmit packet, code "));
@@ -96,11 +96,11 @@ void loop() {
     byte byteArr[8];
     int state = radio.receive(byteArr, 8);
   */
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("[SX1280] Received packet!"));
     Serial.print(F("[SX1280] Data:\t"));
     Serial.println(str);
-  } else if (state == ERR_RX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
     Serial.println(F("[SX1280] Timed out while waiting for packet!"));
   } else {
     Serial.print(F("[SX1280] Failed to receive packet, code "));
diff --git a/examples/SX128x/SX128x_Ranging/SX128x_Ranging.ino b/examples/SX128x/SX128x_Ranging/SX128x_Ranging.ino
index f53b1a2d..2776f4f6 100644
--- a/examples/SX128x/SX128x_Ranging/SX128x_Ranging.ino
+++ b/examples/SX128x/SX128x_Ranging/SX128x_Ranging.ino
@@ -35,7 +35,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -57,14 +57,14 @@ void loop() {
     int state = radio.range(false, 0x12345678);
   */
 
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     // ranging finished successfully
     Serial.println(F("success!"));
     Serial.print(F("[SX1280] Distance:\t\t\t"));
     Serial.print(radio.getRangingResult());
     Serial.println(F(" meters"));
 
-  } else if (state == ERR_RANGING_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_RANGING_TIMEOUT) {
     // timed out waiting for ranging packet
     Serial.println(F("timed out!"));
 
diff --git a/examples/SX128x/SX128x_Receive/SX128x_Receive.ino b/examples/SX128x/SX128x_Receive/SX128x_Receive.ino
index ff5adc41..47c6c63b 100644
--- a/examples/SX128x/SX128x_Receive/SX128x_Receive.ino
+++ b/examples/SX128x/SX128x_Receive/SX128x_Receive.ino
@@ -40,7 +40,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -65,7 +65,7 @@ void loop() {
     int state = radio.receive(byteArr, 8);
   */
 
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     // packet was successfully received
     Serial.println(F("success!"));
 
@@ -85,11 +85,11 @@ void loop() {
     Serial.print(radio.getSNR());
     Serial.println(F(" dB"));
 
-  } else if (state == ERR_RX_TIMEOUT) {
+  } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
     // timeout occurred while waiting for a packet
     Serial.println(F("timeout!"));
 
-  } else if (state == ERR_CRC_MISMATCH) {
+  } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
     // packet was received, but is malformed
     Serial.println(F("CRC error!"));
 
diff --git a/examples/SX128x/SX128x_Receive_Interrupt/SX128x_Receive_Interrupt.ino b/examples/SX128x/SX128x_Receive_Interrupt/SX128x_Receive_Interrupt.ino
index 65e03f7d..9bc9eaaa 100644
--- a/examples/SX128x/SX128x_Receive_Interrupt/SX128x_Receive_Interrupt.ino
+++ b/examples/SX128x/SX128x_Receive_Interrupt/SX128x_Receive_Interrupt.ino
@@ -41,7 +41,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -56,7 +56,7 @@ void setup() {
   // start listening for LoRa packets
   Serial.print(F("[SX1280] Starting to listen ... "));
   state = radio.startReceive();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -115,7 +115,7 @@ void loop() {
       int state = radio.readData(byteArr, 8);
     */
 
-    if (state == ERR_NONE) {
+    if (state == RADIOLIB_ERR_NONE) {
       // packet was successfully received
       Serial.println(F("[SX1280] Received packet!"));
 
@@ -133,7 +133,7 @@ void loop() {
       Serial.print(radio.getSNR());
       Serial.println(F(" dB"));
 
-    } else if (state == ERR_CRC_MISMATCH) {
+    } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
       // packet was received, but is malformed
       Serial.println(F("CRC error!"));
 
diff --git a/examples/SX128x/SX128x_Settings/SX128x_Settings.ino b/examples/SX128x/SX128x_Settings/SX128x_Settings.ino
index 0963d85a..36b02da1 100644
--- a/examples/SX128x/SX128x_Settings/SX128x_Settings.ino
+++ b/examples/SX128x/SX128x_Settings/SX128x_Settings.ino
@@ -48,7 +48,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio1.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -68,7 +68,7 @@ void setup() {
   // output power:                2 dBm
   // preamble length:             20 symbols
   state = radio2.begin(2450.0, 1625.0, 7, 5, 2, 20);
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -80,43 +80,43 @@ void setup() {
   // and check if the configuration was changed successfully
 
   // set carrier frequency to 2410.5 MHz
-  if (radio1.setFrequency(2410.5) == ERR_INVALID_FREQUENCY) {
+  if (radio1.setFrequency(2410.5) == RADIOLIB_ERR_INVALID_FREQUENCY) {
     Serial.println(F("Selected frequency is invalid for this module!"));
     while (true);
   }
 
   // set bandwidth to 203.125 kHz
-  if (radio1.setBandwidth(203.125) == ERR_INVALID_BANDWIDTH) {
+  if (radio1.setBandwidth(203.125) == RADIOLIB_ERR_INVALID_BANDWIDTH) {
     Serial.println(F("Selected bandwidth is invalid for this module!"));
     while (true);
   }
 
   // set spreading factor to 10
-  if (radio1.setSpreadingFactor(10) == ERR_INVALID_SPREADING_FACTOR) {
+  if (radio1.setSpreadingFactor(10) == RADIOLIB_ERR_INVALID_SPREADING_FACTOR) {
     Serial.println(F("Selected spreading factor is invalid for this module!"));
     while (true);
   }
 
   // set coding rate to 6
-  if (radio1.setCodingRate(6) == ERR_INVALID_CODING_RATE) {
+  if (radio1.setCodingRate(6) == RADIOLIB_ERR_INVALID_CODING_RATE) {
     Serial.println(F("Selected coding rate is invalid for this module!"));
     while (true);
   }
 
   // set output power to -2 dBm
-  if (radio1.setOutputPower(-2) == ERR_INVALID_OUTPUT_POWER) {
+  if (radio1.setOutputPower(-2) == RADIOLIB_ERR_INVALID_OUTPUT_POWER) {
     Serial.println(F("Selected output power is invalid for this module!"));
     while (true);
   }
 
   // set LoRa preamble length to 16 symbols (accepted range is 2 - 65535)
-  if (radio1.setPreambleLength(16) == ERR_INVALID_PREAMBLE_LENGTH) {
+  if (radio1.setPreambleLength(16) == RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH) {
     Serial.println(F("Selected preamble length is invalid for this module!"));
     while (true);
   }
 
   // disable CRC
-  if (radio1.setCRC(false) == ERR_INVALID_CRC_CONFIGURATION) {
+  if (radio1.setCRC(false) == RADIOLIB_ERR_INVALID_CRC_CONFIGURATION) {
     Serial.println(F("Selected CRC is invalid for this module!"));
     while (true);
   }
diff --git a/examples/SX128x/SX128x_Transmit/SX128x_Transmit.ino b/examples/SX128x/SX128x_Transmit/SX128x_Transmit.ino
index a4037def..e525698a 100644
--- a/examples/SX128x/SX128x_Transmit/SX128x_Transmit.ino
+++ b/examples/SX128x/SX128x_Transmit/SX128x_Transmit.ino
@@ -43,7 +43,7 @@ void setup() {
   // preamble length:             12 symbols
   // CRC:                         enabled
   int state = radio.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -78,11 +78,11 @@ void loop() {
     int state = radio.transmit(byteArr, 8);
   */
 
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     // the packet was successfully transmitted
     Serial.println(F("success!"));
 
-  } else if (state == ERR_PACKET_TOO_LONG) {
+  } else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
     // the supplied packet was longer than 256 bytes
     Serial.println(F("too long!"));
 
diff --git a/examples/SX128x/SX128x_Transmit_Interrupt/SX128x_Transmit_Interrupt.ino b/examples/SX128x/SX128x_Transmit_Interrupt/SX128x_Transmit_Interrupt.ino
index ecdd9312..b23fb0c1 100644
--- a/examples/SX128x/SX128x_Transmit_Interrupt/SX128x_Transmit_Interrupt.ino
+++ b/examples/SX128x/SX128x_Transmit_Interrupt/SX128x_Transmit_Interrupt.ino
@@ -32,7 +32,7 @@ SX1280 radio = new Module(10, 2, 3, 9);
 //SX1280 radio = RadioShield.ModuleA;
 
 // save transmission state between loops
-int transmissionState = ERR_NONE;
+int transmissionState = RADIOLIB_ERR_NONE;
 
 void setup() {
   Serial.begin(9600);
@@ -40,7 +40,7 @@ void setup() {
   // initialize SX1280 with default settings
   Serial.print(F("[SX1280] Initializing ... "));
   int state = radio.begin();
-  if (state == ERR_NONE) {
+  if (state == RADIOLIB_ERR_NONE) {
     Serial.println(F("success!"));
   } else {
     Serial.print(F("failed, code "));
@@ -97,7 +97,7 @@ void loop() {
     // reset flag
     transmittedFlag = false;
 
-    if (transmissionState == ERR_NONE) {
+    if (transmissionState == RADIOLIB_ERR_NONE) {
       // packet was successfully sent
       Serial.println(F("transmission finished!"));
 
diff --git a/src/modules/SX128x/SX1280.cpp b/src/modules/SX128x/SX1280.cpp
index 4e078280..69fbea97 100644
--- a/src/modules/SX128x/SX1280.cpp
+++ b/src/modules/SX128x/SX1280.cpp
@@ -11,13 +11,13 @@ int16_t SX1280::range(bool master, uint32_t addr) {
   RADIOLIB_ASSERT(state);
 
   // wait until ranging is finished
-  uint32_t start = Module::millis();
-  while(!Module::digitalRead(_mod->getIrq())) {
-    Module::yield();
-    if(Module::millis() - start > 10000) {
+  uint32_t start = _mod->millis();
+  while(!_mod->digitalRead(_mod->getIrq())) {
+    _mod->yield();
+    if(_mod->millis() - start > 10000) {
       clearIrqStatus();
       standby();
-      return(ERR_RANGING_TIMEOUT);
+      return(RADIOLIB_ERR_RANGING_TIMEOUT);
     }
   }
 
@@ -34,8 +34,8 @@ int16_t SX1280::range(bool master, uint32_t addr) {
 int16_t SX1280::startRanging(bool master, uint32_t addr) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING))) {
-    return(ERR_WRONG_MODEM);
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING))) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set mode to standby
@@ -43,8 +43,8 @@ int16_t SX1280::startRanging(bool master, uint32_t addr) {
   RADIOLIB_ASSERT(state);
 
   // ensure modem is set to ranging
-  if(modem == SX128X_PACKET_TYPE_LORA) {
-    state = setPacketType(SX128X_PACKET_TYPE_RANGING);
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
+    state = setPacketType(RADIOLIB_SX128X_PACKET_TYPE_RANGING);
     RADIOLIB_ASSERT(state);
   }
 
@@ -58,21 +58,21 @@ int16_t SX1280::startRanging(bool master, uint32_t addr) {
 
   // check all address bits
   uint8_t regValue;
-  state = readRegister(SX128X_REG_SLAVE_RANGING_ADDRESS_WIDTH, &regValue, 1);
+  state = readRegister(RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_WIDTH, &regValue, 1);
   RADIOLIB_ASSERT(state);
   regValue &= 0b00111111;
   regValue |= 0b11000000;
-  state = writeRegister(SX128X_REG_SLAVE_RANGING_ADDRESS_WIDTH, &regValue, 1);
+  state = writeRegister(RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_WIDTH, &regValue, 1);
   RADIOLIB_ASSERT(state);
 
   // set remaining parameter values
-  uint32_t addrReg = SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_3;
-  uint32_t irqMask = SX128X_IRQ_RANGING_SLAVE_RESP_DONE | SX128X_IRQ_RANGING_SLAVE_REQ_DISCARD;
-  uint32_t irqDio1 = SX128X_IRQ_RANGING_SLAVE_RESP_DONE;
+  uint32_t addrReg = RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_3;
+  uint32_t irqMask = RADIOLIB_SX128X_IRQ_RANGING_SLAVE_RESP_DONE | RADIOLIB_SX128X_IRQ_RANGING_SLAVE_REQ_DISCARD;
+  uint32_t irqDio1 = RADIOLIB_SX128X_IRQ_RANGING_SLAVE_RESP_DONE;
   if(master) {
-    addrReg = SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_3;
-    irqMask = SX128X_IRQ_RANGING_MASTER_RES_VALID | SX128X_IRQ_RANGING_MASTER_TIMEOUT;
-    irqDio1 = SX128X_IRQ_RANGING_MASTER_RES_VALID;
+    addrReg = RADIOLIB_SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_3;
+    irqMask = RADIOLIB_SX128X_IRQ_RANGING_MASTER_RES_VALID | RADIOLIB_SX128X_IRQ_RANGING_MASTER_TIMEOUT;
+    irqDio1 = RADIOLIB_SX128X_IRQ_RANGING_MASTER_RES_VALID;
   }
 
   // set ranging address
@@ -93,35 +93,35 @@ int16_t SX1280::startRanging(bool master, uint32_t addr) {
   };
   uint16_t val = 0;
   switch(_bw) {
-    case(SX128X_LORA_BW_406_25):
+    case(RADIOLIB_SX128X_LORA_BW_406_25):
       val = calTable[0][index];
       break;
-    case(SX128X_LORA_BW_812_50):
+    case(RADIOLIB_SX128X_LORA_BW_812_50):
       val = calTable[1][index];
       break;
-    case(SX128X_LORA_BW_1625_00):
+    case(RADIOLIB_SX128X_LORA_BW_1625_00):
       val = calTable[2][index];
       break;
     default:
-      return(ERR_INVALID_BANDWIDTH);
+      return(RADIOLIB_ERR_INVALID_BANDWIDTH);
   }
   uint8_t calBuff[] = { (uint8_t)((val >> 8) & 0xFF), (uint8_t)(val & 0xFF) };
-  state = writeRegister(SX128X_REG_RANGING_CALIBRATION_MSB, calBuff, 2);
+  state = writeRegister(RADIOLIB_SX128X_REG_RANGING_CALIBRATION_MSB, calBuff, 2);
   RADIOLIB_ASSERT(state);
 
   // set role and start ranging
   if(master) {
-    state = setRangingRole(SX128X_RANGING_ROLE_MASTER);
+    state = setRangingRole(RADIOLIB_SX128X_RANGING_ROLE_MASTER);
     RADIOLIB_ASSERT(state);
 
-    state = setTx(SX128X_TX_TIMEOUT_NONE);
+    state = setTx(RADIOLIB_SX128X_TX_TIMEOUT_NONE);
     RADIOLIB_ASSERT(state);
 
   } else {
-    state = setRangingRole(SX128X_RANGING_ROLE_SLAVE);
+    state = setRangingRole(RADIOLIB_SX128X_RANGING_ROLE_SLAVE);
     RADIOLIB_ASSERT(state);
 
-    state = setRx(SX128X_RX_TIMEOUT_INF);
+    state = setRx(RADIOLIB_SX128X_RX_TIMEOUT_INF);
     RADIOLIB_ASSERT(state);
 
   }
@@ -131,33 +131,33 @@ int16_t SX1280::startRanging(bool master, uint32_t addr) {
 
 float SX1280::getRangingResult() {
   // set mode to standby XOSC
-  int16_t state = standby(SX128X_STANDBY_XOSC);
+  int16_t state = standby(RADIOLIB_SX128X_STANDBY_XOSC);
   RADIOLIB_ASSERT(state);
 
   // enable clock
   uint8_t data[4];
-  state = readRegister(SX128X_REG_RANGING_LORA_CLOCK_ENABLE, data, 1);
+  state = readRegister(RADIOLIB_SX128X_REG_RANGING_LORA_CLOCK_ENABLE, data, 1);
   RADIOLIB_ASSERT(state);
 
   data[0] |= (1 << 1);
-  state = writeRegister(SX128X_REG_RANGING_LORA_CLOCK_ENABLE, data, 1);
+  state = writeRegister(RADIOLIB_SX128X_REG_RANGING_LORA_CLOCK_ENABLE, data, 1);
   RADIOLIB_ASSERT(state);
 
   // set result type to filtered
-  state = readRegister(SX128X_REG_RANGING_TYPE, data, 1);
+  state = readRegister(RADIOLIB_SX128X_REG_RANGING_TYPE, data, 1);
   RADIOLIB_ASSERT(state);
 
   data[0] &= 0xCF;
   data[0] |= (1 << 4);
-  state = writeRegister(SX128X_REG_RANGING_TYPE, data, 1);
+  state = writeRegister(RADIOLIB_SX128X_REG_RANGING_TYPE, data, 1);
   RADIOLIB_ASSERT(state);
 
   // read the register values
-  state = readRegister(SX128X_REG_RANGING_RESULT_MSB, &data[0], 1);
+  state = readRegister(RADIOLIB_SX128X_REG_RANGING_RESULT_MSB, &data[0], 1);
   RADIOLIB_ASSERT(state);
-  state = readRegister(SX128X_REG_RANGING_RESULT_MID, &data[1], 1);
+  state = readRegister(RADIOLIB_SX128X_REG_RANGING_RESULT_MID, &data[1], 1);
   RADIOLIB_ASSERT(state);
-  state = readRegister(SX128X_REG_RANGING_RESULT_LSB, &data[2], 1);
+  state = readRegister(RADIOLIB_SX128X_REG_RANGING_RESULT_LSB, &data[2], 1);
   RADIOLIB_ASSERT(state);
 
   // set mode to standby RC
diff --git a/src/modules/SX128x/SX128x.cpp b/src/modules/SX128x/SX128x.cpp
index d92b5e6d..cdf797d6 100644
--- a/src/modules/SX128x/SX128x.cpp
+++ b/src/modules/SX128x/SX128x.cpp
@@ -1,27 +1,31 @@
 #include "SX128x.h"
 #if !defined(RADIOLIB_EXCLUDE_SX128X)
 
-SX128x::SX128x(Module* mod) : PhysicalLayer(SX128X_FREQUENCY_STEP_SIZE, SX128X_MAX_PACKET_LENGTH) {
+SX128x::SX128x(Module* mod) : PhysicalLayer(RADIOLIB_SX128X_FREQUENCY_STEP_SIZE, RADIOLIB_SX128X_MAX_PACKET_LENGTH) {
   _mod = mod;
 }
 
+Module* SX128x::getMod() {
+  return(_mod);
+}
+
 int16_t SX128x::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power, uint16_t preambleLength) {
   // set module properties
-  _mod->init(RADIOLIB_USE_SPI);
-  Module::pinMode(_mod->getIrq(), INPUT);
-  Module::pinMode(_mod->getGpio(), INPUT);
+  _mod->init();
+  _mod->pinMode(_mod->getIrq(), INPUT);
+  _mod->pinMode(_mod->getGpio(), INPUT);
   RADIOLIB_DEBUG_PRINTLN(F("M\tSX128x"));
 
   // initialize LoRa modulation variables
   _bwKhz = bw;
-  _sf = SX128X_LORA_SF_9;
-  _cr = SX128X_LORA_CR_4_7;
+  _sf = RADIOLIB_SX128X_LORA_SF_9;
+  _cr = RADIOLIB_SX128X_LORA_CR_4_7;
 
   // initialize LoRa packet variables
   _preambleLengthLoRa = preambleLength;
-  _headerType = SX128X_LORA_HEADER_EXPLICIT;
+  _headerType = RADIOLIB_SX128X_LORA_HEADER_EXPLICIT;
   _payloadLen = 0xFF;
-  _crcLoRa = SX128X_LORA_CRC_ON;
+  _crcLoRa = RADIOLIB_SX128X_LORA_CRC_ON;
 
   // reset the module and verify startup
   int16_t state = reset();
@@ -32,7 +36,7 @@ int16_t SX128x::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
   RADIOLIB_ASSERT(state);
 
   // configure settings not accessible by API
-  state = config(SX128X_PACKET_TYPE_LORA);
+  state = config(RADIOLIB_SX128X_PACKET_TYPE_LORA);
   RADIOLIB_ASSERT(state);
 
   // configure publicly accessible settings
@@ -62,24 +66,24 @@ int16_t SX128x::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
 
 int16_t SX128x::beginGFSK(float freq, uint16_t br, float freqDev, int8_t power, uint16_t preambleLength) {
   // set module properties
-  _mod->init(RADIOLIB_USE_SPI);
-  Module::pinMode(_mod->getIrq(), INPUT);
-  Module::pinMode(_mod->getGpio(), INPUT);
+  _mod->init();
+  _mod->pinMode(_mod->getIrq(), INPUT);
+  _mod->pinMode(_mod->getGpio(), INPUT);
   RADIOLIB_DEBUG_PRINTLN(F("M\tSX128x"));
 
   // initialize GFSK modulation variables
   _brKbps = br;
-  _br = SX128X_BLE_GFSK_BR_0_800_BW_2_4;
+  _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_800_BW_2_4;
   _modIndexReal = 1.0;
-  _modIndex = SX128X_BLE_GFSK_MOD_IND_1_00;
-  _shaping = SX128X_BLE_GFSK_BT_0_5;
+  _modIndex = RADIOLIB_SX128X_BLE_GFSK_MOD_IND_1_00;
+  _shaping = RADIOLIB_SX128X_BLE_GFSK_BT_0_5;
 
   // initialize GFSK packet variables
   _preambleLengthGFSK = preambleLength;
   _syncWordLen = 2;
-  _syncWordMatch = SX128X_GFSK_FLRC_SYNC_WORD_1;
-  _crcGFSK = SX128X_GFSK_FLRC_CRC_2_BYTE;
-  _whitening = SX128X_GFSK_BLE_WHITENING_ON;
+  _syncWordMatch = RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1;
+  _crcGFSK = RADIOLIB_SX128X_GFSK_FLRC_CRC_2_BYTE;
+  _whitening = RADIOLIB_SX128X_GFSK_BLE_WHITENING_ON;
 
   // reset the module and verify startup
   int16_t state = reset();
@@ -90,7 +94,7 @@ int16_t SX128x::beginGFSK(float freq, uint16_t br, float freqDev, int8_t power,
   RADIOLIB_ASSERT(state);
 
   // configure settings not accessible by API
-  state = config(SX128X_PACKET_TYPE_GFSK);
+  state = config(RADIOLIB_SX128X_PACKET_TYPE_GFSK);
   RADIOLIB_ASSERT(state);
 
   // configure publicly accessible settings
@@ -125,21 +129,21 @@ int16_t SX128x::beginGFSK(float freq, uint16_t br, float freqDev, int8_t power,
 
 int16_t SX128x::beginBLE(float freq, uint16_t br, float freqDev, int8_t power, uint8_t dataShaping) {
   // set module properties
-  _mod->init(RADIOLIB_USE_SPI);
-  Module::pinMode(_mod->getIrq(), INPUT);
-  Module::pinMode(_mod->getGpio(), INPUT);
+  _mod->init();
+  _mod->pinMode(_mod->getIrq(), INPUT);
+  _mod->pinMode(_mod->getGpio(), INPUT);
   RADIOLIB_DEBUG_PRINTLN(F("M\tSX128x"));
 
   // initialize BLE modulation variables
   _brKbps = br;
-  _br = SX128X_BLE_GFSK_BR_0_800_BW_2_4;
+  _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_800_BW_2_4;
   _modIndexReal = 1.0;
-  _modIndex = SX128X_BLE_GFSK_MOD_IND_1_00;
-  _shaping = SX128X_BLE_GFSK_BT_0_5;
+  _modIndex = RADIOLIB_SX128X_BLE_GFSK_MOD_IND_1_00;
+  _shaping = RADIOLIB_SX128X_BLE_GFSK_BT_0_5;
 
   // initialize BLE packet variables
-  _crcGFSK = SX128X_BLE_CRC_3_BYTE;
-  _whitening = SX128X_GFSK_BLE_WHITENING_ON;
+  _crcGFSK = RADIOLIB_SX128X_BLE_CRC_3_BYTE;
+  _whitening = RADIOLIB_SX128X_GFSK_BLE_WHITENING_ON;
 
   // reset the module and verify startup
   int16_t state = reset();
@@ -150,7 +154,7 @@ int16_t SX128x::beginBLE(float freq, uint16_t br, float freqDev, int8_t power, u
   RADIOLIB_ASSERT(state);
 
   // configure settings not accessible by API
-  state = config(SX128X_PACKET_TYPE_BLE);
+  state = config(RADIOLIB_SX128X_PACKET_TYPE_BLE);
   RADIOLIB_ASSERT(state);
 
   // configure publicly accessible settings
@@ -174,23 +178,23 @@ int16_t SX128x::beginBLE(float freq, uint16_t br, float freqDev, int8_t power, u
 
 int16_t SX128x::beginFLRC(float freq, uint16_t br, uint8_t cr, int8_t power, uint16_t preambleLength, uint8_t dataShaping) {
   // set module properties
-  _mod->init(RADIOLIB_USE_SPI);
-  Module::pinMode(_mod->getIrq(), INPUT);
-  Module::pinMode(_mod->getGpio(), INPUT);
+  _mod->init();
+  _mod->pinMode(_mod->getIrq(), INPUT);
+  _mod->pinMode(_mod->getGpio(), INPUT);
   RADIOLIB_DEBUG_PRINTLN(F("M\tSX128x"));
 
   // initialize FLRC modulation variables
   _brKbps = br;
-  _br = SX128X_FLRC_BR_0_650_BW_0_6;
-  _crFLRC = SX128X_FLRC_CR_3_4;
-  _shaping = SX128X_FLRC_BT_0_5;
+  _br = RADIOLIB_SX128X_FLRC_BR_0_650_BW_0_6;
+  _crFLRC = RADIOLIB_SX128X_FLRC_CR_3_4;
+  _shaping = RADIOLIB_SX128X_FLRC_BT_0_5;
 
   // initialize FLRC packet variables
   _preambleLengthGFSK = preambleLength;
   _syncWordLen = 2;
-  _syncWordMatch = SX128X_GFSK_FLRC_SYNC_WORD_1;
-  _crcGFSK = SX128X_GFSK_FLRC_CRC_2_BYTE;
-  _whitening = SX128X_GFSK_BLE_WHITENING_OFF;
+  _syncWordMatch = RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1;
+  _crcGFSK = RADIOLIB_SX128X_GFSK_FLRC_CRC_2_BYTE;
+  _whitening = RADIOLIB_SX128X_GFSK_BLE_WHITENING_OFF;
 
   // reset the module and verify startup
   int16_t state = reset();
@@ -201,7 +205,7 @@ int16_t SX128x::beginFLRC(float freq, uint16_t br, uint8_t cr, int8_t power, uin
   RADIOLIB_ASSERT(state);
 
   // configure settings not accessible by API
-  state = config(SX128X_PACKET_TYPE_FLRC);
+  state = config(RADIOLIB_SX128X_PACKET_TYPE_FLRC);
   RADIOLIB_ASSERT(state);
 
   // configure publicly accessible settings
@@ -233,47 +237,47 @@ int16_t SX128x::beginFLRC(float freq, uint16_t br, uint8_t cr, int8_t power, uin
 
 int16_t SX128x::reset(bool verify) {
   // run the reset sequence - same as SX126x, as SX128x docs don't seem to mention this
-  Module::pinMode(_mod->getRst(), OUTPUT);
-  Module::digitalWrite(_mod->getRst(), LOW);
-  Module::delay(1);
-  Module::digitalWrite(_mod->getRst(), HIGH);
+  _mod->pinMode(_mod->getRst(), OUTPUT);
+  _mod->digitalWrite(_mod->getRst(), LOW);
+  _mod->delay(1);
+  _mod->digitalWrite(_mod->getRst(), HIGH);
 
   // return immediately when verification is disabled
   if(!verify) {
-    return(ERR_NONE);
+    return(RADIOLIB_ERR_NONE);
   }
 
   // set mode to standby
-  uint32_t start = Module::millis();
+  uint32_t start = _mod->millis();
   while(true) {
     // try to set mode to standby
     int16_t state = standby();
-    if(state == ERR_NONE) {
+    if(state == RADIOLIB_ERR_NONE) {
       // standby command successful
-      return(ERR_NONE);
+      return(RADIOLIB_ERR_NONE);
     }
 
     // standby command failed, check timeout and try again
-    if(Module::millis() - start >= 3000) {
+    if(_mod->millis() - start >= 3000) {
       // timed out, possibly incorrect wiring
       return(state);
     }
 
     // wait a bit to not spam the module
-    Module::delay(10);
+    _mod->delay(10);
   }
 }
 
 int16_t SX128x::transmit(uint8_t* data, size_t len, uint8_t addr) {
   // check packet length
-  if(len > SX128X_MAX_PACKET_LENGTH) {
-    return(ERR_PACKET_TOO_LONG);
+  if(len > RADIOLIB_SX128X_MAX_PACKET_LENGTH) {
+    return(RADIOLIB_ERR_PACKET_TOO_LONG);
   }
 
   // check active modem
   uint8_t modem = getPacketType();
-  if(modem == SX128X_PACKET_TYPE_RANGING) {
-    return(ERR_WRONG_MODEM);
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set mode to standby
@@ -292,13 +296,13 @@ int16_t SX128x::transmit(uint8_t* data, size_t len, uint8_t addr) {
   RADIOLIB_ASSERT(state);
 
   // wait for packet transmission or timeout
-  uint32_t start = Module::micros();
-  while(!Module::digitalRead(_mod->getIrq())) {
-    Module::yield();
-    if(Module::micros() - start > timeout) {
+  uint32_t start = _mod->micros();
+  while(!_mod->digitalRead(_mod->getIrq())) {
+    _mod->yield();
+    if(_mod->micros() - start > timeout) {
       clearIrqStatus();
       standby();
-      return(ERR_TX_TIMEOUT);
+      return(RADIOLIB_ERR_TX_TIMEOUT);
     }
   }
 
@@ -315,8 +319,8 @@ int16_t SX128x::transmit(uint8_t* data, size_t len, uint8_t addr) {
 int16_t SX128x::receive(uint8_t* data, size_t len) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(modem == SX128X_PACKET_TYPE_RANGING) {
-    return(ERR_WRONG_MODEM);
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set mode to standby
@@ -336,13 +340,13 @@ int16_t SX128x::receive(uint8_t* data, size_t len) {
   RADIOLIB_ASSERT(state);
 
   // wait for packet reception or timeout
-  uint32_t start = Module::micros();
-  while(!Module::digitalRead(_mod->getIrq())) {
-    Module::yield();
-    if(Module::micros() - start > timeout) {
+  uint32_t start = _mod->micros();
+  while(!_mod->digitalRead(_mod->getIrq())) {
+    _mod->yield();
+    if(_mod->micros() - start > timeout) {
       clearIrqStatus();
       standby();
-      return(ERR_RX_TIMEOUT);
+      return(RADIOLIB_ERR_RX_TIMEOUT);
     }
   }
 
@@ -355,14 +359,14 @@ int16_t SX128x::transmitDirect(uint32_t frf) {
   _mod->setRfSwitchState(LOW, HIGH);
 
   // user requested to start transmitting immediately (required for RTTY)
-  int16_t state = ERR_NONE;
+  int16_t state = RADIOLIB_ERR_NONE;
   if(frf != 0) {
     state = setRfFrequency(frf);
   }
   RADIOLIB_ASSERT(state);
 
   // start transmitting
-  return(SPIwriteCommand(SX128X_CMD_SET_TX_CONTINUOUS_WAVE, NULL, 0));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_TX_CONTINUOUS_WAVE, NULL, 0));
 }
 
 int16_t SX128x::receiveDirect() {
@@ -370,13 +374,13 @@ int16_t SX128x::receiveDirect() {
   _mod->setRfSwitchState(HIGH, LOW);
 
   // SX128x is unable to output received data directly
-  return(ERR_UNKNOWN);
+  return(RADIOLIB_ERR_UNKNOWN);
 }
 
 int16_t SX128x::scanChannel() {
   // check active modem
-  if(getPacketType() != SX128X_PACKET_TYPE_LORA) {
-    return(ERR_WRONG_MODEM);
+  if(getPacketType() != RADIOLIB_SX128X_PACKET_TYPE_LORA) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set mode to standby
@@ -384,7 +388,7 @@ int16_t SX128x::scanChannel() {
   RADIOLIB_ASSERT(state);
 
   // set DIO pin mapping
-  state = setDioIrqParams(SX128X_IRQ_CAD_DETECTED | SX128X_IRQ_CAD_DONE, SX128X_IRQ_CAD_DETECTED | SX128X_IRQ_CAD_DONE);
+  state = setDioIrqParams(RADIOLIB_SX128X_IRQ_CAD_DETECTED | RADIOLIB_SX128X_IRQ_CAD_DONE, RADIOLIB_SX128X_IRQ_CAD_DETECTED | RADIOLIB_SX128X_IRQ_CAD_DONE);
   RADIOLIB_ASSERT(state);
 
   // clear interrupt flags
@@ -399,43 +403,43 @@ int16_t SX128x::scanChannel() {
   RADIOLIB_ASSERT(state);
 
   // wait for channel activity detected or timeout
-  while(!Module::digitalRead(_mod->getIrq())) {
-    Module::yield();
+  while(!_mod->digitalRead(_mod->getIrq())) {
+    _mod->yield();
   }
 
   // check CAD result
   uint16_t cadResult = getIrqStatus();
-  if(cadResult & SX128X_IRQ_CAD_DETECTED) {
+  if(cadResult & RADIOLIB_SX128X_IRQ_CAD_DETECTED) {
     // detected some LoRa activity
     clearIrqStatus();
-    return(LORA_DETECTED);
-  } else if(cadResult & SX128X_IRQ_CAD_DONE) {
+    return(RADIOLIB_LORA_DETECTED);
+  } else if(cadResult & RADIOLIB_SX128X_IRQ_CAD_DONE) {
     // channel is free
     clearIrqStatus();
-    return(CHANNEL_FREE);
+    return(RADIOLIB_CHANNEL_FREE);
   }
 
-  return(ERR_UNKNOWN);
+  return(RADIOLIB_ERR_UNKNOWN);
 }
 
 int16_t SX128x::sleep(bool retainConfig) {
   // set RF switch (if present)
   _mod->setRfSwitchState(LOW, LOW);
 
-  uint8_t sleepConfig = SX128X_SLEEP_DATA_BUFFER_RETAIN | SX128X_SLEEP_DATA_RAM_RETAIN;
+  uint8_t sleepConfig = RADIOLIB_SX128X_SLEEP_DATA_BUFFER_RETAIN | RADIOLIB_SX128X_SLEEP_DATA_RAM_RETAIN;
   if(!retainConfig) {
-    sleepConfig = SX128X_SLEEP_DATA_BUFFER_FLUSH | SX128X_SLEEP_DATA_RAM_FLUSH;
+    sleepConfig = RADIOLIB_SX128X_SLEEP_DATA_BUFFER_FLUSH | RADIOLIB_SX128X_SLEEP_DATA_RAM_FLUSH;
   }
-  int16_t state = SPIwriteCommand(SX128X_CMD_SET_SLEEP, &sleepConfig, 1, false);
+  int16_t state = SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_SLEEP, &sleepConfig, 1, false);
 
   // wait for SX128x to safely enter sleep mode
-  Module::delay(1);
+  _mod->delay(1);
 
   return(state);
 }
 
 int16_t SX128x::standby() {
-  return(SX128x::standby(SX128X_STANDBY_RC));
+  return(SX128x::standby(RADIOLIB_SX128X_STANDBY_RC));
 }
 
 int16_t SX128x::standby(uint8_t mode) {
@@ -443,15 +447,15 @@ int16_t SX128x::standby(uint8_t mode) {
   _mod->setRfSwitchState(LOW, LOW);
 
   uint8_t data[] = { mode };
-  return(SPIwriteCommand(SX128X_CMD_SET_STANDBY, data, 1));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_STANDBY, data, 1));
 }
 
 void SX128x::setDio1Action(void (*func)(void)) {
-  Module::attachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq()), func, RISING);
+  _mod->attachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq()), func, RISING);
 }
 
 void SX128x::clearDio1Action() {
-  Module::detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq()));
+  _mod->detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq()));
 }
 
 int16_t SX128x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
@@ -459,21 +463,21 @@ int16_t SX128x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
   (void)addr;
 
   // check packet length
-  if(len > SX128X_MAX_PACKET_LENGTH) {
-    return(ERR_PACKET_TOO_LONG);
+  if(len > RADIOLIB_SX128X_MAX_PACKET_LENGTH) {
+    return(RADIOLIB_ERR_PACKET_TOO_LONG);
   }
 
   // set packet Length
-  int16_t state = ERR_NONE;
+  int16_t state = RADIOLIB_ERR_NONE;
   uint8_t modem = getPacketType();
-  if(modem == SX128X_PACKET_TYPE_LORA) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
     state = setPacketParamsLoRa(_preambleLengthLoRa, _headerType, len, _crcLoRa);
-  } else if((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_FLRC)) {
+  } else if((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC)) {
     state = setPacketParamsGFSK(_preambleLengthGFSK, _syncWordLen, _syncWordMatch, _crcGFSK, _whitening, len);
-  } else if(modem == SX128X_PACKET_TYPE_BLE) {
+  } else if(modem == RADIOLIB_SX128X_PACKET_TYPE_BLE) {
     state = setPacketParamsBLE(_connectionState, _crcBLE, _bleTestPayload, _whitening);
   } else {
-    return(ERR_WRONG_MODEM);
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
   RADIOLIB_ASSERT(state);
 
@@ -486,7 +490,7 @@ int16_t SX128x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
   RADIOLIB_ASSERT(state);
 
   // write packet to buffer
-  if(modem == SX128X_PACKET_TYPE_BLE) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_BLE) {
     // first 2 bytes of BLE payload are PDU header
     state = writeBuffer(data, len, 2);
     RADIOLIB_ASSERT(state);
@@ -496,7 +500,7 @@ int16_t SX128x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
   }
 
   // set DIO mapping
-  state = setDioIrqParams(SX128X_IRQ_TX_DONE | SX128X_IRQ_RX_TX_TIMEOUT, SX128X_IRQ_TX_DONE);
+  state = setDioIrqParams(RADIOLIB_SX128X_IRQ_TX_DONE | RADIOLIB_SX128X_IRQ_RX_TX_TIMEOUT, RADIOLIB_SX128X_IRQ_TX_DONE);
   RADIOLIB_ASSERT(state);
 
   // clear interrupt flags
@@ -507,12 +511,12 @@ int16_t SX128x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
   _mod->setRfSwitchState(LOW, HIGH);
 
   // start transmission
-  state = setTx(SX128X_TX_TIMEOUT_NONE);
+  state = setTx(RADIOLIB_SX128X_TX_TIMEOUT_NONE);
   RADIOLIB_ASSERT(state);
 
   // wait for BUSY to go low (= PA ramp up done)
-  while(Module::digitalRead(_mod->getGpio())) {
-    Module::yield();
+  while(_mod->digitalRead(_mod->getGpio())) {
+    _mod->yield();
   }
 
   return(state);
@@ -520,12 +524,12 @@ int16_t SX128x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
 
 int16_t SX128x::startReceive(uint16_t timeout) {
   // check active modem
-  if(getPacketType() == SX128X_PACKET_TYPE_RANGING) {
-    return(ERR_WRONG_MODEM);
+  if(getPacketType() == RADIOLIB_SX128X_PACKET_TYPE_RANGING) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set DIO mapping
-  int16_t state = setDioIrqParams(SX128X_IRQ_RX_DONE | SX128X_IRQ_RX_TX_TIMEOUT | SX128X_IRQ_CRC_ERROR | SX128X_IRQ_HEADER_ERROR, SX128X_IRQ_RX_DONE);
+  int16_t state = setDioIrqParams(RADIOLIB_SX128X_IRQ_RX_DONE | RADIOLIB_SX128X_IRQ_RX_TX_TIMEOUT | RADIOLIB_SX128X_IRQ_CRC_ERROR | RADIOLIB_SX128X_IRQ_HEADER_ERROR, RADIOLIB_SX128X_IRQ_RX_DONE);
   RADIOLIB_ASSERT(state);
 
   // set buffer pointers
@@ -537,7 +541,7 @@ int16_t SX128x::startReceive(uint16_t timeout) {
   RADIOLIB_ASSERT(state);
 
   // set implicit mode and expected len if applicable
-  if((_headerType == SX128X_LORA_HEADER_IMPLICIT) && (getPacketType() == SX128X_PACKET_TYPE_LORA)) {
+  if((_headerType == RADIOLIB_SX128X_LORA_HEADER_IMPLICIT) && (getPacketType() == RADIOLIB_SX128X_PACKET_TYPE_LORA)) {
     state = setPacketParamsLoRa(_preambleLengthLoRa, _headerType, _payloadLen, _crcLoRa);
     RADIOLIB_ASSERT(state);
   }
@@ -553,8 +557,8 @@ int16_t SX128x::startReceive(uint16_t timeout) {
 
 int16_t SX128x::readData(uint8_t* data, size_t len) {
   // check active modem
-  if(getPacketType() == SX128X_PACKET_TYPE_RANGING) {
-    return(ERR_WRONG_MODEM);
+  if(getPacketType() == RADIOLIB_SX128X_PACKET_TYPE_RANGING) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set mode to standby
@@ -563,14 +567,14 @@ int16_t SX128x::readData(uint8_t* data, size_t len) {
 
   // check integrity CRC
   uint16_t irq = getIrqStatus();
-  int16_t crcState = ERR_NONE;
-  if((irq & SX128X_IRQ_CRC_ERROR) || (irq & SX128X_IRQ_HEADER_ERROR)) {
-    crcState = ERR_CRC_MISMATCH;
+  int16_t crcState = RADIOLIB_ERR_NONE;
+  if((irq & RADIOLIB_SX128X_IRQ_CRC_ERROR) || (irq & RADIOLIB_SX128X_IRQ_HEADER_ERROR)) {
+    crcState = RADIOLIB_ERR_CRC_MISMATCH;
   }
 
   // get packet length
   size_t length = len;
-  if(len == SX128X_MAX_PACKET_LENGTH) {
+  if(len == RADIOLIB_SX128X_MAX_PACKET_LENGTH) {
     length = getPacketLength();
   }
 
@@ -588,36 +592,36 @@ int16_t SX128x::readData(uint8_t* data, size_t len) {
 }
 
 int16_t SX128x::setFrequency(float freq) {
-  RADIOLIB_CHECK_RANGE(freq, 2400.0, 2500.0, ERR_INVALID_FREQUENCY);
+  RADIOLIB_CHECK_RANGE(freq, 2400.0, 2500.0, RADIOLIB_ERR_INVALID_FREQUENCY);
 
   // calculate raw value
-  uint32_t frf = (freq * (uint32_t(1) << SX128X_DIV_EXPONENT)) / SX128X_CRYSTAL_FREQ;
+  uint32_t frf = (freq * (uint32_t(1) << RADIOLIB_SX128X_DIV_EXPONENT)) / RADIOLIB_SX128X_CRYSTAL_FREQ;
   return(setRfFrequency(frf));
 }
 
 int16_t SX128x::setBandwidth(float bw) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(modem == SX128X_PACKET_TYPE_LORA) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
     // check range for LoRa
-    RADIOLIB_CHECK_RANGE(bw, 203.125, 1625.0, ERR_INVALID_BANDWIDTH);
-  } else if(modem == SX128X_PACKET_TYPE_RANGING) {
+    RADIOLIB_CHECK_RANGE(bw, 203.125, 1625.0, RADIOLIB_ERR_INVALID_BANDWIDTH);
+  } else if(modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING) {
     // check range for ranging
-    RADIOLIB_CHECK_RANGE(bw, 406.25, 1625.0, ERR_INVALID_BANDWIDTH);
+    RADIOLIB_CHECK_RANGE(bw, 406.25, 1625.0, RADIOLIB_ERR_INVALID_BANDWIDTH);
   } else {
-    return(ERR_WRONG_MODEM);
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   if(fabs(bw - 203.125) <= 0.001) {
-    _bw = SX128X_LORA_BW_203_125;
+    _bw = RADIOLIB_SX128X_LORA_BW_203_125;
   } else if(fabs(bw - 406.25) <= 0.001) {
-    _bw = SX128X_LORA_BW_406_25;
+    _bw = RADIOLIB_SX128X_LORA_BW_406_25;
   } else if(fabs(bw - 812.5) <= 0.001) {
-    _bw = SX128X_LORA_BW_812_50;
+    _bw = RADIOLIB_SX128X_LORA_BW_812_50;
   } else if(fabs(bw - 1625.0) <= 0.001) {
-    _bw = SX128X_LORA_BW_1625_00;
+    _bw = RADIOLIB_SX128X_LORA_BW_1625_00;
   } else {
-    return(ERR_INVALID_BANDWIDTH);
+    return(RADIOLIB_ERR_INVALID_BANDWIDTH);
   }
 
   // update modulation parameters
@@ -628,14 +632,14 @@ int16_t SX128x::setBandwidth(float bw) {
 int16_t SX128x::setSpreadingFactor(uint8_t sf) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(modem == SX128X_PACKET_TYPE_LORA) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
     // check range for LoRa
-    RADIOLIB_CHECK_RANGE(sf, 5, 12, ERR_INVALID_SPREADING_FACTOR);
-  } else if(modem == SX128X_PACKET_TYPE_RANGING) {
+    RADIOLIB_CHECK_RANGE(sf, 5, 12, RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
+  } else if(modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING) {
     // check range for ranging
-    RADIOLIB_CHECK_RANGE(sf, 5, 10, ERR_INVALID_SPREADING_FACTOR);
+    RADIOLIB_CHECK_RANGE(sf, 5, 10, RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
   } else {
-    return(ERR_WRONG_MODEM);
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // update modulation parameters
@@ -644,16 +648,16 @@ int16_t SX128x::setSpreadingFactor(uint8_t sf) {
   RADIOLIB_ASSERT(state);
 
   // update mystery register in LoRa mode - SX1280 datasheet v3.0 section 13.4.1
-  if(modem == SX128X_PACKET_TYPE_LORA) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
     uint8_t data = 0;
-    if((_sf == SX128X_LORA_SF_5) || (_sf == SX128X_LORA_SF_6)) {
+    if((_sf == RADIOLIB_SX128X_LORA_SF_5) || (_sf == RADIOLIB_SX128X_LORA_SF_6)) {
       data = 0x1E;
-    } else if((_sf == SX128X_LORA_SF_7) || (_sf == SX128X_LORA_SF_8)) {
+    } else if((_sf == RADIOLIB_SX128X_LORA_SF_7) || (_sf == RADIOLIB_SX128X_LORA_SF_8)) {
       data = 0x37;
     } else {
       data = 0x32;
     }
-    state = SX128x::writeRegister(SX128X_REG_LORA_SF_CONFIG, &data, 1);
+    state = SX128x::writeRegister(RADIOLIB_SX128X_REG_LORA_SF_CONFIG, &data, 1);
   }
 
   return(state);
@@ -664,11 +668,11 @@ int16_t SX128x::setCodingRate(uint8_t cr, bool longInterleaving) {
   uint8_t modem = getPacketType();
 
   // LoRa/ranging
-  if((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING)) {
-    RADIOLIB_CHECK_RANGE(cr, 5, 8, ERR_INVALID_CODING_RATE);
+  if((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING)) {
+    RADIOLIB_CHECK_RANGE(cr, 5, 8, RADIOLIB_ERR_INVALID_CODING_RATE);
 
     // update modulation parameters
-    if(longInterleaving && (modem == SX128X_PACKET_TYPE_LORA)) {
+    if(longInterleaving && (modem == RADIOLIB_SX128X_PACKET_TYPE_LORA)) {
       _cr = cr;
     } else {
       _cr = cr - 4;
@@ -676,32 +680,32 @@ int16_t SX128x::setCodingRate(uint8_t cr, bool longInterleaving) {
     return(setModulationParams(_sf, _bw, _cr));
 
   // FLRC
-  } else if(modem == SX128X_PACKET_TYPE_FLRC) {
-    RADIOLIB_CHECK_RANGE(cr, 2, 4, ERR_INVALID_CODING_RATE);
+  } else if(modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC) {
+    RADIOLIB_CHECK_RANGE(cr, 2, 4, RADIOLIB_ERR_INVALID_CODING_RATE);
 
     // update modulation parameters
     _crFLRC = (cr - 2) * 2;
     return(setModulationParams(_br, _crFLRC, _shaping));
   }
 
-  return(ERR_WRONG_MODEM);
+  return(RADIOLIB_ERR_WRONG_MODEM);
 }
 
 int16_t SX128x::setOutputPower(int8_t power) {
-  RADIOLIB_CHECK_RANGE(power, -18, 13, ERR_INVALID_OUTPUT_POWER);
+  RADIOLIB_CHECK_RANGE(power, -18, 13, RADIOLIB_ERR_INVALID_OUTPUT_POWER);
   _pwr = power + 18;
   return(setTxParams(_pwr));
 }
 
 int16_t SX128x::setPreambleLength(uint32_t preambleLength) {
   uint8_t modem = getPacketType();
-  if((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING)) {
+  if((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING)) {
     // LoRa or ranging
-    RADIOLIB_CHECK_RANGE(preambleLength, 2, 491520, ERR_INVALID_PREAMBLE_LENGTH);
+    RADIOLIB_CHECK_RANGE(preambleLength, 2, 491520, RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
 
     // check preamble length is even - no point even trying odd numbers
     if(preambleLength % 2 != 0) {
-      return(ERR_INVALID_PREAMBLE_LENGTH);
+      return(RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
     }
 
     // calculate exponent and mantissa values (use the next longer preamble if there's no exact match)
@@ -724,13 +728,13 @@ int16_t SX128x::setPreambleLength(uint32_t preambleLength) {
     _preambleLengthLoRa = (e << 4) | m;
     return(setPacketParamsLoRa(_preambleLengthLoRa, _headerType, _payloadLen, _crcLoRa));
 
-  } else if((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_FLRC)) {
+  } else if((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC)) {
     // GFSK or FLRC
-    RADIOLIB_CHECK_RANGE(preambleLength, 4, 32, ERR_INVALID_PREAMBLE_LENGTH);
+    RADIOLIB_CHECK_RANGE(preambleLength, 4, 32, RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
 
     // check preamble length is multiple of 4
     if(preambleLength % 4 != 0) {
-      return(ERR_INVALID_PREAMBLE_LENGTH);
+      return(RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
     }
 
     // update packet parameters
@@ -738,7 +742,7 @@ int16_t SX128x::setPreambleLength(uint32_t preambleLength) {
     return(setPacketParamsGFSK(_preambleLengthGFSK, _syncWordLen, _syncWordMatch, _crcGFSK, _whitening));
   }
 
-  return(ERR_WRONG_MODEM);
+  return(RADIOLIB_ERR_WRONG_MODEM);
 }
 
 int16_t SX128x::setBitRate(uint16_t br) {
@@ -746,25 +750,25 @@ int16_t SX128x::setBitRate(uint16_t br) {
   uint8_t modem = getPacketType();
 
   // GFSK/BLE
-  if((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_BLE)) {
+  if((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_BLE)) {
     if(br == 125) {
-      _br = SX128X_BLE_GFSK_BR_0_125_BW_0_3;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_125_BW_0_3;
     } else if(br == 250) {
-      _br = SX128X_BLE_GFSK_BR_0_250_BW_0_6;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_250_BW_0_6;
     } else if(br == 400) {
-      _br = SX128X_BLE_GFSK_BR_0_400_BW_1_2;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_400_BW_1_2;
     } else if(br == 500) {
-      _br = SX128X_BLE_GFSK_BR_0_500_BW_1_2;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_500_BW_1_2;
     } else if(br == 800) {
-      _br = SX128X_BLE_GFSK_BR_0_800_BW_2_4;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_800_BW_2_4;
     } else if(br == 1000) {
-      _br = SX128X_BLE_GFSK_BR_1_000_BW_2_4;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_1_000_BW_2_4;
     } else if(br == 1600) {
-      _br = SX128X_BLE_GFSK_BR_1_600_BW_2_4;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_1_600_BW_2_4;
     } else if(br == 2000) {
-      _br = SX128X_BLE_GFSK_BR_2_000_BW_2_4;
+      _br = RADIOLIB_SX128X_BLE_GFSK_BR_2_000_BW_2_4;
     } else {
-      return(ERR_INVALID_BIT_RATE);
+      return(RADIOLIB_ERR_INVALID_BIT_RATE);
     }
 
     // update modulation parameters
@@ -772,21 +776,21 @@ int16_t SX128x::setBitRate(uint16_t br) {
     return(setModulationParams(_br, _modIndex, _shaping));
 
   // FLRC
-  } else if(modem == SX128X_PACKET_TYPE_FLRC) {
+  } else if(modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC) {
     if(br == 260) {
-      _br = SX128X_FLRC_BR_0_260_BW_0_3;
+      _br = RADIOLIB_SX128X_FLRC_BR_0_260_BW_0_3;
     } else if(br == 325) {
-      _br = SX128X_FLRC_BR_0_325_BW_0_3;
+      _br = RADIOLIB_SX128X_FLRC_BR_0_325_BW_0_3;
     } else if(br == 520) {
-      _br = SX128X_FLRC_BR_0_520_BW_0_6;
+      _br = RADIOLIB_SX128X_FLRC_BR_0_520_BW_0_6;
     } else if(br == 650) {
-      _br = SX128X_FLRC_BR_0_650_BW_0_6;
+      _br = RADIOLIB_SX128X_FLRC_BR_0_650_BW_0_6;
     } else if(br == 1000) {
-      _br = SX128X_FLRC_BR_1_000_BW_1_2;
+      _br = RADIOLIB_SX128X_FLRC_BR_1_000_BW_1_2;
     } else if(br == 1300) {
-      _br = SX128X_FLRC_BR_1_300_BW_1_2;
+      _br = RADIOLIB_SX128X_FLRC_BR_1_300_BW_1_2;
     } else {
-      return(ERR_INVALID_BIT_RATE);
+      return(RADIOLIB_ERR_INVALID_BIT_RATE);
     }
 
     // update modulation parameters
@@ -795,14 +799,14 @@ int16_t SX128x::setBitRate(uint16_t br) {
 
   }
 
-  return(ERR_WRONG_MODEM);
+  return(RADIOLIB_ERR_WRONG_MODEM);
 }
 
 int16_t SX128x::setFrequencyDeviation(float freqDev) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_BLE))) {
-    return(ERR_WRONG_MODEM);
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_BLE))) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set frequency deviation to lowest available setting (required for digimodes)
@@ -811,19 +815,19 @@ int16_t SX128x::setFrequencyDeviation(float freqDev) {
     newFreqDev = 62.5;
   }
 
-  RADIOLIB_CHECK_RANGE(newFreqDev, 62.5, 1000.0, ERR_INVALID_FREQUENCY_DEVIATION);
+  RADIOLIB_CHECK_RANGE(newFreqDev, 62.5, 1000.0, RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
 
   // override for the lowest possible frequency deviation - required for some PhysicalLayer protocols
   if(newFreqDev == 0.0) {
-    _modIndex = SX128X_BLE_GFSK_MOD_IND_0_35;
-    _br = SX128X_BLE_GFSK_BR_0_125_BW_0_3;
+    _modIndex = RADIOLIB_SX128X_BLE_GFSK_MOD_IND_0_35;
+    _br = RADIOLIB_SX128X_BLE_GFSK_BR_0_125_BW_0_3;
     return(setModulationParams(_br, _modIndex, _shaping));
   }
 
   // update modulation parameters
   uint8_t modIndex = (uint8_t)((8.0 * (newFreqDev / (float)_brKbps)) - 1.0);
-  if(modIndex > SX128X_BLE_GFSK_MOD_IND_4_00) {
-    return(ERR_INVALID_MODULATION_PARAMETERS);
+  if(modIndex > RADIOLIB_SX128X_BLE_GFSK_MOD_IND_4_00) {
+    return(RADIOLIB_ERR_INVALID_MODULATION_PARAMETERS);
   }
 
   // update modulation parameters
@@ -834,27 +838,27 @@ int16_t SX128x::setFrequencyDeviation(float freqDev) {
 int16_t SX128x::setDataShaping(uint8_t sh) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_BLE) || (modem == SX128X_PACKET_TYPE_FLRC))) {
-    return(ERR_WRONG_MODEM);
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_BLE) || (modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC))) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set data shaping
   switch(sh) {
     case RADIOLIB_SHAPING_NONE:
-      _shaping = SX128X_BLE_GFSK_BT_OFF;
+      _shaping = RADIOLIB_SX128X_BLE_GFSK_BT_OFF;
       break;
     case RADIOLIB_SHAPING_0_5:
-      _shaping = SX128X_BLE_GFSK_BT_0_5;
+      _shaping = RADIOLIB_SX128X_BLE_GFSK_BT_0_5;
       break;
     case RADIOLIB_SHAPING_1_0:
-      _shaping = SX128X_BLE_GFSK_BT_1_0;
+      _shaping = RADIOLIB_SX128X_BLE_GFSK_BT_1_0;
       break;
     default:
-      return(ERR_INVALID_DATA_SHAPING);
+      return(RADIOLIB_ERR_INVALID_DATA_SHAPING);
   }
 
   // update modulation parameters
-  if((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_BLE)) {
+  if((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_BLE)) {
     return(setModulationParams(_br, _modIndex, _shaping));
   } else {
     return(setModulationParams(_br, _crFLRC, _shaping));
@@ -864,14 +868,14 @@ int16_t SX128x::setDataShaping(uint8_t sh) {
 int16_t SX128x::setSyncWord(uint8_t* syncWord, uint8_t len) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_FLRC))) {
-    return(ERR_WRONG_MODEM);
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC))) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
-  if(modem == SX128X_PACKET_TYPE_GFSK) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) {
     // GFSK can use up to 5 bytes as sync word
     if(len > 5) {
-      return(ERR_INVALID_SYNC_WORD);
+      return(RADIOLIB_ERR_INVALID_SYNC_WORD);
     }
 
     // calculate sync word length parameter value
@@ -882,7 +886,7 @@ int16_t SX128x::setSyncWord(uint8_t* syncWord, uint8_t len) {
   } else {
     // FLRC requires 32-bit sync word
     if(!((len == 0) || (len == 4))) {
-      return(ERR_INVALID_SYNC_WORD);
+      return(RADIOLIB_ERR_INVALID_SYNC_WORD);
     }
 
     // save sync word length parameter value
@@ -896,28 +900,28 @@ int16_t SX128x::setSyncWord(uint8_t* syncWord, uint8_t len) {
   }
 
   // update sync word
-  int16_t state = SX128x::writeRegister(SX128X_REG_SYNC_WORD_1_BYTE_4, syncWordBuff, 5);
+  int16_t state = SX128x::writeRegister(RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_4, syncWordBuff, 5);
   RADIOLIB_ASSERT(state);
 
   // update packet parameters
   if(_syncWordLen == 0) {
-    _syncWordMatch = SX128X_GFSK_FLRC_SYNC_WORD_OFF;
+    _syncWordMatch = RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_OFF;
   } else {
     /// \todo add support for multiple sync words
-    _syncWordMatch = SX128X_GFSK_FLRC_SYNC_WORD_1;
+    _syncWordMatch = RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1;
   }
   return(setPacketParamsGFSK(_preambleLengthGFSK, _syncWordLen, _syncWordMatch, _crcGFSK, _whitening));
 }
 
 int16_t SX128x::setSyncWord(uint8_t syncWord, uint8_t controlBits) {
   // check active modem
-  if(getPacketType() != SX128X_PACKET_TYPE_LORA) {
-    return(ERR_WRONG_MODEM);
+  if(getPacketType() != RADIOLIB_SX128X_PACKET_TYPE_LORA) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // update register
   uint8_t data[2] = {(uint8_t)((syncWord & 0xF0) | ((controlBits & 0xF0) >> 4)), (uint8_t)(((syncWord & 0x0F) << 4) | (controlBits & 0x0F))};
-  return(writeRegister(SX128X_REG_LORA_SYNC_WORD_MSB, data, 2));
+  return(writeRegister(RADIOLIB_SX128X_REG_LORA_SYNC_WORD_MSB, data, 2));
 }
 
 int16_t SX128x::setCRC(uint8_t len, uint32_t initial, uint16_t polynomial) {
@@ -925,15 +929,15 @@ int16_t SX128x::setCRC(uint8_t len, uint32_t initial, uint16_t polynomial) {
   uint8_t modem = getPacketType();
 
   int16_t state;
-  if((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_FLRC)) {
+  if((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_FLRC)) {
     // update packet parameters
-    if(modem == SX128X_PACKET_TYPE_GFSK) {
+    if(modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) {
       if(len > 2) {
-        return(ERR_INVALID_CRC_CONFIGURATION);
+        return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
       }
     } else {
       if(len > 3) {
-        return(ERR_INVALID_CRC_CONFIGURATION);
+        return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
       }
     }
     _crcGFSK = len << 4;
@@ -942,63 +946,63 @@ int16_t SX128x::setCRC(uint8_t len, uint32_t initial, uint16_t polynomial) {
 
     // set initial CRC value
     uint8_t data[] = { (uint8_t)((initial >> 8) & 0xFF), (uint8_t)(initial & 0xFF) };
-    state = writeRegister(SX128X_REG_CRC_INITIAL_MSB, data, 2);
+    state = writeRegister(RADIOLIB_SX128X_REG_CRC_INITIAL_MSB, data, 2);
     RADIOLIB_ASSERT(state);
 
     // set CRC polynomial
     data[0] = (uint8_t)((polynomial >> 8) & 0xFF);
     data[1] = (uint8_t)(polynomial & 0xFF);
-    state = writeRegister(SX128X_REG_CRC_POLYNOMIAL_MSB, data, 2);
+    state = writeRegister(RADIOLIB_SX128X_REG_CRC_POLYNOMIAL_MSB, data, 2);
     return(state);
 
-  } else if(modem == SX128X_PACKET_TYPE_BLE) {
+  } else if(modem == RADIOLIB_SX128X_PACKET_TYPE_BLE) {
     // update packet parameters
     if(len == 0) {
-      _crcBLE = SX128X_BLE_CRC_OFF;
+      _crcBLE = RADIOLIB_SX128X_BLE_CRC_OFF;
     } else if(len == 3) {
-      _crcBLE = SX128X_BLE_CRC_3_BYTE;
+      _crcBLE = RADIOLIB_SX128X_BLE_CRC_3_BYTE;
     } else {
-      return(ERR_INVALID_CRC_CONFIGURATION);
+      return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
     }
     state = setPacketParamsBLE(_connectionState, _crcBLE, _bleTestPayload, _whitening);
     RADIOLIB_ASSERT(state);
 
     // set initial CRC value
     uint8_t data[] = { (uint8_t)((initial >> 16) & 0xFF), (uint8_t)((initial >> 8) & 0xFF), (uint8_t)(initial & 0xFF) };
-    state = writeRegister(SX128X_REG_BLE_CRC_INITIAL_MSB, data, 3);
+    state = writeRegister(RADIOLIB_SX128X_REG_BLE_CRC_INITIAL_MSB, data, 3);
     return(state);
 
-  } else if((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING)) {
+  } else if((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING)) {
     // update packet parameters
     if(len == 0) {
-      _crcLoRa = SX128X_LORA_CRC_OFF;
+      _crcLoRa = RADIOLIB_SX128X_LORA_CRC_OFF;
     } else if(len == 2) {
-      _crcLoRa = SX128X_LORA_CRC_ON;
+      _crcLoRa = RADIOLIB_SX128X_LORA_CRC_ON;
     } else {
-      return(ERR_INVALID_CRC_CONFIGURATION);
+      return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
     }
     state = setPacketParamsLoRa(_preambleLengthLoRa, _headerType, _payloadLen, _crcLoRa);
     return(state);
   }
 
-  return(ERR_UNKNOWN);
+  return(RADIOLIB_ERR_UNKNOWN);
 }
 
 int16_t SX128x::setWhitening(bool enabled) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_GFSK) || (modem == SX128X_PACKET_TYPE_BLE))) {
-    return(ERR_WRONG_MODEM);
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) || (modem == RADIOLIB_SX128X_PACKET_TYPE_BLE))) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // update packet parameters
   if(enabled) {
-    _whitening = SX128X_GFSK_BLE_WHITENING_ON;
+    _whitening = RADIOLIB_SX128X_GFSK_BLE_WHITENING_ON;
   } else {
-    _whitening = SX128X_GFSK_BLE_WHITENING_OFF;
+    _whitening = RADIOLIB_SX128X_GFSK_BLE_WHITENING_OFF;
   }
 
-  if(modem == SX128X_PACKET_TYPE_GFSK) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_GFSK) {
     return(setPacketParamsGFSK(_preambleLengthGFSK, _syncWordLen, _syncWordMatch, _crcGFSK, _whitening));
   }
   return(setPacketParamsBLE(_connectionState, _crcBLE, _bleTestPayload, _whitening));
@@ -1006,23 +1010,23 @@ int16_t SX128x::setWhitening(bool enabled) {
 
 int16_t SX128x::setAccessAddress(uint32_t addr) {
   // check active modem
-  if(getPacketType() != SX128X_PACKET_TYPE_BLE) {
-    return(ERR_WRONG_MODEM);
+  if(getPacketType() != RADIOLIB_SX128X_PACKET_TYPE_BLE) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // set the address
   uint8_t addrBuff[] = { (uint8_t)((addr >> 24) & 0xFF), (uint8_t)((addr >> 16) & 0xFF), (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) };
-  return(SX128x::writeRegister(SX128X_REG_ACCESS_ADDRESS_BYTE_3, addrBuff, 4));
+  return(SX128x::writeRegister(RADIOLIB_SX128X_REG_ACCESS_ADDRESS_BYTE_3, addrBuff, 4));
 }
 
 float SX128x::getRSSI() {
   // get packet status
   uint8_t packetStatus[5];
-  SPIreadCommand(SX128X_CMD_GET_PACKET_STATUS, packetStatus, 5);
+  SPIreadCommand(RADIOLIB_SX128X_CMD_GET_PACKET_STATUS, packetStatus, 5);
 
   // check active modem
   uint8_t modem = getPacketType();
-  if((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING)) {
+  if((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING)) {
     // LoRa or ranging
     uint8_t rssiSync = packetStatus[0];
     float rssiMeasured = -1.0 * rssiSync/2.0;
@@ -1042,13 +1046,13 @@ float SX128x::getRSSI() {
 float SX128x::getSNR() {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING))) {
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING))) {
     return(0.0);
   }
 
   // get packet status
   uint8_t packetStatus[5];
-  SPIreadCommand(SX128X_CMD_GET_PACKET_STATUS, packetStatus, 5);
+  SPIreadCommand(RADIOLIB_SX128X_CMD_GET_PACKET_STATUS, packetStatus, 5);
 
   // calculate real SNR
   uint8_t snr = packetStatus[1];
@@ -1062,18 +1066,18 @@ float SX128x::getSNR() {
 size_t SX128x::getPacketLength(bool update) {
   (void)update;
   uint8_t rxBufStatus[2] = {0, 0};
-  SPIreadCommand(SX128X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2);
+  SPIreadCommand(RADIOLIB_SX128X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2);
   return((size_t)rxBufStatus[0]);
 }
 
 uint32_t SX128x::getTimeOnAir(size_t len) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(modem == SX128X_PACKET_TYPE_LORA) {
+  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
     // calculate number of symbols
     float N_symbol = 0;
     uint8_t sf = _sf >> 4;
-    if(_cr <= SX128X_LORA_CR_4_8) {
+    if(_cr <= RADIOLIB_SX128X_LORA_CR_4_8) {
       // legacy coding rate - nice and simple
 
       // get SF coefficients
@@ -1099,13 +1103,13 @@ uint32_t SX128x::getTimeOnAir(size_t len) {
 
       // get CRC length
       int16_t N_bitCRC = 16;
-      if(_crcLoRa == SX128X_LORA_CRC_OFF) {
+      if(_crcLoRa == RADIOLIB_SX128X_LORA_CRC_OFF) {
         N_bitCRC = 0;
       }
 
       // get header length
       int16_t N_symbolHeader = 20;
-      if(_headerType == SX128X_LORA_HEADER_IMPLICIT) {
+      if(_headerType == RADIOLIB_SX128X_LORA_HEADER_IMPLICIT) {
         N_symbolHeader = 0;
       }
 
@@ -1131,11 +1135,11 @@ uint32_t SX128x::getTimeOnAir(size_t len) {
 }
 
 int16_t SX128x::implicitHeader(size_t len) {
-  return(setHeaderType(SX128X_LORA_HEADER_IMPLICIT, len));
+  return(setHeaderType(RADIOLIB_SX128X_LORA_HEADER_IMPLICIT, len));
 }
 
 int16_t SX128x::explicitHeader() {
-  return(setHeaderType(SX128X_LORA_HEADER_EXPLICIT));
+  return(setHeaderType(RADIOLIB_SX128X_LORA_HEADER_EXPLICIT));
 }
 
 int16_t SX128x::setEncoding(uint8_t encoding) {
@@ -1166,83 +1170,83 @@ void SX128x::readBit(RADIOLIB_PIN_TYPE pin) {
 
 uint8_t SX128x::getStatus() {
   uint8_t data = 0;
-  SPIreadCommand(SX128X_CMD_GET_STATUS, &data, 1);
+  SPIreadCommand(RADIOLIB_SX128X_CMD_GET_STATUS, &data, 1);
   return(data);
 }
 
 int16_t SX128x::writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) {
-  uint8_t cmd[] = { SX128X_CMD_WRITE_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) };
+  uint8_t cmd[] = { RADIOLIB_SX128X_CMD_WRITE_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) };
   return(SPIwriteCommand(cmd, 3, data, numBytes));
 }
 
 int16_t SX128x::readRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) {
-  uint8_t cmd[] = { SX128X_CMD_READ_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) };
+  uint8_t cmd[] = { RADIOLIB_SX128X_CMD_READ_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) };
   return(SX128x::SPItransfer(cmd, 3, false, NULL, data, numBytes, true));
 }
 
 int16_t SX128x::writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset) {
-  uint8_t cmd[] = { SX128X_CMD_WRITE_BUFFER, offset };
+  uint8_t cmd[] = { RADIOLIB_SX128X_CMD_WRITE_BUFFER, offset };
   return(SPIwriteCommand(cmd, 2, data, numBytes));
 }
 
 int16_t SX128x::readBuffer(uint8_t* data, uint8_t numBytes) {
-  uint8_t cmd[] = { SX128X_CMD_READ_BUFFER, SX128X_CMD_NOP };
+  uint8_t cmd[] = { RADIOLIB_SX128X_CMD_READ_BUFFER, RADIOLIB_SX128X_CMD_NOP };
   return(SPIreadCommand(cmd, 2, data, numBytes));
 }
 
 int16_t SX128x::setTx(uint16_t periodBaseCount, uint8_t periodBase) {
   uint8_t data[] = { periodBase, (uint8_t)((periodBaseCount >> 8) & 0xFF), (uint8_t)(periodBaseCount & 0xFF) };
-  return(SPIwriteCommand(SX128X_CMD_SET_TX, data, 3));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_TX, data, 3));
 }
 
 int16_t SX128x::setRx(uint16_t periodBaseCount, uint8_t periodBase) {
   uint8_t data[] = { periodBase, (uint8_t)((periodBaseCount >> 8) & 0xFF), (uint8_t)(periodBaseCount & 0xFF) };
-  return(SPIwriteCommand(SX128X_CMD_SET_RX, data, 3));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_RX, data, 3));
 }
 
 int16_t SX128x::setCad() {
-  return(SPIwriteCommand(SX128X_CMD_SET_CAD, NULL, 0));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_CAD, NULL, 0));
 }
 
 uint8_t SX128x::getPacketType() {
   uint8_t data = 0xFF;
-  SPIreadCommand(SX128X_CMD_GET_PACKET_TYPE, &data, 1);
+  SPIreadCommand(RADIOLIB_SX128X_CMD_GET_PACKET_TYPE, &data, 1);
   return(data);
 }
 
 int16_t SX128x::setRfFrequency(uint32_t frf) {
   uint8_t data[] = { (uint8_t)((frf >> 16) & 0xFF), (uint8_t)((frf >> 8) & 0xFF), (uint8_t)(frf & 0xFF) };
-  return(SPIwriteCommand(SX128X_CMD_SET_RF_FREQUENCY, data, 3));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_RF_FREQUENCY, data, 3));
 }
 
 int16_t SX128x::setTxParams(uint8_t power, uint8_t rampTime) {
   uint8_t data[] = { power, rampTime };
-  return(SPIwriteCommand(SX128X_CMD_SET_TX_PARAMS, data, 2));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_TX_PARAMS, data, 2));
 }
 
 int16_t SX128x::setBufferBaseAddress(uint8_t txBaseAddress, uint8_t rxBaseAddress) {
   uint8_t data[] = { txBaseAddress, rxBaseAddress };
-  return(SPIwriteCommand(SX128X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2));
 }
 
 int16_t SX128x::setModulationParams(uint8_t modParam1, uint8_t modParam2, uint8_t modParam3) {
   uint8_t data[] = { modParam1, modParam2, modParam3 };
-  return(SPIwriteCommand(SX128X_CMD_SET_MODULATION_PARAMS, data, 3));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_MODULATION_PARAMS, data, 3));
 }
 
 int16_t SX128x::setPacketParamsGFSK(uint8_t preambleLen, uint8_t syncWordLen, uint8_t syncWordMatch, uint8_t crcLen, uint8_t whitening, uint8_t payloadLen, uint8_t headerType) {
   uint8_t data[] = { preambleLen, syncWordLen, syncWordMatch, headerType, payloadLen, crcLen, whitening };
-  return(SPIwriteCommand(SX128X_CMD_SET_PACKET_PARAMS, data, 7));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_PACKET_PARAMS, data, 7));
 }
 
 int16_t SX128x::setPacketParamsBLE(uint8_t connState, uint8_t crcLen, uint8_t bleTestPayload, uint8_t whitening) {
   uint8_t data[] = { connState, crcLen, bleTestPayload, whitening, 0x00, 0x00, 0x00 };
-  return(SPIwriteCommand(SX128X_CMD_SET_PACKET_PARAMS, data, 7));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_PACKET_PARAMS, data, 7));
 }
 
 int16_t SX128x::setPacketParamsLoRa(uint8_t preambleLen, uint8_t headerType, uint8_t payloadLen, uint8_t crc, uint8_t invertIQ) {
   uint8_t data[] = { preambleLen, headerType, payloadLen, crc, invertIQ, 0x00, 0x00 };
-  return(SPIwriteCommand(SX128X_CMD_SET_PACKET_PARAMS, data, 7));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_PACKET_PARAMS, data, 7));
 }
 
 int16_t SX128x::setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask) {
@@ -1250,35 +1254,35 @@ int16_t SX128x::setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t di
                      (uint8_t)((dio1Mask >> 8) & 0xFF), (uint8_t)(dio1Mask & 0xFF),
                      (uint8_t)((dio2Mask >> 8) & 0xFF), (uint8_t)(dio2Mask & 0xFF),
                      (uint8_t)((dio3Mask >> 8) & 0xFF), (uint8_t)(dio3Mask & 0xFF) };
-  return(SPIwriteCommand(SX128X_CMD_SET_DIO_IRQ_PARAMS, data, 8));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_DIO_IRQ_PARAMS, data, 8));
 }
 
 uint16_t SX128x::getIrqStatus() {
   uint8_t data[] = { 0x00, 0x00 };
-  SPIreadCommand(SX128X_CMD_GET_IRQ_STATUS, data, 2);
+  SPIreadCommand(RADIOLIB_SX128X_CMD_GET_IRQ_STATUS, data, 2);
   return(((uint16_t)(data[0]) << 8) | data[1]);
 }
 
 int16_t SX128x::clearIrqStatus(uint16_t clearIrqParams) {
   uint8_t data[] = { (uint8_t)((clearIrqParams >> 8) & 0xFF), (uint8_t)(clearIrqParams & 0xFF) };
-  return(SPIwriteCommand(SX128X_CMD_CLEAR_IRQ_STATUS, data, 2));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_CLEAR_IRQ_STATUS, data, 2));
 }
 
 int16_t SX128x::setRangingRole(uint8_t role) {
   uint8_t data[] = { role };
-  return(SPIwriteCommand(SX128X_CMD_SET_RANGING_ROLE, data, 1));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_RANGING_ROLE, data, 1));
 }
 
 int16_t SX128x::setPacketType(uint8_t type) {
   uint8_t data[] = { type };
-  return(SPIwriteCommand(SX128X_CMD_SET_PACKET_TYPE, data, 1));
+  return(SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_PACKET_TYPE, data, 1));
 }
 
 int16_t SX128x::setHeaderType(uint8_t headerType, size_t len) {
   // check active modem
   uint8_t modem = getPacketType();
-  if(!((modem == SX128X_PACKET_TYPE_LORA) || (modem == SX128X_PACKET_TYPE_RANGING))) {
-    return(ERR_WRONG_MODEM);
+  if(!((modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) || (modem == RADIOLIB_SX128X_PACKET_TYPE_RANGING))) {
+    return(RADIOLIB_ERR_WRONG_MODEM);
   }
 
   // update packet parameters
@@ -1295,20 +1299,20 @@ int16_t SX128x::config(uint8_t modem) {
   // set modem
   uint8_t data[1];
   data[0] = modem;
-  state = SPIwriteCommand(SX128X_CMD_SET_PACKET_TYPE, data, 1);
+  state = SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_PACKET_TYPE, data, 1);
   RADIOLIB_ASSERT(state);
 
   // set CAD parameters
-  data[0] = SX128X_CAD_ON_8_SYMB;
-  state = SPIwriteCommand(SX128X_CMD_SET_CAD_PARAMS, data, 1);
+  data[0] = RADIOLIB_SX128X_CAD_ON_8_SYMB;
+  state = SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_CAD_PARAMS, data, 1);
   RADIOLIB_ASSERT(state);
 
   // set regulator mode to DC-DC
-  data[0] = SX128X_REGULATOR_DC_DC;
-  state = SPIwriteCommand(SX128X_CMD_SET_REGULATOR_MODE, data, 1);
+  data[0] = RADIOLIB_SX128X_REGULATOR_DC_DC;
+  state = SPIwriteCommand(RADIOLIB_SX128X_CMD_SET_REGULATOR_MODE, data, 1);
   RADIOLIB_ASSERT(state);
 
-  return(ERR_NONE);
+  return(RADIOLIB_ERR_NONE);
 }
 
 int16_t SX128x::SPIwriteCommand(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, uint8_t numBytes, bool waitForBusy) {
@@ -1328,33 +1332,29 @@ int16_t SX128x::SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, boo
 }
 
 int16_t SX128x::SPItransfer(uint8_t* cmd, uint8_t cmdLen, bool write, uint8_t* dataOut, uint8_t* dataIn, uint8_t numBytes, bool waitForBusy, uint32_t timeout) {
-  // get pointer to used SPI interface and the settings
-  SPIClass* spi = _mod->getSpi();
-  SPISettings spiSettings = _mod->getSpiSettings();
-
-  #ifdef RADIOLIB_VERBOSE
+  #if defined(RADIOLIB_VERBOSE)
     uint8_t debugBuff[256];
   #endif
 
   // ensure BUSY is low (state machine ready)
-  uint32_t start = Module::millis();
-  while(Module::digitalRead(_mod->getGpio())) {
-    Module::yield();
-    if(Module::millis() - start >= timeout) {
-      Module::digitalWrite(_mod->getCs(), HIGH);
-      return(ERR_SPI_CMD_TIMEOUT);
+  uint32_t start = _mod->millis();
+  while(_mod->digitalRead(_mod->getGpio())) {
+    _mod->yield();
+    if(_mod->millis() - start >= timeout) {
+      _mod->digitalWrite(_mod->getCs(), HIGH);
+      return(RADIOLIB_ERR_SPI_CMD_TIMEOUT);
     }
   }
 
   // pull NSS low
-  Module::digitalWrite(_mod->getCs(), LOW);
+  _mod->digitalWrite(_mod->getCs(), LOW);
 
   // start transfer
-  spi->beginTransaction(spiSettings);
+  _mod->SPIbeginTransaction();
 
   // send command byte(s)
   for(uint8_t n = 0; n < cmdLen; n++) {
-    spi->transfer(cmd[n]);
+    _mod->SPItransfer(cmd[n]);
   }
 
   // variable to save error during SPI transfer
@@ -1364,63 +1364,63 @@ int16_t SX128x::SPItransfer(uint8_t* cmd, uint8_t cmdLen, bool write, uint8_t* d
   if(write) {
     for(uint8_t n = 0; n < numBytes; n++) {
       // send byte
-      uint8_t in = spi->transfer(dataOut[n]);
-      #ifdef RADIOLIB_VERBOSE
+      uint8_t in = _mod->SPItransfer(dataOut[n]);
+      #if defined(RADIOLIB_VERBOSE)
         debugBuff[n] = in;
       #endif
 
       // check status
-      if(((in & 0b00011100) == SX128X_STATUS_CMD_TIMEOUT) ||
-         ((in & 0b00011100) == SX128X_STATUS_CMD_ERROR) ||
-         ((in & 0b00011100) == SX128X_STATUS_CMD_FAILED)) {
+      if(((in & 0b00011100) == RADIOLIB_SX128X_STATUS_CMD_TIMEOUT) ||
+         ((in & 0b00011100) == RADIOLIB_SX128X_STATUS_CMD_ERROR) ||
+         ((in & 0b00011100) == RADIOLIB_SX128X_STATUS_CMD_FAILED)) {
         status = in & 0b00011100;
         break;
       } else if(in == 0x00 || in == 0xFF) {
-        status = SX128X_STATUS_SPI_FAILED;
+        status = RADIOLIB_SX128X_STATUS_SPI_FAILED;
         break;
       }
     }
 
   } else {
     // skip the first byte for read-type commands (status-only)
-    uint8_t in = spi->transfer(SX128X_CMD_NOP);
-    #ifdef RADIOLIB_VERBOSE
+    uint8_t in = _mod->SPItransfer(RADIOLIB_SX128X_CMD_NOP);
+    #if defined(RADIOLIB_VERBOSE)
       debugBuff[0] = in;
     #endif
 
     // check status
-    if(((in & 0b00011100) == SX128X_STATUS_CMD_TIMEOUT) ||
-       ((in & 0b00011100) == SX128X_STATUS_CMD_ERROR) ||
-       ((in & 0b00011100) == SX128X_STATUS_CMD_FAILED)) {
+    if(((in & 0b00011100) == RADIOLIB_SX128X_STATUS_CMD_TIMEOUT) ||
+       ((in & 0b00011100) == RADIOLIB_SX128X_STATUS_CMD_ERROR) ||
+       ((in & 0b00011100) == RADIOLIB_SX128X_STATUS_CMD_FAILED)) {
       status = in & 0b00011100;
     } else if(in == 0x00 || in == 0xFF) {
-      status = SX128X_STATUS_SPI_FAILED;
+      status = RADIOLIB_SX128X_STATUS_SPI_FAILED;
     } else {
       for(uint8_t n = 0; n < numBytes; n++) {
-        dataIn[n] = spi->transfer(SX128X_CMD_NOP);
+        dataIn[n] = _mod->SPItransfer(RADIOLIB_SX128X_CMD_NOP);
       }
     }
   }
 
   // stop transfer
-  spi->endTransaction();
-  Module::digitalWrite(_mod->getCs(), HIGH);
+  _mod->SPIendTransaction();
+  _mod->digitalWrite(_mod->getCs(), HIGH);
 
   // wait for BUSY to go high and then low
   if(waitForBusy) {
-    Module::delayMicroseconds(1);
-    start = Module::millis();
-    while(Module::digitalRead(_mod->getGpio())) {
-      Module::yield();
-      if(Module::millis() - start >= timeout) {
-        status = SX128X_STATUS_CMD_TIMEOUT;
+    _mod->delayMicroseconds(1);
+    start = _mod->millis();
+    while(_mod->digitalRead(_mod->getGpio())) {
+      _mod->yield();
+      if(_mod->millis() - start >= timeout) {
+        status = RADIOLIB_SX128X_STATUS_CMD_TIMEOUT;
         break;
       }
     }
   }
 
   // print debug output
-  #ifdef RADIOLIB_VERBOSE
+  #if defined(RADIOLIB_VERBOSE)
     // print command byte(s)
     RADIOLIB_VERBOSE_PRINT("CMD\t");
     for(uint8_t n = 0; n < cmdLen; n++) {
@@ -1443,13 +1443,13 @@ int16_t SX128x::SPItransfer(uint8_t* cmd, uint8_t cmdLen, bool write, uint8_t* d
     } else {
       RADIOLIB_VERBOSE_PRINT("R\t");
       // skip the first byte for read-type commands (status-only)
-      RADIOLIB_VERBOSE_PRINT(SX128X_CMD_NOP, HEX);
+      RADIOLIB_VERBOSE_PRINT(RADIOLIB_SX128X_CMD_NOP, HEX);
       RADIOLIB_VERBOSE_PRINT('\t');
       RADIOLIB_VERBOSE_PRINT(debugBuff[0], HEX);
       RADIOLIB_VERBOSE_PRINT('\t')
 
       for(uint8_t n = 0; n < numBytes; n++) {
-        RADIOLIB_VERBOSE_PRINT(SX128X_CMD_NOP, HEX);
+        RADIOLIB_VERBOSE_PRINT(RADIOLIB_SX128X_CMD_NOP, HEX);
         RADIOLIB_VERBOSE_PRINT('\t');
         RADIOLIB_VERBOSE_PRINT(dataIn[n], HEX);
         RADIOLIB_VERBOSE_PRINT('\t');
@@ -1462,22 +1462,22 @@ int16_t SX128x::SPItransfer(uint8_t* cmd, uint8_t cmdLen, bool write, uint8_t* d
     // not sure why, but it seems that long enough SPI transaction
     // (e.g. setPacketParams for GFSK) will fail without it
     #if defined(RADIOLIB_SPI_SLOWDOWN)
-      Module::delay(1);
+      _mod->delay(1);
     #endif
   #endif
 
   // parse status
   switch(status) {
-    case SX128X_STATUS_CMD_TIMEOUT:
-      return(ERR_SPI_CMD_TIMEOUT);
-    case SX128X_STATUS_CMD_ERROR:
-      return(ERR_SPI_CMD_INVALID);
-    case SX128X_STATUS_CMD_FAILED:
-      return(ERR_SPI_CMD_FAILED);
-    case SX128X_STATUS_SPI_FAILED:
-      return(ERR_CHIP_NOT_FOUND);
+    case RADIOLIB_SX128X_STATUS_CMD_TIMEOUT:
+      return(RADIOLIB_ERR_SPI_CMD_TIMEOUT);
+    case RADIOLIB_SX128X_STATUS_CMD_ERROR:
+      return(RADIOLIB_ERR_SPI_CMD_INVALID);
+    case RADIOLIB_SX128X_STATUS_CMD_FAILED:
+      return(RADIOLIB_ERR_SPI_CMD_FAILED);
+    case RADIOLIB_SX128X_STATUS_SPI_FAILED:
+      return(RADIOLIB_ERR_CHIP_NOT_FOUND);
     default:
-      return(ERR_NONE);
+      return(RADIOLIB_ERR_NONE);
   }
 }
 
diff --git a/src/modules/SX128x/SX128x.h b/src/modules/SX128x/SX128x.h
index 377850c3..b1a39e94 100644
--- a/src/modules/SX128x/SX128x.h
+++ b/src/modules/SX128x/SX128x.h
@@ -10,336 +10,336 @@
 #include "../../protocols/PhysicalLayer/PhysicalLayer.h"
 
 // SX128X physical layer properties
-#define SX128X_FREQUENCY_STEP_SIZE                    198.3642578
-#define SX128X_MAX_PACKET_LENGTH                      255
-#define SX128X_CRYSTAL_FREQ                           52.0
-#define SX128X_DIV_EXPONENT                           18
+#define RADIOLIB_SX128X_FREQUENCY_STEP_SIZE                    198.3642578
+#define RADIOLIB_SX128X_MAX_PACKET_LENGTH                      255
+#define RADIOLIB_SX128X_CRYSTAL_FREQ                           52.0
+#define RADIOLIB_SX128X_DIV_EXPONENT                           18
 
 // SX128X SPI commands
-#define SX128X_CMD_NOP                                0x00
-#define SX128X_CMD_GET_STATUS                         0xC0
-#define SX128X_CMD_WRITE_REGISTER                     0x18
-#define SX128X_CMD_READ_REGISTER                      0x19
-#define SX128X_CMD_WRITE_BUFFER                       0x1A
-#define SX128X_CMD_READ_BUFFER                        0x1B
-#define SX128X_CMD_SET_SLEEP                          0x84
-#define SX128X_CMD_SET_STANDBY                        0x80
-#define SX128X_CMD_SET_FS                             0xC1
-#define SX128X_CMD_SET_TX                             0x83
-#define SX128X_CMD_SET_RX                             0x82
-#define SX128X_CMD_SET_RX_DUTY_CYCLE                  0x94
-#define SX128X_CMD_SET_CAD                            0xC5
-#define SX128X_CMD_SET_TX_CONTINUOUS_WAVE             0xD1
-#define SX128X_CMD_SET_TX_CONTINUOUS_PREAMBLE         0xD2
-#define SX128X_CMD_SET_PACKET_TYPE                    0x8A
-#define SX128X_CMD_GET_PACKET_TYPE                    0x03
-#define SX128X_CMD_SET_RF_FREQUENCY                   0x86
-#define SX128X_CMD_SET_TX_PARAMS                      0x8E
-#define SX128X_CMD_SET_CAD_PARAMS                     0x88
-#define SX128X_CMD_SET_BUFFER_BASE_ADDRESS            0x8F
-#define SX128X_CMD_SET_MODULATION_PARAMS              0x8B
-#define SX128X_CMD_SET_PACKET_PARAMS                  0x8C
-#define SX128X_CMD_GET_RX_BUFFER_STATUS               0x17
-#define SX128X_CMD_GET_PACKET_STATUS                  0x1D
-#define SX128X_CMD_GET_RSSI_INST                      0x1F
-#define SX128X_CMD_SET_DIO_IRQ_PARAMS                 0x8D
-#define SX128X_CMD_GET_IRQ_STATUS                     0x15
-#define SX128X_CMD_CLEAR_IRQ_STATUS                   0x97
-#define SX128X_CMD_SET_REGULATOR_MODE                 0x96
-#define SX128X_CMD_SET_SAVE_CONTEXT                   0xD5
-#define SX128X_CMD_SET_AUTO_TX                        0x98
-#define SX128X_CMD_SET_AUTO_FS                        0x9E
-#define SX128X_CMD_SET_PERF_COUNTER_MODE              0x9C
-#define SX128X_CMD_SET_LONG_PREAMBLE                  0x9B
-#define SX128X_CMD_SET_UART_SPEED                     0x9D
-#define SX128X_CMD_SET_RANGING_ROLE                   0xA3
-#define SX128X_CMD_SET_ADVANCED_RANGING               0x9A
+#define RADIOLIB_SX128X_CMD_NOP                                0x00
+#define RADIOLIB_SX128X_CMD_GET_STATUS                         0xC0
+#define RADIOLIB_SX128X_CMD_WRITE_REGISTER                     0x18
+#define RADIOLIB_SX128X_CMD_READ_REGISTER                      0x19
+#define RADIOLIB_SX128X_CMD_WRITE_BUFFER                       0x1A
+#define RADIOLIB_SX128X_CMD_READ_BUFFER                        0x1B
+#define RADIOLIB_SX128X_CMD_SET_SLEEP                          0x84
+#define RADIOLIB_SX128X_CMD_SET_STANDBY                        0x80
+#define RADIOLIB_SX128X_CMD_SET_FS                             0xC1
+#define RADIOLIB_SX128X_CMD_SET_TX                             0x83
+#define RADIOLIB_SX128X_CMD_SET_RX                             0x82
+#define RADIOLIB_SX128X_CMD_SET_RX_DUTY_CYCLE                  0x94
+#define RADIOLIB_SX128X_CMD_SET_CAD                            0xC5
+#define RADIOLIB_SX128X_CMD_SET_TX_CONTINUOUS_WAVE             0xD1
+#define RADIOLIB_SX128X_CMD_SET_TX_CONTINUOUS_PREAMBLE         0xD2
+#define RADIOLIB_SX128X_CMD_SET_PACKET_TYPE                    0x8A
+#define RADIOLIB_SX128X_CMD_GET_PACKET_TYPE                    0x03
+#define RADIOLIB_SX128X_CMD_SET_RF_FREQUENCY                   0x86
+#define RADIOLIB_SX128X_CMD_SET_TX_PARAMS                      0x8E
+#define RADIOLIB_SX128X_CMD_SET_CAD_PARAMS                     0x88
+#define RADIOLIB_SX128X_CMD_SET_BUFFER_BASE_ADDRESS            0x8F
+#define RADIOLIB_SX128X_CMD_SET_MODULATION_PARAMS              0x8B
+#define RADIOLIB_SX128X_CMD_SET_PACKET_PARAMS                  0x8C
+#define RADIOLIB_SX128X_CMD_GET_RX_BUFFER_STATUS               0x17
+#define RADIOLIB_SX128X_CMD_GET_PACKET_STATUS                  0x1D
+#define RADIOLIB_SX128X_CMD_GET_RSSI_INST                      0x1F
+#define RADIOLIB_SX128X_CMD_SET_DIO_IRQ_PARAMS                 0x8D
+#define RADIOLIB_SX128X_CMD_GET_IRQ_STATUS                     0x15
+#define RADIOLIB_SX128X_CMD_CLEAR_IRQ_STATUS                   0x97
+#define RADIOLIB_SX128X_CMD_SET_REGULATOR_MODE                 0x96
+#define RADIOLIB_SX128X_CMD_SET_SAVE_CONTEXT                   0xD5
+#define RADIOLIB_SX128X_CMD_SET_AUTO_TX                        0x98
+#define RADIOLIB_SX128X_CMD_SET_AUTO_FS                        0x9E
+#define RADIOLIB_SX128X_CMD_SET_PERF_COUNTER_MODE              0x9C
+#define RADIOLIB_SX128X_CMD_SET_LONG_PREAMBLE                  0x9B
+#define RADIOLIB_SX128X_CMD_SET_UART_SPEED                     0x9D
+#define RADIOLIB_SX128X_CMD_SET_RANGING_ROLE                   0xA3
+#define RADIOLIB_SX128X_CMD_SET_ADVANCED_RANGING               0x9A
 
 // SX128X register map
-#define SX128X_REG_GAIN_MODE                          0x0891
-#define SX128X_REG_MANUAL_GAIN_CONTROL_ENABLE_2       0x0895
-#define SX128X_REG_MANUAL_GAIN_SETTING                0x089E
-#define SX128X_REG_MANUAL_GAIN_CONTROL_ENABLE_1       0x089F
-#define SX128X_REG_SYNCH_PEAK_ATTENUATION             0x08C2
-#define SX128X_REG_LORA_FIXED_PAYLOAD_LENGTH          0x0901
-#define SX128X_REG_LORA_HEADER_MODE                   0x0903
-#define SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_3      0x0912
-#define SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_2      0x0913
-#define SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_1      0x0914
-#define SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_0      0x0915
-#define SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_3       0x0916
-#define SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_2       0x0917
-#define SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_1       0x0918
-#define SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_0       0x0919
-#define SX128X_REG_RANGING_FILTER_WINDOW_SIZE         0x091E
-#define SX128X_REG_RANGING_FILTER_RESET               0x0923
-#define SX128X_REG_RANGING_TYPE                       0x0924
-#define SX128X_REG_LORA_SF_CONFIG                     0x0925
-#define SX128X_REG_RANGING_ADDRESS_SWITCH             0x0927
-#define SX128X_REG_RANGING_CALIBRATION_BYTE_2         0x092B
-#define SX128X_REG_RANGING_CALIBRATION_MSB            0x092C
-#define SX128X_REG_RANGING_CALIBRATION_LSB            0x092D
-#define SX128X_REG_SLAVE_RANGING_ADDRESS_WIDTH        0x0931
-#define SX128X_REG_FREQ_ERROR_CORRECTION              0x093C
-#define SX128X_REG_LORA_SYNC_WORD_MSB                 0x0944
-#define SX128X_REG_LORA_SYNC_WORD_LSB                 0x0945
-#define SX128X_REG_RANGING_FILTER_RSSI_OFFSET         0x0953
-#define SX128X_REG_FEI_MSB                            0x0954
-#define SX128X_REG_FEI_MID                            0x0955
-#define SX128X_REG_FEI_LSB                            0x0956
-#define SX128X_REG_RANGING_ADDRESS_MSB                0x095F
-#define SX128X_REG_RANGING_ADDRESS_LSB                0x0960
-#define SX128X_REG_RANGING_RESULT_MSB                 0x0961
-#define SX128X_REG_RANGING_RESULT_MID                 0x0962
-#define SX128X_REG_RANGING_RESULT_LSB                 0x0963
-#define SX128X_REG_RANGING_RSSI                       0x0964
-#define SX128X_REG_RANGING_LORA_CLOCK_ENABLE          0x097F
-#define SX128X_REG_PACKET_PREAMBLE_SETTINGS           0x09C1
-#define SX128X_REG_WHITENING_INITIAL_VALUE            0x09C5
-#define SX128X_REG_CRC_POLYNOMIAL_MSB                 0x09C6
-#define SX128X_REG_CRC_POLYNOMIAL_LSB                 0x09C7
-#define SX128X_REG_CRC_INITIAL_MSB                    0x09C8
-#define SX128X_REG_CRC_INITIAL_LSB                    0x09C9
-#define SX128X_REG_BLE_CRC_INITIAL_MSB                0x09C7
-#define SX128X_REG_BLE_CRC_INITIAL_MID                (SX128X_REG_CRC_INITIAL_MSB)
-#define SX128X_REG_BLE_CRC_INITIAL_LSB                (SX128X_REG_CRC_INITIAL_LSB)
-#define SX128X_REG_SYNCH_ADDRESS_CONTROL              0x09CD
-#define SX128X_REG_SYNC_WORD_1_BYTE_4                 0x09CE
-#define SX128X_REG_SYNC_WORD_1_BYTE_3                 0x09CF
-#define SX128X_REG_SYNC_WORD_1_BYTE_2                 0x09D0
-#define SX128X_REG_SYNC_WORD_1_BYTE_1                 0x09D1
-#define SX128X_REG_SYNC_WORD_1_BYTE_0                 0x09D2
-#define SX128X_REG_SYNC_WORD_2_BYTE_4                 0x09D3
-#define SX128X_REG_SYNC_WORD_2_BYTE_3                 0x09D4
-#define SX128X_REG_SYNC_WORD_2_BYTE_2                 0x09D5
-#define SX128X_REG_SYNC_WORD_2_BYTE_1                 0x09D6
-#define SX128X_REG_SYNC_WORD_2_BYTE_0                 0x09D7
-#define SX128X_REG_SYNC_WORD_3_BYTE_4                 0x09D8
-#define SX128X_REG_SYNC_WORD_3_BYTE_3                 0x09D9
-#define SX128X_REG_SYNC_WORD_3_BYTE_2                 0x09DA
-#define SX128X_REG_SYNC_WORD_3_BYTE_1                 0x09DB
-#define SX128X_REG_SYNC_WORD_3_BYTE_0                 0x09DC
-#define SX128X_REG_ACCESS_ADDRESS_BYTE_3              (SX128X_REG_SYNC_WORD_1_BYTE_3)
-#define SX128X_REG_ACCESS_ADDRESS_BYTE_2              (SX128X_REG_SYNC_WORD_1_BYTE_2)
-#define SX128X_REG_ACCESS_ADDRESS_BYTE_1              (SX128X_REG_SYNC_WORD_1_BYTE_1)
-#define SX128X_REG_ACCESS_ADDRESS_BYTE_0              (SX128X_REG_SYNC_WORD_1_BYTE_0)
+#define RADIOLIB_SX128X_REG_GAIN_MODE                          0x0891
+#define RADIOLIB_SX128X_REG_MANUAL_GAIN_CONTROL_ENABLE_2       0x0895
+#define RADIOLIB_SX128X_REG_MANUAL_GAIN_SETTING                0x089E
+#define RADIOLIB_SX128X_REG_MANUAL_GAIN_CONTROL_ENABLE_1       0x089F
+#define RADIOLIB_SX128X_REG_SYNCH_PEAK_ATTENUATION             0x08C2
+#define RADIOLIB_SX128X_REG_LORA_FIXED_PAYLOAD_LENGTH          0x0901
+#define RADIOLIB_SX128X_REG_LORA_HEADER_MODE                   0x0903
+#define RADIOLIB_SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_3      0x0912
+#define RADIOLIB_SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_2      0x0913
+#define RADIOLIB_SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_1      0x0914
+#define RADIOLIB_SX128X_REG_MASTER_RANGING_ADDRESS_BYTE_0      0x0915
+#define RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_3       0x0916
+#define RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_2       0x0917
+#define RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_1       0x0918
+#define RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_BYTE_0       0x0919
+#define RADIOLIB_SX128X_REG_RANGING_FILTER_WINDOW_SIZE         0x091E
+#define RADIOLIB_SX128X_REG_RANGING_FILTER_RESET               0x0923
+#define RADIOLIB_SX128X_REG_RANGING_TYPE                       0x0924
+#define RADIOLIB_SX128X_REG_LORA_SF_CONFIG                     0x0925
+#define RADIOLIB_SX128X_REG_RANGING_ADDRESS_SWITCH             0x0927
+#define RADIOLIB_SX128X_REG_RANGING_CALIBRATION_BYTE_2         0x092B
+#define RADIOLIB_SX128X_REG_RANGING_CALIBRATION_MSB            0x092C
+#define RADIOLIB_SX128X_REG_RANGING_CALIBRATION_LSB            0x092D
+#define RADIOLIB_SX128X_REG_SLAVE_RANGING_ADDRESS_WIDTH        0x0931
+#define RADIOLIB_SX128X_REG_FREQ_ERROR_CORRECTION              0x093C
+#define RADIOLIB_SX128X_REG_LORA_SYNC_WORD_MSB                 0x0944
+#define RADIOLIB_SX128X_REG_LORA_SYNC_WORD_LSB                 0x0945
+#define RADIOLIB_SX128X_REG_RANGING_FILTER_RSSI_OFFSET         0x0953
+#define RADIOLIB_SX128X_REG_FEI_MSB                            0x0954
+#define RADIOLIB_SX128X_REG_FEI_MID                            0x0955
+#define RADIOLIB_SX128X_REG_FEI_LSB                            0x0956
+#define RADIOLIB_SX128X_REG_RANGING_ADDRESS_MSB                0x095F
+#define RADIOLIB_SX128X_REG_RANGING_ADDRESS_LSB                0x0960
+#define RADIOLIB_SX128X_REG_RANGING_RESULT_MSB                 0x0961
+#define RADIOLIB_SX128X_REG_RANGING_RESULT_MID                 0x0962
+#define RADIOLIB_SX128X_REG_RANGING_RESULT_LSB                 0x0963
+#define RADIOLIB_SX128X_REG_RANGING_RSSI                       0x0964
+#define RADIOLIB_SX128X_REG_RANGING_LORA_CLOCK_ENABLE          0x097F
+#define RADIOLIB_SX128X_REG_PACKET_PREAMBLE_SETTINGS           0x09C1
+#define RADIOLIB_SX128X_REG_WHITENING_INITIAL_VALUE            0x09C5
+#define RADIOLIB_SX128X_REG_CRC_POLYNOMIAL_MSB                 0x09C6
+#define RADIOLIB_SX128X_REG_CRC_POLYNOMIAL_LSB                 0x09C7
+#define RADIOLIB_SX128X_REG_CRC_INITIAL_MSB                    0x09C8
+#define RADIOLIB_SX128X_REG_CRC_INITIAL_LSB                    0x09C9
+#define RADIOLIB_SX128X_REG_BLE_CRC_INITIAL_MSB                0x09C7
+#define RADIOLIB_SX128X_REG_BLE_CRC_INITIAL_MID                (RADIOLIB_SX128X_REG_CRC_INITIAL_MSB)
+#define RADIOLIB_SX128X_REG_BLE_CRC_INITIAL_LSB                (RADIOLIB_SX128X_REG_CRC_INITIAL_LSB)
+#define RADIOLIB_SX128X_REG_SYNCH_ADDRESS_CONTROL              0x09CD
+#define RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_4                 0x09CE
+#define RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_3                 0x09CF
+#define RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_2                 0x09D0
+#define RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_1                 0x09D1
+#define RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_0                 0x09D2
+#define RADIOLIB_SX128X_REG_SYNC_WORD_2_BYTE_4                 0x09D3
+#define RADIOLIB_SX128X_REG_SYNC_WORD_2_BYTE_3                 0x09D4
+#define RADIOLIB_SX128X_REG_SYNC_WORD_2_BYTE_2                 0x09D5
+#define RADIOLIB_SX128X_REG_SYNC_WORD_2_BYTE_1                 0x09D6
+#define RADIOLIB_SX128X_REG_SYNC_WORD_2_BYTE_0                 0x09D7
+#define RADIOLIB_SX128X_REG_SYNC_WORD_3_BYTE_4                 0x09D8
+#define RADIOLIB_SX128X_REG_SYNC_WORD_3_BYTE_3                 0x09D9
+#define RADIOLIB_SX128X_REG_SYNC_WORD_3_BYTE_2                 0x09DA
+#define RADIOLIB_SX128X_REG_SYNC_WORD_3_BYTE_1                 0x09DB
+#define RADIOLIB_SX128X_REG_SYNC_WORD_3_BYTE_0                 0x09DC
+#define RADIOLIB_SX128X_REG_ACCESS_ADDRESS_BYTE_3              (RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_3)
+#define RADIOLIB_SX128X_REG_ACCESS_ADDRESS_BYTE_2              (RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_2)
+#define RADIOLIB_SX128X_REG_ACCESS_ADDRESS_BYTE_1              (RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_1)
+#define RADIOLIB_SX128X_REG_ACCESS_ADDRESS_BYTE_0              (RADIOLIB_SX128X_REG_SYNC_WORD_1_BYTE_0)
 
 // SX128X SPI command variables
-//SX128X_CMD_GET_STATUS                                               MSB   LSB   DESCRIPTION
-#define SX128X_STATUS_MODE_STDBY_RC                   0b01000000  //  7     5     current chip mode: STDBY_RC
-#define SX128X_STATUS_MODE_STDBY_XOSC                 0b01100000  //  7     5                        STDBY_XOSC
-#define SX128X_STATUS_MODE_FS                         0b10000000  //  7     5                        FS
-#define SX128X_STATUS_MODE_RX                         0b10100000  //  7     5                        Rx
-#define SX128X_STATUS_MODE_TX                         0b11000000  //  7     5                        Tx
-#define SX128X_STATUS_CMD_PROCESSED                   0b00000100  //  4     2     command status: processing OK
-#define SX128X_STATUS_DATA_AVAILABLE                  0b00001000  //  4     2                     data available
-#define SX128X_STATUS_CMD_TIMEOUT                     0b00001100  //  4     2                     timeout
-#define SX128X_STATUS_CMD_ERROR                       0b00010000  //  4     2                     processing error
-#define SX128X_STATUS_CMD_FAILED                      0b00010100  //  4     2                     failed to execute
-#define SX128X_STATUS_TX_DONE                         0b00011000  //  4     2                     transmission finished
-#define SX128X_STATUS_BUSY                            0b00000001  //  0     0     chip busy
-#define SX128X_STATUS_SPI_FAILED                      0b11111111  //  7     0     SPI transaction failed
+//RADIOLIB_SX128X_CMD_GET_STATUS                                               MSB   LSB   DESCRIPTION
+#define RADIOLIB_SX128X_STATUS_MODE_STDBY_RC                   0b01000000  //  7     5     current chip mode: STDBY_RC
+#define RADIOLIB_SX128X_STATUS_MODE_STDBY_XOSC                 0b01100000  //  7     5                        STDBY_XOSC
+#define RADIOLIB_SX128X_STATUS_MODE_FS                         0b10000000  //  7     5                        FS
+#define RADIOLIB_SX128X_STATUS_MODE_RX                         0b10100000  //  7     5                        Rx
+#define RADIOLIB_SX128X_STATUS_MODE_TX                         0b11000000  //  7     5                        Tx
+#define RADIOLIB_SX128X_STATUS_CMD_PROCESSED                   0b00000100  //  4     2     command status: processing OK
+#define RADIOLIB_SX128X_STATUS_DATA_AVAILABLE                  0b00001000  //  4     2                     data available
+#define RADIOLIB_SX128X_STATUS_CMD_TIMEOUT                     0b00001100  //  4     2                     timeout
+#define RADIOLIB_SX128X_STATUS_CMD_ERROR                       0b00010000  //  4     2                     processing error
+#define RADIOLIB_SX128X_STATUS_CMD_FAILED                      0b00010100  //  4     2                     failed to execute
+#define RADIOLIB_SX128X_STATUS_TX_DONE                         0b00011000  //  4     2                     transmission finished
+#define RADIOLIB_SX128X_STATUS_BUSY                            0b00000001  //  0     0     chip busy
+#define RADIOLIB_SX128X_STATUS_SPI_FAILED                      0b11111111  //  7     0     SPI transaction failed
 
-//SX128X_CMD_SET_SLEEP
-#define SX128X_SLEEP_DATA_BUFFER_FLUSH                0b00000000  //  1     1     data buffer behavior in sleep mode: flush
-#define SX128X_SLEEP_DATA_BUFFER_RETAIN               0b00000010  //  1     1                                         retain
-#define SX128X_SLEEP_DATA_RAM_FLUSH                   0b00000000  //  0     0     data RAM (configuration) behavior in sleep mode: flush
-#define SX128X_SLEEP_DATA_RAM_RETAIN                  0b00000001  //  0     0                                                      retain
+//RADIOLIB_SX128X_CMD_SET_SLEEP
+#define RADIOLIB_SX128X_SLEEP_DATA_BUFFER_FLUSH                0b00000000  //  1     1     data buffer behavior in sleep mode: flush
+#define RADIOLIB_SX128X_SLEEP_DATA_BUFFER_RETAIN               0b00000010  //  1     1                                         retain
+#define RADIOLIB_SX128X_SLEEP_DATA_RAM_FLUSH                   0b00000000  //  0     0     data RAM (configuration) behavior in sleep mode: flush
+#define RADIOLIB_SX128X_SLEEP_DATA_RAM_RETAIN                  0b00000001  //  0     0                                                      retain
 
-//SX128X_CMD_SET_STANDBY
-#define SX128X_STANDBY_RC                             0x00        //  7     0     standby mode: 13 MHz RC oscillator
-#define SX128X_STANDBY_XOSC                           0x01        //  7     0                   52 MHz crystal oscillator
+//RADIOLIB_SX128X_CMD_SET_STANDBY
+#define RADIOLIB_SX128X_STANDBY_RC                             0x00        //  7     0     standby mode: 13 MHz RC oscillator
+#define RADIOLIB_SX128X_STANDBY_XOSC                           0x01        //  7     0                   52 MHz crystal oscillator
 
-//SX128X_CMD_SET_TX + SX128X_CMD_SET_RX + SX128X_CMD_SET_RX_DUTY_CYCLE
-#define SX128X_PERIOD_BASE_15_625_US                  0x00        //  7     0     time period step: 15.625 us
-#define SX128X_PERIOD_BASE_62_5_US                    0x01        //  7     0                       62.5 us
-#define SX128X_PERIOD_BASE_1_MS                       0x02        //  7     0                       1 ms
-#define SX128X_PERIOD_BASE_4_MS                       0x03        //  7     0                       4 ms
+//RADIOLIB_SX128X_CMD_SET_TX + RADIOLIB_SX128X_CMD_SET_RX + RADIOLIB_SX128X_CMD_SET_RX_DUTY_CYCLE
+#define RADIOLIB_SX128X_PERIOD_BASE_15_625_US                  0x00        //  7     0     time period step: 15.625 us
+#define RADIOLIB_SX128X_PERIOD_BASE_62_5_US                    0x01        //  7     0                       62.5 us
+#define RADIOLIB_SX128X_PERIOD_BASE_1_MS                       0x02        //  7     0                       1 ms
+#define RADIOLIB_SX128X_PERIOD_BASE_4_MS                       0x03        //  7     0                       4 ms
 
-//SX128X_CMD_SET_TX
-#define SX128X_TX_TIMEOUT_NONE                        0x0000      //  15    0     Tx timeout duration: no timeout (Tx single mode)
+//RADIOLIB_SX128X_CMD_SET_TX
+#define RADIOLIB_SX128X_TX_TIMEOUT_NONE                        0x0000      //  15    0     Tx timeout duration: no timeout (Tx single mode)
 
-//SX128X_CMD_SET_RX
-#define SX128X_RX_TIMEOUT_NONE                        0x0000      //  15    0     Rx timeout duration: no timeout (Rx single mode)
-#define SX128X_RX_TIMEOUT_INF                         0xFFFF      //  15    0                          infinite (Rx continuous mode)
+//RADIOLIB_SX128X_CMD_SET_RX
+#define RADIOLIB_SX128X_RX_TIMEOUT_NONE                        0x0000      //  15    0     Rx timeout duration: no timeout (Rx single mode)
+#define RADIOLIB_SX128X_RX_TIMEOUT_INF                         0xFFFF      //  15    0                          infinite (Rx continuous mode)
 
-//SX128X_CMD_SET_PACKET_TYPE
-#define SX128X_PACKET_TYPE_GFSK                       0x00        //  7     0     packet type: (G)FSK
-#define SX128X_PACKET_TYPE_LORA                       0x01        //  7     0                  LoRa
-#define SX128X_PACKET_TYPE_RANGING                    0x02        //  7     0                  ranging engine
-#define SX128X_PACKET_TYPE_FLRC                       0x03        //  7     0                  FLRC
-#define SX128X_PACKET_TYPE_BLE                        0x04        //  7     0                  BLE
+//RADIOLIB_SX128X_CMD_SET_PACKET_TYPE
+#define RADIOLIB_SX128X_PACKET_TYPE_GFSK                       0x00        //  7     0     packet type: (G)FSK
+#define RADIOLIB_SX128X_PACKET_TYPE_LORA                       0x01        //  7     0                  LoRa
+#define RADIOLIB_SX128X_PACKET_TYPE_RANGING                    0x02        //  7     0                  ranging engine
+#define RADIOLIB_SX128X_PACKET_TYPE_FLRC                       0x03        //  7     0                  FLRC
+#define RADIOLIB_SX128X_PACKET_TYPE_BLE                        0x04        //  7     0                  BLE
 
-//SX128X_CMD_SET_TX_PARAMS
-#define SX128X_PA_RAMP_02_US                          0x00        //  7     0     PA ramp time: 2 us
-#define SX128X_PA_RAMP_04_US                          0x20        //  7     0                   4 us
-#define SX128X_PA_RAMP_06_US                          0x40        //  7     0                   6 us
-#define SX128X_PA_RAMP_08_US                          0x60        //  7     0                   8 us
-#define SX128X_PA_RAMP_10_US                          0x80        //  7     0                   10 us
-#define SX128X_PA_RAMP_12_US                          0xA0        //  7     0                   12 us
-#define SX128X_PA_RAMP_16_US                          0xC0        //  7     0                   16 us
-#define SX128X_PA_RAMP_20_US                          0xE0        //  7     0                   20 us
+//RADIOLIB_SX128X_CMD_SET_TX_PARAMS
+#define RADIOLIB_SX128X_PA_RAMP_02_US                          0x00        //  7     0     PA ramp time: 2 us
+#define RADIOLIB_SX128X_PA_RAMP_04_US                          0x20        //  7     0                   4 us
+#define RADIOLIB_SX128X_PA_RAMP_06_US                          0x40        //  7     0                   6 us
+#define RADIOLIB_SX128X_PA_RAMP_08_US                          0x60        //  7     0                   8 us
+#define RADIOLIB_SX128X_PA_RAMP_10_US                          0x80        //  7     0                   10 us
+#define RADIOLIB_SX128X_PA_RAMP_12_US                          0xA0        //  7     0                   12 us
+#define RADIOLIB_SX128X_PA_RAMP_16_US                          0xC0        //  7     0                   16 us
+#define RADIOLIB_SX128X_PA_RAMP_20_US                          0xE0        //  7     0                   20 us
 
-//SX128X_CMD_SET_CAD_PARAMS
-#define SX128X_CAD_ON_1_SYMB                          0x00        //  7     0     number of symbols used for CAD: 1
-#define SX128X_CAD_ON_2_SYMB                          0x20        //  7     0                                     2
-#define SX128X_CAD_ON_4_SYMB                          0x40        //  7     0                                     4
-#define SX128X_CAD_ON_8_SYMB                          0x60        //  7     0                                     8
-#define SX128X_CAD_ON_16_SYMB                         0x80        //  7     0                                     16
+//RADIOLIB_SX128X_CMD_SET_CAD_PARAMS
+#define RADIOLIB_SX128X_CAD_ON_1_SYMB                          0x00        //  7     0     number of symbols used for CAD: 1
+#define RADIOLIB_SX128X_CAD_ON_2_SYMB                          0x20        //  7     0                                     2
+#define RADIOLIB_SX128X_CAD_ON_4_SYMB                          0x40        //  7     0                                     4
+#define RADIOLIB_SX128X_CAD_ON_8_SYMB                          0x60        //  7     0                                     8
+#define RADIOLIB_SX128X_CAD_ON_16_SYMB                         0x80        //  7     0                                     16
 
-//SX128X_CMD_SET_MODULATION_PARAMS
-#define SX128X_BLE_GFSK_BR_2_000_BW_2_4               0x04        //  7     0     GFSK/BLE bit rate and bandwidth setting: 2.0 Mbps   2.4 MHz
-#define SX128X_BLE_GFSK_BR_1_600_BW_2_4               0x28        //  7     0                                              1.6 Mbps   2.4 MHz
-#define SX128X_BLE_GFSK_BR_1_000_BW_2_4               0x4C        //  7     0                                              1.0 Mbps   2.4 MHz
-#define SX128X_BLE_GFSK_BR_1_000_BW_1_2               0x45        //  7     0                                              1.0 Mbps   1.2 MHz
-#define SX128X_BLE_GFSK_BR_0_800_BW_2_4               0x70        //  7     0                                              0.8 Mbps   2.4 MHz
-#define SX128X_BLE_GFSK_BR_0_800_BW_1_2               0x69        //  7     0                                              0.8 Mbps   1.2 MHz
-#define SX128X_BLE_GFSK_BR_0_500_BW_1_2               0x8D        //  7     0                                              0.5 Mbps   1.2 MHz
-#define SX128X_BLE_GFSK_BR_0_500_BW_0_6               0x86        //  7     0                                              0.5 Mbps   0.6 MHz
-#define SX128X_BLE_GFSK_BR_0_400_BW_1_2               0xB1        //  7     0                                              0.4 Mbps   1.2 MHz
-#define SX128X_BLE_GFSK_BR_0_400_BW_0_6               0xAA        //  7     0                                              0.4 Mbps   0.6 MHz
-#define SX128X_BLE_GFSK_BR_0_250_BW_0_6               0xCE        //  7     0                                              0.25 Mbps  0.6 MHz
-#define SX128X_BLE_GFSK_BR_0_250_BW_0_3               0xC7        //  7     0                                              0.25 Mbps  0.3 MHz
-#define SX128X_BLE_GFSK_BR_0_125_BW_0_3               0xEF        //  7     0                                              0.125 Mbps 0.3 MHz
-#define SX128X_BLE_GFSK_MOD_IND_0_35                  0x00        //  7     0     GFSK/BLE modulation index: 0.35
-#define SX128X_BLE_GFSK_MOD_IND_0_50                  0x01        //  7     0                                0.50
-#define SX128X_BLE_GFSK_MOD_IND_0_75                  0x02        //  7     0                                0.75
-#define SX128X_BLE_GFSK_MOD_IND_1_00                  0x03        //  7     0                                1.00
-#define SX128X_BLE_GFSK_MOD_IND_1_25                  0x04        //  7     0                                1.25
-#define SX128X_BLE_GFSK_MOD_IND_1_50                  0x05        //  7     0                                1.50
-#define SX128X_BLE_GFSK_MOD_IND_1_75                  0x06        //  7     0                                1.75
-#define SX128X_BLE_GFSK_MOD_IND_2_00                  0x07        //  7     0                                2.00
-#define SX128X_BLE_GFSK_MOD_IND_2_25                  0x08        //  7     0                                2.25
-#define SX128X_BLE_GFSK_MOD_IND_2_50                  0x09        //  7     0                                2.50
-#define SX128X_BLE_GFSK_MOD_IND_2_75                  0x0A        //  7     0                                2.75
-#define SX128X_BLE_GFSK_MOD_IND_3_00                  0x0B        //  7     0                                3.00
-#define SX128X_BLE_GFSK_MOD_IND_3_25                  0x0C        //  7     0                                3.25
-#define SX128X_BLE_GFSK_MOD_IND_3_50                  0x0D        //  7     0                                3.50
-#define SX128X_BLE_GFSK_MOD_IND_3_75                  0x0E        //  7     0                                3.75
-#define SX128X_BLE_GFSK_MOD_IND_4_00                  0x0F        //  7     0                                4.00
-#define SX128X_BLE_GFSK_BT_OFF                        0x00        //  7     0     GFSK Gaussian filter BT product: filter disabled
-#define SX128X_BLE_GFSK_BT_1_0                        0x10        //  7     0                                      1.0
-#define SX128X_BLE_GFSK_BT_0_5                        0x20        //  7     0                                      0.5
-#define SX128X_FLRC_BR_1_300_BW_1_2                   0x45        //  7     0     FLRC bit rate and bandwidth setting: 1.3 Mbps   1.2 MHz
-#define SX128X_FLRC_BR_1_000_BW_1_2                   0x69        //  7     0                                          1.04 Mbps  1.2 MHz
-#define SX128X_FLRC_BR_0_650_BW_0_6                   0x86        //  7     0                                          0.65 Mbps  0.6 MHz
-#define SX128X_FLRC_BR_0_520_BW_0_6                   0xAA        //  7     0                                          0.52 Mbps  0.6 MHz
-#define SX128X_FLRC_BR_0_325_BW_0_3                   0xC7        //  7     0                                          0.325 Mbps 0.3 MHz
-#define SX128X_FLRC_BR_0_260_BW_0_3                   0xEB        //  7     0                                          0.260 Mbps 0.3 MHz
-#define SX128X_FLRC_CR_1_2                            0x00        //  7     0     FLRC coding rate: 1/2
-#define SX128X_FLRC_CR_3_4                            0x02        //  7     0                       3/4
-#define SX128X_FLRC_CR_1_0                            0x04        //  7     0                       1/1
-#define SX128X_FLRC_BT_OFF                            0x00        //  7     0     FLRC Gaussian filter BT product: filter disabled
-#define SX128X_FLRC_BT_1_0                            0x10        //  7     0                                      1.0
-#define SX128X_FLRC_BT_0_5                            0x20        //  7     0                                      0.5
-#define SX128X_LORA_SF_5                              0x50        //  7     0     LoRa spreading factor: 5
-#define SX128X_LORA_SF_6                              0x60        //  7     0                            6
-#define SX128X_LORA_SF_7                              0x70        //  7     0                            7
-#define SX128X_LORA_SF_8                              0x80        //  7     0                            8
-#define SX128X_LORA_SF_9                              0x90        //  7     0                            9
-#define SX128X_LORA_SF_10                             0xA0        //  7     0                            10
-#define SX128X_LORA_SF_11                             0xB0        //  7     0                            11
-#define SX128X_LORA_SF_12                             0xC0        //  7     0                            12
-#define SX128X_LORA_BW_1625_00                        0x0A        //  7     0     LoRa bandwidth: 1625.0 kHz
-#define SX128X_LORA_BW_812_50                         0x18        //  7     0                     812.5 kHz
-#define SX128X_LORA_BW_406_25                         0x26        //  7     0                     406.25 kHz
-#define SX128X_LORA_BW_203_125                        0x34        //  7     0                     203.125 kHz
-#define SX128X_LORA_CR_4_5                            0x01        //  7     0     LoRa coding rate: 4/5
-#define SX128X_LORA_CR_4_6                            0x02        //  7     0                       4/6
-#define SX128X_LORA_CR_4_7                            0x03        //  7     0                       4/7
-#define SX128X_LORA_CR_4_8                            0x04        //  7     0                       4/8
-#define SX128X_LORA_CR_4_5_LI                         0x05        //  7     0                       4/5, long interleaving
-#define SX128X_LORA_CR_4_6_LI                         0x06        //  7     0                       4/6, long interleaving
-#define SX128X_LORA_CR_4_7_LI                         0x07        //  7     0                       4/7, long interleaving
+//RADIOLIB_SX128X_CMD_SET_MODULATION_PARAMS
+#define RADIOLIB_SX128X_BLE_GFSK_BR_2_000_BW_2_4               0x04        //  7     0     GFSK/BLE bit rate and bandwidth setting: 2.0 Mbps   2.4 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_1_600_BW_2_4               0x28        //  7     0                                              1.6 Mbps   2.4 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_1_000_BW_2_4               0x4C        //  7     0                                              1.0 Mbps   2.4 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_1_000_BW_1_2               0x45        //  7     0                                              1.0 Mbps   1.2 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_800_BW_2_4               0x70        //  7     0                                              0.8 Mbps   2.4 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_800_BW_1_2               0x69        //  7     0                                              0.8 Mbps   1.2 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_500_BW_1_2               0x8D        //  7     0                                              0.5 Mbps   1.2 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_500_BW_0_6               0x86        //  7     0                                              0.5 Mbps   0.6 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_400_BW_1_2               0xB1        //  7     0                                              0.4 Mbps   1.2 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_400_BW_0_6               0xAA        //  7     0                                              0.4 Mbps   0.6 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_250_BW_0_6               0xCE        //  7     0                                              0.25 Mbps  0.6 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_250_BW_0_3               0xC7        //  7     0                                              0.25 Mbps  0.3 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_BR_0_125_BW_0_3               0xEF        //  7     0                                              0.125 Mbps 0.3 MHz
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_0_35                  0x00        //  7     0     GFSK/BLE modulation index: 0.35
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_0_50                  0x01        //  7     0                                0.50
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_0_75                  0x02        //  7     0                                0.75
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_1_00                  0x03        //  7     0                                1.00
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_1_25                  0x04        //  7     0                                1.25
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_1_50                  0x05        //  7     0                                1.50
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_1_75                  0x06        //  7     0                                1.75
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_2_00                  0x07        //  7     0                                2.00
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_2_25                  0x08        //  7     0                                2.25
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_2_50                  0x09        //  7     0                                2.50
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_2_75                  0x0A        //  7     0                                2.75
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_3_00                  0x0B        //  7     0                                3.00
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_3_25                  0x0C        //  7     0                                3.25
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_3_50                  0x0D        //  7     0                                3.50
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_3_75                  0x0E        //  7     0                                3.75
+#define RADIOLIB_SX128X_BLE_GFSK_MOD_IND_4_00                  0x0F        //  7     0                                4.00
+#define RADIOLIB_SX128X_BLE_GFSK_BT_OFF                        0x00        //  7     0     GFSK Gaussian filter BT product: filter disabled
+#define RADIOLIB_SX128X_BLE_GFSK_BT_1_0                        0x10        //  7     0                                      1.0
+#define RADIOLIB_SX128X_BLE_GFSK_BT_0_5                        0x20        //  7     0                                      0.5
+#define RADIOLIB_SX128X_FLRC_BR_1_300_BW_1_2                   0x45        //  7     0     FLRC bit rate and bandwidth setting: 1.3 Mbps   1.2 MHz
+#define RADIOLIB_SX128X_FLRC_BR_1_000_BW_1_2                   0x69        //  7     0                                          1.04 Mbps  1.2 MHz
+#define RADIOLIB_SX128X_FLRC_BR_0_650_BW_0_6                   0x86        //  7     0                                          0.65 Mbps  0.6 MHz
+#define RADIOLIB_SX128X_FLRC_BR_0_520_BW_0_6                   0xAA        //  7     0                                          0.52 Mbps  0.6 MHz
+#define RADIOLIB_SX128X_FLRC_BR_0_325_BW_0_3                   0xC7        //  7     0                                          0.325 Mbps 0.3 MHz
+#define RADIOLIB_SX128X_FLRC_BR_0_260_BW_0_3                   0xEB        //  7     0                                          0.260 Mbps 0.3 MHz
+#define RADIOLIB_SX128X_FLRC_CR_1_2                            0x00        //  7     0     FLRC coding rate: 1/2
+#define RADIOLIB_SX128X_FLRC_CR_3_4                            0x02        //  7     0                       3/4
+#define RADIOLIB_SX128X_FLRC_CR_1_0                            0x04        //  7     0                       1/1
+#define RADIOLIB_SX128X_FLRC_BT_OFF                            0x00        //  7     0     FLRC Gaussian filter BT product: filter disabled
+#define RADIOLIB_SX128X_FLRC_BT_1_0                            0x10        //  7     0                                      1.0
+#define RADIOLIB_SX128X_FLRC_BT_0_5                            0x20        //  7     0                                      0.5
+#define RADIOLIB_SX128X_LORA_SF_5                              0x50        //  7     0     LoRa spreading factor: 5
+#define RADIOLIB_SX128X_LORA_SF_6                              0x60        //  7     0                            6
+#define RADIOLIB_SX128X_LORA_SF_7                              0x70        //  7     0                            7
+#define RADIOLIB_SX128X_LORA_SF_8                              0x80        //  7     0                            8
+#define RADIOLIB_SX128X_LORA_SF_9                              0x90        //  7     0                            9
+#define RADIOLIB_SX128X_LORA_SF_10                             0xA0        //  7     0                            10
+#define RADIOLIB_SX128X_LORA_SF_11                             0xB0        //  7     0                            11
+#define RADIOLIB_SX128X_LORA_SF_12                             0xC0        //  7     0                            12
+#define RADIOLIB_SX128X_LORA_BW_1625_00                        0x0A        //  7     0     LoRa bandwidth: 1625.0 kHz
+#define RADIOLIB_SX128X_LORA_BW_812_50                         0x18        //  7     0                     812.5 kHz
+#define RADIOLIB_SX128X_LORA_BW_406_25                         0x26        //  7     0                     406.25 kHz
+#define RADIOLIB_SX128X_LORA_BW_203_125                        0x34        //  7     0                     203.125 kHz
+#define RADIOLIB_SX128X_LORA_CR_4_5                            0x01        //  7     0     LoRa coding rate: 4/5
+#define RADIOLIB_SX128X_LORA_CR_4_6                            0x02        //  7     0                       4/6
+#define RADIOLIB_SX128X_LORA_CR_4_7                            0x03        //  7     0                       4/7
+#define RADIOLIB_SX128X_LORA_CR_4_8                            0x04        //  7     0                       4/8
+#define RADIOLIB_SX128X_LORA_CR_4_5_LI                         0x05        //  7     0                       4/5, long interleaving
+#define RADIOLIB_SX128X_LORA_CR_4_6_LI                         0x06        //  7     0                       4/6, long interleaving
+#define RADIOLIB_SX128X_LORA_CR_4_7_LI                         0x07        //  7     0                       4/7, long interleaving
 
-//SX128X_CMD_SET_PACKET_PARAMS
-#define SX128X_GFSK_FLRC_SYNC_WORD_OFF                0x00        //  7     0     GFSK/FLRC sync word used: none
-#define SX128X_GFSK_FLRC_SYNC_WORD_1                  0x10        //  7     0                               sync word 1
-#define SX128X_GFSK_FLRC_SYNC_WORD_2                  0x20        //  7     0                               sync word 2
-#define SX128X_GFSK_FLRC_SYNC_WORD_1_2                0x30        //  7     0                               sync words 1 and 2
-#define SX128X_GFSK_FLRC_SYNC_WORD_3                  0x40        //  7     0                               sync word 3
-#define SX128X_GFSK_FLRC_SYNC_WORD_1_3                0x50        //  7     0                               sync words 1 and 3
-#define SX128X_GFSK_FLRC_SYNC_WORD_2_3                0x60        //  7     0                               sync words 2 and 3
-#define SX128X_GFSK_FLRC_SYNC_WORD_1_2_3              0x70        //  7     0                               sync words 1, 2 and 3
-#define SX128X_GFSK_FLRC_PACKET_FIXED                 0x00        //  7     0     GFSK/FLRC packet length mode: fixed
-#define SX128X_GFSK_FLRC_PACKET_VARIABLE              0x20        //  7     0                                   variable
-#define SX128X_GFSK_FLRC_CRC_OFF                      0x00        //  7     0     GFSK/FLRC packet CRC: none
-#define SX128X_GFSK_FLRC_CRC_1_BYTE                   0x10        //  7     0                           1 byte
-#define SX128X_GFSK_FLRC_CRC_2_BYTE                   0x20        //  7     0                           2 bytes
-#define SX128X_GFSK_FLRC_CRC_3_BYTE                   0x30        //  7     0                           3 bytes (FLRC only)
-#define SX128X_GFSK_BLE_WHITENING_ON                  0x00        //  7     0     GFSK/BLE whitening: enabled
-#define SX128X_GFSK_BLE_WHITENING_OFF                 0x08        //  7     0                         disabled
-#define SX128X_BLE_PAYLOAD_LENGTH_MAX_31              0x00        //  7     0     BLE maximum payload length: 31 bytes
-#define SX128X_BLE_PAYLOAD_LENGTH_MAX_37              0x20        //  7     0                                 37 bytes
-#define SX128X_BLE_PAYLOAD_LENGTH_TEST                0x40        //  7     0                                 63 bytes (test mode)
-#define SX128X_BLE_PAYLOAD_LENGTH_MAX_255             0x80        //  7     0                                 255 bytes (Bluetooth 4.2 and above)
-#define SX128X_BLE_CRC_OFF                            0x00        //  7     0     BLE packet CRC: none
-#define SX128X_BLE_CRC_3_BYTE                         0x10        //  7     0                     3 byte
-#define SX128X_BLE_PRBS_9                             0x00        //  7     0     BLE test payload contents: PRNG sequence using x^9 + x^5 + x
-#define SX128X_BLE_EYELONG                            0x04        //  7     0                                repeated 0xF0
-#define SX128X_BLE_EYESHORT                           0x08        //  7     0                                repeated 0xAA
-#define SX128X_BLE_PRBS_15                            0x0C        //  7     0                                PRNG sequence using x^15 + x^14 + x^13 + x^12 + x^2 + x + 1
-#define SX128X_BLE_ALL_1                              0x10        //  7     0                                repeated 0xFF
-#define SX128X_BLE_ALL_0                              0x14        //  7     0                                repeated 0x00
-#define SX128X_BLE_EYELONG_INV                        0x18        //  7     0                                repeated 0x0F
-#define SX128X_BLE_EYESHORT_INV                       0x1C        //  7     0                                repeated 0x55
-#define SX128X_FLRC_SYNC_WORD_OFF                     0x00        //  7     0     FLRC sync word: disabled
-#define SX128X_FLRC_SYNC_WORD_ON                      0x04        //  7     0                     enabled
-#define SX128X_LORA_HEADER_EXPLICIT                   0x00        //  7     0     LoRa header mode: explicit
-#define SX128X_LORA_HEADER_IMPLICIT                   0x80        //  7     0                       implicit
-#define SX128X_LORA_CRC_OFF                           0x00        //  7     0     LoRa packet CRC: disabled
-#define SX128X_LORA_CRC_ON                            0x20        //  7     0                      enabled
-#define SX128X_LORA_IQ_STANDARD                       0x40        //  7     0     LoRa IQ: standard
-#define SX128X_LORA_IQ_INVERTED                       0x00        //  7     0              inverted
+//RADIOLIB_SX128X_CMD_SET_PACKET_PARAMS
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_OFF                0x00        //  7     0     GFSK/FLRC sync word used: none
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1                  0x10        //  7     0                               sync word 1
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_2                  0x20        //  7     0                               sync word 2
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1_2                0x30        //  7     0                               sync words 1 and 2
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_3                  0x40        //  7     0                               sync word 3
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1_3                0x50        //  7     0                               sync words 1 and 3
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_2_3                0x60        //  7     0                               sync words 2 and 3
+#define RADIOLIB_SX128X_GFSK_FLRC_SYNC_WORD_1_2_3              0x70        //  7     0                               sync words 1, 2 and 3
+#define RADIOLIB_SX128X_GFSK_FLRC_PACKET_FIXED                 0x00        //  7     0     GFSK/FLRC packet length mode: fixed
+#define RADIOLIB_SX128X_GFSK_FLRC_PACKET_VARIABLE              0x20        //  7     0                                   variable
+#define RADIOLIB_SX128X_GFSK_FLRC_CRC_OFF                      0x00        //  7     0     GFSK/FLRC packet CRC: none
+#define RADIOLIB_SX128X_GFSK_FLRC_CRC_1_BYTE                   0x10        //  7     0                           1 byte
+#define RADIOLIB_SX128X_GFSK_FLRC_CRC_2_BYTE                   0x20        //  7     0                           2 bytes
+#define RADIOLIB_SX128X_GFSK_FLRC_CRC_3_BYTE                   0x30        //  7     0                           3 bytes (FLRC only)
+#define RADIOLIB_SX128X_GFSK_BLE_WHITENING_ON                  0x00        //  7     0     GFSK/BLE whitening: enabled
+#define RADIOLIB_SX128X_GFSK_BLE_WHITENING_OFF                 0x08        //  7     0                         disabled
+#define RADIOLIB_SX128X_BLE_PAYLOAD_LENGTH_MAX_31              0x00        //  7     0     BLE maximum payload length: 31 bytes
+#define RADIOLIB_SX128X_BLE_PAYLOAD_LENGTH_MAX_37              0x20        //  7     0                                 37 bytes
+#define RADIOLIB_SX128X_BLE_PAYLOAD_LENGTH_TEST                0x40        //  7     0                                 63 bytes (test mode)
+#define RADIOLIB_SX128X_BLE_PAYLOAD_LENGTH_MAX_255             0x80        //  7     0                                 255 bytes (Bluetooth 4.2 and above)
+#define RADIOLIB_SX128X_BLE_CRC_OFF                            0x00        //  7     0     BLE packet CRC: none
+#define RADIOLIB_SX128X_BLE_CRC_3_BYTE                         0x10        //  7     0                     3 byte
+#define RADIOLIB_SX128X_BLE_PRBS_9                             0x00        //  7     0     BLE test payload contents: PRNG sequence using x^9 + x^5 + x
+#define RADIOLIB_SX128X_BLE_EYELONG                            0x04        //  7     0                                repeated 0xF0
+#define RADIOLIB_SX128X_BLE_EYESHORT                           0x08        //  7     0                                repeated 0xAA
+#define RADIOLIB_SX128X_BLE_PRBS_15                            0x0C        //  7     0                                PRNG sequence using x^15 + x^14 + x^13 + x^12 + x^2 + x + 1
+#define RADIOLIB_SX128X_BLE_ALL_1                              0x10        //  7     0                                repeated 0xFF
+#define RADIOLIB_SX128X_BLE_ALL_0                              0x14        //  7     0                                repeated 0x00
+#define RADIOLIB_SX128X_BLE_EYELONG_INV                        0x18        //  7     0                                repeated 0x0F
+#define RADIOLIB_SX128X_BLE_EYESHORT_INV                       0x1C        //  7     0                                repeated 0x55
+#define RADIOLIB_SX128X_FLRC_SYNC_WORD_OFF                     0x00        //  7     0     FLRC sync word: disabled
+#define RADIOLIB_SX128X_FLRC_SYNC_WORD_ON                      0x04        //  7     0                     enabled
+#define RADIOLIB_SX128X_LORA_HEADER_EXPLICIT                   0x00        //  7     0     LoRa header mode: explicit
+#define RADIOLIB_SX128X_LORA_HEADER_IMPLICIT                   0x80        //  7     0                       implicit
+#define RADIOLIB_SX128X_LORA_CRC_OFF                           0x00        //  7     0     LoRa packet CRC: disabled
+#define RADIOLIB_SX128X_LORA_CRC_ON                            0x20        //  7     0                      enabled
+#define RADIOLIB_SX128X_LORA_IQ_STANDARD                       0x40        //  7     0     LoRa IQ: standard
+#define RADIOLIB_SX128X_LORA_IQ_INVERTED                       0x00        //  7     0              inverted
 
-//SX128X_CMD_GET_PACKET_STATUS
-#define SX128X_PACKET_STATUS_SYNC_ERROR               0b01000000  //  6     6     packet status errors byte: sync word error
-#define SX128X_PACKET_STATUS_LENGTH_ERROR             0b00100000  //  5     5                                packet length error
-#define SX128X_PACKET_STATUS_CRC_ERROR                0b00010000  //  4     4                                CRC error
-#define SX128X_PACKET_STATUS_ABORT_ERROR              0b00001000  //  3     3                                packet reception aborted
-#define SX128X_PACKET_STATUS_HEADER_RECEIVED          0b00000100  //  2     2                                header received
-#define SX128X_PACKET_STATUS_PACKET_RECEIVED          0b00000010  //  1     1                                packet received
-#define SX128X_PACKET_STATUS_PACKET_CTRL_BUSY         0b00000001  //  0     0                                packet controller is busy
-#define SX128X_PACKET_STATUS_RX_PID                   0b11000000  //  7     6     packet status status byte: PID field of the received packet
-#define SX128X_PACKET_STATUS_NO_ACK                   0b00100000  //  5     5                                NO_ACK field of the received packet
-#define SX128X_PACKET_STATUS_RX_PID_ERROR             0b00010000  //  4     4                                PID field error
-#define SX128X_PACKET_STATUS_PACKET_SENT              0b00000001  //  0     0                                packet sent
-#define SX128X_PACKET_STATUS_SYNC_DET_ERROR           0b00000000  //  2     0     packet status sync byte: sync word detection error
-#define SX128X_PACKET_STATUS_SYNC_DET_1               0b00000001  //  2     0                              detected sync word 1
-#define SX128X_PACKET_STATUS_SYNC_DET_2               0b00000010  //  2     0                              detected sync word 2
-#define SX128X_PACKET_STATUS_SYNC_DET_3               0b00000100  //  2     0                              detected sync word 3
+//RADIOLIB_SX128X_CMD_GET_PACKET_STATUS
+#define RADIOLIB_SX128X_PACKET_STATUS_SYNC_ERROR               0b01000000  //  6     6     packet status errors byte: sync word error
+#define RADIOLIB_SX128X_PACKET_STATUS_LENGTH_ERROR             0b00100000  //  5     5                                packet length error
+#define RADIOLIB_SX128X_PACKET_STATUS_CRC_ERROR                0b00010000  //  4     4                                CRC error
+#define RADIOLIB_SX128X_PACKET_STATUS_ABORT_ERROR              0b00001000  //  3     3                                packet reception aborted
+#define RADIOLIB_SX128X_PACKET_STATUS_HEADER_RECEIVED          0b00000100  //  2     2                                header received
+#define RADIOLIB_SX128X_PACKET_STATUS_PACKET_RECEIVED          0b00000010  //  1     1                                packet received
+#define RADIOLIB_SX128X_PACKET_STATUS_PACKET_CTRL_BUSY         0b00000001  //  0     0                                packet controller is busy
+#define RADIOLIB_SX128X_PACKET_STATUS_RX_PID                   0b11000000  //  7     6     packet status status byte: PID field of the received packet
+#define RADIOLIB_SX128X_PACKET_STATUS_NO_ACK                   0b00100000  //  5     5                                NO_ACK field of the received packet
+#define RADIOLIB_SX128X_PACKET_STATUS_RX_PID_ERROR             0b00010000  //  4     4                                PID field error
+#define RADIOLIB_SX128X_PACKET_STATUS_PACKET_SENT              0b00000001  //  0     0                                packet sent
+#define RADIOLIB_SX128X_PACKET_STATUS_SYNC_DET_ERROR           0b00000000  //  2     0     packet status sync byte: sync word detection error
+#define RADIOLIB_SX128X_PACKET_STATUS_SYNC_DET_1               0b00000001  //  2     0                              detected sync word 1
+#define RADIOLIB_SX128X_PACKET_STATUS_SYNC_DET_2               0b00000010  //  2     0                              detected sync word 2
+#define RADIOLIB_SX128X_PACKET_STATUS_SYNC_DET_3               0b00000100  //  2     0                              detected sync word 3
 
-//SX128X_CMD_SET_DIO_IRQ_PARAMS
-#define SX128X_IRQ_PREAMBLE_DETECTED                  0x8000      //  15    15    interrupt source: preamble detected
-#define SX128X_IRQ_ADVANCED_RANGING_DONE              0x8000      //  15    15                      advanced ranging done
-#define SX128X_IRQ_RX_TX_TIMEOUT                      0x4000      //  14    14                      Rx or Tx timeout
-#define SX128X_IRQ_CAD_DETECTED                       0x2000      //  13    13                      channel activity detected
-#define SX128X_IRQ_CAD_DONE                           0x1000      //  12    12                      CAD finished
-#define SX128X_IRQ_RANGING_SLAVE_REQ_VALID            0x0800      //  11    11                      ranging request valid (slave)
-#define SX128X_IRQ_RANGING_MASTER_TIMEOUT             0x0400      //  10    10                      ranging timeout (master)
-#define SX128X_IRQ_RANGING_MASTER_RES_VALID           0x0200      //  9     9                       ranging result valid (master)
-#define SX128X_IRQ_RANGING_SLAVE_REQ_DISCARD          0x0100      //  8     8                       ranging result valid (master)
-#define SX128X_IRQ_RANGING_SLAVE_RESP_DONE            0x0080      //  7     7                       ranging response complete (slave)
-#define SX128X_IRQ_CRC_ERROR                          0x0040      //  6     6                       CRC error
-#define SX128X_IRQ_HEADER_ERROR                       0x0020      //  5     5                       header error
-#define SX128X_IRQ_HEADER_VALID                       0x0010      //  4     4                       header valid
-#define SX128X_IRQ_SYNC_WORD_ERROR                    0x0008      //  3     3                       sync word error
-#define SX128X_IRQ_SYNC_WORD_VALID                    0x0004      //  2     2                       sync word valid
-#define SX128X_IRQ_RX_DONE                            0x0002      //  1     1                       Rx done
-#define SX128X_IRQ_TX_DONE                            0x0001      //  0     0                       Tx done
-#define SX128X_IRQ_NONE                               0x0000      //  15    0                       none
-#define SX128X_IRQ_ALL                                0xFFFF      //  15    0                       all
+//RADIOLIB_SX128X_CMD_SET_DIO_IRQ_PARAMS
+#define RADIOLIB_SX128X_IRQ_RADIOLIB_PREAMBLE_DETECTED                  0x8000      //  15    15    interrupt source: preamble detected
+#define RADIOLIB_SX128X_IRQ_ADVANCED_RANGING_DONE              0x8000      //  15    15                      advanced ranging done
+#define RADIOLIB_SX128X_IRQ_RX_TX_TIMEOUT                      0x4000      //  14    14                      Rx or Tx timeout
+#define RADIOLIB_SX128X_IRQ_CAD_DETECTED                       0x2000      //  13    13                      channel activity detected
+#define RADIOLIB_SX128X_IRQ_CAD_DONE                           0x1000      //  12    12                      CAD finished
+#define RADIOLIB_SX128X_IRQ_RANGING_SLAVE_REQ_VALID            0x0800      //  11    11                      ranging request valid (slave)
+#define RADIOLIB_SX128X_IRQ_RANGING_MASTER_TIMEOUT             0x0400      //  10    10                      ranging timeout (master)
+#define RADIOLIB_SX128X_IRQ_RANGING_MASTER_RES_VALID           0x0200      //  9     9                       ranging result valid (master)
+#define RADIOLIB_SX128X_IRQ_RANGING_SLAVE_REQ_DISCARD          0x0100      //  8     8                       ranging result valid (master)
+#define RADIOLIB_SX128X_IRQ_RANGING_SLAVE_RESP_DONE            0x0080      //  7     7                       ranging response complete (slave)
+#define RADIOLIB_SX128X_IRQ_CRC_ERROR                          0x0040      //  6     6                       CRC error
+#define RADIOLIB_SX128X_IRQ_HEADER_ERROR                       0x0020      //  5     5                       header error
+#define RADIOLIB_SX128X_IRQ_HEADER_VALID                       0x0010      //  4     4                       header valid
+#define RADIOLIB_SX128X_IRQ_SYNC_WORD_ERROR                    0x0008      //  3     3                       sync word error
+#define RADIOLIB_SX128X_IRQ_SYNC_WORD_VALID                    0x0004      //  2     2                       sync word valid
+#define RADIOLIB_SX128X_IRQ_RX_DONE                            0x0002      //  1     1                       Rx done
+#define RADIOLIB_SX128X_IRQ_TX_DONE                            0x0001      //  0     0                       Tx done
+#define RADIOLIB_SX128X_IRQ_NONE                               0x0000      //  15    0                       none
+#define RADIOLIB_SX128X_IRQ_ALL                                0xFFFF      //  15    0                       all
 
-//SX128X_CMD_SET_REGULATOR_MODE
-#define SX128X_REGULATOR_LDO                          0x00        //  7     0     set regulator mode: LDO (default)
-#define SX128X_REGULATOR_DC_DC                        0x01        //  7     0                         DC-DC
+//RADIOLIB_SX128X_CMD_SET_REGULATOR_MODE
+#define RADIOLIB_SX128X_REGULATOR_LDO                          0x00        //  7     0     set regulator mode: LDO (default)
+#define RADIOLIB_SX128X_REGULATOR_DC_DC                        0x01        //  7     0                         DC-DC
 
-//SX128X_CMD_SET_RANGING_ROLE
-#define SX128X_RANGING_ROLE_MASTER                    0x01        //  7     0     ranging role: master
-#define SX128X_RANGING_ROLE_SLAVE                     0x00        //  7     0                   slave
+//RADIOLIB_SX128X_CMD_SET_RANGING_ROLE
+#define RADIOLIB_SX128X_RANGING_ROLE_MASTER                    0x01        //  7     0     ranging role: master
+#define RADIOLIB_SX128X_RANGING_ROLE_SLAVE                     0x00        //  7     0                   slave
 
-//SX128X_REG_LORA_SYNC_WORD_1 - SX128X_REG_LORA_SYNC_WORD_2
-#define SX128X_SYNC_WORD_PRIVATE                      0x12
+//RADIOLIB_SX128X_REG_LORA_SYNC_WORD_1 - RADIOLIB_SX128X_REG_LORA_SYNC_WORD_2
+#define RADIOLIB_SX128X_SYNC_WORD_PRIVATE                      0x12
 
 /*!
   \class SX128x
@@ -362,6 +362,8 @@ class SX128x: public PhysicalLayer {
     */
     SX128x(Module* mod);
 
+    Module* getMod();
+
     // basic methods
 
     /*!
@@ -375,7 +377,7 @@ class SX128x: public PhysicalLayer {
 
       \param cr LoRa coding rate denominator. Defaults to 7 (coding rate 4/7).
 
-      \param syncWord 2-byte LoRa sync word. Defaults to SX128X_SYNC_WORD_PRIVATE (0x12).
+      \param syncWord 2-byte LoRa sync word. Defaults to RADIOLIB_SX128X_SYNC_WORD_PRIVATE (0x12).
 
       \param power Output power in dBm. Defaults to 10 dBm.
 
@@ -383,7 +385,7 @@ class SX128x: public PhysicalLayer {
 
       \returns \ref status_codes
     */
-    int16_t begin(float freq = 2400.0, float bw = 812.5, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX128X_SYNC_WORD_PRIVATE, int8_t power = 10, uint16_t preambleLength = 12);
+    int16_t begin(float freq = 2400.0, float bw = 812.5, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = RADIOLIB_SX128X_SYNC_WORD_PRIVATE, int8_t power = 10, uint16_t preambleLength = 12);
 
     /*!
       \brief Initialization method for GFSK modem.
@@ -485,7 +487,7 @@ class SX128x: public PhysicalLayer {
 
     /*!
       \brief Starts direct mode reception. Only implemented for PhysicalLayer compatibility, as %SX128x series does not support direct mode reception.
-      Will always return ERR_UNKNOWN.
+      Will always return RADIOLIB_ERR_UNKNOWN.
 
       \returns \ref status_codes
     */
@@ -517,7 +519,7 @@ class SX128x: public PhysicalLayer {
     /*!
       \brief Sets the module to standby mode.
 
-      \param mode Oscillator to be used in standby mode. Can be set to SX128X_STANDBY_RC (13 MHz RC oscillator) or SX128X_STANDBY_XOSC (52 MHz external crystal oscillator).
+      \param mode Oscillator to be used in standby mode. Can be set to RADIOLIB_SX128X_STANDBY_RC (13 MHz RC oscillator) or RADIOLIB_SX128X_STANDBY_XOSC (52 MHz external crystal oscillator).
 
       \returns \ref status_codes
     */
@@ -554,11 +556,11 @@ class SX128x: public PhysicalLayer {
     /*!
       \brief Interrupt-driven receive method. DIO1 will be activated when full packet is received.
 
-      \param timeout Raw timeout value, expressed as multiples of 15.625 us. Defaults to SX128X_RX_TIMEOUT_INF for infinite timeout (Rx continuous mode), set to SX128X_RX_TIMEOUT_NONE for no timeout (Rx single mode).
+      \param timeout Raw timeout value, expressed as multiples of 15.625 us. Defaults to RADIOLIB_SX128X_RX_TIMEOUT_INF for infinite timeout (Rx continuous mode), set to RADIOLIB_SX128X_RX_TIMEOUT_NONE for no timeout (Rx single mode).
 
       \returns \ref status_codes
     */
-    int16_t startReceive(uint16_t timeout = SX128X_RX_TIMEOUT_INF);
+    int16_t startReceive(uint16_t timeout = RADIOLIB_SX128X_RX_TIMEOUT_INF);
 
     /*!
       \brief Reads data received after calling startReceive method.
@@ -818,20 +820,20 @@ class SX128x: public PhysicalLayer {
     int16_t readRegister(uint16_t addr, uint8_t* data, uint8_t numBytes);
     int16_t writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset = 0x00);
     int16_t readBuffer(uint8_t* data, uint8_t numBytes);
-    int16_t setTx(uint16_t periodBaseCount = SX128X_TX_TIMEOUT_NONE, uint8_t periodBase = SX128X_PERIOD_BASE_15_625_US);
-    int16_t setRx(uint16_t periodBaseCount, uint8_t periodBase = SX128X_PERIOD_BASE_15_625_US);
+    int16_t setTx(uint16_t periodBaseCount = RADIOLIB_SX128X_TX_TIMEOUT_NONE, uint8_t periodBase = RADIOLIB_SX128X_PERIOD_BASE_15_625_US);
+    int16_t setRx(uint16_t periodBaseCount, uint8_t periodBase = RADIOLIB_SX128X_PERIOD_BASE_15_625_US);
     int16_t setCad();
     uint8_t getPacketType();
     int16_t setRfFrequency(uint32_t frf);
-    int16_t setTxParams(uint8_t power, uint8_t rampTime = SX128X_PA_RAMP_10_US);
+    int16_t setTxParams(uint8_t power, uint8_t rampTime = RADIOLIB_SX128X_PA_RAMP_10_US);
     int16_t setBufferBaseAddress(uint8_t txBaseAddress = 0x00, uint8_t rxBaseAddress = 0x00);
     int16_t setModulationParams(uint8_t modParam1, uint8_t modParam2, uint8_t modParam3);
-    int16_t setPacketParamsGFSK(uint8_t preambleLen, uint8_t syncWordLen, uint8_t syncWordMatch, uint8_t crcLen, uint8_t whitening, uint8_t payloadLen = 0xFF, uint8_t headerType = SX128X_GFSK_FLRC_PACKET_VARIABLE);
+    int16_t setPacketParamsGFSK(uint8_t preambleLen, uint8_t syncWordLen, uint8_t syncWordMatch, uint8_t crcLen, uint8_t whitening, uint8_t payloadLen = 0xFF, uint8_t headerType = RADIOLIB_SX128X_GFSK_FLRC_PACKET_VARIABLE);
     int16_t setPacketParamsBLE(uint8_t connState, uint8_t crcLen, uint8_t bleTestPayload, uint8_t whitening);
-    int16_t setPacketParamsLoRa(uint8_t preambleLen, uint8_t headerType, uint8_t payloadLen, uint8_t crc, uint8_t invertIQ = SX128X_LORA_IQ_STANDARD);
-    int16_t setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = SX128X_IRQ_NONE, uint16_t dio3Mask = SX128X_IRQ_NONE);
+    int16_t setPacketParamsLoRa(uint8_t preambleLen, uint8_t headerType, uint8_t payloadLen, uint8_t crc, uint8_t invertIQ = RADIOLIB_SX128X_LORA_IQ_STANDARD);
+    int16_t setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = RADIOLIB_SX128X_IRQ_NONE, uint16_t dio3Mask = RADIOLIB_SX128X_IRQ_NONE);
     uint16_t getIrqStatus();
-    int16_t clearIrqStatus(uint16_t clearIrqParams = SX128X_IRQ_ALL);
+    int16_t clearIrqStatus(uint16_t clearIrqParams = RADIOLIB_SX128X_IRQ_ALL);
     int16_t setRangingRole(uint8_t role);
     int16_t setPacketType(uint8_t type);