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

Minor formatting changes

Browse source
This commit is contained in:
jgromes 2019-12-05 14:38:44 +01:00
parent 8a4cae9411
commit f543436647
2 changed files with 37 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
src/modules/SX126x/SX126x.cpp
View file

@ -454,41 +454,37 @@ int16_t SX126x::startReceive(uint32_t timeout) {
return(state); return(state);
} }
int16_t SX126x::startReceiveDutyCycle(uint32_t rxPeriod_us, uint32_t sleepPeriod_us) int16_t SX126x::startReceiveDutyCycle(uint32_t rxPeriod, uint32_t sleepPeriod) {
{ // datasheet claims time to go to sleep is ~500us, same to wake up, compensate for that with 1 ms + TCXO delay
// datasheet claims time to go to sleep is ~500us, same to wake up. uint32_t transitionTime = _tcxoDelay + 1000;
// compensate for that 1ms + tcxo delay. sleepPeriod -= transitionTime;
uint32_t transitionTime = _tcxoDelay_us + 1000;
sleepPeriod_us -= transitionTime;
// divide by 15.625 // divide by 15.625
uint32_t rxPeriodRaw = (rxPeriod_us * 8) / 125; uint32_t rxPeriodRaw = (rxPeriod * 8) / 125;
uint32_t sleepPeriodRaw = (sleepPeriod_us * 8) / 125; uint32_t sleepPeriodRaw = (sleepPeriod * 8) / 125;
// 24 bit limit. Also give an error if the user passes zero values (likely unintentional) // check 24 bit limit and zero value (likely not intended)
if ((rxPeriodRaw & 0xFF000000) || (rxPeriodRaw == 0)) { if((rxPeriodRaw & 0xFF000000) || (rxPeriodRaw == 0)) {
return(ERR_INVALID_RX_PERIOD); return(ERR_INVALID_RX_PERIOD);
} }
// this check of the high byte also catches underflow when we subtracted transitionTime // this check of the high byte also catches underflow when we subtracted transitionTime
if ((sleepPeriodRaw & 0xFF000000) || (sleepPeriodRaw == 0)) { if((sleepPeriodRaw & 0xFF000000) || (sleepPeriodRaw == 0)) {
return(ERR_INVALID_SLEEP_PERIOD); return(ERR_INVALID_SLEEP_PERIOD);
} }
int16_t state = startReceiveCommon(); int16_t state = startReceiveCommon();
if (state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
uint8_t data[6] = { uint8_t data[6] = {(rxPeriodRaw >> 16) & 0xFF, (rxPeriodRaw >> 8) & 0xFF, rxPeriodRaw & 0xFF,
(rxPeriodRaw >> 16) & 0xFF, (rxPeriodRaw >> 8) & 0xFF, rxPeriodRaw & 0xFF, (sleepPeriodRaw >> 16) & 0xFF, (sleepPeriodRaw >> 8) & 0xFF, sleepPeriodRaw & 0xFF};
(sleepPeriodRaw >> 16) & 0xFF, (sleepPeriodRaw >> 8) & 0xFF, sleepPeriodRaw & 0xFF
};
return(SPIwriteCommand(SX126X_CMD_SET_RX_DUTY_CYCLE, data, 6)); return(SPIwriteCommand(SX126X_CMD_SET_RX_DUTY_CYCLE, data, 6));
} }
int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_t minSymbols) int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_t minSymbols) {
{ if(senderPreambleLength == 0) {
if (senderPreambleLength == 0) {
senderPreambleLength = _preambleLength; senderPreambleLength = _preambleLength;
} }
@ -498,37 +494,37 @@ int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_
uint16_t sleepSymbols = senderPreambleLength - 2 * minSymbols; uint16_t sleepSymbols = senderPreambleLength - 2 * minSymbols;
// if we're not to sleep at all, just use the standard startReceive. // if we're not to sleep at all, just use the standard startReceive.
if (2 * minSymbols > senderPreambleLength) { if(2 * minSymbols > senderPreambleLength) {
return(startReceive()); return(startReceive());
} }
uint32_t symbolLength_us = ((uint32_t)(10 * 1000) << _sf) / (10 * _bwKhz); uint32_t symbolLength = ((uint32_t)(10 * 1000) << _sf) / (10 * _bwKhz);
uint32_t sleepPeriod_us = symbolLength_us * sleepSymbols; uint32_t sleepPeriod = symbolLength * sleepSymbols;
RADIOLIB_DEBUG_PRINT(F("Auto sleep period: ")); RADIOLIB_DEBUG_PRINT(F("Auto sleep period: "));
RADIOLIB_DEBUG_PRINTLN(sleepPeriod_us); RADIOLIB_DEBUG_PRINTLN(sleepPeriod);
// when the unit detects a preamble, it starts a timer that will timeout if it doesn't receive a header in time. // when the unit detects a preamble, it starts a timer that will timeout if it doesn't receive a header in time.
// the duration is sleepPeriod + 2 * wakePeriod. // the duration is sleepPeriod + 2 * wakePeriod.
// The sleepPeriod doesn't take into account shutdown and startup time for the unit (~1ms) // The sleepPeriod doesn't take into account shutdown and startup time for the unit (~1ms)
// We need to ensure that the timout is longer than senderPreambleLength. // We need to ensure that the timout is longer than senderPreambleLength.
// So we must satisfy: wakePeriod > (preamblePeriod - (sleepPeriod - 1000)) / 2. (A) // So we must satisfy: wakePeriod > (preamblePeriod - (sleepPeriod - 1000)) / 2. (A)
// we also need to ensure the unit is awake to see at least minSymbols. (B) // we also need to ensure the unit is awake to see at least minSymbols. (B)
uint32_t wakePeriod_us = max( uint32_t wakePeriod = max(
(symbolLength_us * (senderPreambleLength + 1) - (sleepPeriod_us - 1000)) / 2, // (A) (symbolLength * (senderPreambleLength + 1) - (sleepPeriod - 1000)) / 2, // (A)
symbolLength_us * (minSymbols + 1)); //(B) symbolLength * (minSymbols + 1)); //(B)
RADIOLIB_DEBUG_PRINT(F("Auto wake period: ")); RADIOLIB_DEBUG_PRINT(F("Auto wake period: "));
RADIOLIB_DEBUG_PRINTLN(wakePeriod_us); RADIOLIB_DEBUG_PRINTLN(wakePeriod);
//If our sleep period is shorter than our transition time, just use the standard startReceive //If our sleep period is shorter than our transition time, just use the standard startReceive
if (sleepPeriod_us < _tcxoDelay_us + 1016) { if(sleepPeriod < _tcxoDelay + 1016) {
return(startReceive()); return(startReceive());
} }
return(startReceiveDutyCycle(wakePeriod_us, sleepPeriod_us)); return(startReceiveDutyCycle(wakePeriod, sleepPeriod));
} }
int16_t SX126x::startReceiveCommon() int16_t SX126x::startReceiveCommon() {
{ // set DIO mapping
// set DIO mapping
int16_t state = setDioIrqParams(SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT | SX126X_IRQ_CRC_ERR | SX126X_IRQ_HEADER_ERR, SX126X_IRQ_RX_DONE); int16_t state = setDioIrqParams(SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT | SX126X_IRQ_CRC_ERR | SX126X_IRQ_HEADER_ERR, SX126X_IRQ_RX_DONE);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
@ -542,6 +538,7 @@ int16_t SX126x::startReceiveCommon()
// clear interrupt flags // clear interrupt flags
state = clearIrqStatus(); state = clearIrqStatus();
return(state); return(state);
} }
@ -1119,7 +1116,7 @@ int16_t SX126x::setTCXO(float voltage, uint32_t delay) {
data[2] = (uint8_t)((delayValue >> 8) & 0xFF); data[2] = (uint8_t)((delayValue >> 8) & 0xFF);
data[3] = (uint8_t)(delayValue & 0xFF); data[3] = (uint8_t)(delayValue & 0xFF);
_tcxoDelay_us = delay; _tcxoDelay = delay;
// enable TCXO control on DIO3 // enable TCXO control on DIO3
return(SPIwriteCommand(SX126X_CMD_SET_DIO3_AS_TCXO_CTRL, data, 4)); return(SPIwriteCommand(SX126X_CMD_SET_DIO3_AS_TCXO_CTRL, data, 4));

15
src/modules/SX126x/SX126x.h
View file

@ -501,26 +501,23 @@ class SX126x: public PhysicalLayer {
/*! /*!
\brief Interrupt-driven receive method where the device mostly sleeps and periodically wakes to listen. \brief Interrupt-driven receive method where the device mostly sleeps and periodically wakes to listen.
Note that this function assumes the unit will take 500us + TCXO_delay to change state. See datasheet section 13.1.7, version 1.2.
\param rxPeriod_us The duration the receiver will be in Rx mode, in microseconds. \param rxPeriod The duration the receiver will be in Rx mode, in microseconds.
\param sleepPeriod_us The duration the receiver will not be in Rx mode, in microseconds. \param sleepPeriod The duration the receiver will not be in Rx mode, in microseconds.
\returns \ref status_codes \returns \ref status_codes
Note that this function assumes the unit will take 500us + TCXO_delay to change state. See datasheet section 13.1.7, version 1.2.
*/ */
int16_t startReceiveDutyCycle(uint32_t rxPeriod_us, uint32_t sleepPeriod_us); int16_t startReceiveDutyCycle(uint32_t rxPeriod, uint32_t sleepPeriod);
/*! /*!
\brief Calls \ref startReceiveDutyCycle with rxPeriod and sleepPeriod set so the unit shouldn't miss any messages. \brief Calls \ref startReceiveDutyCycle with rxPeriod and sleepPeriod set so the unit shouldn't miss any messages.
\param senderPreambleLength Expected preamble length of the messages to receive. \param senderPreambleLength Expected preamble length of the messages to receive.
If zero, uses the currently configured preamble length. Default zero. If set to zero, the currently configured preamble length will be used. Defaults to zero.
\param minSymbols Parameters will be chosen to ensure that the unit will catch at least this many symbols of any preamble of the specified length.
Default 3.
\param minSymbols Parameters will be chosen to ensure that the unit will catch at least this many symbols of any preamble of the specified length. Defaults to 3.
Note that Semtech in the CAD application note state that 2 symbols are fine for CAD, Note that Semtech in the CAD application note state that 2 symbols are fine for CAD,
but in the RX duty cycle note specify that sleep duration should be 8 symbols less than preamble length (corresponding to minSymbols = 4). but in the RX duty cycle note specify that sleep duration should be 8 symbols less than preamble length (corresponding to minSymbols = 4).
Testing suggests that a value of 3 for minSymbols works at high SNR. Testing suggests that a value of 3 for minSymbols works at high SNR.