diff --git a/keywords.txt b/keywords.txt index 76cf9f20..2ffc5a94 100644 --- a/keywords.txt +++ b/keywords.txt @@ -88,6 +88,8 @@ setDataShaping KEYWORD2 setOOK KEYWORD2 setDataShapingOOK KEYWORD2 setCRC KEYWORD2 +variablePacketLengthMode KEYWORD2 +fixedPacketLengthMode KEYWORD2 # RF69-specific setAESKey KEYWORD2 diff --git a/src/modules/CC1101.cpp b/src/modules/CC1101.cpp index 42fe5d7f..657400a0 100644 --- a/src/modules/CC1101.cpp +++ b/src/modules/CC1101.cpp @@ -3,6 +3,7 @@ CC1101::CC1101(Module* module) : PhysicalLayer(CC1101_CRYSTAL_FREQ, CC1101_DIV_EXPONENT, CC1101_MAX_PACKET_LENGTH) { _mod = module; _packetLengthQueried = false; + _packetLengthConfig = CC1101_LENGTH_CONFIG_VARIABLE; } int16_t CC1101::begin(float freq, float br, float rxBw, float freqDev, int8_t power) { @@ -20,15 +21,15 @@ int16_t CC1101::begin(float freq, float br, float rxBw, float freqDev, int8_t po flagFound = true; } else { #ifdef RADIOLIB_DEBUG - Serial.print(F("CC1101 not found! (")); - Serial.print(i + 1); - Serial.print(F(" of 10 tries) CC1101_REG_VERSION == ")); + RADIOLIB_DEBUG_PRINT(F("CC1101 not found! (")); + RADIOLIB_DEBUG_PRINT(i + 1); + RADIOLIB_DEBUG_PRINT(F(" of 10 tries) CC1101_REG_VERSION == ")); char buffHex[7]; sprintf(buffHex, "0x%04X", version); - Serial.print(buffHex); - Serial.print(F(", expected 0x0014")); - Serial.println(); + RADIOLIB_DEBUG_PRINT(buffHex); + RADIOLIB_DEBUG_PRINT(F(", expected 0x0014")); + RADIOLIB_DEBUG_PRINTLN(); #endif delay(1000); i++; @@ -55,26 +56,36 @@ int16_t CC1101::begin(float freq, float br, float rxBw, float freqDev, int8_t po return(state); } + // configure bitrate state = setBitRate(br); if(state != ERR_NONE) { return(state); } + // configure default RX bandwidth state = setRxBandwidth(rxBw); if(state != ERR_NONE) { return(state); } + // configure default frequency deviation state = setFrequencyDeviation(freqDev); if(state != ERR_NONE) { return(state); } + // configure default TX output power state = setOutputPower(power); if(state != ERR_NONE) { return(state); } + // set default packet length mode + state = variablePacketLengthMode(); + if (state != ERR_NONE) { + return(state); + } + // flush FIFOs SPIsendCommand(CC1101_CMD_FLUSH_RX); SPIsendCommand(CC1101_CMD_FLUSH_TX); @@ -162,7 +173,7 @@ int16_t CC1101::receiveDirect() { int16_t CC1101::packetMode() { int16_t state = SPIsetRegValue(CC1101_REG_PKTCTRL1, CC1101_CRC_AUTOFLUSH_OFF | CC1101_APPEND_STATUS_ON | CC1101_ADR_CHK_NONE, 3, 0); state |= SPIsetRegValue(CC1101_REG_PKTCTRL0, CC1101_WHITE_DATA_OFF | CC1101_PKT_FORMAT_NORMAL, 6, 4); - state |= SPIsetRegValue(CC1101_REG_PKTCTRL0, CC1101_CRC_ON | CC1101_LENGTH_CONFIG_VARIABLE, 2, 0); + state |= SPIsetRegValue(CC1101_REG_PKTCTRL0, CC1101_CRC_ON | _packetLengthConfig, 2, 0); return(state); } @@ -192,8 +203,10 @@ int16_t CC1101::startTransmit(uint8_t* data, size_t len, uint8_t addr) { return(state); } - // write packet length - SPIwriteRegister(CC1101_REG_FIFO, len); + // optionally write packet length + if (_packetLengthConfig == CC1101_LENGTH_CONFIG_VARIABLE) { + SPIwriteRegister(CC1101_REG_FIFO, len); + } // check address filtering uint8_t filter = SPIgetRegValue(CC1101_REG_PKTCTRL1, 1, 0); @@ -477,13 +490,63 @@ uint8_t CC1101::getLQI() { size_t CC1101::getPacketLength(bool update) { if(!_packetLengthQueried && update) { - _packetLength = _mod->SPIreadRegister(CC1101_REG_FIFO); + if (_packetLengthConfig == CC1101_LENGTH_CONFIG_VARIABLE) { + _packetLength = _mod->SPIreadRegister(CC1101_REG_FIFO); + } else { + _packetLength = _mod->SPIreadRegister(CC1101_REG_PKTLEN); + } + _packetLengthQueried = true; } return(_packetLength); } +int16_t CC1101::fixedPacketLengthMode(uint8_t len) { + if (len > CC1101_MAX_PACKET_LENGTH) { + return(ERR_PACKET_TOO_LONG); + } + + // set to fixed packet length + int16_t state = SPIsetRegValue(CC1101_REG_PKTCTRL0, CC1101_LENGTH_CONFIG_FIXED, 1, 0); + if (state != ERR_NONE) { + return(state); + } + + // set length to register + state = SPIsetRegValue(CC1101_REG_PKTLEN, len); + if (state != ERR_NONE) { + return(state); + } + + // all went well: cache the reg value + _packetLengthConfig = CC1101_LENGTH_CONFIG_FIXED; + + return(state); +} + +int16_t CC1101::variablePacketLengthMode(uint8_t maxLen) { + if (maxLen > CC1101_MAX_PACKET_LENGTH) { + return(ERR_PACKET_TOO_LONG); + } + + // set to fixed packet length + int16_t state = SPIsetRegValue(CC1101_REG_PKTCTRL0, CC1101_LENGTH_CONFIG_VARIABLE, 1, 0); + if (state != ERR_NONE) { + return(state); + } + + // set max length to register + state = SPIsetRegValue(CC1101_REG_PKTLEN, maxLen); + if (state != ERR_NONE) { + return(state); + } + + // all went well: cache the reg value + _packetLengthConfig = CC1101_LENGTH_CONFIG_VARIABLE; + return(state); +} + int16_t CC1101::config() { // enable automatic frequency synthesizer calibration int16_t state = SPIsetRegValue(CC1101_REG_MCSM0, CC1101_FS_AUTOCAL_IDLE_TO_RXTX, 5, 4); diff --git a/src/modules/CC1101.h b/src/modules/CC1101.h index a2060819..c57a7e6d 100644 --- a/src/modules/CC1101.h +++ b/src/modules/CC1101.h @@ -739,6 +739,24 @@ class CC1101: public PhysicalLayer { */ size_t getPacketLength(bool update = true); + /*! + \brief Set modem in fixed packet length mode. + + \param len Packet length. + + \returns \ref status_codes + */ + int16_t fixedPacketLengthMode(uint8_t len = CC1101_MAX_PACKET_LENGTH); + + /*! + \brief Set modem in variable packet length mode. + + \param len Maximum packet length. + + \returns \ref status_codes + */ + int16_t variablePacketLengthMode(uint8_t maxLen = CC1101_MAX_PACKET_LENGTH); + private: Module* _mod; @@ -748,6 +766,7 @@ class CC1101: public PhysicalLayer { size_t _packetLength; bool _packetLengthQueried; + uint8_t _packetLengthConfig; int16_t config(); int16_t directMode(); diff --git a/src/modules/RF69.cpp b/src/modules/RF69.cpp index 8e7f56b0..a0febe19 100644 --- a/src/modules/RF69.cpp +++ b/src/modules/RF69.cpp @@ -4,6 +4,7 @@ RF69::RF69(Module* module) : PhysicalLayer(RF69_CRYSTAL_FREQ, RF69_DIV_EXPONENT, _mod = module; _tempOffset = 0; _packetLengthQueried = false; + _packetLengthConfig = RF69_PACKET_FORMAT_VARIABLE; } int16_t RF69::begin(float freq, float br, float rxBw, float freqDev, int8_t power) { @@ -19,15 +20,15 @@ int16_t RF69::begin(float freq, float br, float rxBw, float freqDev, int8_t powe flagFound = true; } else { #ifdef RADIOLIB_DEBUG - Serial.print(F("RF69 not found! (")); - Serial.print(i + 1); - Serial.print(F(" of 10 tries) RF69_REG_VERSION == ")); + RADIOLIB_DEBUG_PRINT(F("RF69 not found! (")); + RADIOLIB_DEBUG_PRINT(i + 1); + RADIOLIB_DEBUG_PRINT(F(" of 10 tries) RF69_REG_VERSION == ")); char buffHex[7]; sprintf(buffHex, "0x%04X", version); - Serial.print(buffHex); - Serial.print(F(", expected 0x0024")); - Serial.println(); + RADIOLIB_DEBUG_PRINT(buffHex); + RADIOLIB_DEBUG_PRINT(F(", expected 0x0024")); + RADIOLIB_DEBUG_PRINTLN(); #endif delay(1000); i++; @@ -54,27 +55,37 @@ int16_t RF69::begin(float freq, float br, float rxBw, float freqDev, int8_t powe return(state); } + // configure bitrate _rxBw = 125.0; state = setBitRate(br); if(state != ERR_NONE) { return(state); } + // configure default RX bandwidth state = setRxBandwidth(rxBw); if(state != ERR_NONE) { return(state); } + // configure default frequency deviation state = setFrequencyDeviation(freqDev); if(state != ERR_NONE) { return(state); } + // configure default TX output power state = setOutputPower(power); if(state != ERR_NONE) { return(state); } + // set default packet length mode + state = variablePacketLengthMode(); + if (state != ERR_NONE) { + return(state); + } + // default sync word values 0x2D01 is the same as the default in LowPowerLab RFM69 library uint8_t syncWord[] = {0x2D, 0x01}; state = setSyncWord(syncWord, 2); @@ -250,6 +261,11 @@ int16_t RF69::startTransmit(uint8_t* data, size_t len, uint8_t addr) { // set packet length _mod->SPIwriteRegister(RF69_REG_FIFO, len); + // optionally write packet length + if (_packetLengthConfig == RF69_PACKET_FORMAT_VARIABLE) { + _mod->SPIwriteRegister(RF69_REG_FIFO, len); + } + // check address filtering uint8_t filter = _mod->SPIgetRegValue(RF69_REG_PACKET_CONFIG_1, 2, 1); if((filter == RF69_ADDRESS_FILTERING_NODE) || (filter == RF69_ADDRESS_FILTERING_NODE_BROADCAST)) { @@ -563,13 +579,63 @@ int16_t RF69::getTemperature() { size_t RF69::getPacketLength(bool update) { if(!_packetLengthQueried && update) { - _packetLength = _mod->SPIreadRegister(RF69_REG_FIFO); + if (_packetLengthConfig == RF69_PACKET_FORMAT_VARIABLE) { + _packetLength = _mod->SPIreadRegister(RF69_REG_FIFO); + } else { + _packetLength = _mod->SPIreadRegister(RF69_REG_PAYLOAD_LENGTH); + } _packetLengthQueried = true; } return(_packetLength); } +int16_t RF69::fixedPacketLengthMode(uint8_t len) { + if (len > RF69_MAX_PACKET_LENGTH) { + return(ERR_PACKET_TOO_LONG); + } + + // set to fixed packet length + int16_t state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_PACKET_FORMAT_FIXED, 7, 7); + if (state != ERR_NONE) { + return(state); + } + + // set length to register + state = _mod->SPIsetRegValue(RF69_REG_PAYLOAD_LENGTH, len); + if (state != ERR_NONE) { + return(state); + } + + // all went well: cache the reg value + _packetLengthConfig = RF69_PACKET_FORMAT_FIXED; + + return(state); +} + +int16_t RF69::variablePacketLengthMode(uint8_t maxLen) { + if (maxLen > RF69_MAX_PACKET_LENGTH) { + return(ERR_PACKET_TOO_LONG); + } + + // set to variable packet length + int16_t state = _mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_1, RF69_PACKET_FORMAT_VARIABLE, 7, 7); + if (state != ERR_NONE) { + return(state); + } + + // set max length to register + state = _mod->SPIsetRegValue(RF69_REG_PAYLOAD_LENGTH, maxLen); + if (state != ERR_NONE) { + return(state); + } + + // all went well: cache the reg value + _packetLengthConfig = RF69_PACKET_FORMAT_VARIABLE; + + return(state); +} + int16_t RF69::config() { int16_t state = ERR_NONE; diff --git a/src/modules/RF69.h b/src/modules/RF69.h index 15fe18dc..9820d539 100644 --- a/src/modules/RF69.h +++ b/src/modules/RF69.h @@ -697,7 +697,7 @@ class RF69: public PhysicalLayer { */ int16_t getTemperature(); - /*! + /*! \brief Query modem for the packet length of received payload. \param update Update received packet length. Will return cached value when set to false. @@ -706,6 +706,24 @@ class RF69: public PhysicalLayer { */ size_t getPacketLength(bool update = true); + /*! + \brief Set modem in fixed packet length mode. + + \param len Packet length. + + \returns \ref status_codes + */ + int16_t fixedPacketLengthMode(uint8_t len = RF69_MAX_PACKET_LENGTH); + + /*! + \brief Set modem in variable packet length mode. + + \param len Maximum packet length. + + \returns \ref status_codes + */ + int16_t variablePacketLengthMode(uint8_t maxLen = RF69_MAX_PACKET_LENGTH); + protected: Module* _mod; @@ -715,6 +733,7 @@ class RF69: public PhysicalLayer { size_t _packetLength; bool _packetLengthQueried; + uint8_t _packetLengthConfig; int16_t config(); int16_t directMode(); diff --git a/src/modules/SX1231.cpp b/src/modules/SX1231.cpp index 63767987..375e4b69 100644 --- a/src/modules/SX1231.cpp +++ b/src/modules/SX1231.cpp @@ -18,15 +18,15 @@ int16_t SX1231::begin(float freq, float br, float rxBw, float freqDev, int8_t po _chipRevision = version; } else { #ifdef RADIOLIB_DEBUG - Serial.print(F("SX127x not found! (")); - Serial.print(i + 1); - Serial.print(F(" of 10 tries) SX127X_REG_VERSION == ")); + RADIOLIB_DEBUG_PRINT(F("SX127x not found! (")); + RADIOLIB_DEBUG_PRINT(i + 1); + RADIOLIB_DEBUG_PRINT(F(" of 10 tries) SX127X_REG_VERSION == ")); char buffHex[7]; sprintf(buffHex, "0x%04X", version); - Serial.print(buffHex); - Serial.print(F(", expected 0x0021 / 0x0022 / 0x0023")); - Serial.println(); + RADIOLIB_DEBUG_PRINT(buffHex); + RADIOLIB_DEBUG_PRINT(F(", expected 0x0021 / 0x0022 / 0x0023")); + RADIOLIB_DEBUG_PRINTLN(); #endif delay(1000); i++; @@ -53,22 +53,26 @@ int16_t SX1231::begin(float freq, float br, float rxBw, float freqDev, int8_t po return(state); } + // configure bitrate _rxBw = 125.0; state = setBitRate(br); if(state != ERR_NONE) { return(state); } + // configure default RX bandwidth state = setRxBandwidth(rxBw); if(state != ERR_NONE) { return(state); } + // configure default frequency deviation state = setFrequencyDeviation(freqDev); if(state != ERR_NONE) { return(state); } + // configure default TX output power state = setOutputPower(power); if(state != ERR_NONE) { return(state); @@ -81,6 +85,12 @@ int16_t SX1231::begin(float freq, float br, float rxBw, float freqDev, int8_t po return(state); } + // set default packet length mode + state = variablePacketLengthMode(); + if (state != ERR_NONE) { + return(state); + } + // SX1231 V2a only if(_chipRevision == SX1231_CHIP_REVISION_2_A) { // modify default OOK threshold value diff --git a/src/modules/SX127x.cpp b/src/modules/SX127x.cpp index 72fa605a..b3e8603a 100644 --- a/src/modules/SX127x.cpp +++ b/src/modules/SX127x.cpp @@ -955,16 +955,16 @@ bool SX127x::findChip(uint8_t ver) { flagFound = true; } else { #ifdef RADIOLIB_DEBUG - Serial.print(F("SX127x not found! (")); - Serial.print(i + 1); - Serial.print(F(" of 10 tries) SX127X_REG_VERSION == ")); + RADIOLIB_DEBUG_PRINT(F("SX127x not found! (")); + RADIOLIB_DEBUG_PRINT(i + 1); + RADIOLIB_DEBUG_PRINT(F(" of 10 tries) SX127X_REG_VERSION == ")); char buffHex[5]; sprintf(buffHex, "0x%02X", version); - Serial.print(buffHex); - Serial.print(F(", expected 0x00")); - Serial.print(ver, HEX); - Serial.println(); + RADIOLIB_DEBUG_PRINT(buffHex); + RADIOLIB_DEBUG_PRINT(F(", expected 0x00")); + RADIOLIB_DEBUG_PRINT(ver, HEX); + RADIOLIB_DEBUG_PRINTLN(); #endif delay(1000); i++; @@ -1013,23 +1013,23 @@ void SX127x::clearFIFO(size_t count) { #ifdef RADIOLIB_DEBUG void SX127x::regDump() { - Serial.println(); - Serial.println(F("ADDR\tVALUE")); + RADIOLIB_DEBUG_PRINTLN(); + RADIOLIB_DEBUG_PRINTLN(F("ADDR\tVALUE")); for(uint16_t addr = 0x01; addr <= 0x70; addr++) { if(addr <= 0x0F) { - Serial.print(F("0x0")); + RADIOLIB_DEBUG_PRINT(F("0x0")); } else { - Serial.print(F("0x")); + RADIOLIB_DEBUG_PRINT(F("0x")); } - Serial.print(addr, HEX); - Serial.print('\t'); + RADIOLIB_DEBUG_PRINT(addr, HEX); + RADIOLIB_DEBUG_PRINT('\t'); uint8_t val = _mod->SPIreadRegister(addr); if(val <= 0x0F) { - Serial.print(F("0x0")); + RADIOLIB_DEBUG_PRINT(F("0x0")); } else { - Serial.print(F("0x")); + RADIOLIB_DEBUG_PRINT(F("0x")); } - Serial.println(val, HEX); + RADIOLIB_DEBUG_PRINTLN(val, HEX); delay(50); }