mirror
/
RadioLib
kopia lustrzana https://github.com/jgromes/RadioLib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

[RF69] Update to 5.0.0

pull/406/head
jgromes 2021-11-14 11:40:31 +01:00
rodzic e775bfc22e
commit 008187b0b1
11 zmienionych plików z 596 dodań i 590 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

8
examples/RF69/RF69_Receive/RF69_Receive.ino
Wyświetl plik

@ -35,7 +35,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -57,7 +57,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!"));
@ -71,11 +71,11 @@ void loop() {
Serial.print(radio.getRSSI());
Serial.println(F(" dBm"));
} 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!"));

8
examples/RF69/RF69_Receive_AES/RF69_Receive_AES.ino
Wyświetl plik

@ -31,7 +31,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -67,7 +67,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!"));
@ -75,11 +75,11 @@ void loop() {
Serial.print(F("[RF69] Data:\t\t"));
Serial.println(str);
} 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!"));

14
examples/RF69/RF69_Receive_Address/RF69_Receive_Address.ino
Wyświetl plik

@ -33,7 +33,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -46,7 +46,7 @@ void setup() {
// address filtering (node address only)
Serial.print(F("[RF69] Setting node address ... "));
state = radio.setNodeAddress(0x02);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -59,7 +59,7 @@ void setup() {
// address filtering (node or broadcast address)
Serial.print(F("[RF69] Setting broadcast address ... "));
state = radio.setBroadcastAddress(0xFF);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -73,7 +73,7 @@ void setup() {
/*
Serial.print(F("[RF69] Disabling address filtering ... "));
state == radio.disableAddressFiltering();
if(state == ERR_NONE) {
if(state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -96,7 +96,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!"));
@ -104,11 +104,11 @@ void loop() {
Serial.print(F("[RF69] Data:\t\t"));
Serial.println(str);
} 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!"));

8
examples/RF69/RF69_Receive_Interrupt/RF69_Receive_Interrupt.ino
Wyświetl plik

@ -31,7 +31,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -46,7 +46,7 @@ void setup() {
// start listening for packets
Serial.print(F("[RF69] 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 "));
@ -104,7 +104,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("[RF69] Received packet!"));
@ -118,7 +118,7 @@ void loop() {
Serial.print(radio.getRSSI());
Serial.println(F(" dBm"));
} else if (state == ERR_CRC_MISMATCH) {
} else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
// packet was received, but is malformed
Serial.println(F("CRC error!"));

20
examples/RF69/RF69_Settings/RF69_Settings.ino
Wyświetl plik

@ -43,7 +43,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio1.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -60,7 +60,7 @@ void setup() {
// output power: 17 dBm
// preamble length: 32 bits
state = radio2.begin(868.0, 300.0, 60.0, 250.0, 17, 32);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -72,17 +72,17 @@ 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("[RF69] Selected frequency is invalid for this module!"));
while (true);
}
// set bit rate to 100.0 kbps
state = radio1.setBitRate(100.0);
if (state == ERR_INVALID_BIT_RATE) {
if (state == RADIOLIB_ERR_INVALID_BIT_RATE) {
Serial.println(F("[RF69] Selected bit rate is invalid for this module!"));
while (true);
} else if (state == ERR_INVALID_BIT_RATE_BW_RATIO) {
} else if (state == RADIOLIB_ERR_INVALID_BIT_RATE_BW_RATIO) {
Serial.println(F("[RF69] Selected bit rate to bandwidth ratio is invalid!"));
Serial.println(F("[RF69] Increase receiver bandwidth to set this bit rate."));
while (true);
@ -90,23 +90,23 @@ void setup() {
// set receiver bandwidth to 250.0 kHz
state = radio1.setRxBandwidth(250.0);
if (state == ERR_INVALID_RX_BANDWIDTH) {
if (state == RADIOLIB_ERR_INVALID_RX_BANDWIDTH) {
Serial.println(F("[RF69] Selected receiver bandwidth is invalid for this module!"));
while (true);
} else if (state == ERR_INVALID_BIT_RATE_BW_RATIO) {
} else if (state == RADIOLIB_ERR_INVALID_BIT_RATE_BW_RATIO) {
Serial.println(F("[RF69] Selected bit rate to bandwidth ratio is invalid!"));
Serial.println(F("[RF69] Decrease bit rate to set this receiver bandwidth."));
while (true);
}
// set allowed frequency deviation to 10.0 kHz
if (radio1.setFrequencyDeviation(10.0) == ERR_INVALID_FREQUENCY_DEVIATION) {
if (radio1.setFrequencyDeviation(10.0) == RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION) {
Serial.println(F("[RF69] Selected frequency deviation is invalid for this module!"));
while (true);
}
// set output power to 2 dBm
if (radio1.setOutputPower(2) == ERR_INVALID_OUTPUT_POWER) {
if (radio1.setOutputPower(2) == RADIOLIB_ERR_INVALID_OUTPUT_POWER) {
Serial.println(F("[RF69] Selected output power is invalid for this module!"));
while (true);
}
@ -115,7 +115,7 @@ void setup() {
// NOTE: sync word must not contain any zero bytes
// set sync word to 0x0123456789ABCDEF
uint8_t syncWord[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
if (radio1.setSyncWord(syncWord, 8) == ERR_INVALID_SYNC_WORD) {
if (radio1.setSyncWord(syncWord, 8) == RADIOLIB_ERR_INVALID_SYNC_WORD) {
Serial.println(F("[RF69] Selected sync word is invalid for this module!"));
while (true);
}

8
examples/RF69/RF69_Transmit/RF69_Transmit.ino
Wyświetl plik

@ -33,7 +33,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -49,7 +49,7 @@ void setup() {
/*
Serial.print(F("[RF69] Setting high power module ... "));
state = radio.setOutputPower(20, true);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -71,11 +71,11 @@ void loop() {
int state = radio.transmit(byteArr, 8);
*/
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
// the packet was successfully transmitted
Serial.println(F("success!"));
} else if (state == ERR_PACKET_TOO_LONG) {
} else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
// the supplied packet was longer than 64 bytes
Serial.println(F("too long!"));

6
examples/RF69/RF69_Transmit_AES/RF69_Transmit_AES.ino
Wyświetl plik

@ -31,7 +31,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -66,11 +66,11 @@ void loop() {
int state = radio.transmit(byteArr, 8);
*/
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
// the packet was successfully transmitted
Serial.println(F("success!"));
} else if (state == ERR_PACKET_TOO_LONG) {
} else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
// the supplied packet was longer than 64 bytes
Serial.println(F("too long!"));

12
examples/RF69/RF69_Transmit_Address/RF69_Transmit_Address.ino
Wyświetl plik

@ -33,7 +33,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -46,7 +46,7 @@ void setup() {
// address filtering (node address only)
Serial.print(F("[RF69] Setting node address ... "));
state = radio.setNodeAddress(0x01);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -59,7 +59,7 @@ void setup() {
// address filtering (node or broadcast address)
Serial.print(F("[RF69] Setting broadcast address ... "));
state = radio.setBroadcastAddress(0xFF);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -73,7 +73,7 @@ void setup() {
/*
Serial.print(F("[RF69] Disabling address filtering ... "));
state = radio.disableAddressFiltering();
if(state == ERR_NONE) {
if(state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -106,11 +106,11 @@ void loop() {
int state = radio.transmit(byteArr, 8, 0xFF);
*/
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
// the packet was successfully transmitted
Serial.println(F("success!"));
} else if (state == ERR_PACKET_TOO_LONG) {
} else if (state == RADIOLIB_ERR_PACKET_TOO_LONG) {
// the supplied packet was longer than 64 bytes
Serial.println(F("too long!"));

8
examples/RF69/RF69_Transmit_Interrupt/RF69_Transmit_Interrupt.ino
Wyświetl plik

@ -29,7 +29,7 @@ RF69 radio = new Module(10, 2, 3);
//RF69 radio = RadioShield.ModuleA;
// save transmission state between loops
int transmissionState = ERR_NONE;
int transmissionState = RADIOLIB_ERR_NONE;
void setup() {
Serial.begin(9600);
@ -37,7 +37,7 @@ void setup() {
// initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin();
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -57,7 +57,7 @@ void setup() {
/*
Serial.print(F("[RF69] Setting high power module ... "));
state = radio.setOutputPower(20, true);
if (state == ERR_NONE) {
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
@ -111,7 +111,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!"));

418
src/modules/RF69/RF69.cpp
Wyświetl plik

@ -1,14 +1,18 @@
#include "RF69.h"
#if !defined(RADIOLIB_EXCLUDE_RF69)
RF69::RF69(Module* module) : PhysicalLayer(RF69_FREQUENCY_STEP_SIZE, RF69_MAX_PACKET_LENGTH) {
RF69::RF69(Module* module) : PhysicalLayer(RADIOLIB_RF69_FREQUENCY_STEP_SIZE, RADIOLIB_RF69_MAX_PACKET_LENGTH) {
_mod = module;
}
Module* RF69::getMod() {
return(_mod);
}
int16_t RF69::begin(float freq, float br, float freqDev, float rxBw, int8_t power, uint8_t preambleLen) {
// set module properties
_mod->init(RADIOLIB_USE_SPI);
Module::pinMode(_mod->getIrq(), INPUT);
_mod->init();
_mod->pinMode(_mod->getIrq(), INPUT);
// try to find the RF69 chip
uint8_t i = 0;
@ -19,13 +23,13 @@ int16_t RF69::begin(float freq, float br, float freqDev, float rxBw, int8_t powe
// check version register
int16_t version = getChipVersion();
if(version == RF69_CHIP_VERSION) {
if(version == RADIOLIB_RF69_CHIP_VERSION) {
flagFound = true;
} else {
#ifdef RADIOLIB_DEBUG
#if defined(RADIOLIB_DEBUG)
RADIOLIB_DEBUG_PRINT(F("RF69 not found! ("));
RADIOLIB_DEBUG_PRINT(i + 1);
RADIOLIB_DEBUG_PRINT(F(" of 10 tries) RF69_REG_VERSION == "));
RADIOLIB_DEBUG_PRINT(F(" of 10 tries) RADIOLIB_RF69_REG_VERSION == "));
char buffHex[7];
sprintf(buffHex, "0x%04X", version);
@ -33,15 +37,15 @@ int16_t RF69::begin(float freq, float br, float freqDev, float rxBw, int8_t powe
RADIOLIB_DEBUG_PRINT(F(", expected 0x0024"));
RADIOLIB_DEBUG_PRINTLN();
#endif
Module::delay(10);
_mod->delay(10);
i++;
}
}
if(!flagFound) {
RADIOLIB_DEBUG_PRINTLN(F("No RF69 found!"));
_mod->term(RADIOLIB_USE_SPI);
return(ERR_CHIP_NOT_FOUND);
_mod->term();
return(RADIOLIB_ERR_CHIP_NOT_FOUND);
} else {
RADIOLIB_DEBUG_PRINTLN(F("M\tRF69"));
}
@ -100,11 +104,11 @@ int16_t RF69::begin(float freq, float br, float freqDev, float rxBw, int8_t powe
}
void RF69::reset() {
Module::pinMode(_mod->getRst(), OUTPUT);
Module::digitalWrite(_mod->getRst(), HIGH);
Module::delay(1);
Module::digitalWrite(_mod->getRst(), LOW);
Module::delay(10);
_mod->pinMode(_mod->getRst(), OUTPUT);
_mod->digitalWrite(_mod->getRst(), HIGH);
_mod->delay(1);
_mod->digitalWrite(_mod->getRst(), LOW);
_mod->delay(10);
}
int16_t RF69::transmit(uint8_t* data, size_t len, uint8_t addr) {
@ -116,14 +120,14 @@ int16_t RF69::transmit(uint8_t* data, size_t len, uint8_t addr) {
RADIOLIB_ASSERT(state);
// wait for transmission end or timeout
uint32_t start = Module::micros();
while(!Module::digitalRead(_mod->getIrq())) {
Module::yield();
uint32_t start = _mod->micros();
while(!_mod->digitalRead(_mod->getIrq())) {
_mod->yield();
if(Module::micros() - start > timeout) {
if(_mod->micros() - start > timeout) {
standby();
clearIRQFlags();
return(ERR_TX_TIMEOUT);
return(RADIOLIB_ERR_TX_TIMEOUT);
}
}
@ -133,26 +137,26 @@ int16_t RF69::transmit(uint8_t* data, size_t len, uint8_t addr) {
// clear interrupt flags
clearIRQFlags();
return(ERR_NONE);
return(RADIOLIB_ERR_NONE);
}
int16_t RF69::receive(uint8_t* data, size_t len) {
// calculate timeout (500 ms + 400 full 64-byte packets at current bit rate)
uint32_t timeout = 500000 + (1.0/(_br*1000.0))*(RF69_MAX_PACKET_LENGTH*400.0);
uint32_t timeout = 500000 + (1.0/(_br*1000.0))*(RADIOLIB_RF69_MAX_PACKET_LENGTH*400.0);
// start reception
int16_t state = startReceive();
RADIOLIB_ASSERT(state);
// wait for packet reception or timeout
uint32_t start = Module::micros();
while(!Module::digitalRead(_mod->getIrq())) {
Module::yield();
uint32_t start = _mod->micros();
while(!_mod->digitalRead(_mod->getIrq())) {
_mod->yield();
if(Module::micros() - start > timeout) {
if(_mod->micros() - start > timeout) {
standby();
clearIRQFlags();
return(ERR_RX_TIMEOUT);
return(RADIOLIB_ERR_RX_TIMEOUT);
}
}
@ -165,7 +169,7 @@ int16_t RF69::sleep() {
_mod->setRfSwitchState(LOW, LOW);
// set module to sleep
return(setMode(RF69_SLEEP));
return(setMode(RADIOLIB_RF69_SLEEP));
}
int16_t RF69::standby() {
@ -173,7 +177,7 @@ int16_t RF69::standby() {
_mod->setRfSwitchState(LOW, LOW);
// set module to standby
return(setMode(RF69_STANDBY));
return(setMode(RADIOLIB_RF69_STANDBY));
}
int16_t RF69::transmitDirect(uint32_t frf) {
@ -182,11 +186,11 @@ int16_t RF69::transmitDirect(uint32_t frf) {
// user requested to start transmitting immediately (required for RTTY)
if(frf != 0) {
_mod->SPIwriteRegister(RF69_REG_FRF_MSB, (frf & 0xFF0000) >> 16);
_mod->SPIwriteRegister(RF69_REG_FRF_MID, (frf & 0x00FF00) >> 8);
_mod->SPIwriteRegister(RF69_REG_FRF_LSB, frf & 0x0000FF);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MSB, (frf & 0xFF0000) >> 16);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MID, (frf & 0x00FF00) >> 8);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_LSB, frf & 0x0000FF);
return(setMode(RF69_TX));
return(setMode(RADIOLIB_RF69_TX));
}
// activate direct mode
@ -194,7 +198,7 @@ int16_t RF69::transmitDirect(uint32_t frf) {
RADIOLIB_ASSERT(state);
// start transmitting
return(setMode(RF69_TX));
return(setMode(RADIOLIB_RF69_TX));
}
int16_t RF69::receiveDirect() {
@ -206,47 +210,47 @@ int16_t RF69::receiveDirect() {
RADIOLIB_ASSERT(state);
// start receiving
return(setMode(RF69_RX));
return(setMode(RADIOLIB_RF69_RX));
}
int16_t RF69::directMode() {
// set mode to standby
int16_t state = setMode(RF69_STANDBY);
int16_t state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state);
// set DIO mapping
state = _mod->SPIsetRegValue(RF69_REG_DIO_MAPPING_1, RF69_DIO1_CONT_DCLK | RF69_DIO2_CONT_DATA, 5, 2);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DIO_MAPPING_1, RADIOLIB_RF69_DIO1_CONT_DCLK | RADIOLIB_RF69_DIO2_CONT_DATA, 5, 2);
RADIOLIB_ASSERT(state);
// set continuous mode
return(_mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_CONTINUOUS_MODE_WITH_SYNC, 6, 5));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_CONTINUOUS_MODE_WITH_SYNC, 6, 5));
}
int16_t RF69::packetMode() {
return(_mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_PACKET_MODE, 6, 5));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_PACKET_MODE, 6, 5));
}
void RF69::setAESKey(uint8_t* key) {
_mod->SPIwriteRegisterBurst(RF69_REG_AES_KEY_1, key, 16);
_mod->SPIwriteRegisterBurst(RADIOLIB_RF69_REG_AES_KEY_1, key, 16);
}
int16_t RF69::enableAES() {
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AES_ON, 0, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_2, RADIOLIB_RF69_AES_ON, 0, 0));
}
int16_t RF69::disableAES() {
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AES_OFF, 0, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_2, RADIOLIB_RF69_AES_OFF, 0, 0));
}
int16_t RF69::startReceive() {
// set mode to standby
int16_t state = setMode(RF69_STANDBY);
int16_t state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state);
// set RX timeouts and DIO pin mapping
state = _mod->SPIsetRegValue(RF69_REG_DIO_MAPPING_1, RF69_DIO0_PACK_PAYLOAD_READY, 7, 4);
state |= _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_1, RF69_TIMEOUT_RX_START);
state |= _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_2, RF69_TIMEOUT_RSSI_THRESH);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DIO_MAPPING_1, RADIOLIB_RF69_DIO0_PACK_PAYLOAD_READY, 7, 4);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_1, RADIOLIB_RF69_TIMEOUT_RX_START);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_2, RADIOLIB_RF69_TIMEOUT_RSSI_THRESH);
RADIOLIB_ASSERT(state);
// clear interrupt flags
@ -256,75 +260,75 @@ int16_t RF69::startReceive() {
_mod->setRfSwitchState(HIGH, LOW);
// set mode to receive
state = _mod->SPIsetRegValue(RF69_REG_OCP, RF69_OCP_ON | RF69_OCP_TRIM);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA1, RF69_PA1_NORMAL);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA2, RF69_PA2_NORMAL);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_OCP, RADIOLIB_RF69_OCP_ON | RADIOLIB_RF69_OCP_TRIM);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA1, RADIOLIB_RF69_PA1_NORMAL);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA2, RADIOLIB_RF69_PA2_NORMAL);
RADIOLIB_ASSERT(state);
state = setMode(RF69_RX);
state = setMode(RADIOLIB_RF69_RX);
return(state);
}
void RF69::setDio0Action(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 RF69::clearDio0Action() {
Module::detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq()));
_mod->detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getIrq()));
}
void RF69::setDio1Action(void (*func)(void)) {
if(_mod->getGpio() == RADIOLIB_NC) {
return;
}
Module::pinMode(_mod->getGpio(), INPUT);
Module::attachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getGpio()), func, RISING);
_mod->pinMode(_mod->getGpio(), INPUT);
_mod->attachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getGpio()), func, RISING);
}
void RF69::clearDio1Action() {
if(_mod->getGpio() == RADIOLIB_NC) {
return;
}
Module::detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getGpio()));
_mod->detachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getGpio()));
}
int16_t RF69::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
// check packet length
if(len > RF69_MAX_PACKET_LENGTH) {
return(ERR_PACKET_TOO_LONG);
if(len > RADIOLIB_RF69_MAX_PACKET_LENGTH) {
return(RADIOLIB_ERR_PACKET_TOO_LONG);
}
// set mode to standby
int16_t state = setMode(RF69_STANDBY);
int16_t state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state);
// set DIO pin mapping
state = _mod->SPIsetRegValue(RF69_REG_DIO_MAPPING_1, RF69_DIO0_PACK_PACKET_SENT, 7, 6);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DIO_MAPPING_1, RADIOLIB_RF69_DIO0_PACK_PACKET_SENT, 7, 6);
RADIOLIB_ASSERT(state);
// clear interrupt flags
clearIRQFlags();
// optionally write packet length
if (_packetLengthConfig == RF69_PACKET_FORMAT_VARIABLE) {
_mod->SPIwriteRegister(RF69_REG_FIFO, len);
if (_packetLengthConfig == RADIOLIB_RF69_PACKET_FORMAT_VARIABLE) {
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FIFO, len);
}
// check address filtering
uint8_t filter = _mod->SPIgetRegValue(RF69_REG_PACKET_CONFIG_1, 2, 1);
if((filter == RF69_ADDRESS_FILTERING_NODE) || (filter == RF69_ADDRESS_FILTERING_NODE_BROADCAST)) {
_mod->SPIwriteRegister(RF69_REG_FIFO, addr);
uint8_t filter = _mod->SPIgetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, 2, 1);
if((filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE) || (filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST)) {
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FIFO, addr);
}
// write packet to FIFO
_mod->SPIwriteRegisterBurst(RF69_REG_FIFO, data, len);
_mod->SPIwriteRegisterBurst(RADIOLIB_RF69_REG_FIFO, data, len);
// enable +20 dBm operation
if(_power > 17) {
state = _mod->SPIsetRegValue(RF69_REG_OCP, RF69_OCP_OFF | 0x0F);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA1, RF69_PA1_20_DBM);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA2, RF69_PA2_20_DBM);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_OCP, RADIOLIB_RF69_OCP_OFF | 0x0F);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA1, RADIOLIB_RF69_PA1_20_DBM);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA2, RADIOLIB_RF69_PA2_20_DBM);
RADIOLIB_ASSERT(state);
}
@ -332,7 +336,7 @@ int16_t RF69::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
_mod->setRfSwitchState(LOW, HIGH);
// set mode to transmit
state = setMode(RF69_TX);
state = setMode(RADIOLIB_RF69_TX);
return(state);
}
@ -344,18 +348,18 @@ int16_t RF69::readData(uint8_t* data, size_t len) {
// get packet length
size_t length = len;
if(len == RF69_MAX_PACKET_LENGTH) {
if(len == RADIOLIB_RF69_MAX_PACKET_LENGTH) {
length = getPacketLength();
}
// check address filtering
uint8_t filter = _mod->SPIgetRegValue(RF69_REG_PACKET_CONFIG_1, 2, 1);
if((filter == RF69_ADDRESS_FILTERING_NODE) || (filter == RF69_ADDRESS_FILTERING_NODE_BROADCAST)) {
_mod->SPIreadRegister(RF69_REG_FIFO);
uint8_t filter = _mod->SPIgetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, 2, 1);
if((filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE) || (filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST)) {
_mod->SPIreadRegister(RADIOLIB_RF69_REG_FIFO);
}
// read packet data
_mod->SPIreadRegisterBurst(RF69_REG_FIFO, length, data);
_mod->SPIreadRegisterBurst(RADIOLIB_RF69_REG_FIFO, length, data);
// clear internal flag so getPacketLength can return the new packet length
_packetLengthQueried = false;
@ -363,18 +367,18 @@ int16_t RF69::readData(uint8_t* data, size_t len) {
// clear interrupt flags
clearIRQFlags();
return(ERR_NONE);
return(RADIOLIB_ERR_NONE);
}
int16_t RF69::setOOK(bool enableOOK) {
// set OOK and if successful, save the new setting
int16_t state = ERR_NONE;
int16_t state = RADIOLIB_ERR_NONE;
if(enableOOK) {
state = _mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_OOK, 4, 3, 5);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_OOK, 4, 3, 5);
} else {
state = _mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_FSK, 4, 3, 5);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_FSK, 4, 3, 5);
}
if(state == ERR_NONE) {
if(state == RADIOLIB_ERR_NONE) {
_ook = enableOOK;
}
@ -382,10 +386,10 @@ int16_t RF69::setOOK(bool enableOOK) {
}
int16_t RF69::setOokThresholdType(uint8_t type) {
if((type != RF69_OOK_THRESH_FIXED) && (type != RF69_OOK_THRESH_PEAK) && (type != RF69_OOK_THRESH_AVERAGE)) {
return(ERR_INVALID_OOK_RSSI_PEAK_TYPE);
if((type != RADIOLIB_RF69_OOK_THRESH_FIXED) && (type != RADIOLIB_RF69_OOK_THRESH_PEAK) && (type != RADIOLIB_RF69_OOK_THRESH_AVERAGE)) {
return(RADIOLIB_ERR_INVALID_OOK_RSSI_PEAK_TYPE);
}
return(_mod->SPIsetRegValue(RF69_REG_OOK_PEAK, type, 7, 3, 5));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_OOK_PEAK, type, 7, 3, 5));
}
int16_t RF69::setFrequency(float freq) {
@ -393,39 +397,39 @@ int16_t RF69::setFrequency(float freq) {
if(!(((freq > 290.0) && (freq < 340.0)) ||
((freq > 431.0) && (freq < 510.0)) ||
((freq > 862.0) && (freq < 1020.0)))) {
return(ERR_INVALID_FREQUENCY);
return(RADIOLIB_ERR_INVALID_FREQUENCY);
}
// set mode to standby
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
//set carrier frequency
uint32_t FRF = (freq * (uint32_t(1) << RF69_DIV_EXPONENT)) / RF69_CRYSTAL_FREQ;
_mod->SPIwriteRegister(RF69_REG_FRF_MSB, (FRF & 0xFF0000) >> 16);
_mod->SPIwriteRegister(RF69_REG_FRF_MID, (FRF & 0x00FF00) >> 8);
_mod->SPIwriteRegister(RF69_REG_FRF_LSB, FRF & 0x0000FF);
uint32_t FRF = (freq * (uint32_t(1) << RADIOLIB_RF69_DIV_EXPONENT)) / RADIOLIB_RF69_CRYSTAL_FREQ;
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MSB, (FRF & 0xFF0000) >> 16);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MID, (FRF & 0x00FF00) >> 8);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_LSB, FRF & 0x0000FF);
_freq = freq;
return(ERR_NONE);
return(RADIOLIB_ERR_NONE);
}
int16_t RF69::setBitRate(float br) {
RADIOLIB_CHECK_RANGE(br, 1.2, 300.0, ERR_INVALID_BIT_RATE);
RADIOLIB_CHECK_RANGE(br, 1.2, 300.0, RADIOLIB_ERR_INVALID_BIT_RATE);
// check bitrate-bandwidth ratio
if(!(br < 2000 * _rxBw)) {
return(ERR_INVALID_BIT_RATE_BW_RATIO);
return(RADIOLIB_ERR_INVALID_BIT_RATE_BW_RATIO);
}
// set mode to standby
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
// set bit rate
uint16_t bitRate = 32000 / br;
int16_t state = _mod->SPIsetRegValue(RF69_REG_BITRATE_MSB, (bitRate & 0xFF00) >> 8, 7, 0);
state |= _mod->SPIsetRegValue(RF69_REG_BITRATE_LSB, bitRate & 0x00FF, 7, 0);
if(state == ERR_NONE) {
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_BITRATE_MSB, (bitRate & 0xFF00) >> 8, 7, 0);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_BITRATE_LSB, bitRate & 0x00FF, 7, 0);
if(state == RADIOLIB_ERR_NONE) {
RF69::_br = br;
}
return(state);
@ -434,93 +438,93 @@ int16_t RF69::setBitRate(float br) {
int16_t RF69::setRxBandwidth(float rxBw) {
// check bitrate-bandwidth ratio
if(!(_br < 2000 * rxBw)) {
return(ERR_INVALID_BIT_RATE_BW_RATIO);
return(RADIOLIB_ERR_INVALID_BIT_RATE_BW_RATIO);
}
// check allowed bandwidth values
uint8_t bwMant, bwExp;
if(rxBw == 2.6) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 7;
} else if(rxBw == 3.1) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 7;
} else if(rxBw == 3.9) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 7;
} else if(rxBw == 5.2) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 6;
} else if(rxBw == 6.3) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 6;
} else if(rxBw == 7.8) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 6;
} else if(rxBw == 10.4) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 5;
} else if(rxBw == 12.5) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 5;
} else if(rxBw == 15.6) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 5;
} else if(rxBw == 20.8) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 4;
} else if(rxBw == 25.0) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 4;
} else if(rxBw == 31.3) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 4;
} else if(rxBw == 41.7) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 3;
} else if(rxBw == 50.0) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 3;
} else if(rxBw == 62.5) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 3;
} else if(rxBw == 83.3) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 2;
} else if(rxBw == 100.0) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 2;
} else if(rxBw == 125.0) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 2;
} else if(rxBw == 166.7) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 1;
} else if(rxBw == 200.0) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 1;
} else if(rxBw == 250.0) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 1;
} else if(rxBw == 333.3) {
bwMant = RF69_RX_BW_MANT_24;
bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 0;
} else if(rxBw == 400.0) {
bwMant = RF69_RX_BW_MANT_20;
bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 0;
} else if(rxBw == 500.0) {
bwMant = RF69_RX_BW_MANT_16;
bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 0;
} else {
return(ERR_INVALID_RX_BANDWIDTH);
return(RADIOLIB_ERR_INVALID_RX_BANDWIDTH);
}
// set mode to standby
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
// set Rx bandwidth
int16_t state = _mod->SPIsetRegValue(RF69_REG_RX_BW, RF69_DCC_FREQ | bwMant | bwExp, 7, 0);
if(state == ERR_NONE) {
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_BW, RADIOLIB_RF69_DCC_FREQ | bwMant | bwExp, 7, 0);
if(state == RADIOLIB_ERR_NONE) {
RF69::_rxBw = rxBw;
}
return(state);
@ -535,30 +539,30 @@ int16_t RF69::setFrequencyDeviation(float freqDev) {
// check frequency deviation range
if(!((newFreqDev + _br/2 <= 500))) {
return(ERR_INVALID_FREQUENCY_DEVIATION);
return(RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
}
// set mode to standby
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
// set frequency deviation from carrier frequency
uint32_t base = 1;
uint32_t fdev = (newFreqDev * (base << 19)) / 32000;
int16_t state = _mod->SPIsetRegValue(RF69_REG_FDEV_MSB, (fdev & 0xFF00) >> 8, 5, 0);
state |= _mod->SPIsetRegValue(RF69_REG_FDEV_LSB, fdev & 0x00FF, 7, 0);
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_FDEV_MSB, (fdev & 0xFF00) >> 8, 5, 0);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_FDEV_LSB, fdev & 0x00FF, 7, 0);
return(state);
}
int16_t RF69::setOutputPower(int8_t power, bool highPower) {
if(highPower) {
RADIOLIB_CHECK_RANGE(power, -2, 20, ERR_INVALID_OUTPUT_POWER);
RADIOLIB_CHECK_RANGE(power, -2, 20, RADIOLIB_ERR_INVALID_OUTPUT_POWER);
} else {
RADIOLIB_CHECK_RANGE(power, -18, 13, ERR_INVALID_OUTPUT_POWER);
RADIOLIB_CHECK_RANGE(power, -18, 13, RADIOLIB_ERR_INVALID_OUTPUT_POWER);
}
// set mode to standby
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
// set output power
int16_t state;
@ -566,22 +570,22 @@ int16_t RF69::setOutputPower(int8_t power, bool highPower) {
// check if both PA1 and PA2 are needed
if(power <= 10) {
// -2 to 13 dBm, PA1 is enough
state = _mod->SPIsetRegValue(RF69_REG_PA_LEVEL, RF69_PA0_OFF | RF69_PA1_ON | RF69_PA2_OFF | (power + 18), 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PA_LEVEL, RADIOLIB_RF69_PA0_OFF | RADIOLIB_RF69_PA1_ON | RADIOLIB_RF69_PA2_OFF | (power + 18), 7, 0);
} else if(power <= 17) {
// 13 to 17 dBm, both PAs required
state = _mod->SPIsetRegValue(RF69_REG_PA_LEVEL, RF69_PA0_OFF | RF69_PA1_ON | RF69_PA2_ON | (power + 14), 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PA_LEVEL, RADIOLIB_RF69_PA0_OFF | RADIOLIB_RF69_PA1_ON | RADIOLIB_RF69_PA2_ON | (power + 14), 7, 0);
} else {
// 18 - 20 dBm, both PAs and hig power settings required
state = _mod->SPIsetRegValue(RF69_REG_PA_LEVEL, RF69_PA0_OFF | RF69_PA1_ON | RF69_PA2_ON | (power + 11), 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PA_LEVEL, RADIOLIB_RF69_PA0_OFF | RADIOLIB_RF69_PA1_ON | RADIOLIB_RF69_PA2_ON | (power + 11), 7, 0);
}
} else {
// low power module, use only PA0
state = _mod->SPIsetRegValue(RF69_REG_PA_LEVEL, RF69_PA0_ON | RF69_PA1_OFF | RF69_PA2_OFF | (power + 18), 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PA_LEVEL, RADIOLIB_RF69_PA0_ON | RADIOLIB_RF69_PA1_OFF | RADIOLIB_RF69_PA2_OFF | (power + 18), 7, 0);
}
// cache the power value
if(state == ERR_NONE) {
if(state == RADIOLIB_ERR_NONE) {
_power = power;
}
@ -591,13 +595,13 @@ int16_t RF69::setOutputPower(int8_t power, bool highPower) {
int16_t RF69::setSyncWord(uint8_t* syncWord, size_t len, uint8_t maxErrBits) {
// check constraints
if((maxErrBits > 7) || (len > 8)) {
return(ERR_INVALID_SYNC_WORD);
return(RADIOLIB_ERR_INVALID_SYNC_WORD);
}
// sync word must not contain value 0x00
for(uint8_t i = 0; i < len; i++) {
if(syncWord[i] == 0x00) {
return(ERR_INVALID_SYNC_WORD);
return(RADIOLIB_ERR_INVALID_SYNC_WORD);
}
}
@ -607,50 +611,50 @@ int16_t RF69::setSyncWord(uint8_t* syncWord, size_t len, uint8_t maxErrBits) {
RADIOLIB_ASSERT(state);
// set sync word register
_mod->SPIwriteRegisterBurst(RF69_REG_SYNC_VALUE_1, syncWord, len);
return(ERR_NONE);
_mod->SPIwriteRegisterBurst(RADIOLIB_RF69_REG_SYNC_VALUE_1, syncWord, len);
return(RADIOLIB_ERR_NONE);
}
int16_t RF69::setPreambleLength(uint8_t preambleLen) {
// RF69 configures preamble length in bytes
if(preambleLen % 8 != 0) {
return(ERR_INVALID_PREAMBLE_LENGTH);
return(RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
}
uint8_t preLenBytes = preambleLen / 8;
_mod->SPIwriteRegister(RF69_REG_PREAMBLE_MSB, 0x00);
return(_mod->SPIsetRegValue(RF69_REG_PREAMBLE_LSB, preLenBytes));
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_PREAMBLE_MSB, 0x00);
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PREAMBLE_LSB, preLenBytes));
}
int16_t RF69::setNodeAddress(uint8_t nodeAddr) {
// enable address filtering (node only)
int16_t state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_ADDRESS_FILTERING_NODE, 2, 1);
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_ADDRESS_FILTERING_NODE, 2, 1);
RADIOLIB_ASSERT(state);
// set node address
return(_mod->SPIsetRegValue(RF69_REG_NODE_ADRS, nodeAddr));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_NODE_ADRS, nodeAddr));
}
int16_t RF69::setBroadcastAddress(uint8_t broadAddr) {
// enable address filtering (node + broadcast)
int16_t state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_ADDRESS_FILTERING_NODE_BROADCAST, 2, 1);
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST, 2, 1);
RADIOLIB_ASSERT(state);
// set broadcast address
return(_mod->SPIsetRegValue(RF69_REG_BROADCAST_ADRS, broadAddr));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_BROADCAST_ADRS, broadAddr));
}
int16_t RF69::disableAddressFiltering() {
// disable address filtering
int16_t state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_ADDRESS_FILTERING_OFF, 2, 1);
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_ADDRESS_FILTERING_OFF, 2, 1);
RADIOLIB_ASSERT(state);
// set node address to default (0x00)
state = _mod->SPIsetRegValue(RF69_REG_NODE_ADRS, 0x00);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_NODE_ADRS, 0x00);
RADIOLIB_ASSERT(state);
// set broadcast address to default (0x00)
return(_mod->SPIsetRegValue(RF69_REG_BROADCAST_ADRS, 0x00));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_BROADCAST_ADRS, 0x00));
}
void RF69::setAmbientTemperature(int16_t tempAmbient) {
@ -659,27 +663,27 @@ void RF69::setAmbientTemperature(int16_t tempAmbient) {
int16_t RF69::getTemperature() {
// set mode to STANDBY
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
// start temperature measurement
_mod->SPIsetRegValue(RF69_REG_TEMP_1, RF69_TEMP_MEAS_START, 3, 3);
_mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEMP_1, RADIOLIB_RF69_TEMP_MEAS_START, 3, 3);
// wait until measurement is finished
while(_mod->SPIgetRegValue(RF69_REG_TEMP_1, 2, 2) == RF69_TEMP_MEAS_RUNNING) {
while(_mod->SPIgetRegValue(RADIOLIB_RF69_REG_TEMP_1, 2, 2) == RADIOLIB_RF69_TEMP_MEAS_RUNNING) {
// check every 10 us
Module::delay(10);
_mod->delay(10);
}
int8_t rawTemp = _mod->SPIgetRegValue(RF69_REG_TEMP_2);
int8_t rawTemp = _mod->SPIgetRegValue(RADIOLIB_RF69_REG_TEMP_2);
return(0 - (rawTemp + _tempOffset));
}
size_t RF69::getPacketLength(bool update) {
if(!_packetLengthQueried && update) {
if (_packetLengthConfig == RF69_PACKET_FORMAT_VARIABLE) {
_packetLength = _mod->SPIreadRegister(RF69_REG_FIFO);
if (_packetLengthConfig == RADIOLIB_RF69_PACKET_FORMAT_VARIABLE) {
_packetLength = _mod->SPIreadRegister(RADIOLIB_RF69_REG_FIFO);
} else {
_packetLength = _mod->SPIreadRegister(RF69_REG_PAYLOAD_LENGTH);
_packetLength = _mod->SPIreadRegister(RADIOLIB_RF69_REG_PAYLOAD_LENGTH);
}
_packetLengthQueried = true;
}
@ -688,40 +692,40 @@ size_t RF69::getPacketLength(bool update) {
}
int16_t RF69::fixedPacketLengthMode(uint8_t len) {
return(setPacketMode(RF69_PACKET_FORMAT_FIXED, len));
return(setPacketMode(RADIOLIB_RF69_PACKET_FORMAT_FIXED, len));
}
int16_t RF69::variablePacketLengthMode(uint8_t maxLen) {
return(setPacketMode(RF69_PACKET_FORMAT_VARIABLE, maxLen));
return(setPacketMode(RADIOLIB_RF69_PACKET_FORMAT_VARIABLE, maxLen));
}
int16_t RF69::enableSyncWordFiltering(uint8_t maxErrBits) {
// enable sync word recognition
return(_mod->SPIsetRegValue(RF69_REG_SYNC_CONFIG, RF69_SYNC_ON | RF69_FIFO_FILL_CONDITION_SYNC | (_syncWordLength - 1) << 3 | maxErrBits, 7, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_SYNC_CONFIG, RADIOLIB_RF69_SYNC_ON | RADIOLIB_RF69_FIFO_FILL_CONDITION_SYNC | (_syncWordLength - 1) << 3 | maxErrBits, 7, 0));
}
int16_t RF69::disableSyncWordFiltering() {
// disable preamble detection and generation
int16_t state = _mod->SPIsetRegValue(RF69_REG_PREAMBLE_LSB, 0, 7, 0);
state |= _mod->SPIsetRegValue(RF69_REG_PREAMBLE_MSB, 0, 7, 0);
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PREAMBLE_LSB, 0, 7, 0);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PREAMBLE_MSB, 0, 7, 0);
RADIOLIB_ASSERT(state);
// disable sync word detection and generation
state = _mod->SPIsetRegValue(RF69_REG_SYNC_CONFIG, RF69_SYNC_OFF | RF69_FIFO_FILL_CONDITION, 7, 6);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_SYNC_CONFIG, RADIOLIB_RF69_SYNC_OFF | RADIOLIB_RF69_FIFO_FILL_CONDITION, 7, 6);
return(state);
}
int16_t RF69::setCrcFiltering(bool crcOn) {
if (crcOn == true) {
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_CRC_ON, 4, 4));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_CRC_ON, 4, 4));
} else {
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_CRC_OFF, 4, 4));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_CRC_OFF, 4, 4));
}
}
int16_t RF69::setPromiscuousMode(bool promiscuous) {
int16_t state = ERR_NONE;
int16_t state = RADIOLIB_ERR_NONE;
if (_promiscuous == promiscuous) {
return(state);
@ -754,15 +758,15 @@ int16_t RF69::setDataShaping(uint8_t sh) {
// set data shaping
switch(sh) {
case RADIOLIB_SHAPING_NONE:
return(_mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_NO_SHAPING, 1, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_NO_SHAPING, 1, 0));
case RADIOLIB_SHAPING_0_3:
return(_mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_FSK_GAUSSIAN_0_3, 1, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_FSK_GAUSSIAN_0_3, 1, 0));
case RADIOLIB_SHAPING_0_5:
return(_mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_FSK_GAUSSIAN_0_5, 1, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_FSK_GAUSSIAN_0_5, 1, 0));
case RADIOLIB_SHAPING_1_0:
return(_mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_FSK_GAUSSIAN_1_0, 1, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_FSK_GAUSSIAN_1_0, 1, 0));
default:
return(ERR_INVALID_DATA_SHAPING);
return(RADIOLIB_ERR_INVALID_DATA_SHAPING);
}
}
@ -774,26 +778,26 @@ int16_t RF69::setEncoding(uint8_t encoding) {
// set encoding
switch(encoding) {
case RADIOLIB_ENCODING_NRZ:
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_DC_FREE_NONE, 6, 5));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_DC_FREE_NONE, 6, 5));
case RADIOLIB_ENCODING_MANCHESTER:
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_DC_FREE_MANCHESTER, 6, 5));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_DC_FREE_MANCHESTER, 6, 5));
case RADIOLIB_ENCODING_WHITENING:
return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_DC_FREE_WHITENING, 6, 5));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_DC_FREE_WHITENING, 6, 5));
default:
return(ERR_INVALID_ENCODING);
return(RADIOLIB_ERR_INVALID_ENCODING);
}
}
int16_t RF69::setLnaTestBoost(bool value) {
if(value) {
return (_mod->SPIsetRegValue(RF69_REG_TEST_LNA, RF69_TEST_LNA_BOOST_HIGH, 7, 0));
return (_mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_LNA, RADIOLIB_RF69_TEST_LNA_BOOST_HIGH, 7, 0));
}
return(_mod->SPIsetRegValue(RF69_TEST_LNA_BOOST_NORMAL, RF69_TEST_LNA_BOOST_HIGH, 7, 0));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_TEST_LNA_BOOST_NORMAL, RADIOLIB_RF69_TEST_LNA_BOOST_HIGH, 7, 0));
}
float RF69::getRSSI() {
return(-1.0 * (_mod->SPIgetRegValue(RF69_REG_RSSI_VALUE)/2.0));
return(-1.0 * (_mod->SPIgetRegValue(RADIOLIB_RF69_REG_RSSI_VALUE)/2.0));
}
void RF69::setRfSwitchPins(RADIOLIB_PIN_TYPE rxEn, RADIOLIB_PIN_TYPE txEn) {
@ -802,19 +806,19 @@ void RF69::setRfSwitchPins(RADIOLIB_PIN_TYPE rxEn, RADIOLIB_PIN_TYPE txEn) {
uint8_t RF69::randomByte() {
// set mode to Rx
setMode(RF69_RX);
setMode(RADIOLIB_RF69_RX);
// 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++) {
randByte |= ((_mod->SPIreadRegister(RF69_REG_RSSI_VALUE) & 0x01) << i);
randByte |= ((_mod->SPIreadRegister(RADIOLIB_RF69_REG_RSSI_VALUE) & 0x01) << i);
}
// set mode to standby
setMode(RF69_STANDBY);
setMode(RADIOLIB_RF69_STANDBY);
return(randByte);
}
@ -828,77 +832,77 @@ void RF69::readBit(RADIOLIB_PIN_TYPE pin) {
}
int16_t RF69::getChipVersion() {
return(_mod->SPIgetRegValue(RF69_REG_VERSION));
return(_mod->SPIgetRegValue(RADIOLIB_RF69_REG_VERSION));
}
int16_t RF69::config() {
int16_t state = ERR_NONE;
int16_t state = RADIOLIB_ERR_NONE;
// set mode to STANDBY
state = setMode(RF69_STANDBY);
state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state);
// set operation modes
state = _mod->SPIsetRegValue(RF69_REG_OP_MODE, RF69_SEQUENCER_ON | RF69_LISTEN_OFF, 7, 6);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_OP_MODE, RADIOLIB_RF69_SEQUENCER_ON | RADIOLIB_RF69_LISTEN_OFF, 7, 6);
RADIOLIB_ASSERT(state);
// enable over-current protection
state = _mod->SPIsetRegValue(RF69_REG_OCP, RF69_OCP_ON, 4, 4);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_OCP, RADIOLIB_RF69_OCP_ON, 4, 4);
RADIOLIB_ASSERT(state);
// set data mode, modulation type and shaping
state = _mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_PACKET_MODE | RF69_FSK, 6, 3);
state |= _mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_FSK_GAUSSIAN_0_3, 1, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_PACKET_MODE | RADIOLIB_RF69_FSK, 6, 3);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_FSK_GAUSSIAN_0_3, 1, 0);
RADIOLIB_ASSERT(state);
// set RSSI threshold
state = _mod->SPIsetRegValue(RF69_REG_RSSI_THRESH, RF69_RSSI_THRESHOLD, 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RSSI_THRESH, RADIOLIB_RF69_RSSI_THRESHOLD, 7, 0);
RADIOLIB_ASSERT(state);
// reset FIFO flag
_mod->SPIwriteRegister(RF69_REG_IRQ_FLAGS_2, RF69_IRQ_FIFO_OVERRUN);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_IRQ_FLAGS_2, RADIOLIB_RF69_IRQ_FIFO_OVERRUN);
// disable ClkOut on DIO5
state = _mod->SPIsetRegValue(RF69_REG_DIO_MAPPING_2, RF69_CLK_OUT_OFF, 2, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DIO_MAPPING_2, RADIOLIB_RF69_CLK_OUT_OFF, 2, 0);
RADIOLIB_ASSERT(state);
// set packet configuration and disable encryption
state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_PACKET_FORMAT_VARIABLE | RF69_DC_FREE_NONE | RF69_CRC_ON | RF69_CRC_AUTOCLEAR_ON | RF69_ADDRESS_FILTERING_OFF, 7, 1);
state |= _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_INTER_PACKET_RX_DELAY, 7, 4);
state |= _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AUTO_RX_RESTART_ON | RF69_AES_OFF, 1, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, RADIOLIB_RF69_PACKET_FORMAT_VARIABLE | RADIOLIB_RF69_DC_FREE_NONE | RADIOLIB_RF69_CRC_ON | RADIOLIB_RF69_CRC_AUTOCLEAR_ON | RADIOLIB_RF69_ADDRESS_FILTERING_OFF, 7, 1);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_2, RADIOLIB_RF69_INTER_PACKET_RX_DELAY, 7, 4);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_2, RADIOLIB_RF69_AUTO_RX_RESTART_ON | RADIOLIB_RF69_AES_OFF, 1, 0);
RADIOLIB_ASSERT(state);
// set payload length
state = _mod->SPIsetRegValue(RF69_REG_PAYLOAD_LENGTH, RF69_PAYLOAD_LENGTH, 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PAYLOAD_LENGTH, RADIOLIB_RF69_PAYLOAD_LENGTH, 7, 0);
RADIOLIB_ASSERT(state);
// set FIFO threshold
state = _mod->SPIsetRegValue(RF69_REG_FIFO_THRESH, RF69_TX_START_CONDITION_FIFO_NOT_EMPTY | RF69_FIFO_THRESHOLD, 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_FIFO_THRESH, RADIOLIB_RF69_TX_START_CONDITION_FIFO_NOT_EMPTY | RADIOLIB_RF69_FIFO_THRESHOLD, 7, 0);
RADIOLIB_ASSERT(state);
// set Rx timeouts
state = _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_1, RF69_TIMEOUT_RX_START, 7, 0);
state |= _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_2, RF69_TIMEOUT_RSSI_THRESH, 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_1, RADIOLIB_RF69_TIMEOUT_RX_START, 7, 0);
state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_2, RADIOLIB_RF69_TIMEOUT_RSSI_THRESH, 7, 0);
RADIOLIB_ASSERT(state);
// enable improved fading margin
state = _mod->SPIsetRegValue(RF69_REG_TEST_DAGC, RF69_CONTINUOUS_DAGC_LOW_BETA_OFF, 7, 0);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_DAGC, RADIOLIB_RF69_CONTINUOUS_DAGC_LOW_BETA_OFF, 7, 0);
return(state);
}
int16_t RF69::setPacketMode(uint8_t mode, uint8_t len) {
// check length
if (len > RF69_MAX_PACKET_LENGTH) {
return(ERR_PACKET_TOO_LONG);
if (len > RADIOLIB_RF69_MAX_PACKET_LENGTH) {
return(RADIOLIB_ERR_PACKET_TOO_LONG);
}
// set to fixed packet length
int16_t state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, mode, 7, 7);
int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, mode, 7, 7);
RADIOLIB_ASSERT(state);
// set length to register
state = _mod->SPIsetRegValue(RF69_REG_PAYLOAD_LENGTH, len);
state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PAYLOAD_LENGTH, len);
RADIOLIB_ASSERT(state);
// update the cached value
@ -907,12 +911,12 @@ int16_t RF69::setPacketMode(uint8_t mode, uint8_t len) {
}
int16_t RF69::setMode(uint8_t mode) {
return(_mod->SPIsetRegValue(RF69_REG_OP_MODE, mode, 4, 2));
return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_OP_MODE, mode, 4, 2));
}
void RF69::clearIRQFlags() {
_mod->SPIwriteRegister(RF69_REG_IRQ_FLAGS_1, 0b11111111);
_mod->SPIwriteRegister(RF69_REG_IRQ_FLAGS_2, 0b11111111);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_IRQ_FLAGS_1, 0b11111111);
_mod->SPIwriteRegister(RADIOLIB_RF69_REG_IRQ_FLAGS_2, 0b11111111);
}
#endif

676
src/modules/RF69/RF69.h
Wyświetl plik

@ -10,427 +10,427 @@
#include "../../protocols/PhysicalLayer/PhysicalLayer.h"
// RF69 physical layer properties
#define RF69_FREQUENCY_STEP_SIZE 61.03515625
#define RF69_MAX_PACKET_LENGTH 64
#define RF69_CRYSTAL_FREQ 32.0
#define RF69_DIV_EXPONENT 19
#define RADIOLIB_RF69_FREQUENCY_STEP_SIZE 61.03515625
#define RADIOLIB_RF69_MAX_PACKET_LENGTH 64
#define RADIOLIB_RF69_CRYSTAL_FREQ 32.0
#define RADIOLIB_RF69_DIV_EXPONENT 19
// RF69 register map
#define RF69_REG_FIFO 0x00
#define RF69_REG_OP_MODE 0x01
#define RF69_REG_DATA_MODUL 0x02
#define RF69_REG_BITRATE_MSB 0x03
#define RF69_REG_BITRATE_LSB 0x04
#define RF69_REG_FDEV_MSB 0x05
#define RF69_REG_FDEV_LSB 0x06
#define RF69_REG_FRF_MSB 0x07
#define RF69_REG_FRF_MID 0x08
#define RF69_REG_FRF_LSB 0x09
#define RF69_REG_OSC_1 0x0A
#define RF69_REG_AFC_CTRL 0x0B
#define RF69_REG_LISTEN_1 0x0D
#define RF69_REG_LISTEN_2 0x0E
#define RF69_REG_LISTEN_3 0x0F
#define RF69_REG_VERSION 0x10
#define RF69_REG_PA_LEVEL 0x11
#define RF69_REG_PA_RAMP 0x12
#define RF69_REG_OCP 0x13
#define RF69_REG_LNA 0x18
#define RF69_REG_RX_BW 0x19
#define RF69_REG_AFC_BW 0x1A
#define RF69_REG_OOK_PEAK 0x1B
#define RF69_REG_OOK_AVG 0x1C
#define RF69_REG_OOK_FIX 0x1D
#define RF69_REG_AFC_FEI 0x1E
#define RF69_REG_AFC_MSB 0x1F
#define RF69_REG_AFC_LSB 0x20
#define RF69_REG_FEI_MSB 0x21
#define RF69_REG_FEI_LSB 0x22
#define RF69_REG_RSSI_CONFIG 0x23
#define RF69_REG_RSSI_VALUE 0x24
#define RF69_REG_DIO_MAPPING_1 0x25
#define RF69_REG_DIO_MAPPING_2 0x26
#define RF69_REG_IRQ_FLAGS_1 0x27
#define RF69_REG_IRQ_FLAGS_2 0x28
#define RF69_REG_RSSI_THRESH 0x29
#define RF69_REG_RX_TIMEOUT_1 0x2A
#define RF69_REG_RX_TIMEOUT_2 0x2B
#define RF69_REG_PREAMBLE_MSB 0x2C
#define RF69_REG_PREAMBLE_LSB 0x2D
#define RF69_REG_SYNC_CONFIG 0x2E
#define RF69_REG_SYNC_VALUE_1 0x2F
#define RF69_REG_SYNC_VALUE_2 0x30
#define RF69_REG_SYNC_VALUE_3 0x31
#define RF69_REG_SYNC_VALUE_4 0x32
#define RF69_REG_SYNC_VALUE_5 0x33
#define RF69_REG_SYNC_VALUE_6 0x34
#define RF69_REG_SYNC_VALUE_7 0x35
#define RF69_REG_SYNC_VALUE_8 0x36
#define RF69_REG_PACKET_CONFIG_1 0x37
#define RF69_REG_PAYLOAD_LENGTH 0x38
#define RF69_REG_NODE_ADRS 0x39
#define RF69_REG_BROADCAST_ADRS 0x3A
#define RF69_REG_AUTO_MODES 0x3B
#define RF69_REG_FIFO_THRESH 0x3C
#define RF69_REG_PACKET_CONFIG_2 0x3D
#define RF69_REG_AES_KEY_1 0x3E
#define RF69_REG_AES_KEY_2 0x3F
#define RF69_REG_AES_KEY_3 0x40
#define RF69_REG_AES_KEY_4 0x41
#define RF69_REG_AES_KEY_5 0x42
#define RF69_REG_AES_KEY_6 0x43
#define RF69_REG_AES_KEY_7 0x44
#define RF69_REG_AES_KEY_8 0x45
#define RF69_REG_AES_KEY_9 0x46
#define RF69_REG_AES_KEY_10 0x47
#define RF69_REG_AES_KEY_11 0x48
#define RF69_REG_AES_KEY_12 0x49
#define RF69_REG_AES_KEY_13 0x4A
#define RF69_REG_AES_KEY_14 0x4B
#define RF69_REG_AES_KEY_15 0x4C
#define RF69_REG_AES_KEY_16 0x4D
#define RF69_REG_TEMP_1 0x4E
#define RF69_REG_TEMP_2 0x4F
#define RF69_REG_TEST_LNA 0x58
#define RF69_REG_TEST_PA1 0x5A
#define RF69_REG_TEST_PA2 0x5C
#define RF69_REG_TEST_DAGC 0x6F
#define RADIOLIB_RF69_REG_FIFO 0x00
#define RADIOLIB_RF69_REG_OP_MODE 0x01
#define RADIOLIB_RF69_REG_DATA_MODUL 0x02
#define RADIOLIB_RF69_REG_BITRATE_MSB 0x03
#define RADIOLIB_RF69_REG_BITRATE_LSB 0x04
#define RADIOLIB_RF69_REG_FDEV_MSB 0x05
#define RADIOLIB_RF69_REG_FDEV_LSB 0x06
#define RADIOLIB_RF69_REG_FRF_MSB 0x07
#define RADIOLIB_RF69_REG_FRF_MID 0x08
#define RADIOLIB_RF69_REG_FRF_LSB 0x09
#define RADIOLIB_RF69_REG_OSC_1 0x0A
#define RADIOLIB_RF69_REG_AFC_CTRL 0x0B
#define RADIOLIB_RF69_REG_LISTEN_1 0x0D
#define RADIOLIB_RF69_REG_LISTEN_2 0x0E
#define RADIOLIB_RF69_REG_LISTEN_3 0x0F
#define RADIOLIB_RF69_REG_VERSION 0x10
#define RADIOLIB_RF69_REG_PA_LEVEL 0x11
#define RADIOLIB_RF69_REG_PA_RAMP 0x12
#define RADIOLIB_RF69_REG_OCP 0x13
#define RADIOLIB_RF69_REG_LNA 0x18
#define RADIOLIB_RF69_REG_RX_BW 0x19
#define RADIOLIB_RF69_REG_AFC_BW 0x1A
#define RADIOLIB_RF69_REG_OOK_PEAK 0x1B
#define RADIOLIB_RF69_REG_OOK_AVG 0x1C
#define RADIOLIB_RF69_REG_OOK_FIX 0x1D
#define RADIOLIB_RF69_REG_AFC_FEI 0x1E
#define RADIOLIB_RF69_REG_AFC_MSB 0x1F
#define RADIOLIB_RF69_REG_AFC_LSB 0x20
#define RADIOLIB_RF69_REG_FEI_MSB 0x21
#define RADIOLIB_RF69_REG_FEI_LSB 0x22
#define RADIOLIB_RF69_REG_RSSI_CONFIG 0x23
#define RADIOLIB_RF69_REG_RSSI_VALUE 0x24
#define RADIOLIB_RF69_REG_DIO_MAPPING_1 0x25
#define RADIOLIB_RF69_REG_DIO_MAPPING_2 0x26
#define RADIOLIB_RF69_REG_IRQ_FLAGS_1 0x27
#define RADIOLIB_RF69_REG_IRQ_FLAGS_2 0x28
#define RADIOLIB_RF69_REG_RSSI_THRESH 0x29
#define RADIOLIB_RF69_REG_RX_TIMEOUT_1 0x2A
#define RADIOLIB_RF69_REG_RX_TIMEOUT_2 0x2B
#define RADIOLIB_RF69_REG_PREAMBLE_MSB 0x2C
#define RADIOLIB_RF69_REG_PREAMBLE_LSB 0x2D
#define RADIOLIB_RF69_REG_SYNC_CONFIG 0x2E
#define RADIOLIB_RF69_REG_SYNC_VALUE_1 0x2F
#define RADIOLIB_RF69_REG_SYNC_VALUE_2 0x30
#define RADIOLIB_RF69_REG_SYNC_VALUE_3 0x31
#define RADIOLIB_RF69_REG_SYNC_VALUE_4 0x32
#define RADIOLIB_RF69_REG_SYNC_VALUE_5 0x33
#define RADIOLIB_RF69_REG_SYNC_VALUE_6 0x34
#define RADIOLIB_RF69_REG_SYNC_VALUE_7 0x35
#define RADIOLIB_RF69_REG_SYNC_VALUE_8 0x36
#define RADIOLIB_RF69_REG_PACKET_CONFIG_1 0x37
#define RADIOLIB_RF69_REG_PAYLOAD_LENGTH 0x38
#define RADIOLIB_RF69_REG_NODE_ADRS 0x39
#define RADIOLIB_RF69_REG_BROADCAST_ADRS 0x3A
#define RADIOLIB_RF69_REG_AUTO_MODES 0x3B
#define RADIOLIB_RF69_REG_FIFO_THRESH 0x3C
#define RADIOLIB_RF69_REG_PACKET_CONFIG_2 0x3D
#define RADIOLIB_RF69_REG_AES_KEY_1 0x3E
#define RADIOLIB_RF69_REG_AES_KEY_2 0x3F
#define RADIOLIB_RF69_REG_AES_KEY_3 0x40
#define RADIOLIB_RF69_REG_AES_KEY_4 0x41
#define RADIOLIB_RF69_REG_AES_KEY_5 0x42
#define RADIOLIB_RF69_REG_AES_KEY_6 0x43
#define RADIOLIB_RF69_REG_AES_KEY_7 0x44
#define RADIOLIB_RF69_REG_AES_KEY_8 0x45
#define RADIOLIB_RF69_REG_AES_KEY_9 0x46
#define RADIOLIB_RF69_REG_AES_KEY_10 0x47
#define RADIOLIB_RF69_REG_AES_KEY_11 0x48
#define RADIOLIB_RF69_REG_AES_KEY_12 0x49
#define RADIOLIB_RF69_REG_AES_KEY_13 0x4A
#define RADIOLIB_RF69_REG_AES_KEY_14 0x4B
#define RADIOLIB_RF69_REG_AES_KEY_15 0x4C
#define RADIOLIB_RF69_REG_AES_KEY_16 0x4D
#define RADIOLIB_RF69_REG_TEMP_1 0x4E
#define RADIOLIB_RF69_REG_TEMP_2 0x4F
#define RADIOLIB_RF69_REG_TEST_LNA 0x58
#define RADIOLIB_RF69_REG_TEST_PA1 0x5A
#define RADIOLIB_RF69_REG_TEST_PA2 0x5C
#define RADIOLIB_RF69_REG_TEST_DAGC 0x6F
// RF69 modem settings
// RF69_REG_OP_MODE MSB LSB DESCRIPTION
#define RF69_SEQUENCER_OFF 0b00000000 // 7 7 disable automatic sequencer
#define RF69_SEQUENCER_ON 0b10000000 // 7 7 enable automatic sequencer
#define RF69_LISTEN_OFF 0b00000000 // 6 6 disable Listen mode
#define RF69_LISTEN_ON 0b01000000 // 6 6 enable Listen mode
#define RF69_LISTEN_ABORT 0b00100000 // 5 5 abort Listen mode (has to be set together with RF69_LISTEN_OFF)
#define RF69_SLEEP 0b00000000 // 4 2 sleep
#define RF69_STANDBY 0b00000100 // 4 2 standby
#define RF69_FS 0b00001000 // 4 2 frequency synthesis
#define RF69_TX 0b00001100 // 4 2 transmit
#define RF69_RX 0b00010000 // 4 2 receive
#define RADIOLIB_RF69_SEQUENCER_OFF 0b00000000 // 7 7 disable automatic sequencer
#define RADIOLIB_RF69_SEQUENCER_ON 0b10000000 // 7 7 enable automatic sequencer
#define RADIOLIB_RF69_LISTEN_OFF 0b00000000 // 6 6 disable Listen mode
#define RADIOLIB_RF69_LISTEN_ON 0b01000000 // 6 6 enable Listen mode
#define RADIOLIB_RF69_LISTEN_ABORT 0b00100000 // 5 5 abort Listen mode (has to be set together with RF69_LISTEN_OFF)
#define RADIOLIB_RF69_SLEEP 0b00000000 // 4 2 sleep
#define RADIOLIB_RF69_STANDBY 0b00000100 // 4 2 standby
#define RADIOLIB_RF69_FS 0b00001000 // 4 2 frequency synthesis
#define RADIOLIB_RF69_TX 0b00001100 // 4 2 transmit
#define RADIOLIB_RF69_RX 0b00010000 // 4 2 receive
// RF69_REG_DATA_MODUL
#define RF69_PACKET_MODE 0b00000000 // 6 5 packet mode (default)
#define RF69_CONTINUOUS_MODE_WITH_SYNC 0b01000000 // 6 5 continuous mode with bit synchronizer
#define RF69_CONTINUOUS_MODE 0b01100000 // 6 5 continuous mode without bit synchronizer
#define RF69_FSK 0b00000000 // 4 3 modulation: FSK (default)
#define RF69_OOK 0b00001000 // 4 3 OOK
#define RF69_NO_SHAPING 0b00000000 // 1 0 modulation shaping: no shaping (default)
#define RF69_FSK_GAUSSIAN_1_0 0b00000001 // 1 0 FSK modulation Gaussian filter, BT = 1.0
#define RF69_FSK_GAUSSIAN_0_5 0b00000010 // 1 0 FSK modulation Gaussian filter, BT = 0.5
#define RF69_FSK_GAUSSIAN_0_3 0b00000011 // 1 0 FSK modulation Gaussian filter, BT = 0.3
#define RF69_OOK_FILTER_BR 0b00000001 // 1 0 OOK modulation filter, f_cutoff = BR
#define RF69_OOK_FILTER_2BR 0b00000010 // 1 0 OOK modulation filter, f_cutoff = 2*BR
#define RADIOLIB_RF69_PACKET_MODE 0b00000000 // 6 5 packet mode (default)
#define RADIOLIB_RF69_CONTINUOUS_MODE_WITH_SYNC 0b01000000 // 6 5 continuous mode with bit synchronizer
#define RADIOLIB_RF69_CONTINUOUS_MODE 0b01100000 // 6 5 continuous mode without bit synchronizer
#define RADIOLIB_RF69_FSK 0b00000000 // 4 3 modulation: FSK (default)
#define RADIOLIB_RF69_OOK 0b00001000 // 4 3 OOK
#define RADIOLIB_RF69_NO_SHAPING 0b00000000 // 1 0 modulation shaping: no shaping (default)
#define RADIOLIB_RF69_FSK_GAUSSIAN_1_0 0b00000001 // 1 0 FSK modulation Gaussian filter, BT = 1.0
#define RADIOLIB_RF69_FSK_GAUSSIAN_0_5 0b00000010 // 1 0 FSK modulation Gaussian filter, BT = 0.5
#define RADIOLIB_RF69_FSK_GAUSSIAN_0_3 0b00000011 // 1 0 FSK modulation Gaussian filter, BT = 0.3
#define RADIOLIB_RF69_OOK_FILTER_BR 0b00000001 // 1 0 OOK modulation filter, f_cutoff = BR
#define RADIOLIB_RF69_OOK_FILTER_2BR 0b00000010 // 1 0 OOK modulation filter, f_cutoff = 2*BR
// RF69_REG_BITRATE_MSB + REG_BITRATE_LSB
#define RF69_BITRATE_MSB 0x1A // 7 0 bit rate setting: rate = F(XOSC) / BITRATE
#define RF69_BITRATE_LSB 0x0B // 7 0 default value: 4.8 kbps 0x40 // 7 0
#define RADIOLIB_RF69_BITRATE_MSB 0x1A // 7 0 bit rate setting: rate = F(XOSC) / BITRATE
#define RADIOLIB_RF69_BITRATE_LSB 0x0B // 7 0 default value: 4.8 kbps 0x40 // 7 0
// RF69_REG_FDEV_MSB + REG_FDEV_LSB
#define RF69_FDEV_MSB 0x00 // 5 0 frequency deviation: f_dev = f_step * FDEV
#define RF69_FDEV_LSB 0x52 // 7 0 default value: 5 kHz
#define RADIOLIB_RF69_FDEV_MSB 0x00 // 5 0 frequency deviation: f_dev = f_step * FDEV
#define RADIOLIB_RF69_FDEV_LSB 0x52 // 7 0 default value: 5 kHz
// RF69_REG_FRF_MSB + REG_FRF_MID + REG_FRF_LSB
#define RF69_FRF_MSB 0xE4 // 7 0 carrier frequency setting: f_RF = (F(XOSC) * FRF)/2^19
#define RF69_FRF_MID 0xC0 // 7 0 where F(XOSC) = 32 MHz
#define RF69_FRF_LSB 0x00 // 7 0 default value: 915 MHz
#define RADIOLIB_RF69_FRF_MSB 0xE4 // 7 0 carrier frequency setting: f_RF = (F(XOSC) * FRF)/2^19
#define RADIOLIB_RF69_FRF_MID 0xC0 // 7 0 where F(XOSC) = 32 MHz
#define RADIOLIB_RF69_FRF_LSB 0x00 // 7 0 default value: 915 MHz
// RF69_REG_OSC_1
#define RF69_RC_CAL_START 0b10000000 // 7 7 force RC oscillator calibration
#define RF69_RC_CAL_RUNNING 0b00000000 // 6 6 RC oscillator calibration is still running
#define RF69_RC_CAL_DONE 0b00000000 // 5 5 RC oscillator calibration has finished
#define RADIOLIB_RF69_RC_CAL_START 0b10000000 // 7 7 force RC oscillator calibration
#define RADIOLIB_RF69_RC_CAL_RUNNING 0b00000000 // 6 6 RC oscillator calibration is still running
#define RADIOLIB_RF69_RC_CAL_DONE 0b00000000 // 5 5 RC oscillator calibration has finished
// RF69_REG_AFC_CTRL
#define RF69_AFC_LOW_BETA_OFF 0b00000000 // 5 5 standard AFC routine
#define RF69_AFC_LOW_BETA_ON 0b00100000 // 5 5 improved AFC routine for signals with modulation index less than 2
#define RADIOLIB_RF69_AFC_LOW_BETA_OFF 0b00000000 // 5 5 standard AFC routine
#define RADIOLIB_RF69_AFC_LOW_BETA_ON 0b00100000 // 5 5 improved AFC routine for signals with modulation index less than 2
// RF69_REG_LISTEN_1
#define RF69_LISTEN_RES_IDLE_64_US 0b01000000 // 7 6 resolution of Listen mode idle time: 64 us
#define RF69_LISTEN_RES_IDLE_4_1_MS 0b10000000 // 7 6 4.1 ms (default)
#define RF69_LISTEN_RES_IDLE_262_MS 0b11000000 // 7 6 262 ms
#define RF69_LISTEN_RES_RX_64_US 0b00010000 // 5 4 resolution of Listen mode rx time: 64 us (default)
#define RF69_LISTEN_RES_RX_4_1_MS 0b00100000 // 5 4 4.1 ms
#define RF69_LISTEN_RES_RX_262_MS 0b00110000 // 5 4 262 ms
#define RF69_LISTEN_ACCEPT_ABOVE_RSSI_THRESH 0b00000000 // 3 3 packet acceptance criteria: RSSI above threshold
#define RF69_LISTEN_ACCEPT_MATCH_SYNC_ADDRESS 0b00001000 // 3 3 RSSI above threshold AND sync address matched
#define RF69_LISTEN_END_KEEP_RX 0b00000000 // 2 1 action after packet acceptance: stay in Rx mode
#define RF69_LISTEN_END_KEEP_RX_TIMEOUT 0b00000010 // 2 1 stay in Rx mode until timeout (default)
#define RF69_LISTEN_END_KEEP_RX_TIMEOUT_RESUME 0b00000100 // 2 1 stay in Rx mode until timeout, Listen mode will resume
#define RADIOLIB_RF69_LISTEN_RES_IDLE_64_US 0b01000000 // 7 6 resolution of Listen mode idle time: 64 us
#define RADIOLIB_RF69_LISTEN_RES_IDLE_4_1_MS 0b10000000 // 7 6 4.1 ms (default)
#define RADIOLIB_RF69_LISTEN_RES_IDLE_262_MS 0b11000000 // 7 6 262 ms
#define RADIOLIB_RF69_LISTEN_RES_RX_64_US 0b00010000 // 5 4 resolution of Listen mode rx time: 64 us (default)
#define RADIOLIB_RF69_LISTEN_RES_RX_4_1_MS 0b00100000 // 5 4 4.1 ms
#define RADIOLIB_RF69_LISTEN_RES_RX_262_MS 0b00110000 // 5 4 262 ms
#define RADIOLIB_RF69_LISTEN_ACCEPT_ABOVE_RSSI_THRESH 0b00000000 // 3 3 packet acceptance criteria: RSSI above threshold
#define RADIOLIB_RF69_LISTEN_ACCEPT_MATCH_SYNC_ADDRESS 0b00001000 // 3 3 RSSI above threshold AND sync address matched
#define RADIOLIB_RF69_LISTEN_END_KEEP_RX 0b00000000 // 2 1 action after packet acceptance: stay in Rx mode
#define RADIOLIB_RF69_LISTEN_END_KEEP_RX_TIMEOUT 0b00000010 // 2 1 stay in Rx mode until timeout (default)
#define RADIOLIB_RF69_LISTEN_END_KEEP_RX_TIMEOUT_RESUME 0b00000100 // 2 1 stay in Rx mode until timeout, Listen mode will resume
// RF69_REG_LISTEN_2
#define RF69_LISTEN_COEF_IDLE 0xF5 // 7 0 duration of idle phase in Listen mode
#define RADIOLIB_RF69_LISTEN_COEF_IDLE 0xF5 // 7 0 duration of idle phase in Listen mode
// RF69_REG_LISTEN_3
#define RF69_LISTEN_COEF_RX 0x20 // 7 0 duration of Rx phase in Listen mode
#define RADIOLIB_RF69_LISTEN_COEF_RX 0x20 // 7 0 duration of Rx phase in Listen mode
// RF69_REG_VERSION
#define RF69_CHIP_VERSION 0x24 // 7 0
#define RADIOLIB_RF69_CHIP_VERSION 0x24 // 7 0
// RF69_REG_PA_LEVEL
#define RF69_PA0_OFF 0b00000000 // 7 7 PA0 disabled
#define RF69_PA0_ON 0b10000000 // 7 7 PA0 enabled (default)
#define RF69_PA1_OFF 0b00000000 // 6 6 PA1 disabled (default)
#define RF69_PA1_ON 0b01000000 // 6 6 PA1 enabled
#define RF69_PA2_OFF 0b00000000 // 5 5 PA2 disabled (default)
#define RF69_PA2_ON 0b00100000 // 5 5 PA2 enabled
#define RF69_OUTPUT_POWER 0b00011111 // 4 0 output power: P_out = -18 + OUTPUT_POWER
#define RADIOLIB_RF69_PA0_OFF 0b00000000 // 7 7 PA0 disabled
#define RADIOLIB_RF69_PA0_ON 0b10000000 // 7 7 PA0 enabled (default)
#define RADIOLIB_RF69_PA1_OFF 0b00000000 // 6 6 PA1 disabled (default)
#define RADIOLIB_RF69_PA1_ON 0b01000000 // 6 6 PA1 enabled
#define RADIOLIB_RF69_PA2_OFF 0b00000000 // 5 5 PA2 disabled (default)
#define RADIOLIB_RF69_PA2_ON 0b00100000 // 5 5 PA2 enabled
#define RADIOLIB_RF69_OUTPUT_POWER 0b00011111 // 4 0 output power: P_out = -18 + OUTPUT_POWER
// RF69_REG_PA_RAMP
#define RF69_PA_RAMP_3_4_MS 0b00000000 // 3 0 PA ramp rise/fall time: 3.4 ms
#define RF69_PA_RAMP_2_MS 0b00000001 // 3 0 2 ms
#define RF69_PA_RAMP_1_MS 0b00000010 // 3 0 1 ms
#define RF69_PA_RAMP_500_US 0b00000011 // 3 0 500 us
#define RF69_PA_RAMP_250_US 0b00000100 // 3 0 250 us
#define RF69_PA_RAMP_125_US 0b00000101 // 3 0 125 us
#define RF69_PA_RAMP_100_US 0b00000110 // 3 0 100 us
#define RF69_PA_RAMP_62_US 0b00000111 // 3 0 62 us
#define RF69_PA_RAMP_50_US 0b00001000 // 3 0 50 us
#define RF69_PA_RAMP_40_US 0b00001001 // 3 0 40 us (default)
#define RF69_PA_RAMP_31_US 0b00001010 // 3 0 31 us
#define RF69_PA_RAMP_25_US 0b00001011 // 3 0 25 us
#define RF69_PA_RAMP_20_US 0b00001100 // 3 0 20 us
#define RF69_PA_RAMP_15_US 0b00001101 // 3 0 15 us
#define RF69_PA_RAMP_12_US 0b00001110 // 3 0 12 us
#define RF69_PA_RAMP_10_US 0b00001111 // 3 0 10 us
#define RADIOLIB_RF69_PA_RAMP_3_4_MS 0b00000000 // 3 0 PA ramp rise/fall time: 3.4 ms
#define RADIOLIB_RF69_PA_RAMP_2_MS 0b00000001 // 3 0 2 ms
#define RADIOLIB_RF69_PA_RAMP_1_MS 0b00000010 // 3 0 1 ms
#define RADIOLIB_RF69_PA_RAMP_500_US 0b00000011 // 3 0 500 us
#define RADIOLIB_RF69_PA_RAMP_250_US 0b00000100 // 3 0 250 us
#define RADIOLIB_RF69_PA_RAMP_125_US 0b00000101 // 3 0 125 us
#define RADIOLIB_RF69_PA_RAMP_100_US 0b00000110 // 3 0 100 us
#define RADIOLIB_RF69_PA_RAMP_62_US 0b00000111 // 3 0 62 us
#define RADIOLIB_RF69_PA_RAMP_50_US 0b00001000 // 3 0 50 us
#define RADIOLIB_RF69_PA_RAMP_40_US 0b00001001 // 3 0 40 us (default)
#define RADIOLIB_RF69_PA_RAMP_31_US 0b00001010 // 3 0 31 us
#define RADIOLIB_RF69_PA_RAMP_25_US 0b00001011 // 3 0 25 us
#define RADIOLIB_RF69_PA_RAMP_20_US 0b00001100 // 3 0 20 us
#define RADIOLIB_RF69_PA_RAMP_15_US 0b00001101 // 3 0 15 us
#define RADIOLIB_RF69_PA_RAMP_12_US 0b00001110 // 3 0 12 us
#define RADIOLIB_RF69_PA_RAMP_10_US 0b00001111 // 3 0 10 us
// RF69_REG_OCP
#define RF69_OCP_OFF 0b00000000 // 4 4 PA overload current protection disabled
#define RF69_OCP_ON 0b00010000 // 4 4 PA overload current protection enabled
#define RF69_OCP_TRIM 0b00001010 // 3 0 OCP current: I_max(OCP_TRIM = 0b1010) = 95 mA
#define RADIOLIB_RF69_OCP_OFF 0b00000000 // 4 4 PA overload current protection disabled
#define RADIOLIB_RF69_OCP_ON 0b00010000 // 4 4 PA overload current protection enabled
#define RADIOLIB_RF69_OCP_TRIM 0b00001010 // 3 0 OCP current: I_max(OCP_TRIM = 0b1010) = 95 mA
// RF69_REG_LNA
#define RF69_LNA_Z_IN_50_OHM 0b00000000 // 7 7 LNA input impedance: 50 ohm
#define RF69_LNA_Z_IN_200_OHM 0b10000000 // 7 7 200 ohm
#define RF69_LNA_CURRENT_GAIN 0b00001000 // 5 3 manually set LNA current gain
#define RF69_LNA_GAIN_AUTO 0b00000000 // 2 0 LNA gain setting: set automatically by AGC
#define RF69_LNA_GAIN_MAX 0b00000001 // 2 0 max gain
#define RF69_LNA_GAIN_MAX_6_DB 0b00000010 // 2 0 max gain - 6 dB
#define RF69_LNA_GAIN_MAX_12_DB 0b00000011 // 2 0 max gain - 12 dB
#define RF69_LNA_GAIN_MAX_24_DB 0b00000100 // 2 0 max gain - 24 dB
#define RF69_LNA_GAIN_MAX_36_DB 0b00000101 // 2 0 max gain - 36 dB
#define RF69_LNA_GAIN_MAX_48_DB 0b00000110 // 2 0 max gain - 48 dB
#define RADIOLIB_RF69_LNA_Z_IN_50_OHM 0b00000000 // 7 7 LNA input impedance: 50 ohm
#define RADIOLIB_RF69_LNA_Z_IN_200_OHM 0b10000000 // 7 7 200 ohm
#define RADIOLIB_RF69_LNA_CURRENT_GAIN 0b00001000 // 5 3 manually set LNA current gain
#define RADIOLIB_RF69_LNA_GAIN_AUTO 0b00000000 // 2 0 LNA gain setting: set automatically by AGC
#define RADIOLIB_RF69_LNA_GAIN_MAX 0b00000001 // 2 0 max gain
#define RADIOLIB_RF69_LNA_GAIN_MAX_6_DB 0b00000010 // 2 0 max gain - 6 dB
#define RADIOLIB_RF69_LNA_GAIN_MAX_12_DB 0b00000011 // 2 0 max gain - 12 dB
#define RADIOLIB_RF69_LNA_GAIN_MAX_24_DB 0b00000100 // 2 0 max gain - 24 dB
#define RADIOLIB_RF69_LNA_GAIN_MAX_36_DB 0b00000101 // 2 0 max gain - 36 dB
#define RADIOLIB_RF69_LNA_GAIN_MAX_48_DB 0b00000110 // 2 0 max gain - 48 dB
// RF69_REG_RX_BW
#define RF69_DCC_FREQ 0b01000000 // 7 5 DC offset canceller cutoff frequency (4% Rx BW by default)
#define RF69_RX_BW_MANT_16 0b00000000 // 4 3 Channel filter bandwidth FSK: RxBw = F(XOSC)/(RxBwMant * 2^(RxBwExp + 2))
#define RF69_RX_BW_MANT_20 0b00001000 // 4 3 OOK: RxBw = F(XOSC)/(RxBwMant * 2^(RxBwExp + 3))
#define RF69_RX_BW_MANT_24 0b00010000 // 4 3
#define RF69_RX_BW_EXP 0b00000101 // 2 0 default RxBwExp value = 5
#define RADIOLIB_RF69_DCC_FREQ 0b01000000 // 7 5 DC offset canceller cutoff frequency (4% Rx BW by default)
#define RADIOLIB_RF69_RX_BW_MANT_16 0b00000000 // 4 3 Channel filter bandwidth FSK: RxBw = F(XOSC)/(RxBwMant * 2^(RxBwExp + 2))
#define RADIOLIB_RF69_RX_BW_MANT_20 0b00001000 // 4 3 OOK: RxBw = F(XOSC)/(RxBwMant * 2^(RxBwExp + 3))
#define RADIOLIB_RF69_RX_BW_MANT_24 0b00010000 // 4 3
#define RADIOLIB_RF69_RX_BW_EXP 0b00000101 // 2 0 default RxBwExp value = 5
// RF69_REG_AFC_BW
#define RF69_DCC_FREQ_AFC 0b10000000 // 7 5 default DccFreq parameter for AFC
#define RF69_DCC_RX_BW_MANT_AFC 0b00001000 // 4 3 default RxBwMant parameter for AFC
#define RF69_DCC_RX_BW_EXP_AFC 0b00000011 // 2 0 default RxBwExp parameter for AFC
#define RADIOLIB_RF69_DCC_FREQ_AFC 0b10000000 // 7 5 default DccFreq parameter for AFC
#define RADIOLIB_RF69_DCC_RX_BW_MANT_AFC 0b00001000 // 4 3 default RxBwMant parameter for AFC
#define RADIOLIB_RF69_DCC_RX_BW_EXP_AFC 0b00000011 // 2 0 default RxBwExp parameter for AFC
// RF69_REG_OOK_PEAK
#define RF69_OOK_THRESH_FIXED 0b00000000 // 7 6 OOK threshold type: fixed
#define RF69_OOK_THRESH_PEAK 0b01000000 // 7 6 peak (default)
#define RF69_OOK_THRESH_AVERAGE 0b10000000 // 7 6 average
#define RF69_OOK_PEAK_THRESH_STEP_0_5_DB 0b00000000 // 5 3 OOK demodulator step size: 0.5 dB (default)
#define RF69_OOK_PEAK_THRESH_STEP_1_0_DB 0b00001000 // 5 3 1.0 dB
#define RF69_OOK_PEAK_THRESH_STEP_1_5_DB 0b00010000 // 5 3 1.5 dB
#define RF69_OOK_PEAK_THRESH_STEP_2_0_DB 0b00011000 // 5 3 2.0 dB
#define RF69_OOK_PEAK_THRESH_STEP_3_0_DB 0b00100000 // 5 3 3.0 dB
#define RF69_OOK_PEAK_THRESH_STEP_4_0_DB 0b00101000 // 5 3 4.0 dB
#define RF69_OOK_PEAK_THRESH_STEP_5_0_DB 0b00110000 // 5 3 5.0 dB
#define RF69_OOK_PEAK_THRESH_STEP_6_0_DB 0b00111000 // 5 3 6.0 dB
#define RF69_OOK_PEAK_THRESH_DEC_1_1_CHIP 0b00000000 // 2 0 OOK demodulator step period: once per chip (default)
#define RF69_OOK_PEAK_THRESH_DEC_1_2_CHIP 0b00000001 // 2 0 once every 2 chips
#define RF69_OOK_PEAK_THRESH_DEC_1_4_CHIP 0b00000010 // 2 0 once every 4 chips
#define RF69_OOK_PEAK_THRESH_DEC_1_8_CHIP 0b00000011 // 2 0 once every 8 chips
#define RF69_OOK_PEAK_THRESH_DEC_2_1_CHIP 0b00000100 // 2 0 2 times per chip
#define RF69_OOK_PEAK_THRESH_DEC_4_1_CHIP 0b00000101 // 2 0 4 times per chip
#define RF69_OOK_PEAK_THRESH_DEC_8_1_CHIP 0b00000110 // 2 0 8 times per chip
#define RF69_OOK_PEAK_THRESH_DEC_16_1_CHIP 0b00000111 // 2 0 16 times per chip
#define RADIOLIB_RF69_OOK_THRESH_FIXED 0b00000000 // 7 6 OOK threshold type: fixed
#define RADIOLIB_RF69_OOK_THRESH_PEAK 0b01000000 // 7 6 peak (default)
#define RADIOLIB_RF69_OOK_THRESH_AVERAGE 0b10000000 // 7 6 average
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_0_5_DB 0b00000000 // 5 3 OOK demodulator step size: 0.5 dB (default)
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_1_0_DB 0b00001000 // 5 3 1.0 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_1_5_DB 0b00010000 // 5 3 1.5 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_2_0_DB 0b00011000 // 5 3 2.0 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_3_0_DB 0b00100000 // 5 3 3.0 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_4_0_DB 0b00101000 // 5 3 4.0 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_5_0_DB 0b00110000 // 5 3 5.0 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_STEP_6_0_DB 0b00111000 // 5 3 6.0 dB
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_1_1_CHIP 0b00000000 // 2 0 OOK demodulator step period: once per chip (default)
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_1_2_CHIP 0b00000001 // 2 0 once every 2 chips
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_1_4_CHIP 0b00000010 // 2 0 once every 4 chips
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_1_8_CHIP 0b00000011 // 2 0 once every 8 chips
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_2_1_CHIP 0b00000100 // 2 0 2 times per chip
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_4_1_CHIP 0b00000101 // 2 0 4 times per chip
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_8_1_CHIP 0b00000110 // 2 0 8 times per chip
#define RADIOLIB_RF69_OOK_PEAK_THRESH_DEC_16_1_CHIP 0b00000111 // 2 0 16 times per chip
// RF69_REG_OOK_AVG
#define RF69_OOK_AVG_THRESH_FILT_32_PI 0b00000000 // 7 6 OOK average filter coefficient: chip rate / 32*pi
#define RF69_OOK_AVG_THRESH_FILT_8_PI 0b01000000 // 7 6 chip rate / 8*pi
#define RF69_OOK_AVG_THRESH_FILT_4_PI 0b10000000 // 7 6 chip rate / 4*pi (default)
#define RF69_OOK_AVG_THRESH_FILT_2_PI 0b11000000 // 7 6 chip rate / 2*pi
#define RADIOLIB_RF69_OOK_AVG_THRESH_FILT_32_PI 0b00000000 // 7 6 OOK average filter coefficient: chip rate / 32*pi
#define RADIOLIB_RF69_OOK_AVG_THRESH_FILT_8_PI 0b01000000 // 7 6 chip rate / 8*pi
#define RADIOLIB_RF69_OOK_AVG_THRESH_FILT_4_PI 0b10000000 // 7 6 chip rate / 4*pi (default)
#define RADIOLIB_RF69_OOK_AVG_THRESH_FILT_2_PI 0b11000000 // 7 6 chip rate / 2*pi
// RF69_REG_OOK_FIX
#define RF69_OOK_FIXED_THRESH 0b00000110 // 7 0 default OOK fixed threshold (6 dB)
#define RADIOLIB_RF69_OOK_FIXED_THRESH 0b00000110 // 7 0 default OOK fixed threshold (6 dB)
// RF69_REG_AFC_FEI
#define RF69_FEI_RUNNING 0b00000000 // 6 6 FEI status: on-going
#define RF69_FEI_DONE 0b01000000 // 6 6 done
#define RF69_FEI_START 0b00100000 // 5 5 force new FEI measurement
#define RF69_AFC_RUNNING 0b00000000 // 4 4 AFC status: on-going
#define RF69_AFC_DONE 0b00010000 // 4 4 done
#define RF69_AFC_AUTOCLEAR_OFF 0b00000000 // 3 3 AFC register autoclear disabled
#define RF69_AFC_AUTOCLEAR_ON 0b00001000 // 3 3 AFC register autoclear enabled
#define RF69_AFC_AUTO_OFF 0b00000000 // 2 2 perform AFC only manually
#define RF69_AFC_AUTO_ON 0b00000100 // 2 2 perform AFC each time Rx mode is started
#define RF69_AFC_CLEAR 0b00000010 // 1 1 clear AFC register
#define RF69_AFC_START 0b00000001 // 0 0 start AFC
#define RADIOLIB_RF69_FEI_RUNNING 0b00000000 // 6 6 FEI status: on-going
#define RADIOLIB_RF69_FEI_DONE 0b01000000 // 6 6 done
#define RADIOLIB_RF69_FEI_START 0b00100000 // 5 5 force new FEI measurement
#define RADIOLIB_RF69_AFC_RUNNING 0b00000000 // 4 4 AFC status: on-going
#define RADIOLIB_RF69_AFC_DONE 0b00010000 // 4 4 done
#define RADIOLIB_RF69_AFC_AUTOCLEAR_OFF 0b00000000 // 3 3 AFC register autoclear disabled
#define RADIOLIB_RF69_AFC_AUTOCLEAR_ON 0b00001000 // 3 3 AFC register autoclear enabled
#define RADIOLIB_RF69_AFC_AUTO_OFF 0b00000000 // 2 2 perform AFC only manually
#define RADIOLIB_RF69_AFC_AUTO_ON 0b00000100 // 2 2 perform AFC each time Rx mode is started
#define RADIOLIB_RF69_AFC_CLEAR 0b00000010 // 1 1 clear AFC register
#define RADIOLIB_RF69_AFC_START 0b00000001 // 0 0 start AFC
// RF69_REG_RSSI_CONFIG
#define RF69_RSSI_RUNNING 0b00000000 // 1 1 RSSI status: on-going
#define RF69_RSSI_DONE 0b00000010 // 1 1 done
#define RF69_RSSI_START 0b00000001 // 0 0 start RSSI measurement
#define RADIOLIB_RF69_RSSI_RUNNING 0b00000000 // 1 1 RSSI status: on-going
#define RADIOLIB_RF69_RSSI_DONE 0b00000010 // 1 1 done
#define RADIOLIB_RF69_RSSI_START 0b00000001 // 0 0 start RSSI measurement
// RF69_REG_DIO_MAPPING_1
#define RF69_DIO0_CONT_MODE_READY 0b11000000 // 7 6
#define RF69_DIO0_CONT_PLL_LOCK 0b00000000 // 7 6
#define RF69_DIO0_CONT_SYNC_ADDRESS 0b00000000 // 7 6
#define RF69_DIO0_CONT_TIMEOUT 0b01000000 // 7 6
#define RF69_DIO0_CONT_RSSI 0b10000000 // 7 6
#define RF69_DIO0_CONT_TX_READY 0b01000000 // 7 6
#define RF69_DIO0_PACK_PLL_LOCK 0b11000000 // 7 6
#define RF69_DIO0_PACK_CRC_OK 0b00000000 // 7 6
#define RF69_DIO0_PACK_PAYLOAD_READY 0b01000000 // 7 6
#define RF69_DIO0_PACK_SYNC_ADDRESS 0b10000000 // 7 6
#define RF69_DIO0_PACK_RSSI 0b11000000 // 7 6
#define RF69_DIO0_PACK_PACKET_SENT 0b00000000 // 7 6
#define RF69_DIO0_PACK_TX_READY 0b01000000 // 7 6
#define RF69_DIO1_CONT_PLL_LOCK 0b00110000 // 5 4
#define RF69_DIO1_CONT_DCLK 0b00000000 // 5 4
#define RF69_DIO1_CONT_RX_READY 0b00010000 // 5 4
#define RF69_DIO1_CONT_SYNC_ADDRESS 0b00110000 // 5 4
#define RF69_DIO1_CONT_TX_READY 0b00010000 // 5 4
#define RF69_DIO1_PACK_FIFO_LEVEL 0b00000000 // 5 4
#define RF69_DIO1_PACK_FIFO_FULL 0b00010000 // 5 4
#define RF69_DIO1_PACK_FIFO_NOT_EMPTY 0b00100000 // 5 4
#define RF69_DIO1_PACK_PLL_LOCK 0b00110000 // 5 4
#define RF69_DIO1_PACK_TIMEOUT 0b00110000 // 5 4
#define RF69_DIO2_CONT_DATA 0b00000000 // 3 2
#define RADIOLIB_RF69_DIO0_CONT_MODE_READY 0b11000000 // 7 6
#define RADIOLIB_RF69_DIO0_CONT_PLL_LOCK 0b00000000 // 7 6
#define RADIOLIB_RF69_DIO0_CONT_SYNC_ADDRESS 0b00000000 // 7 6
#define RADIOLIB_RF69_DIO0_CONT_TIMEOUT 0b01000000 // 7 6
#define RADIOLIB_RF69_DIO0_CONT_RSSI 0b10000000 // 7 6
#define RADIOLIB_RF69_DIO0_CONT_TX_READY 0b01000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_PLL_LOCK 0b11000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_CRC_OK 0b00000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_PAYLOAD_READY 0b01000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_SYNC_ADDRESS 0b10000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_RSSI 0b11000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_PACKET_SENT 0b00000000 // 7 6
#define RADIOLIB_RF69_DIO0_PACK_TX_READY 0b01000000 // 7 6
#define RADIOLIB_RF69_DIO1_CONT_PLL_LOCK 0b00110000 // 5 4
#define RADIOLIB_RF69_DIO1_CONT_DCLK 0b00000000 // 5 4
#define RADIOLIB_RF69_DIO1_CONT_RX_READY 0b00010000 // 5 4
#define RADIOLIB_RF69_DIO1_CONT_SYNC_ADDRESS 0b00110000 // 5 4
#define RADIOLIB_RF69_DIO1_CONT_TX_READY 0b00010000 // 5 4
#define RADIOLIB_RF69_DIO1_PACK_FIFO_LEVEL 0b00000000 // 5 4
#define RADIOLIB_RF69_DIO1_PACK_FIFO_FULL 0b00010000 // 5 4
#define RADIOLIB_RF69_DIO1_PACK_FIFO_NOT_EMPTY 0b00100000 // 5 4
#define RADIOLIB_RF69_DIO1_PACK_PLL_LOCK 0b00110000 // 5 4
#define RADIOLIB_RF69_DIO1_PACK_TIMEOUT 0b00110000 // 5 4
#define RADIOLIB_RF69_DIO2_CONT_DATA 0b00000000 // 3 2
// RF69_REG_DIO_MAPPING_2
#define RF69_CLK_OUT_FXOSC 0b00000000 // 2 0 ClkOut frequency: F(XOSC)
#define RF69_CLK_OUT_FXOSC_2 0b00000001 // 2 0 F(XOSC) / 2
#define RF69_CLK_OUT_FXOSC_4 0b00000010 // 2 0 F(XOSC) / 4
#define RF69_CLK_OUT_FXOSC_8 0b00000011 // 2 0 F(XOSC) / 8
#define RF69_CLK_OUT_FXOSC_16 0b00000100 // 2 0 F(XOSC) / 16
#define RF69_CLK_OUT_FXOSC_32 0b00000101 // 2 0 F(XOSC) / 31
#define RF69_CLK_OUT_RC 0b00000110 // 2 0 RC
#define RF69_CLK_OUT_OFF 0b00000111 // 2 0 disabled (default)
#define RADIOLIB_RF69_CLK_OUT_FXOSC 0b00000000 // 2 0 ClkOut frequency: F(XOSC)
#define RADIOLIB_RF69_CLK_OUT_FXOSC_2 0b00000001 // 2 0 F(XOSC) / 2
#define RADIOLIB_RF69_CLK_OUT_FXOSC_4 0b00000010 // 2 0 F(XOSC) / 4
#define RADIOLIB_RF69_CLK_OUT_FXOSC_8 0b00000011 // 2 0 F(XOSC) / 8
#define RADIOLIB_RF69_CLK_OUT_FXOSC_16 0b00000100 // 2 0 F(XOSC) / 16
#define RADIOLIB_RF69_CLK_OUT_FXOSC_32 0b00000101 // 2 0 F(XOSC) / 31
#define RADIOLIB_RF69_CLK_OUT_RC 0b00000110 // 2 0 RC
#define RADIOLIB_RF69_CLK_OUT_OFF 0b00000111 // 2 0 disabled (default)
// RF69_REG_IRQ_FLAGS_1
#define RF69_IRQ_MODE_READY 0b10000000 // 7 7 requested mode was set
#define RF69_IRQ_RX_READY 0b01000000 // 6 6 Rx mode ready
#define RF69_IRQ_TX_READY 0b00100000 // 5 5 Tx mode ready
#define RF69_IRQ_PLL_LOCK 0b00010000 // 4 4 PLL is locked
#define RF69_IRQ_RSSI 0b00001000 // 3 3 RSSI value exceeded RssiThreshold
#define RF69_IRQ_TIMEOUT 0b00000100 // 2 2 timeout occurred
#define RF69_IRQ_AUTO_MODE 0b00000010 // 1 1 entered intermediate mode
#define RF69_SYNC_ADDRESS_MATCH 0b00000001 // 0 0 sync address detected
#define RADIOLIB_RF69_IRQ_MODE_READY 0b10000000 // 7 7 requested mode was set
#define RADIOLIB_RF69_IRQ_RX_READY 0b01000000 // 6 6 Rx mode ready
#define RADIOLIB_RF69_IRQ_TX_READY 0b00100000 // 5 5 Tx mode ready
#define RADIOLIB_RF69_IRQ_PLL_LOCK 0b00010000 // 4 4 PLL is locked
#define RADIOLIB_RF69_IRQ_RSSI 0b00001000 // 3 3 RSSI value exceeded RssiThreshold
#define RADIOLIB_RF69_IRQ_TIMEOUT 0b00000100 // 2 2 timeout occurred
#define RADIOLIB_RF69_IRQ_AUTO_MODE 0b00000010 // 1 1 entered intermediate mode
#define RADIOLIB_RF69_SYNC_ADDRESS_MATCH 0b00000001 // 0 0 sync address detected
// RF69_REG_IRQ_FLAGS_2
#define RF69_IRQ_FIFO_FULL 0b10000000 // 7 7 FIFO is full
#define RF69_IRQ_FIFO_NOT_EMPTY 0b01000000 // 6 6 FIFO contains at least 1 byte
#define RF69_IRQ_FIFO_LEVEL 0b00100000 // 5 5 FIFO contains more than FifoThreshold bytes
#define RF69_IRQ_FIFO_OVERRUN 0b00010000 // 4 4 FIFO overrun occurred
#define RF69_IRQ_PACKET_SENT 0b00001000 // 3 3 packet was sent
#define RF69_IRQ_PAYLOAD_READY 0b00000100 // 2 2 last payload byte received and CRC check passed
#define RF69_IRQ_CRC_OK 0b00000010 // 1 1 CRC check passed
#define RADIOLIB_RF69_IRQ_FIFO_FULL 0b10000000 // 7 7 FIFO is full
#define RADIOLIB_RF69_IRQ_FIFO_NOT_EMPTY 0b01000000 // 6 6 FIFO contains at least 1 byte
#define RADIOLIB_RF69_IRQ_FIFO_LEVEL 0b00100000 // 5 5 FIFO contains more than FifoThreshold bytes
#define RADIOLIB_RF69_IRQ_FIFO_OVERRUN 0b00010000 // 4 4 FIFO overrun occurred
#define RADIOLIB_RF69_IRQ_PACKET_SENT 0b00001000 // 3 3 packet was sent
#define RADIOLIB_RF69_IRQ_PAYLOAD_READY 0b00000100 // 2 2 last payload byte received and CRC check passed
#define RADIOLIB_RF69_IRQ_CRC_OK 0b00000010 // 1 1 CRC check passed
// RF69_REG_RSSI_THRESH
#define RF69_RSSI_THRESHOLD 0xE4 // 7 0 RSSI threshold level (2 dB by default)
#define RADIOLIB_RF69_RSSI_THRESHOLD 0xE4 // 7 0 RSSI threshold level (2 dB by default)
// RF69_REG_RX_TIMEOUT_1
#define RF69_TIMEOUT_RX_START_OFF 0x00 // 7 0 RSSI interrupt timeout disabled (default)
#define RF69_TIMEOUT_RX_START 0xFF // 7 0 timeout will occur if RSSI interrupt is not received
#define RADIOLIB_RF69_TIMEOUT_RX_START_OFF 0x00 // 7 0 RSSI interrupt timeout disabled (default)
#define RADIOLIB_RF69_TIMEOUT_RX_START 0xFF // 7 0 timeout will occur if RSSI interrupt is not received
// RF69_REG_RX_TIMEOUT_2
#define RF69_TIMEOUT_RSSI_THRESH_OFF 0x00 // 7 0 PayloadReady interrupt timeout disabled (default)
#define RF69_TIMEOUT_RSSI_THRESH 0xFF // 7 0 timeout will occur if PayloadReady interrupt is not received
#define RADIOLIB_RF69_TIMEOUT_RSSI_THRESH_OFF 0x00 // 7 0 PayloadReady interrupt timeout disabled (default)
#define RADIOLIB_RF69_TIMEOUT_RSSI_THRESH 0xFF // 7 0 timeout will occur if PayloadReady interrupt is not received
// RF69_REG_PREAMBLE_MSB + REG_PREAMBLE_MSB
#define RF69_PREAMBLE_MSB 0x00 // 7 0 2-byte preamble size value
#define RF69_PREAMBLE_LSB 0x03 // 7 0
#define RADIOLIB_RF69_PREAMBLE_MSB 0x00 // 7 0 2-byte preamble size value
#define RADIOLIB_RF69_PREAMBLE_LSB 0x03 // 7 0
// RF69_REG_SYNC_CONFIG
#define RF69_SYNC_OFF 0b00000000 // 7 7 sync word detection off
#define RF69_SYNC_ON 0b10000000 // 7 7 sync word detection on (default)
#define RF69_FIFO_FILL_CONDITION_SYNC 0b00000000 // 6 6 FIFO fill condition: on SyncAddress interrupt (default)
#define RF69_FIFO_FILL_CONDITION 0b01000000 // 6 6 as long as the bit is set
#define RF69_SYNC_SIZE 0b00001000 // 5 3 size of sync word: SyncSize + 1 bytes
#define RF69_SYNC_TOL 0b00000000 // 2 0 number of tolerated errors in sync word
#define RADIOLIB_RF69_SYNC_OFF 0b00000000 // 7 7 sync word detection off
#define RADIOLIB_RF69_SYNC_ON 0b10000000 // 7 7 sync word detection on (default)
#define RADIOLIB_RF69_FIFO_FILL_CONDITION_SYNC 0b00000000 // 6 6 FIFO fill condition: on SyncAddress interrupt (default)
#define RADIOLIB_RF69_FIFO_FILL_CONDITION 0b01000000 // 6 6 as long as the bit is set
#define RADIOLIB_RF69_SYNC_SIZE 0b00001000 // 5 3 size of sync word: SyncSize + 1 bytes
#define RADIOLIB_RF69_SYNC_TOL 0b00000000 // 2 0 number of tolerated errors in sync word
// RF69_REG_SYNC_VALUE_1 - SYNC_VALUE_8
#define RF69_SYNC_BYTE_1 0x01 // 7 0 sync word: 1st byte (MSB)
#define RF69_SYNC_BYTE_2 0x01 // 7 0 2nd byte
#define RF69_SYNC_BYTE_3 0x01 // 7 0 3rd byte
#define RF69_SYNC_BYTE_4 0x01 // 7 0 4th byte
#define RF69_SYNC_BYTE_5 0x01 // 7 0 5th byte
#define RF69_SYNC_BYTE_6 0x01 // 7 0 6th byte
#define RF69_SYNC_BYTE_7 0x01 // 7 0 7th byte
#define RF69_SYNC_BYTE_8 0x01 // 7 0 8th byte (LSB)
#define RADIOLIB_RF69_SYNC_BYTE_1 0x01 // 7 0 sync word: 1st byte (MSB)
#define RADIOLIB_RF69_SYNC_BYTE_2 0x01 // 7 0 2nd byte
#define RADIOLIB_RF69_SYNC_BYTE_3 0x01 // 7 0 3rd byte
#define RADIOLIB_RF69_SYNC_BYTE_4 0x01 // 7 0 4th byte
#define RADIOLIB_RF69_SYNC_BYTE_5 0x01 // 7 0 5th byte
#define RADIOLIB_RF69_SYNC_BYTE_6 0x01 // 7 0 6th byte
#define RADIOLIB_RF69_SYNC_BYTE_7 0x01 // 7 0 7th byte
#define RADIOLIB_RF69_SYNC_BYTE_8 0x01 // 7 0 8th byte (LSB)
// RF69_REG_PACKET_CONFIG_1
#define RF69_PACKET_FORMAT_FIXED 0b00000000 // 7 7 fixed packet length (default)
#define RF69_PACKET_FORMAT_VARIABLE 0b10000000 // 7 7 variable packet length
#define RF69_DC_FREE_NONE 0b00000000 // 6 5 DC-free encoding: none (default)
#define RF69_DC_FREE_MANCHESTER 0b00100000 // 6 5 Manchester
#define RF69_DC_FREE_WHITENING 0b01000000 // 6 5 Whitening
#define RF69_CRC_OFF 0b00000000 // 4 4 CRC disabled
#define RF69_CRC_ON 0b00010000 // 4 4 CRC enabled (default)
#define RF69_CRC_AUTOCLEAR_ON 0b00000000 // 3 3 discard packet when CRC check fails (default)
#define RF69_CRC_AUTOCLEAR_OFF 0b00001000 // 3 3 keep packet when CRC check fails
#define RF69_ADDRESS_FILTERING_OFF 0b00000000 // 2 1 address filtering: none (default)
#define RF69_ADDRESS_FILTERING_NODE 0b00000010 // 2 1 node
#define RF69_ADDRESS_FILTERING_NODE_BROADCAST 0b00000100 // 2 1 node or broadcast
#define RADIOLIB_RF69_PACKET_FORMAT_FIXED 0b00000000 // 7 7 fixed packet length (default)
#define RADIOLIB_RF69_PACKET_FORMAT_VARIABLE 0b10000000 // 7 7 variable packet length
#define RADIOLIB_RF69_DC_FREE_NONE 0b00000000 // 6 5 DC-free encoding: none (default)
#define RADIOLIB_RF69_DC_FREE_MANCHESTER 0b00100000 // 6 5 Manchester
#define RADIOLIB_RF69_DC_FREE_WHITENING 0b01000000 // 6 5 Whitening
#define RADIOLIB_RF69_CRC_OFF 0b00000000 // 4 4 CRC disabled
#define RADIOLIB_RF69_CRC_ON 0b00010000 // 4 4 CRC enabled (default)
#define RADIOLIB_RF69_CRC_AUTOCLEAR_ON 0b00000000 // 3 3 discard packet when CRC check fails (default)
#define RADIOLIB_RF69_CRC_AUTOCLEAR_OFF 0b00001000 // 3 3 keep packet when CRC check fails
#define RADIOLIB_RF69_ADDRESS_FILTERING_OFF 0b00000000 // 2 1 address filtering: none (default)
#define RADIOLIB_RF69_ADDRESS_FILTERING_NODE 0b00000010 // 2 1 node
#define RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST 0b00000100 // 2 1 node or broadcast
// RF69_REG_PAYLOAD_LENGTH
#define RF69_PAYLOAD_LENGTH 0xFF // 7 0 payload length
#define RADIOLIB_RF69_PAYLOAD_LENGTH 0xFF // 7 0 payload length
// RF69_REG_AUTO_MODES
#define RF69_ENTER_COND_NONE 0b00000000 // 7 5 condition for entering intermediate mode: none, AutoModes disabled (default)
#define RF69_ENTER_COND_FIFO_NOT_EMPTY 0b00100000 // 7 5 FifoNotEmpty rising edge
#define RF69_ENTER_COND_FIFO_LEVEL 0b01000000 // 7 5 FifoLevel rising edge
#define RF69_ENTER_COND_CRC_OK 0b01100000 // 7 5 CrcOk rising edge
#define RF69_ENTER_COND_PAYLOAD_READY 0b10000000 // 7 5 PayloadReady rising edge
#define RF69_ENTER_COND_SYNC_ADDRESS 0b10100000 // 7 5 SyncAddress rising edge
#define RF69_ENTER_COND_PACKET_SENT 0b11000000 // 7 5 PacketSent rising edge
#define RF69_ENTER_COND_FIFO_EMPTY 0b11100000 // 7 5 FifoNotEmpty falling edge
#define RF69_EXIT_COND_NONE 0b00000000 // 4 2 condition for exiting intermediate mode: none, AutoModes disabled (default)
#define RF69_EXIT_COND_FIFO_EMPTY 0b00100000 // 4 2 FifoNotEmpty falling edge
#define RF69_EXIT_COND_FIFO_LEVEL 0b01000000 // 4 2 FifoLevel rising edge
#define RF69_EXIT_COND_CRC_OK 0b01100000 // 4 2 CrcOk rising edge
#define RF69_EXIT_COND_PAYLOAD_READY 0b10000000 // 4 2 PayloadReady rising edge
#define RF69_EXIT_COND_SYNC_ADDRESS 0b10100000 // 4 2 SyncAddress rising edge
#define RF69_EXIT_COND_PACKET_SENT 0b11000000 // 4 2 PacketSent rising edge
#define RF69_EXIT_COND_TIMEOUT 0b11100000 // 4 2 timeout rising edge
#define RF69_INTER_MODE_SLEEP 0b00000000 // 1 0 intermediate mode: sleep (default)
#define RF69_INTER_MODE_STANDBY 0b00000001 // 1 0 standby
#define RF69_INTER_MODE_RX 0b00000010 // 1 0 Rx
#define RF69_INTER_MODE_TX 0b00000011 // 1 0 Tx
#define RADIOLIB_RF69_ENTER_COND_NONE 0b00000000 // 7 5 condition for entering intermediate mode: none, AutoModes disabled (default)
#define RADIOLIB_RF69_ENTER_COND_FIFO_NOT_EMPTY 0b00100000 // 7 5 FifoNotEmpty rising edge
#define RADIOLIB_RF69_ENTER_COND_FIFO_LEVEL 0b01000000 // 7 5 FifoLevel rising edge
#define RADIOLIB_RF69_ENTER_COND_CRC_OK 0b01100000 // 7 5 CrcOk rising edge
#define RADIOLIB_RF69_ENTER_COND_PAYLOAD_READY 0b10000000 // 7 5 PayloadReady rising edge
#define RADIOLIB_RF69_ENTER_COND_SYNC_ADDRESS 0b10100000 // 7 5 SyncAddress rising edge
#define RADIOLIB_RF69_ENTER_COND_PACKET_SENT 0b11000000 // 7 5 PacketSent rising edge
#define RADIOLIB_RF69_ENTER_COND_FIFO_EMPTY 0b11100000 // 7 5 FifoNotEmpty falling edge
#define RADIOLIB_RF69_EXIT_COND_NONE 0b00000000 // 4 2 condition for exiting intermediate mode: none, AutoModes disabled (default)
#define RADIOLIB_RF69_EXIT_COND_FIFO_EMPTY 0b00100000 // 4 2 FifoNotEmpty falling edge
#define RADIOLIB_RF69_EXIT_COND_FIFO_LEVEL 0b01000000 // 4 2 FifoLevel rising edge
#define RADIOLIB_RF69_EXIT_COND_CRC_OK 0b01100000 // 4 2 CrcOk rising edge
#define RADIOLIB_RF69_EXIT_COND_PAYLOAD_READY 0b10000000 // 4 2 PayloadReady rising edge
#define RADIOLIB_RF69_EXIT_COND_SYNC_ADDRESS 0b10100000 // 4 2 SyncAddress rising edge
#define RADIOLIB_RF69_EXIT_COND_PACKET_SENT 0b11000000 // 4 2 PacketSent rising edge
#define RADIOLIB_RF69_EXIT_COND_TIMEOUT 0b11100000 // 4 2 timeout rising edge
#define RADIOLIB_RF69_INTER_MODE_SLEEP 0b00000000 // 1 0 intermediate mode: sleep (default)
#define RADIOLIB_RF69_INTER_MODE_STANDBY 0b00000001 // 1 0 standby
#define RADIOLIB_RF69_INTER_MODE_RX 0b00000010 // 1 0 Rx
#define RADIOLIB_RF69_INTER_MODE_TX 0b00000011 // 1 0 Tx
// RF69_REG_FIFO_THRESH
#define RF69_TX_START_CONDITION_FIFO_LEVEL 0b00000000 // 7 7 packet transmission start condition: FifoLevel
#define RF69_TX_START_CONDITION_FIFO_NOT_EMPTY 0b10000000 // 7 7 FifoNotEmpty (default)
#define RF69_FIFO_THRESHOLD 0b00001111 // 6 0 default threshold to trigger FifoLevel interrupt
#define RADIOLIB_RF69_TX_START_CONDITION_FIFO_LEVEL 0b00000000 // 7 7 packet transmission start condition: FifoLevel
#define RADIOLIB_RF69_TX_START_CONDITION_FIFO_NOT_EMPTY 0b10000000 // 7 7 FifoNotEmpty (default)
#define RADIOLIB_RF69_FIFO_THRESHOLD 0b00001111 // 6 0 default threshold to trigger FifoLevel interrupt
// RF69_REG_PACKET_CONFIG_2
#define RF69_INTER_PACKET_RX_DELAY 0b00000000 // 7 4 delay between FIFO empty and start of new RSSI phase
#define RF69_RESTART_RX 0b00000100 // 2 2 force receiver into wait mode
#define RF69_AUTO_RX_RESTART_OFF 0b00000000 // 1 1 auto Rx restart disabled
#define RF69_AUTO_RX_RESTART_ON 0b00000010 // 1 1 auto Rx restart enabled (default)
#define RF69_AES_OFF 0b00000000 // 0 0 AES encryption disabled (default)
#define RF69_AES_ON 0b00000001 // 0 0 AES encryption enabled, payload size limited to 66 bytes
#define RADIOLIB_RF69_INTER_PACKET_RX_DELAY 0b00000000 // 7 4 delay between FIFO empty and start of new RSSI phase
#define RADIOLIB_RF69_RESTART_RX 0b00000100 // 2 2 force receiver into wait mode
#define RADIOLIB_RF69_AUTO_RX_RESTART_OFF 0b00000000 // 1 1 auto Rx restart disabled
#define RADIOLIB_RF69_AUTO_RX_RESTART_ON 0b00000010 // 1 1 auto Rx restart enabled (default)
#define RADIOLIB_RF69_AES_OFF 0b00000000 // 0 0 AES encryption disabled (default)
#define RADIOLIB_RF69_AES_ON 0b00000001 // 0 0 AES encryption enabled, payload size limited to 66 bytes
// RF69_REG_TEST_LNA
#define RF69_TEST_LNA_BOOST_NORMAL 0x1B // 7 0
#define RF69_TEST_LNA_BOOST_HIGH 0x2D // 7 0
#define RADIOLIB_RF69_TEST_LNA_BOOST_NORMAL 0x1B // 7 0
#define RADIOLIB_RF69_TEST_LNA_BOOST_HIGH 0x2D // 7 0
// RF69_REG_TEMP_1
#define RF69_TEMP_MEAS_START 0b00001000 // 3 3 trigger temperature measurement
#define RF69_TEMP_MEAS_RUNNING 0b00000100 // 2 2 temperature measurement status: on-going
#define RF69_TEMP_MEAS_DONE 0b00000000 // 2 2 done
#define RADIOLIB_RF69_TEMP_MEAS_START 0b00001000 // 3 3 trigger temperature measurement
#define RADIOLIB_RF69_TEMP_MEAS_RUNNING 0b00000100 // 2 2 temperature measurement status: on-going
#define RADIOLIB_RF69_TEMP_MEAS_DONE 0b00000000 // 2 2 done
// RF69_REG_TEST_DAGC
#define RF69_CONTINUOUS_DAGC_NORMAL 0x00 // 7 0 fading margin improvement: normal mode
#define RF69_CONTINUOUS_DAGC_LOW_BETA_ON 0x20 // 7 0 improved mode for AfcLowBetaOn
#define RF69_CONTINUOUS_DAGC_LOW_BETA_OFF 0x30 // 7 0 improved mode for AfcLowBetaOff (default)
#define RADIOLIB_RF69_CONTINUOUS_DAGC_NORMAL 0x00 // 7 0 fading margin improvement: normal mode
#define RADIOLIB_RF69_CONTINUOUS_DAGC_LOW_BETA_ON 0x20 // 7 0 improved mode for AfcLowBetaOn
#define RADIOLIB_RF69_CONTINUOUS_DAGC_LOW_BETA_OFF 0x30 // 7 0 improved mode for AfcLowBetaOff (default)
// RF69_REG_TEST_PA1
#define RF69_PA1_NORMAL 0x55 // 7 0 PA_BOOST: none
#define RF69_PA1_20_DBM 0x5D // 7 0 +20 dBm
#define RADIOLIB_RF69_PA1_NORMAL 0x55 // 7 0 PA_BOOST: none
#define RADIOLIB_RF69_PA1_20_DBM 0x5D // 7 0 +20 dBm
// RF69_REG_TEST_PA2
#define RF69_PA2_NORMAL 0x70 // 7 0 PA_BOOST: none
#define RF69_PA2_20_DBM 0x7C // 7 0 +20 dBm
#define RADIOLIB_RF69_PA2_NORMAL 0x70 // 7 0 PA_BOOST: none
#define RADIOLIB_RF69_PA2_20_DBM 0x7C // 7 0 +20 dBm
/*!
\class RF69
@ -452,6 +452,8 @@ class RF69: public PhysicalLayer {
*/
RF69(Module* module);
Module* getMod();
// basic methods
/*!
@ -764,7 +766,7 @@ class RF69: public PhysicalLayer {
\returns \ref status_codes
*/
int16_t fixedPacketLengthMode(uint8_t len = RF69_MAX_PACKET_LENGTH);
int16_t fixedPacketLengthMode(uint8_t len = RADIOLIB_RF69_MAX_PACKET_LENGTH);
/*!
\brief Set modem in variable packet length mode.
@ -773,7 +775,7 @@ class RF69: public PhysicalLayer {
\returns \ref status_codes
*/
int16_t variablePacketLengthMode(uint8_t maxLen = RF69_MAX_PACKET_LENGTH);
int16_t variablePacketLengthMode(uint8_t maxLen = RADIOLIB_RF69_MAX_PACKET_LENGTH);
/*!
\brief Enable sync word filtering and generation.
@ -901,7 +903,7 @@ class RF69: public PhysicalLayer {
size_t _packetLength = 0;
bool _packetLengthQueried = false;
uint8_t _packetLengthConfig = RF69_PACKET_FORMAT_VARIABLE;
uint8_t _packetLengthConfig = RADIOLIB_RF69_PACKET_FORMAT_VARIABLE;
bool _promiscuous = false;