1197 lines
41 KiB
C++
1197 lines
41 KiB
C++
#include "LR2021.h"
|
||
|
||
#include "../LR11x0/LR_common.h"
|
||
#include "LR2021_registers.h"
|
||
|
||
#include <math.h>
|
||
#include <string.h>
|
||
|
||
#if !RADIOLIB_EXCLUDE_LR2021
|
||
|
||
// maximum number of allowed frontend calibration attempts
|
||
#define RADIOLIB_LR2021_MAX_CAL_ATTEMPTS (10)
|
||
|
||
// Sub-GHz: below this RF frequency (MHz) use Table 7-17 (490 MHz ref.); at/above use Table 7-16 (915 MHz ref.).
|
||
#define RADIOLIB_LR2021_LF_PA_TABLE_490_MHZ_MAX (700.0f)
|
||
|
||
// Table 7-16: Optimal Values for 915 MHz Semtech Reference Design (LF PA).
|
||
// Integer targeted dBm 22..10 only: half-dBm rows (e.g. 21.5) need a future API that passes 0.5 dB steps.
|
||
// SetTxParams first byte = `txHalfDbm` (signed half-dBm); matches datasheet TX_PARAM column * 2.
|
||
static const struct {
|
||
int8_t txHalfDbm;
|
||
uint8_t paLfDutyCycle;
|
||
uint8_t paLfSlices;
|
||
} RADIOLIB_LR2021_TABLE_7_16_915_LF[] = {
|
||
/* 22 */ { 44, 7, 6 },
|
||
/* 21 */ { 42, 7, 7 },
|
||
/* 20 */ { 41, 6, 6 },
|
||
/* 19 */ { 39, 6, 6 },
|
||
/* 18 */ { 38, 5, 6 },
|
||
/* 17 */ { 36, 5, 6 },
|
||
/* 16 */ { 36, 4, 4 },
|
||
/* 15 */ { 33, 5, 4 },
|
||
/* 14 */ { 34, 4, 2 },
|
||
/* 13 */ { 31, 4, 3 },
|
||
/* 12 */ { 30, 5, 1 },
|
||
/* 11 */ { 32, 2, 2 },
|
||
/* 10 */ { 32, 2, 1 },
|
||
};
|
||
|
||
// `targetedDbm` integer 10..22 only (Table 7-16 rows).
|
||
static void lr2021Table716LfRow(int8_t targetedDbm, int8_t* txHalfDbm, uint8_t* duty, uint8_t* slices) {
|
||
if(targetedDbm < 10) { targetedDbm = 10; }
|
||
if(targetedDbm > 22) { targetedDbm = 22; }
|
||
const auto& e = RADIOLIB_LR2021_TABLE_7_16_915_LF[22 - targetedDbm];
|
||
*txHalfDbm = e.txHalfDbm;
|
||
*duty = e.paLfDutyCycle;
|
||
*slices = e.paLfSlices;
|
||
}
|
||
|
||
// Table 7-17: Optimal Values for 490 MHz Semtech Reference Design (LF PA). Integer targeted dBm 20..10.
|
||
static const struct {
|
||
int8_t txHalfDbm;
|
||
uint8_t paLfDutyCycle;
|
||
uint8_t paLfSlices;
|
||
} RADIOLIB_LR2021_TABLE_7_17_490_LF[] = {
|
||
/* 20 */ { 40, 7, 7 },
|
||
/* 19 */ { 38, 7, 7 },
|
||
/* 18 */ { 36, 7, 6 },
|
||
/* 17 */ { 34, 7, 6 },
|
||
/* 16 */ { 32, 7, 6 },
|
||
/* 15 */ { 31, 7, 4 },
|
||
/* 14 */ { 31, 6, 4 },
|
||
/* 13 */ { 29, 7, 2 },
|
||
/* 12 */ { 30, 5, 3 },
|
||
/* 11 */ { 29, 5, 2 },
|
||
/* 10 */ { 31, 4, 2 },
|
||
};
|
||
|
||
static void lr2021Table717LfRow(int8_t targetedDbm, int8_t* txHalfDbm, uint8_t* duty, uint8_t* slices) {
|
||
if(targetedDbm < 10) { targetedDbm = 10; }
|
||
if(targetedDbm > 20) { targetedDbm = 20; }
|
||
const auto& e = RADIOLIB_LR2021_TABLE_7_17_490_LF[20 - targetedDbm];
|
||
*txHalfDbm = e.txHalfDbm;
|
||
*duty = e.paLfDutyCycle;
|
||
*slices = e.paLfSlices;
|
||
}
|
||
|
||
// Table 7-18: Optimal Values for 2445 MHz Semtech Reference Design (HF PA). Integer targeted dBm 0..12.
|
||
static const struct {
|
||
int8_t txHalfDbm;
|
||
uint8_t paHfDutyCycle;
|
||
} RADIOLIB_LR2021_TABLE_7_18_2445_HF[] = {
|
||
/* 12 */ { 24, 16 },
|
||
/* 11 */ { 24, 26 },
|
||
/* 10 */ { 24, 30 },
|
||
/* 9 */ { 22, 30 },
|
||
/* 8 */ { 21, 31 },
|
||
/* 7 */ { 18, 30 },
|
||
/* 6 */ { 16, 30 },
|
||
/* 5 */ { 15, 31 },
|
||
/* 4 */ { 10, 25 },
|
||
/* 3 */ { 8, 25 },
|
||
/* 2 */ { 7, 28 },
|
||
/* 1 */ { 6, 30 },
|
||
/* 0 */ { 4, 30 },
|
||
};
|
||
|
||
static void lr2021Table718HfRow(int8_t targetedDbm, int8_t* txHalfDbm, uint8_t* hfDuty) {
|
||
if(targetedDbm < 0) { targetedDbm = 0; }
|
||
if(targetedDbm > 12) { targetedDbm = 12; }
|
||
const auto& e = RADIOLIB_LR2021_TABLE_7_18_2445_HF[12 - targetedDbm];
|
||
*txHalfDbm = e.txHalfDbm;
|
||
*hfDuty = e.paHfDutyCycle;
|
||
}
|
||
|
||
int16_t LR2021::setFrequency(float freq) {
|
||
return(this->setFrequency(freq, false));
|
||
}
|
||
|
||
int16_t LR2021::setFrequency(float freq, bool skipCalibration) {
|
||
#if RADIOLIB_CHECK_PARAMS
|
||
if(!(((freq >= 150.0f) && (freq <= 1090.0f)) ||
|
||
((freq >= 1900.0f) && (freq <= 2200.0f)) ||
|
||
((freq >= 2400.0f) && (freq <= 2500.0f)))) {
|
||
return(RADIOLIB_ERR_INVALID_FREQUENCY);
|
||
}
|
||
#endif
|
||
|
||
// check if we need to recalibrate image
|
||
int16_t state;
|
||
if(!skipCalibration && (fabsf(freq - this->freqMHz) >= RADIOLIB_LR2021_CAL_IMG_FREQ_TRIG_MHZ)) {
|
||
// calibration can fail if there is a strong interfering source
|
||
// run it several times until it passes
|
||
int i = 0;
|
||
for(; i < RADIOLIB_LR2021_MAX_CAL_ATTEMPTS; i++) {
|
||
// get the nearest multiple of 4 MHz
|
||
uint16_t frequencies[3] = { (uint16_t)((freq / 4.0f) + 0.5f), 0, 0 };
|
||
frequencies[0] |= (freq > RADIOLIB_LR2021_LF_CUTOFF_FREQ) ? RADIOLIB_LR2021_CALIBRATE_FE_HF_PATH : RADIOLIB_LR2021_CALIBRATE_FE_LF_PATH;
|
||
state = calibrateFrontEnd(const_cast<const uint16_t*>(frequencies));
|
||
|
||
// if something failed, check the device errors
|
||
if(state != RADIOLIB_ERR_NONE) {
|
||
uint16_t errors = 0;
|
||
getErrors(&errors);
|
||
RADIOLIB_DEBUG_BASIC_PRINTLN("Frontend calibration #%d failed, device errors: 0x%X", i, errors);
|
||
|
||
// if this is caused by something else than RSSI saturation, repeating will not help
|
||
if((errors & RADIOLIB_LR2021_SRC_SATURATION_CALIB_ERR) == 0) {
|
||
return(state);
|
||
}
|
||
|
||
// wait a little while before the next attempt
|
||
this->mod->hal->delay(5);
|
||
|
||
} else {
|
||
// calibration passed
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
if(i == RADIOLIB_LR2021_MAX_CAL_ATTEMPTS) {
|
||
return(RADIOLIB_ERR_FRONTEND_CALIBRATION_FAILED);
|
||
}
|
||
|
||
}
|
||
|
||
// set frequency
|
||
state = setRfFrequency((uint32_t)(freq*1000000.0f));
|
||
RADIOLIB_ASSERT(state);
|
||
this->freqMHz = freq;
|
||
this->highFreq = (freq > RADIOLIB_LR2021_LF_CUTOFF_FREQ);
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::setOutputPower(int8_t power) {
|
||
return(this->setOutputPower(power, 48));
|
||
}
|
||
|
||
int16_t LR2021::setOutputPower(int8_t power, uint32_t rampTimeUs) {
|
||
int16_t state = this->checkOutputPower(power, NULL);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// pa_sel: 0 = LF (Sub-GHz), 1 = HF (1.9–2.5 GHz). Same encoding as lr20xx reference driver.
|
||
uint8_t paSel = this->highFreq ? (uint8_t)1 : (uint8_t)0;
|
||
uint8_t paLfMode = RADIOLIB_LR2021_PA_LF_MODE_FSM;
|
||
uint8_t paLfDutyCycle = RADIOLIB_LR2021_PA_LF_DUTY_CYCLE_UNUSED;
|
||
uint8_t paLfSlices = RADIOLIB_LR2021_PA_LF_SLICES_UNUSED;
|
||
uint8_t paHfDutyCycle = RADIOLIB_LR2021_PA_HF_DUTY_CYCLE_UNUSED;
|
||
// TX_PARAM from tables is signed half-dBm (not always 2 * targeted dBm).
|
||
int8_t lfTxHalfDbm = (int8_t)(power * 2);
|
||
int8_t hfTxHalfDbm = (int8_t)(power * 2);
|
||
|
||
if(this->highFreq) {
|
||
// HF PA: Table 7-18 (2445 MHz); LF nibbles per Semtech reference (7/6).
|
||
paLfDutyCycle = (uint8_t)0x07;
|
||
paLfSlices = (uint8_t)0x06;
|
||
if(power >= 0) {
|
||
lr2021Table718HfRow(power, &hfTxHalfDbm, &paHfDutyCycle);
|
||
} else {
|
||
lr2021Table718HfRow(0, &hfTxHalfDbm, &paHfDutyCycle);
|
||
hfTxHalfDbm = (int8_t)(power * 2);
|
||
}
|
||
} else if(this->freqMHz < RADIOLIB_LR2021_LF_PA_TABLE_490_MHZ_MAX) {
|
||
// LF PA: Table 7-17 (490 MHz ref.), max +20 dBm in table; 21–22 use row 20 PA + requested TX half-dBm.
|
||
if(power > 20) {
|
||
lr2021Table717LfRow(20, &lfTxHalfDbm, &paLfDutyCycle, &paLfSlices);
|
||
lfTxHalfDbm = (int8_t)(power * 2);
|
||
} else if(power >= 10) {
|
||
lr2021Table717LfRow(power, &lfTxHalfDbm, &paLfDutyCycle, &paLfSlices);
|
||
} else {
|
||
lr2021Table717LfRow(10, &lfTxHalfDbm, &paLfDutyCycle, &paLfSlices);
|
||
lfTxHalfDbm = (int8_t)(power * 2);
|
||
}
|
||
} else {
|
||
// LF PA: Table 7-16 (915 MHz ref.)
|
||
if(power >= 10) {
|
||
lr2021Table716LfRow(power, &lfTxHalfDbm, &paLfDutyCycle, &paLfSlices);
|
||
} else {
|
||
lr2021Table716LfRow(10, &lfTxHalfDbm, &paLfDutyCycle, &paLfSlices);
|
||
lfTxHalfDbm = (int8_t)(power * 2);
|
||
}
|
||
}
|
||
|
||
(void)clearErrors();
|
||
|
||
state = setPaConfig(paSel, paLfMode, paLfDutyCycle, paLfSlices, paHfDutyCycle);
|
||
RADIOLIB_ASSERT(state);
|
||
#if RADIOLIB_DEBUG_BASIC
|
||
RADIOLIB_DEBUG_BASIC_PRINTLN("LR2021 PA cfg: hf=%d lf_dc=0x%X lf_sl=0x%X hf_dc=0x%X",
|
||
(int)this->highFreq, (int)paLfDutyCycle, (int)paLfSlices, (int)paHfDutyCycle);
|
||
#endif
|
||
|
||
state = selPa(paSel);
|
||
RADIOLIB_ASSERT(state);
|
||
#if RADIOLIB_DEBUG_BASIC
|
||
RADIOLIB_DEBUG_BASIC_PRINTLN("LR2021 PA sel: %s", paSel ? "HF" : "LF");
|
||
#endif
|
||
|
||
if(this->highFreq) {
|
||
state = setTxParamsHalfDbm(hfTxHalfDbm, roundRampTime(rampTimeUs));
|
||
} else {
|
||
state = setTxParamsHalfDbm(lfTxHalfDbm, roundRampTime(rampTimeUs));
|
||
}
|
||
RADIOLIB_ASSERT(state);
|
||
#if RADIOLIB_DEBUG_BASIC
|
||
uint16_t err = 0;
|
||
if(getErrors(&err) == RADIOLIB_ERR_NONE) {
|
||
RADIOLIB_DEBUG_BASIC_PRINTLN("LR2021 device errors after PA/TX: 0x%X", err);
|
||
}
|
||
#endif
|
||
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::checkOutputPower(int8_t power, int8_t* clipped) {
|
||
if(this->highFreq) {
|
||
if(clipped) {
|
||
*clipped = RADIOLIB_MAX(-19, RADIOLIB_MIN(12, power));
|
||
}
|
||
RADIOLIB_CHECK_RANGE(power, -19, 12, RADIOLIB_ERR_INVALID_OUTPUT_POWER);
|
||
|
||
} else {
|
||
if(clipped) {
|
||
*clipped = RADIOLIB_MAX(-9, RADIOLIB_MIN(22, power));
|
||
}
|
||
RADIOLIB_CHECK_RANGE(power, -9, 22, RADIOLIB_ERR_INVALID_OUTPUT_POWER);
|
||
|
||
}
|
||
|
||
return(RADIOLIB_ERR_NONE);
|
||
}
|
||
|
||
void LR2021::setRfSwitchTable(const uint32_t (&pins)[Module::RFSWITCH_MAX_PINS], const Module::RfSwitchMode_t table[]) {
|
||
// find which pins are used
|
||
// on LR2021, modes are configured per DIO (exact opposite of LR11x0)
|
||
uint8_t dioConfigs[7] = { 0 };
|
||
for(size_t i = 0; i < Module::RFSWITCH_MAX_PINS; i++) {
|
||
// check if this pin is unused
|
||
if(pins[i] == RADIOLIB_NC) { continue; }
|
||
|
||
// only keep DIO pins, there may be some GPIOs in the switch tabke
|
||
if((pins[i] & RFSWITCH_PIN_FLAG) == 0) { continue; }
|
||
|
||
// find modes in which this pin is used
|
||
uint32_t dioNum = RADIOLIB_LRXXXX_DIOx_VAL(pins[i]);
|
||
size_t j = 0;
|
||
while(table[j].mode != LR2021::MODE_END_OF_TABLE) {
|
||
dioConfigs[dioNum] |= (table[j].values[i] == this->mod->hal->GpioLevelHigh) ? (1UL << (table[j].mode - 1)) : 0;
|
||
j++;
|
||
}
|
||
|
||
// For DIO = 5, only DIO_SLEEP_PULL_UP is accepted. Otherwise the SetDioFunction returns FAIL.
|
||
uint8_t pull = dioNum == 0 ? RADIOLIB_LR2021_DIO_SLEEP_PULL_UP : RADIOLIB_LR2021_DIO_SLEEP_PULL_AUTO;
|
||
// enable RF control for this pin and set the modes in which it is active
|
||
(void)this->setDioFunction(dioNum + 5, RADIOLIB_LR2021_DIO_FUNCTION_RF_SWITCH, pull);
|
||
(void)this->setDioRfSwitchConfig(dioNum + 5, dioConfigs[i]);
|
||
}
|
||
}
|
||
|
||
int16_t LR2021::setBandwidth(float bw) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// convert to int to avoid bunch of math
|
||
int bw_div2 = bw / 2 + 0.01f;
|
||
|
||
// check allowed bandwidth values
|
||
switch (bw_div2) {
|
||
case 15:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_31;
|
||
break;
|
||
case 20:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_41;
|
||
break;
|
||
case 31:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_62;
|
||
break;
|
||
case 41:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_83;
|
||
break;
|
||
case 50:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_101;
|
||
break;
|
||
case 101:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_203;
|
||
break;
|
||
case 62:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_125;
|
||
break;
|
||
case 125:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_250;
|
||
break;
|
||
case 203:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_406;
|
||
break;
|
||
case 250:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_500;
|
||
break;
|
||
case 406:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_812;
|
||
break;
|
||
case 500:
|
||
this->bandwidth = RADIOLIB_LR2021_LORA_BW_1000;
|
||
break;
|
||
default:
|
||
return(RADIOLIB_ERR_INVALID_BANDWIDTH);
|
||
}
|
||
|
||
// update modulation parameters
|
||
this->bandwidthKhz = bw;
|
||
return(setLoRaModulationParams(this->spreadingFactor, this->bandwidth, this->codingRate, this->ldrOptimize));
|
||
}
|
||
|
||
int16_t LR2021::setSpreadingFactor(uint8_t sf, bool legacy) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
RADIOLIB_CHECK_RANGE(sf, 5, 12, RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
|
||
|
||
//! \TODO: [LR2021] enable SF6 legacy mode
|
||
if(legacy && (sf == 6)) {
|
||
//this->mod->SPIsetRegValue(RADIOLIB_LR11X0_REG_SF6_SX127X_COMPAT, RADIOLIB_LR11X0_SF6_SX127X, 18, 18);
|
||
}
|
||
|
||
// update modulation parameters
|
||
this->spreadingFactor = sf;
|
||
return(setLoRaModulationParams(this->spreadingFactor, this->bandwidth, this->codingRate, this->ldrOptimize));
|
||
}
|
||
|
||
int16_t LR2021::setCodingRate(uint8_t cr, bool longInterleave) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
RADIOLIB_CHECK_RANGE(cr, 4, 8, RADIOLIB_ERR_INVALID_CODING_RATE);
|
||
|
||
if(longInterleave) {
|
||
switch(cr) {
|
||
case 4:
|
||
this->codingRate = 0;
|
||
break;
|
||
case 5:
|
||
case 6:
|
||
this->codingRate = cr;
|
||
break;
|
||
case 8:
|
||
this->codingRate = cr - 1;
|
||
break;
|
||
default:
|
||
return(RADIOLIB_ERR_INVALID_CODING_RATE);
|
||
}
|
||
|
||
} else {
|
||
this->codingRate = cr - 4;
|
||
|
||
}
|
||
|
||
// update modulation parameters
|
||
return(setLoRaModulationParams(this->spreadingFactor, this->bandwidth, this->codingRate, this->ldrOptimize));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_FLRC) {
|
||
if(cr > RADIOLIB_LR2021_FLRC_CR_2_3) {
|
||
return(RADIOLIB_ERR_INVALID_CODING_RATE);
|
||
}
|
||
|
||
// update modulation parameters
|
||
this->codingRateFlrc = cr;
|
||
return(setFlrcModulationParams(this->bitRateFlrc, this->codingRateFlrc, this->pulseShape));
|
||
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setSyncWord(uint8_t syncWord) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
return(setLoRaSyncword(syncWord));
|
||
}
|
||
|
||
int16_t LR2021::setPreambleLength(size_t preambleLength) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
this->preambleLengthLoRa = preambleLength;
|
||
return(setLoRaPacketParams(this->preambleLengthLoRa, this->headerType, this->implicitLen, this->crcTypeLoRa, (uint8_t)this->invertIQEnabled));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
this->preambleLengthGFSK = preambleLength;
|
||
this->preambleDetLength = (preambleLength / 8) << 3;
|
||
return(setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_OOK) {
|
||
this->preambleLengthGFSK = preambleLength;
|
||
this->preambleDetLength = (preambleLength / 8) << 3;
|
||
return(setOokPacketParams(this->preambleLengthGFSK, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_FLRC) {
|
||
if((preambleLength % 4) != 0) {
|
||
return(RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH);
|
||
}
|
||
this->preambleLengthGFSK = (preambleLength / 4) - 1;
|
||
return(setFlrcPacketParams(this->preambleLengthGFSK, this->syncWordLength, 1, 0x01, this->packetType == RADIOLIB_LR2021_GFSK_OOK_PACKET_FORMAT_FIXED, this->crcLenGFSK, RADIOLIB_LR2021_MAX_PACKET_LENGTH));
|
||
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setTCXO(float voltage, uint32_t delay) {
|
||
// check if TCXO is enabled at all
|
||
if(this->XTAL) {
|
||
return(RADIOLIB_ERR_INVALID_TCXO_VOLTAGE);
|
||
}
|
||
|
||
// set mode to standby
|
||
standby();
|
||
|
||
// check oscillator startup error flag and clear it
|
||
uint16_t errors = 0;
|
||
int16_t state = getErrors(&errors);
|
||
RADIOLIB_ASSERT(state);
|
||
if(errors & RADIOLIB_LR2021_HF_XOSC_START_ERR) {
|
||
clearErrors();
|
||
}
|
||
|
||
// check 0 V disable
|
||
if(fabsf(voltage - 0.0f) <= 0.001f) {
|
||
setTcxoMode(0, 0);
|
||
return(reset());
|
||
}
|
||
|
||
// check allowed voltage values
|
||
uint8_t tune = 0;
|
||
if(fabsf(voltage - 1.6f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_1_6;
|
||
} else if(fabsf(voltage - 1.7f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_1_7;
|
||
} else if(fabsf(voltage - 1.8f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_1_8;
|
||
} else if(fabsf(voltage - 2.2f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_2_2;
|
||
} else if(fabsf(voltage - 2.4f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_2_4;
|
||
} else if(fabsf(voltage - 2.7f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_2_7;
|
||
} else if(fabsf(voltage - 3.0f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_3_0;
|
||
} else if(fabsf(voltage - 3.3f) <= 0.001f) {
|
||
tune = RADIOLIB_LRXXXX_TCXO_VOLTAGE_3_3;
|
||
} else {
|
||
return(RADIOLIB_ERR_INVALID_TCXO_VOLTAGE);
|
||
}
|
||
|
||
// calculate delay value
|
||
uint32_t delayValue = (uint32_t)((float)delay / 30.52f);
|
||
if(delayValue == 0) {
|
||
delayValue = 1;
|
||
}
|
||
|
||
// enable TCXO control
|
||
return(setTcxoMode(tune, delayValue));
|
||
}
|
||
|
||
int16_t LR2021::setCRC(uint8_t len, uint32_t initial, uint32_t polynomial, bool inverted) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
// LoRa CRC doesn't allow to set CRC polynomial, initial value, or inversion
|
||
this->crcTypeLoRa = len > 0;
|
||
return(setLoRaPacketParams(this->preambleLengthLoRa, this->headerType, this->implicitLen, this->crcTypeLoRa, (uint8_t)this->invertIQEnabled));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
if(len > 4) {
|
||
return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
|
||
}
|
||
|
||
this->crcTypeGFSK = len;
|
||
if((this->crcTypeGFSK != RADIOLIB_LR2021_GFSK_OOK_CRC_OFF) && inverted) {
|
||
this->crcTypeGFSK += 0x08;
|
||
}
|
||
|
||
state = setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
return(setGfskCrcParams(polynomial, initial));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_OOK) {
|
||
if(len > 4) {
|
||
return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
|
||
}
|
||
|
||
this->crcTypeGFSK = len;
|
||
if((this->crcTypeGFSK != RADIOLIB_LR2021_GFSK_OOK_CRC_OFF) && inverted) {
|
||
this->crcTypeGFSK += 0x08;
|
||
}
|
||
|
||
state = setOokPacketParams(this->preambleLengthGFSK, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
return(setOokCrcParams(polynomial, initial));
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_FLRC) {
|
||
if((len == 1) || (len > 4)) {
|
||
return(RADIOLIB_ERR_INVALID_CRC_CONFIGURATION);
|
||
}
|
||
|
||
this->crcLenGFSK = len ? len - 1 : 0;
|
||
return(setFlrcPacketParams(this->preambleLengthGFSK, this->syncWordLength, 1, 0x01, this->packetType == RADIOLIB_LR2021_GFSK_OOK_PACKET_FORMAT_FIXED, this->crcLenGFSK, RADIOLIB_LR2021_MAX_PACKET_LENGTH));
|
||
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::invertIQ(bool enable) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
this->invertIQEnabled = enable;
|
||
return(setLoRaPacketParams(this->preambleLengthLoRa, this->headerType, this->implicitLen, this->crcTypeLoRa, (uint8_t)this->invertIQEnabled));
|
||
}
|
||
|
||
int16_t LR2021::setBitRate(float br) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
RADIOLIB_CHECK_RANGE(br, 0.5f, 2000.0f, RADIOLIB_ERR_INVALID_BIT_RATE);
|
||
//! \TODO: [LR2021] implement fractional bit rate configuration
|
||
this->bitRate = br * 1000.0f;
|
||
state = setGfskModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, this->frequencyDev);
|
||
return(state);
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_OOK) {
|
||
RADIOLIB_CHECK_RANGE(br, 0.5f, 2000.0f, RADIOLIB_ERR_INVALID_BIT_RATE);
|
||
//! \TODO: [LR2021] implement fractional bit rate configuration
|
||
this->bitRate = br * 1000.0f;
|
||
//! \TODO: [LR2021] implement OOK magnitude depth configuration
|
||
state = setOokModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, RADIOLIB_LR2021_OOK_DEPTH_FULL);
|
||
return(state);
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_FLRC) {
|
||
if((uint16_t)br == 260) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_260;
|
||
} else if((uint16_t)br == 325) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_325;
|
||
} else if((uint16_t)br == 520) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_520;
|
||
} else if((uint16_t)br == 650) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_650;
|
||
} else if((uint16_t)br == 1040) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_1040;
|
||
} else if((uint16_t)br == 1300) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_1300;
|
||
} else if((uint16_t)br == 2080) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_2080;
|
||
} else if((uint16_t)br == 2600) {
|
||
this->bitRateFlrc = RADIOLIB_LR2021_FLRC_BR_2600;
|
||
} else {
|
||
return(RADIOLIB_ERR_INVALID_BIT_RATE);
|
||
}
|
||
|
||
// it is slightly weird to reuse the GFSK bitrate variable in this way
|
||
// but if GFSK gets enabled it should get reset anyway ... I think
|
||
this->bitRate = br;
|
||
|
||
// update modulation parameters
|
||
return(setFlrcModulationParams(this->bitRateFlrc, this->codingRateFlrc, this->pulseShape));
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setFrequencyDeviation(float freqDev) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// set frequency deviation to lowest available setting (required for digimodes)
|
||
float newFreqDev = freqDev;
|
||
if(freqDev < 0.6f) {
|
||
newFreqDev = 0.6f;
|
||
}
|
||
|
||
RADIOLIB_CHECK_RANGE(newFreqDev, 0.6f, 500.0f, RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
|
||
this->frequencyDev = newFreqDev * 1000.0f;
|
||
state = setGfskModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, this->frequencyDev);
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::setRxBandwidth(float rxBw) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(!((type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) ||
|
||
(type == RADIOLIB_LR2021_PACKET_TYPE_OOK))) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
const uint8_t rxBwLut[] = {
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_4_8,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_5_8,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_7_4,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_9_7,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_12_0,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_14_9,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_19_2,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_23_1,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_29_8,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_38_5,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_46_3,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_59_5,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_76_9,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_92_6,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_119_0,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_153_8,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_185_2,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_238_1,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_307_7,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_370_4,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_476_2,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_555_6,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_666_7,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_769_2,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_1111,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_2222,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_2666,
|
||
RADIOLIB_LR2021_GFSK_OOK_RX_BW_3076,
|
||
};
|
||
|
||
state = findRxBw(rxBw, rxBwLut, sizeof(rxBwLut)/sizeof(rxBwLut[0]), 3076.0f, &this->rxBandwidth);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// update modulation parameters
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
state = setGfskModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, this->frequencyDev);
|
||
} else {
|
||
state = setOokModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, RADIOLIB_LR2021_OOK_DEPTH_FULL);
|
||
}
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::setSyncWord(uint8_t* syncWord, size_t len) {
|
||
if(len > RADIOLIB_LR2021_GFSK_SYNC_WORD_LEN) {
|
||
return(RADIOLIB_ERR_INVALID_SYNC_WORD);
|
||
}
|
||
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
uint32_t sync = 0;
|
||
switch(type) {
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_GFSK):
|
||
// default to MSB-first
|
||
return(setGfskSyncword(const_cast<const uint8_t*>(syncWord), len, true));
|
||
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_OOK):
|
||
// default to MSB-first
|
||
return(setOokSyncword(const_cast<const uint8_t*>(syncWord), len, true));
|
||
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_LORA):
|
||
// with length set to 1 and LoRa modem active, assume it is the LoRa sync word
|
||
if(len > 1) {
|
||
return(RADIOLIB_ERR_INVALID_SYNC_WORD);
|
||
}
|
||
return(setSyncWord(syncWord[0]));
|
||
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_LR_FHSS):
|
||
// with length set to 4 and LR-FHSS modem active, assume it is the LR-FHSS sync word
|
||
if(len != sizeof(uint32_t)) {
|
||
return(RADIOLIB_ERR_INVALID_SYNC_WORD);
|
||
}
|
||
memcpy(&sync, syncWord, sizeof(uint32_t));
|
||
return(lrFhssSetSyncword(sync));
|
||
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_FLRC):
|
||
// FLRC requires 16 or 32-bit sync word
|
||
if(!((len == 0) || (len == 2) || (len == 4))) {
|
||
return(RADIOLIB_ERR_INVALID_SYNC_WORD);
|
||
}
|
||
|
||
// update sync word length
|
||
this->syncWordLength = len;
|
||
state = setFlrcPacketParams(this->preambleLengthGFSK, this->syncWordLength, 1, 0x01, this->packetType == RADIOLIB_LR2021_GFSK_OOK_PACKET_FORMAT_FIXED, this->crcLenGFSK, RADIOLIB_LR2021_MAX_PACKET_LENGTH);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
sync |= (uint32_t)syncWord[0] << 24;
|
||
sync |= (uint32_t)syncWord[1] << 16;
|
||
sync |= (uint32_t)syncWord[2] << 8;
|
||
sync |= (uint32_t)syncWord[3];
|
||
return(setFlrcSyncWord(1, sync));
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setDataShaping(uint8_t sh) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set data shaping
|
||
switch(sh) {
|
||
case RADIOLIB_SHAPING_NONE:
|
||
this->pulseShape = RADIOLIB_LR2021_GFSK_BPSK_FLRC_OOK_SHAPING_NONE;
|
||
break;
|
||
case RADIOLIB_SHAPING_0_3:
|
||
this->pulseShape = RADIOLIB_LR2021_GFSK_BPSK_FLRC_OOK_SHAPING_GAUSS_BT_0_3;
|
||
break;
|
||
case RADIOLIB_SHAPING_0_5:
|
||
this->pulseShape = RADIOLIB_LR2021_GFSK_BPSK_FLRC_OOK_SHAPING_GAUSS_BT_0_5;
|
||
break;
|
||
case RADIOLIB_SHAPING_0_7:
|
||
this->pulseShape = RADIOLIB_LR2021_GFSK_BPSK_FLRC_OOK_SHAPING_GAUSS_BT_0_7;
|
||
break;
|
||
case RADIOLIB_SHAPING_1_0:
|
||
this->pulseShape = RADIOLIB_LR2021_GFSK_BPSK_FLRC_OOK_SHAPING_GAUSS_BT_1_0;
|
||
break;
|
||
default:
|
||
return(RADIOLIB_ERR_INVALID_DATA_SHAPING);
|
||
}
|
||
|
||
// update modulation parameters
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_FLRC) {
|
||
return(setFlrcModulationParams(this->bitRateFlrc, this->codingRateFlrc, this->pulseShape));
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
return(setGfskModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, this->frequencyDev));
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_OOK) {
|
||
return(setOokModulationParams(this->bitRate, this->pulseShape, this->rxBandwidth, RADIOLIB_LR2021_OOK_DEPTH_FULL));
|
||
}
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setEncoding(uint8_t encoding) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
switch(type) {
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_GFSK):
|
||
return(setWhitening(encoding == RADIOLIB_ENCODING_WHITENING));
|
||
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_OOK):
|
||
switch(encoding) {
|
||
case(RADIOLIB_ENCODING_NRZ):
|
||
case(RADIOLIB_ENCODING_WHITENING):
|
||
return(setWhitening(encoding == RADIOLIB_ENCODING_WHITENING));
|
||
|
||
case(RADIOLIB_ENCODING_MANCHESTER):
|
||
state = setWhitening(false);
|
||
RADIOLIB_ASSERT(state);
|
||
this->whitening = RADIOLIB_LR2021_OOK_MANCHESTER_ON;
|
||
return(setOokPacketParams(this->preambleLengthGFSK, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
|
||
case(RADIOLIB_ENCODING_MANCHESTER_INV):
|
||
state = setWhitening(false);
|
||
RADIOLIB_ASSERT(state);
|
||
this->whitening = RADIOLIB_LR2021_OOK_MANCHESTER_ON_INV;
|
||
return(setOokPacketParams(this->preambleLengthGFSK, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
|
||
default:
|
||
return(RADIOLIB_ERR_INVALID_ENCODING);
|
||
}
|
||
|
||
default:
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::fixedPacketLengthMode(uint8_t len) {
|
||
return(setPacketMode(RADIOLIB_LR2021_GFSK_OOK_PACKET_FORMAT_FIXED, len));
|
||
}
|
||
|
||
int16_t LR2021::variablePacketLengthMode(uint8_t maxLen) {
|
||
return(setPacketMode(RADIOLIB_LR2021_GFSK_OOK_PACKET_FORMAT_VARIABLE_8BIT, maxLen));
|
||
}
|
||
|
||
int16_t LR2021::setWhitening(bool enabled, uint16_t initial) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
switch(type) {
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_GFSK):
|
||
//! \TODO: [LR2021] Implement SX128x-compatible whitening
|
||
if(enabled) {
|
||
state = setGfskWhiteningParams(RADIOLIB_LR2021_GFSK_WHITENING_TYPE_SX126X_LR11XX, initial);
|
||
RADIOLIB_ASSERT(state);
|
||
}
|
||
this->whitening = enabled;
|
||
return(setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
|
||
case(RADIOLIB_LR2021_PACKET_TYPE_OOK):
|
||
this->whitening = enabled;
|
||
if(enabled) {
|
||
//! \TODO: [LR2021] Implement configurable index and polynomial
|
||
state = setOokWhiteningParams(12, 0x01FF, initial);
|
||
} else {
|
||
state = setOokWhiteningParams(0, 0, 0);
|
||
}
|
||
RADIOLIB_ASSERT(state);
|
||
return(setOokPacketParams(this->preambleLengthGFSK, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setDataRate(DataRate_t dr, ModemType_t modem ) {
|
||
// get the current modem
|
||
ModemType_t currentModem;
|
||
int16_t state = this->getModem(¤tModem);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// switch over if the requested modem is different
|
||
if(modem != RADIOLIB_MODEM_NONE && modem != currentModem) {
|
||
state = this->standby();
|
||
RADIOLIB_ASSERT(state);
|
||
state = this->setModem(modem);
|
||
RADIOLIB_ASSERT(state);
|
||
}
|
||
|
||
if(modem == RADIOLIB_MODEM_NONE) {
|
||
modem = currentModem;
|
||
}
|
||
|
||
// select interpretation based on modem
|
||
if(modem == RADIOLIB_MODEM_FSK) {
|
||
// set the bit rate
|
||
state = this->setBitRate(dr.fsk.bitRate);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set the frequency deviation
|
||
state = this->setFrequencyDeviation(dr.fsk.freqDev);
|
||
|
||
} else if(modem == RADIOLIB_MODEM_LORA) {
|
||
// set the spreading factor
|
||
state = this->setSpreadingFactor(dr.lora.spreadingFactor);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set the bandwidth
|
||
state = this->setBandwidth(dr.lora.bandwidth);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set the coding rate
|
||
state = this->setCodingRate(dr.lora.codingRate);
|
||
|
||
} else if(modem == RADIOLIB_MODEM_LRFHSS) {
|
||
// set the basic config
|
||
state = this->setLrFhssConfig(dr.lrFhss.bw, dr.lrFhss.cr);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set hopping grid
|
||
this->lrFhssGrid = dr.lrFhss.narrowGrid ? RADIOLIB_LRXXXX_LR_FHSS_GRID_STEP_NON_FCC : RADIOLIB_LRXXXX_LR_FHSS_GRID_STEP_FCC;
|
||
|
||
}
|
||
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::checkDataRate(DataRate_t dr, ModemType_t modem) {
|
||
int16_t state = RADIOLIB_ERR_UNKNOWN;
|
||
|
||
// retrieve modem if not supplied
|
||
if(modem == RADIOLIB_MODEM_NONE) {
|
||
state = this->getModem(&modem);
|
||
RADIOLIB_ASSERT(state);
|
||
}
|
||
|
||
// select interpretation based on modem
|
||
if(modem == RADIOLIB_MODEM_FSK) {
|
||
RADIOLIB_CHECK_RANGE(dr.fsk.bitRate, 0.5f, 2000.0f, RADIOLIB_ERR_INVALID_BIT_RATE);
|
||
RADIOLIB_CHECK_RANGE(dr.fsk.freqDev, 0.6f, 500.0f, RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
|
||
return(RADIOLIB_ERR_NONE);
|
||
|
||
} else if(modem == RADIOLIB_MODEM_LORA) {
|
||
RADIOLIB_CHECK_RANGE(dr.lora.spreadingFactor, 5, 12, RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
|
||
RADIOLIB_CHECK_RANGE(dr.lora.bandwidth, 0.0f, 510.0f, RADIOLIB_ERR_INVALID_BANDWIDTH);
|
||
RADIOLIB_CHECK_RANGE(dr.lora.codingRate, 4, 8, RADIOLIB_ERR_INVALID_CODING_RATE);
|
||
return(RADIOLIB_ERR_NONE);
|
||
|
||
}
|
||
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::setLrFhssConfig(uint8_t bw, uint8_t cr, uint8_t hdrCount, uint16_t hopSeed) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_LR_FHSS) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// check and cache all parameters
|
||
RADIOLIB_CHECK_RANGE((int8_t)cr, (int8_t)RADIOLIB_LRXXXX_LR_FHSS_CR_5_6, (int8_t)RADIOLIB_LRXXXX_LR_FHSS_CR_1_3, RADIOLIB_ERR_INVALID_CODING_RATE);
|
||
this->lrFhssCr = cr;
|
||
RADIOLIB_CHECK_RANGE((int8_t)bw, (int8_t)RADIOLIB_LRXXXX_LR_FHSS_BW_39_06, (int8_t)RADIOLIB_LRXXXX_LR_FHSS_BW_1574_2, RADIOLIB_ERR_INVALID_BANDWIDTH);
|
||
this->lrFhssBw = bw;
|
||
RADIOLIB_CHECK_RANGE(hdrCount, 1, 4, RADIOLIB_ERR_INVALID_BIT_RANGE);
|
||
this->lrFhssHdrCount = hdrCount;
|
||
RADIOLIB_CHECK_RANGE((int16_t)hopSeed, (int16_t)0x000, (int16_t)0x1FF, RADIOLIB_ERR_INVALID_DATA_SHAPING);
|
||
this->lrFhssHopSeq = hopSeed;
|
||
return(RADIOLIB_ERR_NONE);
|
||
}
|
||
|
||
int16_t LR2021::setRxBoostedGainMode(uint8_t level) {
|
||
int16_t state = this->setRxPath(this->highFreq ? RADIOLIB_LR2021_RX_PATH_HF : RADIOLIB_LR2021_RX_PATH_LF, this->highFreq ? this->gainModeHf : this->gainModeLf);
|
||
RADIOLIB_ASSERT(state);
|
||
if(this->highFreq) {
|
||
this->gainModeHf = level;
|
||
} else {
|
||
this->gainModeLf = level;
|
||
}
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::setPacketMode(uint8_t mode, uint8_t len) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type == RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
// set requested packet mode
|
||
state = setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, mode, len, this->crcTypeGFSK, this->whitening);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// update cached value
|
||
this->packetType = mode;
|
||
return(state);
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_OOK) {
|
||
// set requested packet mode
|
||
state = setOokPacketParams(this->preambleLengthGFSK, this->addrComp, mode, len, this->crcTypeGFSK, this->whitening);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// update cached value
|
||
this->packetType = mode;
|
||
return(state);
|
||
|
||
} else if(type == RADIOLIB_LR2021_PACKET_TYPE_FLRC) {
|
||
state = setFlrcPacketParams(this->preambleLengthGFSK, this->syncWordLength, 1, 0x01, mode == RADIOLIB_LR2021_GFSK_OOK_PACKET_FORMAT_FIXED, this->crcLenGFSK, len);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
this->packetType = mode;
|
||
return(state);
|
||
|
||
}
|
||
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
int16_t LR2021::setLoRaHeaderType(uint8_t hdrType, size_t len) {
|
||
uint8_t modem = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&modem);
|
||
RADIOLIB_ASSERT(state);
|
||
if(modem != RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// set requested packet mode
|
||
state = setLoRaPacketParams(this->preambleLengthLoRa, hdrType, len, this->crcTypeLoRa, this->invertIQEnabled);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// update cached value
|
||
this->headerType = hdrType;
|
||
this->implicitLen = len;
|
||
|
||
return(state);
|
||
}
|
||
|
||
int16_t LR2021::implicitHeader(size_t len) {
|
||
return(this->setLoRaHeaderType(RADIOLIB_LR2021_LORA_HEADER_IMPLICIT, len));
|
||
}
|
||
|
||
int16_t LR2021::explicitHeader() {
|
||
return(this->setLoRaHeaderType(RADIOLIB_LR2021_LORA_HEADER_EXPLICIT));
|
||
}
|
||
|
||
int16_t LR2021::setNodeAddress(uint8_t nodeAddr) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// enable address filtering (node only)
|
||
this->addrComp = RADIOLIB_LR2021_GFSK_OOK_ADDR_FILT_NODE;
|
||
state = setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set node address
|
||
this->node = nodeAddr;
|
||
return(setGfskAddress(this->node, 0));
|
||
}
|
||
|
||
int16_t LR2021::setBroadcastAddress(uint8_t broadAddr) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// enable address filtering (node and broadcast)
|
||
this->addrComp = RADIOLIB_LR2021_GFSK_OOK_ADDR_FILT_NODE_BROADCAST;
|
||
state = setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
// set node and broadcast address
|
||
return(setGfskAddress(this->node, broadAddr));
|
||
}
|
||
|
||
int16_t LR2021::disableAddressFiltering() {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_GFSK) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
// disable address filtering
|
||
this->addrComp = RADIOLIB_LR2021_GFSK_OOK_ADDR_FILT_DISABLED;
|
||
return(setGfskPacketParams(this->preambleLengthGFSK, this->preambleDetLength, false, false, this->addrComp, this->packetType, RADIOLIB_LR2021_MAX_PACKET_LENGTH, this->crcTypeGFSK, this->whitening));
|
||
}
|
||
|
||
int16_t LR2021::ookDetector(uint16_t pattern, uint8_t len, uint8_t repeats, bool syncRaw, bool rising, uint8_t sofLen) {
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_OOK) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
return(setOokDetector(pattern, len - 1, repeats, syncRaw, rising, sofLen));
|
||
}
|
||
|
||
int16_t LR2021::setOokDetectionThreshold(int16_t level) {
|
||
int16_t levelRaw = 64 + level;
|
||
return(this->writeRegMemMask32(RADIOLIB_LR2021_REG_OOK_DETECTION_THRESHOLD, (0x7FUL << 20), (uint32_t)levelRaw << 20));
|
||
}
|
||
|
||
int16_t LR2021::setSideDetector(const LR2021LoRaSideDetector_t* cfg, size_t numDetectors) {
|
||
// some basic sanity checks
|
||
if((cfg == nullptr) || (numDetectors == 0)) {
|
||
return(RADIOLIB_ERR_NONE);
|
||
}
|
||
|
||
if(numDetectors > 3) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
|
||
// if bandwidth is higher than 500 kHz, at most 2 side detectors are allowed
|
||
if((this->bandwidthKhz > 500.0f) && (numDetectors > 2)) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
|
||
// if the primary spreading factor is 10, 11 or 12, at most 2 side detectors are allowed
|
||
if((this->spreadingFactor >= 10) && (numDetectors > 2)) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
|
||
// condition of the primary spreading factor being the smallest/largest is not checked
|
||
// this is intentional, because it depends on whether the user wants to start Rx or CAD
|
||
|
||
uint8_t detectors[3] = { 0 };
|
||
uint8_t syncWords[3] = { 0 };
|
||
uint8_t minSf = this->spreadingFactor;
|
||
for(size_t i = 0; i < numDetectors; i++) {
|
||
// all side-detector spreading factors must be higher than the primary one
|
||
//! \todo [LR2021] implement multi-SF for CAD (main SF must be smallest!)
|
||
if(this->spreadingFactor >= cfg[i].sf) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
|
||
// the difference between maximum and minimum spreading factor used must be less than or equal to 4
|
||
if(cfg[i].sf - minSf > 4) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
|
||
if(cfg[i].sf < minSf) { minSf = cfg[i].sf; }
|
||
|
||
detectors[i] = cfg[i].sf << 4 | cfg[i].ldro << 2 | cfg[i].invertIQ;
|
||
syncWords[i] = cfg[i].syncWord;
|
||
}
|
||
|
||
// all spreading factors must be different
|
||
if(numDetectors >= 2) {
|
||
if(cfg[0].sf == cfg[1].sf) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
}
|
||
|
||
if(numDetectors == 3) {
|
||
if((cfg[1].sf == cfg[2].sf) || (cfg[0].sf == cfg[2].sf)) {
|
||
return(RADIOLIB_ERR_INVALID_SIDE_DETECT);
|
||
}
|
||
}
|
||
|
||
// check active modem
|
||
uint8_t type = RADIOLIB_LR2021_PACKET_TYPE_NONE;
|
||
int16_t state = getPacketType(&type);
|
||
RADIOLIB_ASSERT(state);
|
||
if(type != RADIOLIB_LR2021_PACKET_TYPE_LORA) {
|
||
return(RADIOLIB_ERR_WRONG_MODEM);
|
||
}
|
||
|
||
state = setLoRaSideDetConfig(detectors, numDetectors);
|
||
RADIOLIB_ASSERT(state);
|
||
|
||
return(setLoRaSideDetSyncword(syncWords, numDetectors));
|
||
}
|
||
|
||
int16_t LR2021::setGain(uint8_t gain) {
|
||
if(gain > 13) {
|
||
return(RADIOLIB_ERR_INVALID_GAIN);
|
||
}
|
||
return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_AGC_GAIN_MANUAL, true, &gain, sizeof(gain)));
|
||
}
|
||
|
||
#endif
|