From 6f744a8f138dbce1586f31589753da4556204a4c Mon Sep 17 00:00:00 2001 From: jgromes Date: Sun, 14 Nov 2021 11:41:53 +0100 Subject: [PATCH] [SX126x] Update to 5.0.0 --- .../SX126x_Channel_Activity_Detection.ino | 6 +- ...x_Channel_Activity_Detection_Interrupt.ino | 10 +- .../SX126x_FSK_Modem/SX126x_FSK_Modem.ino | 18 +- .../SX126x_PingPong/SX126x_PingPong.ino | 10 +- .../SX126x/SX126x_Receive/SX126x_Receive.ino | 8 +- .../SX126x_Receive_Interrupt.ino | 8 +- .../SX126x_Settings/SX126x_Settings.ino | 26 +- .../SX126x_Transmit/SX126x_Transmit.ino | 8 +- .../SX126x_Transmit_Interrupt.ino | 6 +- src/modules/SX126x/SX1261.cpp | 8 +- src/modules/SX126x/SX1261.h | 4 +- src/modules/SX126x/SX1262.cpp | 30 +- src/modules/SX126x/SX1262.h | 8 +- src/modules/SX126x/SX1268.cpp | 22 +- src/modules/SX126x/SX1268.h | 8 +- src/modules/SX126x/SX126x.cpp | 700 +++++++++--------- src/modules/SX126x/SX126x.h | 586 +++++++-------- 17 files changed, 734 insertions(+), 732 deletions(-) diff --git a/examples/SX126x/SX126x_Channel_Activity_Detection/SX126x_Channel_Activity_Detection.ino b/examples/SX126x/SX126x_Channel_Activity_Detection/SX126x_Channel_Activity_Detection.ino index b888a95d..8a5b6e16 100644 --- a/examples/SX126x/SX126x_Channel_Activity_Detection/SX126x_Channel_Activity_Detection.ino +++ b/examples/SX126x/SX126x_Channel_Activity_Detection/SX126x_Channel_Activity_Detection.ino @@ -35,7 +35,7 @@ void setup() { // initialize SX1262 with default settings Serial.print(F("[SX1262] Initializing ... ")); int state = radio.begin(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -50,11 +50,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/SX126x/SX126x_Channel_Activity_Detection_Interrupt/SX126x_Channel_Activity_Detection_Interrupt.ino b/examples/SX126x/SX126x_Channel_Activity_Detection_Interrupt/SX126x_Channel_Activity_Detection_Interrupt.ino index 9d65ab24..2598e68c 100644 --- a/examples/SX126x/SX126x_Channel_Activity_Detection_Interrupt/SX126x_Channel_Activity_Detection_Interrupt.ino +++ b/examples/SX126x/SX126x_Channel_Activity_Detection_Interrupt/SX126x_Channel_Activity_Detection_Interrupt.ino @@ -35,7 +35,7 @@ void setup() { // initialize SX1262 with default settings Serial.print(F("[SX1262] Initializing ... ")); int state = radio.begin(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -50,7 +50,7 @@ void setup() { // start scanning the channel Serial.print(F("[SX1262] Starting scan for LoRa preamble ... ")); state = radio.startChannelScan(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -91,11 +91,11 @@ void loop() { // check CAD result int state = radio.getChannelScanResult(); - if (state == LORA_DETECTED) { + if (state == RADIOLIB_LORA_DETECTED) { // LoRa packet was detected Serial.println(F("[SX1262] Packet detected!")); - } else if (state == CHANNEL_FREE) { + } else if (state == RADIOLIB_CHANNEL_FREE) { // channel is free Serial.println(F("[SX1262] Channel is free!")); @@ -109,7 +109,7 @@ void loop() { // start scanning the channel again Serial.print(F("[SX1262] Starting scan for LoRa preamble ... ")); state = radio.startChannelScan(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); diff --git a/examples/SX126x/SX126x_FSK_Modem/SX126x_FSK_Modem.ino b/examples/SX126x/SX126x_FSK_Modem/SX126x_FSK_Modem.ino index d450f9c6..7231da00 100644 --- a/examples/SX126x/SX126x_FSK_Modem/SX126x_FSK_Modem.ino +++ b/examples/SX126x/SX126x_FSK_Modem/SX126x_FSK_Modem.ino @@ -36,7 +36,7 @@ void setup() { // initialize SX1262 FSK modem with default settings Serial.print(F("[SX1262] Initializing ... ")); int state = radio.beginFSK(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -61,7 +61,7 @@ void setup() { uint8_t syncWord[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; state = radio.setSyncWord(syncWord, 8); - if (state != ERR_NONE) { + if (state != RADIOLIB_ERR_NONE) { Serial.print(F("Unable to set configuration, code ")); Serial.println(state); while (true); @@ -94,11 +94,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("[SX1262] Packet transmitted successfully!")); - } else if (state == ERR_PACKET_TOO_LONG) { + } else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) { Serial.println(F("[SX1262] Packet too long!")); - } else if (state == ERR_TX_TIMEOUT) { + } else if (state == RADIOLIB_ERR_TX_TIMEOUT) { Serial.println(F("[SX1262] Timed out while transmitting!")); } else { Serial.println(F("[SX1262] Failed to transmit packet, code ")); @@ -112,11 +112,11 @@ void loop() { byte byteArr[8]; int state = radio.receive(byteArr, 8); */ - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("[SX1262] Received packet!")); Serial.print(F("[SX1262] Data:\t")); Serial.println(str); - } else if (state == ERR_RX_TIMEOUT) { + } else if (state == RADIOLIB_ERR_RX_TIMEOUT) { Serial.println(F("[SX1262] Timed out while waiting for packet!")); } else { Serial.println(F("[SX1262] Failed to receive packet, code ")); @@ -137,7 +137,7 @@ void loop() { state = radio.setNodeAddress(0x02); // set broadcast address to 0xFF state = radio.setBroadcastAddress(0xFF); - if (state != ERR_NONE) { + if (state != RADIOLIB_ERR_NONE) { Serial.println(F("[SX1262] Unable to set address filter, code ")); Serial.println(state); } @@ -147,7 +147,7 @@ void loop() { // node and broadcast address /* state = radio.disableAddressFiltering(); - if (state != ERR_NONE) { + if (state != RADIOLIB_ERR_NONE) { Serial.println(F("Unable to remove address filter, code ")); } */ diff --git a/examples/SX126x/SX126x_PingPong/SX126x_PingPong.ino b/examples/SX126x/SX126x_PingPong/SX126x_PingPong.ino index 946a175c..1f0f8688 100644 --- a/examples/SX126x/SX126x_PingPong/SX126x_PingPong.ino +++ b/examples/SX126x/SX126x_PingPong/SX126x_PingPong.ino @@ -27,7 +27,7 @@ SX1262 radio = new Module(10, 2, 3, 9); //SX1262 radio = RadioShield.ModuleA; // save transmission states between loops -int transmissionState = ERR_NONE; +int transmissionState = RADIOLIB_ERR_NONE; // flag to indicate transmission or reception state bool transmitFlag = false; @@ -58,7 +58,7 @@ void setup() { // initialize SX1262 with default settings Serial.print(F("[SX1262] Initializing ... ")); int state = radio.begin(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -79,7 +79,7 @@ void setup() { // start listening for LoRa packets on this node Serial.print(F("[SX1262] 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 ")); @@ -102,7 +102,7 @@ void loop() { if(transmitFlag) { // the previous operation was transmission, listen for response // print the result - if (transmissionState == ERR_NONE) { + if (transmissionState == RADIOLIB_ERR_NONE) { // packet was successfully sent Serial.println(F("transmission finished!")); @@ -122,7 +122,7 @@ void loop() { String str; int state = radio.readData(str); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { // packet was successfully received Serial.println(F("[SX1262] Received packet!")); diff --git a/examples/SX126x/SX126x_Receive/SX126x_Receive.ino b/examples/SX126x/SX126x_Receive/SX126x_Receive.ino index 23969cb1..0c862e69 100644 --- a/examples/SX126x/SX126x_Receive/SX126x_Receive.ino +++ b/examples/SX126x/SX126x_Receive/SX126x_Receive.ino @@ -40,7 +40,7 @@ void setup() { // initialize SX1262 with default settings Serial.print(F("[SX1262] 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/SX126x/SX126x_Receive_Interrupt/SX126x_Receive_Interrupt.ino b/examples/SX126x/SX126x_Receive_Interrupt/SX126x_Receive_Interrupt.ino index 3932f7b0..2a732d91 100644 --- a/examples/SX126x/SX126x_Receive_Interrupt/SX126x_Receive_Interrupt.ino +++ b/examples/SX126x/SX126x_Receive_Interrupt/SX126x_Receive_Interrupt.ino @@ -41,7 +41,7 @@ void setup() { // initialize SX1262 with default settings Serial.print(F("[SX1262] 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("[SX1262] 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("[SX1262] 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/SX126x/SX126x_Settings/SX126x_Settings.ino b/examples/SX126x/SX126x_Settings/SX126x_Settings.ino index f485284f..f33c9aa0 100644 --- a/examples/SX126x/SX126x_Settings/SX126x_Settings.ino +++ b/examples/SX126x/SX126x_Settings/SX126x_Settings.ino @@ -51,7 +51,7 @@ void setup() { // initialize SX1268 with default settings Serial.print(F("[SX1262] Initializing ... ")); int state = radio1.begin(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -72,7 +72,7 @@ void setup() { // output power: 2 dBm // preamble length: 20 symbols state = radio2.begin(915.0, 500.0, 6, 5, 0x34, 20); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -84,56 +84,56 @@ void setup() { // and check if the configuration was changed successfully // set carrier frequency to 433.5 MHz - if (radio1.setFrequency(433.5) == ERR_INVALID_FREQUENCY) { + if (radio1.setFrequency(433.5) == RADIOLIB_ERR_INVALID_FREQUENCY) { Serial.println(F("Selected frequency is invalid for this module!")); while (true); } // set bandwidth to 250 kHz - if (radio1.setBandwidth(250.0) == ERR_INVALID_BANDWIDTH) { + if (radio1.setBandwidth(250.0) == 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 LoRa sync word to 0xAB - if (radio1.setSyncWord(0xAB) != ERR_NONE) { + if (radio1.setSyncWord(0xAB) != RADIOLIB_ERR_NONE) { Serial.println(F("Unable to set sync word!")); while (true); } // set output power to 10 dBm (accepted range is -17 - 22 dBm) - if (radio1.setOutputPower(10) == ERR_INVALID_OUTPUT_POWER) { + if (radio1.setOutputPower(10) == RADIOLIB_ERR_INVALID_OUTPUT_POWER) { Serial.println(F("Selected output power is invalid for this module!")); while (true); } // set over current protection limit to 80 mA (accepted range is 45 - 240 mA) // NOTE: set value to 0 to disable overcurrent protection - if (radio1.setCurrentLimit(80) == ERR_INVALID_CURRENT_LIMIT) { + if (radio1.setCurrentLimit(80) == RADIOLIB_ERR_INVALID_CURRENT_LIMIT) { Serial.println(F("Selected current limit is invalid for this module!")); while (true); } // set LoRa preamble length to 15 symbols (accepted range is 0 - 65535) - if (radio1.setPreambleLength(15) == ERR_INVALID_PREAMBLE_LENGTH) { + if (radio1.setPreambleLength(15) == 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); } @@ -141,7 +141,7 @@ void setup() { // Some SX126x modules have TCXO (temperature compensated crystal // oscillator). To configure TCXO reference voltage, // the following method can be used. - if (radio1.setTCXO(2.4) == ERR_INVALID_TCXO_VOLTAGE) { + if (radio1.setTCXO(2.4) == RADIOLIB_ERR_INVALID_TCXO_VOLTAGE) { Serial.println(F("Selected TCXO voltage is invalid for this module!")); while (true); } @@ -150,7 +150,7 @@ void setup() { // this feature, the following method can be used. // NOTE: As long as DIO2 is configured to control RF switch, // it can't be used as interrupt pin! - if (radio1.setDio2AsRfSwitch() != ERR_NONE) { + if (radio1.setDio2AsRfSwitch() != RADIOLIB_ERR_NONE) { Serial.println(F("Failed to set DIO2 as RF switch!")); while (true); } diff --git a/examples/SX126x/SX126x_Transmit/SX126x_Transmit.ino b/examples/SX126x/SX126x_Transmit/SX126x_Transmit.ino index 541645ee..5b4c5d0d 100644 --- a/examples/SX126x/SX126x_Transmit/SX126x_Transmit.ino +++ b/examples/SX126x/SX126x_Transmit/SX126x_Transmit.ino @@ -36,7 +36,7 @@ void setup() { // initialize SX1262 with default settings Serial.print(F("[SX1262] Initializing ... ")); int state = radio.begin(); - if (state == ERR_NONE) { + if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { Serial.print(F("failed, code ")); @@ -71,7 +71,7 @@ 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!")); @@ -80,11 +80,11 @@ void loop() { Serial.print(radio.getDataRate()); Serial.println(F(" bps")); - } 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!")); - } else if (state == ERR_TX_TIMEOUT) { + } else if (state == RADIOLIB_ERR_TX_TIMEOUT) { // timeout occured while transmitting packet Serial.println(F("timeout!")); diff --git a/examples/SX126x/SX126x_Transmit_Interrupt/SX126x_Transmit_Interrupt.ino b/examples/SX126x/SX126x_Transmit_Interrupt/SX126x_Transmit_Interrupt.ino index 20600a11..0ec70f65 100644 --- a/examples/SX126x/SX126x_Transmit_Interrupt/SX126x_Transmit_Interrupt.ino +++ b/examples/SX126x/SX126x_Transmit_Interrupt/SX126x_Transmit_Interrupt.ino @@ -32,7 +32,7 @@ SX1262 radio = new Module(10, 2, 3, 9); //SX1262 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 SX1262 with default settings Serial.print(F("[SX1262] 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/SX126x/SX1261.cpp b/src/modules/SX126x/SX1261.cpp index 1e035651..b3424f6f 100644 --- a/src/modules/SX126x/SX1261.cpp +++ b/src/modules/SX126x/SX1261.cpp @@ -6,15 +6,15 @@ SX1261::SX1261(Module* mod): SX1262(mod) { } int16_t SX1261::setOutputPower(int8_t power) { - RADIOLIB_CHECK_RANGE(power, -17, 14, ERR_INVALID_OUTPUT_POWER); + RADIOLIB_CHECK_RANGE(power, -17, 14, RADIOLIB_ERR_INVALID_OUTPUT_POWER); // get current OCP configuration uint8_t ocp = 0; - int16_t state = readRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1); + int16_t state = readRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1); RADIOLIB_ASSERT(state); // set PA config - state = SX126x::setPaConfig(0x04, SX126X_PA_CONFIG_SX1261, 0x00); + state = SX126x::setPaConfig(0x04, RADIOLIB_SX126X_PA_CONFIG_SX1261, 0x00); RADIOLIB_ASSERT(state); // set output power @@ -23,7 +23,7 @@ int16_t SX1261::setOutputPower(int8_t power) { RADIOLIB_ASSERT(state); // restore OCP configuration - return(writeRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1)); } #endif diff --git a/src/modules/SX126x/SX1261.h b/src/modules/SX126x/SX1261.h index 0f5262fd..1dcd6d19 100644 --- a/src/modules/SX126x/SX1261.h +++ b/src/modules/SX126x/SX1261.h @@ -9,8 +9,8 @@ #include "SX126x.h" #include "SX1262.h" -//SX126X_CMD_SET_PA_CONFIG -#define SX126X_PA_CONFIG_SX1261 0x01 +//RADIOLIB_SX126X_CMD_SET_PA_CONFIG +#define RADIOLIB_SX126X_PA_CONFIG_SX1261 0x01 /*! \class SX1261 diff --git a/src/modules/SX126x/SX1262.cpp b/src/modules/SX126x/SX1262.cpp index 0d78eea5..33422125 100644 --- a/src/modules/SX126x/SX1262.cpp +++ b/src/modules/SX126x/SX1262.cpp @@ -42,26 +42,26 @@ int16_t SX1262::beginFSK(float freq, float br, float freqDev, float rxBw, int8_t } int16_t SX1262::setFrequency(float freq, bool calibrate) { - RADIOLIB_CHECK_RANGE(freq, 150.0, 960.0, ERR_INVALID_FREQUENCY); + RADIOLIB_CHECK_RANGE(freq, 150.0, 960.0, RADIOLIB_ERR_INVALID_FREQUENCY); // calibrate image if(calibrate) { uint8_t data[2]; if(freq > 900.0) { - data[0] = SX126X_CAL_IMG_902_MHZ_1; - data[1] = SX126X_CAL_IMG_902_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_902_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_902_MHZ_2; } else if(freq > 850.0) { - data[0] = SX126X_CAL_IMG_863_MHZ_1; - data[1] = SX126X_CAL_IMG_863_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_863_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_863_MHZ_2; } else if(freq > 770.0) { - data[0] = SX126X_CAL_IMG_779_MHZ_1; - data[1] = SX126X_CAL_IMG_779_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_779_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_779_MHZ_2; } else if(freq > 460.0) { - data[0] = SX126X_CAL_IMG_470_MHZ_1; - data[1] = SX126X_CAL_IMG_470_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_470_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_470_MHZ_2; } else { - data[0] = SX126X_CAL_IMG_430_MHZ_1; - data[1] = SX126X_CAL_IMG_430_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_430_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_430_MHZ_2; } int16_t state = SX126x::calibrateImage(data); RADIOLIB_ASSERT(state); @@ -72,15 +72,15 @@ int16_t SX1262::setFrequency(float freq, bool calibrate) { } int16_t SX1262::setOutputPower(int8_t power) { - RADIOLIB_CHECK_RANGE(power, -17, 22, ERR_INVALID_OUTPUT_POWER); + RADIOLIB_CHECK_RANGE(power, -17, 22, RADIOLIB_ERR_INVALID_OUTPUT_POWER); // get current OCP configuration uint8_t ocp = 0; - int16_t state = readRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1); + int16_t state = readRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1); RADIOLIB_ASSERT(state); // set PA config - state = SX126x::setPaConfig(0x04, SX126X_PA_CONFIG_SX1262); + state = SX126x::setPaConfig(0x04, RADIOLIB_SX126X_PA_CONFIG_SX1262); RADIOLIB_ASSERT(state); // set output power @@ -89,7 +89,7 @@ int16_t SX1262::setOutputPower(int8_t power) { RADIOLIB_ASSERT(state); // restore OCP configuration - return(writeRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1)); } #endif diff --git a/src/modules/SX126x/SX1262.h b/src/modules/SX126x/SX1262.h index 3f5afd6c..f259065f 100644 --- a/src/modules/SX126x/SX1262.h +++ b/src/modules/SX126x/SX1262.h @@ -8,8 +8,8 @@ #include "../../Module.h" #include "SX126x.h" -//SX126X_CMD_SET_PA_CONFIG -#define SX126X_PA_CONFIG_SX1262 0x00 +//RADIOLIB_SX126X_CMD_SET_PA_CONFIG +#define RADIOLIB_SX126X_PA_CONFIG_SX1262 0x00 /*! \class SX1262 @@ -38,7 +38,7 @@ class SX1262: public SX126x { \param cr LoRa coding rate denominator. Defaults to 7 (coding rate 4/7). - \param syncWord 2-byte LoRa sync word. Defaults to SX126X_SYNC_WORD_PRIVATE (0x12). + \param syncWord 2-byte LoRa sync word. Defaults to RADIOLIB_SX126X_SYNC_WORD_PRIVATE (0x12). \param power Output power in dBm. Defaults to 10 dBm. @@ -48,7 +48,7 @@ class SX1262: public SX126x { \returns \ref status_codes */ - int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX126X_SYNC_WORD_PRIVATE, int8_t power = 10, uint16_t preambleLength = 8, float tcxoVoltage = 1.6, bool useRegulatorLDO = false); + int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = RADIOLIB_SX126X_SYNC_WORD_PRIVATE, int8_t power = 10, uint16_t preambleLength = 8, float tcxoVoltage = 1.6, bool useRegulatorLDO = false); /*! \brief Initialization method for FSK modem. diff --git a/src/modules/SX126x/SX1268.cpp b/src/modules/SX126x/SX1268.cpp index 0addddf8..dfa65430 100644 --- a/src/modules/SX126x/SX1268.cpp +++ b/src/modules/SX126x/SX1268.cpp @@ -43,20 +43,20 @@ int16_t SX1268::beginFSK(float freq, float br, float freqDev, float rxBw, int8_t /// \todo integers only (all modules - frequency, data rate, bandwidth etc.) int16_t SX1268::setFrequency(float freq, bool calibrate) { - RADIOLIB_CHECK_RANGE(freq, 410.0, 810.0, ERR_INVALID_FREQUENCY); + RADIOLIB_CHECK_RANGE(freq, 410.0, 810.0, RADIOLIB_ERR_INVALID_FREQUENCY); // calibrate image if(calibrate) { uint8_t data[2]; if(freq > 770.0) { - data[0] = SX126X_CAL_IMG_779_MHZ_1; - data[1] = SX126X_CAL_IMG_779_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_779_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_779_MHZ_2; } else if(freq > 460.0) { - data[0] = SX126X_CAL_IMG_470_MHZ_1; - data[1] = SX126X_CAL_IMG_470_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_470_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_470_MHZ_2; } else { - data[0] = SX126X_CAL_IMG_430_MHZ_1; - data[1] = SX126X_CAL_IMG_430_MHZ_2; + data[0] = RADIOLIB_SX126X_CAL_IMG_430_MHZ_1; + data[1] = RADIOLIB_SX126X_CAL_IMG_430_MHZ_2; } int16_t state = SX126x::calibrateImage(data); RADIOLIB_ASSERT(state); @@ -67,15 +67,15 @@ int16_t SX1268::setFrequency(float freq, bool calibrate) { } int16_t SX1268::setOutputPower(int8_t power) { - RADIOLIB_CHECK_RANGE(power, -9, 22, ERR_INVALID_OUTPUT_POWER); + RADIOLIB_CHECK_RANGE(power, -9, 22, RADIOLIB_ERR_INVALID_OUTPUT_POWER); // get current OCP configuration uint8_t ocp = 0; - int16_t state = readRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1); + int16_t state = readRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1); RADIOLIB_ASSERT(state); // set PA config - state = SX126x::setPaConfig(0x04, SX126X_PA_CONFIG_SX1268); + state = SX126x::setPaConfig(0x04, RADIOLIB_SX126X_PA_CONFIG_SX1268); RADIOLIB_ASSERT(state); // set output power @@ -84,7 +84,7 @@ int16_t SX1268::setOutputPower(int8_t power) { RADIOLIB_ASSERT(state); // restore OCP configuration - return(writeRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1)); } #endif diff --git a/src/modules/SX126x/SX1268.h b/src/modules/SX126x/SX1268.h index 3803ec05..4b575342 100644 --- a/src/modules/SX126x/SX1268.h +++ b/src/modules/SX126x/SX1268.h @@ -8,8 +8,8 @@ #include "../../Module.h" #include "SX126x.h" -//SX126X_CMD_SET_PA_CONFIG -#define SX126X_PA_CONFIG_SX1268 0x00 +//RADIOLIB_SX126X_CMD_SET_PA_CONFIG +#define RADIOLIB_SX126X_PA_CONFIG_SX1268 0x00 /*! \class SX1268 @@ -38,7 +38,7 @@ class SX1268: public SX126x { \param cr LoRa coding rate denominator. Defaults to 7 (coding rate 4/7). - \param syncWord 2-byte LoRa sync word. Defaults to SX126X_SYNC_WORD_PRIVATE (0x12). + \param syncWord 2-byte LoRa sync word. Defaults to RADIOLIB_SX126X_SYNC_WORD_PRIVATE (0x12). \param power Output power in dBm. Defaults to 10 dBm. @@ -48,7 +48,7 @@ class SX1268: public SX126x { \returns \ref status_codes */ - int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX126X_SYNC_WORD_PRIVATE, int8_t power = 10, uint16_t preambleLength = 8, float tcxoVoltage = 1.6, bool useRegulatorLDO = false); + int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = RADIOLIB_SX126X_SYNC_WORD_PRIVATE, int8_t power = 10, uint16_t preambleLength = 8, float tcxoVoltage = 1.6, bool useRegulatorLDO = false); /*! \brief Initialization method for FSK modem. diff --git a/src/modules/SX126x/SX126x.cpp b/src/modules/SX126x/SX126x.cpp index 2c8dd3a0..2a308f1a 100644 --- a/src/modules/SX126x/SX126x.cpp +++ b/src/modules/SX126x/SX126x.cpp @@ -1,15 +1,19 @@ #include "SX126x.h" #if !defined(RADIOLIB_EXCLUDE_SX126X) -SX126x::SX126x(Module* mod) : PhysicalLayer(SX126X_FREQUENCY_STEP_SIZE, SX126X_MAX_PACKET_LENGTH) { +SX126x::SX126x(Module* mod) : PhysicalLayer(RADIOLIB_SX126X_FREQUENCY_STEP_SIZE, RADIOLIB_SX126X_MAX_PACKET_LENGTH) { _mod = mod; } +Module* SX126x::getMod() { + return(_mod); +} + int16_t SX126x::begin(float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, uint16_t preambleLength, float tcxoVoltage, bool useRegulatorLDO) { // 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\tSX126x")); // BW in kHz and SF are required in order to calculate LDRO for setModulationParams @@ -17,13 +21,13 @@ int16_t SX126x::begin(float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, uint16 _sf = sf; // initialize configuration variables (will be overwritten during public settings configuration) - _bw = SX126X_LORA_BW_125_0; - _cr = SX126X_LORA_CR_4_7; + _bw = RADIOLIB_SX126X_LORA_BW_125_0; + _cr = RADIOLIB_SX126X_LORA_CR_4_7; _ldro = 0x00; - _crcType = SX126X_LORA_CRC_ON; + _crcType = RADIOLIB_SX126X_LORA_CRC_ON; _preambleLength = preambleLength; _tcxoDelay = 0; - _headerType = SX126X_LORA_HEADER_EXPLICIT; + _headerType = RADIOLIB_SX126X_LORA_HEADER_EXPLICIT; _implicitLen = 0xFF; // reset the module and verify startup @@ -35,7 +39,7 @@ int16_t SX126x::begin(float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, uint16 RADIOLIB_ASSERT(state); // configure settings not accessible by API - state = config(SX126X_PACKET_TYPE_LORA); + state = config(RADIOLIB_SX126X_PACKET_TYPE_LORA); RADIOLIB_ASSERT(state); // set TCXO control, if requested @@ -78,20 +82,20 @@ int16_t SX126x::begin(float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, uint16 int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleLength, float tcxoVoltage, bool useRegulatorLDO) { // 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\tSX126x")); // initialize configuration variables (will be overwritten during public settings configuration) _br = 21333; // 48.0 kbps _freqDev = 52428; // 50.0 kHz - _rxBw = SX126X_GFSK_RX_BW_156_2; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_156_2; _rxBwKhz = 156.2; - _pulseShape = SX126X_GFSK_FILTER_GAUSS_0_5; - _crcTypeFSK = SX126X_GFSK_CRC_2_BYTE_INV; // CCIT CRC configuration + _pulseShape = RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_5; + _crcTypeFSK = RADIOLIB_SX126X_GFSK_CRC_2_BYTE_INV; // CCIT CRC configuration _preambleLengthFSK = preambleLength; - _addrComp = SX126X_GFSK_ADDRESS_FILT_OFF; + _addrComp = RADIOLIB_SX126X_GFSK_ADDRESS_FILT_OFF; // reset the module and verify startup int16_t state = reset(); @@ -102,7 +106,7 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL RADIOLIB_ASSERT(state); // configure settings not accessible by API - state = config(SX126X_PACKET_TYPE_GFSK); + state = config(RADIOLIB_SX126X_PACKET_TYPE_GFSK); RADIOLIB_ASSERT(state); // set TCXO control, if requested @@ -145,7 +149,7 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL state = setEncoding(RADIOLIB_ENCODING_NRZ); RADIOLIB_ASSERT(state); - state = variablePacketLengthMode(SX126X_MAX_PACKET_LENGTH); + state = variablePacketLengthMode(RADIOLIB_SX126X_MAX_PACKET_LENGTH); RADIOLIB_ASSERT(state); state = setCRC(2); @@ -159,34 +163,34 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL int16_t SX126x::reset(bool verify) { // run the reset sequence - 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 - SX126x often refuses first few commands after reset - 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); } } @@ -196,24 +200,24 @@ int16_t SX126x::transmit(uint8_t* data, size_t len, uint8_t addr) { RADIOLIB_ASSERT(state); // check packet length - if(len > SX126X_MAX_PACKET_LENGTH) { - return(ERR_PACKET_TOO_LONG); + if(len > RADIOLIB_SX126X_MAX_PACKET_LENGTH) { + return(RADIOLIB_ERR_PACKET_TOO_LONG); } uint32_t timeout = 0; // get currently active modem uint8_t modem = getPacketType(); - if(modem == SX126X_PACKET_TYPE_LORA) { + if(modem == RADIOLIB_SX126X_PACKET_TYPE_LORA) { // calculate timeout (150% of expected time-on-air) timeout = (getTimeOnAir(len) * 3) / 2; - } else if(modem == SX126X_PACKET_TYPE_GFSK) { + } else if(modem == RADIOLIB_SX126X_PACKET_TYPE_GFSK) { // calculate timeout (500% of expected time-on-air) timeout = getTimeOnAir(len) * 5; } else { - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } RADIOLIB_DEBUG_PRINT(F("Timeout in ")); @@ -225,16 +229,16 @@ int16_t SX126x::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); } } - uint32_t elapsed = Module::micros() - start; + uint32_t elapsed = _mod->micros() - start; // update data rate _dataRate = (len*8.0)/((float)elapsed/1000000.0); @@ -258,21 +262,21 @@ int16_t SX126x::receive(uint8_t* data, size_t len) { // get currently active modem uint8_t modem = getPacketType(); - if(modem == SX126X_PACKET_TYPE_LORA) { + if(modem == RADIOLIB_SX126X_PACKET_TYPE_LORA) { // calculate timeout (100 LoRa symbols, the default for SX127x series) float symbolLength = (float)(uint32_t(1) << _sf) / (float)_bwKhz; timeout = (uint32_t)(symbolLength * 100.0 * 1000.0); - } else if(modem == SX126X_PACKET_TYPE_GFSK) { + } else if(modem == RADIOLIB_SX126X_PACKET_TYPE_GFSK) { // calculate timeout (500 % of expected time-one-air) size_t maxLen = len; if(len == 0) { maxLen = 0xFF; } - float brBps = ((float)(SX126X_CRYSTAL_FREQ) * 1000000.0 * 32.0) / (float)_br; + float brBps = ((float)(RADIOLIB_SX126X_CRYSTAL_FREQ) * 1000000.0 * 32.0) / (float)_br; timeout = (uint32_t)(((maxLen * 8.0) / brBps) * 1000000.0 * 5.0); } else { - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } RADIOLIB_DEBUG_PRINT(F("Timeout in ")); @@ -285,19 +289,19 @@ int16_t SX126x::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) { fixImplicitTimeout(); clearIrqStatus(); standby(); - return(ERR_RX_TIMEOUT); + return(RADIOLIB_ERR_RX_TIMEOUT); } } // fix timeout in implicit LoRa mode - if(((_headerType == SX126X_LORA_HEADER_IMPLICIT) && (getPacketType() == SX126X_PACKET_TYPE_LORA))) { + if(((_headerType == RADIOLIB_SX126X_LORA_HEADER_IMPLICIT) && (getPacketType() == RADIOLIB_SX126X_PACKET_TYPE_LORA))) { state = fixImplicitTimeout(); RADIOLIB_ASSERT(state); } @@ -311,15 +315,15 @@ int16_t SX126x::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 - uint8_t data[] = {SX126X_CMD_NOP}; - return(SPIwriteCommand(SX126X_CMD_SET_TX_CONTINUOUS_WAVE, data, 1)); + uint8_t data[] = {RADIOLIB_SX126X_CMD_NOP}; + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_TX_CONTINUOUS_WAVE, data, 1)); } int16_t SX126x::receiveDirect() { @@ -327,7 +331,7 @@ int16_t SX126x::receiveDirect() { _mod->setRfSwitchState(HIGH, LOW); // SX126x is unable to output received data directly - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } int16_t SX126x::scanChannel() { @@ -336,8 +340,8 @@ int16_t SX126x::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 @@ -348,20 +352,20 @@ int16_t SX126x::sleep(bool retainConfig) { // set RF switch (if present) _mod->setRfSwitchState(LOW, LOW); - uint8_t sleepMode = SX126X_SLEEP_START_WARM | SX126X_SLEEP_RTC_OFF; + uint8_t sleepMode = RADIOLIB_SX126X_SLEEP_START_WARM | RADIOLIB_SX126X_SLEEP_RTC_OFF; if(!retainConfig) { - sleepMode = SX126X_SLEEP_START_COLD | SX126X_SLEEP_RTC_OFF; + sleepMode = RADIOLIB_SX126X_SLEEP_START_COLD | RADIOLIB_SX126X_SLEEP_RTC_OFF; } - int16_t state = SPIwriteCommand(SX126X_CMD_SET_SLEEP, &sleepMode, 1, false); + int16_t state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_SLEEP, &sleepMode, 1, false); // wait for SX126x to safely enter sleep mode - Module::delay(1); + _mod->delay(1); return(state); } int16_t SX126x::standby() { - return(SX126x::standby(SX126X_STANDBY_RC)); + return(SX126x::standby(RADIOLIB_SX126X_STANDBY_RC)); } int16_t SX126x::standby(uint8_t mode) { @@ -369,15 +373,15 @@ int16_t SX126x::standby(uint8_t mode) { _mod->setRfSwitchState(LOW, LOW); uint8_t data[] = {mode}; - return(SPIwriteCommand(SX126X_CMD_SET_STANDBY, data, 1)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_STANDBY, data, 1)); } void SX126x::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 SX126x::clearDio1Action() { - Module::detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq())); + _mod->detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq())); } int16_t SX126x::startTransmit(uint8_t* data, size_t len, uint8_t addr) { @@ -385,29 +389,29 @@ int16_t SX126x::startTransmit(uint8_t* data, size_t len, uint8_t addr) { (void)addr; // check packet length - if(len > SX126X_MAX_PACKET_LENGTH) { - return(ERR_PACKET_TOO_LONG); + if(len > RADIOLIB_SX126X_MAX_PACKET_LENGTH) { + return(RADIOLIB_ERR_PACKET_TOO_LONG); } // maximum packet length is decreased by 1 when address filtering is active - if((_addrComp != SX126X_GFSK_ADDRESS_FILT_OFF) && (len > SX126X_MAX_PACKET_LENGTH - 1)) { - return(ERR_PACKET_TOO_LONG); + if((_addrComp != RADIOLIB_SX126X_GFSK_ADDRESS_FILT_OFF) && (len > RADIOLIB_SX126X_MAX_PACKET_LENGTH - 1)) { + 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 == SX126X_PACKET_TYPE_LORA) { + if(modem == RADIOLIB_SX126X_PACKET_TYPE_LORA) { state = setPacketParams(_preambleLength, _crcType, len, _headerType); - } else if(modem == SX126X_PACKET_TYPE_GFSK) { + } else if(modem == RADIOLIB_SX126X_PACKET_TYPE_GFSK) { state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType, len); } else { - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } RADIOLIB_ASSERT(state); // set DIO mapping - state = setDioIrqParams(SX126X_IRQ_TX_DONE | SX126X_IRQ_TIMEOUT, SX126X_IRQ_TX_DONE); + state = setDioIrqParams(RADIOLIB_SX126X_IRQ_TX_DONE | RADIOLIB_SX126X_IRQ_TIMEOUT, RADIOLIB_SX126X_IRQ_TX_DONE); RADIOLIB_ASSERT(state); // set buffer pointers @@ -430,12 +434,12 @@ int16_t SX126x::startTransmit(uint8_t* data, size_t len, uint8_t addr) { _mod->setRfSwitchState(LOW, HIGH); // start transmission - state = setTx(SX126X_TX_TIMEOUT_NONE); + state = setTx(RADIOLIB_SX126X_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); @@ -465,12 +469,12 @@ int16_t SX126x::startReceiveDutyCycle(uint32_t rxPeriod, uint32_t sleepPeriod) { // check 24 bit limit and zero value (likely not intended) if((rxPeriodRaw & 0xFF000000) || (rxPeriodRaw == 0)) { - return(ERR_INVALID_RX_PERIOD); + return(RADIOLIB_ERR_INVALID_RX_PERIOD); } // this check of the high byte also catches underflow when we subtracted transitionTime if((sleepPeriodRaw & 0xFF000000) || (sleepPeriodRaw == 0)) { - return(ERR_INVALID_SLEEP_PERIOD); + return(RADIOLIB_ERR_INVALID_SLEEP_PERIOD); } int16_t state = startReceiveCommon(); @@ -478,7 +482,7 @@ int16_t SX126x::startReceiveDutyCycle(uint32_t rxPeriod, uint32_t sleepPeriod) { uint8_t data[6] = {(uint8_t)((rxPeriodRaw >> 16) & 0xFF), (uint8_t)((rxPeriodRaw >> 8) & 0xFF), (uint8_t)(rxPeriodRaw & 0xFF), (uint8_t)((sleepPeriodRaw >> 16) & 0xFF), (uint8_t)((sleepPeriodRaw >> 8) & 0xFF), (uint8_t)(sleepPeriodRaw & 0xFF)}; - return(SPIwriteCommand(SX126X_CMD_SET_RX_DUTY_CYCLE, data, 6)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RX_DUTY_CYCLE, data, 6)); } int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_t minSymbols) { @@ -523,7 +527,7 @@ int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_ int16_t SX126x::startReceiveCommon() { // set DIO mapping - int16_t state = setDioIrqParams(SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT | SX126X_IRQ_CRC_ERR | SX126X_IRQ_HEADER_ERR, SX126X_IRQ_RX_DONE); + int16_t state = setDioIrqParams(RADIOLIB_SX126X_IRQ_RX_DONE | RADIOLIB_SX126X_IRQ_TIMEOUT | RADIOLIB_SX126X_IRQ_CRC_ERR | RADIOLIB_SX126X_IRQ_HEADER_ERR, RADIOLIB_SX126X_IRQ_RX_DONE); RADIOLIB_ASSERT(state); // set buffer pointers @@ -535,12 +539,12 @@ int16_t SX126x::startReceiveCommon() { // restore original packet length uint8_t modem = getPacketType(); - if(modem == SX126X_PACKET_TYPE_LORA) { + if(modem == RADIOLIB_SX126X_PACKET_TYPE_LORA) { state = setPacketParams(_preambleLength, _crcType, _implicitLen, _headerType); - } else if(modem == SX126X_PACKET_TYPE_GFSK) { + } else if(modem == RADIOLIB_SX126X_PACKET_TYPE_GFSK) { state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType); } else { - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } return(state); @@ -553,14 +557,14 @@ int16_t SX126x::readData(uint8_t* data, size_t len) { // check integrity CRC uint16_t irq = getIrqStatus(); - int16_t crcState = ERR_NONE; - if((irq & SX126X_IRQ_CRC_ERR) || (irq & SX126X_IRQ_HEADER_ERR)) { - crcState = ERR_CRC_MISMATCH; + int16_t crcState = RADIOLIB_ERR_NONE; + if((irq & RADIOLIB_SX126X_IRQ_CRC_ERR) || (irq & RADIOLIB_SX126X_IRQ_HEADER_ERR)) { + crcState = RADIOLIB_ERR_CRC_MISMATCH; } // get packet length size_t length = len; - if(len == SX126X_MAX_PACKET_LENGTH) { + if(len == RADIOLIB_SX126X_MAX_PACKET_LENGTH) { length = getPacketLength(); } @@ -579,8 +583,8 @@ int16_t SX126x::readData(uint8_t* data, size_t len) { int16_t SX126x::startChannelScan() { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } // set mode to standby @@ -591,7 +595,7 @@ int16_t SX126x::startChannelScan() { _mod->setRfSwitchState(HIGH, LOW); // set DIO pin mapping - state = setDioIrqParams(SX126X_IRQ_CAD_DETECTED | SX126X_IRQ_CAD_DONE, SX126X_IRQ_CAD_DETECTED | SX126X_IRQ_CAD_DONE); + state = setDioIrqParams(RADIOLIB_SX126X_IRQ_CAD_DETECTED | RADIOLIB_SX126X_IRQ_CAD_DONE, RADIOLIB_SX126X_IRQ_CAD_DETECTED | RADIOLIB_SX126X_IRQ_CAD_DONE); RADIOLIB_ASSERT(state); // clear interrupt flags @@ -605,69 +609,69 @@ int16_t SX126x::startChannelScan() { int16_t SX126x::getChannelScanResult() { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } // check CAD result uint16_t cadResult = getIrqStatus(); - if(cadResult & SX126X_IRQ_CAD_DETECTED) { + if(cadResult & RADIOLIB_SX126X_IRQ_CAD_DETECTED) { // detected some LoRa activity clearIrqStatus(); - return(LORA_DETECTED); - } else if(cadResult & SX126X_IRQ_CAD_DONE) { + return(RADIOLIB_LORA_DETECTED); + } else if(cadResult & RADIOLIB_SX126X_IRQ_CAD_DONE) { // channel is free clearIrqStatus(); - return(CHANNEL_FREE); + return(RADIOLIB_CHANNEL_FREE); } - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } int16_t SX126x::setBandwidth(float bw) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } // ensure byte conversion doesn't overflow - RADIOLIB_CHECK_RANGE(bw, 0.0, 510.0, ERR_INVALID_BANDWIDTH); + RADIOLIB_CHECK_RANGE(bw, 0.0, 510.0, RADIOLIB_ERR_INVALID_BANDWIDTH); // check allowed bandwidth values uint8_t bw_div2 = bw / 2 + 0.01; switch (bw_div2) { case 3: // 7.8: - _bw = SX126X_LORA_BW_7_8; + _bw = RADIOLIB_SX126X_LORA_BW_7_8; break; case 5: // 10.4: - _bw = SX126X_LORA_BW_10_4; + _bw = RADIOLIB_SX126X_LORA_BW_10_4; break; case 7: // 15.6: - _bw = SX126X_LORA_BW_15_6; + _bw = RADIOLIB_SX126X_LORA_BW_15_6; break; case 10: // 20.8: - _bw = SX126X_LORA_BW_20_8; + _bw = RADIOLIB_SX126X_LORA_BW_20_8; break; case 15: // 31.25: - _bw = SX126X_LORA_BW_31_25; + _bw = RADIOLIB_SX126X_LORA_BW_31_25; break; case 20: // 41.7: - _bw = SX126X_LORA_BW_41_7; + _bw = RADIOLIB_SX126X_LORA_BW_41_7; break; case 31: // 62.5: - _bw = SX126X_LORA_BW_62_5; + _bw = RADIOLIB_SX126X_LORA_BW_62_5; break; case 62: // 125.0: - _bw = SX126X_LORA_BW_125_0; + _bw = RADIOLIB_SX126X_LORA_BW_125_0; break; case 125: // 250.0 - _bw = SX126X_LORA_BW_250_0; + _bw = RADIOLIB_SX126X_LORA_BW_250_0; break; case 250: // 500.0 - _bw = SX126X_LORA_BW_500_0; + _bw = RADIOLIB_SX126X_LORA_BW_500_0; break; default: - return(ERR_INVALID_BANDWIDTH); + return(RADIOLIB_ERR_INVALID_BANDWIDTH); } // update modulation parameters @@ -677,11 +681,11 @@ int16_t SX126x::setBandwidth(float bw) { int16_t SX126x::setSpreadingFactor(uint8_t sf) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } - RADIOLIB_CHECK_RANGE(sf, 5, 12, ERR_INVALID_SPREADING_FACTOR); + RADIOLIB_CHECK_RANGE(sf, 5, 12, RADIOLIB_ERR_INVALID_SPREADING_FACTOR); // update modulation parameters _sf = sf; @@ -690,11 +694,11 @@ int16_t SX126x::setSpreadingFactor(uint8_t sf) { int16_t SX126x::setCodingRate(uint8_t cr) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } - RADIOLIB_CHECK_RANGE(cr, 5, 8, ERR_INVALID_CODING_RATE); + RADIOLIB_CHECK_RANGE(cr, 5, 8, RADIOLIB_ERR_INVALID_CODING_RATE); // update modulation parameters _cr = cr - 4; @@ -703,32 +707,32 @@ int16_t SX126x::setCodingRate(uint8_t cr) { int16_t SX126x::setSyncWord(uint8_t syncWord, uint8_t controlBits) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_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(SX126X_REG_LORA_SYNC_WORD_MSB, data, 2)); + return(writeRegister(RADIOLIB_SX126X_REG_LORA_SYNC_WORD_MSB, data, 2)); } int16_t SX126x::setCurrentLimit(float currentLimit) { // check allowed range if(!((currentLimit >= 0) && (currentLimit <= 140))) { - return(ERR_INVALID_CURRENT_LIMIT); + return(RADIOLIB_ERR_INVALID_CURRENT_LIMIT); } // calculate raw value uint8_t rawLimit = (uint8_t)(currentLimit / 2.5); // update register - return(writeRegister(SX126X_REG_OCP_CONFIGURATION, &rawLimit, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &rawLimit, 1)); } float SX126x::getCurrentLimit() { // get the raw value uint8_t ocp = 0; - readRegister(SX126X_REG_OCP_CONFIGURATION, &ocp, 1); + readRegister(RADIOLIB_SX126X_REG_OCP_CONFIGURATION, &ocp, 1); // return the actual value return((float)ocp * 2.5); @@ -736,21 +740,21 @@ float SX126x::getCurrentLimit() { int16_t SX126x::setPreambleLength(uint16_t preambleLength) { uint8_t modem = getPacketType(); - if(modem == SX126X_PACKET_TYPE_LORA) { + if(modem == RADIOLIB_SX126X_PACKET_TYPE_LORA) { _preambleLength = preambleLength; return(setPacketParams(_preambleLength, _crcType, _implicitLen, _headerType)); - } else if(modem == SX126X_PACKET_TYPE_GFSK) { + } else if(modem == RADIOLIB_SX126X_PACKET_TYPE_GFSK) { _preambleLengthFSK = preambleLength; return(setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType)); } - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } int16_t SX126x::setFrequencyDeviation(float freqDev) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // set frequency deviation to lowest available setting (required for digimodes) @@ -759,14 +763,14 @@ int16_t SX126x::setFrequencyDeviation(float freqDev) { newFreqDev = 0.6; } - RADIOLIB_CHECK_RANGE(newFreqDev, 0.6, 200.0, ERR_INVALID_FREQUENCY_DEVIATION); + RADIOLIB_CHECK_RANGE(newFreqDev, 0.6, 200.0, RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION); // calculate raw frequency deviation value - uint32_t freqDevRaw = (uint32_t)(((newFreqDev * 1000.0) * (float)((uint32_t)(1) << 25)) / (SX126X_CRYSTAL_FREQ * 1000000.0)); + uint32_t freqDevRaw = (uint32_t)(((newFreqDev * 1000.0) * (float)((uint32_t)(1) << 25)) / (RADIOLIB_SX126X_CRYSTAL_FREQ * 1000000.0)); // check modulation parameters /*if(2 * freqDevRaw + _br > _rxBwKhz * 1000.0) { - return(ERR_INVALID_MODULATION_PARAMETERS); + return(RADIOLIB_ERR_INVALID_MODULATION_PARAMETERS); }*/ _freqDev = freqDevRaw; @@ -776,18 +780,18 @@ int16_t SX126x::setFrequencyDeviation(float freqDev) { int16_t SX126x::setBitRate(float br) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } - RADIOLIB_CHECK_RANGE(br, 0.6, 300.0, ERR_INVALID_BIT_RATE); + RADIOLIB_CHECK_RANGE(br, 0.6, 300.0, RADIOLIB_ERR_INVALID_BIT_RATE); // calculate raw bit rate value - uint32_t brRaw = (uint32_t)((SX126X_CRYSTAL_FREQ * 1000000.0 * 32.0) / (br * 1000.0)); + uint32_t brRaw = (uint32_t)((RADIOLIB_SX126X_CRYSTAL_FREQ * 1000000.0 * 32.0) / (br * 1000.0)); // check modulation parameters /*if(2 * _freqDev + brRaw > _rxBwKhz * 1000.0) { - return(ERR_INVALID_MODULATION_PARAMETERS); + return(RADIOLIB_ERR_INVALID_MODULATION_PARAMETERS); }*/ _br = brRaw; @@ -797,61 +801,61 @@ int16_t SX126x::setBitRate(float br) { int16_t SX126x::setRxBandwidth(float rxBw) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // check modulation parameters /*if(2 * _freqDev + _br > rxBw * 1000.0) { - return(ERR_INVALID_MODULATION_PARAMETERS); + return(RADIOLIB_ERR_INVALID_MODULATION_PARAMETERS); }*/ _rxBwKhz = rxBw; // check allowed receiver bandwidth values if(fabs(rxBw - 4.8) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_4_8; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_4_8; } else if(fabs(rxBw - 5.8) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_5_8; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_5_8; } else if(fabs(rxBw - 7.3) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_7_3; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_7_3; } else if(fabs(rxBw - 9.7) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_9_7; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_9_7; } else if(fabs(rxBw - 11.7) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_11_7; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_11_7; } else if(fabs(rxBw - 14.6) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_14_6; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_14_6; } else if(fabs(rxBw - 19.5) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_19_5; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_19_5; } else if(fabs(rxBw - 23.4) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_23_4; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_23_4; } else if(fabs(rxBw - 29.3) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_29_3; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_29_3; } else if(fabs(rxBw - 39.0) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_39_0; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_39_0; } else if(fabs(rxBw - 46.9) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_46_9; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_46_9; } else if(fabs(rxBw - 58.6) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_58_6; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_58_6; } else if(fabs(rxBw - 78.2) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_78_2; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_78_2; } else if(fabs(rxBw - 93.8) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_93_8; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_93_8; } else if(fabs(rxBw - 117.3) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_117_3; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_117_3; } else if(fabs(rxBw - 156.2) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_156_2; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_156_2; } else if(fabs(rxBw - 187.2) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_187_2; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_187_2; } else if(fabs(rxBw - 234.3) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_234_3; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_234_3; } else if(fabs(rxBw - 312.0) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_312_0; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_312_0; } else if(fabs(rxBw - 373.6) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_373_6; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_373_6; } else if(fabs(rxBw - 467.0) <= 0.001) { - _rxBw = SX126X_GFSK_RX_BW_467_0; + _rxBw = RADIOLIB_SX126X_GFSK_RX_BW_467_0; } else { - return(ERR_INVALID_RX_BANDWIDTH); + return(RADIOLIB_ERR_INVALID_RX_BANDWIDTH); } // update modulation parameters @@ -860,29 +864,29 @@ int16_t SX126x::setRxBandwidth(float rxBw) { int16_t SX126x::setDataShaping(uint8_t sh) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // set data shaping switch(sh) { case RADIOLIB_SHAPING_NONE: - _pulseShape = SX126X_GFSK_FILTER_NONE; + _pulseShape = RADIOLIB_SX126X_GFSK_FILTER_NONE; break; case RADIOLIB_SHAPING_0_3: - _pulseShape = SX126X_GFSK_FILTER_GAUSS_0_3; + _pulseShape = RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_3; break; case RADIOLIB_SHAPING_0_5: - _pulseShape = SX126X_GFSK_FILTER_GAUSS_0_5; + _pulseShape = RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_5; break; case RADIOLIB_SHAPING_0_7: - _pulseShape = SX126X_GFSK_FILTER_GAUSS_0_7; + _pulseShape = RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_7; break; case RADIOLIB_SHAPING_1_0: - _pulseShape = SX126X_GFSK_FILTER_GAUSS_1; + _pulseShape = RADIOLIB_SX126X_GFSK_FILTER_GAUSS_1; break; default: - return(ERR_INVALID_DATA_SHAPING); + return(RADIOLIB_ERR_INVALID_DATA_SHAPING); } // update modulation parameters @@ -891,17 +895,17 @@ int16_t SX126x::setDataShaping(uint8_t sh) { int16_t SX126x::setSyncWord(uint8_t* syncWord, uint8_t len) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // check sync word Length if(len > 8) { - return(ERR_INVALID_SYNC_WORD); + return(RADIOLIB_ERR_INVALID_SYNC_WORD); } // write sync word - int16_t state = writeRegister(SX126X_REG_SYNC_WORD_0, syncWord, len); + int16_t state = writeRegister(RADIOLIB_SX126X_REG_SYNC_WORD_0, syncWord, len); RADIOLIB_ASSERT(state); // update packet parameters @@ -913,13 +917,13 @@ int16_t SX126x::setSyncWord(uint8_t* syncWord, uint8_t len) { int16_t SX126x::setSyncBits(uint8_t *syncWord, uint8_t bitsLen) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // check sync word Length if(bitsLen > 0x40) { - return(ERR_INVALID_SYNC_WORD); + return(RADIOLIB_ERR_INVALID_SYNC_WORD); } uint8_t bytesLen = bitsLen / 8; @@ -928,7 +932,7 @@ int16_t SX126x::setSyncBits(uint8_t *syncWord, uint8_t bitsLen) { } // write sync word - int16_t state = writeRegister(SX126X_REG_SYNC_WORD_0, syncWord, bytesLen); + int16_t state = writeRegister(RADIOLIB_SX126X_REG_SYNC_WORD_0, syncWord, bytesLen); RADIOLIB_ASSERT(state); // update packet parameters @@ -940,46 +944,46 @@ int16_t SX126x::setSyncBits(uint8_t *syncWord, uint8_t bitsLen) { int16_t SX126x::setNodeAddress(uint8_t nodeAddr) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // enable address filtering (node only) - _addrComp = SX126X_GFSK_ADDRESS_FILT_NODE; + _addrComp = RADIOLIB_SX126X_GFSK_ADDRESS_FILT_NODE; int16_t state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType); RADIOLIB_ASSERT(state); // set node address - state = writeRegister(SX126X_REG_NODE_ADDRESS, &nodeAddr, 1); + state = writeRegister(RADIOLIB_SX126X_REG_NODE_ADDRESS, &nodeAddr, 1); return(state); } int16_t SX126x::setBroadcastAddress(uint8_t broadAddr) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // enable address filtering (node and broadcast) - _addrComp = SX126X_GFSK_ADDRESS_FILT_NODE_BROADCAST; + _addrComp = RADIOLIB_SX126X_GFSK_ADDRESS_FILT_NODE_BROADCAST; int16_t state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType); RADIOLIB_ASSERT(state); // set broadcast address - state = writeRegister(SX126X_REG_BROADCAST_ADDRESS, &broadAddr, 1); + state = writeRegister(RADIOLIB_SX126X_REG_BROADCAST_ADDRESS, &broadAddr, 1); return(state); } int16_t SX126x::disableAddressFiltering() { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // disable address filtering - _addrComp = SX126X_GFSK_ADDRESS_FILT_OFF; + _addrComp = RADIOLIB_SX126X_GFSK_ADDRESS_FILT_OFF; return(setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening)); } @@ -987,28 +991,28 @@ int16_t SX126x::setCRC(uint8_t len, uint16_t initial, uint16_t polynomial, bool // check active modem uint8_t modem = getPacketType(); - if(modem == SX126X_PACKET_TYPE_GFSK) { + if(modem == RADIOLIB_SX126X_PACKET_TYPE_GFSK) { // update packet parameters switch(len) { case 0: - _crcTypeFSK = SX126X_GFSK_CRC_OFF; + _crcTypeFSK = RADIOLIB_SX126X_GFSK_CRC_OFF; break; case 1: if(inverted) { - _crcTypeFSK = SX126X_GFSK_CRC_1_BYTE_INV; + _crcTypeFSK = RADIOLIB_SX126X_GFSK_CRC_1_BYTE_INV; } else { - _crcTypeFSK = SX126X_GFSK_CRC_1_BYTE; + _crcTypeFSK = RADIOLIB_SX126X_GFSK_CRC_1_BYTE; } break; case 2: if(inverted) { - _crcTypeFSK = SX126X_GFSK_CRC_2_BYTE_INV; + _crcTypeFSK = RADIOLIB_SX126X_GFSK_CRC_2_BYTE_INV; } else { - _crcTypeFSK = SX126X_GFSK_CRC_2_BYTE; + _crcTypeFSK = RADIOLIB_SX126X_GFSK_CRC_2_BYTE; } break; default: - return(ERR_INVALID_CRC_CONFIGURATION); + return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION); } int16_t state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType); @@ -1016,61 +1020,61 @@ int16_t SX126x::setCRC(uint8_t len, uint16_t initial, uint16_t polynomial, bool // write initial CRC value uint8_t data[2] = {(uint8_t)((initial >> 8) & 0xFF), (uint8_t)(initial & 0xFF)}; - state = writeRegister(SX126X_REG_CRC_INITIAL_MSB, data, 2); + state = writeRegister(RADIOLIB_SX126X_REG_CRC_INITIAL_MSB, data, 2); RADIOLIB_ASSERT(state); // write CRC polynomial value data[0] = (uint8_t)((polynomial >> 8) & 0xFF); data[1] = (uint8_t)(polynomial & 0xFF); - state = writeRegister(SX126X_REG_CRC_POLYNOMIAL_MSB, data, 2); + state = writeRegister(RADIOLIB_SX126X_REG_CRC_POLYNOMIAL_MSB, data, 2); return(state); - } else if(modem == SX126X_PACKET_TYPE_LORA) { + } else if(modem == RADIOLIB_SX126X_PACKET_TYPE_LORA) { // LoRa CRC doesn't allow to set CRC polynomial, initial value, or inversion // update packet parameters if(len) { - _crcType = SX126X_LORA_CRC_ON; + _crcType = RADIOLIB_SX126X_LORA_CRC_ON; } else { - _crcType = SX126X_LORA_CRC_OFF; + _crcType = RADIOLIB_SX126X_LORA_CRC_OFF; } return(setPacketParams(_preambleLength, _crcType, _implicitLen, _headerType)); } - return(ERR_UNKNOWN); + return(RADIOLIB_ERR_UNKNOWN); } int16_t SX126x::setWhitening(bool enabled, uint16_t initial) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } - int16_t state = ERR_NONE; + int16_t state = RADIOLIB_ERR_NONE; if(!enabled) { // disable whitening - _whitening = SX126X_GFSK_WHITENING_OFF; + _whitening = RADIOLIB_SX126X_GFSK_WHITENING_OFF; state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType); RADIOLIB_ASSERT(state); } else { // enable whitening - _whitening = SX126X_GFSK_WHITENING_ON; + _whitening = RADIOLIB_SX126X_GFSK_WHITENING_ON; // write initial whitening value // as per note on pg. 65 of datasheet v1.2: "The user should not change the value of the 7 MSB's of this register" uint8_t data[2]; // first read the actual value and mask 7 MSB which we can not change // if different value is written in 7 MSB, the Rx won't even work (tested on HW) - state = readRegister(SX126X_REG_WHITENING_INITIAL_MSB, data, 1); + state = readRegister(RADIOLIB_SX126X_REG_WHITENING_INITIAL_MSB, data, 1); RADIOLIB_ASSERT(state); data[0] = (data[0] & 0xFE) | (uint8_t)((initial >> 8) & 0x01); data[1] = (uint8_t)(initial & 0xFF); - state = writeRegister(SX126X_REG_WHITENING_INITIAL_MSB, data, 2); + state = writeRegister(RADIOLIB_SX126X_REG_WHITENING_INITIAL_MSB, data, 2); RADIOLIB_ASSERT(state); state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, _whitening, _packetType); @@ -1092,8 +1096,8 @@ float SX126x::getRSSI() { float SX126x::getSNR() { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } // get last packet SNR from packet status @@ -1109,22 +1113,22 @@ float SX126x::getSNR() { size_t SX126x::getPacketLength(bool update) { (void)update; uint8_t rxBufStatus[2] = {0, 0}; - SPIreadCommand(SX126X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2); return((size_t)rxBufStatus[0]); } int16_t SX126x::fixedPacketLengthMode(uint8_t len) { - return(setPacketMode(SX126X_GFSK_PACKET_FIXED, len)); + return(setPacketMode(RADIOLIB_SX126X_GFSK_PACKET_FIXED, len)); } int16_t SX126x::variablePacketLengthMode(uint8_t maxLen) { - return(setPacketMode(SX126X_GFSK_PACKET_VARIABLE, maxLen)); + return(setPacketMode(RADIOLIB_SX126X_GFSK_PACKET_VARIABLE, maxLen)); } uint32_t SX126x::getTimeOnAir(size_t len) { // everything is in microseconds to allow integer arithmetic // some constants have .25, these are multiplied by 4, and have _x4 postfix to indicate that fact - if(getPacketType() == SX126X_PACKET_TYPE_LORA) { + if(getPacketType() == RADIOLIB_SX126X_PACKET_TYPE_LORA) { uint32_t symbolLength_us = ((uint32_t)(1000 * 10) << _sf) / (_bwKhz * 10) ; uint8_t sfCoeff1_x4 = 17; // (4.25 * 4) uint8_t sfCoeff2 = 8; @@ -1137,7 +1141,7 @@ uint32_t SX126x::getTimeOnAir(size_t len) { sfDivisor = 4*(_sf - 2); } const int8_t bitsPerCrc = 16; - const int8_t N_symbol_header = _headerType == SX126X_LORA_HEADER_EXPLICIT ? 20 : 0; + const int8_t N_symbol_header = _headerType == RADIOLIB_SX126X_LORA_HEADER_EXPLICIT ? 20 : 0; // numerator of equation in section 6.1.4 of SX1268 datasheet v1.1 (might not actually be bitcount, but it has len * 8) int16_t bitCount = (int16_t) 8 * len + _crcType * bitsPerCrc - 4 * _sf + sfCoeff2 + N_symbol_header; @@ -1152,31 +1156,31 @@ uint32_t SX126x::getTimeOnAir(size_t len) { return((symbolLength_us * nSymbol_x4) / 4); } else { - return((len * 8 * _br) / (SX126X_CRYSTAL_FREQ * 32)); + return((len * 8 * _br) / (RADIOLIB_SX126X_CRYSTAL_FREQ * 32)); } } float SX126x::getRSSIInst() { uint8_t data[3] = {0, 0, 0}; // RssiInst, Status, RFU - SPIreadCommand(SX126X_CMD_GET_RSSI_INST, data, 3); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_RSSI_INST, data, 3); return (float)data[0] / (-2.0); } int16_t SX126x::implicitHeader(size_t len) { - return(setHeaderType(SX126X_LORA_HEADER_IMPLICIT, len)); + return(setHeaderType(RADIOLIB_SX126X_LORA_HEADER_IMPLICIT, len)); } int16_t SX126x::explicitHeader() { - return(setHeaderType(SX126X_LORA_HEADER_EXPLICIT)); + return(setHeaderType(RADIOLIB_SX126X_LORA_HEADER_EXPLICIT)); } int16_t SX126x::setRegulatorLDO() { - return(setRegulatorMode(SX126X_REGULATOR_LDO)); + return(setRegulatorMode(RADIOLIB_SX126X_REGULATOR_LDO)); } int16_t SX126x::setRegulatorDCDC() { - return(setRegulatorMode(SX126X_REGULATOR_DC_DC)); + return(setRegulatorMode(RADIOLIB_SX126X_REGULATOR_DC_DC)); } int16_t SX126x::setEncoding(uint8_t encoding) { @@ -1189,8 +1193,8 @@ void SX126x::setRfSwitchPins(RADIOLIB_PIN_TYPE rxEn, RADIOLIB_PIN_TYPE txEn) { int16_t SX126x::forceLDRO(bool enable) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } // update modulation parameters @@ -1200,26 +1204,26 @@ int16_t SX126x::forceLDRO(bool enable) { } int16_t SX126x::autoLDRO() { - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } _ldroAuto = true; - return(ERR_NONE); + return(RADIOLIB_ERR_NONE); } uint8_t SX126x::randomByte() { // set mode to Rx - setRx(SX126X_RX_TIMEOUT_INF); + setRx(RADIOLIB_SX126X_RX_TIMEOUT_INF); // wait a bit for the RSSI reading to stabilise - Module::delay(10); + _mod->delay(10); // read RSSI value 8 times, always keep just the least significant bit uint8_t randByte = 0x00; for(uint8_t i = 0; i < 8; i++) { uint8_t val = 0x00; - readRegister(SX126X_REG_RANDOM_NUMBER_0, &val, sizeof(uint8_t)); + readRegister(RADIOLIB_SX126X_REG_RANDOM_NUMBER_0, &val, sizeof(uint8_t)); randByte |= ((val & 0x01) << i); } @@ -1245,8 +1249,8 @@ int16_t SX126x::setTCXO(float voltage, uint32_t delay) { // set mode to standby standby(); - // check SX126X_XOSC_START_ERR flag and clear it - if(getDeviceErrors() & SX126X_XOSC_START_ERR) { + // check RADIOLIB_SX126X_XOSC_START_ERR flag and clear it + if(getDeviceErrors() & RADIOLIB_SX126X_XOSC_START_ERR) { clearDeviceErrors(); } @@ -1258,23 +1262,23 @@ int16_t SX126x::setTCXO(float voltage, uint32_t delay) { // check alowed voltage values uint8_t data[4]; if(fabs(voltage - 1.6) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_1_6; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_1_6; } else if(fabs(voltage - 1.7) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_1_7; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_1_7; } else if(fabs(voltage - 1.8) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_1_8; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_1_8; } else if(fabs(voltage - 2.2) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_2_2; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_2_2; } else if(fabs(voltage - 2.4) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_2_4; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_2_4; } else if(fabs(voltage - 2.7) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_2_7; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_2_7; } else if(fabs(voltage - 3.0) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_3_0; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_3_0; } else if(fabs(voltage - 3.3) <= 0.001) { - data[0] = SX126X_DIO3_OUTPUT_3_3; + data[0] = RADIOLIB_SX126X_DIO3_OUTPUT_3_3; } else { - return(ERR_INVALID_TCXO_VOLTAGE); + return(RADIOLIB_ERR_INVALID_TCXO_VOLTAGE); } // calculate delay @@ -1286,55 +1290,55 @@ int16_t SX126x::setTCXO(float voltage, uint32_t delay) { _tcxoDelay = delay; // enable TCXO control on DIO3 - return(SPIwriteCommand(SX126X_CMD_SET_DIO3_AS_TCXO_CTRL, data, 4)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_DIO3_AS_TCXO_CTRL, data, 4)); } int16_t SX126x::setDio2AsRfSwitch(bool enable) { uint8_t data = 0; if(enable) { - data = SX126X_DIO2_AS_RF_SWITCH; + data = RADIOLIB_SX126X_DIO2_AS_RF_SWITCH; } else { - data = SX126X_DIO2_AS_IRQ; + data = RADIOLIB_SX126X_DIO2_AS_IRQ; } - return(SPIwriteCommand(SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, &data, 1)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, &data, 1)); } int16_t SX126x::setTx(uint32_t timeout) { uint8_t data[] = { (uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF)} ; - return(SPIwriteCommand(SX126X_CMD_SET_TX, data, 3)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_TX, data, 3)); } int16_t SX126x::setRx(uint32_t timeout) { uint8_t data[] = { (uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF) }; - return(SPIwriteCommand(SX126X_CMD_SET_RX, data, 3)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RX, data, 3)); } int16_t SX126x::setCad() { - return(SPIwriteCommand(SX126X_CMD_SET_CAD, NULL, 0)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_CAD, NULL, 0)); } int16_t SX126x::setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax, uint8_t paLut) { uint8_t data[] = { paDutyCycle, hpMax, deviceSel, paLut }; - return(SPIwriteCommand(SX126X_CMD_SET_PA_CONFIG, data, 4)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PA_CONFIG, data, 4)); } int16_t SX126x::writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) { - uint8_t cmd[] = { SX126X_CMD_WRITE_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) }; + uint8_t cmd[] = { RADIOLIB_SX126X_CMD_WRITE_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) }; return(SPIwriteCommand(cmd, 3, data, numBytes)); } int16_t SX126x::readRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) { - uint8_t cmd[] = { SX126X_CMD_READ_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) }; + uint8_t cmd[] = { RADIOLIB_SX126X_CMD_READ_REGISTER, (uint8_t)((addr >> 8) & 0xFF), (uint8_t)(addr & 0xFF) }; return(SX126x::SPItransfer(cmd, 3, false, NULL, data, numBytes, true)); } int16_t SX126x::writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset) { - uint8_t cmd[] = { SX126X_CMD_WRITE_BUFFER, offset }; + uint8_t cmd[] = { RADIOLIB_SX126X_CMD_WRITE_BUFFER, offset }; return(SPIwriteCommand(cmd, 2, data, numBytes)); } int16_t SX126x::readBuffer(uint8_t* data, uint8_t numBytes) { - uint8_t cmd[] = { SX126X_CMD_READ_BUFFER, SX126X_CMD_NOP }; + uint8_t cmd[] = { RADIOLIB_SX126X_CMD_READ_BUFFER, RADIOLIB_SX126X_CMD_NOP }; return(SPIreadCommand(cmd, 2, data, numBytes)); } @@ -1343,44 +1347,44 @@ int16_t SX126x::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(SX126X_CMD_SET_DIO_IRQ_PARAMS, data, 8)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_DIO_IRQ_PARAMS, data, 8)); } uint16_t SX126x::getIrqStatus() { uint8_t data[] = { 0x00, 0x00 }; - SPIreadCommand(SX126X_CMD_GET_IRQ_STATUS, data, 2); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_IRQ_STATUS, data, 2); return(((uint16_t)(data[0]) << 8) | data[1]); } int16_t SX126x::clearIrqStatus(uint16_t clearIrqParams) { uint8_t data[] = { (uint8_t)((clearIrqParams >> 8) & 0xFF), (uint8_t)(clearIrqParams & 0xFF) }; - return(SPIwriteCommand(SX126X_CMD_CLEAR_IRQ_STATUS, data, 2)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_CLEAR_IRQ_STATUS, data, 2)); } int16_t SX126x::setRfFrequency(uint32_t frf) { uint8_t data[] = { (uint8_t)((frf >> 24) & 0xFF), (uint8_t)((frf >> 16) & 0xFF), (uint8_t)((frf >> 8) & 0xFF), (uint8_t)(frf & 0xFF) }; - return(SPIwriteCommand(SX126X_CMD_SET_RF_FREQUENCY, data, 4)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RF_FREQUENCY, data, 4)); } int16_t SX126x::calibrateImage(uint8_t* data) { - return(SPIwriteCommand(SX126X_CMD_CALIBRATE_IMAGE, data, 2)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_CALIBRATE_IMAGE, data, 2)); } uint8_t SX126x::getPacketType() { uint8_t data = 0xFF; - SPIreadCommand(SX126X_CMD_GET_PACKET_TYPE, &data, 1); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_PACKET_TYPE, &data, 1); return(data); } int16_t SX126x::setTxParams(uint8_t power, uint8_t rampTime) { uint8_t data[] = { power, rampTime }; - return(SPIwriteCommand(SX126X_CMD_SET_TX_PARAMS, data, 2)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_TX_PARAMS, data, 2)); } int16_t SX126x::setPacketMode(uint8_t mode, uint8_t len) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_GFSK) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_GFSK) { + return(RADIOLIB_ERR_WRONG_MODEM); } // set requested packet mode @@ -1394,8 +1398,8 @@ int16_t SX126x::setPacketMode(uint8_t mode, uint8_t len) { int16_t SX126x::setHeaderType(uint8_t headerType, size_t len) { // check active modem - if(getPacketType() != SX126X_PACKET_TYPE_LORA) { - return(ERR_WRONG_MODEM); + if(getPacketType() != RADIOLIB_SX126X_PACKET_TYPE_LORA) { + return(RADIOLIB_ERR_WRONG_MODEM); } // set requested packet mode @@ -1417,76 +1421,76 @@ int16_t SX126x::setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t RADIOLIB_DEBUG_PRINT(symbolLength); RADIOLIB_DEBUG_PRINTLN(" ms"); if(symbolLength >= 16.0) { - _ldro = SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_ON; + _ldro = RADIOLIB_SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_ON; } else { - _ldro = SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_OFF; + _ldro = RADIOLIB_SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_OFF; } } else { _ldro = ldro; } uint8_t data[4] = {sf, bw, cr, _ldro}; - return(SPIwriteCommand(SX126X_CMD_SET_MODULATION_PARAMS, data, 4)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS, data, 4)); } int16_t SX126x::setModulationParamsFSK(uint32_t br, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev) { uint8_t data[8] = {(uint8_t)((br >> 16) & 0xFF), (uint8_t)((br >> 8) & 0xFF), (uint8_t)(br & 0xFF), pulseShape, rxBw, (uint8_t)((freqDev >> 16) & 0xFF), (uint8_t)((freqDev >> 8) & 0xFF), (uint8_t)(freqDev & 0xFF)}; - return(SPIwriteCommand(SX126X_CMD_SET_MODULATION_PARAMS, data, 8)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS, data, 8)); } int16_t SX126x::setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength, uint8_t headerType, uint8_t invertIQ) { int16_t state = fixInvertedIQ(invertIQ); RADIOLIB_ASSERT(state); uint8_t data[6] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF), headerType, payloadLength, crcType, invertIQ}; - return(SPIwriteCommand(SX126X_CMD_SET_PACKET_PARAMS, data, 6)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS, data, 6)); } int16_t SX126x::setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t whitening, uint8_t packetType, uint8_t payloadLength, uint8_t preambleDetectorLength) { uint8_t data[9] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF), preambleDetectorLength, syncWordLength, addrComp, packetType, payloadLength, crcType, whitening}; - return(SPIwriteCommand(SX126X_CMD_SET_PACKET_PARAMS, data, 9)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS, data, 9)); } int16_t SX126x::setBufferBaseAddress(uint8_t txBaseAddress, uint8_t rxBaseAddress) { uint8_t data[2] = {txBaseAddress, rxBaseAddress}; - return(SPIwriteCommand(SX126X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2)); } int16_t SX126x::setRegulatorMode(uint8_t mode) { uint8_t data[1] = {mode}; - return(SPIwriteCommand(SX126X_CMD_SET_REGULATOR_MODE, data, 1)); + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_REGULATOR_MODE, data, 1)); } uint8_t SX126x::getStatus() { uint8_t data = 0; - SPIreadCommand(SX126X_CMD_GET_STATUS, &data, 1); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_STATUS, &data, 1); return(data); } uint32_t SX126x::getPacketStatus() { uint8_t data[3] = {0, 0, 0}; - SPIreadCommand(SX126X_CMD_GET_PACKET_STATUS, data, 3); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_PACKET_STATUS, data, 3); return((((uint32_t)data[0]) << 16) | (((uint32_t)data[1]) << 8) | (uint32_t)data[2]); } uint16_t SX126x::getDeviceErrors() { uint8_t data[2] = {0, 0}; - SPIreadCommand(SX126X_CMD_GET_DEVICE_ERRORS, data, 2); + SPIreadCommand(RADIOLIB_SX126X_CMD_GET_DEVICE_ERRORS, data, 2); uint16_t opError = (((uint16_t)data[0] & 0xFF) << 8) & ((uint16_t)data[1]); return(opError); } int16_t SX126x::clearDeviceErrors() { - uint8_t data[2] = {SX126X_CMD_NOP, SX126X_CMD_NOP}; - return(SPIwriteCommand(SX126X_CMD_CLEAR_DEVICE_ERRORS, data, 2)); + uint8_t data[2] = {RADIOLIB_SX126X_CMD_NOP, RADIOLIB_SX126X_CMD_NOP}; + return(SPIwriteCommand(RADIOLIB_SX126X_CMD_CLEAR_DEVICE_ERRORS, data, 2)); } int16_t SX126x::setFrequencyRaw(float freq) { // calculate raw value - uint32_t frf = (freq * (uint32_t(1) << SX126X_DIV_EXPONENT)) / SX126X_CRYSTAL_FREQ; + uint32_t frf = (freq * (uint32_t(1) << RADIOLIB_SX126X_DIV_EXPONENT)) / RADIOLIB_SX126X_CRYSTAL_FREQ; return(setRfFrequency(frf)); } @@ -1496,16 +1500,16 @@ int16_t SX126x::fixSensitivity() { // read current sensitivity configuration uint8_t sensitivityConfig = 0; - int16_t state = readRegister(SX126X_REG_SENSITIVITY_CONFIG, &sensitivityConfig, 1); + int16_t state = readRegister(RADIOLIB_SX126X_REG_SENSITIVITY_CONFIG, &sensitivityConfig, 1); RADIOLIB_ASSERT(state); // fix the value for LoRa with 500 kHz bandwidth - if((getPacketType() == SX126X_PACKET_TYPE_LORA) && (fabs(_bwKhz - 500.0) <= 0.001)) { + if((getPacketType() == RADIOLIB_SX126X_PACKET_TYPE_LORA) && (fabs(_bwKhz - 500.0) <= 0.001)) { sensitivityConfig &= 0xFB; } else { sensitivityConfig |= 0x04; } - return(writeRegister(SX126X_REG_SENSITIVITY_CONFIG, &sensitivityConfig, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_SENSITIVITY_CONFIG, &sensitivityConfig, 1)); } int16_t SX126x::fixPaClamping() { @@ -1514,12 +1518,12 @@ int16_t SX126x::fixPaClamping() { // read current clamping configuration uint8_t clampConfig = 0; - int16_t state = readRegister(SX126X_REG_TX_CLAMP_CONFIG, &clampConfig, 1); + int16_t state = readRegister(RADIOLIB_SX126X_REG_TX_CLAMP_CONFIG, &clampConfig, 1); RADIOLIB_ASSERT(state); // update with the new value clampConfig |= 0x1E; - return(writeRegister(SX126X_REG_TX_CLAMP_CONFIG, &clampConfig, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_TX_CLAMP_CONFIG, &clampConfig, 1)); } int16_t SX126x::fixImplicitTimeout() { @@ -1527,23 +1531,23 @@ int16_t SX126x::fixImplicitTimeout() { // see SX1262/SX1268 datasheet, chapter 15 Known Limitations, section 15.3 for details //check if we're in implicit LoRa mode - if(!((_headerType == SX126X_LORA_HEADER_IMPLICIT) && (getPacketType() == SX126X_PACKET_TYPE_LORA))) { - return(ERR_WRONG_MODEM); + if(!((_headerType == RADIOLIB_SX126X_LORA_HEADER_IMPLICIT) && (getPacketType() == RADIOLIB_SX126X_PACKET_TYPE_LORA))) { + return(RADIOLIB_ERR_WRONG_MODEM); } // stop RTC counter uint8_t rtcStop = 0x00; - int16_t state = writeRegister(SX126X_REG_RTC_STOP, &rtcStop, 1); + int16_t state = writeRegister(RADIOLIB_SX126X_REG_RTC_STOP, &rtcStop, 1); RADIOLIB_ASSERT(state); // read currently active event uint8_t rtcEvent = 0; - state = readRegister(SX126X_REG_RTC_EVENT, &rtcEvent, 1); + state = readRegister(RADIOLIB_SX126X_REG_RTC_EVENT, &rtcEvent, 1); RADIOLIB_ASSERT(state); // clear events rtcEvent |= 0x02; - return(writeRegister(SX126X_REG_RTC_EVENT, &rtcEvent, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_RTC_EVENT, &rtcEvent, 1)); } int16_t SX126x::fixInvertedIQ(uint8_t iqConfig) { @@ -1552,18 +1556,18 @@ int16_t SX126x::fixInvertedIQ(uint8_t iqConfig) { // read current IQ configuration uint8_t iqConfigCurrent = 0; - int16_t state = readRegister(SX126X_REG_IQ_CONFIG, &iqConfigCurrent, 1); + int16_t state = readRegister(RADIOLIB_SX126X_REG_IQ_CONFIG, &iqConfigCurrent, 1); RADIOLIB_ASSERT(state); // set correct IQ configuration - if(iqConfig == SX126X_LORA_IQ_STANDARD) { + if(iqConfig == RADIOLIB_SX126X_LORA_IQ_STANDARD) { iqConfigCurrent &= 0xFB; } else { iqConfigCurrent |= 0x04; } // update with the new value - return(writeRegister(SX126X_REG_IQ_CONFIG, &iqConfigCurrent, 1)); + return(writeRegister(RADIOLIB_SX126X_REG_IQ_CONFIG, &iqConfigCurrent, 1)); } int16_t SX126x::config(uint8_t modem) { @@ -1574,42 +1578,42 @@ int16_t SX126x::config(uint8_t modem) { // set modem uint8_t data[7]; data[0] = modem; - state = SPIwriteCommand(SX126X_CMD_SET_PACKET_TYPE, data, 1); + state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PACKET_TYPE, data, 1); RADIOLIB_ASSERT(state); // set Rx/Tx fallback mode to STDBY_RC - data[0] = SX126X_RX_TX_FALLBACK_MODE_STDBY_RC; - state = SPIwriteCommand(SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1); + data[0] = RADIOLIB_SX126X_RX_TX_FALLBACK_MODE_STDBY_RC; + state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1); RADIOLIB_ASSERT(state); // set CAD parameters - data[0] = SX126X_CAD_ON_8_SYMB; + data[0] = RADIOLIB_SX126X_CAD_ON_8_SYMB; data[1] = _sf + 13; data[2] = 10; - data[3] = SX126X_CAD_GOTO_STDBY; + data[3] = RADIOLIB_SX126X_CAD_GOTO_STDBY; data[4] = 0x00; data[5] = 0x00; data[6] = 0x00; - state = SPIwriteCommand(SX126X_CMD_SET_CAD_PARAMS, data, 7); + state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_CAD_PARAMS, data, 7); RADIOLIB_ASSERT(state); // clear IRQ state = clearIrqStatus(); - state |= setDioIrqParams(SX126X_IRQ_NONE, SX126X_IRQ_NONE); + state |= setDioIrqParams(RADIOLIB_SX126X_IRQ_NONE, RADIOLIB_SX126X_IRQ_NONE); RADIOLIB_ASSERT(state); // calibrate all blocks - data[0] = SX126X_CALIBRATE_ALL; - state = SPIwriteCommand(SX126X_CMD_CALIBRATE, data, 1); + data[0] = RADIOLIB_SX126X_CALIBRATE_ALL; + state = SPIwriteCommand(RADIOLIB_SX126X_CMD_CALIBRATE, data, 1); RADIOLIB_ASSERT(state); // wait for calibration completion - Module::delay(5); - while(Module::digitalRead(_mod->getGpio())) { - Module::yield(); + _mod->delay(5); + while(_mod->digitalRead(_mod->getGpio())) { + _mod->yield(); } - return(ERR_NONE); + return(RADIOLIB_ERR_NONE); } int16_t SX126x::SPIwriteCommand(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, uint8_t numBytes, bool waitForBusy) { @@ -1629,33 +1633,29 @@ int16_t SX126x::SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, boo } int16_t SX126x::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 // pull NSS low - Module::digitalWrite(_mod->getCs(), LOW); + _mod->digitalWrite(_mod->getCs(), LOW); // 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); } } // 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 @@ -1665,63 +1665,63 @@ int16_t SX126x::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 & 0b00001110) == SX126X_STATUS_CMD_TIMEOUT) || - ((in & 0b00001110) == SX126X_STATUS_CMD_INVALID) || - ((in & 0b00001110) == SX126X_STATUS_CMD_FAILED)) { + if(((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_TIMEOUT) || + ((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_INVALID) || + ((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_FAILED)) { status = in & 0b00001110; break; } else if(in == 0x00 || in == 0xFF) { - status = SX126X_STATUS_SPI_FAILED; + status = RADIOLIB_SX126X_STATUS_SPI_FAILED; break; } } } else { // skip the first byte for read-type commands (status-only) - uint8_t in = spi->transfer(SX126X_CMD_NOP); - #ifdef RADIOLIB_VERBOSE + uint8_t in = _mod->SPItransfer(RADIOLIB_SX126X_CMD_NOP); + #if defined(RADIOLIB_VERBOSE) debugBuff[0] = in; #endif // check status - if(((in & 0b00001110) == SX126X_STATUS_CMD_TIMEOUT) || - ((in & 0b00001110) == SX126X_STATUS_CMD_INVALID) || - ((in & 0b00001110) == SX126X_STATUS_CMD_FAILED)) { + if(((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_TIMEOUT) || + ((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_INVALID) || + ((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_FAILED)) { status = in & 0b00001110; } else if(in == 0x00 || in == 0xFF) { - status = SX126X_STATUS_SPI_FAILED; + status = RADIOLIB_SX126X_STATUS_SPI_FAILED; } else { for(uint8_t n = 0; n < numBytes; n++) { - dataIn[n] = spi->transfer(SX126X_CMD_NOP); + dataIn[n] = _mod->SPItransfer(RADIOLIB_SX126X_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 = SX126X_STATUS_CMD_TIMEOUT; + _mod->delayMicroseconds(1); + start = _mod->millis(); + while(_mod->digitalRead(_mod->getGpio())) { + _mod->yield(); + if(_mod->millis() - start >= timeout) { + status = RADIOLIB_SX126X_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++) { @@ -1744,13 +1744,13 @@ int16_t SX126x::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(SX126X_CMD_NOP, HEX); + RADIOLIB_VERBOSE_PRINT(RADIOLIB_SX126X_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(SX126X_CMD_NOP, HEX); + RADIOLIB_VERBOSE_PRINT(RADIOLIB_SX126X_CMD_NOP, HEX); RADIOLIB_VERBOSE_PRINT('\t'); RADIOLIB_VERBOSE_PRINT(dataIn[n], HEX); RADIOLIB_VERBOSE_PRINT('\t'); @@ -1763,22 +1763,22 @@ int16_t SX126x::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 SX126X_STATUS_CMD_TIMEOUT: - return(ERR_SPI_CMD_TIMEOUT); - case SX126X_STATUS_CMD_INVALID: - return(ERR_SPI_CMD_INVALID); - case SX126X_STATUS_CMD_FAILED: - return(ERR_SPI_CMD_FAILED); - case SX126X_STATUS_SPI_FAILED: - return(ERR_CHIP_NOT_FOUND); + case RADIOLIB_SX126X_STATUS_CMD_TIMEOUT: + return(RADIOLIB_ERR_SPI_CMD_TIMEOUT); + case RADIOLIB_SX126X_STATUS_CMD_INVALID: + return(RADIOLIB_ERR_SPI_CMD_INVALID); + case RADIOLIB_SX126X_STATUS_CMD_FAILED: + return(RADIOLIB_ERR_SPI_CMD_FAILED); + case RADIOLIB_SX126X_STATUS_SPI_FAILED: + return(RADIOLIB_ERR_CHIP_NOT_FOUND); default: - return(ERR_NONE); + return(RADIOLIB_ERR_NONE); } } diff --git a/src/modules/SX126x/SX126x.h b/src/modules/SX126x/SX126x.h index 97fb05fe..79564f2f 100644 --- a/src/modules/SX126x/SX126x.h +++ b/src/modules/SX126x/SX126x.h @@ -10,327 +10,327 @@ #include "../../protocols/PhysicalLayer/PhysicalLayer.h" // SX126X physical layer properties -#define SX126X_FREQUENCY_STEP_SIZE 0.9536743164 -#define SX126X_MAX_PACKET_LENGTH 255 -#define SX126X_CRYSTAL_FREQ 32.0 -#define SX126X_DIV_EXPONENT 25 +#define RADIOLIB_SX126X_FREQUENCY_STEP_SIZE 0.9536743164 +#define RADIOLIB_SX126X_MAX_PACKET_LENGTH 255 +#define RADIOLIB_SX126X_CRYSTAL_FREQ 32.0 +#define RADIOLIB_SX126X_DIV_EXPONENT 25 // SX126X SPI commands // operational modes commands -#define SX126X_CMD_NOP 0x00 -#define SX126X_CMD_SET_SLEEP 0x84 -#define SX126X_CMD_SET_STANDBY 0x80 -#define SX126X_CMD_SET_FS 0xC1 -#define SX126X_CMD_SET_TX 0x83 -#define SX126X_CMD_SET_RX 0x82 -#define SX126X_CMD_STOP_TIMER_ON_PREAMBLE 0x9F -#define SX126X_CMD_SET_RX_DUTY_CYCLE 0x94 -#define SX126X_CMD_SET_CAD 0xC5 -#define SX126X_CMD_SET_TX_CONTINUOUS_WAVE 0xD1 -#define SX126X_CMD_SET_TX_INFINITE_PREAMBLE 0xD2 -#define SX126X_CMD_SET_REGULATOR_MODE 0x96 -#define SX126X_CMD_CALIBRATE 0x89 -#define SX126X_CMD_CALIBRATE_IMAGE 0x98 -#define SX126X_CMD_SET_PA_CONFIG 0x95 -#define SX126X_CMD_SET_RX_TX_FALLBACK_MODE 0x93 +#define RADIOLIB_SX126X_CMD_NOP 0x00 +#define RADIOLIB_SX126X_CMD_SET_SLEEP 0x84 +#define RADIOLIB_SX126X_CMD_SET_STANDBY 0x80 +#define RADIOLIB_SX126X_CMD_SET_FS 0xC1 +#define RADIOLIB_SX126X_CMD_SET_TX 0x83 +#define RADIOLIB_SX126X_CMD_SET_RX 0x82 +#define RADIOLIB_SX126X_CMD_STOP_TIMER_ON_PREAMBLE 0x9F +#define RADIOLIB_SX126X_CMD_SET_RX_DUTY_CYCLE 0x94 +#define RADIOLIB_SX126X_CMD_SET_CAD 0xC5 +#define RADIOLIB_SX126X_CMD_SET_TX_CONTINUOUS_WAVE 0xD1 +#define RADIOLIB_SX126X_CMD_SET_TX_INFINITE_PREAMBLE 0xD2 +#define RADIOLIB_SX126X_CMD_SET_REGULATOR_MODE 0x96 +#define RADIOLIB_SX126X_CMD_CALIBRATE 0x89 +#define RADIOLIB_SX126X_CMD_CALIBRATE_IMAGE 0x98 +#define RADIOLIB_SX126X_CMD_SET_PA_CONFIG 0x95 +#define RADIOLIB_SX126X_CMD_SET_RX_TX_FALLBACK_MODE 0x93 // register and buffer access commands -#define SX126X_CMD_WRITE_REGISTER 0x0D -#define SX126X_CMD_READ_REGISTER 0x1D -#define SX126X_CMD_WRITE_BUFFER 0x0E -#define SX126X_CMD_READ_BUFFER 0x1E +#define RADIOLIB_SX126X_CMD_WRITE_REGISTER 0x0D +#define RADIOLIB_SX126X_CMD_READ_REGISTER 0x1D +#define RADIOLIB_SX126X_CMD_WRITE_BUFFER 0x0E +#define RADIOLIB_SX126X_CMD_READ_BUFFER 0x1E // DIO and IRQ control -#define SX126X_CMD_SET_DIO_IRQ_PARAMS 0x08 -#define SX126X_CMD_GET_IRQ_STATUS 0x12 -#define SX126X_CMD_CLEAR_IRQ_STATUS 0x02 -#define SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL 0x9D -#define SX126X_CMD_SET_DIO3_AS_TCXO_CTRL 0x97 +#define RADIOLIB_SX126X_CMD_SET_DIO_IRQ_PARAMS 0x08 +#define RADIOLIB_SX126X_CMD_GET_IRQ_STATUS 0x12 +#define RADIOLIB_SX126X_CMD_CLEAR_IRQ_STATUS 0x02 +#define RADIOLIB_SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL 0x9D +#define RADIOLIB_SX126X_CMD_SET_DIO3_AS_TCXO_CTRL 0x97 // RF, modulation and packet commands -#define SX126X_CMD_SET_RF_FREQUENCY 0x86 -#define SX126X_CMD_SET_PACKET_TYPE 0x8A -#define SX126X_CMD_GET_PACKET_TYPE 0x11 -#define SX126X_CMD_SET_TX_PARAMS 0x8E -#define SX126X_CMD_SET_MODULATION_PARAMS 0x8B -#define SX126X_CMD_SET_PACKET_PARAMS 0x8C -#define SX126X_CMD_SET_CAD_PARAMS 0x88 -#define SX126X_CMD_SET_BUFFER_BASE_ADDRESS 0x8F -#define SX126X_CMD_SET_LORA_SYMB_NUM_TIMEOUT 0x0A +#define RADIOLIB_SX126X_CMD_SET_RF_FREQUENCY 0x86 +#define RADIOLIB_SX126X_CMD_SET_PACKET_TYPE 0x8A +#define RADIOLIB_SX126X_CMD_GET_PACKET_TYPE 0x11 +#define RADIOLIB_SX126X_CMD_SET_TX_PARAMS 0x8E +#define RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS 0x8B +#define RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS 0x8C +#define RADIOLIB_SX126X_CMD_SET_CAD_PARAMS 0x88 +#define RADIOLIB_SX126X_CMD_SET_BUFFER_BASE_ADDRESS 0x8F +#define RADIOLIB_SX126X_CMD_SET_LORA_SYMB_NUM_TIMEOUT 0x0A // status commands -#define SX126X_CMD_GET_STATUS 0xC0 -#define SX126X_CMD_GET_RSSI_INST 0x15 -#define SX126X_CMD_GET_RX_BUFFER_STATUS 0x13 -#define SX126X_CMD_GET_PACKET_STATUS 0x14 -#define SX126X_CMD_GET_DEVICE_ERRORS 0x17 -#define SX126X_CMD_CLEAR_DEVICE_ERRORS 0x07 -#define SX126X_CMD_GET_STATS 0x10 -#define SX126X_CMD_RESET_STATS 0x00 +#define RADIOLIB_SX126X_CMD_GET_STATUS 0xC0 +#define RADIOLIB_SX126X_CMD_GET_RSSI_INST 0x15 +#define RADIOLIB_SX126X_CMD_GET_RX_BUFFER_STATUS 0x13 +#define RADIOLIB_SX126X_CMD_GET_PACKET_STATUS 0x14 +#define RADIOLIB_SX126X_CMD_GET_DEVICE_ERRORS 0x17 +#define RADIOLIB_SX126X_CMD_CLEAR_DEVICE_ERRORS 0x07 +#define RADIOLIB_SX126X_CMD_GET_STATS 0x10 +#define RADIOLIB_SX126X_CMD_RESET_STATS 0x00 // SX126X register map -#define SX126X_REG_WHITENING_INITIAL_MSB 0x06B8 -#define SX126X_REG_WHITENING_INITIAL_LSB 0x06B9 -#define SX126X_REG_CRC_INITIAL_MSB 0x06BC -#define SX126X_REG_CRC_INITIAL_LSB 0x06BD -#define SX126X_REG_CRC_POLYNOMIAL_MSB 0x06BE -#define SX126X_REG_CRC_POLYNOMIAL_LSB 0x06BF -#define SX126X_REG_SYNC_WORD_0 0x06C0 -#define SX126X_REG_SYNC_WORD_1 0x06C1 -#define SX126X_REG_SYNC_WORD_2 0x06C2 -#define SX126X_REG_SYNC_WORD_3 0x06C3 -#define SX126X_REG_SYNC_WORD_4 0x06C4 -#define SX126X_REG_SYNC_WORD_5 0x06C5 -#define SX126X_REG_SYNC_WORD_6 0x06C6 -#define SX126X_REG_SYNC_WORD_7 0x06C7 -#define SX126X_REG_NODE_ADDRESS 0x06CD -#define SX126X_REG_BROADCAST_ADDRESS 0x06CE -#define SX126X_REG_LORA_SYNC_WORD_MSB 0x0740 -#define SX126X_REG_LORA_SYNC_WORD_LSB 0x0741 -#define SX126X_REG_RANDOM_NUMBER_0 0x0819 -#define SX126X_REG_RANDOM_NUMBER_1 0x081A -#define SX126X_REG_RANDOM_NUMBER_2 0x081B -#define SX126X_REG_RANDOM_NUMBER_3 0x081C -#define SX126X_REG_RX_GAIN 0x08AC -#define SX126X_REG_OCP_CONFIGURATION 0x08E7 -#define SX126X_REG_XTA_TRIM 0x0911 -#define SX126X_REG_XTB_TRIM 0x0912 +#define RADIOLIB_SX126X_REG_WHITENING_INITIAL_MSB 0x06B8 +#define RADIOLIB_SX126X_REG_WHITENING_INITIAL_LSB 0x06B9 +#define RADIOLIB_SX126X_REG_CRC_INITIAL_MSB 0x06BC +#define RADIOLIB_SX126X_REG_CRC_INITIAL_LSB 0x06BD +#define RADIOLIB_SX126X_REG_CRC_POLYNOMIAL_MSB 0x06BE +#define RADIOLIB_SX126X_REG_CRC_POLYNOMIAL_LSB 0x06BF +#define RADIOLIB_SX126X_REG_SYNC_WORD_0 0x06C0 +#define RADIOLIB_SX126X_REG_SYNC_WORD_1 0x06C1 +#define RADIOLIB_SX126X_REG_SYNC_WORD_2 0x06C2 +#define RADIOLIB_SX126X_REG_SYNC_WORD_3 0x06C3 +#define RADIOLIB_SX126X_REG_SYNC_WORD_4 0x06C4 +#define RADIOLIB_SX126X_REG_SYNC_WORD_5 0x06C5 +#define RADIOLIB_SX126X_REG_SYNC_WORD_6 0x06C6 +#define RADIOLIB_SX126X_REG_SYNC_WORD_7 0x06C7 +#define RADIOLIB_SX126X_REG_NODE_ADDRESS 0x06CD +#define RADIOLIB_SX126X_REG_BROADCAST_ADDRESS 0x06CE +#define RADIOLIB_SX126X_REG_LORA_SYNC_WORD_MSB 0x0740 +#define RADIOLIB_SX126X_REG_LORA_SYNC_WORD_LSB 0x0741 +#define RADIOLIB_SX126X_REG_RANDOM_NUMBER_0 0x0819 +#define RADIOLIB_SX126X_REG_RANDOM_NUMBER_1 0x081A +#define RADIOLIB_SX126X_REG_RANDOM_NUMBER_2 0x081B +#define RADIOLIB_SX126X_REG_RANDOM_NUMBER_3 0x081C +#define RADIOLIB_SX126X_REG_RX_GAIN 0x08AC +#define RADIOLIB_SX126X_REG_OCP_CONFIGURATION 0x08E7 +#define RADIOLIB_SX126X_REG_XTA_TRIM 0x0911 +#define RADIOLIB_SX126X_REG_XTB_TRIM 0x0912 // undocumented registers -#define SX126X_REG_SENSITIVITY_CONFIG 0x0889 // SX1268 datasheet v1.1, section 15.1 -#define SX126X_REG_TX_CLAMP_CONFIG 0x08D8 // SX1268 datasheet v1.1, section 15.2 -#define SX126X_REG_RTC_STOP 0x0920 // SX1268 datasheet v1.1, section 15.3 -#define SX126X_REG_RTC_EVENT 0x0944 // SX1268 datasheet v1.1, section 15.3 -#define SX126X_REG_IQ_CONFIG 0x0736 // SX1268 datasheet v1.1, section 15.4 -#define SX126X_REG_RX_GAIN_RETENTION_0 0x029F // SX1268 datasheet v1.1, section 9.6 -#define SX126X_REG_RX_GAIN_RETENTION_1 0x02A0 // SX1268 datasheet v1.1, section 9.6 -#define SX126X_REG_RX_GAIN_RETENTION_2 0x02A1 // SX1268 datasheet v1.1, section 9.6 +#define RADIOLIB_SX126X_REG_SENSITIVITY_CONFIG 0x0889 // SX1268 datasheet v1.1, section 15.1 +#define RADIOLIB_SX126X_REG_TX_CLAMP_CONFIG 0x08D8 // SX1268 datasheet v1.1, section 15.2 +#define RADIOLIB_SX126X_REG_RTC_STOP 0x0920 // SX1268 datasheet v1.1, section 15.3 +#define RADIOLIB_SX126X_REG_RTC_EVENT 0x0944 // SX1268 datasheet v1.1, section 15.3 +#define RADIOLIB_SX126X_REG_IQ_CONFIG 0x0736 // SX1268 datasheet v1.1, section 15.4 +#define RADIOLIB_SX126X_REG_RX_GAIN_RETENTION_0 0x029F // SX1268 datasheet v1.1, section 9.6 +#define RADIOLIB_SX126X_REG_RX_GAIN_RETENTION_1 0x02A0 // SX1268 datasheet v1.1, section 9.6 +#define RADIOLIB_SX126X_REG_RX_GAIN_RETENTION_2 0x02A1 // SX1268 datasheet v1.1, section 9.6 // SX126X SPI command variables -//SX126X_CMD_SET_SLEEP MSB LSB DESCRIPTION -#define SX126X_SLEEP_START_COLD 0b00000000 // 2 2 sleep mode: cold start, configuration is lost (default) -#define SX126X_SLEEP_START_WARM 0b00000100 // 2 2 warm start, configuration is retained -#define SX126X_SLEEP_RTC_OFF 0b00000000 // 0 0 wake on RTC timeout: disabled -#define SX126X_SLEEP_RTC_ON 0b00000001 // 0 0 enabled +//RADIOLIB_SX126X_CMD_SET_SLEEP MSB LSB DESCRIPTION +#define RADIOLIB_SX126X_SLEEP_START_COLD 0b00000000 // 2 2 sleep mode: cold start, configuration is lost (default) +#define RADIOLIB_SX126X_SLEEP_START_WARM 0b00000100 // 2 2 warm start, configuration is retained +#define RADIOLIB_SX126X_SLEEP_RTC_OFF 0b00000000 // 0 0 wake on RTC timeout: disabled +#define RADIOLIB_SX126X_SLEEP_RTC_ON 0b00000001 // 0 0 enabled -//SX126X_CMD_SET_STANDBY -#define SX126X_STANDBY_RC 0x00 // 7 0 standby mode: 13 MHz RC oscillator -#define SX126X_STANDBY_XOSC 0x01 // 7 0 32 MHz crystal oscillator +//RADIOLIB_SX126X_CMD_SET_STANDBY +#define RADIOLIB_SX126X_STANDBY_RC 0x00 // 7 0 standby mode: 13 MHz RC oscillator +#define RADIOLIB_SX126X_STANDBY_XOSC 0x01 // 7 0 32 MHz crystal oscillator -//SX126X_CMD_SET_RX -#define SX126X_RX_TIMEOUT_NONE 0x000000 // 23 0 Rx timeout duration: no timeout (Rx single mode) -#define SX126X_RX_TIMEOUT_INF 0xFFFFFF // 23 0 infinite (Rx continuous mode) +//RADIOLIB_SX126X_CMD_SET_RX +#define RADIOLIB_SX126X_RX_TIMEOUT_NONE 0x000000 // 23 0 Rx timeout duration: no timeout (Rx single mode) +#define RADIOLIB_SX126X_RX_TIMEOUT_INF 0xFFFFFF // 23 0 infinite (Rx continuous mode) -//SX126X_CMD_SET_TX -#define SX126X_TX_TIMEOUT_NONE 0x000000 // 23 0 Tx timeout duration: no timeout (Tx single mode) +//RADIOLIB_SX126X_CMD_SET_TX +#define RADIOLIB_SX126X_TX_TIMEOUT_NONE 0x000000 // 23 0 Tx timeout duration: no timeout (Tx single mode) -//SX126X_CMD_STOP_TIMER_ON_PREAMBLE -#define SX126X_STOP_ON_PREAMBLE_OFF 0x00 // 7 0 stop timer on: sync word or header (default) -#define SX126X_STOP_ON_PREAMBLE_ON 0x01 // 7 0 preamble detection +//RADIOLIB_SX126X_CMD_STOP_TIMER_ON_PREAMBLE +#define RADIOLIB_SX126X_STOP_ON_PREAMBLE_OFF 0x00 // 7 0 stop timer on: sync word or header (default) +#define RADIOLIB_SX126X_STOP_ON_PREAMBLE_ON 0x01 // 7 0 preamble detection -//SX126X_CMD_SET_REGULATOR_MODE -#define SX126X_REGULATOR_LDO 0x00 // 7 0 set regulator mode: LDO (default) -#define SX126X_REGULATOR_DC_DC 0x01 // 7 0 DC-DC +//RADIOLIB_SX126X_CMD_SET_REGULATOR_MODE +#define RADIOLIB_SX126X_REGULATOR_LDO 0x00 // 7 0 set regulator mode: LDO (default) +#define RADIOLIB_SX126X_REGULATOR_DC_DC 0x01 // 7 0 DC-DC -//SX126X_CMD_CALIBRATE -#define SX126X_CALIBRATE_IMAGE_OFF 0b00000000 // 6 6 image calibration: disabled -#define SX126X_CALIBRATE_IMAGE_ON 0b01000000 // 6 6 enabled -#define SX126X_CALIBRATE_ADC_BULK_P_OFF 0b00000000 // 5 5 ADC bulk P calibration: disabled -#define SX126X_CALIBRATE_ADC_BULK_P_ON 0b00100000 // 5 5 enabled -#define SX126X_CALIBRATE_ADC_BULK_N_OFF 0b00000000 // 4 4 ADC bulk N calibration: disabled -#define SX126X_CALIBRATE_ADC_BULK_N_ON 0b00010000 // 4 4 enabled -#define SX126X_CALIBRATE_ADC_PULSE_OFF 0b00000000 // 3 3 ADC pulse calibration: disabled -#define SX126X_CALIBRATE_ADC_PULSE_ON 0b00001000 // 3 3 enabled -#define SX126X_CALIBRATE_PLL_OFF 0b00000000 // 2 2 PLL calibration: disabled -#define SX126X_CALIBRATE_PLL_ON 0b00000100 // 2 2 enabled -#define SX126X_CALIBRATE_RC13M_OFF 0b00000000 // 1 1 13 MHz RC osc. calibration: disabled -#define SX126X_CALIBRATE_RC13M_ON 0b00000010 // 1 1 enabled -#define SX126X_CALIBRATE_RC64K_OFF 0b00000000 // 0 0 64 kHz RC osc. calibration: disabled -#define SX126X_CALIBRATE_RC64K_ON 0b00000001 // 0 0 enabled -#define SX126X_CALIBRATE_ALL 0b01111111 // 6 0 calibrate all blocks +//RADIOLIB_SX126X_CMD_CALIBRATE +#define RADIOLIB_SX126X_CALIBRATE_IMAGE_OFF 0b00000000 // 6 6 image calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_IMAGE_ON 0b01000000 // 6 6 enabled +#define RADIOLIB_SX126X_CALIBRATE_ADC_BULK_P_OFF 0b00000000 // 5 5 ADC bulk P calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_ADC_BULK_P_ON 0b00100000 // 5 5 enabled +#define RADIOLIB_SX126X_CALIBRATE_ADC_BULK_N_OFF 0b00000000 // 4 4 ADC bulk N calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_ADC_BULK_N_ON 0b00010000 // 4 4 enabled +#define RADIOLIB_SX126X_CALIBRATE_ADC_PULSE_OFF 0b00000000 // 3 3 ADC pulse calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_ADC_PULSE_ON 0b00001000 // 3 3 enabled +#define RADIOLIB_SX126X_CALIBRATE_PLL_OFF 0b00000000 // 2 2 PLL calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_PLL_ON 0b00000100 // 2 2 enabled +#define RADIOLIB_SX126X_CALIBRATE_RC13M_OFF 0b00000000 // 1 1 13 MHz RC osc. calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_RC13M_ON 0b00000010 // 1 1 enabled +#define RADIOLIB_SX126X_CALIBRATE_RC64K_OFF 0b00000000 // 0 0 64 kHz RC osc. calibration: disabled +#define RADIOLIB_SX126X_CALIBRATE_RC64K_ON 0b00000001 // 0 0 enabled +#define RADIOLIB_SX126X_CALIBRATE_ALL 0b01111111 // 6 0 calibrate all blocks -//SX126X_CMD_CALIBRATE_IMAGE -#define SX126X_CAL_IMG_430_MHZ_1 0x6B -#define SX126X_CAL_IMG_430_MHZ_2 0x6F -#define SX126X_CAL_IMG_470_MHZ_1 0x75 -#define SX126X_CAL_IMG_470_MHZ_2 0x81 -#define SX126X_CAL_IMG_779_MHZ_1 0xC1 -#define SX126X_CAL_IMG_779_MHZ_2 0xC5 -#define SX126X_CAL_IMG_863_MHZ_1 0xD7 -#define SX126X_CAL_IMG_863_MHZ_2 0xDB -#define SX126X_CAL_IMG_902_MHZ_1 0xE1 -#define SX126X_CAL_IMG_902_MHZ_2 0xE9 +//RADIOLIB_SX126X_CMD_CALIBRATE_IMAGE +#define RADIOLIB_SX126X_CAL_IMG_430_MHZ_1 0x6B +#define RADIOLIB_SX126X_CAL_IMG_430_MHZ_2 0x6F +#define RADIOLIB_SX126X_CAL_IMG_470_MHZ_1 0x75 +#define RADIOLIB_SX126X_CAL_IMG_470_MHZ_2 0x81 +#define RADIOLIB_SX126X_CAL_IMG_779_MHZ_1 0xC1 +#define RADIOLIB_SX126X_CAL_IMG_779_MHZ_2 0xC5 +#define RADIOLIB_SX126X_CAL_IMG_863_MHZ_1 0xD7 +#define RADIOLIB_SX126X_CAL_IMG_863_MHZ_2 0xDB +#define RADIOLIB_SX126X_CAL_IMG_902_MHZ_1 0xE1 +#define RADIOLIB_SX126X_CAL_IMG_902_MHZ_2 0xE9 -//SX126X_CMD_SET_PA_CONFIG -#define SX126X_PA_CONFIG_HP_MAX 0x07 -#define SX126X_PA_CONFIG_PA_LUT 0x01 -#define SX126X_PA_CONFIG_SX1262_8 0x00 +//RADIOLIB_SX126X_CMD_SET_PA_CONFIG +#define RADIOLIB_SX126X_PA_CONFIG_HP_MAX 0x07 +#define RADIOLIB_SX126X_PA_CONFIG_PA_LUT 0x01 +#define RADIOLIB_SX126X_PA_CONFIG_SX1262_8 0x00 -//SX126X_CMD_SET_RX_TX_FALLBACK_MODE -#define SX126X_RX_TX_FALLBACK_MODE_FS 0x40 // 7 0 after Rx/Tx go to: FS mode -#define SX126X_RX_TX_FALLBACK_MODE_STDBY_XOSC 0x30 // 7 0 standby with crystal oscillator -#define SX126X_RX_TX_FALLBACK_MODE_STDBY_RC 0x20 // 7 0 standby with RC oscillator (default) +//RADIOLIB_SX126X_CMD_SET_RX_TX_FALLBACK_MODE +#define RADIOLIB_SX126X_RX_TX_FALLBACK_MODE_FS 0x40 // 7 0 after Rx/Tx go to: FS mode +#define RADIOLIB_SX126X_RX_TX_FALLBACK_MODE_STDBY_XOSC 0x30 // 7 0 standby with crystal oscillator +#define RADIOLIB_SX126X_RX_TX_FALLBACK_MODE_STDBY_RC 0x20 // 7 0 standby with RC oscillator (default) -//SX126X_CMD_SET_DIO_IRQ_PARAMS -#define SX126X_IRQ_TIMEOUT 0b1000000000 // 9 9 Rx or Tx timeout -#define SX126X_IRQ_CAD_DETECTED 0b0100000000 // 8 8 channel activity detected -#define SX126X_IRQ_CAD_DONE 0b0010000000 // 7 7 channel activity detection finished -#define SX126X_IRQ_CRC_ERR 0b0001000000 // 6 6 wrong CRC received -#define SX126X_IRQ_HEADER_ERR 0b0000100000 // 5 5 LoRa header CRC error -#define SX126X_IRQ_HEADER_VALID 0b0000010000 // 4 4 valid LoRa header received -#define SX126X_IRQ_SYNC_WORD_VALID 0b0000001000 // 3 3 valid sync word detected -#define SX126X_IRQ_PREAMBLE_DETECTED 0b0000000100 // 2 2 preamble detected -#define SX126X_IRQ_RX_DONE 0b0000000010 // 1 1 packet received -#define SX126X_IRQ_TX_DONE 0b0000000001 // 0 0 packet transmission completed -#define SX126X_IRQ_ALL 0b1111111111 // 9 0 all interrupts -#define SX126X_IRQ_NONE 0b0000000000 // 9 0 no interrupts +//RADIOLIB_SX126X_CMD_SET_DIO_IRQ_PARAMS +#define RADIOLIB_SX126X_IRQ_TIMEOUT 0b1000000000 // 9 9 Rx or Tx timeout +#define RADIOLIB_SX126X_IRQ_CAD_DETECTED 0b0100000000 // 8 8 channel activity detected +#define RADIOLIB_SX126X_IRQ_CAD_DONE 0b0010000000 // 7 7 channel activity detection finished +#define RADIOLIB_SX126X_IRQ_CRC_ERR 0b0001000000 // 6 6 wrong CRC received +#define RADIOLIB_SX126X_IRQ_HEADER_ERR 0b0000100000 // 5 5 LoRa header CRC error +#define RADIOLIB_SX126X_IRQ_HEADER_VALID 0b0000010000 // 4 4 valid LoRa header received +#define RADIOLIB_SX126X_IRQ_SYNC_WORD_VALID 0b0000001000 // 3 3 valid sync word detected +#define RADIOLIB_SX126X_IRQ_RADIOLIB_PREAMBLE_DETECTED 0b0000000100 // 2 2 preamble detected +#define RADIOLIB_SX126X_IRQ_RX_DONE 0b0000000010 // 1 1 packet received +#define RADIOLIB_SX126X_IRQ_TX_DONE 0b0000000001 // 0 0 packet transmission completed +#define RADIOLIB_SX126X_IRQ_ALL 0b1111111111 // 9 0 all interrupts +#define RADIOLIB_SX126X_IRQ_NONE 0b0000000000 // 9 0 no interrupts -//SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL -#define SX126X_DIO2_AS_IRQ 0x00 // 7 0 DIO2 configuration: IRQ -#define SX126X_DIO2_AS_RF_SWITCH 0x01 // 7 0 RF switch control +//RADIOLIB_SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL +#define RADIOLIB_SX126X_DIO2_AS_IRQ 0x00 // 7 0 DIO2 configuration: IRQ +#define RADIOLIB_SX126X_DIO2_AS_RF_SWITCH 0x01 // 7 0 RF switch control -//SX126X_CMD_SET_DIO3_AS_TCXO_CTRL -#define SX126X_DIO3_OUTPUT_1_6 0x00 // 7 0 DIO3 voltage output for TCXO: 1.6 V -#define SX126X_DIO3_OUTPUT_1_7 0x01 // 7 0 1.7 V -#define SX126X_DIO3_OUTPUT_1_8 0x02 // 7 0 1.8 V -#define SX126X_DIO3_OUTPUT_2_2 0x03 // 7 0 2.2 V -#define SX126X_DIO3_OUTPUT_2_4 0x04 // 7 0 2.4 V -#define SX126X_DIO3_OUTPUT_2_7 0x05 // 7 0 2.7 V -#define SX126X_DIO3_OUTPUT_3_0 0x06 // 7 0 3.0 V -#define SX126X_DIO3_OUTPUT_3_3 0x07 // 7 0 3.3 V +//RADIOLIB_SX126X_CMD_SET_DIO3_AS_TCXO_CTRL +#define RADIOLIB_SX126X_DIO3_OUTPUT_1_6 0x00 // 7 0 DIO3 voltage output for TCXO: 1.6 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_1_7 0x01 // 7 0 1.7 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_1_8 0x02 // 7 0 1.8 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_2_2 0x03 // 7 0 2.2 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_2_4 0x04 // 7 0 2.4 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_2_7 0x05 // 7 0 2.7 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_3_0 0x06 // 7 0 3.0 V +#define RADIOLIB_SX126X_DIO3_OUTPUT_3_3 0x07 // 7 0 3.3 V -//SX126X_CMD_SET_PACKET_TYPE -#define SX126X_PACKET_TYPE_GFSK 0x00 // 7 0 packet type: GFSK -#define SX126X_PACKET_TYPE_LORA 0x01 // 7 0 LoRa +//RADIOLIB_SX126X_CMD_SET_PACKET_TYPE +#define RADIOLIB_SX126X_PACKET_TYPE_GFSK 0x00 // 7 0 packet type: GFSK +#define RADIOLIB_SX126X_PACKET_TYPE_LORA 0x01 // 7 0 LoRa -//SX126X_CMD_SET_TX_PARAMS -#define SX126X_PA_RAMP_10U 0x00 // 7 0 ramp time: 10 us -#define SX126X_PA_RAMP_20U 0x01 // 7 0 20 us -#define SX126X_PA_RAMP_40U 0x02 // 7 0 40 us -#define SX126X_PA_RAMP_80U 0x03 // 7 0 80 us -#define SX126X_PA_RAMP_200U 0x04 // 7 0 200 us -#define SX126X_PA_RAMP_800U 0x05 // 7 0 800 us -#define SX126X_PA_RAMP_1700U 0x06 // 7 0 1700 us -#define SX126X_PA_RAMP_3400U 0x07 // 7 0 3400 us +//RADIOLIB_SX126X_CMD_SET_TX_PARAMS +#define RADIOLIB_SX126X_PA_RAMP_10U 0x00 // 7 0 ramp time: 10 us +#define RADIOLIB_SX126X_PA_RAMP_20U 0x01 // 7 0 20 us +#define RADIOLIB_SX126X_PA_RAMP_40U 0x02 // 7 0 40 us +#define RADIOLIB_SX126X_PA_RAMP_80U 0x03 // 7 0 80 us +#define RADIOLIB_SX126X_PA_RAMP_200U 0x04 // 7 0 200 us +#define RADIOLIB_SX126X_PA_RAMP_800U 0x05 // 7 0 800 us +#define RADIOLIB_SX126X_PA_RAMP_1700U 0x06 // 7 0 1700 us +#define RADIOLIB_SX126X_PA_RAMP_3400U 0x07 // 7 0 3400 us -//SX126X_CMD_SET_MODULATION_PARAMS -#define SX126X_GFSK_FILTER_NONE 0x00 // 7 0 GFSK filter: none -#define SX126X_GFSK_FILTER_GAUSS_0_3 0x08 // 7 0 Gaussian, BT = 0.3 -#define SX126X_GFSK_FILTER_GAUSS_0_5 0x09 // 7 0 Gaussian, BT = 0.5 -#define SX126X_GFSK_FILTER_GAUSS_0_7 0x0A // 7 0 Gaussian, BT = 0.7 -#define SX126X_GFSK_FILTER_GAUSS_1 0x0B // 7 0 Gaussian, BT = 1 -#define SX126X_GFSK_RX_BW_4_8 0x1F // 7 0 GFSK Rx bandwidth: 4.8 kHz -#define SX126X_GFSK_RX_BW_5_8 0x17 // 7 0 5.8 kHz -#define SX126X_GFSK_RX_BW_7_3 0x0F // 7 0 7.3 kHz -#define SX126X_GFSK_RX_BW_9_7 0x1E // 7 0 9.7 kHz -#define SX126X_GFSK_RX_BW_11_7 0x16 // 7 0 11.7 kHz -#define SX126X_GFSK_RX_BW_14_6 0x0E // 7 0 14.6 kHz -#define SX126X_GFSK_RX_BW_19_5 0x1D // 7 0 19.5 kHz -#define SX126X_GFSK_RX_BW_23_4 0x15 // 7 0 23.4 kHz -#define SX126X_GFSK_RX_BW_29_3 0x0D // 7 0 29.3 kHz -#define SX126X_GFSK_RX_BW_39_0 0x1C // 7 0 39.0 kHz -#define SX126X_GFSK_RX_BW_46_9 0x14 // 7 0 46.9 kHz -#define SX126X_GFSK_RX_BW_58_6 0x0C // 7 0 58.6 kHz -#define SX126X_GFSK_RX_BW_78_2 0x1B // 7 0 78.2 kHz -#define SX126X_GFSK_RX_BW_93_8 0x13 // 7 0 93.8 kHz -#define SX126X_GFSK_RX_BW_117_3 0x0B // 7 0 117.3 kHz -#define SX126X_GFSK_RX_BW_156_2 0x1A // 7 0 156.2 kHz -#define SX126X_GFSK_RX_BW_187_2 0x12 // 7 0 187.2 kHz -#define SX126X_GFSK_RX_BW_234_3 0x0A // 7 0 234.3 kHz -#define SX126X_GFSK_RX_BW_312_0 0x19 // 7 0 312.0 kHz -#define SX126X_GFSK_RX_BW_373_6 0x11 // 7 0 373.6 kHz -#define SX126X_GFSK_RX_BW_467_0 0x09 // 7 0 467.0 kHz -#define SX126X_LORA_BW_7_8 0x00 // 7 0 LoRa bandwidth: 7.8 kHz -#define SX126X_LORA_BW_10_4 0x08 // 7 0 10.4 kHz -#define SX126X_LORA_BW_15_6 0x01 // 7 0 15.6 kHz -#define SX126X_LORA_BW_20_8 0x09 // 7 0 20.8 kHz -#define SX126X_LORA_BW_31_25 0x02 // 7 0 31.25 kHz -#define SX126X_LORA_BW_41_7 0x0A // 7 0 41.7 kHz -#define SX126X_LORA_BW_62_5 0x03 // 7 0 62.5 kHz -#define SX126X_LORA_BW_125_0 0x04 // 7 0 125.0 kHz -#define SX126X_LORA_BW_250_0 0x05 // 7 0 250.0 kHz -#define SX126X_LORA_BW_500_0 0x06 // 7 0 500.0 kHz -#define SX126X_LORA_CR_4_5 0x01 // 7 0 LoRa coding rate: 4/5 -#define SX126X_LORA_CR_4_6 0x02 // 7 0 4/6 -#define SX126X_LORA_CR_4_7 0x03 // 7 0 4/7 -#define SX126X_LORA_CR_4_8 0x04 // 7 0 4/8 -#define SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_OFF 0x00 // 7 0 LoRa low data rate optimization: disabled -#define SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_ON 0x01 // 7 0 enabled +//RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS +#define RADIOLIB_SX126X_GFSK_FILTER_NONE 0x00 // 7 0 GFSK filter: none +#define RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_3 0x08 // 7 0 Gaussian, BT = 0.3 +#define RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_5 0x09 // 7 0 Gaussian, BT = 0.5 +#define RADIOLIB_SX126X_GFSK_FILTER_GAUSS_0_7 0x0A // 7 0 Gaussian, BT = 0.7 +#define RADIOLIB_SX126X_GFSK_FILTER_GAUSS_1 0x0B // 7 0 Gaussian, BT = 1 +#define RADIOLIB_SX126X_GFSK_RX_BW_4_8 0x1F // 7 0 GFSK Rx bandwidth: 4.8 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_5_8 0x17 // 7 0 5.8 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_7_3 0x0F // 7 0 7.3 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_9_7 0x1E // 7 0 9.7 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_11_7 0x16 // 7 0 11.7 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_14_6 0x0E // 7 0 14.6 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_19_5 0x1D // 7 0 19.5 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_23_4 0x15 // 7 0 23.4 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_29_3 0x0D // 7 0 29.3 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_39_0 0x1C // 7 0 39.0 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_46_9 0x14 // 7 0 46.9 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_58_6 0x0C // 7 0 58.6 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_78_2 0x1B // 7 0 78.2 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_93_8 0x13 // 7 0 93.8 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_117_3 0x0B // 7 0 117.3 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_156_2 0x1A // 7 0 156.2 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_187_2 0x12 // 7 0 187.2 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_234_3 0x0A // 7 0 234.3 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_312_0 0x19 // 7 0 312.0 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_373_6 0x11 // 7 0 373.6 kHz +#define RADIOLIB_SX126X_GFSK_RX_BW_467_0 0x09 // 7 0 467.0 kHz +#define RADIOLIB_SX126X_LORA_BW_7_8 0x00 // 7 0 LoRa bandwidth: 7.8 kHz +#define RADIOLIB_SX126X_LORA_BW_10_4 0x08 // 7 0 10.4 kHz +#define RADIOLIB_SX126X_LORA_BW_15_6 0x01 // 7 0 15.6 kHz +#define RADIOLIB_SX126X_LORA_BW_20_8 0x09 // 7 0 20.8 kHz +#define RADIOLIB_SX126X_LORA_BW_31_25 0x02 // 7 0 31.25 kHz +#define RADIOLIB_SX126X_LORA_BW_41_7 0x0A // 7 0 41.7 kHz +#define RADIOLIB_SX126X_LORA_BW_62_5 0x03 // 7 0 62.5 kHz +#define RADIOLIB_SX126X_LORA_BW_125_0 0x04 // 7 0 125.0 kHz +#define RADIOLIB_SX126X_LORA_BW_250_0 0x05 // 7 0 250.0 kHz +#define RADIOLIB_SX126X_LORA_BW_500_0 0x06 // 7 0 500.0 kHz +#define RADIOLIB_SX126X_LORA_CR_4_5 0x01 // 7 0 LoRa coding rate: 4/5 +#define RADIOLIB_SX126X_LORA_CR_4_6 0x02 // 7 0 4/6 +#define RADIOLIB_SX126X_LORA_CR_4_7 0x03 // 7 0 4/7 +#define RADIOLIB_SX126X_LORA_CR_4_8 0x04 // 7 0 4/8 +#define RADIOLIB_SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_OFF 0x00 // 7 0 LoRa low data rate optimization: disabled +#define RADIOLIB_SX126X_LORA_LOW_DATA_RATE_OPTIMIZE_ON 0x01 // 7 0 enabled -//SX126X_CMD_SET_PACKET_PARAMS -#define SX126X_GFSK_PREAMBLE_DETECT_OFF 0x00 // 7 0 GFSK minimum preamble length before reception starts: detector disabled -#define SX126X_GFSK_PREAMBLE_DETECT_8 0x04 // 7 0 8 bits -#define SX126X_GFSK_PREAMBLE_DETECT_16 0x05 // 7 0 16 bits -#define SX126X_GFSK_PREAMBLE_DETECT_24 0x06 // 7 0 24 bits -#define SX126X_GFSK_PREAMBLE_DETECT_32 0x07 // 7 0 32 bits -#define SX126X_GFSK_ADDRESS_FILT_OFF 0x00 // 7 0 GFSK address filtering: disabled -#define SX126X_GFSK_ADDRESS_FILT_NODE 0x01 // 7 0 node only -#define SX126X_GFSK_ADDRESS_FILT_NODE_BROADCAST 0x02 // 7 0 node and broadcast -#define SX126X_GFSK_PACKET_FIXED 0x00 // 7 0 GFSK packet type: fixed (payload length known in advance to both sides) -#define SX126X_GFSK_PACKET_VARIABLE 0x01 // 7 0 variable (payload length added to packet) -#define SX126X_GFSK_CRC_OFF 0x01 // 7 0 GFSK packet CRC: disabled -#define SX126X_GFSK_CRC_1_BYTE 0x00 // 7 0 1 byte -#define SX126X_GFSK_CRC_2_BYTE 0x02 // 7 0 2 byte -#define SX126X_GFSK_CRC_1_BYTE_INV 0x04 // 7 0 1 byte, inverted -#define SX126X_GFSK_CRC_2_BYTE_INV 0x06 // 7 0 2 byte, inverted -#define SX126X_GFSK_WHITENING_OFF 0x00 // 7 0 GFSK data whitening: disabled -#define SX126X_GFSK_WHITENING_ON 0x01 // 7 0 enabled -#define SX126X_LORA_HEADER_EXPLICIT 0x00 // 7 0 LoRa header mode: explicit -#define SX126X_LORA_HEADER_IMPLICIT 0x01 // 7 0 implicit -#define SX126X_LORA_CRC_OFF 0x00 // 7 0 LoRa CRC mode: disabled -#define SX126X_LORA_CRC_ON 0x01 // 7 0 enabled -#define SX126X_LORA_IQ_STANDARD 0x00 // 7 0 LoRa IQ setup: standard -#define SX126X_LORA_IQ_INVERTED 0x01 // 7 0 inverted +//RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS +#define RADIOLIB_SX126X_GFSK_PREAMBLE_DETECT_OFF 0x00 // 7 0 GFSK minimum preamble length before reception starts: detector disabled +#define RADIOLIB_SX126X_GFSK_PREAMBLE_DETECT_8 0x04 // 7 0 8 bits +#define RADIOLIB_SX126X_GFSK_PREAMBLE_DETECT_16 0x05 // 7 0 16 bits +#define RADIOLIB_SX126X_GFSK_PREAMBLE_DETECT_24 0x06 // 7 0 24 bits +#define RADIOLIB_SX126X_GFSK_PREAMBLE_DETECT_32 0x07 // 7 0 32 bits +#define RADIOLIB_SX126X_GFSK_ADDRESS_FILT_OFF 0x00 // 7 0 GFSK address filtering: disabled +#define RADIOLIB_SX126X_GFSK_ADDRESS_FILT_NODE 0x01 // 7 0 node only +#define RADIOLIB_SX126X_GFSK_ADDRESS_FILT_NODE_BROADCAST 0x02 // 7 0 node and broadcast +#define RADIOLIB_SX126X_GFSK_PACKET_FIXED 0x00 // 7 0 GFSK packet type: fixed (payload length known in advance to both sides) +#define RADIOLIB_SX126X_GFSK_PACKET_VARIABLE 0x01 // 7 0 variable (payload length added to packet) +#define RADIOLIB_SX126X_GFSK_CRC_OFF 0x01 // 7 0 GFSK packet CRC: disabled +#define RADIOLIB_SX126X_GFSK_CRC_1_BYTE 0x00 // 7 0 1 byte +#define RADIOLIB_SX126X_GFSK_CRC_2_BYTE 0x02 // 7 0 2 byte +#define RADIOLIB_SX126X_GFSK_CRC_1_BYTE_INV 0x04 // 7 0 1 byte, inverted +#define RADIOLIB_SX126X_GFSK_CRC_2_BYTE_INV 0x06 // 7 0 2 byte, inverted +#define RADIOLIB_SX126X_GFSK_WHITENING_OFF 0x00 // 7 0 GFSK data whitening: disabled +#define RADIOLIB_SX126X_GFSK_WHITENING_ON 0x01 // 7 0 enabled +#define RADIOLIB_SX126X_LORA_HEADER_EXPLICIT 0x00 // 7 0 LoRa header mode: explicit +#define RADIOLIB_SX126X_LORA_HEADER_IMPLICIT 0x01 // 7 0 implicit +#define RADIOLIB_SX126X_LORA_CRC_OFF 0x00 // 7 0 LoRa CRC mode: disabled +#define RADIOLIB_SX126X_LORA_CRC_ON 0x01 // 7 0 enabled +#define RADIOLIB_SX126X_LORA_IQ_STANDARD 0x00 // 7 0 LoRa IQ setup: standard +#define RADIOLIB_SX126X_LORA_IQ_INVERTED 0x01 // 7 0 inverted -//SX126X_CMD_SET_CAD_PARAMS -#define SX126X_CAD_ON_1_SYMB 0x00 // 7 0 number of symbols used for CAD: 1 -#define SX126X_CAD_ON_2_SYMB 0x01 // 7 0 2 -#define SX126X_CAD_ON_4_SYMB 0x02 // 7 0 4 -#define SX126X_CAD_ON_8_SYMB 0x03 // 7 0 8 -#define SX126X_CAD_ON_16_SYMB 0x04 // 7 0 16 -#define SX126X_CAD_GOTO_STDBY 0x00 // 7 0 after CAD is done, always go to STDBY_RC mode -#define SX126X_CAD_GOTO_RX 0x01 // 7 0 after CAD is done, go to Rx mode if activity is detected +//RADIOLIB_SX126X_CMD_SET_CAD_PARAMS +#define RADIOLIB_SX126X_CAD_ON_1_SYMB 0x00 // 7 0 number of symbols used for CAD: 1 +#define RADIOLIB_SX126X_CAD_ON_2_SYMB 0x01 // 7 0 2 +#define RADIOLIB_SX126X_CAD_ON_4_SYMB 0x02 // 7 0 4 +#define RADIOLIB_SX126X_CAD_ON_8_SYMB 0x03 // 7 0 8 +#define RADIOLIB_SX126X_CAD_ON_16_SYMB 0x04 // 7 0 16 +#define RADIOLIB_SX126X_CAD_GOTO_STDBY 0x00 // 7 0 after CAD is done, always go to STDBY_RC mode +#define RADIOLIB_SX126X_CAD_GOTO_RX 0x01 // 7 0 after CAD is done, go to Rx mode if activity is detected -//SX126X_CMD_GET_STATUS -#define SX126X_STATUS_MODE_STDBY_RC 0b00100000 // 6 4 current chip mode: STDBY_RC -#define SX126X_STATUS_MODE_STDBY_XOSC 0b00110000 // 6 4 STDBY_XOSC -#define SX126X_STATUS_MODE_FS 0b01000000 // 6 4 FS -#define SX126X_STATUS_MODE_RX 0b01010000 // 6 4 RX -#define SX126X_STATUS_MODE_TX 0b01100000 // 6 4 TX -#define SX126X_STATUS_DATA_AVAILABLE 0b00000100 // 3 1 command status: packet received and data can be retrieved -#define SX126X_STATUS_CMD_TIMEOUT 0b00000110 // 3 1 SPI command timed out -#define SX126X_STATUS_CMD_INVALID 0b00001000 // 3 1 invalid SPI command -#define SX126X_STATUS_CMD_FAILED 0b00001010 // 3 1 SPI command failed to execute -#define SX126X_STATUS_TX_DONE 0b00001100 // 3 1 packet transmission done -#define SX126X_STATUS_SPI_FAILED 0b11111111 // 7 0 SPI transaction failed +//RADIOLIB_SX126X_CMD_GET_STATUS +#define RADIOLIB_SX126X_STATUS_MODE_STDBY_RC 0b00100000 // 6 4 current chip mode: STDBY_RC +#define RADIOLIB_SX126X_STATUS_MODE_STDBY_XOSC 0b00110000 // 6 4 STDBY_XOSC +#define RADIOLIB_SX126X_STATUS_MODE_FS 0b01000000 // 6 4 FS +#define RADIOLIB_SX126X_STATUS_MODE_RX 0b01010000 // 6 4 RX +#define RADIOLIB_SX126X_STATUS_MODE_TX 0b01100000 // 6 4 TX +#define RADIOLIB_SX126X_STATUS_DATA_AVAILABLE 0b00000100 // 3 1 command status: packet received and data can be retrieved +#define RADIOLIB_SX126X_STATUS_CMD_TIMEOUT 0b00000110 // 3 1 SPI command timed out +#define RADIOLIB_SX126X_STATUS_CMD_INVALID 0b00001000 // 3 1 invalid SPI command +#define RADIOLIB_SX126X_STATUS_CMD_FAILED 0b00001010 // 3 1 SPI command failed to execute +#define RADIOLIB_SX126X_STATUS_TX_DONE 0b00001100 // 3 1 packet transmission done +#define RADIOLIB_SX126X_STATUS_SPI_FAILED 0b11111111 // 7 0 SPI transaction failed -//SX126X_CMD_GET_PACKET_STATUS -#define SX126X_GFSK_RX_STATUS_PREAMBLE_ERR 0b10000000 // 7 7 GFSK Rx status: preamble error -#define SX126X_GFSK_RX_STATUS_SYNC_ERR 0b01000000 // 6 6 sync word error -#define SX126X_GFSK_RX_STATUS_ADRS_ERR 0b00100000 // 5 5 address error -#define SX126X_GFSK_RX_STATUS_CRC_ERR 0b00010000 // 4 4 CRC error -#define SX126X_GFSK_RX_STATUS_LENGTH_ERR 0b00001000 // 3 3 length error -#define SX126X_GFSK_RX_STATUS_ABORT_ERR 0b00000100 // 2 2 abort error -#define SX126X_GFSK_RX_STATUS_PACKET_RECEIVED 0b00000010 // 2 2 packet received -#define SX126X_GFSK_RX_STATUS_PACKET_SENT 0b00000001 // 2 2 packet sent +//RADIOLIB_SX126X_CMD_GET_PACKET_STATUS +#define RADIOLIB_SX126X_GFSK_RX_STATUS_PREAMBLE_ERR 0b10000000 // 7 7 GFSK Rx status: preamble error +#define RADIOLIB_SX126X_GFSK_RX_STATUS_SYNC_ERR 0b01000000 // 6 6 sync word error +#define RADIOLIB_SX126X_GFSK_RX_STATUS_ADRS_ERR 0b00100000 // 5 5 address error +#define RADIOLIB_SX126X_GFSK_RX_STATUS_CRC_ERR 0b00010000 // 4 4 CRC error +#define RADIOLIB_SX126X_GFSK_RX_STATUS_LENGTH_ERR 0b00001000 // 3 3 length error +#define RADIOLIB_SX126X_GFSK_RX_STATUS_ABORT_ERR 0b00000100 // 2 2 abort error +#define RADIOLIB_SX126X_GFSK_RX_STATUS_PACKET_RECEIVED 0b00000010 // 2 2 packet received +#define RADIOLIB_SX126X_GFSK_RX_STATUS_PACKET_SENT 0b00000001 // 2 2 packet sent -//SX126X_CMD_GET_DEVICE_ERRORS -#define SX126X_PA_RAMP_ERR 0b100000000 // 8 8 device errors: PA ramping failed -#define SX126X_PLL_LOCK_ERR 0b001000000 // 6 6 PLL failed to lock -#define SX126X_XOSC_START_ERR 0b000100000 // 5 5 crystal oscillator failed to start -#define SX126X_IMG_CALIB_ERR 0b000010000 // 4 4 image calibration failed -#define SX126X_ADC_CALIB_ERR 0b000001000 // 3 3 ADC calibration failed -#define SX126X_PLL_CALIB_ERR 0b000000100 // 2 2 PLL calibration failed -#define SX126X_RC13M_CALIB_ERR 0b000000010 // 1 1 RC13M calibration failed -#define SX126X_RC64K_CALIB_ERR 0b000000001 // 0 0 RC64K calibration failed +//RADIOLIB_SX126X_CMD_GET_DEVICE_ERRORS +#define RADIOLIB_SX126X_PA_RAMP_ERR 0b100000000 // 8 8 device errors: PA ramping failed +#define RADIOLIB_SX126X_PLL_LOCK_ERR 0b001000000 // 6 6 PLL failed to lock +#define RADIOLIB_SX126X_XOSC_START_ERR 0b000100000 // 5 5 crystal oscillator failed to start +#define RADIOLIB_SX126X_IMG_CALIB_ERR 0b000010000 // 4 4 image calibration failed +#define RADIOLIB_SX126X_ADC_CALIB_ERR 0b000001000 // 3 3 ADC calibration failed +#define RADIOLIB_SX126X_PLL_CALIB_ERR 0b000000100 // 2 2 PLL calibration failed +#define RADIOLIB_SX126X_RC13M_CALIB_ERR 0b000000010 // 1 1 RC13M calibration failed +#define RADIOLIB_SX126X_RC64K_CALIB_ERR 0b000000001 // 0 0 RC64K calibration failed // SX126X SPI register variables -//SX126X_REG_LORA_SYNC_WORD_MSB + LSB -#define SX126X_SYNC_WORD_PUBLIC 0x34 // actually 0x3444 NOTE: The low nibbles in each byte (0x_4_4) are masked out since apparently, they're reserved. -#define SX126X_SYNC_WORD_PRIVATE 0x12 // actually 0x1424 You couldn't make this up if you tried. +//RADIOLIB_SX126X_REG_LORA_SYNC_WORD_MSB + LSB +#define RADIOLIB_SX126X_SYNC_WORD_PUBLIC 0x34 // actually 0x3444 NOTE: The low nibbles in each byte (0x_4_4) are masked out since apparently, they're reserved. +#define RADIOLIB_SX126X_SYNC_WORD_PRIVATE 0x12 // actually 0x1424 You couldn't make this up if you tried. /*! @@ -354,6 +354,8 @@ class SX126x: public PhysicalLayer { */ SX126x(Module* mod); + Module* getMod(); + // basic methods /*! @@ -443,7 +445,7 @@ class SX126x: public PhysicalLayer { /*! \brief Starts direct mode reception. Only implemented for PhysicalLayer compatibility, as %SX126x series does not support direct mode reception. - Will always return ERR_UNKNOWN. + Will always return RADIOLIB_ERR_UNKNOWN. \returns \ref status_codes */ @@ -475,7 +477,7 @@ class SX126x: public PhysicalLayer { /*! \brief Sets the module to standby mode. - \param mode Oscillator to be used in standby mode. Can be set to SX126X_STANDBY_RC (13 MHz RC oscillator) or SX126X_STANDBY_XOSC (32 MHz external crystal oscillator). + \param mode Oscillator to be used in standby mode. Can be set to RADIOLIB_SX126X_STANDBY_RC (13 MHz RC oscillator) or RADIOLIB_SX126X_STANDBY_XOSC (32 MHz external crystal oscillator). \returns \ref status_codes */ @@ -512,11 +514,11 @@ class SX126x: 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 SX126X_RX_TIMEOUT_INF for infinite timeout (Rx continuous mode), set to SX126X_RX_TIMEOUT_NONE for no timeout (Rx single mode). + \param timeout Raw timeout value, expressed as multiples of 15.625 us. Defaults to RADIOLIB_SX126X_RX_TIMEOUT_INF for infinite timeout (Rx continuous mode), set to RADIOLIB_SX126X_RX_TIMEOUT_NONE for no timeout (Rx single mode). \returns \ref status_codes */ - int16_t startReceive(uint32_t timeout = SX126X_RX_TIMEOUT_INF); + int16_t startReceive(uint32_t timeout = RADIOLIB_SX126X_RX_TIMEOUT_INF); /*! \brief Interrupt-driven receive method where the device mostly sleeps and periodically wakes to listen. @@ -800,7 +802,7 @@ class SX126x: public PhysicalLayer { \returns \ref status_codes */ - int16_t fixedPacketLengthMode(uint8_t len = SX126X_MAX_PACKET_LENGTH); + int16_t fixedPacketLengthMode(uint8_t len = RADIOLIB_SX126X_MAX_PACKET_LENGTH); /*! \brief Set modem in variable packet length mode. Available in FSK mode only. @@ -809,7 +811,7 @@ class SX126x: public PhysicalLayer { \returns \ref status_codes */ - int16_t variablePacketLengthMode(uint8_t maxLen = SX126X_MAX_PACKET_LENGTH); + int16_t variablePacketLengthMode(uint8_t maxLen = RADIOLIB_SX126X_MAX_PACKET_LENGTH); /*! \brief Get expected time-on-air for a given size of payload @@ -915,29 +917,29 @@ class SX126x: public PhysicalLayer { */ void readBit(RADIOLIB_PIN_TYPE pin); -#ifndef RADIOLIB_GODMODE +#if !defined(RADIOLIB_GODMODE) protected: #endif // SX126x SPI command implementations int16_t setTx(uint32_t timeout = 0); int16_t setRx(uint32_t timeout); int16_t setCad(); - int16_t setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax = SX126X_PA_CONFIG_HP_MAX, uint8_t paLut = SX126X_PA_CONFIG_PA_LUT); + int16_t setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax = RADIOLIB_SX126X_PA_CONFIG_HP_MAX, uint8_t paLut = RADIOLIB_SX126X_PA_CONFIG_PA_LUT); int16_t writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes); 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 setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = SX126X_IRQ_NONE, uint16_t dio3Mask = SX126X_IRQ_NONE); + int16_t setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = RADIOLIB_SX126X_IRQ_NONE, uint16_t dio3Mask = RADIOLIB_SX126X_IRQ_NONE); uint16_t getIrqStatus(); - int16_t clearIrqStatus(uint16_t clearIrqParams = SX126X_IRQ_ALL); + int16_t clearIrqStatus(uint16_t clearIrqParams = RADIOLIB_SX126X_IRQ_ALL); int16_t setRfFrequency(uint32_t frf); int16_t calibrateImage(uint8_t* data); uint8_t getPacketType(); - int16_t setTxParams(uint8_t power, uint8_t rampTime = SX126X_PA_RAMP_200U); + int16_t setTxParams(uint8_t power, uint8_t rampTime = RADIOLIB_SX126X_PA_RAMP_200U); int16_t setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro); int16_t setModulationParamsFSK(uint32_t br, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev); - int16_t setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength, uint8_t headerType, uint8_t invertIQ = SX126X_LORA_IQ_STANDARD); - int16_t setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t whitening, uint8_t packetType = SX126X_GFSK_PACKET_VARIABLE, uint8_t payloadLength = 0xFF, uint8_t preambleDetectorLength = SX126X_GFSK_PREAMBLE_DETECT_16); + int16_t setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength, uint8_t headerType, uint8_t invertIQ = RADIOLIB_SX126X_LORA_IQ_STANDARD); + int16_t setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t whitening, uint8_t packetType = RADIOLIB_SX126X_GFSK_PACKET_VARIABLE, uint8_t payloadLength = 0xFF, uint8_t preambleDetectorLength = RADIOLIB_SX126X_GFSK_PREAMBLE_DETECT_16); int16_t setBufferBaseAddress(uint8_t txBaseAddress = 0x00, uint8_t rxBaseAddress = 0x00); int16_t setRegulatorMode(uint8_t mode); uint8_t getStatus();