forks/RadioLibSmol
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[RF69] Update to 5.0.0

Browse source
This commit is contained in:
jgromes 2021-11-14 11:40:31 +01:00
parent e775bfc22e
commit 008187b0b1
11 changed files with 596 additions and 590 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
examples/RF69/RF69_Receive/RF69_Receive.ino
View file

@ -35,7 +35,7 @@ void setup() {
// initialize RF69 with default settings // initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... ")); Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin(); int state = radio.begin();
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code ")); Serial.print(F("failed, code "));
@ -57,7 +57,7 @@ void loop() {
int state = radio.receive(byteArr, 8); int state = radio.receive(byteArr, 8);
*/ */
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
// packet was successfully received // packet was successfully received
Serial.println(F("success!")); Serial.println(F("success!"));
@ -71,11 +71,11 @@ void loop() {
Serial.print(radio.getRSSI()); Serial.print(radio.getRSSI());
Serial.println(F(" dBm")); Serial.println(F(" dBm"));
} else if (state == ERR_RX_TIMEOUT) { } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
// timeout occurred while waiting for a packet // timeout occurred while waiting for a packet
Serial.println(F("timeout!")); Serial.println(F("timeout!"));
} else if (state == ERR_CRC_MISMATCH) { } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
// packet was received, but is malformed // packet was received, but is malformed
Serial.println(F("CRC error!")); Serial.println(F("CRC error!"));

8
examples/RF69/RF69_Receive_AES/RF69_Receive_AES.ino
View file

@ -31,7 +31,7 @@ void setup() {
// initialize RF69 with default settings // initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... ")); Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin(); int state = radio.begin();
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code ")); Serial.print(F("failed, code "));
@ -67,7 +67,7 @@ void loop() {
int state = radio.receive(byteArr, 8); int state = radio.receive(byteArr, 8);
*/ */
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
// packet was successfully received // packet was successfully received
Serial.println(F("success!")); Serial.println(F("success!"));
@ -75,11 +75,11 @@ void loop() {
Serial.print(F("[RF69] Data:\t\t")); Serial.print(F("[RF69] Data:\t\t"));
Serial.println(str); Serial.println(str);
} else if (state == ERR_RX_TIMEOUT) { } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
// timeout occurred while waiting for a packet // timeout occurred while waiting for a packet
Serial.println(F("timeout!")); Serial.println(F("timeout!"));
} else if (state == ERR_CRC_MISMATCH) { } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
// packet was received, but is malformed // packet was received, but is malformed
Serial.println(F("CRC error!")); Serial.println(F("CRC error!"));

14
examples/RF69/RF69_Receive_Address/RF69_Receive_Address.ino
View file

@ -33,7 +33,7 @@ void setup() {
// initialize RF69 with default settings // initialize RF69 with default settings
Serial.print(F("[RF69] Initializing ... ")); Serial.print(F("[RF69] Initializing ... "));
int state = radio.begin(); int state = radio.begin();
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code ")); Serial.print(F("failed, code "));
@ -46,7 +46,7 @@ void setup() {
// address filtering (node address only) // address filtering (node address only)
Serial.print(F("[RF69] Setting node address ... ")); Serial.print(F("[RF69] Setting node address ... "));
state = radio.setNodeAddress(0x02); state = radio.setNodeAddress(0x02);
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code ")); Serial.print(F("failed, code "));
@ -59,7 +59,7 @@ void setup() {
// address filtering (node or broadcast address) // address filtering (node or broadcast address)
Serial.print(F("[RF69] Setting broadcast address ... ")); Serial.print(F("[RF69] Setting broadcast address ... "));
state = radio.setBroadcastAddress(0xFF); state = radio.setBroadcastAddress(0xFF);
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code ")); Serial.print(F("failed, code "));
@ -73,7 +73,7 @@ void setup() {
/* /*
Serial.print(F("[RF69] Disabling address filtering ... ")); Serial.print(F("[RF69] Disabling address filtering ... "));
state == radio.disableAddressFiltering(); state == radio.disableAddressFiltering();
if(state == ERR_NONE) { if(state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code ")); Serial.print(F("failed, code "));
@ -96,7 +96,7 @@ void loop() {
int state = radio.receive(byteArr, 8); int state = radio.receive(byteArr, 8);
*/ */
if (state == ERR_NONE) { if (state == RADIOLIB_ERR_NONE) {
// packet was successfully received // packet was successfully received
Serial.println(F("success!")); Serial.println(F("success!"));
@ -104,11 +104,11 @@ void loop() {
Serial.print(F("[RF69] Data:\t\t")); Serial.print(F("[RF69] Data:\t\t"));
Serial.println(str); Serial.println(str);
} else if (state == ERR_RX_TIMEOUT) { } else if (state == RADIOLIB_ERR_RX_TIMEOUT) {
// timeout occurred while waiting for a packet // timeout occurred while waiting for a packet
Serial.println(F("timeout!")); Serial.println(F("timeout!"));
} else if (state == ERR_CRC_MISMATCH) { } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
// packet was received, but is malformed // packet was received, but is malformed
Serial.println(F("CRC error!")); Serial.println(F("CRC error!"));

8
examples/RF69/RF69_Receive_Interrupt/RF69_Receive_Interrupt.ino
View file

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

20
examples/RF69/RF69_Settings/RF69_Settings.ino
View file

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

8
examples/RF69/RF69_Transmit/RF69_Transmit.ino
View file

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

6
examples/RF69/RF69_Transmit_AES/RF69_Transmit_AES.ino
View file

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

12
examples/RF69/RF69_Transmit_Address/RF69_Transmit_Address.ino
View file

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

8
examples/RF69/RF69_Transmit_Interrupt/RF69_Transmit_Interrupt.ino
View file

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

418
src/modules/RF69/RF69.cpp
View file

@ -1,14 +1,18 @@
#include "RF69.h" #include "RF69.h"
#if !defined(RADIOLIB_EXCLUDE_RF69) #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; _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) { int16_t RF69::begin(float freq, float br, float freqDev, float rxBw, int8_t power, uint8_t preambleLen) {
// set module properties // set module properties
_mod->init(RADIOLIB_USE_SPI); _mod->init();
Module::pinMode(_mod->getIrq(), INPUT); _mod->pinMode(_mod->getIrq(), INPUT);
// try to find the RF69 chip // try to find the RF69 chip
uint8_t i = 0; 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 // check version register
int16_t version = getChipVersion(); int16_t version = getChipVersion();
if(version == RF69_CHIP_VERSION) { if(version == RADIOLIB_RF69_CHIP_VERSION) {
flagFound = true; flagFound = true;
} else { } else {
#ifdef RADIOLIB_DEBUG #if defined(RADIOLIB_DEBUG)
RADIOLIB_DEBUG_PRINT(F("RF69 not found! (")); RADIOLIB_DEBUG_PRINT(F("RF69 not found! ("));
RADIOLIB_DEBUG_PRINT(i + 1); 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]; char buffHex[7];
sprintf(buffHex, "0x%04X", version); 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_PRINT(F(", expected 0x0024"));
RADIOLIB_DEBUG_PRINTLN(); RADIOLIB_DEBUG_PRINTLN();
#endif #endif
Module::delay(10); _mod->delay(10);
i++; i++;
} }
} }
if(!flagFound) { if(!flagFound) {
RADIOLIB_DEBUG_PRINTLN(F("No RF69 found!")); RADIOLIB_DEBUG_PRINTLN(F("No RF69 found!"));
_mod->term(RADIOLIB_USE_SPI); _mod->term();
return(ERR_CHIP_NOT_FOUND); return(RADIOLIB_ERR_CHIP_NOT_FOUND);
} else { } else {
RADIOLIB_DEBUG_PRINTLN(F("M\tRF69")); 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() { void RF69::reset() {
Module::pinMode(_mod->getRst(), OUTPUT); _mod->pinMode(_mod->getRst(), OUTPUT);
Module::digitalWrite(_mod->getRst(), HIGH); _mod->digitalWrite(_mod->getRst(), HIGH);
Module::delay(1); _mod->delay(1);
Module::digitalWrite(_mod->getRst(), LOW); _mod->digitalWrite(_mod->getRst(), LOW);
Module::delay(10); _mod->delay(10);
} }
int16_t RF69::transmit(uint8_t* data, size_t len, uint8_t addr) { 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); RADIOLIB_ASSERT(state);
// wait for transmission end or timeout // wait for transmission end or timeout
uint32_t start = Module::micros(); uint32_t start = _mod->micros();
while(!Module::digitalRead(_mod->getIrq())) { while(!_mod->digitalRead(_mod->getIrq())) {
Module::yield(); _mod->yield();
if(Module::micros() - start > timeout) { if(_mod->micros() - start > timeout) {
standby(); standby();
clearIRQFlags(); 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 // clear interrupt flags
clearIRQFlags(); clearIRQFlags();
return(ERR_NONE); return(RADIOLIB_ERR_NONE);
} }
int16_t RF69::receive(uint8_t* data, size_t len) { int16_t RF69::receive(uint8_t* data, size_t len) {
// calculate timeout (500 ms + 400 full 64-byte packets at current bit rate) // 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 // start reception
int16_t state = startReceive(); int16_t state = startReceive();
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// wait for packet reception or timeout // wait for packet reception or timeout
uint32_t start = Module::micros(); uint32_t start = _mod->micros();
while(!Module::digitalRead(_mod->getIrq())) { while(!_mod->digitalRead(_mod->getIrq())) {
Module::yield(); _mod->yield();
if(Module::micros() - start > timeout) { if(_mod->micros() - start > timeout) {
standby(); standby();
clearIRQFlags(); clearIRQFlags();
return(ERR_RX_TIMEOUT); return(RADIOLIB_ERR_RX_TIMEOUT);
} }
} }
@ -165,7 +169,7 @@ int16_t RF69::sleep() {
_mod->setRfSwitchState(LOW, LOW); _mod->setRfSwitchState(LOW, LOW);
// set module to sleep // set module to sleep
return(setMode(RF69_SLEEP)); return(setMode(RADIOLIB_RF69_SLEEP));
} }
int16_t RF69::standby() { int16_t RF69::standby() {
@ -173,7 +177,7 @@ int16_t RF69::standby() {
_mod->setRfSwitchState(LOW, LOW); _mod->setRfSwitchState(LOW, LOW);
// set module to standby // set module to standby
return(setMode(RF69_STANDBY)); return(setMode(RADIOLIB_RF69_STANDBY));
} }
int16_t RF69::transmitDirect(uint32_t frf) { 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) // user requested to start transmitting immediately (required for RTTY)
if(frf != 0) { if(frf != 0) {
_mod->SPIwriteRegister(RF69_REG_FRF_MSB, (frf & 0xFF0000) >> 16); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MSB, (frf & 0xFF0000) >> 16);
_mod->SPIwriteRegister(RF69_REG_FRF_MID, (frf & 0x00FF00) >> 8); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MID, (frf & 0x00FF00) >> 8);
_mod->SPIwriteRegister(RF69_REG_FRF_LSB, frf & 0x0000FF); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_LSB, frf & 0x0000FF);
return(setMode(RF69_TX)); return(setMode(RADIOLIB_RF69_TX));
} }
// activate direct mode // activate direct mode
@ -194,7 +198,7 @@ int16_t RF69::transmitDirect(uint32_t frf) {
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// start transmitting // start transmitting
return(setMode(RF69_TX)); return(setMode(RADIOLIB_RF69_TX));
} }
int16_t RF69::receiveDirect() { int16_t RF69::receiveDirect() {
@ -206,47 +210,47 @@ int16_t RF69::receiveDirect() {
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// start receiving // start receiving
return(setMode(RF69_RX)); return(setMode(RADIOLIB_RF69_RX));
} }
int16_t RF69::directMode() { int16_t RF69::directMode() {
// set mode to standby // set mode to standby
int16_t state = setMode(RF69_STANDBY); int16_t state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// set DIO mapping // 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); RADIOLIB_ASSERT(state);
// set continuous mode // 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() { 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) { 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() { 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() { 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() { int16_t RF69::startReceive() {
// set mode to standby // set mode to standby
int16_t state = setMode(RF69_STANDBY); int16_t state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// set RX timeouts and DIO pin mapping // 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(RADIOLIB_RF69_REG_DIO_MAPPING_1, RADIOLIB_RF69_DIO0_PACK_PAYLOAD_READY, 7, 4);
state |= _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_1, RF69_TIMEOUT_RX_START); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_1, RADIOLIB_RF69_TIMEOUT_RX_START);
state |= _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_2, RF69_TIMEOUT_RSSI_THRESH); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_2, RADIOLIB_RF69_TIMEOUT_RSSI_THRESH);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// clear interrupt flags // clear interrupt flags
@ -256,75 +260,75 @@ int16_t RF69::startReceive() {
_mod->setRfSwitchState(HIGH, LOW); _mod->setRfSwitchState(HIGH, LOW);
// set mode to receive // set mode to receive
state = _mod->SPIsetRegValue(RF69_REG_OCP, RF69_OCP_ON | RF69_OCP_TRIM); state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_OCP, RADIOLIB_RF69_OCP_ON | RADIOLIB_RF69_OCP_TRIM);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA1, RF69_PA1_NORMAL); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA1, RADIOLIB_RF69_PA1_NORMAL);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA2, RF69_PA2_NORMAL); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA2, RADIOLIB_RF69_PA2_NORMAL);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
state = setMode(RF69_RX); state = setMode(RADIOLIB_RF69_RX);
return(state); return(state);
} }
void RF69::setDio0Action(void (*func)(void)) { 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() { 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)) { void RF69::setDio1Action(void (*func)(void)) {
if(_mod->getGpio() == RADIOLIB_NC) { if(_mod->getGpio() == RADIOLIB_NC) {
return; return;
} }
Module::pinMode(_mod->getGpio(), INPUT); _mod->pinMode(_mod->getGpio(), INPUT);
Module::attachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getGpio()), func, RISING); _mod->attachInterrupt(RADIOLIB_DIGITAL_PIN_TO_INTERRUPT(_mod->getGpio()), func, RISING);
} }
void RF69::clearDio1Action() { void RF69::clearDio1Action() {
if(_mod->getGpio() == RADIOLIB_NC) { if(_mod->getGpio() == RADIOLIB_NC) {
return; 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) { int16_t RF69::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
// check packet length // check packet length
if(len > RF69_MAX_PACKET_LENGTH) { if(len > RADIOLIB_RF69_MAX_PACKET_LENGTH) {
return(ERR_PACKET_TOO_LONG); return(RADIOLIB_ERR_PACKET_TOO_LONG);
} }
// set mode to standby // set mode to standby
int16_t state = setMode(RF69_STANDBY); int16_t state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// set DIO pin mapping // 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); RADIOLIB_ASSERT(state);
// clear interrupt flags // clear interrupt flags
clearIRQFlags(); clearIRQFlags();
// optionally write packet length // optionally write packet length
if (_packetLengthConfig == RF69_PACKET_FORMAT_VARIABLE) { if (_packetLengthConfig == RADIOLIB_RF69_PACKET_FORMAT_VARIABLE) {
_mod->SPIwriteRegister(RF69_REG_FIFO, len); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FIFO, len);
} }
// check address filtering // check address filtering
uint8_t filter = _mod->SPIgetRegValue(RF69_REG_PACKET_CONFIG_1, 2, 1); uint8_t filter = _mod->SPIgetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, 2, 1);
if((filter == RF69_ADDRESS_FILTERING_NODE) || (filter == RF69_ADDRESS_FILTERING_NODE_BROADCAST)) { if((filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE) || (filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST)) {
_mod->SPIwriteRegister(RF69_REG_FIFO, addr); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FIFO, addr);
} }
// write packet to FIFO // write packet to FIFO
_mod->SPIwriteRegisterBurst(RF69_REG_FIFO, data, len); _mod->SPIwriteRegisterBurst(RADIOLIB_RF69_REG_FIFO, data, len);
// enable +20 dBm operation // enable +20 dBm operation
if(_power > 17) { if(_power > 17) {
state = _mod->SPIsetRegValue(RF69_REG_OCP, RF69_OCP_OFF | 0x0F); state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_OCP, RADIOLIB_RF69_OCP_OFF | 0x0F);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA1, RF69_PA1_20_DBM); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA1, RADIOLIB_RF69_PA1_20_DBM);
state |= _mod->SPIsetRegValue(RF69_REG_TEST_PA2, RF69_PA2_20_DBM); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_TEST_PA2, RADIOLIB_RF69_PA2_20_DBM);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
} }
@ -332,7 +336,7 @@ int16_t RF69::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
_mod->setRfSwitchState(LOW, HIGH); _mod->setRfSwitchState(LOW, HIGH);
// set mode to transmit // set mode to transmit
state = setMode(RF69_TX); state = setMode(RADIOLIB_RF69_TX);
return(state); return(state);
} }
@ -344,18 +348,18 @@ int16_t RF69::readData(uint8_t* data, size_t len) {
// get packet length // get packet length
size_t length = len; size_t length = len;
if(len == RF69_MAX_PACKET_LENGTH) { if(len == RADIOLIB_RF69_MAX_PACKET_LENGTH) {
length = getPacketLength(); length = getPacketLength();
} }
// check address filtering // check address filtering
uint8_t filter = _mod->SPIgetRegValue(RF69_REG_PACKET_CONFIG_1, 2, 1); uint8_t filter = _mod->SPIgetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_1, 2, 1);
if((filter == RF69_ADDRESS_FILTERING_NODE) || (filter == RF69_ADDRESS_FILTERING_NODE_BROADCAST)) { if((filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE) || (filter == RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST)) {
_mod->SPIreadRegister(RF69_REG_FIFO); _mod->SPIreadRegister(RADIOLIB_RF69_REG_FIFO);
} }
// read packet data // 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 // clear internal flag so getPacketLength can return the new packet length
_packetLengthQueried = false; _packetLengthQueried = false;
@ -363,18 +367,18 @@ int16_t RF69::readData(uint8_t* data, size_t len) {
// clear interrupt flags // clear interrupt flags
clearIRQFlags(); clearIRQFlags();
return(ERR_NONE); return(RADIOLIB_ERR_NONE);
} }
int16_t RF69::setOOK(bool enableOOK) { int16_t RF69::setOOK(bool enableOOK) {
// set OOK and if successful, save the new setting // set OOK and if successful, save the new setting
int16_t state = ERR_NONE; int16_t state = RADIOLIB_ERR_NONE;
if(enableOOK) { 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 { } 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; _ook = enableOOK;
} }
@ -382,10 +386,10 @@ int16_t RF69::setOOK(bool enableOOK) {
} }
int16_t RF69::setOokThresholdType(uint8_t type) { int16_t RF69::setOokThresholdType(uint8_t type) {
if((type != RF69_OOK_THRESH_FIXED) && (type != RF69_OOK_THRESH_PEAK) && (type != RF69_OOK_THRESH_AVERAGE)) { if((type != RADIOLIB_RF69_OOK_THRESH_FIXED) && (type != RADIOLIB_RF69_OOK_THRESH_PEAK) && (type != RADIOLIB_RF69_OOK_THRESH_AVERAGE)) {
return(ERR_INVALID_OOK_RSSI_PEAK_TYPE); 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) { int16_t RF69::setFrequency(float freq) {
@ -393,39 +397,39 @@ int16_t RF69::setFrequency(float freq) {
if(!(((freq > 290.0) && (freq < 340.0)) || if(!(((freq > 290.0) && (freq < 340.0)) ||
((freq > 431.0) && (freq < 510.0)) || ((freq > 431.0) && (freq < 510.0)) ||
((freq > 862.0) && (freq < 1020.0)))) { ((freq > 862.0) && (freq < 1020.0)))) {
return(ERR_INVALID_FREQUENCY); return(RADIOLIB_ERR_INVALID_FREQUENCY);
} }
// set mode to standby // set mode to standby
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
//set carrier frequency //set carrier frequency
uint32_t FRF = (freq * (uint32_t(1) << RF69_DIV_EXPONENT)) / RF69_CRYSTAL_FREQ; uint32_t FRF = (freq * (uint32_t(1) << RADIOLIB_RF69_DIV_EXPONENT)) / RADIOLIB_RF69_CRYSTAL_FREQ;
_mod->SPIwriteRegister(RF69_REG_FRF_MSB, (FRF & 0xFF0000) >> 16); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MSB, (FRF & 0xFF0000) >> 16);
_mod->SPIwriteRegister(RF69_REG_FRF_MID, (FRF & 0x00FF00) >> 8); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_MID, (FRF & 0x00FF00) >> 8);
_mod->SPIwriteRegister(RF69_REG_FRF_LSB, FRF & 0x0000FF); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_FRF_LSB, FRF & 0x0000FF);
_freq = freq; _freq = freq;
return(ERR_NONE); return(RADIOLIB_ERR_NONE);
} }
int16_t RF69::setBitRate(float br) { 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 // check bitrate-bandwidth ratio
if(!(br < 2000 * _rxBw)) { if(!(br < 2000 * _rxBw)) {
return(ERR_INVALID_BIT_RATE_BW_RATIO); return(RADIOLIB_ERR_INVALID_BIT_RATE_BW_RATIO);
} }
// set mode to standby // set mode to standby
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
// set bit rate // set bit rate
uint16_t bitRate = 32000 / br; uint16_t bitRate = 32000 / br;
int16_t state = _mod->SPIsetRegValue(RF69_REG_BITRATE_MSB, (bitRate & 0xFF00) >> 8, 7, 0); int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_BITRATE_MSB, (bitRate & 0xFF00) >> 8, 7, 0);
state |= _mod->SPIsetRegValue(RF69_REG_BITRATE_LSB, bitRate & 0x00FF, 7, 0); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_BITRATE_LSB, bitRate & 0x00FF, 7, 0);
if(state == ERR_NONE) { if(state == RADIOLIB_ERR_NONE) {
RF69::_br = br; RF69::_br = br;
} }
return(state); return(state);
@ -434,93 +438,93 @@ int16_t RF69::setBitRate(float br) {
int16_t RF69::setRxBandwidth(float rxBw) { int16_t RF69::setRxBandwidth(float rxBw) {
// check bitrate-bandwidth ratio // check bitrate-bandwidth ratio
if(!(_br < 2000 * rxBw)) { if(!(_br < 2000 * rxBw)) {
return(ERR_INVALID_BIT_RATE_BW_RATIO); return(RADIOLIB_ERR_INVALID_BIT_RATE_BW_RATIO);
} }
// check allowed bandwidth values // check allowed bandwidth values
uint8_t bwMant, bwExp; uint8_t bwMant, bwExp;
if(rxBw == 2.6) { if(rxBw == 2.6) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 7; bwExp = 7;
} else if(rxBw == 3.1) { } else if(rxBw == 3.1) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 7; bwExp = 7;
} else if(rxBw == 3.9) { } else if(rxBw == 3.9) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 7; bwExp = 7;
} else if(rxBw == 5.2) { } else if(rxBw == 5.2) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 6; bwExp = 6;
} else if(rxBw == 6.3) { } else if(rxBw == 6.3) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 6; bwExp = 6;
} else if(rxBw == 7.8) { } else if(rxBw == 7.8) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 6; bwExp = 6;
} else if(rxBw == 10.4) { } else if(rxBw == 10.4) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 5; bwExp = 5;
} else if(rxBw == 12.5) { } else if(rxBw == 12.5) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 5; bwExp = 5;
} else if(rxBw == 15.6) { } else if(rxBw == 15.6) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 5; bwExp = 5;
} else if(rxBw == 20.8) { } else if(rxBw == 20.8) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 4; bwExp = 4;
} else if(rxBw == 25.0) { } else if(rxBw == 25.0) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 4; bwExp = 4;
} else if(rxBw == 31.3) { } else if(rxBw == 31.3) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 4; bwExp = 4;
} else if(rxBw == 41.7) { } else if(rxBw == 41.7) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 3; bwExp = 3;
} else if(rxBw == 50.0) { } else if(rxBw == 50.0) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 3; bwExp = 3;
} else if(rxBw == 62.5) { } else if(rxBw == 62.5) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 3; bwExp = 3;
} else if(rxBw == 83.3) { } else if(rxBw == 83.3) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 2; bwExp = 2;
} else if(rxBw == 100.0) { } else if(rxBw == 100.0) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 2; bwExp = 2;
} else if(rxBw == 125.0) { } else if(rxBw == 125.0) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 2; bwExp = 2;
} else if(rxBw == 166.7) { } else if(rxBw == 166.7) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 1; bwExp = 1;
} else if(rxBw == 200.0) { } else if(rxBw == 200.0) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 1; bwExp = 1;
} else if(rxBw == 250.0) { } else if(rxBw == 250.0) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 1; bwExp = 1;
} else if(rxBw == 333.3) { } else if(rxBw == 333.3) {
bwMant = RF69_RX_BW_MANT_24; bwMant = RADIOLIB_RF69_RX_BW_MANT_24;
bwExp = 0; bwExp = 0;
} else if(rxBw == 400.0) { } else if(rxBw == 400.0) {
bwMant = RF69_RX_BW_MANT_20; bwMant = RADIOLIB_RF69_RX_BW_MANT_20;
bwExp = 0; bwExp = 0;
} else if(rxBw == 500.0) { } else if(rxBw == 500.0) {
bwMant = RF69_RX_BW_MANT_16; bwMant = RADIOLIB_RF69_RX_BW_MANT_16;
bwExp = 0; bwExp = 0;
} else { } else {
return(ERR_INVALID_RX_BANDWIDTH); return(RADIOLIB_ERR_INVALID_RX_BANDWIDTH);
} }
// set mode to standby // set mode to standby
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
// set Rx bandwidth // set Rx bandwidth
int16_t state = _mod->SPIsetRegValue(RF69_REG_RX_BW, RF69_DCC_FREQ | bwMant | bwExp, 7, 0); int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_BW, RADIOLIB_RF69_DCC_FREQ | bwMant | bwExp, 7, 0);
if(state == ERR_NONE) { if(state == RADIOLIB_ERR_NONE) {
RF69::_rxBw = rxBw; RF69::_rxBw = rxBw;
} }
return(state); return(state);
@ -535,30 +539,30 @@ int16_t RF69::setFrequencyDeviation(float freqDev) {
// check frequency deviation range // check frequency deviation range
if(!((newFreqDev + _br/2 <= 500))) { if(!((newFreqDev + _br/2 <= 500))) {
return(ERR_INVALID_FREQUENCY_DEVIATION); return(RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
} }
// set mode to standby // set mode to standby
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
// set frequency deviation from carrier frequency // set frequency deviation from carrier frequency
uint32_t base = 1; uint32_t base = 1;
uint32_t fdev = (newFreqDev * (base << 19)) / 32000; uint32_t fdev = (newFreqDev * (base << 19)) / 32000;
int16_t state = _mod->SPIsetRegValue(RF69_REG_FDEV_MSB, (fdev & 0xFF00) >> 8, 5, 0); int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_FDEV_MSB, (fdev & 0xFF00) >> 8, 5, 0);
state |= _mod->SPIsetRegValue(RF69_REG_FDEV_LSB, fdev & 0x00FF, 7, 0); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_FDEV_LSB, fdev & 0x00FF, 7, 0);
return(state); return(state);
} }
int16_t RF69::setOutputPower(int8_t power, bool highPower) { int16_t RF69::setOutputPower(int8_t power, bool highPower) {
if(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 { } 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 // set mode to standby
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
// set output power // set output power
int16_t state; int16_t state;
@ -566,22 +570,22 @@ int16_t RF69::setOutputPower(int8_t power, bool highPower) {
// check if both PA1 and PA2 are needed // check if both PA1 and PA2 are needed
if(power <= 10) { if(power <= 10) {
// -2 to 13 dBm, PA1 is enough // -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) { } else if(power <= 17) {
// 13 to 17 dBm, both PAs required // 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 { } else {
// 18 - 20 dBm, both PAs and hig power settings required // 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 { } else {
// low power module, use only PA0 // 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 // cache the power value
if(state == ERR_NONE) { if(state == RADIOLIB_ERR_NONE) {
_power = power; _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) { int16_t RF69::setSyncWord(uint8_t* syncWord, size_t len, uint8_t maxErrBits) {
// check constraints // check constraints
if((maxErrBits > 7) || (len > 8)) { if((maxErrBits > 7) || (len > 8)) {
return(ERR_INVALID_SYNC_WORD); return(RADIOLIB_ERR_INVALID_SYNC_WORD);
} }
// sync word must not contain value 0x00 // sync word must not contain value 0x00
for(uint8_t i = 0; i < len; i++) { for(uint8_t i = 0; i < len; i++) {
if(syncWord[i] == 0x00) { 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); RADIOLIB_ASSERT(state);
// set sync word register // set sync word register
_mod->SPIwriteRegisterBurst(RF69_REG_SYNC_VALUE_1, syncWord, len); _mod->SPIwriteRegisterBurst(RADIOLIB_RF69_REG_SYNC_VALUE_1, syncWord, len);
return(ERR_NONE); return(RADIOLIB_ERR_NONE);
} }
int16_t RF69::setPreambleLength(uint8_t preambleLen) { int16_t RF69::setPreambleLength(uint8_t preambleLen) {
// RF69 configures preamble length in bytes // RF69 configures preamble length in bytes
if(preambleLen % 8 != 0) { if(preambleLen % 8 != 0) {
return(ERR_INVALID_PREAMBLE_LENGTH); return(RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
} }
uint8_t preLenBytes = preambleLen / 8; uint8_t preLenBytes = preambleLen / 8;
_mod->SPIwriteRegister(RF69_REG_PREAMBLE_MSB, 0x00); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_PREAMBLE_MSB, 0x00);
return(_mod->SPIsetRegValue(RF69_REG_PREAMBLE_LSB, preLenBytes)); return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_PREAMBLE_LSB, preLenBytes));
} }
int16_t RF69::setNodeAddress(uint8_t nodeAddr) { int16_t RF69::setNodeAddress(uint8_t nodeAddr) {
// enable address filtering (node only) // 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); RADIOLIB_ASSERT(state);
// set node address // 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) { int16_t RF69::setBroadcastAddress(uint8_t broadAddr) {
// enable address filtering (node + broadcast) // 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); RADIOLIB_ASSERT(state);
// set broadcast address // set broadcast address
return(_mod->SPIsetRegValue(RF69_REG_BROADCAST_ADRS, broadAddr)); return(_mod->SPIsetRegValue(RADIOLIB_RF69_REG_BROADCAST_ADRS, broadAddr));
} }
int16_t RF69::disableAddressFiltering() { int16_t RF69::disableAddressFiltering() {
// disable address filtering // 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); RADIOLIB_ASSERT(state);
// set node address to default (0x00) // 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); RADIOLIB_ASSERT(state);
// set broadcast address to default (0x00) // 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) { void RF69::setAmbientTemperature(int16_t tempAmbient) {
@ -659,27 +663,27 @@ void RF69::setAmbientTemperature(int16_t tempAmbient) {
int16_t RF69::getTemperature() { int16_t RF69::getTemperature() {
// set mode to STANDBY // set mode to STANDBY
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
// start temperature measurement // 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 // 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 // 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)); return(0 - (rawTemp + _tempOffset));
} }
size_t RF69::getPacketLength(bool update) { size_t RF69::getPacketLength(bool update) {
if(!_packetLengthQueried && update) { if(!_packetLengthQueried && update) {
if (_packetLengthConfig == RF69_PACKET_FORMAT_VARIABLE) { if (_packetLengthConfig == RADIOLIB_RF69_PACKET_FORMAT_VARIABLE) {
_packetLength = _mod->SPIreadRegister(RF69_REG_FIFO); _packetLength = _mod->SPIreadRegister(RADIOLIB_RF69_REG_FIFO);
} else { } else {
_packetLength = _mod->SPIreadRegister(RF69_REG_PAYLOAD_LENGTH); _packetLength = _mod->SPIreadRegister(RADIOLIB_RF69_REG_PAYLOAD_LENGTH);
} }
_packetLengthQueried = true; _packetLengthQueried = true;
} }
@ -688,40 +692,40 @@ size_t RF69::getPacketLength(bool update) {
} }
int16_t RF69::fixedPacketLengthMode(uint8_t len) { 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) { 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) { int16_t RF69::enableSyncWordFiltering(uint8_t maxErrBits) {
// enable sync word recognition // 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() { int16_t RF69::disableSyncWordFiltering() {
// disable preamble detection and generation // disable preamble detection and generation
int16_t state = _mod->SPIsetRegValue(RF69_REG_PREAMBLE_LSB, 0, 7, 0); int16_t state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PREAMBLE_LSB, 0, 7, 0);
state |= _mod->SPIsetRegValue(RF69_REG_PREAMBLE_MSB, 0, 7, 0); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PREAMBLE_MSB, 0, 7, 0);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// disable sync word detection and generation // 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); return(state);
} }
int16_t RF69::setCrcFiltering(bool crcOn) { int16_t RF69::setCrcFiltering(bool crcOn) {
if (crcOn == true) { 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 { } 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 RF69::setPromiscuousMode(bool promiscuous) {
int16_t state = ERR_NONE; int16_t state = RADIOLIB_ERR_NONE;
if (_promiscuous == promiscuous) { if (_promiscuous == promiscuous) {
return(state); return(state);
@ -754,15 +758,15 @@ int16_t RF69::setDataShaping(uint8_t sh) {
// set data shaping // set data shaping
switch(sh) { switch(sh) {
case RADIOLIB_SHAPING_NONE: 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: 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: 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: 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: 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 // set encoding
switch(encoding) { switch(encoding) {
case RADIOLIB_ENCODING_NRZ: 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: 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: 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: default:
return(ERR_INVALID_ENCODING); return(RADIOLIB_ERR_INVALID_ENCODING);
} }
} }
int16_t RF69::setLnaTestBoost(bool value) { int16_t RF69::setLnaTestBoost(bool value) {
if(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() { 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) { 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() { uint8_t RF69::randomByte() {
// set mode to Rx // set mode to Rx
setMode(RF69_RX); setMode(RADIOLIB_RF69_RX);
// wait a bit for the RSSI reading to stabilise // 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 // read RSSI value 8 times, always keep just the least significant bit
uint8_t randByte = 0x00; uint8_t randByte = 0x00;
for(uint8_t i = 0; i < 8; i++) { 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 // set mode to standby
setMode(RF69_STANDBY); setMode(RADIOLIB_RF69_STANDBY);
return(randByte); return(randByte);
} }
@ -828,77 +832,77 @@ void RF69::readBit(RADIOLIB_PIN_TYPE pin) {
} }
int16_t RF69::getChipVersion() { int16_t RF69::getChipVersion() {
return(_mod->SPIgetRegValue(RF69_REG_VERSION)); return(_mod->SPIgetRegValue(RADIOLIB_RF69_REG_VERSION));
} }
int16_t RF69::config() { int16_t RF69::config() {
int16_t state = ERR_NONE; int16_t state = RADIOLIB_ERR_NONE;
// set mode to STANDBY // set mode to STANDBY
state = setMode(RF69_STANDBY); state = setMode(RADIOLIB_RF69_STANDBY);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// set operation modes // 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); RADIOLIB_ASSERT(state);
// enable over-current protection // 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); RADIOLIB_ASSERT(state);
// set data mode, modulation type and shaping // set data mode, modulation type and shaping
state = _mod->SPIsetRegValue(RF69_REG_DATA_MODUL, RF69_PACKET_MODE | RF69_FSK, 6, 3); state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_DATA_MODUL, RADIOLIB_RF69_PACKET_MODE | RADIOLIB_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_FSK_GAUSSIAN_0_3, 1, 0);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// set RSSI threshold // 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); RADIOLIB_ASSERT(state);
// reset FIFO flag // 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 // 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); RADIOLIB_ASSERT(state);
// set packet configuration and disable encryption // 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(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(RF69_REG_PACKET_CONFIG_2, RF69_INTER_PACKET_RX_DELAY, 7, 4); state |= _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PACKET_CONFIG_2, RADIOLIB_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_2, RADIOLIB_RF69_AUTO_RX_RESTART_ON | RADIOLIB_RF69_AES_OFF, 1, 0);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// set payload length // 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); RADIOLIB_ASSERT(state);
// set FIFO threshold // 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); RADIOLIB_ASSERT(state);
// set Rx timeouts // set Rx timeouts
state = _mod->SPIsetRegValue(RF69_REG_RX_TIMEOUT_1, RF69_TIMEOUT_RX_START, 7, 0); state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_RX_TIMEOUT_1, RADIOLIB_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_2, RADIOLIB_RF69_TIMEOUT_RSSI_THRESH, 7, 0);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// enable improved fading margin // 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); return(state);
} }
int16_t RF69::setPacketMode(uint8_t mode, uint8_t len) { int16_t RF69::setPacketMode(uint8_t mode, uint8_t len) {
// check length // check length
if (len > RF69_MAX_PACKET_LENGTH) { if (len > RADIOLIB_RF69_MAX_PACKET_LENGTH) {
return(ERR_PACKET_TOO_LONG); return(RADIOLIB_ERR_PACKET_TOO_LONG);
} }
// set to fixed packet length // 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); RADIOLIB_ASSERT(state);
// set length to register // set length to register
state = _mod->SPIsetRegValue(RF69_REG_PAYLOAD_LENGTH, len); state = _mod->SPIsetRegValue(RADIOLIB_RF69_REG_PAYLOAD_LENGTH, len);
RADIOLIB_ASSERT(state); RADIOLIB_ASSERT(state);
// update the cached value // 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) { 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() { void RF69::clearIRQFlags() {
_mod->SPIwriteRegister(RF69_REG_IRQ_FLAGS_1, 0b11111111); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_IRQ_FLAGS_1, 0b11111111);
_mod->SPIwriteRegister(RF69_REG_IRQ_FLAGS_2, 0b11111111); _mod->SPIwriteRegister(RADIOLIB_RF69_REG_IRQ_FLAGS_2, 0b11111111);
} }
#endif #endif

676
src/modules/RF69/RF69.h
View file

@ -10,427 +10,427 @@
#include "../../protocols/PhysicalLayer/PhysicalLayer.h" #include "../../protocols/PhysicalLayer/PhysicalLayer.h"
// RF69 physical layer properties // RF69 physical layer properties
#define RF69_FREQUENCY_STEP_SIZE 61.03515625 #define RADIOLIB_RF69_FREQUENCY_STEP_SIZE 61.03515625
#define RF69_MAX_PACKET_LENGTH 64 #define RADIOLIB_RF69_MAX_PACKET_LENGTH 64
#define RF69_CRYSTAL_FREQ 32.0 #define RADIOLIB_RF69_CRYSTAL_FREQ 32.0
#define RF69_DIV_EXPONENT 19 #define RADIOLIB_RF69_DIV_EXPONENT 19
// RF69 register map // RF69 register map
#define RF69_REG_FIFO 0x00 #define RADIOLIB_RF69_REG_FIFO 0x00
#define RF69_REG_OP_MODE 0x01 #define RADIOLIB_RF69_REG_OP_MODE 0x01
#define RF69_REG_DATA_MODUL 0x02 #define RADIOLIB_RF69_REG_DATA_MODUL 0x02
#define RF69_REG_BITRATE_MSB 0x03 #define RADIOLIB_RF69_REG_BITRATE_MSB 0x03
#define RF69_REG_BITRATE_LSB 0x04 #define RADIOLIB_RF69_REG_BITRATE_LSB 0x04
#define RF69_REG_FDEV_MSB 0x05 #define RADIOLIB_RF69_REG_FDEV_MSB 0x05
#define RF69_REG_FDEV_LSB 0x06 #define RADIOLIB_RF69_REG_FDEV_LSB 0x06
#define RF69_REG_FRF_MSB 0x07 #define RADIOLIB_RF69_REG_FRF_MSB 0x07
#define RF69_REG_FRF_MID 0x08 #define RADIOLIB_RF69_REG_FRF_MID 0x08
#define RF69_REG_FRF_LSB 0x09 #define RADIOLIB_RF69_REG_FRF_LSB 0x09
#define RF69_REG_OSC_1 0x0A #define RADIOLIB_RF69_REG_OSC_1 0x0A
#define RF69_REG_AFC_CTRL 0x0B #define RADIOLIB_RF69_REG_AFC_CTRL 0x0B
#define RF69_REG_LISTEN_1 0x0D #define RADIOLIB_RF69_REG_LISTEN_1 0x0D
#define RF69_REG_LISTEN_2 0x0E #define RADIOLIB_RF69_REG_LISTEN_2 0x0E
#define RF69_REG_LISTEN_3 0x0F #define RADIOLIB_RF69_REG_LISTEN_3 0x0F
#define RF69_REG_VERSION 0x10 #define RADIOLIB_RF69_REG_VERSION 0x10
#define RF69_REG_PA_LEVEL 0x11 #define RADIOLIB_RF69_REG_PA_LEVEL 0x11
#define RF69_REG_PA_RAMP 0x12 #define RADIOLIB_RF69_REG_PA_RAMP 0x12
#define RF69_REG_OCP 0x13 #define RADIOLIB_RF69_REG_OCP 0x13
#define RF69_REG_LNA 0x18 #define RADIOLIB_RF69_REG_LNA 0x18
#define RF69_REG_RX_BW 0x19 #define RADIOLIB_RF69_REG_RX_BW 0x19
#define RF69_REG_AFC_BW 0x1A #define RADIOLIB_RF69_REG_AFC_BW 0x1A
#define RF69_REG_OOK_PEAK 0x1B #define RADIOLIB_RF69_REG_OOK_PEAK 0x1B
#define RF69_REG_OOK_AVG 0x1C #define RADIOLIB_RF69_REG_OOK_AVG 0x1C
#define RF69_REG_OOK_FIX 0x1D #define RADIOLIB_RF69_REG_OOK_FIX 0x1D
#define RF69_REG_AFC_FEI 0x1E #define RADIOLIB_RF69_REG_AFC_FEI 0x1E
#define RF69_REG_AFC_MSB 0x1F #define RADIOLIB_RF69_REG_AFC_MSB 0x1F
#define RF69_REG_AFC_LSB 0x20 #define RADIOLIB_RF69_REG_AFC_LSB 0x20
#define RF69_REG_FEI_MSB 0x21 #define RADIOLIB_RF69_REG_FEI_MSB 0x21
#define RF69_REG_FEI_LSB 0x22 #define RADIOLIB_RF69_REG_FEI_LSB 0x22
#define RF69_REG_RSSI_CONFIG 0x23 #define RADIOLIB_RF69_REG_RSSI_CONFIG 0x23
#define RF69_REG_RSSI_VALUE 0x24 #define RADIOLIB_RF69_REG_RSSI_VALUE 0x24
#define RF69_REG_DIO_MAPPING_1 0x25 #define RADIOLIB_RF69_REG_DIO_MAPPING_1 0x25
#define RF69_REG_DIO_MAPPING_2 0x26 #define RADIOLIB_RF69_REG_DIO_MAPPING_2 0x26
#define RF69_REG_IRQ_FLAGS_1 0x27 #define RADIOLIB_RF69_REG_IRQ_FLAGS_1 0x27
#define RF69_REG_IRQ_FLAGS_2 0x28 #define RADIOLIB_RF69_REG_IRQ_FLAGS_2 0x28
#define RF69_REG_RSSI_THRESH 0x29 #define RADIOLIB_RF69_REG_RSSI_THRESH 0x29
#define RF69_REG_RX_TIMEOUT_1 0x2A #define RADIOLIB_RF69_REG_RX_TIMEOUT_1 0x2A
#define RF69_REG_RX_TIMEOUT_2 0x2B #define RADIOLIB_RF69_REG_RX_TIMEOUT_2 0x2B
#define RF69_REG_PREAMBLE_MSB 0x2C #define RADIOLIB_RF69_REG_PREAMBLE_MSB 0x2C
#define RF69_REG_PREAMBLE_LSB 0x2D #define RADIOLIB_RF69_REG_PREAMBLE_LSB 0x2D
#define RF69_REG_SYNC_CONFIG 0x2E #define RADIOLIB_RF69_REG_SYNC_CONFIG 0x2E
#define RF69_REG_SYNC_VALUE_1 0x2F #define RADIOLIB_RF69_REG_SYNC_VALUE_1 0x2F
#define RF69_REG_SYNC_VALUE_2 0x30 #define RADIOLIB_RF69_REG_SYNC_VALUE_2 0x30
#define RF69_REG_SYNC_VALUE_3 0x31 #define RADIOLIB_RF69_REG_SYNC_VALUE_3 0x31
#define RF69_REG_SYNC_VALUE_4 0x32 #define RADIOLIB_RF69_REG_SYNC_VALUE_4 0x32
#define RF69_REG_SYNC_VALUE_5 0x33 #define RADIOLIB_RF69_REG_SYNC_VALUE_5 0x33
#define RF69_REG_SYNC_VALUE_6 0x34 #define RADIOLIB_RF69_REG_SYNC_VALUE_6 0x34
#define RF69_REG_SYNC_VALUE_7 0x35 #define RADIOLIB_RF69_REG_SYNC_VALUE_7 0x35
#define RF69_REG_SYNC_VALUE_8 0x36 #define RADIOLIB_RF69_REG_SYNC_VALUE_8 0x36
#define RF69_REG_PACKET_CONFIG_1 0x37 #define RADIOLIB_RF69_REG_PACKET_CONFIG_1 0x37
#define RF69_REG_PAYLOAD_LENGTH 0x38 #define RADIOLIB_RF69_REG_PAYLOAD_LENGTH 0x38
#define RF69_REG_NODE_ADRS 0x39 #define RADIOLIB_RF69_REG_NODE_ADRS 0x39
#define RF69_REG_BROADCAST_ADRS 0x3A #define RADIOLIB_RF69_REG_BROADCAST_ADRS 0x3A
#define RF69_REG_AUTO_MODES 0x3B #define RADIOLIB_RF69_REG_AUTO_MODES 0x3B
#define RF69_REG_FIFO_THRESH 0x3C #define RADIOLIB_RF69_REG_FIFO_THRESH 0x3C
#define RF69_REG_PACKET_CONFIG_2 0x3D #define RADIOLIB_RF69_REG_PACKET_CONFIG_2 0x3D
#define RF69_REG_AES_KEY_1 0x3E #define RADIOLIB_RF69_REG_AES_KEY_1 0x3E
#define RF69_REG_AES_KEY_2 0x3F #define RADIOLIB_RF69_REG_AES_KEY_2 0x3F
#define RF69_REG_AES_KEY_3 0x40 #define RADIOLIB_RF69_REG_AES_KEY_3 0x40
#define RF69_REG_AES_KEY_4 0x41 #define RADIOLIB_RF69_REG_AES_KEY_4 0x41
#define RF69_REG_AES_KEY_5 0x42 #define RADIOLIB_RF69_REG_AES_KEY_5 0x42
#define RF69_REG_AES_KEY_6 0x43 #define RADIOLIB_RF69_REG_AES_KEY_6 0x43
#define RF69_REG_AES_KEY_7 0x44 #define RADIOLIB_RF69_REG_AES_KEY_7 0x44
#define RF69_REG_AES_KEY_8 0x45 #define RADIOLIB_RF69_REG_AES_KEY_8 0x45
#define RF69_REG_AES_KEY_9 0x46 #define RADIOLIB_RF69_REG_AES_KEY_9 0x46
#define RF69_REG_AES_KEY_10 0x47 #define RADIOLIB_RF69_REG_AES_KEY_10 0x47
#define RF69_REG_AES_KEY_11 0x48 #define RADIOLIB_RF69_REG_AES_KEY_11 0x48
#define RF69_REG_AES_KEY_12 0x49 #define RADIOLIB_RF69_REG_AES_KEY_12 0x49
#define RF69_REG_AES_KEY_13 0x4A #define RADIOLIB_RF69_REG_AES_KEY_13 0x4A
#define RF69_REG_AES_KEY_14 0x4B #define RADIOLIB_RF69_REG_AES_KEY_14 0x4B
#define RF69_REG_AES_KEY_15 0x4C #define RADIOLIB_RF69_REG_AES_KEY_15 0x4C
#define RF69_REG_AES_KEY_16 0x4D #define RADIOLIB_RF69_REG_AES_KEY_16 0x4D
#define RF69_REG_TEMP_1 0x4E #define RADIOLIB_RF69_REG_TEMP_1 0x4E
#define RF69_REG_TEMP_2 0x4F #define RADIOLIB_RF69_REG_TEMP_2 0x4F
#define RF69_REG_TEST_LNA 0x58 #define RADIOLIB_RF69_REG_TEST_LNA 0x58
#define RF69_REG_TEST_PA1 0x5A #define RADIOLIB_RF69_REG_TEST_PA1 0x5A
#define RF69_REG_TEST_PA2 0x5C #define RADIOLIB_RF69_REG_TEST_PA2 0x5C
#define RF69_REG_TEST_DAGC 0x6F #define RADIOLIB_RF69_REG_TEST_DAGC 0x6F
// RF69 modem settings // RF69 modem settings
// RF69_REG_OP_MODE MSB LSB DESCRIPTION // RF69_REG_OP_MODE MSB LSB DESCRIPTION
#define RF69_SEQUENCER_OFF 0b00000000 // 7 7 disable automatic sequencer #define RADIOLIB_RF69_SEQUENCER_OFF 0b00000000 // 7 7 disable automatic sequencer
#define RF69_SEQUENCER_ON 0b10000000 // 7 7 enable automatic sequencer #define RADIOLIB_RF69_SEQUENCER_ON 0b10000000 // 7 7 enable automatic sequencer
#define RF69_LISTEN_OFF 0b00000000 // 6 6 disable Listen mode #define RADIOLIB_RF69_LISTEN_OFF 0b00000000 // 6 6 disable Listen mode
#define RF69_LISTEN_ON 0b01000000 // 6 6 enable Listen mode #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_SLEEP 0b00000000 // 4 2 sleep
#define RF69_STANDBY 0b00000100 // 4 2 standby #define RADIOLIB_RF69_STANDBY 0b00000100 // 4 2 standby
#define RF69_FS 0b00001000 // 4 2 frequency synthesis #define RADIOLIB_RF69_FS 0b00001000 // 4 2 frequency synthesis
#define RF69_TX 0b00001100 // 4 2 transmit #define RADIOLIB_RF69_TX 0b00001100 // 4 2 transmit
#define RF69_RX 0b00010000 // 4 2 receive #define RADIOLIB_RF69_RX 0b00010000 // 4 2 receive
// RF69_REG_DATA_MODUL // RF69_REG_DATA_MODUL
#define RF69_PACKET_MODE 0b00000000 // 6 5 packet mode (default) #define RADIOLIB_RF69_PACKET_MODE 0b00000000 // 6 5 packet mode (default)
#define RF69_CONTINUOUS_MODE_WITH_SYNC 0b01000000 // 6 5 continuous mode with bit synchronizer #define RADIOLIB_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 RADIOLIB_RF69_CONTINUOUS_MODE 0b01100000 // 6 5 continuous mode without bit synchronizer
#define RF69_FSK 0b00000000 // 4 3 modulation: FSK (default) #define RADIOLIB_RF69_FSK 0b00000000 // 4 3 modulation: FSK (default)
#define RF69_OOK 0b00001000 // 4 3 OOK #define RADIOLIB_RF69_OOK 0b00001000 // 4 3 OOK
#define RF69_NO_SHAPING 0b00000000 // 1 0 modulation shaping: no shaping (default) #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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_OOK_FILTER_2BR 0b00000010 // 1 0 OOK modulation filter, f_cutoff = 2*BR
// RF69_REG_BITRATE_MSB + REG_BITRATE_LSB // RF69_REG_BITRATE_MSB + REG_BITRATE_LSB
#define RF69_BITRATE_MSB 0x1A // 7 0 bit rate setting: rate = F(XOSC) / BITRATE #define RADIOLIB_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_LSB 0x0B // 7 0 default value: 4.8 kbps 0x40 // 7 0
// RF69_REG_FDEV_MSB + REG_FDEV_LSB // RF69_REG_FDEV_MSB + REG_FDEV_LSB
#define RF69_FDEV_MSB 0x00 // 5 0 frequency deviation: f_dev = f_step * FDEV #define RADIOLIB_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_LSB 0x52 // 7 0 default value: 5 kHz
// RF69_REG_FRF_MSB + REG_FRF_MID + REG_FRF_LSB // 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 RADIOLIB_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 RADIOLIB_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_LSB 0x00 // 7 0 default value: 915 MHz
// RF69_REG_OSC_1 // RF69_REG_OSC_1
#define RF69_RC_CAL_START 0b10000000 // 7 7 force RC oscillator calibration #define RADIOLIB_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 RADIOLIB_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_DONE 0b00000000 // 5 5 RC oscillator calibration has finished
// RF69_REG_AFC_CTRL // RF69_REG_AFC_CTRL
#define RF69_AFC_LOW_BETA_OFF 0b00000000 // 5 5 standard AFC routine #define RADIOLIB_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_ON 0b00100000 // 5 5 improved AFC routine for signals with modulation index less than 2
// RF69_REG_LISTEN_1 // RF69_REG_LISTEN_1
#define RF69_LISTEN_RES_IDLE_64_US 0b01000000 // 7 6 resolution of Listen mode idle time: 64 us #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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_END_KEEP_RX_TIMEOUT_RESUME 0b00000100 // 2 1 stay in Rx mode until timeout, Listen mode will resume
// RF69_REG_LISTEN_2 // 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 // 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 // RF69_REG_VERSION
#define RF69_CHIP_VERSION 0x24 // 7 0 #define RADIOLIB_RF69_CHIP_VERSION 0x24 // 7 0
// RF69_REG_PA_LEVEL // RF69_REG_PA_LEVEL
#define RF69_PA0_OFF 0b00000000 // 7 7 PA0 disabled #define RADIOLIB_RF69_PA0_OFF 0b00000000 // 7 7 PA0 disabled
#define RF69_PA0_ON 0b10000000 // 7 7 PA0 enabled (default) #define RADIOLIB_RF69_PA0_ON 0b10000000 // 7 7 PA0 enabled (default)
#define RF69_PA1_OFF 0b00000000 // 6 6 PA1 disabled (default) #define RADIOLIB_RF69_PA1_OFF 0b00000000 // 6 6 PA1 disabled (default)
#define RF69_PA1_ON 0b01000000 // 6 6 PA1 enabled #define RADIOLIB_RF69_PA1_ON 0b01000000 // 6 6 PA1 enabled
#define RF69_PA2_OFF 0b00000000 // 5 5 PA2 disabled (default) #define RADIOLIB_RF69_PA2_OFF 0b00000000 // 5 5 PA2 disabled (default)
#define RF69_PA2_ON 0b00100000 // 5 5 PA2 enabled #define RADIOLIB_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_OUTPUT_POWER 0b00011111 // 4 0 output power: P_out = -18 + OUTPUT_POWER
// RF69_REG_PA_RAMP // RF69_REG_PA_RAMP
#define RF69_PA_RAMP_3_4_MS 0b00000000 // 3 0 PA ramp rise/fall time: 3.4 ms #define RADIOLIB_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 RADIOLIB_RF69_PA_RAMP_2_MS 0b00000001 // 3 0 2 ms
#define RF69_PA_RAMP_1_MS 0b00000010 // 3 0 1 ms #define RADIOLIB_RF69_PA_RAMP_1_MS 0b00000010 // 3 0 1 ms
#define RF69_PA_RAMP_500_US 0b00000011 // 3 0 500 us #define RADIOLIB_RF69_PA_RAMP_500_US 0b00000011 // 3 0 500 us
#define RF69_PA_RAMP_250_US 0b00000100 // 3 0 250 us #define RADIOLIB_RF69_PA_RAMP_250_US 0b00000100 // 3 0 250 us
#define RF69_PA_RAMP_125_US 0b00000101 // 3 0 125 us #define RADIOLIB_RF69_PA_RAMP_125_US 0b00000101 // 3 0 125 us
#define RF69_PA_RAMP_100_US 0b00000110 // 3 0 100 us #define RADIOLIB_RF69_PA_RAMP_100_US 0b00000110 // 3 0 100 us
#define RF69_PA_RAMP_62_US 0b00000111 // 3 0 62 us #define RADIOLIB_RF69_PA_RAMP_62_US 0b00000111 // 3 0 62 us
#define RF69_PA_RAMP_50_US 0b00001000 // 3 0 50 us #define RADIOLIB_RF69_PA_RAMP_50_US 0b00001000 // 3 0 50 us
#define RF69_PA_RAMP_40_US 0b00001001 // 3 0 40 us (default) #define RADIOLIB_RF69_PA_RAMP_40_US 0b00001001 // 3 0 40 us (default)
#define RF69_PA_RAMP_31_US 0b00001010 // 3 0 31 us #define RADIOLIB_RF69_PA_RAMP_31_US 0b00001010 // 3 0 31 us
#define RF69_PA_RAMP_25_US 0b00001011 // 3 0 25 us #define RADIOLIB_RF69_PA_RAMP_25_US 0b00001011 // 3 0 25 us
#define RF69_PA_RAMP_20_US 0b00001100 // 3 0 20 us #define RADIOLIB_RF69_PA_RAMP_20_US 0b00001100 // 3 0 20 us
#define RF69_PA_RAMP_15_US 0b00001101 // 3 0 15 us #define RADIOLIB_RF69_PA_RAMP_15_US 0b00001101 // 3 0 15 us
#define RF69_PA_RAMP_12_US 0b00001110 // 3 0 12 us #define RADIOLIB_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_10_US 0b00001111 // 3 0 10 us
// RF69_REG_OCP // RF69_REG_OCP
#define RF69_OCP_OFF 0b00000000 // 4 4 PA overload current protection disabled #define RADIOLIB_RF69_OCP_OFF 0b00000000 // 4 4 PA overload current protection disabled
#define RF69_OCP_ON 0b00010000 // 4 4 PA overload current protection enabled #define RADIOLIB_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_TRIM 0b00001010 // 3 0 OCP current: I_max(OCP_TRIM = 0b1010) = 95 mA
// RF69_REG_LNA // RF69_REG_LNA
#define RF69_LNA_Z_IN_50_OHM 0b00000000 // 7 7 LNA input impedance: 50 ohm #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_LNA_GAIN_MAX 0b00000001 // 2 0 max gain
#define RF69_LNA_GAIN_MAX_6_DB 0b00000010 // 2 0 max gain - 6 dB #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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_GAIN_MAX_48_DB 0b00000110 // 2 0 max gain - 48 dB
// RF69_REG_RX_BW // RF69_REG_RX_BW
#define RF69_DCC_FREQ 0b01000000 // 7 5 DC offset canceller cutoff frequency (4% Rx BW by default) #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_RX_BW_MANT_24 0b00010000 // 4 3
#define RF69_RX_BW_EXP 0b00000101 // 2 0 default RxBwExp value = 5 #define RADIOLIB_RF69_RX_BW_EXP 0b00000101 // 2 0 default RxBwExp value = 5
// RF69_REG_AFC_BW // RF69_REG_AFC_BW
#define RF69_DCC_FREQ_AFC 0b10000000 // 7 5 default DccFreq parameter for AFC #define RADIOLIB_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 RADIOLIB_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_RX_BW_EXP_AFC 0b00000011 // 2 0 default RxBwExp parameter for AFC
// RF69_REG_OOK_PEAK // RF69_REG_OOK_PEAK
#define RF69_OOK_THRESH_FIXED 0b00000000 // 7 6 OOK threshold type: fixed #define RADIOLIB_RF69_OOK_THRESH_FIXED 0b00000000 // 7 6 OOK threshold type: fixed
#define RF69_OOK_THRESH_PEAK 0b01000000 // 7 6 peak (default) #define RADIOLIB_RF69_OOK_THRESH_PEAK 0b01000000 // 7 6 peak (default)
#define RF69_OOK_THRESH_AVERAGE 0b10000000 // 7 6 average #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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_PEAK_THRESH_DEC_16_1_CHIP 0b00000111 // 2 0 16 times per chip
// RF69_REG_OOK_AVG // RF69_REG_OOK_AVG
#define 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_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 RADIOLIB_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 RADIOLIB_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_2_PI 0b11000000 // 7 6 chip rate / 2*pi
// RF69_REG_OOK_FIX // 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 // RF69_REG_AFC_FEI
#define RF69_FEI_RUNNING 0b00000000 // 6 6 FEI status: on-going #define RADIOLIB_RF69_FEI_RUNNING 0b00000000 // 6 6 FEI status: on-going
#define RF69_FEI_DONE 0b01000000 // 6 6 done #define RADIOLIB_RF69_FEI_DONE 0b01000000 // 6 6 done
#define RF69_FEI_START 0b00100000 // 5 5 force new FEI measurement #define RADIOLIB_RF69_FEI_START 0b00100000 // 5 5 force new FEI measurement
#define RF69_AFC_RUNNING 0b00000000 // 4 4 AFC status: on-going #define RADIOLIB_RF69_AFC_RUNNING 0b00000000 // 4 4 AFC status: on-going
#define RF69_AFC_DONE 0b00010000 // 4 4 done #define RADIOLIB_RF69_AFC_DONE 0b00010000 // 4 4 done
#define RF69_AFC_AUTOCLEAR_OFF 0b00000000 // 3 3 AFC register autoclear disabled #define RADIOLIB_RF69_AFC_AUTOCLEAR_OFF 0b00000000 // 3 3 AFC register autoclear disabled
#define RF69_AFC_AUTOCLEAR_ON 0b00001000 // 3 3 AFC register autoclear enabled #define RADIOLIB_RF69_AFC_AUTOCLEAR_ON 0b00001000 // 3 3 AFC register autoclear enabled
#define RF69_AFC_AUTO_OFF 0b00000000 // 2 2 perform AFC only manually #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_AFC_CLEAR 0b00000010 // 1 1 clear AFC register
#define RF69_AFC_START 0b00000001 // 0 0 start AFC #define RADIOLIB_RF69_AFC_START 0b00000001 // 0 0 start AFC
// RF69_REG_RSSI_CONFIG // RF69_REG_RSSI_CONFIG
#define RF69_RSSI_RUNNING 0b00000000 // 1 1 RSSI status: on-going #define RADIOLIB_RF69_RSSI_RUNNING 0b00000000 // 1 1 RSSI status: on-going
#define RF69_RSSI_DONE 0b00000010 // 1 1 done #define RADIOLIB_RF69_RSSI_DONE 0b00000010 // 1 1 done
#define RF69_RSSI_START 0b00000001 // 0 0 start RSSI measurement #define RADIOLIB_RF69_RSSI_START 0b00000001 // 0 0 start RSSI measurement
// RF69_REG_DIO_MAPPING_1 // RF69_REG_DIO_MAPPING_1
#define RF69_DIO0_CONT_MODE_READY 0b11000000 // 7 6 #define RADIOLIB_RF69_DIO0_CONT_MODE_READY 0b11000000 // 7 6
#define RF69_DIO0_CONT_PLL_LOCK 0b00000000 // 7 6 #define RADIOLIB_RF69_DIO0_CONT_PLL_LOCK 0b00000000 // 7 6
#define RF69_DIO0_CONT_SYNC_ADDRESS 0b00000000 // 7 6 #define RADIOLIB_RF69_DIO0_CONT_SYNC_ADDRESS 0b00000000 // 7 6
#define RF69_DIO0_CONT_TIMEOUT 0b01000000 // 7 6 #define RADIOLIB_RF69_DIO0_CONT_TIMEOUT 0b01000000 // 7 6
#define RF69_DIO0_CONT_RSSI 0b10000000 // 7 6 #define RADIOLIB_RF69_DIO0_CONT_RSSI 0b10000000 // 7 6
#define RF69_DIO0_CONT_TX_READY 0b01000000 // 7 6 #define RADIOLIB_RF69_DIO0_CONT_TX_READY 0b01000000 // 7 6
#define RF69_DIO0_PACK_PLL_LOCK 0b11000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_PLL_LOCK 0b11000000 // 7 6
#define RF69_DIO0_PACK_CRC_OK 0b00000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_CRC_OK 0b00000000 // 7 6
#define RF69_DIO0_PACK_PAYLOAD_READY 0b01000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_PAYLOAD_READY 0b01000000 // 7 6
#define RF69_DIO0_PACK_SYNC_ADDRESS 0b10000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_SYNC_ADDRESS 0b10000000 // 7 6
#define RF69_DIO0_PACK_RSSI 0b11000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_RSSI 0b11000000 // 7 6
#define RF69_DIO0_PACK_PACKET_SENT 0b00000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_PACKET_SENT 0b00000000 // 7 6
#define RF69_DIO0_PACK_TX_READY 0b01000000 // 7 6 #define RADIOLIB_RF69_DIO0_PACK_TX_READY 0b01000000 // 7 6
#define RF69_DIO1_CONT_PLL_LOCK 0b00110000 // 5 4 #define RADIOLIB_RF69_DIO1_CONT_PLL_LOCK 0b00110000 // 5 4
#define RF69_DIO1_CONT_DCLK 0b00000000 // 5 4 #define RADIOLIB_RF69_DIO1_CONT_DCLK 0b00000000 // 5 4
#define RF69_DIO1_CONT_RX_READY 0b00010000 // 5 4 #define RADIOLIB_RF69_DIO1_CONT_RX_READY 0b00010000 // 5 4
#define RF69_DIO1_CONT_SYNC_ADDRESS 0b00110000 // 5 4 #define RADIOLIB_RF69_DIO1_CONT_SYNC_ADDRESS 0b00110000 // 5 4
#define RF69_DIO1_CONT_TX_READY 0b00010000 // 5 4 #define RADIOLIB_RF69_DIO1_CONT_TX_READY 0b00010000 // 5 4
#define RF69_DIO1_PACK_FIFO_LEVEL 0b00000000 // 5 4 #define RADIOLIB_RF69_DIO1_PACK_FIFO_LEVEL 0b00000000 // 5 4
#define RF69_DIO1_PACK_FIFO_FULL 0b00010000 // 5 4 #define RADIOLIB_RF69_DIO1_PACK_FIFO_FULL 0b00010000 // 5 4
#define RF69_DIO1_PACK_FIFO_NOT_EMPTY 0b00100000 // 5 4 #define RADIOLIB_RF69_DIO1_PACK_FIFO_NOT_EMPTY 0b00100000 // 5 4
#define RF69_DIO1_PACK_PLL_LOCK 0b00110000 // 5 4 #define RADIOLIB_RF69_DIO1_PACK_PLL_LOCK 0b00110000 // 5 4
#define RF69_DIO1_PACK_TIMEOUT 0b00110000 // 5 4 #define RADIOLIB_RF69_DIO1_PACK_TIMEOUT 0b00110000 // 5 4
#define RF69_DIO2_CONT_DATA 0b00000000 // 3 2 #define RADIOLIB_RF69_DIO2_CONT_DATA 0b00000000 // 3 2
// RF69_REG_DIO_MAPPING_2 // RF69_REG_DIO_MAPPING_2
#define RF69_CLK_OUT_FXOSC 0b00000000 // 2 0 ClkOut frequency: F(XOSC) #define RADIOLIB_RF69_CLK_OUT_FXOSC 0b00000000 // 2 0 ClkOut frequency: F(XOSC)
#define RF69_CLK_OUT_FXOSC_2 0b00000001 // 2 0 F(XOSC) / 2 #define RADIOLIB_RF69_CLK_OUT_FXOSC_2 0b00000001 // 2 0 F(XOSC) / 2
#define RF69_CLK_OUT_FXOSC_4 0b00000010 // 2 0 F(XOSC) / 4 #define RADIOLIB_RF69_CLK_OUT_FXOSC_4 0b00000010 // 2 0 F(XOSC) / 4
#define RF69_CLK_OUT_FXOSC_8 0b00000011 // 2 0 F(XOSC) / 8 #define RADIOLIB_RF69_CLK_OUT_FXOSC_8 0b00000011 // 2 0 F(XOSC) / 8
#define RF69_CLK_OUT_FXOSC_16 0b00000100 // 2 0 F(XOSC) / 16 #define RADIOLIB_RF69_CLK_OUT_FXOSC_16 0b00000100 // 2 0 F(XOSC) / 16
#define RF69_CLK_OUT_FXOSC_32 0b00000101 // 2 0 F(XOSC) / 31 #define RADIOLIB_RF69_CLK_OUT_FXOSC_32 0b00000101 // 2 0 F(XOSC) / 31
#define RF69_CLK_OUT_RC 0b00000110 // 2 0 RC #define RADIOLIB_RF69_CLK_OUT_RC 0b00000110 // 2 0 RC
#define RF69_CLK_OUT_OFF 0b00000111 // 2 0 disabled (default) #define RADIOLIB_RF69_CLK_OUT_OFF 0b00000111 // 2 0 disabled (default)
// RF69_REG_IRQ_FLAGS_1 // RF69_REG_IRQ_FLAGS_1
#define RF69_IRQ_MODE_READY 0b10000000 // 7 7 requested mode was set #define RADIOLIB_RF69_IRQ_MODE_READY 0b10000000 // 7 7 requested mode was set
#define RF69_IRQ_RX_READY 0b01000000 // 6 6 Rx mode ready #define RADIOLIB_RF69_IRQ_RX_READY 0b01000000 // 6 6 Rx mode ready
#define RF69_IRQ_TX_READY 0b00100000 // 5 5 Tx mode ready #define RADIOLIB_RF69_IRQ_TX_READY 0b00100000 // 5 5 Tx mode ready
#define RF69_IRQ_PLL_LOCK 0b00010000 // 4 4 PLL is locked #define RADIOLIB_RF69_IRQ_PLL_LOCK 0b00010000 // 4 4 PLL is locked
#define RF69_IRQ_RSSI 0b00001000 // 3 3 RSSI value exceeded RssiThreshold #define RADIOLIB_RF69_IRQ_RSSI 0b00001000 // 3 3 RSSI value exceeded RssiThreshold
#define RF69_IRQ_TIMEOUT 0b00000100 // 2 2 timeout occurred #define RADIOLIB_RF69_IRQ_TIMEOUT 0b00000100 // 2 2 timeout occurred
#define RF69_IRQ_AUTO_MODE 0b00000010 // 1 1 entered intermediate mode #define RADIOLIB_RF69_IRQ_AUTO_MODE 0b00000010 // 1 1 entered intermediate mode
#define RF69_SYNC_ADDRESS_MATCH 0b00000001 // 0 0 sync address detected #define RADIOLIB_RF69_SYNC_ADDRESS_MATCH 0b00000001 // 0 0 sync address detected
// RF69_REG_IRQ_FLAGS_2 // RF69_REG_IRQ_FLAGS_2
#define RF69_IRQ_FIFO_FULL 0b10000000 // 7 7 FIFO is full #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_IRQ_FIFO_OVERRUN 0b00010000 // 4 4 FIFO overrun occurred
#define RF69_IRQ_PACKET_SENT 0b00001000 // 3 3 packet was sent #define RADIOLIB_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 RADIOLIB_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_CRC_OK 0b00000010 // 1 1 CRC check passed
// RF69_REG_RSSI_THRESH // 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 // RF69_REG_RX_TIMEOUT_1
#define RF69_TIMEOUT_RX_START_OFF 0x00 // 7 0 RSSI interrupt timeout disabled (default) #define RADIOLIB_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 0xFF // 7 0 timeout will occur if RSSI interrupt is not received
// RF69_REG_RX_TIMEOUT_2 // RF69_REG_RX_TIMEOUT_2
#define RF69_TIMEOUT_RSSI_THRESH_OFF 0x00 // 7 0 PayloadReady interrupt timeout disabled (default) #define RADIOLIB_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 0xFF // 7 0 timeout will occur if PayloadReady interrupt is not received
// RF69_REG_PREAMBLE_MSB + REG_PREAMBLE_MSB // RF69_REG_PREAMBLE_MSB + REG_PREAMBLE_MSB
#define RF69_PREAMBLE_MSB 0x00 // 7 0 2-byte preamble size value #define RADIOLIB_RF69_PREAMBLE_MSB 0x00 // 7 0 2-byte preamble size value
#define RF69_PREAMBLE_LSB 0x03 // 7 0 #define RADIOLIB_RF69_PREAMBLE_LSB 0x03 // 7 0
// RF69_REG_SYNC_CONFIG // RF69_REG_SYNC_CONFIG
#define RF69_SYNC_OFF 0b00000000 // 7 7 sync word detection off #define RADIOLIB_RF69_SYNC_OFF 0b00000000 // 7 7 sync word detection off
#define RF69_SYNC_ON 0b10000000 // 7 7 sync word detection on (default) #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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_TOL 0b00000000 // 2 0 number of tolerated errors in sync word
// RF69_REG_SYNC_VALUE_1 - SYNC_VALUE_8 // RF69_REG_SYNC_VALUE_1 - SYNC_VALUE_8
#define RF69_SYNC_BYTE_1 0x01 // 7 0 sync word: 1st byte (MSB) #define RADIOLIB_RF69_SYNC_BYTE_1 0x01 // 7 0 sync word: 1st byte (MSB)
#define RF69_SYNC_BYTE_2 0x01 // 7 0 2nd byte #define RADIOLIB_RF69_SYNC_BYTE_2 0x01 // 7 0 2nd byte
#define RF69_SYNC_BYTE_3 0x01 // 7 0 3rd byte #define RADIOLIB_RF69_SYNC_BYTE_3 0x01 // 7 0 3rd byte
#define RF69_SYNC_BYTE_4 0x01 // 7 0 4th byte #define RADIOLIB_RF69_SYNC_BYTE_4 0x01 // 7 0 4th byte
#define RF69_SYNC_BYTE_5 0x01 // 7 0 5th byte #define RADIOLIB_RF69_SYNC_BYTE_5 0x01 // 7 0 5th byte
#define RF69_SYNC_BYTE_6 0x01 // 7 0 6th byte #define RADIOLIB_RF69_SYNC_BYTE_6 0x01 // 7 0 6th byte
#define RF69_SYNC_BYTE_7 0x01 // 7 0 7th byte #define RADIOLIB_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_8 0x01 // 7 0 8th byte (LSB)
// RF69_REG_PACKET_CONFIG_1 // RF69_REG_PACKET_CONFIG_1
#define RF69_PACKET_FORMAT_FIXED 0b00000000 // 7 7 fixed packet length (default) #define RADIOLIB_RF69_PACKET_FORMAT_FIXED 0b00000000 // 7 7 fixed packet length (default)
#define RF69_PACKET_FORMAT_VARIABLE 0b10000000 // 7 7 variable packet length #define RADIOLIB_RF69_PACKET_FORMAT_VARIABLE 0b10000000 // 7 7 variable packet length
#define RF69_DC_FREE_NONE 0b00000000 // 6 5 DC-free encoding: none (default) #define RADIOLIB_RF69_DC_FREE_NONE 0b00000000 // 6 5 DC-free encoding: none (default)
#define RF69_DC_FREE_MANCHESTER 0b00100000 // 6 5 Manchester #define RADIOLIB_RF69_DC_FREE_MANCHESTER 0b00100000 // 6 5 Manchester
#define RF69_DC_FREE_WHITENING 0b01000000 // 6 5 Whitening #define RADIOLIB_RF69_DC_FREE_WHITENING 0b01000000 // 6 5 Whitening
#define RF69_CRC_OFF 0b00000000 // 4 4 CRC disabled #define RADIOLIB_RF69_CRC_OFF 0b00000000 // 4 4 CRC disabled
#define RF69_CRC_ON 0b00010000 // 4 4 CRC enabled (default) #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_ADDRESS_FILTERING_OFF 0b00000000 // 2 1 address filtering: none (default)
#define RF69_ADDRESS_FILTERING_NODE 0b00000010 // 2 1 node #define RADIOLIB_RF69_ADDRESS_FILTERING_NODE 0b00000010 // 2 1 node
#define RF69_ADDRESS_FILTERING_NODE_BROADCAST 0b00000100 // 2 1 node or broadcast #define RADIOLIB_RF69_ADDRESS_FILTERING_NODE_BROADCAST 0b00000100 // 2 1 node or broadcast
// RF69_REG_PAYLOAD_LENGTH // 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 // RF69_REG_AUTO_MODES
#define RF69_ENTER_COND_NONE 0b00000000 // 7 5 condition for entering intermediate mode: none, AutoModes disabled (default) #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_ENTER_COND_FIFO_LEVEL 0b01000000 // 7 5 FifoLevel rising edge
#define RF69_ENTER_COND_CRC_OK 0b01100000 // 7 5 CrcOk rising edge #define RADIOLIB_RF69_ENTER_COND_CRC_OK 0b01100000 // 7 5 CrcOk rising edge
#define RF69_ENTER_COND_PAYLOAD_READY 0b10000000 // 7 5 PayloadReady rising edge #define RADIOLIB_RF69_ENTER_COND_PAYLOAD_READY 0b10000000 // 7 5 PayloadReady rising edge
#define RF69_ENTER_COND_SYNC_ADDRESS 0b10100000 // 7 5 SyncAddress rising edge #define RADIOLIB_RF69_ENTER_COND_SYNC_ADDRESS 0b10100000 // 7 5 SyncAddress rising edge
#define RF69_ENTER_COND_PACKET_SENT 0b11000000 // 7 5 PacketSent rising edge #define RADIOLIB_RF69_ENTER_COND_PACKET_SENT 0b11000000 // 7 5 PacketSent rising edge
#define RF69_ENTER_COND_FIFO_EMPTY 0b11100000 // 7 5 FifoNotEmpty falling edge #define RADIOLIB_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 RADIOLIB_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 RADIOLIB_RF69_EXIT_COND_FIFO_EMPTY 0b00100000 // 4 2 FifoNotEmpty falling edge
#define RF69_EXIT_COND_FIFO_LEVEL 0b01000000 // 4 2 FifoLevel rising edge #define RADIOLIB_RF69_EXIT_COND_FIFO_LEVEL 0b01000000 // 4 2 FifoLevel rising edge
#define RF69_EXIT_COND_CRC_OK 0b01100000 // 4 2 CrcOk rising edge #define RADIOLIB_RF69_EXIT_COND_CRC_OK 0b01100000 // 4 2 CrcOk rising edge
#define RF69_EXIT_COND_PAYLOAD_READY 0b10000000 // 4 2 PayloadReady rising edge #define RADIOLIB_RF69_EXIT_COND_PAYLOAD_READY 0b10000000 // 4 2 PayloadReady rising edge
#define RF69_EXIT_COND_SYNC_ADDRESS 0b10100000 // 4 2 SyncAddress rising edge #define RADIOLIB_RF69_EXIT_COND_SYNC_ADDRESS 0b10100000 // 4 2 SyncAddress rising edge
#define RF69_EXIT_COND_PACKET_SENT 0b11000000 // 4 2 PacketSent rising edge #define RADIOLIB_RF69_EXIT_COND_PACKET_SENT 0b11000000 // 4 2 PacketSent rising edge
#define RF69_EXIT_COND_TIMEOUT 0b11100000 // 4 2 timeout rising edge #define RADIOLIB_RF69_EXIT_COND_TIMEOUT 0b11100000 // 4 2 timeout rising edge
#define RF69_INTER_MODE_SLEEP 0b00000000 // 1 0 intermediate mode: sleep (default) #define RADIOLIB_RF69_INTER_MODE_SLEEP 0b00000000 // 1 0 intermediate mode: sleep (default)
#define RF69_INTER_MODE_STANDBY 0b00000001 // 1 0 standby #define RADIOLIB_RF69_INTER_MODE_STANDBY 0b00000001 // 1 0 standby
#define RF69_INTER_MODE_RX 0b00000010 // 1 0 Rx #define RADIOLIB_RF69_INTER_MODE_RX 0b00000010 // 1 0 Rx
#define RF69_INTER_MODE_TX 0b00000011 // 1 0 Tx #define RADIOLIB_RF69_INTER_MODE_TX 0b00000011 // 1 0 Tx
// RF69_REG_FIFO_THRESH // RF69_REG_FIFO_THRESH
#define RF69_TX_START_CONDITION_FIFO_LEVEL 0b00000000 // 7 7 packet transmission start condition: FifoLevel #define RADIOLIB_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 RADIOLIB_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_FIFO_THRESHOLD 0b00001111 // 6 0 default threshold to trigger FifoLevel interrupt
// RF69_REG_PACKET_CONFIG_2 // 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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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 RADIOLIB_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_AES_ON 0b00000001 // 0 0 AES encryption enabled, payload size limited to 66 bytes
// RF69_REG_TEST_LNA // RF69_REG_TEST_LNA
#define RF69_TEST_LNA_BOOST_NORMAL 0x1B // 7 0 #define RADIOLIB_RF69_TEST_LNA_BOOST_NORMAL 0x1B // 7 0
#define RF69_TEST_LNA_BOOST_HIGH 0x2D // 7 0 #define RADIOLIB_RF69_TEST_LNA_BOOST_HIGH 0x2D // 7 0
// RF69_REG_TEMP_1 // RF69_REG_TEMP_1
#define RF69_TEMP_MEAS_START 0b00001000 // 3 3 trigger temperature measurement #define RADIOLIB_RF69_TEMP_MEAS_START 0b00001000 // 3 3 trigger temperature measurement
#define RF69_TEMP_MEAS_RUNNING 0b00000100 // 2 2 temperature measurement status: on-going #define RADIOLIB_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_DONE 0b00000000 // 2 2 done
// RF69_REG_TEST_DAGC // RF69_REG_TEST_DAGC
#define RF69_CONTINUOUS_DAGC_NORMAL 0x00 // 7 0 fading margin improvement: normal mode #define RADIOLIB_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 RADIOLIB_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_LOW_BETA_OFF 0x30 // 7 0 improved mode for AfcLowBetaOff (default)
// RF69_REG_TEST_PA1 // RF69_REG_TEST_PA1
#define RF69_PA1_NORMAL 0x55 // 7 0 PA_BOOST: none #define RADIOLIB_RF69_PA1_NORMAL 0x55 // 7 0 PA_BOOST: none
#define RF69_PA1_20_DBM 0x5D // 7 0 +20 dBm #define RADIOLIB_RF69_PA1_20_DBM 0x5D // 7 0 +20 dBm
// RF69_REG_TEST_PA2 // RF69_REG_TEST_PA2
#define RF69_PA2_NORMAL 0x70 // 7 0 PA_BOOST: none #define RADIOLIB_RF69_PA2_NORMAL 0x70 // 7 0 PA_BOOST: none
#define RF69_PA2_20_DBM 0x7C // 7 0 +20 dBm #define RADIOLIB_RF69_PA2_20_DBM 0x7C // 7 0 +20 dBm
/*! /*!
\class RF69 \class RF69
@ -452,6 +452,8 @@ class RF69: public PhysicalLayer {
*/ */
RF69(Module* module); RF69(Module* module);
Module* getMod();
// basic methods // basic methods
/*! /*!
@ -764,7 +766,7 @@ class RF69: public PhysicalLayer {
\returns \ref status_codes \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. \brief Set modem in variable packet length mode.
@ -773,7 +775,7 @@ class RF69: public PhysicalLayer {
\returns \ref status_codes \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. \brief Enable sync word filtering and generation.
@ -901,7 +903,7 @@ class RF69: public PhysicalLayer {
size_t _packetLength = 0; size_t _packetLength = 0;
bool _packetLengthQueried = false; bool _packetLengthQueried = false;
uint8_t _packetLengthConfig = RF69_PACKET_FORMAT_VARIABLE; uint8_t _packetLengthConfig = RADIOLIB_RF69_PACKET_FORMAT_VARIABLE;
bool _promiscuous = false; bool _promiscuous = false;