BTSSN Projet Drone Imagerie Télémétrie
Library SX1272, initially created by C.Pham, University of Pau, France for Arduino. Suitable for MBED / NUCLEO / STM32
Dependents: LOW_COAST_LORA_NODE
Diff: SX1272.cpp
- Revision:
- 0:d974bcee4f69
- Child:
- 1:5d57c6a92509
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SX1272.cpp Sun Nov 05 14:30:04 2017 +0000
@@ -0,0 +1,7160 @@
+/*
+ * Library for LoRa 868 / 915MHz SX1272 LoRa module
+ *
+ * Copyright (C) Libelium Comunicaciones Distribuidas S.L.
+ * http://www.libelium.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ * Version: 1.1
+ * Design: David Gascón
+ * Implementation: Covadonga Albiñana & Victor Boria
+ */
+
+//**********************************************************************/
+// Includes
+//**********************************************************************/
+#include "mbed.h"
+#include "SX1272.h"
+#include <SPI.h>
+
+/* CHANGE LOGS by C. Pham
+ * June, 22th, 2017
+ * - setPowerDBM(uint8_t dbm) calls setPower('X') when dbm is set to 20
+ * Apr, 21th, 2017
+ * - change the way timeout are detected: exitTime=millis()+(unsigned long)wait; then millis() < exitTime;
+ * Mar, 26th, 2017
+ * - insert delay(100) before setting radio module to sleep mode. Remove unstability issue
+ * - (proposed by escyes - https://github.com/CongducPham/LowCostLoRaGw/issues/53#issuecomment-289237532)
+ * Jan, 11th, 2017
+ * - fix bug in getRSSIpacket() when SNR < 0 thanks to John Rohde from Aarhus University
+ * Dec, 17th, 2016
+ * - fix bug making -DPABOOST in radio.makefile inoperant
+ * Dec, 1st, 2016
+ * - add RSSI computation while performing CAD with doCAD()
+ * - WARNING: the SX1272 lib for gateway (Raspberry) does not have this functionality
+ * Nov, 26th, 2016
+ * - add preliminary support for ToA limitation
+ * - when in "production" mode, uncomment #define LIMIT_TOA
+ * Nov, 16th, 2016
+ * - provide better power management mechanisms
+ * - manage PA_BOOST and dBm setting
+ * Jan, 23rd, 2016
+ * - the packet format at transmission does not use the original Libelium format anymore
+ * * the retry field is removed therefore all operations using retry will probably not work well, not tested though
+ * - therefore DO NOT use sendPacketTimeoutACKRetries()
+ * - the reason is that we do not want to have a reserved byte after the payload
+ * * the length field is removed because it is much better to get the packet length at the reception side
+ * * after the dst field, we inserted a packet type field to better identify the packet type: DATA, ACK, encryption, app key,...
+ * - the format is now dst(1B) ptype(1B) src(1B) seq(1B) payload(xB)
+ * - ptype is decomposed in 2 parts type(4bits) flags(4bits)
+ * - type can take current value of DATA=0001 and ACK=0010
+ * - the flags are from left to right: ack_requested|encrypted|with_appkey|is_binary
+ * - ptype can be set with setPacketType(), see constant defined in SX1272.h
+ * - the header length is then 4 instead of 5
+ * Jan, 16th, 2016
+ * - add support for SX1276, automatic detect
+ * - add LF/HF calibaration copied from LoRaMAC-Node. Don't know if it is really necessary though
+ * - change various radio settings
+ * Dec, 10th, 2015
+ * - add SyncWord for test with simple LoRaWAN
+ * - add mode 11 that have BW=125, CR=4/5, SF=7 on channel 868.1MHz
+ * - use following in your code if (loraMode==11) { e = sx1272.setChannel(CH_18_868); }
+ * Nov, 13th, 2015
+ * - add CarrierSense() to perform some Listen Before Talk procedure
+ * - add dynamic ACK suport
+ * - compile with W_REQUESTED_ACK, retry field is used to indicate at the receiver
+ * that an ACK should be sent
+ * - receiveWithTimeout() has been modified to send an ACK if retry is 1
+ * - at sender side, sendPacketTimeoutACK() has been modified to indicate
+ * whether retry should be set to 1 or not in setPacket()
+ * - receiver should always use receiveWithTimeout() while sender decides to use
+ * sendPacketTimeout() or sendPacketTimeoutACK()
+ * Jun, 2015
+ * - Add time on air computation and CAD features
+*/
+
+// Added by C. Pham
+// based on SIFS=3CAD
+uint8_t sx1272_SIFS_value[11]={0, 183, 94, 44, 47, 23, 24, 12, 12, 7, 4};
+uint8_t sx1272_CAD_value[11]={0, 62, 31, 16, 16, 8, 9, 5, 3, 1, 1};
+
+//#define LIMIT_TOA
+// 0.1% for testing
+//#define MAX_DUTY_CYCLE_PER_HOUR 3600L
+// 1%, regular mode
+#define MAX_DUTY_CYCLE_PER_HOUR 36000L
+// normally 1 hour, set to smaller value for testing
+#define DUTYCYCLE_DURATION 3600000L
+// 4 min for testing
+//#define DUTYCYCLE_DURATION 240000L
+
+// end
+
+//ajoute par C.DUPATY
+//Serial pc(USBTX, USBRX); // tx, rx
+SPI spi(SPI_MOSI,SPI_MISO,SPI_SCK);; // mosi, miso, sclk
+DigitalOut ss(SPI_CS);
+DigitalOut rst(PA_8);
+
+//**********************************************************************/
+// Public functions.
+//**********************************************************************/
+
+SX1272::SX1272()
+{
+//ajoute par C.DUPATY
+us_ticker_init();
+srand(time(NULL));
+// ajoute parC.Dupaty
+// A VERIFIER !!!!!!!!!!!!!!!!!!!!!!!
+ spi.format(8,0); // spi 8 bits mode 0
+ spi.frequency(2000000); // spi clock 200KHz a l origine
+
+ // Initialize class variables
+ _bandwidth = BW_125;
+ _codingRate = CR_5;
+ _spreadingFactor = SF_7;
+ _channel = CH_12_900;
+ _header = HEADER_ON;
+ _CRC = CRC_OFF;
+ _modem = FSK;
+ _power = 15;
+ _packetNumber = 0;
+ _reception = CORRECT_PACKET;
+ _retries = 0;
+ // added by C. Pham
+ _defaultSyncWord=0x12;
+ _rawFormat=false;
+ _extendedIFS=true;
+ _RSSIonSend=true;
+ // disabled by default
+ _enableCarrierSense=false;
+ // DIFS by default
+ _send_cad_number=9;
+#ifdef PABOOST
+ _needPABOOST=true;
+#else
+ _needPABOOST=false;
+#endif
+ _limitToA=false;
+ _startToAcycle=millis();
+ _remainingToA=MAX_DUTY_CYCLE_PER_HOUR;
+ _endToAcycle=_startToAcycle+DUTYCYCLE_DURATION;
+#ifdef W_REQUESTED_ACK
+ _requestACK = 0;
+#endif
+#ifdef W_NET_KEY
+ _my_netkey[0] = net_key_0;
+ _my_netkey[1] = net_key_1;
+#endif
+ // end
+ _maxRetries = 3;
+ packet_sent.retry = _retries;
+};
+
+// added by C. Pham
+// copied from LoRaMAC-Node
+/*!
+ * Performs the Rx chain calibration for LF and HF bands
+ * \remark Must be called just after the reset so all registers are at their
+ * default values
+ */
+void SX1272::RxChainCalibration()
+{
+ if (_board==SX1276Chip) {
+
+ printf("SX1276 LF/HF calibration\r");
+
+ // Cut the PA just in case, RFO output, power = -1 dBm
+ writeRegister( REG_PA_CONFIG, 0x00 );
+
+ // Launch Rx chain calibration for LF band
+ writeRegister( REG_IMAGE_CAL, ( readRegister( REG_IMAGE_CAL ) & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START );
+ while( ( readRegister( REG_IMAGE_CAL ) & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )
+ {
+ }
+
+ // Sets a Frequency in HF band
+ setChannel(CH_17_868);
+
+ // Launch Rx chain calibration for HF band
+ writeRegister( REG_IMAGE_CAL, ( readRegister( REG_IMAGE_CAL ) & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START );
+ while( ( readRegister( REG_IMAGE_CAL ) & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )
+ {
+ }
+ }
+}
+
+
+/*
+ Function: Sets the module ON.
+ Returns: uint8_t setLORA state
+*/
+uint8_t SX1272::ON()
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'ON'\n");
+#endif
+
+ // Powering the module
+// pinMode(SX1272_SS,OUTPUT);
+// digitalWrite(SX1272_SS,HIGH);
+ ss=1;
+ wait_ms(100);
+
+ //#define USE_SPI_SETTINGS
+/*
+#ifdef USE_SPI_SETTINGS
+ SPI.beginTransaction(SPISettings(2000000, MSBFIRST, SPI_MODE0));
+#else
+ //Configure the MISO, MOSI, CS, SPCR.
+ SPI.begin();
+ //Set Most significant bit first
+ SPI.setBitOrder(MSBFIRST);
+#ifdef _VARIANT_ARDUINO_DUE_X_
+ // for the DUE, set to 4MHz
+ SPI.setClockDivider(42);
+#else
+ // for the MEGA, set to 2MHz
+ SPI.setClockDivider(SPI_CLOCK_DIV8);
+#endif
+ //Set data mode
+ SPI.setDataMode(SPI_MODE0);
+#endif
+*/
+ wait_ms(100);
+
+/* // added by C. Pham
+ pinMode(SX1272_RST,OUTPUT);
+ digitalWrite(SX1272_RST,HIGH);
+ wait_ms(100);
+ digitalWrite(SX1272_RST,LOW);
+ wait_ms(100);
+ */
+
+ rst=1;
+ wait_ms(100);
+ rst=0;
+
+ // from single_chan_pkt_fwd by Thomas Telkamp
+ uint8_t version = readRegister(REG_VERSION);
+
+ if (version == 0x22) {
+ // sx1272
+ printf("SX1272 detected, starting\n");
+ _board = SX1272Chip;
+ } else {
+ // sx1276?
+ // digitalWrite(SX1272_RST, LOW);
+ rst=0;
+ wait_ms(100);
+ // digitalWrite(SX1272_RST, HIGH);
+ rst=1;
+ wait_ms(100);
+ version = readRegister(REG_VERSION);
+ if (version == 0x12) {
+ // sx1276
+ printf("SX1276 detected, starting\n");
+ _board = SX1276Chip;
+ } else {
+ printf("Unrecognized transceiver\n");
+ }
+ }
+ // end from single_chan_pkt_fwd by Thomas Telkamp
+
+ // added by C. Pham
+ RxChainCalibration();
+
+ setMaxCurrent(0x1B);
+#if (SX1272_debug_mode > 1)
+ printf("## Setting ON with maximum current supply ##");
+ printf("\n");
+#endif
+
+ // set LoRa mode
+ state = setLORA();
+
+ // Added by C. Pham for ToA computation
+ getPreambleLength();
+#ifdef W_NET_KEY
+ //#if (SX1272_debug_mode > 1)
+ printf("## SX1272 layer has net key##");
+ //#endif
+#endif
+
+#ifdef W_INITIALIZATION
+ // CAUTION
+ // doing initialization as proposed by Libelium seems not to work for the SX1276
+ // so we decided to leave the default value of the SX127x, then configure the radio when
+ // setting to LoRa mode
+
+ //Set initialization values
+ writeRegister(0x0,0x0);
+ // comment by C. Pham
+ // still valid for SX1276
+ writeRegister(0x1,0x81);
+ // end
+ writeRegister(0x2,0x1A);
+ writeRegister(0x3,0xB);
+ writeRegister(0x4,0x0);
+ writeRegister(0x5,0x52);
+ writeRegister(0x6,0xD8);
+ writeRegister(0x7,0x99);
+ writeRegister(0x8,0x99);
+ // modified by C. Pham
+ // added by C. Pham
+ if (_board==SX1272Chip)
+ // RFIO_pin RFU OutputPower
+ // 0 000 0000
+ writeRegister(0x9,0x0);
+ else
+ // RFO_pin MaxP OutputPower
+ // 0 100 1111
+ // set MaxPower to 0x4 and OutputPower to 0
+ writeRegister(0x9,0x40);
+
+ writeRegister(0xA,0x9);
+ writeRegister(0xB,0x3B);
+
+ // comment by C. Pham
+ // still valid for SX1276
+ writeRegister(0xC,0x23);
+
+ // REG_RX_CONFIG
+ writeRegister(0xD,0x1);
+
+ writeRegister(0xE,0x80);
+ writeRegister(0xF,0x0);
+ writeRegister(0x10,0x0);
+ writeRegister(0x11,0x0);
+ writeRegister(0x12,0x0);
+ writeRegister(0x13,0x0);
+ writeRegister(0x14,0x0);
+ writeRegister(0x15,0x0);
+ writeRegister(0x16,0x0);
+ writeRegister(0x17,0x0);
+ writeRegister(0x18,0x10);
+ writeRegister(0x19,0x0);
+ writeRegister(0x1A,0x0);
+ writeRegister(0x1B,0x0);
+ writeRegister(0x1C,0x0);
+
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ // comment by C. Pham
+ // 0x4A = 01 001 0 1 0
+ // BW=250 CR=4/5 ImplicitH_off RxPayloadCrcOn_on LowDataRateOptimize_off
+ writeRegister(0x1D,0x4A);
+ // 1001 0 1 11
+ // SF=9 TxContinuous_off AgcAutoOn SymbTimeOut
+ writeRegister(0x1E,0x97);
+ }
+ else {
+ // 1000 001 0
+ // BW=250 CR=4/5 ImplicitH_off
+ writeRegister(0x1D,0x82);
+ // 1001 0 1 11
+ // SF=9 TxContinuous_off RxPayloadCrcOn_on SymbTimeOut
+ writeRegister(0x1E,0x97);
+ }
+ // end
+
+ writeRegister(0x1F,0xFF);
+ writeRegister(0x20,0x0);
+ writeRegister(0x21,0x8);
+ writeRegister(0x22,0xFF);
+ writeRegister(0x23,0xFF);
+ writeRegister(0x24,0x0);
+ writeRegister(0x25,0x0);
+
+ // added by C. Pham
+ if (_board==SX1272Chip)
+ writeRegister(0x26,0x0);
+ else
+ // 0000 0 1 00
+ // reserved LowDataRateOptimize_off AgcAutoOn reserved
+ writeRegister(0x26,0x04);
+
+ // REG_SYNC_CONFIG
+ writeRegister(0x27,0x0);
+
+ writeRegister(0x28,0x0);
+ writeRegister(0x29,0x0);
+ writeRegister(0x2A,0x0);
+ writeRegister(0x2B,0x0);
+ writeRegister(0x2C,0x0);
+ writeRegister(0x2D,0x50);
+ writeRegister(0x2E,0x14);
+ writeRegister(0x2F,0x40);
+ writeRegister(0x30,0x0);
+ writeRegister(0x31,0x3);
+ writeRegister(0x32,0x5);
+ writeRegister(0x33,0x27);
+ writeRegister(0x34,0x1C);
+ writeRegister(0x35,0xA);
+ writeRegister(0x36,0x0);
+ writeRegister(0x37,0xA);
+ writeRegister(0x38,0x42);
+ writeRegister(0x39,0x12);
+ //writeRegister(0x3A,0x65);
+ //writeRegister(0x3B,0x1D);
+ //writeRegister(0x3C,0x1);
+ //writeRegister(0x3D,0xA1);
+ //writeRegister(0x3E,0x0);
+ //writeRegister(0x3F,0x0);
+ //writeRegister(0x40,0x0);
+ //writeRegister(0x41,0x0);
+ // commented by C. Pham
+ // since now we handle also the SX1276
+ //writeRegister(0x42,0x22);
+#endif
+ // added by C. Pham
+ // default sync word for non-LoRaWAN
+ setSyncWord(_defaultSyncWord);
+ getSyncWord();
+ _defaultSyncWord=_syncWord;
+
+#ifdef LIMIT_TOA
+ uint16_t remainingToA=limitToA();
+ printf("## Limit ToA ON ##");
+ printf("cycle begins at ");
+ Serial.print(_startToAcycle);
+ printf(" cycle ends at ");
+ Serial.print(_endToAcycle);
+ printf(" remaining ToA is ");
+ Serial.print(remainingToA);
+ printf("\n");
+#endif
+ //end
+
+ return state;
+}
+
+/*
+ Function: Sets the module OFF.
+ Returns: Nothing
+*/
+void SX1272::OFF()
+{
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'OFF'\n");
+#endif
+
+// ajoute par C.Dupaty
+ //SPI.end();
+
+ // Powering the module
+ // pinMode(SX1272_SS,OUTPUT);
+ // digitalWrite(SX1272_SS,LOW);
+ ss=0; // ????? !!!!!!!!!!!!!!!!!
+#if (SX1272_debug_mode > 1)
+ printf("## Setting OFF ##");
+ printf("\n");
+#endif
+}
+
+/*
+ Function: Reads the indicated register.
+ Returns: The content of the register
+ Parameters:
+ address: address register to read from
+*/
+byte SX1272::readRegister(byte address)
+{
+ byte value = 0x00;
+
+ //digitalWrite(SX1272_SS,LOW);
+ ss=0;
+ bitClear(address, 7); // Bit 7 cleared to write in registers
+ // SPI.transfer(address);
+ spi.write(address);
+ //value = SPI.transfer(0x00);
+ value = spi.write(0x00);
+ //digitalWrite(SX1272_SS,HIGH);
+ ss=1;
+
+#if (SX1272_debug_mode > 1)
+ printf("## Reading: ");
+ printf("Register 0x%02X : 0x%02X\n",address,value);
+ // Serial.print(address, HEX);
+ // printf(": ");
+ // Serial.print(value, HEX);
+ // printf("\n");
+#endif
+
+ return value;
+}
+
+/*
+ Function: Writes on the indicated register.
+ Returns: Nothing
+ Parameters:
+ address: address register to write in
+ data : value to write in the register
+*/
+void SX1272::writeRegister(byte address, byte data)
+{
+ //digitalWrite(SX1272_SS,LOW);
+ ss=0;
+ bitSet(address, 7); // Bit 7 set to read from registers
+ //SPI.transfer(address);
+ //SPI.transfer(data);
+ spi.write(address);
+ spi.write(data);
+ // digitalWrite(SX1272_SS,HIGH);
+ ss=1;
+
+#if (SX1272_debug_mode > 1)
+ printf("## Writing: Register ");
+ bitClear(address, 7);
+ printf("0x%02X : 0x%02X\n",address,data);
+ // Serial.print(address, HEX);
+ // printf(": ");
+ // Serial.print(data, HEX);
+ // printf("\n");
+#endif
+
+}
+
+/*
+ Function: Clears the interruption flags
+ Returns: Nothing
+*/
+void SX1272::clearFlags()
+{
+ byte st0;
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == LORA )
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Stdby mode to write in registers
+ writeRegister(REG_IRQ_FLAGS, 0xFF); // LoRa mode flags register
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+#if (SX1272_debug_mode > 1)
+ printf("## LoRa flags cleared ##\n");
+#endif
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Stdby mode to write in registers
+ writeRegister(REG_IRQ_FLAGS1, 0xFF); // FSK mode flags1 register
+ writeRegister(REG_IRQ_FLAGS2, 0xFF); // FSK mode flags2 register
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+#if (SX1272_debug_mode > 1)
+ printf("## FSK flags cleared ##");
+#endif
+ }
+}
+
+/*
+ Function: Sets the module in LoRa mode.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setLORA()
+{
+ uint8_t state = 2;
+ byte st0;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setLORA'\n");
+#endif
+
+ // modified by C. Pham
+ uint8_t retry=0;
+
+ do {
+ wait_ms(200);
+ writeRegister(REG_OP_MODE, FSK_SLEEP_MODE); // Sleep mode (mandatory to set LoRa mode)
+ writeRegister(REG_OP_MODE, LORA_SLEEP_MODE); // LoRa sleep mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+ wait_ms(50+retry*10);
+ st0 = readRegister(REG_OP_MODE);
+ printf("...");
+
+ if ((retry % 2)==0)
+ if (retry==20)
+ retry=0;
+ else
+ retry++;
+ /*
+ if (st0!=LORA_STANDBY_MODE) {
+ pinMode(SX1272_RST,OUTPUT);
+ digitalWrite(SX1272_RST,HIGH);
+ wait_ms(100);
+ digitalWrite(SX1272_RST,LOW);
+ }
+ */
+
+ } while (st0!=LORA_STANDBY_MODE); // LoRa standby mode
+
+ if( st0 == LORA_STANDBY_MODE)
+ { // LoRa mode
+ _modem = LORA;
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## LoRa set with success ##");
+ printf("\n");
+#endif
+ }
+ else
+ { // FSK mode
+ _modem = FSK;
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while setting LoRa **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Sets the module in FSK mode.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setFSK()
+{
+ uint8_t state = 2;
+ byte st0;
+ byte config1;
+
+ if (_board==SX1276Chip)
+ printf("Warning: FSK has not been tested on SX1276!");
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setFSK'\n");
+#endif
+
+ writeRegister(REG_OP_MODE, FSK_SLEEP_MODE); // Sleep mode (mandatory to change mode)
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // FSK standby mode
+ config1 = readRegister(REG_PACKET_CONFIG1);
+ config1 = config1 & 0B01111101; // clears bits 8 and 1 from REG_PACKET_CONFIG1
+ config1 = config1 | 0B00000100; // sets bit 2 from REG_PACKET_CONFIG1
+ writeRegister(REG_PACKET_CONFIG1,config1); // AddressFiltering = NodeAddress + BroadcastAddress
+ writeRegister(REG_FIFO_THRESH, 0x80); // condition to start packet tx
+ config1 = readRegister(REG_SYNC_CONFIG);
+ config1 = config1 & 0B00111111;
+ writeRegister(REG_SYNC_CONFIG,config1);
+
+ wait_ms(100);
+
+ st0 = readRegister(REG_OP_MODE); // Reading config mode
+ if( st0 == FSK_STANDBY_MODE )
+ { // FSK mode
+ _modem = FSK;
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## FSK set with success ##");
+ printf("\n");
+#endif
+ }
+ else
+ { // LoRa mode
+ _modem = LORA;
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while setting FSK **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Gets the bandwidth, coding rate and spreading factor of the LoRa modulation.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getMode()
+{
+ byte st0;
+ int8_t state = 2;
+ byte value = 0x00;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getMode'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ if( _modem == FSK )
+ {
+ setLORA(); // Setting LoRa mode
+ }
+ value = readRegister(REG_MODEM_CONFIG1);
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ _bandwidth = (value >> 6); // Storing 2 MSB from REG_MODEM_CONFIG1 (=_bandwidth)
+ // added by C. Pham
+ // convert to common bandwidth values used by both SX1272 and SX1276
+ _bandwidth += 7;
+ }
+ else
+ _bandwidth = (value >> 4); // Storing 4 MSB from REG_MODEM_CONFIG1 (=_bandwidth)
+
+ if (_board==SX1272Chip)
+ _codingRate = (value >> 3) & 0x07; // Storing third, forth and fifth bits from
+ else
+ _codingRate = (value >> 1) & 0x07; // Storing 3-1 bits REG_MODEM_CONFIG1 (=_codingRate)
+
+ value = readRegister(REG_MODEM_CONFIG2);
+ _spreadingFactor = (value >> 4) & 0x0F; // Storing 4 MSB from REG_MODEM_CONFIG2 (=_spreadingFactor)
+ state = 1;
+
+ if( isBW(_bandwidth) ) // Checking available values for:
+ { // _bandwidth
+ if( isCR(_codingRate) ) // _codingRate
+ { // _spreadingFactor
+ if( isSF(_spreadingFactor) )
+ {
+ state = 0;
+ }
+ }
+ }
+
+#if (SX1272_debug_mode > 1)
+ printf("## Parameters from configuration mode are:");
+ printf("Bandwidth: %X\n",_bandwidth);
+ // Serial.print(_bandwidth, HEX);
+ // printf("\n");
+ printf("\t Coding Rate: %X\n",_codingRate);
+ // Serial.print(_codingRate, HEX);
+ // printf("\n");
+ printf("\t Spreading Factor: %X\n",_spreadingFactor);
+ // Serial.print(_spreadingFactor, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Sets the bandwidth, coding rate and spreading factor of the LoRa modulation.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ mode: mode number to set the required BW, SF and CR of LoRa modem.
+*/
+int8_t SX1272::setMode(uint8_t mode)
+{
+ int8_t state = 2;
+ byte st0;
+ byte config1 = 0x00;
+ byte config2 = 0x00;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setMode'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == FSK )
+ {
+ setLORA();
+ }
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // LoRa standby mode
+
+ switch (mode)
+ {
+ // mode 1 (better reach, medium time on air)
+ case 1:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_12); // SF = 12
+ setBW(BW_125); // BW = 125 KHz
+ break;
+
+ // mode 2 (medium reach, less time on air)
+ case 2:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_12); // SF = 12
+ setBW(BW_250); // BW = 250 KHz
+ break;
+
+ // mode 3 (worst reach, less time on air)
+ case 3:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_10); // SF = 10
+ setBW(BW_125); // BW = 125 KHz
+ break;
+
+ // mode 4 (better reach, low time on air)
+ case 4:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_12); // SF = 12
+ setBW(BW_500); // BW = 500 KHz
+ break;
+
+ // mode 5 (better reach, medium time on air)
+ case 5:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_10); // SF = 10
+ setBW(BW_250); // BW = 250 KHz
+ break;
+
+ // mode 6 (better reach, worst time-on-air)
+ case 6:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_11); // SF = 11
+ setBW(BW_500); // BW = 500 KHz
+ break;
+
+ // mode 7 (medium-high reach, medium-low time-on-air)
+ case 7:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_9); // SF = 9
+ setBW(BW_250); // BW = 250 KHz
+ break;
+
+ // mode 8 (medium reach, medium time-on-air)
+ case 8:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_9); // SF = 9
+ setBW(BW_500); // BW = 500 KHz
+ break;
+
+ // mode 9 (medium-low reach, medium-high time-on-air)
+ case 9:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_8); // SF = 8
+ setBW(BW_500); // BW = 500 KHz
+ break;
+
+ // mode 10 (worst reach, less time_on_air)
+ case 10:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_7); // SF = 7
+ setBW(BW_500); // BW = 500 KHz
+ break;
+
+ // added by C. Pham
+ // test for LoRaWAN channel
+ case 11:
+ setCR(CR_5); // CR = 4/5
+ setSF(SF_12); // SF = 12
+ setBW(BW_125); // BW = 125 KHz
+ // set the sync word to the LoRaWAN sync word which is 0x34
+ setSyncWord(0x34);
+ printf("** Using sync word of 0x%X\n",_syncWord);
+ // Serial.println(_syncWord, HEX);
+ break;
+
+ default: state = -1; // The indicated mode doesn't exist
+
+ };
+
+ if( state == -1 ) // if state = -1, don't change its value
+ {
+#if (SX1272_debug_mode > 1)
+ printf("** The indicated mode doesn't exist, ");
+ printf("please select from 1 to 10 **");
+#endif
+ }
+ else
+ {
+ printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verifications \n");
+ state = 1;
+ config1 = readRegister(REG_MODEM_CONFIG1);
+ switch (mode)
+ { // Different way to check for each mode:
+ // (config1 >> 3) ---> take out bits 7-3 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ // (config2 >> 4) ---> take out bits 7-4 from REG_MODEM_CONFIG2 (=_spreadingFactor)
+
+ // mode 1: BW = 125 KHz, CR = 4/5, SF = 12.
+ case 1:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ //////////////////////////////////////////////possible pb sur config1 qui vaut 0
+ if( (config1 >> 3) == 0x01 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x39 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_12 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+
+ // mode 2: BW = 250 KHz, CR = 4/5, SF = 12.
+ case 2:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x09 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x41 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_12 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 3: BW = 125 KHz, CR = 4/5, SF = 10.
+ case 3:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x01 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x39 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_10 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 4: BW = 500 KHz, CR = 4/5, SF = 12.
+ case 4:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x11 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x49 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_12 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 5: BW = 250 KHz, CR = 4/5, SF = 10.
+ case 5:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x09 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x41 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_10 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 6: BW = 500 KHz, CR = 4/5, SF = 11.
+ case 6:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x11 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x49 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_11 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 7: BW = 250 KHz, CR = 4/5, SF = 9.
+ case 7:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x09 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x41 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_9 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 8: BW = 500 KHz, CR = 4/5, SF = 9.
+ case 8:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x11 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x49 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_9 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 9: BW = 500 KHz, CR = 4/5, SF = 8.
+ case 9:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x11 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x49 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_8 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // mode 10: BW = 500 KHz, CR = 4/5, SF = 7.
+ case 10:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x11 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x49 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_7 )
+ {
+ state = 0;
+ }
+ }
+ break;
+
+ // added by C. Pham
+ // test of LoRaWAN channel
+ // mode 11: BW = 125 KHz, CR = 4/5, SF = 12.
+ case 11:
+
+ //modified by C. Pham
+ if (_board==SX1272Chip) {
+ if( (config1 >> 3) == 0x01 )
+ state=0;
+ }
+ else {
+ // (config1 >> 1) ---> take out bits 7-1 from REG_MODEM_CONFIG1 (=_bandwidth & _codingRate together)
+ if( (config1 >> 1) == 0x39 )
+ state=0;
+ }
+
+ if( state==0) {
+ state = 1;
+ config2 = readRegister(REG_MODEM_CONFIG2);
+
+ if( (config2 >> 4) == SF_12 )
+ {
+ state = 0;
+ }
+ }
+ break;
+ }// end switch
+
+ if (mode!=11) {
+ setSyncWord(_defaultSyncWord);
+#if (SX1272_debug_mode > 1)
+ printf("*** Using sync word of 0x%X\n",_defaultSyncWord);
+ // Serial.println(_defaultSyncWord, HEX);
+#endif
+ }
+ }
+ // added by C. Pham
+ if (state == 0)
+ _loraMode=mode;
+
+#if (SX1272_debug_mode > 1)
+
+ if( state == 0 )
+ {
+ printf("## Mode %d ",mode);
+ // Serial.print(mode, DEC);
+ printf(" configured with success ##");
+ }
+ else
+ {
+ printf("** There has been an error while configuring mode %d ",mode);
+ // Serial.print(mode, DEC);
+ printf(". **\n");
+ }
+#endif
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Indicates if module is configured in implicit or explicit header mode.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getHeader()
+{
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getHeader'\n");
+#endif
+
+ // added by C. Pham
+ uint8_t theHeaderBit;
+
+ if (_board==SX1272Chip)
+ theHeaderBit=2;
+ else
+ theHeaderBit=0;
+
+ // take out bit 2 from REG_MODEM_CONFIG1 indicates ImplicitHeaderModeOn
+ if( bitRead(REG_MODEM_CONFIG1, theHeaderBit) == 0 )
+ { // explicit header mode (ON)
+ _header = HEADER_ON;
+ state = 1;
+ }
+ else
+ { // implicit header mode (OFF)
+ _header = HEADER_OFF;
+ state = 1;
+ }
+
+ state = 0;
+
+ if( _modem == FSK )
+ { // header is not available in FSK mode
+#if (SX1272_debug_mode > 1)
+ printf("## Notice that FSK mode packets hasn't header ##");
+ printf("\n");
+#endif
+ }
+ else
+ { // header in LoRa mode
+#if (SX1272_debug_mode > 1)
+ printf("## Header is ");
+ if( _header == HEADER_ON )
+ {
+ printf("in explicit header mode ##");
+ }
+ else
+ {
+ printf("in implicit header mode ##");
+ }
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Sets the module in explicit header mode (header is sent).
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::setHeaderON()
+{
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setHeaderON'\n");
+#endif
+
+ if( _modem == FSK )
+ {
+ state = -1; // header is not available in FSK mode
+#if (SX1272_debug_mode > 1)
+ printf("## FSK mode packets hasn't header ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ config1 = readRegister(REG_MODEM_CONFIG1); // Save config1 to modify only the header bit
+ if( _spreadingFactor == 6 )
+ {
+ state = -1; // Mandatory headerOFF with SF = 6
+#if (SX1272_debug_mode > 1)
+ printf("## Mandatory implicit header mode with spreading factor = 6 ##");
+#endif
+ }
+ else
+ {
+ // added by C. Pham
+ if (_board==SX1272Chip)
+ config1 = config1 & 0B11111011; // clears bit 2 from config1 = headerON
+ else
+ config1 = config1 & 0B11111110; // clears bit 0 from config1 = headerON
+
+ writeRegister(REG_MODEM_CONFIG1,config1); // Update config1
+ }
+
+ // added by C. Pham
+ uint8_t theHeaderBit;
+
+ if (_board==SX1272Chip)
+ theHeaderBit=2;
+ else
+ theHeaderBit=0;
+
+ if( _spreadingFactor != 6 )
+ { // checking headerON taking out bit 2 from REG_MODEM_CONFIG1
+ config1 = readRegister(REG_MODEM_CONFIG1);
+ // modified by C. Pham
+ if( bitRead(config1, theHeaderBit) == HEADER_ON )
+ {
+ state = 0;
+ _header = HEADER_ON;
+#if (SX1272_debug_mode > 1)
+ printf("## Header has been activated ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+ }
+ // modifie par C.Dupaty
+ //return state;
+ }
+ return state;
+}
+
+/*
+ Function: Sets the module in implicit header mode (header is not sent).
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::setHeaderOFF()
+{
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setHeaderOFF'\n");
+#endif
+
+ if( _modem == FSK )
+ { // header is not available in FSK mode
+ state = -1;
+#if (SX1272_debug_mode > 1)
+ printf("## Notice that FSK mode packets hasn't header ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ config1 = readRegister(REG_MODEM_CONFIG1); // Save config1 to modify only the header bit
+
+ // modified by C. Pham
+ if (_board==SX1272Chip)
+ config1 = config1 | 0B00000100; // sets bit 2 from REG_MODEM_CONFIG1 = headerOFF
+ else
+ config1 = config1 | 0B00000001; // sets bit 0 from REG_MODEM_CONFIG1 = headerOFF
+
+ writeRegister(REG_MODEM_CONFIG1,config1); // Update config1
+
+ config1 = readRegister(REG_MODEM_CONFIG1);
+
+ // added by C. Pham
+ uint8_t theHeaderBit;
+
+ if (_board==SX1272Chip)
+ theHeaderBit=2;
+ else
+ theHeaderBit=0;
+
+ if( bitRead(config1, theHeaderBit) == HEADER_OFF )
+ { // checking headerOFF taking out bit 2 from REG_MODEM_CONFIG1
+ state = 0;
+ _header = HEADER_OFF;
+
+#if (SX1272_debug_mode > 1)
+ printf("## Header has been desactivated ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Header hasn't been desactivated ##");
+ printf("\n");
+#endif
+ }
+ }
+ return state;
+}
+
+/*
+ Function: Indicates if module is configured with or without checking CRC.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getCRC()
+{
+ int8_t state = 2;
+ byte value;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getCRC'\n");
+#endif
+
+ if( _modem == LORA )
+ { // LoRa mode
+
+ // added by C. Pham
+ uint8_t theRegister;
+ uint8_t theCrcBit;
+
+ if (_board==SX1272Chip) {
+ theRegister=REG_MODEM_CONFIG1;
+ theCrcBit=1;
+ }
+ else {
+ theRegister=REG_MODEM_CONFIG2;
+ theCrcBit=2;
+ }
+
+ // take out bit 1 from REG_MODEM_CONFIG1 indicates RxPayloadCrcOn
+ value = readRegister(theRegister);
+ if( bitRead(value, theCrcBit) == CRC_OFF )
+ { // CRCoff
+ _CRC = CRC_OFF;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC is desactivated ##");
+ printf("\n");
+#endif
+ state = 0;
+ }
+ else
+ { // CRCon
+ _CRC = CRC_ON;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC is activated ##");
+ printf("\n");
+#endif
+ state = 0;
+ }
+ }
+ else
+ { // FSK mode
+
+ // take out bit 2 from REG_PACKET_CONFIG1 indicates CrcOn
+ value = readRegister(REG_PACKET_CONFIG1);
+ if( bitRead(value, 4) == CRC_OFF )
+ { // CRCoff
+ _CRC = CRC_OFF;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC is desactivated ##");
+ printf("\n");
+#endif
+ state = 0;
+ }
+ else
+ { // CRCon
+ _CRC = CRC_ON;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC is activated ##");
+ printf("\n");
+#endif
+ state = 0;
+ }
+ }
+ if( state != 0 )
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while getting configured CRC **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Sets the module with CRC on.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setCRC_ON()
+{
+ uint8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setCRC_ON'\n");
+#endif
+
+ if( _modem == LORA )
+ { // LORA mode
+
+ // added by C. Pham
+ uint8_t theRegister;
+ uint8_t theCrcBit;
+
+ if (_board==SX1272Chip) {
+ theRegister=REG_MODEM_CONFIG1;
+ theCrcBit=1;
+ }
+ else {
+ theRegister=REG_MODEM_CONFIG2;
+ theCrcBit=2;
+ }
+
+ config1 = readRegister(theRegister); // Save config1 to modify only the CRC bit
+
+ if (_board==SX1272Chip)
+ config1 = config1 | 0B00000010; // sets bit 1 from REG_MODEM_CONFIG1 = CRC_ON
+ else
+ config1 = config1 | 0B00000100; // sets bit 2 from REG_MODEM_CONFIG2 = CRC_ON
+
+ writeRegister(theRegister,config1);
+
+ state = 1;
+
+ config1 = readRegister(theRegister);
+
+ if( bitRead(config1, theCrcBit) == CRC_ON )
+ { // take out bit 1 from REG_MODEM_CONFIG1 indicates RxPayloadCrcOn
+ state = 0;
+ _CRC = CRC_ON;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC has been activated ##");
+ printf("\n");
+#endif
+ }
+ }
+ else
+ { // FSK mode
+ config1 = readRegister(REG_PACKET_CONFIG1); // Save config1 to modify only the CRC bit
+ config1 = config1 | 0B00010000; // set bit 4 and 3 from REG_MODEM_CONFIG1 = CRC_ON
+ writeRegister(REG_PACKET_CONFIG1,config1);
+
+ state = 1;
+
+ config1 = readRegister(REG_PACKET_CONFIG1);
+ if( bitRead(config1, 4) == CRC_ON )
+ { // take out bit 4 from REG_PACKET_CONFIG1 indicates CrcOn
+ state = 0;
+ _CRC = CRC_ON;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC has been activated ##");
+ printf("\n");
+#endif
+ }
+ }
+ if( state != 0 )
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while setting CRC ON **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Sets the module with CRC off.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setCRC_OFF()
+{
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setCRC_OFF'\n");
+#endif
+
+ if( _modem == LORA )
+ { // LORA mode
+
+ // added by C. Pham
+ uint8_t theRegister;
+ uint8_t theCrcBit;
+
+ if (_board==SX1272Chip) {
+ theRegister=REG_MODEM_CONFIG1;
+ theCrcBit=1;
+ }
+ else {
+ theRegister=REG_MODEM_CONFIG2;
+ theCrcBit=2;
+ }
+
+ config1 = readRegister(theRegister); // Save config1 to modify only the CRC bit
+ if (_board==SX1272Chip)
+ config1 = config1 & 0B11111101; // clears bit 1 from config1 = CRC_OFF
+ else
+ config1 = config1 & 0B11111011; // clears bit 2 from config1 = CRC_OFF
+
+ writeRegister(theRegister,config1);
+
+ config1 = readRegister(theRegister);
+ if( (bitRead(config1, theCrcBit)) == CRC_OFF )
+ { // take out bit 1 from REG_MODEM_CONFIG1 indicates RxPayloadCrcOn
+ state = 0;
+ _CRC = CRC_OFF;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC has been desactivated ##");
+ printf("\n");
+#endif
+ }
+ }
+ else
+ { // FSK mode
+ config1 = readRegister(REG_PACKET_CONFIG1); // Save config1 to modify only the CRC bit
+ config1 = config1 & 0B11101111; // clears bit 4 from config1 = CRC_OFF
+ writeRegister(REG_PACKET_CONFIG1,config1);
+
+ config1 = readRegister(REG_PACKET_CONFIG1);
+ if( bitRead(config1, 4) == CRC_OFF )
+ { // take out bit 4 from REG_PACKET_CONFIG1 indicates RxPayloadCrcOn
+ state = 0;
+ _CRC = CRC_OFF;
+#if (SX1272_debug_mode > 1)
+ printf("## CRC has been desactivated ##");
+ printf("\n");
+#endif
+ }
+ }
+ if( state != 0 )
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while setting CRC OFF **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Checks if SF is a valid value.
+ Returns: Boolean that's 'true' if the SF value exists and
+ it's 'false' if the SF value does not exist.
+ Parameters:
+ spr: spreading factor value to check.
+*/
+boolean SX1272::isSF(uint8_t spr)
+{
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'isSF'\n");
+#endif
+
+ // Checking available values for _spreadingFactor
+ switch(spr)
+ {
+ case SF_6:
+ case SF_7:
+ case SF_8:
+ case SF_9:
+ case SF_10:
+ case SF_11:
+ case SF_12:
+ return true;
+ //break;
+
+ default:
+ return false;
+ }
+#if (SX1272_debug_mode > 1)
+ printf("## Finished 'isSF' ##");
+ printf("\n");
+#endif
+}
+
+/*
+ Function: Gets the SF within the module is configured.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::getSF()
+{
+ int8_t state = 2;
+ byte config2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getSF'\n");
+#endif
+
+ if( _modem == FSK )
+ {
+ state = -1; // SF is not available in FSK mode
+#if (SX1272_debug_mode > 1)
+ printf("** FSK mode hasn't spreading factor **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ // take out bits 7-4 from REG_MODEM_CONFIG2 indicates _spreadingFactor
+ config2 = (readRegister(REG_MODEM_CONFIG2)) >> 4;
+ _spreadingFactor = config2;
+ state = 1;
+
+ if( (config2 == _spreadingFactor) && isSF(_spreadingFactor) )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Spreading factor is %X",_spreadingFactor);
+ // Serial.print(_spreadingFactor,HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ }
+ return state;
+}
+
+/*
+ Function: Sets the indicated SF in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ Parameters:
+ spr: spreading factor value to set in LoRa modem configuration.
+*/
+uint8_t SX1272::setSF(uint8_t spr)
+{
+ byte st0;
+ int8_t state = 2;
+ byte config1;
+ byte config2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setSF'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == FSK )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("## Notice that FSK hasn't Spreading Factor parameter, ");
+ printf("so you are configuring it in LoRa mode ##");
+#endif
+ state = setLORA(); // Setting LoRa mode
+ }
+ else
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // LoRa standby mode
+ config2 = (readRegister(REG_MODEM_CONFIG2)); // Save config2 to modify SF value (bits 7-4)
+ switch(spr)
+ {
+ case SF_6: config2 = config2 & 0B01101111; // clears bits 7 & 4 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B01100000; // sets bits 6 & 5 from REG_MODEM_CONFIG2
+ setHeaderOFF(); // Mandatory headerOFF with SF = 6
+ break;
+ case SF_7: config2 = config2 & 0B01111111; // clears bits 7 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B01110000; // sets bits 6, 5 & 4
+ break;
+ case SF_8: config2 = config2 & 0B10001111; // clears bits 6, 5 & 4 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B10000000; // sets bit 7 from REG_MODEM_CONFIG2
+ break;
+ case SF_9: config2 = config2 & 0B10011111; // clears bits 6, 5 & 4 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B10010000; // sets bits 7 & 4 from REG_MODEM_CONFIG2
+ break;
+ case SF_10: config2 = config2 & 0B10101111; // clears bits 6 & 4 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B10100000; // sets bits 7 & 5 from REG_MODEM_CONFIG2
+ break;
+ case SF_11: config2 = config2 & 0B10111111; // clears bit 6 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B10110000; // sets bits 7, 5 & 4 from REG_MODEM_CONFIG2
+ getBW();
+
+ // modified by C. Pham
+ if( _bandwidth == BW_125)
+ { // LowDataRateOptimize (Mandatory with SF_11 if BW_125)
+ if (_board==SX1272Chip) {
+ config1 = (readRegister(REG_MODEM_CONFIG1)); // Save config1 to modify only the LowDataRateOptimize
+ config1 = config1 | 0B00000001;
+ writeRegister(REG_MODEM_CONFIG1,config1);
+ }
+ else {
+ byte config3=readRegister(REG_MODEM_CONFIG3);
+ config3 = config3 | 0B00001000;
+ writeRegister(REG_MODEM_CONFIG3,config3);
+ }
+ }
+ break;
+ case SF_12: config2 = config2 & 0B11001111; // clears bits 5 & 4 from REG_MODEM_CONFIG2
+ config2 = config2 | 0B11000000; // sets bits 7 & 6 from REG_MODEM_CONFIG2
+ if( _bandwidth == BW_125)
+ { // LowDataRateOptimize (Mandatory with SF_12 if BW_125)
+ // modified by C. Pham
+ if (_board==SX1272Chip) {
+ config1 = (readRegister(REG_MODEM_CONFIG1)); // Save config1 to modify only the LowDataRateOptimize
+ config1 = config1 | 0B00000001;
+ writeRegister(REG_MODEM_CONFIG1,config1);
+ }
+ else {
+ byte config3=readRegister(REG_MODEM_CONFIG3);
+ config3 = config3 | 0B00001000;
+ writeRegister(REG_MODEM_CONFIG3,config3);
+ }
+ }
+ break;
+ }
+
+ // Check if it is neccesary to set special settings for SF=6
+ if( spr == SF_6 )
+ {
+ // Mandatory headerOFF with SF = 6 (Implicit mode)
+ setHeaderOFF();
+
+ // Set the bit field DetectionOptimize of
+ // register RegLoRaDetectOptimize to value "0b101".
+ writeRegister(REG_DETECT_OPTIMIZE, 0x05);
+
+ // Write 0x0C in the register RegDetectionThreshold.
+ writeRegister(REG_DETECTION_THRESHOLD, 0x0C);
+ }
+ else
+ {
+ // added by C. Pham
+ setHeaderON();
+
+ // LoRa detection Optimize: 0x03 --> SF7 to SF12
+ writeRegister(REG_DETECT_OPTIMIZE, 0x03);
+
+ // LoRa detection threshold: 0x0A --> SF7 to SF12
+ writeRegister(REG_DETECTION_THRESHOLD, 0x0A);
+ }
+
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ // comment by C. Pham
+ // bit 9:8 of SymbTimeout are then 11
+ // single_chan_pkt_fwd uses 00 and then 00001000
+ // why?
+ // sets bit 2-0 (AgcAutoOn and SymbTimout) for any SF value
+ //config2 = config2 | 0B00000111;
+ // modified by C. Pham
+ config2 = config2 | 0B00000100;
+ writeRegister(REG_MODEM_CONFIG1, config1); // Update config1
+ }
+ else {
+ // set the AgcAutoOn in bit 2 of REG_MODEM_CONFIG3
+ uint8_t config3 = (readRegister(REG_MODEM_CONFIG3));
+ config3=config3 | 0B00000100;
+ writeRegister(REG_MODEM_CONFIG3, config3);
+ }
+
+ // here we write the new SF
+ writeRegister(REG_MODEM_CONFIG2, config2); // Update config2
+
+ wait_ms(100);
+
+ // added by C. Pham
+ byte configAgc;
+ uint8_t theLDRBit;
+
+ if (_board==SX1272Chip) {
+ config1 = (readRegister(REG_MODEM_CONFIG1)); // Save config1 to check update
+ config2 = (readRegister(REG_MODEM_CONFIG2)); // Save config2 to check update
+ // comment by C. Pham
+ // (config2 >> 4) ---> take out bits 7-4 from REG_MODEM_CONFIG2 (=_spreadingFactor)
+ // bitRead(config1, 0) ---> take out bits 1 from config1 (=LowDataRateOptimize)
+ // config2 is only for the AgcAutoOn
+ configAgc=config2;
+ theLDRBit=0;
+ }
+ else {
+ config1 = (readRegister(REG_MODEM_CONFIG3)); // Save config1 to check update
+ config2 = (readRegister(REG_MODEM_CONFIG2));
+ // LowDataRateOptimize is in REG_MODEM_CONFIG3
+ // AgcAutoOn is in REG_MODEM_CONFIG3
+ configAgc=config1;
+ theLDRBit=3;
+ }
+
+
+ switch(spr)
+ {
+ case SF_6: if( ((config2 >> 4) == spr)
+ && (bitRead(configAgc, 2) == 1)
+ && (_header == HEADER_OFF))
+ {
+ state = 0;
+ }
+ break;
+ case SF_7: if( ((config2 >> 4) == 0x07)
+ && (bitRead(configAgc, 2) == 1))
+ {
+ state = 0;
+ }
+ break;
+ case SF_8: if( ((config2 >> 4) == 0x08)
+ && (bitRead(configAgc, 2) == 1))
+ {
+ state = 0;
+ }
+ break;
+ case SF_9: if( ((config2 >> 4) == 0x09)
+ && (bitRead(configAgc, 2) == 1))
+ {
+ state = 0;
+ }
+ break;
+ case SF_10: if( ((config2 >> 4) == 0x0A)
+ && (bitRead(configAgc, 2) == 1))
+ {
+ state = 0;
+ }
+ break;
+ case SF_11: if( ((config2 >> 4) == 0x0B)
+ && (bitRead(configAgc, 2) == 1)
+ && (bitRead(config1, theLDRBit) == 1))
+ {
+ state = 0;
+ }
+ break;
+ case SF_12: if( ((config2 >> 4) == 0x0C)
+ && (bitRead(configAgc, 2) == 1)
+ && (bitRead(config1, theLDRBit) == 1))
+ {
+ state = 0;
+ }
+ break;
+ default: state = 1;
+ }
+ }
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+
+ if( isSF(spr) )
+ { // Checking available value for _spreadingFactor
+ state = 0;
+ _spreadingFactor = spr;
+#if (SX1272_debug_mode > 1)
+ printf("## Spreading factor %d ",_spreadingFactor);
+ // Serial.print(_spreadingFactor, DEC);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ if( state != 0 )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while setting the spreading factor **");
+ printf("\n");
+#endif
+ }
+ }
+ return state;
+}
+
+/*
+ Function: Checks if BW is a valid value.
+ Returns: Boolean that's 'true' if the BW value exists and
+ it's 'false' if the BW value does not exist.
+ Parameters:
+ band: bandwidth value to check.
+*/
+boolean SX1272::isBW(uint16_t band)
+{
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'isBW'\n");
+#endif
+
+ // Checking available values for _bandwidth
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ switch(band)
+ {
+ case BW_125:
+ case BW_250:
+ case BW_500:
+ return true;
+ //break;
+
+ default:
+ return false;
+ }
+ }
+ else {
+ switch(band)
+ {
+ case BW_7_8:
+ case BW_10_4:
+ case BW_15_6:
+ case BW_20_8:
+ case BW_31_25:
+ case BW_41_7:
+ case BW_62_5:
+ case BW_125:
+ case BW_250:
+ case BW_500:
+ return true;
+ //break;
+
+ default:
+ return false;
+ }
+ }
+
+#if (SX1272_debug_mode > 1)
+ printf("## Finished 'isBW' ##");
+ printf("\n");
+#endif
+}
+
+/*
+ Function: Gets the BW within the module is configured.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::getBW()
+{
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getBW'\n");
+#endif
+
+ if( _modem == FSK )
+ {
+ state = -1; // BW is not available in FSK mode
+#if (SX1272_debug_mode > 1)
+ printf("** FSK mode hasn't bandwidth **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ // take out bits 7-6 from REG_MODEM_CONFIG1 indicates _bandwidth
+ config1 = (readRegister(REG_MODEM_CONFIG1)) >> 6;
+ }
+ else {
+ // take out bits 7-4 from REG_MODEM_CONFIG1 indicates _bandwidth
+ config1 = (readRegister(REG_MODEM_CONFIG1)) >> 4;
+ }
+
+ _bandwidth = config1;
+
+ if( (config1 == _bandwidth) && isBW(_bandwidth) )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Bandwidth is %X ",_bandwidth);
+ // Serial.print(_bandwidth,HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while getting bandwidth **");
+ printf("\n");
+#endif
+ }
+ }
+ return state;
+}
+
+/*
+ Function: Sets the indicated BW in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ Parameters:
+ band: bandwith value to set in LoRa modem configuration.
+*/
+int8_t SX1272::setBW(uint16_t band)
+{
+ byte st0;
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setBW'\n");
+#endif
+
+ if(!isBW(band) )
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Bandwidth %X ",band);
+ // Serial.print(band, HEX);
+ printf(" is not a correct value **");
+ printf("\n");
+#endif
+ return state;
+ }
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == FSK )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("## Notice that FSK hasn't Bandwidth parameter, ");
+ printf("so you are configuring it in LoRa mode ##");
+#endif
+ state = setLORA();
+ }
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // LoRa standby mode
+ config1 = (readRegister(REG_MODEM_CONFIG1)); // Save config1 to modify only the BW
+
+ // added by C. Pham for SX1276
+ if (_board==SX1272Chip) {
+ switch(band)
+ {
+ case BW_125: config1 = config1 & 0B00111111; // clears bits 7 & 6 from REG_MODEM_CONFIG1
+ getSF();
+ if( _spreadingFactor == 11 )
+ { // LowDataRateOptimize (Mandatory with BW_125 if SF_11)
+ config1 = config1 | 0B00000001;
+ }
+ if( _spreadingFactor == 12 )
+ { // LowDataRateOptimize (Mandatory with BW_125 if SF_12)
+ config1 = config1 | 0B00000001;
+ }
+ break;
+ case BW_250: config1 = config1 & 0B01111111; // clears bit 7 from REG_MODEM_CONFIG1
+ config1 = config1 | 0B01000000; // sets bit 6 from REG_MODEM_CONFIG1
+ break;
+ case BW_500: config1 = config1 & 0B10111111; //clears bit 6 from REG_MODEM_CONFIG1
+ config1 = config1 | 0B10000000; //sets bit 7 from REG_MODEM_CONFIG1
+ break;
+ }
+ }
+ else {
+ // SX1276
+ config1 = config1 & 0B00001111; // clears bits 7 - 4 from REG_MODEM_CONFIG1
+ switch(band)
+ {
+ case BW_125:
+ // 0111
+ config1 = config1 | 0B01110000;
+ getSF();
+ if( _spreadingFactor == 11 || _spreadingFactor == 12)
+ { // LowDataRateOptimize (Mandatory with BW_125 if SF_11 or SF_12)
+ byte config3=readRegister(REG_MODEM_CONFIG3);
+ config3 = config3 | 0B00001000;
+ writeRegister(REG_MODEM_CONFIG3,config3);
+ }
+ break;
+ case BW_250:
+ // 1000
+ config1 = config1 | 0B10000000;
+ break;
+ case BW_500:
+ // 1001
+ config1 = config1 | 0B10010000;
+ break;
+ }
+ }
+ // end
+
+ writeRegister(REG_MODEM_CONFIG1,config1); // Update config1
+
+ wait_ms(100);
+
+ config1 = (readRegister(REG_MODEM_CONFIG1));
+
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ // (config1 >> 6) ---> take out bits 7-6 from REG_MODEM_CONFIG1 (=_bandwidth)
+ switch(band)
+ {
+ case BW_125: if( (config1 >> 6) == SX1272_BW_125 )
+ {
+ state = 0;
+ if( _spreadingFactor == 11 )
+ {
+ if( bitRead(config1, 0) == 1 )
+ { // LowDataRateOptimize
+ state = 0;
+ }
+ else
+ {
+ state = 1;
+ }
+ }
+ if( _spreadingFactor == 12 )
+ {
+ if( bitRead(config1, 0) == 1 )
+ { // LowDataRateOptimize
+ state = 0;
+ }
+ else
+ {
+ state = 1;
+ }
+ }
+ }
+ break;
+ case BW_250: if( (config1 >> 6) == SX1272_BW_250 )
+ {
+ state = 0;
+ }
+ break;
+ case BW_500: if( (config1 >> 6) == SX1272_BW_500 )
+ {
+ state = 0;
+ }
+ break;
+ }
+ }
+ else {
+ // (config1 >> 4) ---> take out bits 7-4 from REG_MODEM_CONFIG1 (=_bandwidth)
+ switch(band)
+ {
+ case BW_125: if( (config1 >> 4) == BW_125 )
+ {
+ state = 0;
+
+ byte config3 = (readRegister(REG_MODEM_CONFIG3));
+
+ if( _spreadingFactor == 11 )
+ {
+ if( bitRead(config3, 3) == 1 )
+ { // LowDataRateOptimize
+ state = 0;
+ }
+ else
+ {
+ state = 1;
+ }
+ }
+ if( _spreadingFactor == 12 )
+ {
+ if( bitRead(config3, 3) == 1 )
+ { // LowDataRateOptimize
+ state = 0;
+ }
+ else
+ {
+ state = 1;
+ }
+ }
+ }
+ break;
+ case BW_250: if( (config1 >> 4) == BW_250 )
+ {
+ state = 0;
+ }
+ break;
+ case BW_500: if( (config1 >> 4) == BW_500 )
+ {
+ state = 0;
+ }
+ break;
+ }
+ }
+
+ if(state==0)
+ {
+ _bandwidth = band;
+#if (SX1272_debug_mode > 1)
+ printf("## Bandwidth %X ",band);
+ // Serial.print(band, HEX);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Checks if CR is a valid value.
+ Returns: Boolean that's 'true' if the CR value exists and
+ it's 'false' if the CR value does not exist.
+ Parameters:
+ cod: coding rate value to check.
+*/
+boolean SX1272::isCR(uint8_t cod)
+{
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'isCR'\n");
+#endif
+
+ // Checking available values for _codingRate
+ switch(cod)
+ {
+ case CR_5:
+ case CR_6:
+ case CR_7:
+ case CR_8:
+ return true;
+ //break;
+
+ default:
+ return false;
+ }
+#if (SX1272_debug_mode > 1)
+ printf("## Finished 'isCR' ##");
+ printf("\n");
+#endif
+}
+
+/*
+ Function: Indicates the CR within the module is configured.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::getCR()
+{
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getCR'\n");
+#endif
+
+ if( _modem == FSK )
+ {
+ state = -1; // CR is not available in FSK mode
+#if (SX1272_debug_mode > 1)
+ printf("** FSK mode hasn't coding rate **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ // take out bits 7-3 from REG_MODEM_CONFIG1 indicates _bandwidth & _codingRate
+ config1 = (readRegister(REG_MODEM_CONFIG1)) >> 3;
+ config1 = config1 & 0B00000111; // clears bits 7-3 ---> clears _bandwidth
+ }
+ else {
+ // take out bits 7-1 from REG_MODEM_CONFIG1 indicates _bandwidth & _codingRate
+ config1 = (readRegister(REG_MODEM_CONFIG1)) >> 1;
+ config1 = config1 & 0B00000111; // clears bits 7-3 ---> clears _bandwidth
+ }
+
+ _codingRate = config1;
+ state = 1;
+
+ if( (config1 == _codingRate) && isCR(_codingRate) )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Coding rate is %X ",_codingRate);
+ // Serial.print(_codingRate, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ }
+ return state;
+}
+
+/*
+ Function: Sets the indicated CR in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ cod: coding rate value to set in LoRa modem configuration.
+*/
+int8_t SX1272::setCR(uint8_t cod)
+{
+ byte st0;
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setCR'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == FSK )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("## Notice that FSK hasn't Coding Rate parameter, ");
+ printf("so you are configuring it in LoRa mode ##");
+#endif
+ state = setLORA();
+ }
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Set Standby mode to write in registers
+
+ config1 = readRegister(REG_MODEM_CONFIG1); // Save config1 to modify only the CR
+
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ switch(cod)
+ {
+ case CR_5: config1 = config1 & 0B11001111; // clears bits 5 & 4 from REG_MODEM_CONFIG1
+ config1 = config1 | 0B00001000; // sets bit 3 from REG_MODEM_CONFIG1
+ break;
+ case CR_6: config1 = config1 & 0B11010111; // clears bits 5 & 3 from REG_MODEM_CONFIG1
+ config1 = config1 | 0B00010000; // sets bit 4 from REG_MODEM_CONFIG1
+ break;
+ case CR_7: config1 = config1 & 0B11011111; // clears bit 5 from REG_MODEM_CONFIG1
+ config1 = config1 | 0B00011000; // sets bits 4 & 3 from REG_MODEM_CONFIG1
+ break;
+ case CR_8: config1 = config1 & 0B11100111; // clears bits 4 & 3 from REG_MODEM_CONFIG1
+ config1 = config1 | 0B00100000; // sets bit 5 from REG_MODEM_CONFIG1
+ break;
+ }
+ }
+ else {
+ // SX1276
+ config1 = config1 & 0B11110001; // clears bits 3 - 1 from REG_MODEM_CONFIG1
+ switch(cod)
+ {
+ case CR_5:
+ config1 = config1 | 0B00000010;
+ break;
+ case CR_6:
+ config1 = config1 | 0B00000100;
+ break;
+ case CR_7:
+ config1 = config1 | 0B00000110;
+ break;
+ case CR_8:
+ config1 = config1 | 0B00001000;
+ break;
+ }
+ }
+ writeRegister(REG_MODEM_CONFIG1, config1); // Update config1
+
+ wait_ms(100);
+
+ config1 = readRegister(REG_MODEM_CONFIG1);
+
+ // added by C. Pham
+ uint8_t nshift=3;
+
+ // only 1 right shift for SX1276
+ if (_board==SX1276Chip)
+ nshift=1;
+
+ // ((config1 >> 3) & 0B0000111) ---> take out bits 5-3 from REG_MODEM_CONFIG1 (=_codingRate)
+ switch(cod)
+ {
+ case CR_5: if( ((config1 >> nshift) & 0B0000111) == 0x01 )
+ {
+ state = 0;
+ }
+ break;
+ case CR_6: if( ((config1 >> nshift) & 0B0000111) == 0x02 )
+ {
+ state = 0;
+ }
+ break;
+ case CR_7: if( ((config1 >> nshift) & 0B0000111) == 0x03 )
+ {
+ state = 0;
+ }
+ break;
+ case CR_8: if( ((config1 >> nshift) & 0B0000111) == 0x04 )
+ {
+ state = 0;
+ }
+ break;
+ }
+
+
+ if( isCR(cod) )
+ {
+ _codingRate = cod;
+#if (SX1272_debug_mode > 1)
+ printf("## Coding Rate %X ",cod);
+ // Serial.print(cod, HEX);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while configuring Coding Rate parameter **");
+ printf("\n");
+#endif
+ }
+ writeRegister(REG_OP_MODE,st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Checks if channel is a valid value.
+ Returns: Boolean that's 'true' if the CR value exists and
+ it's 'false' if the CR value does not exist.
+ Parameters:
+ ch: frequency channel value to check.
+*/
+boolean SX1272::isChannel(uint32_t ch)
+{
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'isChannel'\n");
+#endif
+
+ // Checking available values for _channel
+ switch(ch)
+ {
+ //added by C. Pham
+ case CH_04_868:
+ case CH_05_868:
+ case CH_06_868:
+ case CH_07_868:
+ case CH_08_868:
+ case CH_09_868:
+ //end
+ case CH_10_868:
+ case CH_11_868:
+ case CH_12_868:
+ case CH_13_868:
+ case CH_14_868:
+ case CH_15_868:
+ case CH_16_868:
+ case CH_17_868:
+ //added by C. Pham
+ case CH_18_868:
+ //end
+ case CH_00_900:
+ case CH_01_900:
+ case CH_02_900:
+ case CH_03_900:
+ case CH_04_900:
+ case CH_05_900:
+ case CH_06_900:
+ case CH_07_900:
+ case CH_08_900:
+ case CH_09_900:
+ case CH_10_900:
+ case CH_11_900:
+ //added by C. Pham
+ case CH_12_900:
+ case CH_00_433:
+ case CH_01_433:
+ case CH_02_433:
+ case CH_03_433:
+ //end
+ return true;
+ //break;
+
+ default:
+ return false;
+ }
+#if (SX1272_debug_mode > 1)
+ printf("## Finished 'isChannel' ##");
+ printf("\n");
+#endif
+}
+
+/*
+ Function: Indicates the frequency channel within the module is configured.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getChannel()
+{
+ uint8_t state = 2;
+ uint32_t ch;
+ uint8_t freq3;
+ uint8_t freq2;
+ uint8_t freq1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getChannel'\n");
+#endif
+
+ freq3 = readRegister(REG_FRF_MSB); // frequency channel MSB
+ freq2 = readRegister(REG_FRF_MID); // frequency channel MID
+ freq1 = readRegister(REG_FRF_LSB); // frequency channel LSB
+ ch = ((uint32_t)freq3 << 16) + ((uint32_t)freq2 << 8) + (uint32_t)freq1;
+ _channel = ch; // frequency channel
+
+ if( (_channel == ch) && isChannel(_channel) )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Frequency channel is %d ", _channel);
+ // Serial.print(_channel, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+ return state;
+}
+
+/*
+ Function: Sets the indicated channel in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ ch: frequency channel value to set in configuration.
+*/
+int8_t SX1272::setChannel(uint32_t ch)
+{
+ byte st0;
+ int8_t state = 2;
+ unsigned int freq3;
+ unsigned int freq2;
+ uint8_t freq1;
+ uint32_t freq;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setChannel'\n");
+#endif
+
+ // added by C. Pham
+ _starttime=millis();
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ if( _modem == LORA )
+ {
+ // LoRa Stdby mode in order to write in registers
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+ }
+ else
+ {
+ // FSK Stdby mode in order to write in registers
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);
+ }
+
+ freq3 = ((ch >> 16) & 0x0FF); // frequency channel MSB
+ freq2 = ((ch >> 8) & 0x0FF); // frequency channel MIB
+ freq1 = (ch & 0xFF); // frequency channel LSB
+
+ writeRegister(REG_FRF_MSB, freq3);
+ writeRegister(REG_FRF_MID, freq2);
+ writeRegister(REG_FRF_LSB, freq1);
+
+ // added by C. Pham
+ _stoptime=millis();
+
+ wait_ms(100);
+
+ // storing MSB in freq channel value
+ freq3 = (readRegister(REG_FRF_MSB));
+ freq = (freq3 << 8) & 0xFFFFFF;
+
+ // storing MID in freq channel value
+ freq2 = (readRegister(REG_FRF_MID));
+ freq = (freq << 8) + ((freq2 << 8) & 0xFFFFFF);
+
+ // storing LSB in freq channel value
+ freq = freq + ((readRegister(REG_FRF_LSB)) & 0xFFFFFF);
+
+ if( freq == ch )
+ {
+ state = 0;
+ _channel = ch;
+#if (SX1272_debug_mode > 1)
+ printf("## Frequency channel %X ",ch);
+ // Serial.print(ch, HEX);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+
+ // commented by C. Pham to avoid adding new channel each time
+ // besides, the test above is sufficient
+ /*
+ if(!isChannel(ch) )
+ {
+ state = -1;
+#if (SX1272_debug_mode > 1)
+ printf("** Frequency channel ");
+ Serial.print(ch, HEX);
+ printf("is not a correct value **");
+ printf("\n");
+#endif
+ }
+ */
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Gets the signal power within the module is configured.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getPower()
+{
+ uint8_t state = 2;
+ int8_t value = 0x00; // modifie par C.Dupaty type byte a l'origine
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getPower'\n");
+#endif
+
+ value = readRegister(REG_PA_CONFIG);
+ state = 1;
+
+ // modified by C. Pham
+ // get only the OutputPower
+ _power = value & 0B00001111;
+
+ if( (value > -1) & (value < 16) )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Output power is %X ",_power);
+ // Serial.print(_power, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+
+ return state;
+}
+
+/*
+ Function: Sets the signal power indicated in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ p: power option to set in configuration.
+*/
+int8_t SX1272::setPower(char p)
+{
+ byte st0;
+ int8_t state = 2;
+ byte value = 0x00;
+
+ byte RegPaDacReg=(_board==SX1272Chip)?0x5A:0x4D;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPower'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ if( _modem == LORA )
+ { // LoRa Stdby mode to write in registers
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+ }
+ else
+ { // FSK Stdby mode to write in registers
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);
+ }
+
+ switch (p)
+ {
+ // L = Low. On SX1272/76: PA0 on RFO setting
+ // H = High. On SX1272/76: PA0 on RFO setting
+ // M = MAX. On SX1272/76: PA0 on RFO setting
+
+ // x = extreme; added by C. Pham. On SX1272/76: PA1&PA2 PA_BOOST setting
+ // X = eXtreme; added by C. Pham. On SX1272/76: PA1&PA2 PA_BOOST setting + 20dBm settings
+
+ // added by C. Pham
+ //
+ case 'x':
+ case 'X':
+ case 'M': value = 0x0F;
+ // SX1272/76: 14dBm
+ break;
+
+ // modified by C. Pham, set to 0x03 instead of 0x00
+ case 'L': value = 0x03;
+ // SX1272/76: 2dBm
+ break;
+
+ case 'H': value = 0x07;
+ // SX1272/76: 6dBm
+ break;
+
+ default: state = -1;
+ break;
+ }
+
+ // 100mA
+ setMaxCurrent(0x0B);
+
+ if (p=='x') {
+ // we set only the PA_BOOST pin
+ // limit to 14dBm
+ value = 0x0C;
+ value = value & 0B10000000;
+ // set RegOcp for OcpOn and OcpTrim
+ // 130mA
+ setMaxCurrent(0x10);
+ }
+
+ if (p=='X') {
+ // normally value = 0x0F;
+ // we set the PA_BOOST pin
+ value = value & 0B10000000;
+ // and then set the high output power config with register REG_PA_DAC
+ writeRegister(RegPaDacReg, 0x87);
+ // set RegOcp for OcpOn and OcpTrim
+ // 150mA
+ setMaxCurrent(0x12);
+ }
+ else {
+ // disable high power output in all other cases
+ writeRegister(RegPaDacReg, 0x84);
+ }
+
+ // added by C. Pham
+ if (_board==SX1272Chip) {
+ // Pout = -1 + _power[3:0] on RFO
+ // Pout = 2 + _power[3:0] on PA_BOOST
+ // so: L=2dBm; H=6dBm, M=14dBm, x=14dBm (PA), X=20dBm(PA+PADAC)
+ writeRegister(REG_PA_CONFIG, value); // Setting output power value
+ }
+ else {
+ // for the SX1276
+
+ // set MaxPower to 7 -> Pmax=10.8+0.6*MaxPower [dBm] = 15
+ value = value & 0B01110000;
+
+ // then Pout = Pmax-(15-_power[3:0]) if PaSelect=0 (RFO pin for +14dBm)
+ // so L=3dBm; H=7dBm; M=15dBm (but should be limited to 14dBm by RFO pin)
+
+ // and Pout = 17-(15-_power[3:0]) if PaSelect=1 (PA_BOOST pin for +14dBm)
+ // so x= 14dBm (PA);
+ // when p=='X' for 20dBm, value is 0x0F and RegPaDacReg=0x87 so 20dBm is enabled
+
+ writeRegister(REG_PA_CONFIG, value);
+ }
+
+ _power=value;
+
+ value = readRegister(REG_PA_CONFIG);
+
+ if( value == _power )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Output power has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Sets the signal power indicated in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ p: power option to set in configuration.
+*/
+int8_t SX1272::setPowerNum(uint8_t pow)
+{
+ byte st0;
+ int8_t state = 2;
+ byte value = 0x00;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPower'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ if( _modem == LORA )
+ { // LoRa Stdby mode to write in registers
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+ }
+ else
+ { // FSK Stdby mode to write in registers
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);
+ }
+
+ // Modifie par C.Dupaty
+ // if ( (pow >= 0) & (pow < 15) )
+ if (pow < 15)
+ {
+ _power = pow;
+ }
+ else
+ {
+ state = -1;
+#if (SX1272_debug_mode > 1)
+ printf("## Power value is not valid ##");
+ printf("\n");
+#endif
+ }
+
+ // added by C. Pham
+ if (_board==SX1276Chip) {
+ value=readRegister(REG_PA_CONFIG);
+ // clear OutputPower, but keep current value of PaSelect and MaxPower
+ value=value & 0B11110000;
+ value=value + _power;
+ _power=value;
+ }
+ writeRegister(REG_PA_CONFIG, _power); // Setting output power value
+ value = readRegister(REG_PA_CONFIG);
+
+ if( value == _power )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Output power has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+
+/*
+ Function: Gets the preamble length from the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getPreambleLength()
+{
+ int8_t state = 2;
+ uint8_t p_length;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getPreambleLength'\n");
+#endif
+
+ state = 1;
+ if( _modem == LORA )
+ { // LORA mode
+ p_length = readRegister(REG_PREAMBLE_MSB_LORA);
+ // Saving MSB preamble length in LoRa mode
+ _preamblelength = (p_length << 8) & 0xFFFF;
+ p_length = readRegister(REG_PREAMBLE_LSB_LORA);
+ // Saving LSB preamble length in LoRa mode
+ _preamblelength = _preamblelength + (p_length & 0xFFFF);
+#if (SX1272_debug_mode > 1)
+ printf("## Preamble length configured is %X ",_preamblelength);
+ // Serial.print(_preamblelength, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ else
+ { // FSK mode
+ p_length = readRegister(REG_PREAMBLE_MSB_FSK);
+ // Saving MSB preamble length in FSK mode
+ _preamblelength = (p_length << 8) & 0xFFFF;
+ p_length = readRegister(REG_PREAMBLE_LSB_FSK);
+ // Saving LSB preamble length in FSK mode
+ _preamblelength = _preamblelength + (p_length & 0xFFFF);
+#if (SX1272_debug_mode > 1)
+ printf("## Preamble length configured is %X ",_preamblelength);
+ // Serial.print(_preamblelength, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ state = 0;
+ return state;
+}
+
+/*
+ Function: Sets the preamble length in the module
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ Parameters:
+ l: length value to set as preamble length.
+*/
+uint8_t SX1272::setPreambleLength(uint16_t l)
+{
+ byte st0;
+ uint8_t p_length;
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPreambleLength'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ state = 1;
+ if( _modem == LORA )
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Set Standby mode to write in registers
+ p_length = ((l >> 8) & 0x0FF);
+ // Storing MSB preamble length in LoRa mode
+ writeRegister(REG_PREAMBLE_MSB_LORA, p_length);
+ p_length = (l & 0x0FF);
+ // Storing LSB preamble length in LoRa mode
+ writeRegister(REG_PREAMBLE_LSB_LORA, p_length);
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Set Standby mode to write in registers
+ p_length = ((l >> 8) & 0x0FF);
+ // Storing MSB preamble length in FSK mode
+ writeRegister(REG_PREAMBLE_MSB_FSK, p_length);
+ p_length = (l & 0x0FF);
+ // Storing LSB preamble length in FSK mode
+ writeRegister(REG_PREAMBLE_LSB_FSK, p_length);
+ }
+
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Preamble length %X ",l);
+ // Serial.print(l, HEX);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+/*
+ Function: Gets the payload length from the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getPayloadLength()
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getPayloadLength'\n");
+#endif
+
+ if( _modem == LORA )
+ { // LORA mode
+ // Saving payload length in LoRa mode
+ _payloadlength = readRegister(REG_PAYLOAD_LENGTH_LORA);
+ state = 1;
+ }
+ else
+ { // FSK mode
+ // Saving payload length in FSK mode
+ _payloadlength = readRegister(REG_PAYLOAD_LENGTH_FSK);
+ state = 1;
+ }
+
+#if (SX1272_debug_mode > 1)
+ printf("## Payload length configured is %X ",_payloadlength);
+ // Serial.print(_payloadlength, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+
+ state = 0;
+ return state;
+}
+
+/*
+ Function: Sets the packet length in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::setPacketLength()
+{
+ uint16_t length;
+
+ // added by C. Pham
+ // if gateway is in rawFormat mode for packet reception, it will also send in rawFormat
+ // unless we switch it back to normal format just for transmission, e.g. for downlink transmission
+ if (_rawFormat)
+ length = _payloadlength;
+ else
+ length = _payloadlength + OFFSET_PAYLOADLENGTH;
+
+ return setPacketLength(length);
+}
+
+/*
+ Function: Sets the packet length in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ l: length value to set as payload length.
+*/
+int8_t SX1272::setPacketLength(uint8_t l)
+{
+ byte st0;
+ byte value = 0x00;
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPacketLength'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ packet_sent.length = l;
+
+ if( _modem == LORA )
+ { // LORA mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Set LoRa Standby mode to write in registers
+ writeRegister(REG_PAYLOAD_LENGTH_LORA, packet_sent.length);
+ // Storing payload length in LoRa mode
+ value = readRegister(REG_PAYLOAD_LENGTH_LORA);
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Set FSK Standby mode to write in registers
+ writeRegister(REG_PAYLOAD_LENGTH_FSK, packet_sent.length);
+ // Storing payload length in FSK mode
+ value = readRegister(REG_PAYLOAD_LENGTH_FSK);
+ }
+
+ if( packet_sent.length == value )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Packet length %d ",packet_sent.length);
+ // Serial.print(packet_sent.length, DEC);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ // comment by C. Pham
+ // this delay is included in the send delay overhead
+ // TODO: do we really need this delay?
+ wait_ms(250);
+ return state;
+}
+
+/*
+ Function: Gets the node address in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getNodeAddress()
+{
+ byte st0 = 0;
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getNodeAddress'\n");
+#endif
+
+ if( _modem == LORA )
+ { // LoRa mode
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ // Allowing access to FSK registers while in LoRa standby mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_FSK_REGS_MODE);
+ }
+
+ // Saving node address
+ _nodeAddress = readRegister(REG_NODE_ADRS);
+ state = 1;
+
+ if( _modem == LORA )
+ {
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ }
+
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Node address configured is %d ", _nodeAddress);
+ // Serial.print(_nodeAddress);
+ printf(" ##");
+ printf("\n");
+#endif
+ return state;
+}
+
+/*
+ Function: Sets the node address in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ addr: address value to set as node address.
+*/
+int8_t SX1272::setNodeAddress(uint8_t addr)
+{
+ byte st0;
+ uint8_t value; // type byte a l origine. Modifie par C.Dupaty
+ int8_t state = 2; // type uint_8 a l origine
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setNodeAddress'\n");
+#endif
+
+ if( addr > 255 )
+ {
+ state = -1;
+#if (SX1272_debug_mode > 1)
+ printf("** Node address must be less than 255 **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ // Saving node address
+ _nodeAddress = addr;
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == LORA )
+ { // Allowing access to FSK registers while in LoRa standby mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_FSK_REGS_MODE);
+ }
+ else
+ { //Set FSK Standby mode to write in registers
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);
+ }
+
+ // Storing node and broadcast address
+ writeRegister(REG_NODE_ADRS, addr);
+ writeRegister(REG_BROADCAST_ADRS, BROADCAST_0);
+
+ value = readRegister(REG_NODE_ADRS);
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+
+ if( value == _nodeAddress )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Node address %d ",addr);
+ // Serial.print(addr);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while setting address ##");
+ printf("\n");
+#endif
+ }
+ }
+ return state;
+}
+
+/*
+ Function: Gets the SNR value in LoRa mode.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::getSNR()
+{ // getSNR exists only in LoRa mode
+ int8_t state = 2;
+ byte value;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getSNR'\n");
+#endif
+
+ if( _modem == LORA )
+ { // LoRa mode
+ state = 1;
+ value = readRegister(REG_PKT_SNR_VALUE);
+ _rawSNR = value;
+
+ if( value & 0x80 ) // The SNR sign bit is 1
+ {
+ // Invert and divide by 4
+ value = ( ( ~value + 1 ) & 0xFF ) >> 2;
+ _SNR = -value;
+ }
+ else
+ {
+ // Divide by 4
+ _SNR = ( value & 0xFF ) >> 2;
+ }
+ state = 0;
+#if (SX1272_debug_mode > 0)
+ printf("## SNR value is %d\n",_SNR);
+ // Serial.print(_SNR, DEC);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ else
+ { // forbidden command if FSK mode
+ state = -1;
+#if (SX1272_debug_mode > 0)
+ printf("** SNR does not exist in FSK mode **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Gets the current value of RSSI.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getRSSI()
+{
+ uint8_t state = 2;
+ int rssi_mean = 0;
+ int total = 5;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getRSSI'\n");
+#endif
+
+ if( _modem == LORA )
+ {
+ /// LoRa mode
+ // get mean value of RSSI
+ for(int i = 0; i < total; i++)
+ {
+ // modified by C. Pham
+ // with SX1276 we have to add 18 to OFFSET_RSSI to obtain -157
+ _RSSI = -(OFFSET_RSSI+(_board==SX1276Chip?18:0)) + readRegister(REG_RSSI_VALUE_LORA);
+ rssi_mean += _RSSI;
+ }
+
+ rssi_mean = rssi_mean / total;
+ _RSSI = rssi_mean;
+
+ state = 0;
+#if (SX1272_debug_mode > 0)
+ printf("## RSSI value is %d",_RSSI);
+ // Serial.print(_RSSI, DEC);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ /// FSK mode
+ // get mean value of RSSI
+ for(int i = 0; i < total; i++)
+ {
+ _RSSI = (readRegister(REG_RSSI_VALUE_FSK) >> 1);
+ rssi_mean += _RSSI;
+ }
+ rssi_mean = rssi_mean / total;
+ _RSSI = rssi_mean;
+
+ state = 0;
+
+#if (SX1272_debug_mode > 0)
+ printf("## RSSI value is %d ",_RSSI);
+ //Serial.print(_RSSI);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Gets the RSSI of the last packet received in LoRa mode.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int16_t SX1272::getRSSIpacket()
+{ // RSSIpacket only exists in LoRa
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getRSSIpacket'\n");
+#endif
+
+ state = 1;
+ if( _modem == LORA )
+ { // LoRa mode
+ state = getSNR();
+ if( state == 0 )
+ {
+ // added by C. Pham
+ _RSSIpacket = readRegister(REG_PKT_RSSI_VALUE);
+
+ if( _SNR < 0 )
+ {
+ // commented by C. Pham
+ //_RSSIpacket = -NOISE_ABSOLUTE_ZERO + 10.0 * SignalBwLog[_bandwidth] + NOISE_FIGURE + ( double )_SNR;
+
+ // added by C. Pham, using Semtech SX1272 rev3 March 2015
+ // for SX1272 we use -139, for SX1276, we use -157
+ // then for SX1276 when using low-frequency (i.e. 433MHz) then we use -164
+ _RSSIpacket = -(OFFSET_RSSI+(_board==SX1276Chip?18:0)+(_channel<CH_04_868?7:0)) + (double)_RSSIpacket + (double)_rawSNR*0.25;
+ state = 0;
+ }
+ else
+ {
+ // commented by C. Pham
+ //_RSSIpacket = readRegister(REG_PKT_RSSI_VALUE);
+ _RSSIpacket = -(OFFSET_RSSI+(_board==SX1276Chip?18:0)+(_channel<CH_04_868?7:0)) + (double)_RSSIpacket;
+ //end
+ state = 0;
+ }
+#if (SX1272_debug_mode > 0)
+ printf("## RSSI packet value is %d",_RSSIpacket);
+ // Serial.print(_RSSIpacket, DEC);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ }
+ else
+ { // RSSI packet doesn't exist in FSK mode
+ state = -1;
+#if (SX1272_debug_mode > 0)
+ printf("** RSSI packet does not exist in FSK mode **");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: It sets the maximum number of retries.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 -->
+*/
+uint8_t SX1272::setRetries(uint8_t ret)
+{
+ int8_t state = 2; // uint8_t a l origine
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setRetries'\n");
+#endif
+
+ state = 1;
+ if( ret > MAX_RETRIES )
+ {
+ state = -1;
+#if (SX1272_debug_mode > 1)
+ printf("** Retries value can't be greater than %d ",MAX_RETRIES );
+ // Serial.print(MAX_RETRIES, DEC);
+ printf(" **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ _maxRetries = ret;
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Maximum retries value = %d ",_maxRetries);
+ // Serial.print(_maxRetries, DEC);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Gets the current supply limit of the power amplifier, protecting battery chemistries.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ Parameters:
+ rate: value to compute the maximum current supply. Maximum current is 45+5*'rate' [mA]
+*/
+uint8_t SX1272::getMaxCurrent()
+{
+ int8_t state = 2;
+ byte value;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getMaxCurrent'\n");
+#endif
+
+ state = 1;
+ _maxCurrent = readRegister(REG_OCP);
+
+ // extract only the OcpTrim value from the OCP register
+ _maxCurrent &= 0B00011111;
+
+ if( _maxCurrent <= 15 )
+ {
+ value = (45 + (5 * _maxCurrent));
+ }
+ else if( _maxCurrent <= 27 )
+ {
+ value = (-30 + (10 * _maxCurrent));
+ }
+ else
+ {
+ value = 240;
+ }
+
+ _maxCurrent = value;
+#if (SX1272_debug_mode > 1)
+ printf("## Maximum current supply configured is %d ",value);
+ // Serial.print(value, DEC);
+ printf(" mA ##");
+ printf("\n");
+#endif
+ state = 0;
+ return state;
+}
+
+/*
+ Function: Limits the current supply of the power amplifier, protecting battery chemistries.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden parameter value for this function
+ Parameters:
+ rate: value to compute the maximum current supply. Maximum current is 45+5*'rate' [mA]
+*/
+int8_t SX1272::setMaxCurrent(uint8_t rate)
+{
+ int8_t state = 2;
+ byte st0;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setMaxCurrent'\n");
+#endif
+
+ // Maximum rate value = 0x1B, because maximum current supply = 240 mA
+ if (rate > 0x1B)
+ {
+ state = -1;
+#if (SX1272_debug_mode > 1)
+ printf("** Maximum current supply is 240 mA, ");
+ printf("so maximum parameter value must be 27 (DEC) or 0x1B (HEX) **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ // Enable Over Current Protection
+ rate |= 0B00100000;
+
+ state = 1;
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ if( _modem == LORA )
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Set LoRa Standby mode to write in registers
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Set FSK Standby mode to write in registers
+ }
+ writeRegister(REG_OCP, rate); // Modifying maximum current supply
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ state = 0;
+ }
+ return state;
+}
+
+/*
+ Function: Gets the content of different registers.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getRegs()
+{
+ int8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getRegs'\n");
+#endif
+
+ state_f = 1;
+ state = getMode(); // Stores the BW, CR and SF.
+ if( state == 0 )
+ {
+ state = getPower(); // Stores the power.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting mode **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getChannel(); // Stores the channel.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting power **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getCRC(); // Stores the CRC configuration.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting channel **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getHeader(); // Stores the header configuration.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting CRC **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getPreambleLength(); // Stores the preamble length.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting header **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getPayloadLength(); // Stores the payload length.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting preamble length **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getNodeAddress(); // Stores the node address.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting payload length **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state = getMaxCurrent(); // Stores the maximum current supply.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting node address **");
+#endif
+ }
+ if( state == 0 )
+ {
+ state_f = getTemp(); // Stores the module temperature.
+ }
+ else
+ {
+ state_f = 1;
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting maximum current supply **");
+#endif
+ }
+ if( state_f != 0 )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("** Error getting temperature **");
+ printf("\n");
+#endif
+ }
+ return state_f;
+}
+
+/*
+ Function: It truncs the payload length if it is greater than 0xFF.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::truncPayload(uint16_t length16)
+{
+ uint8_t state = 2;
+
+ state = 1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'truncPayload'\n");
+#endif
+
+ if( length16 > MAX_PAYLOAD )
+ {
+ _payloadlength = MAX_PAYLOAD;
+ }
+ else
+ {
+ _payloadlength = (length16 & 0xFF);
+ }
+ state = 0;
+
+ return state;
+}
+
+/*
+ Function: It sets an ACK in FIFO in order to send it.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setACK()
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setACK'\n");
+#endif
+
+ // added by C. Pham
+ // check for enough remaining ToA
+ // when operating under duty-cycle mode
+ if (_limitToA) {
+ if (getRemainingToA() - getToA(ACK_LENGTH) < 0) {
+ printf("## not enough ToA for ACK at %d",millis());
+ // Serial.println(millis());
+ return SX1272_ERROR_TOA;
+ }
+ }
+
+ // delay(1000);
+
+ clearFlags(); // Initializing flags
+
+ if( _modem == LORA )
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Stdby LoRa mode to write in FIFO
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Stdby FSK mode to write in FIFO
+ }
+
+ // Setting ACK length in order to send it
+ state = setPacketLength(ACK_LENGTH);
+ if( state == 0 )
+ {
+ // Setting ACK
+ ACK.dst = packet_received.src; // ACK destination is packet source
+ ACK.type = PKT_TYPE_ACK;
+ ACK.src = packet_received.dst; // ACK source is packet destination
+ ACK.packnum = packet_received.packnum; // packet number that has been correctly received
+ ACK.length = 2;
+ ACK.data[0] = _reception; // CRC of the received packet
+ // added by C. Pham
+ // store the SNR
+ ACK.data[1]= readRegister(REG_PKT_SNR_VALUE);
+
+ // Setting address pointer in FIFO data buffer
+ writeRegister(REG_FIFO_ADDR_PTR, 0x80);
+
+ state = 1;
+
+ // Writing ACK to send in FIFO
+ writeRegister(REG_FIFO, ACK.dst); // Writing the destination in FIFO
+ writeRegister(REG_FIFO, ACK.type);
+ writeRegister(REG_FIFO, ACK.src); // Writing the source in FIFO
+ writeRegister(REG_FIFO, ACK.packnum); // Writing the packet number in FIFO
+ writeRegister(REG_FIFO, ACK.length); // Writing the packet length in FIFO
+ writeRegister(REG_FIFO, ACK.data[0]); // Writing the ACK in FIFO
+ writeRegister(REG_FIFO, ACK.data[1]); // Writing the ACK in FIFO
+
+ //#if (SX1272_debug_mode > 0)
+ printf("## ACK set and written in FIFO ##\n");
+ // Print the complete ACK if debug_mode
+ printf("## ACK to send:\n");
+ printf("Destination: %d\n",ACK.dst);
+ // Serial.println(ACK.dst); // Printing destination
+ printf("Source: %d\n",ACK.src);
+ // Serial.println(ACK.src); // Printing source
+ printf("ACK number: %d\n",ACK.packnum);
+ // Serial.println(ACK.packnum); // Printing ACK number
+ printf("ACK length: %d\n",ACK.length);
+ // Serial.println(ACK.length); // Printing ACK length
+ printf("ACK payload: %d\n",ACK.data[0]);
+ // Serial.println(ACK.data[0]); // Printing ACK payload
+ printf("ACK SNR last rcv pkt: %d\n",_SNR);
+ // Serial.println(_SNR);
+ printf("##\n");
+ printf("\n");
+ //#endif
+
+ state = 0;
+ _reception = CORRECT_PACKET; // Updating value to next packet
+
+ // comment by C. Pham
+ // TODO: do we really need this delay?
+ wait_ms(500);
+ }
+ return state;
+}
+
+/*
+ Function: Configures the module to receive information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receive()
+{
+ uint8_t state = 1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'receive'\n");
+#endif
+
+ // Initializing packet_received struct
+ memset( &packet_received, 0x00, sizeof(packet_received) );
+
+ // Setting Testmode
+ // commented by C. Pham
+ //writeRegister(0x31,0x43);
+
+ // Set LowPnTxPllOff
+ // modified by C. Pham from 0x09 to 0x08
+ writeRegister(REG_PA_RAMP, 0x08);
+
+ //writeRegister(REG_LNA, 0x23); // Important in reception
+ // modified by C. Pham
+ writeRegister(REG_LNA, LNA_MAX_GAIN);
+ writeRegister(REG_FIFO_ADDR_PTR, 0x00); // Setting address pointer in FIFO data buffer
+ // change RegSymbTimeoutLsb
+ // comment by C. Pham
+ // single_chan_pkt_fwd uses 00 00001000
+ // why here we have 11 11111111
+ // change RegSymbTimeoutLsb
+ //writeRegister(REG_SYMB_TIMEOUT_LSB, 0xFF);
+
+ // modified by C. Pham
+ if (_spreadingFactor == SF_10 || _spreadingFactor == SF_11 || _spreadingFactor == SF_12) {
+ writeRegister(REG_SYMB_TIMEOUT_LSB,0x05);
+ } else {
+ writeRegister(REG_SYMB_TIMEOUT_LSB,0x08);
+ }
+ //end
+
+ writeRegister(REG_FIFO_RX_BYTE_ADDR, 0x00); // Setting current value of reception buffer pointer
+ //clearFlags(); // Initializing flags
+ //state = 1;
+ if( _modem == LORA )
+ { // LoRa mode
+ state = setPacketLength(MAX_LENGTH); // With MAX_LENGTH gets all packets with length < MAX_LENGTH
+ writeRegister(REG_OP_MODE, LORA_RX_MODE); // LORA mode - Rx
+#if (SX1272_debug_mode > 1)
+ printf("## Receiving LoRa mode activated with success ##");
+ printf("\n");
+#endif
+ }
+ else
+ { // FSK mode
+ state = setPacketLength();
+ writeRegister(REG_OP_MODE, FSK_RX_MODE); // FSK mode - Rx
+#if (SX1272_debug_mode > 1)
+ printf("## Receiving FSK mode activated with success ##");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Configures the module to receive information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receivePacketMAXTimeout()
+{
+ return receivePacketTimeout(MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to receive information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receivePacketTimeout()
+{
+ setTimeout();
+ return receivePacketTimeout(_sendTime);
+}
+
+/*
+ Function: Configures the module to receive information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+#ifdef W_REQUESTED_ACK
+
+// added by C. Pham
+// receiver always use receivePacketTimeout()
+// sender should either use sendPacketTimeout() or sendPacketTimeoutACK()
+
+uint8_t SX1272::receivePacketTimeout(uint16_t wait)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'receivePacketTimeout'\n");
+#endif
+
+ state = receive();
+ if( state == 0 )
+ {
+ if( availableData(wait) )
+ {
+ state = getPacket();
+ }
+ else
+ {
+ state = 1;
+ state_f = 3; // There is no packet received
+ }
+ }
+ else
+ {
+ state = 1;
+ state_f = 1; // There has been an error with the 'receive' function
+ }
+
+ if( (state == 0) || (state == 3) || (state == 5) )
+ {
+ if( _reception == INCORRECT_PACKET )
+ {
+ state_f = 4; // The packet has been incorrectly received
+ }
+ else
+ {
+ state_f = 0; // The packet has been correctly received
+ // added by C. Pham
+ // we get the SNR and RSSI of the received packet for future usage
+ getSNR();
+ getRSSIpacket();
+ }
+
+ // need to send an ACK
+ if ( state == 5 && state_f == 0) {
+
+ state = setACK();
+
+ if( state == 0 )
+ {
+ state = sendWithTimeout();
+ if( state == 0 )
+ {
+ state_f = 0;
+#if (SX1272_debug_mode > 1)
+ printf("This last packet was an ACK, so ...");
+ printf("ACK successfully sent");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state_f = 1; // There has been an error with the 'sendWithTimeout' function
+ }
+ }
+ else
+ {
+ state_f = 1; // There has been an error with the 'setACK' function
+ }
+ }
+ }
+ else
+ {
+ // we need to conserve state_f=3 to indicate that no packet has been received after timeout
+ //state_f = 1;
+ }
+ return state_f;
+}
+#else
+
+uint8_t SX1272::receivePacketTimeout(uint16_t wait)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'receivePacketTimeout'\n");
+#endif
+
+ state = receive();
+ if( state == 0 )
+ {
+ if( availableData(wait) )
+ {
+ // If packet received, getPacket
+ state_f = getPacket();
+ }
+ else
+ {
+ state_f = 1;
+ }
+ }
+ else
+ {
+ state_f = state;
+ }
+ return state_f;
+}
+#endif
+
+/*
+ Function: Configures the module to receive information and send an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receivePacketMAXTimeoutACK()
+{
+ return receivePacketTimeoutACK(MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to receive information and send an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receivePacketTimeoutACK()
+{
+ setTimeout();
+ return receivePacketTimeoutACK(_sendTime);
+}
+
+/*
+ Function: Configures the module to receive information and send an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 4 --> The command has been executed but the packet received is incorrect
+ state = 3 --> The command has been executed but there is no packet received
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receivePacketTimeoutACK(uint16_t wait)
+{
+ // commented by C. Pham because not used
+ /*
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'receivePacketTimeoutACK'");
+#endif
+
+ state = receive();
+ if( state == 0 )
+ {
+ if( availableData(wait) )
+ {
+ state = getPacket();
+ }
+ else
+ {
+ state = 1;
+ state_f = 3; // There is no packet received
+ }
+ }
+ else
+ {
+ state = 1;
+ state_f = 1; // There has been an error with the 'receive' function
+ }
+ if( (state == 0) || (state == 3) )
+ {
+ if( _reception == INCORRECT_PACKET )
+ {
+ state_f = 4; // The packet has been incorrectly received
+ }
+ else
+ {
+ state_f = 1; // The packet has been correctly received
+ }
+ state = setACK();
+ if( state == 0 )
+ {
+ state = sendWithTimeout();
+ if( state == 0 )
+ {
+ state_f = 0;
+#if (SX1272_debug_mode > 1)
+ printf("This last packet was an ACK, so ...");
+ printf("ACK successfully sent");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state_f = 1; // There has been an error with the 'sendWithTimeout' function
+ }
+ }
+ else
+ {
+ state_f = 1; // There has been an error with the 'setACK' function
+ }
+ }
+ else
+ {
+ state_f = 1;
+ }
+ return state_f;
+ */
+ // ajoute par C.Dupaty
+ return 0;
+}
+
+/*
+ Function: Configures the module to receive all the information on air, before MAX_TIMEOUT expires.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receiveAll()
+{
+ return receiveAll(MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to receive all the information on air.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::receiveAll(uint16_t wait)
+{
+ uint8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'receiveAll'\n");
+#endif
+
+ if( _modem == FSK )
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Setting standby FSK mode
+ config1 = readRegister(REG_PACKET_CONFIG1);
+ config1 = config1 & 0B11111001; // clears bits 2-1 from REG_PACKET_CONFIG1
+ writeRegister(REG_PACKET_CONFIG1, config1); // AddressFiltering = None
+ }
+#if (SX1272_debug_mode > 1)
+ printf("## Address filtering desactivated ##");
+ printf("\n");
+#endif
+ state = receive(); // Setting Rx mode
+ if( state == 0 )
+ {
+ state = getPacket(wait); // Getting all packets received in wait
+ }
+ return state;
+}
+
+/*
+ Function: If a packet is received, checks its destination.
+ Returns: Boolean that's 'true' if the packet is for the module and
+ it's 'false' if the packet is not for the module.
+*/
+boolean SX1272::availableData()
+{
+ return availableData(MAX_TIMEOUT);
+}
+
+/*
+ Function: If a packet is received, checks its destination.
+ Returns: Boolean that's 'true' if the packet is for the module and
+ it's 'false' if the packet is not for the module.
+ Parameters:
+ wait: time to wait while there is no a valid header received.
+*/
+boolean SX1272::availableData(uint16_t wait)
+{
+ byte value;
+ byte header = 0;
+ boolean forme = false;
+ boolean _hreceived = false;
+ //unsigned long previous;
+ unsigned long exitTime;
+
+
+#if (SX1272_debug_mode > 0)
+ printf("\n");
+ printf("Starting 'availableData'\n");
+#endif
+
+ exitTime=millis()+(unsigned long)wait;
+
+ //previous = millis();
+ if( _modem == LORA )
+ { // LoRa mode
+ value = readRegister(REG_IRQ_FLAGS);
+ // Wait to ValidHeader interrupt
+ //while( (bitRead(value, 4) == 0) && (millis() - previous < (unsigned long)wait) )
+ while( (bitRead(value, 4) == 0) && (millis() < exitTime) )
+ {
+ value = readRegister(REG_IRQ_FLAGS);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ } // end while (millis)
+
+ if( bitRead(value, 4) == 1 )
+ { // header received
+#if (SX1272_debug_mode > 0)
+ printf("## Valid Header received in LoRa mode ##");
+#endif
+ _hreceived = true;
+
+#ifdef W_NET_KEY
+ // actually, need to wait until 3 bytes have been received
+ //while( (header < 3) && (millis() - previous < (unsigned long)wait) )
+ while( (header < 3) && (millis() < exitTime) )
+#else
+ //while( (header == 0) && (millis() - previous < (unsigned long)wait) )
+ while( (header == 0) && (millis() < exitTime) )
+#endif
+ { // Waiting to read first payload bytes from packet
+ header = readRegister(REG_FIFO_RX_BYTE_ADDR);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }
+
+ if( header != 0 )
+ { // Reading first byte of the received packet
+#ifdef W_NET_KEY
+ // added by C. Pham
+ // if we actually wait for an ACK, there is no net key before ACK data
+ if (_requestACK==0) {
+ _the_net_key_0 = readRegister(REG_FIFO);
+ _the_net_key_1 = readRegister(REG_FIFO);
+ }
+#endif
+ _destination = readRegister(REG_FIFO);
+ }
+ }
+ else
+ {
+ forme = false;
+ _hreceived = false;
+#if (SX1272_debug_mode > 0)
+ printf("** The timeout has expired **");
+ printf("\n");
+#endif
+ }
+ }
+ else
+ { // FSK mode
+ value = readRegister(REG_IRQ_FLAGS2);
+ // Wait to Payload Ready interrupt
+ //while( (bitRead(value, 2) == 0) && (millis() - previous < wait) )
+ while( (bitRead(value, 2) == 0) && (millis() < exitTime) )
+ {
+ value = readRegister(REG_IRQ_FLAGS2);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }// end while (millis)
+
+ if( bitRead(value, 2) == 1 ) // something received
+ {
+ _hreceived = true;
+#if (SX1272_debug_mode > 0)
+ printf("## Valid Preamble detected in FSK mode ##");
+#endif
+ // Reading first byte of the received packet
+ _destination = readRegister(REG_FIFO);
+ }
+ else
+ {
+ forme = false;
+ _hreceived = false;
+#if (SX1272_debug_mode > 0)
+ printf("** The timeout has expired **");
+ printf("\n");
+#endif
+ }
+ }
+ // We use _hreceived because we need to ensure that _destination value is correctly
+ // updated and is not the _destination value from the previously packet
+ if( _hreceived == true )
+ { // Checking destination
+#if (SX1272_debug_mode > 0)
+ printf("## Checking destination ##");
+#endif
+
+ // added by C. Pham
+#ifdef W_NET_KEY
+ forme=true;
+
+ // if we wait for an ACK, then we do not check for net key
+ if (_requestACK==0)
+ if (_the_net_key_0!=_my_netkey[0] || _the_net_key_1!=_my_netkey[1]) {
+ //#if (SX1272_debug_mode > 0)
+ printf("## Wrong net key ##");
+ //#endif
+ forme=false;
+ }
+ else
+ {
+ //#if (SX1272_debug_mode > 0)
+ printf("## Good net key ##");
+ //#endif
+ }
+
+
+ if( forme && ((_destination == _nodeAddress) || (_destination == BROADCAST_0)) )
+#else
+ // modified by C. Pham
+ // if _rawFormat, accept all
+ if( (_destination == _nodeAddress) || (_destination == BROADCAST_0) || _rawFormat)
+#endif
+ { // LoRa or FSK mode
+ forme = true;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet received is for me ##");
+#endif
+ }
+ else
+ {
+ forme = false;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet received is not for me ##");
+ printf("\n");
+#endif
+ if( _modem == LORA ) // STANDBY PARA MINIMIZAR EL CONSUMO
+ { // LoRa mode
+ //writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Setting standby LoRa mode
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Setting standby FSK mode
+ }
+ }
+ }
+ //----else
+ // {
+ // }
+ return forme;
+}
+
+/*
+ Function: It gets and stores a packet if it is received before MAX_TIMEOUT expires.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getPacketMAXTimeout()
+{
+ return getPacket(MAX_TIMEOUT);
+}
+
+/*
+ Function: It gets and stores a packet if it is received.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+int8_t SX1272::getPacket()
+{
+ return getPacket(MAX_TIMEOUT);
+}
+
+/*
+ Function: It gets and stores a packet if it is received before ending 'wait' time.
+ Returns: Integer that determines if there has been any error
+ // added by C. Pham
+ state = 5 --> The command has been executed with no errors and an ACK is requested
+ state = 3 --> The command has been executed but packet has been incorrectly received
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden parameter value for this function
+ Parameters:
+ wait: time to wait while there is no a valid header received.
+*/
+int8_t SX1272::getPacket(uint16_t wait)
+{
+ int8_t state = 2; // uint8_t a l origine
+ byte value = 0x00;
+ //unsigned long previous;
+ unsigned long exitTime;
+ boolean p_received = false;
+
+#if (SX1272_debug_mode > 0)
+ printf("\n");
+ printf("Starting 'getPacket'\n");
+#endif
+
+ //previous = millis();
+ exitTime = millis() + (unsigned long)wait;
+ if( _modem == LORA )
+ { // LoRa mode
+ value = readRegister(REG_IRQ_FLAGS);
+ // Wait until the packet is received (RxDone flag) or the timeout expires
+ //while( (bitRead(value, 6) == 0) && (millis() - previous < (unsigned long)wait) )
+ while( (bitRead(value, 6) == 0) && (millis() < exitTime) )
+ {
+ value = readRegister(REG_IRQ_FLAGS);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ } // end while (millis)
+
+ if( (bitRead(value, 6) == 1) && (bitRead(value, 5) == 0) )
+ { // packet received & CRC correct
+ p_received = true; // packet correctly received
+ _reception = CORRECT_PACKET;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet correctly received in LoRa mode ##");
+#endif
+ }
+ else
+ {
+ if( bitRead(value, 5) != 0 )
+ { // CRC incorrect
+ _reception = INCORRECT_PACKET;
+ state = 3;
+#if (SX1272_debug_mode > 0)
+ printf("** The CRC is incorrect **");
+ printf("\n");
+#endif
+ }
+ }
+ //writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Setting standby LoRa mode
+ }
+ else
+ { // FSK mode
+ value = readRegister(REG_IRQ_FLAGS2);
+ //while( (bitRead(value, 2) == 0) && (millis() - previous < wait) )
+ while( (bitRead(value, 2) == 0) && (millis() < exitTime) )
+ {
+ value = readRegister(REG_IRQ_FLAGS2);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ } // end while (millis)
+
+ if( bitRead(value, 2) == 1 )
+ { // packet received
+ if( bitRead(value, 1) == 1 )
+ { // CRC correct
+ _reception = CORRECT_PACKET;
+ p_received = true;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet correctly received in FSK mode ##");
+#endif
+ }
+ else
+ { // CRC incorrect
+ _reception = INCORRECT_PACKET;
+ state = 3;
+ p_received = false;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet incorrectly received in FSK mode ##");
+#endif
+ }
+ }
+ else
+ {
+#if (SX1272_debug_mode > 0)
+ printf("** The timeout has expired **");
+ printf("\n");
+#endif
+ }
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Setting standby FSK mode
+ }
+ if( p_received == true )
+ {
+ // Store the packet
+ if( _modem == LORA )
+ {
+ // comment by C. Pham
+ // set the FIFO addr to 0 to read again all the bytes
+ writeRegister(REG_FIFO_ADDR_PTR, 0x00); // Setting address pointer in FIFO data buffer
+
+#ifdef W_NET_KEY
+ // added by C. Pham
+ packet_received.netkey[0]=readRegister(REG_FIFO);
+ packet_received.netkey[1]=readRegister(REG_FIFO);
+#endif
+ //modified by C. Pham
+ if (!_rawFormat)
+ packet_received.dst = readRegister(REG_FIFO); // Storing first byte of the received packet
+ else
+ packet_received.dst = 0;
+ }
+ else
+ {
+ value = readRegister(REG_PACKET_CONFIG1);
+ if( (bitRead(value, 2) == 0) && (bitRead(value, 1) == 0) )
+ {
+ packet_received.dst = readRegister(REG_FIFO); // Storing first byte of the received packet
+ }
+ else
+ {
+ packet_received.dst = _destination; // Storing first byte of the received packet
+ }
+ }
+
+ // modified by C. Pham
+ if (!_rawFormat) {
+ packet_received.type = readRegister(REG_FIFO); // Reading second byte of the received packet
+ packet_received.src = readRegister(REG_FIFO); // Reading second byte of the received packet
+ packet_received.packnum = readRegister(REG_FIFO); // Reading third byte of the received packet
+ //packet_received.length = readRegister(REG_FIFO); // Reading fourth byte of the received packet
+ }
+ else {
+ packet_received.type = 0;
+ packet_received.src = 0;
+ packet_received.packnum = 0;
+ }
+
+ packet_received.length = readRegister(REG_RX_NB_BYTES);
+
+ if( _modem == LORA )
+ {
+ if (_rawFormat) {
+ _payloadlength=packet_received.length;
+ }
+ else
+ _payloadlength = packet_received.length - OFFSET_PAYLOADLENGTH;
+ }
+ if( packet_received.length > (MAX_LENGTH + 1) )
+ {
+#if (SX1272_debug_mode > 0)
+ printf("Corrupted packet, length must be less than 256");
+#endif
+ }
+ else
+ {
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ packet_received.data[i] = readRegister(REG_FIFO); // Storing payload
+ }
+
+ // commented by C. Pham
+ //packet_received.retry = readRegister(REG_FIFO);
+
+ // Print the packet if debug_mode
+#if (SX1272_debug_mode > 0)
+ printf("## Packet received:\n");
+ printf("Destination: %d\n",packet_received.dst);
+ // Serial.println(packet_received.dst); // Printing destination
+ printf("Type: %d\n",packet_received.type);
+ // Serial.println(packet_received.type); // Printing source
+ printf("Source: %d\n",packet_received.src);
+ // Serial.println(packet_received.src); // Printing source
+ printf("Packet number: %d\n",packet_received.packnum);
+ // Serial.println(packet_received.packnum); // Printing packet number
+ //printf("Packet length: ");
+ //Serial.println(packet_received.length); // Printing packet length
+ printf("Data: ");
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ //Serial.print((char)packet_received.data[i]); // Printing payload
+ printf("%c",packet_received.data[i]);
+ }
+ printf("\n");
+ //printf("Retry number: ");
+ //Serial.println(packet_received.retry); // Printing number retry
+ printf("##");
+ printf("\n");
+#endif
+ state = 0;
+
+#ifdef W_REQUESTED_ACK
+ // added by C. Pham
+ // need to send an ACK
+ if (packet_received.type & PKT_FLAG_ACK_REQ) {
+ state = 5;
+ _requestACK_indicator=1;
+ }
+ else
+ _requestACK_indicator=0;
+#endif
+ }
+ }
+ else
+ {
+ state = 1;
+ if( (_reception == INCORRECT_PACKET) && (_retries < _maxRetries) )
+ {
+ // comment by C. Pham
+ // what is the purpose of incrementing retries here?
+ // bug? not needed?
+ _retries++;
+#if (SX1272_debug_mode > 0)
+ printf("## Retrying to send the last packet ##");
+ printf("\n");
+#endif
+ }
+ }
+ if( _modem == LORA )
+ {
+ writeRegister(REG_FIFO_ADDR_PTR, 0x00); // Setting address pointer in FIFO data buffer
+ }
+ clearFlags(); // Initializing flags
+ if( wait > MAX_WAIT )
+ {
+ state = -1;
+#if (SX1272_debug_mode > 0)
+ printf("** The timeout must be smaller than 12.5 seconds **");
+ printf("\n");
+#endif
+ }
+
+ return state;
+}
+
+/*
+ Function: It sets the packet destination.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ Parameters:
+ dest: destination value of the packet sent.
+*/
+int8_t SX1272::setDestination(uint8_t dest)
+{
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setDestination'\n");
+#endif
+
+ state = 1;
+ _destination = dest; // Storing destination in a global variable
+ packet_sent.dst = dest; // Setting destination in packet structure
+ packet_sent.src = _nodeAddress; // Setting source in packet structure
+ packet_sent.packnum = _packetNumber; // Setting packet number in packet structure
+ _packetNumber++;
+ state = 0;
+
+#if (SX1272_debug_mode > 1)
+ printf("## Destination %X\n",_destination);
+// Serial.print(_destination, HEX);
+ printf(" successfully set ##");
+ printf("## Source %d\n",packet_sent.src);
+// Serial.print(packet_sent.src, DEC);
+ printf(" successfully set ##");
+ printf("## Packet number %d\n",packet_sent.packnum);
+ // Serial.print(packet_sent.packnum, DEC);
+ printf(" successfully set ##");
+ printf("\n");
+#endif
+ return state;
+}
+
+/*
+ Function: It sets the timeout according to the configured mode.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setTimeout()
+{
+ uint8_t state = 2;
+// retire par C.Dupaty
+ // uint16_t delay;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setTimeout'\n");
+#endif
+
+ state = 1;
+
+ // changed by C. Pham
+ // we always use MAX_TIMEOUT
+ _sendTime = MAX_TIMEOUT;
+
+ /*
+ if( _modem == LORA )
+ {
+ switch(_spreadingFactor)
+ { // Choosing Spreading Factor
+ case SF_6: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 335;
+ break;
+ case CR_6: _sendTime = 352;
+ break;
+ case CR_7: _sendTime = 368;
+ break;
+ case CR_8: _sendTime = 386;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 287;
+ break;
+ case CR_6: _sendTime = 296;
+ break;
+ case CR_7: _sendTime = 305;
+ break;
+ case CR_8: _sendTime = 312;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 242;
+ break;
+ case CR_6: _sendTime = 267;
+ break;
+ case CR_7: _sendTime = 272;
+ break;
+ case CR_8: _sendTime = 276;
+ break;
+ }
+ break;
+ }
+ break;
+
+ case SF_7: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 408;
+ break;
+ case CR_6: _sendTime = 438;
+ break;
+ case CR_7: _sendTime = 468;
+ break;
+ case CR_8: _sendTime = 497;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 325;
+ break;
+ case CR_6: _sendTime = 339;
+ break;
+ case CR_7: _sendTime = 355;
+ break;
+ case CR_8: _sendTime = 368;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 282;
+ break;
+ case CR_6: _sendTime = 290;
+ break;
+ case CR_7: _sendTime = 296;
+ break;
+ case CR_8: _sendTime = 305;
+ break;
+ }
+ break;
+ }
+ break;
+
+ case SF_8: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 537;
+ break;
+ case CR_6: _sendTime = 588;
+ break;
+ case CR_7: _sendTime = 640;
+ break;
+ case CR_8: _sendTime = 691;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 388;
+ break;
+ case CR_6: _sendTime = 415;
+ break;
+ case CR_7: _sendTime = 440;
+ break;
+ case CR_8: _sendTime = 466;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 315;
+ break;
+ case CR_6: _sendTime = 326;
+ break;
+ case CR_7: _sendTime = 340;
+ break;
+ case CR_8: _sendTime = 352;
+ break;
+ }
+ break;
+ }
+ break;
+
+ case SF_9: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 774;
+ break;
+ case CR_6: _sendTime = 864;
+ break;
+ case CR_7: _sendTime = 954;
+ break;
+ case CR_8: _sendTime = 1044;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 506;
+ break;
+ case CR_6: _sendTime = 552;
+ break;
+ case CR_7: _sendTime = 596;
+ break;
+ case CR_8: _sendTime = 642;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 374;
+ break;
+ case CR_6: _sendTime = 396;
+ break;
+ case CR_7: _sendTime = 418;
+ break;
+ case CR_8: _sendTime = 441;
+ break;
+ }
+ break;
+ }
+ break;
+
+ case SF_10: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 1226;
+ break;
+ case CR_6: _sendTime = 1388;
+ break;
+ case CR_7: _sendTime = 1552;
+ break;
+ case CR_8: _sendTime = 1716;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 732;
+ break;
+ case CR_6: _sendTime = 815;
+ break;
+ case CR_7: _sendTime = 896;
+ break;
+ case CR_8: _sendTime = 977;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 486;
+ break;
+ case CR_6: _sendTime = 527;
+ break;
+ case CR_7: _sendTime = 567;
+ break;
+ case CR_8: _sendTime = 608;
+ break;
+ }
+ break;
+ }
+ break;
+
+ case SF_11: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 2375;
+ break;
+ case CR_6: _sendTime = 2735;
+ break;
+ case CR_7: _sendTime = 3095;
+ break;
+ case CR_8: _sendTime = 3456;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 1144;
+ break;
+ case CR_6: _sendTime = 1291;
+ break;
+ case CR_7: _sendTime = 1437;
+ break;
+ case CR_8: _sendTime = 1586;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 691;
+ break;
+ case CR_6: _sendTime = 766;
+ break;
+ case CR_7: _sendTime = 838;
+ break;
+ case CR_8: _sendTime = 912;
+ break;
+ }
+ break;
+ }
+ break;
+
+ case SF_12: switch(_bandwidth)
+ { // Choosing bandwidth
+ case BW_125:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 4180;
+ break;
+ case CR_6: _sendTime = 4836;
+ break;
+ case CR_7: _sendTime = 5491;
+ break;
+ case CR_8: _sendTime = 6146;
+ break;
+ }
+ break;
+ case BW_250:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 1965;
+ break;
+ case CR_6: _sendTime = 2244;
+ break;
+ case CR_7: _sendTime = 2521;
+ break;
+ case CR_8: _sendTime = 2800;
+ break;
+ }
+ break;
+ case BW_500:
+ switch(_codingRate)
+ { // Choosing coding rate
+ case CR_5: _sendTime = 1102;
+ break;
+ case CR_6: _sendTime = 1241;
+ break;
+ case CR_7: _sendTime = 1381;
+ break;
+ case CR_8: _sendTime = 1520;
+ break;
+ }
+ break;
+ }
+ break;
+ default: _sendTime = MAX_TIMEOUT;
+ }
+ }
+ else
+ {
+ _sendTime = MAX_TIMEOUT;
+ }
+ delay = ((0.1*_sendTime) + 1);
+ _sendTime = (uint16_t) ((_sendTime * 1.2) + (rand()%delay));
+
+ */
+#if (SX1272_debug_mode > 1)
+ printf("Timeout to send/receive is: %d\n",_sendTime);
+ // Serial.println(_sendTime, DEC);
+#endif
+ state = 0;
+ return state;
+}
+
+/*
+ Function: It sets a char array payload packet in a packet struct.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setPayload(char *payload)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+ uint16_t length16;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPayload'\n");
+#endif
+
+ state = 1;
+ length16 = (uint16_t)strlen(payload);
+ state = truncPayload(length16);
+ if( state == 0 )
+ {
+ // fill data field until the end of the string
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ packet_sent.data[i] = payload[i];
+ }
+ }
+ else
+ {
+ state_f = state;
+ }
+ if( ( _modem == FSK ) && ( _payloadlength > MAX_PAYLOAD_FSK ) )
+ {
+ _payloadlength = MAX_PAYLOAD_FSK;
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("In FSK, payload length must be less than 60 bytes.");
+ printf("\n");
+#endif
+ }
+ // set length with the actual counter value
+ state_f = setPacketLength(); // Setting packet length in packet structure
+ return state_f;
+}
+
+/*
+ Function: It sets an uint8_t array payload packet in a packet struct.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setPayload(uint8_t *payload)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPayload'\n");
+#endif
+
+ state = 1;
+ if( ( _modem == FSK ) && ( _payloadlength > MAX_PAYLOAD_FSK ) )
+ {
+ _payloadlength = MAX_PAYLOAD_FSK;
+ state = 1;
+#if (SX1272_debug_mode > 1)
+ printf("In FSK, payload length must be less than 60 bytes.");
+ printf("\n");
+#endif
+ }
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ packet_sent.data[i] = payload[i]; // Storing payload in packet structure
+ }
+ // set length with the actual counter value
+ state = setPacketLength(); // Setting packet length in packet structure
+ return state;
+}
+
+/*
+ Function: It sets a packet struct in FIFO in order to send it.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setPacket(uint8_t dest, char *payload)
+{
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPacket'\n");
+#endif
+
+ // added by C. Pham
+ // check for enough remaining ToA
+ // when operating under duty-cycle mode
+ if (_limitToA) {
+ uint16_t length16 = (uint16_t)strlen(payload);
+
+ if (!_rawFormat)
+ length16 = length16 + OFFSET_PAYLOADLENGTH;
+
+ if (getRemainingToA() - getToA(length16) < 0) {
+ printf("## not enough ToA at %d\n",millis());
+ // Serial.println(millis());
+ return SX1272_ERROR_TOA;
+ }
+ }
+
+ clearFlags(); // Initializing flags
+
+ if( _modem == LORA )
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Stdby LoRa mode to write in FIFO
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Stdby FSK mode to write in FIFO
+ }
+
+ _reception = CORRECT_PACKET; // Updating incorrect value
+ if( _retries == 0 )
+ { // Updating this values only if is not going to re-send the last packet
+ state = setDestination(dest); // Setting destination in packet structure
+ packet_sent.retry = _retries;
+ if( state == 0 )
+ {
+ state = setPayload(payload);
+ }
+ }
+ else
+ {
+ // comment by C. Pham
+ // why to increase the length here?
+ // bug?
+ if( _retries == 1 )
+ {
+ packet_sent.length++;
+ }
+ state = setPacketLength();
+ packet_sent.retry = _retries;
+#if (SX1272_debug_mode > 0)
+ printf("** Retrying to send last packet %d\n",_retries);
+ // Serial.print(_retries, DEC);
+ printf(" time **");
+#endif
+ }
+
+ // added by C. Pham
+ // set the type to be a data packet
+ packet_sent.type |= PKT_TYPE_DATA;
+
+#ifdef W_REQUESTED_ACK
+ // added by C. Pham
+ // indicate that an ACK should be sent by the receiver
+ if (_requestACK)
+ packet_sent.type |= PKT_FLAG_ACK_REQ;
+#endif
+
+ writeRegister(REG_FIFO_ADDR_PTR, 0x80); // Setting address pointer in FIFO data buffer
+ if( state == 0 )
+ {
+ state = 1;
+ // Writing packet to send in FIFO
+#ifdef W_NET_KEY
+ // added by C. Pham
+ packet_sent.netkey[0]=_my_netkey[0];
+ packet_sent.netkey[1]=_my_netkey[1];
+ //#if (SX1272_debug_mode > 0)
+ printf("## Setting net key ##");
+ //#endif
+ writeRegister(REG_FIFO, packet_sent.netkey[0]);
+ writeRegister(REG_FIFO, packet_sent.netkey[1]);
+#endif
+ // added by C. Pham
+ // we can skip the header for instance when we want to generate
+ // at a higher layer a LoRaWAN packet
+ if (!_rawFormat) {
+ writeRegister(REG_FIFO, packet_sent.dst); // Writing the destination in FIFO
+ // added by C. Pham
+ writeRegister(REG_FIFO, packet_sent.type); // Writing the packet type in FIFO
+ writeRegister(REG_FIFO, packet_sent.src); // Writing the source in FIFO
+ writeRegister(REG_FIFO, packet_sent.packnum); // Writing the packet number in FIFO
+ }
+ // commented by C. Pham
+ //writeRegister(REG_FIFO, packet_sent.length); // Writing the packet length in FIFO
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ writeRegister(REG_FIFO, packet_sent.data[i]); // Writing the payload in FIFO
+ }
+ // commented by C. Pham
+ //writeRegister(REG_FIFO, packet_sent.retry); // Writing the number retry in FIFO
+ state = 0;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet set and written in FIFO ##");
+ // Print the complete packet if debug_mode
+ printf("## Packet to send: \n");
+ printf("Destination: %d\n",packet_sent.dst);
+ // Serial.println(packet_sent.dst); // Printing destination
+ printf("Packet type: %d\n",packet_sent.type);
+ // Serial.println(packet_sent.type); // Printing packet type
+ printf("Source: %d\n",packet_sent.src);
+ // Serial.println(packet_sent.src); // Printing source
+ printf("Packet number: %d\n",packet_sent.packnum);
+ // Serial.println(packet_sent.packnum); // Printing packet number
+ printf("Packet length: %d\n",packet_sent.length);
+ // Serial.println(packet_sent.length); // Printing packet length
+ printf("Data: ");
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ // Serial.print((char)packet_sent.data[i]); // Printing payload
+ printf("%c",packet_sent.data[i]);
+ }
+ printf("\n");
+ //printf("Retry number: ");
+ //Serial.println(packet_sent.retry); // Printing retry number
+ printf("##");
+#endif
+ }
+
+ return state;
+}
+
+/*
+ Function: It sets a packet struct in FIFO in order to sent it.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::setPacket(uint8_t dest, uint8_t *payload)
+{
+ int8_t state = 2;
+ byte st0;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPacket'\n");
+#endif
+
+ // added by C. Pham
+ // check for enough remaining ToA
+ // when operating under duty-cycle mode
+ if (_limitToA) {
+ // here truncPayload() should have been called before in
+ // sendPacketTimeout(uint8_t dest, uint8_t *payload, uint16_t length16)
+ uint16_t length16 = _payloadlength;
+
+ if (!_rawFormat)
+ length16 = length16 + OFFSET_PAYLOADLENGTH;
+
+ if (getRemainingToA() - getToA(length16) < 0) {
+ printf("## not enough ToA at %d\n",millis());
+ // Serial.println(millis());
+ return SX1272_ERROR_TOA;
+ }
+ }
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ clearFlags(); // Initializing flags
+
+ if( _modem == LORA )
+ { // LoRa mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Stdby LoRa mode to write in FIFO
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Stdby FSK mode to write in FIFO
+ }
+
+ _reception = CORRECT_PACKET; // Updating incorrect value to send a packet (old or new)
+ if( _retries == 0 )
+ { // Sending new packet
+ state = setDestination(dest); // Setting destination in packet structure
+ packet_sent.retry = _retries;
+ if( state == 0 )
+ {
+ state = setPayload(payload);
+ }
+ }
+ else
+ {
+ // comment by C. Pham
+ // why to increase the length here?
+ // bug?
+ if( _retries == 1 )
+ {
+ packet_sent.length++;
+ }
+ state = setPacketLength();
+ packet_sent.retry = _retries;
+#if (SX1272_debug_mode > 0)
+ printf("** Retrying to send last packet %d\n",_retries);
+ // Serial.print(_retries, DEC);
+ printf(" time **");
+#endif
+ }
+
+ // added by C. Pham
+ // set the type to be a data packet
+ packet_sent.type |= PKT_TYPE_DATA;
+
+#ifdef W_REQUESTED_ACK
+ // added by C. Pham
+ // indicate that an ACK should be sent by the receiver
+ if (_requestACK)
+ packet_sent.type |= PKT_FLAG_ACK_REQ;
+#endif
+
+ writeRegister(REG_FIFO_ADDR_PTR, 0x80); // Setting address pointer in FIFO data buffer
+ if( state == 0 )
+ {
+ state = 1;
+ // Writing packet to send in FIFO
+#ifdef W_NET_KEY
+ // added by C. Pham
+ packet_sent.netkey[0]=_my_netkey[0];
+ packet_sent.netkey[1]=_my_netkey[1];
+ //#if (SX1272_debug_mode > 0)
+ printf("## Setting net key ##");
+ //#endif
+ writeRegister(REG_FIFO, packet_sent.netkey[0]);
+ writeRegister(REG_FIFO, packet_sent.netkey[1]);
+#endif
+ // added by C. Pham
+ // we can skip the header for instance when we want to generate
+ // at a higher layer a LoRaWAN packet
+ if (!_rawFormat) {
+ writeRegister(REG_FIFO, packet_sent.dst); // Writing the destination in FIFO
+ // added by C. Pham
+ writeRegister(REG_FIFO, packet_sent.type); // Writing the packet type in FIFO
+ writeRegister(REG_FIFO, packet_sent.src); // Writing the source in FIFO
+ writeRegister(REG_FIFO, packet_sent.packnum); // Writing the packet number in FIFO
+ }
+ // commented by C. Pham
+ //writeRegister(REG_FIFO, packet_sent.length); // Writing the packet length in FIFO
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ writeRegister(REG_FIFO, packet_sent.data[i]); // Writing the payload in FIFO
+ }
+ // commented by C. Pham
+ //writeRegister(REG_FIFO, packet_sent.retry); // Writing the number retry in FIFO
+ state = 0;
+#if (SX1272_debug_mode > 0)
+ printf("## Packet set and written in FIFO ##");
+ // Print the complete packet if debug_mode
+ printf("## Packet to send: ");
+ printf("Destination: %d\n",packet_sent.dst);
+ // Serial.println(packet_sent.dst); // Printing destination
+ printf("Packet type: %d\n",packet_sent.type);
+ // Serial.println(packet_sent.type); // Printing packet type
+ printf("Source: %d\n",packet_sent.src);
+ // Serial.println(packet_sent.src); // Printing source
+ printf("Packet number: %d\n",packet_sent.packnum);
+ // Serial.println(packet_sent.packnum); // Printing packet number
+ printf("Packet length: %d\n",packet_sent.length);
+ // Serial.println(packet_sent.length); // Printing packet length
+ printf("Data: ");
+ for(unsigned int i = 0; i < _payloadlength; i++)
+ {
+ //Serial.print((char)packet_sent.data[i]); // Printing payload
+ printf("%c",packet_sent.data[i]);
+ }
+ printf("\n");
+ //printf("Retry number: ");
+ //Serial.println(packet_sent.retry); // Printing retry number
+ printf("##");
+#endif
+ }
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendWithMAXTimeout()
+{
+ return sendWithTimeout(MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendWithTimeout()
+{
+ setTimeout();
+ return sendWithTimeout(_sendTime);
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendWithTimeout(uint16_t wait)
+{
+ uint8_t state = 2;
+ byte value = 0x00;
+ //unsigned long previous;
+ unsigned long exitTime;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendWithTimeout'\n");
+#endif
+
+ // clearFlags(); // Initializing flags
+
+ // wait to TxDone flag
+ //previous = millis();
+ exitTime = millis() + (unsigned long)wait;
+ if( _modem == LORA )
+ { // LoRa mode
+ clearFlags(); // Initializing flags
+
+ writeRegister(REG_OP_MODE, LORA_TX_MODE); // LORA mode - Tx
+
+#if (SX1272_debug_mode > 1)
+ value = readRegister(REG_OP_MODE);
+
+ if (value & LORA_TX_MODE == LORA_TX_MODE)
+ printf("OK");
+ else
+ printf("ERROR");
+#endif
+ value = readRegister(REG_IRQ_FLAGS);
+ // Wait until the packet is sent (TX Done flag) or the timeout expires
+ //while ((bitRead(value, 3) == 0) && (millis() - previous < wait))
+ while ((bitRead(value, 3) == 0) && (millis() < exitTime))
+ {
+ value = readRegister(REG_IRQ_FLAGS);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }
+ state = 1;
+ }
+ else
+ { // FSK mode
+ writeRegister(REG_OP_MODE, FSK_TX_MODE); // FSK mode - Tx
+
+ value = readRegister(REG_IRQ_FLAGS2);
+ // Wait until the packet is sent (Packet Sent flag) or the timeout expires
+ //while ((bitRead(value, 3) == 0) && (millis() - previous < wait))
+ while ((bitRead(value, 3) == 0) && (millis() < exitTime))
+ {
+ value = readRegister(REG_IRQ_FLAGS2);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }
+ state = 1;
+ }
+ if( bitRead(value, 3) == 1 )
+ {
+ state = 0; // Packet successfully sent
+#if (SX1272_debug_mode > 1)
+ printf("## Packet successfully sent ##");
+ printf("\n");
+#endif
+ // added by C. Pham
+ // normally there should be enough remaing ToA as the test has been done earlier
+ if (_limitToA)
+ removeToA(_currentToA);
+ }
+ else
+ {
+ if( state == 1 )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("** Timeout has expired **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error and packet has not been sent **");
+ printf("\n");
+#endif
+ }
+ }
+
+ clearFlags(); // Initializing flags
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketMAXTimeout(uint8_t dest, char *payload)
+{
+ return sendPacketTimeout(dest, payload, MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketMAXTimeout(uint8_t dest, uint8_t *payload, uint16_t length16)
+{
+ return sendPacketTimeout(dest, payload, length16, MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeout(uint8_t dest, char *payload)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeout'\n");
+#endif
+
+ state = setPacket(dest, payload); // Setting a packet with 'dest' destination
+ if (state == 0) // and writing it in FIFO.
+ {
+ state = sendWithTimeout(); // Sending the packet
+ }
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeout(uint8_t dest, uint8_t *payload, uint16_t length16)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeout'\n");
+#endif
+
+ state = truncPayload(length16);
+ if( state == 0 )
+ {
+ state_f = setPacket(dest, payload); // Setting a packet with 'dest' destination
+ } // and writing it in FIFO.
+ else
+ {
+ state_f = state;
+ }
+ if( state_f == 0 )
+ {
+ state_f = sendWithTimeout(); // Sending the packet
+ }
+ return state_f;
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeout(uint8_t dest, char *payload, uint16_t wait)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeout'\n");
+#endif
+
+ state = setPacket(dest, payload); // Setting a packet with 'dest' destination
+ if (state == 0) // and writing it in FIFO.
+ {
+ state = sendWithTimeout(wait); // Sending the packet
+ }
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeout(uint8_t dest, uint8_t *payload, uint16_t length16, uint16_t wait)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeout'\n");
+#endif
+
+ state = truncPayload(length16);
+ if( state == 0 )
+ {
+ state_f = setPacket(dest, payload); // Setting a packet with 'dest' destination
+ }
+ else
+ {
+ state_f = state;
+ }
+ if( state_f == 0 ) // and writing it in FIFO.
+ {
+ state_f = sendWithTimeout(wait); // Sending the packet
+ }
+ return state_f;
+}
+
+/*
+ Function: Configures the module to transmit information.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketMAXTimeoutACK(uint8_t dest, char *payload)
+{
+ return sendPacketTimeoutACK(dest, payload, MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information and receive an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketMAXTimeoutACK(uint8_t dest, uint8_t *payload, uint16_t length16)
+{
+ return sendPacketTimeoutACK(dest, payload, length16, MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information and receive an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 3 --> Packet has been sent but ACK has not been received
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACK(uint8_t dest, char *payload)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACK'\n");
+#endif
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 1;
+#endif
+ state = sendPacketTimeout(dest, payload); // Sending packet to 'dest' destination
+
+ if( state == 0 )
+ {
+ state = receive(); // Setting Rx mode to wait an ACK
+ }
+ else
+ {
+ state_f = state;
+ }
+ if( state == 0 )
+ {
+ // added by C. Pham
+ printf("wait for ACK");
+
+ if( availableData() )
+ {
+ state_f = getACK(); // Getting ACK
+ }
+ else
+ {
+ state_f = SX1272_ERROR_ACK;
+ // added by C. Pham
+ printf("no ACK");
+ }
+ }
+ else
+ {
+ state_f = state;
+ }
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 0;
+#endif
+ return state_f;
+}
+
+/*
+ Function: Configures the module to transmit information and receive an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 3 --> Packet has been sent but ACK has not been received
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACK(uint8_t dest, uint8_t *payload, uint16_t length16)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACK'\n");
+#endif
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 1;
+#endif
+ // Sending packet to 'dest' destination
+ state = sendPacketTimeout(dest, payload, length16);
+
+ // Trying to receive the ACK
+ if( state == 0 )
+ {
+ state = receive(); // Setting Rx mode to wait an ACK
+ }
+ else
+ {
+ state_f = state;
+ }
+ if( state == 0 )
+ {
+ // added by C. Pham
+ printf("wait for ACK");
+
+ if( availableData() )
+ {
+ state_f = getACK(); // Getting ACK
+ }
+ else
+ {
+ state_f = SX1272_ERROR_ACK;
+ // added by C. Pham
+ printf("no ACK");
+ }
+ }
+ else
+ {
+ state_f = state;
+ }
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 0;
+#endif
+ return state_f;
+}
+
+/*
+ Function: Configures the module to transmit information and receive an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 3 --> Packet has been sent but ACK has not been received
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACK(uint8_t dest, char *payload, uint16_t wait)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACK'\n");
+#endif
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 1;
+#endif
+ state = sendPacketTimeout(dest, payload, wait); // Sending packet to 'dest' destination
+
+ if( state == 0 )
+ {
+ state = receive(); // Setting Rx mode to wait an ACK
+ }
+ else
+ {
+ state_f = 1;
+ }
+ if( state == 0 )
+ {
+ // added by C. Pham
+ printf("wait for ACK");
+
+ if( availableData() )
+ {
+ state_f = getACK(); // Getting ACK
+ }
+ else
+ {
+ state_f = SX1272_ERROR_ACK;
+ // added by C. Pham
+ printf("no ACK");
+ }
+ }
+ else
+ {
+ state_f = 1;
+ }
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 0;
+#endif
+ return state_f;
+}
+
+/*
+ Function: Configures the module to transmit information and receive an ACK.
+ Returns: Integer that determines if there has been any error
+ state = 3 --> Packet has been sent but ACK has not been received
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACK(uint8_t dest, uint8_t *payload, uint16_t length16, uint16_t wait)
+{
+ uint8_t state = 2;
+ uint8_t state_f = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACK'\n");
+#endif
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 1;
+#endif
+ state = sendPacketTimeout(dest, payload, length16, wait); // Sending packet to 'dest' destination
+
+ if( state == 0 )
+ {
+ state = receive(); // Setting Rx mode to wait an ACK
+ }
+ else
+ {
+ state_f = 1;
+ }
+ if( state == 0 )
+ {
+ // added by C. Pham
+ printf("wait for ACK");
+
+ if( availableData() )
+ {
+ state_f = getACK(); // Getting ACK
+ }
+ else
+ {
+ state_f = SX1272_ERROR_ACK;
+ // added by C. Pham
+ printf("no ACK");
+ }
+ }
+ else
+ {
+ state_f = 1;
+ }
+
+#ifdef W_REQUESTED_ACK
+ _requestACK = 0;
+#endif
+ return state_f;
+}
+
+/*
+ Function: It gets and stores an ACK if it is received.
+ Returns:
+*/
+uint8_t SX1272::getACK()
+{
+ return getACK(MAX_TIMEOUT);
+}
+
+/*
+ Function: It gets and stores an ACK if it is received, before ending 'wait' time.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The ACK has not been received
+ state = 1 --> The N-ACK has been received with no errors
+ state = 0 --> The ACK has been received with no errors
+ Parameters:
+ wait: time to wait while there is no a valid header received.
+*/
+uint8_t SX1272::getACK(uint16_t wait)
+{
+ uint8_t state = 2;
+ byte value = 0x00;
+ //unsigned long previous;
+ unsigned long exitTime;
+ boolean a_received = false;
+
+ //#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getACK'\n");
+ //#endif
+
+ //previous = millis();
+ exitTime = millis()+(unsigned long)wait;
+ if( _modem == LORA )
+ { // LoRa mode
+ value = readRegister(REG_IRQ_FLAGS);
+ // Wait until the ACK is received (RxDone flag) or the timeout expires
+ //while ((bitRead(value, 6) == 0) && (millis() - previous < wait))
+ while ((bitRead(value, 6) == 0) && (millis() < exitTime))
+ {
+ value = readRegister(REG_IRQ_FLAGS);
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }
+ if( bitRead(value, 6) == 1 )
+ { // ACK received
+ // comment by C. Pham
+ // not really safe because the received packet may not be an ACK
+ // probability is low if using unicast to gateway, but if broadcast
+ // can get a packet from another node!!
+ a_received = true;
+ }
+ // Standby para minimizar el consumo
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Setting standby LoRa mode
+ }
+ else
+ { // FSK mode
+ value = readRegister(REG_IRQ_FLAGS2);
+ // Wait until the packet is received (RxDone flag) or the timeout expires
+ //while ((bitRead(value, 2) == 0) && (millis() - previous < wait))
+ while ((bitRead(value, 2) == 0) && (millis() < exitTime))
+ {
+ value = readRegister(REG_IRQ_FLAGS2);
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }
+ if( bitRead(value, 2) == 1 )
+ { // ACK received
+ a_received = true;
+ }
+ // Standby para minimizar el consumo
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Setting standby FSK mode
+ }
+
+ // comment by C. Pham
+ // not safe because the received packet may not be an ACK!
+ if( a_received )
+ {
+ // Storing the received ACK
+ ACK.dst = _destination;
+ ACK.type = readRegister(REG_FIFO);
+ ACK.src = readRegister(REG_FIFO);
+ ACK.packnum = readRegister(REG_FIFO);
+ ACK.length = readRegister(REG_FIFO);
+ ACK.data[0] = readRegister(REG_FIFO);
+ ACK.data[1] = readRegister(REG_FIFO);
+
+ if (ACK.type == PKT_TYPE_ACK) {
+
+ // Checking the received ACK
+ if( ACK.dst == packet_sent.src )
+ {
+ if( ACK.src == packet_sent.dst )
+ {
+ if( ACK.packnum == packet_sent.packnum )
+ {
+ if( ACK.length == 2 )
+ {
+ if( ACK.data[0] == CORRECT_PACKET )
+ {
+ state = 0;
+ //#if (SX1272_debug_mode > 0)
+ // Printing the received ACK
+ printf("## ACK received:");
+ printf("Destination: %d\n",ACK.dst);
+ // Serial.println(ACK.dst); // Printing destination
+ printf("Source: %d\n",ACK.src);
+ // Serial.println(ACK.src); // Printing source
+ printf("ACK number: %d\n",ACK.packnum);
+ // Serial.println(ACK.packnum); // Printing ACK number
+ printf("ACK length: %d\n",ACK.length);
+ // Serial.println(ACK.length); // Printing ACK length
+ printf("ACK payload: %d\n",ACK.data[0]);
+ // Serial.println(ACK.data[0]); // Printing ACK payload
+ printf("ACK SNR of rcv pkt at gw: ");
+
+ value = ACK.data[1];
+
+ if( value & 0x80 ) // The SNR sign bit is 1
+ {
+ // Invert and divide by 4
+ value = ( ( ~value + 1 ) & 0xFF ) >> 2;
+ _rcv_snr_in_ack = -value;
+ }
+ else
+ {
+ // Divide by 4
+ _rcv_snr_in_ack = ( value & 0xFF ) >> 2;
+ }
+
+ //Serial.println(_rcv_snr_in_ack);
+ printf("%d\n",_rcv_snr_in_ack);
+ printf("##");
+ printf("\n");
+ //#endif
+ }
+ else
+ {
+ state = 1;
+ //#if (SX1272_debug_mode > 0)
+ printf("** N-ACK received **");
+ printf("\n");
+ //#endif
+ }
+ }
+ else
+ {
+ state = 1;
+ //#if (SX1272_debug_mode > 0)
+ printf("** ACK length incorrectly received **");
+ printf("\n");
+ //#endif
+ }
+ }
+ else
+ {
+ state = 1;
+ //#if (SX1272_debug_mode > 0)
+ printf("** ACK number incorrectly received **");
+ printf("\n");
+ //#endif
+ }
+ }
+ else
+ {
+ state = 1;
+ //#if (SX1272_debug_mode > 0)
+ printf("** ACK source incorrectly received **");
+ printf("\n");
+ //#endif
+ }
+ }
+ }
+ else
+ {
+ state = 1;
+ //#if (SX1272_debug_mode > 0)
+ printf("** ACK destination incorrectly received **");
+ printf("\n");
+ //#endif
+ }
+ }
+ else
+ {
+ state = 1;
+ //#if (SX1272_debug_mode > 0)
+ printf("** ACK lost **");
+ printf("\n");
+ //#endif
+ }
+ clearFlags(); // Initializing flags
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information with retries in case of error.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketMAXTimeoutACKRetries(uint8_t dest, char *payload)
+{
+ return sendPacketTimeoutACKRetries(dest, payload, MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information with retries in case of error.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketMAXTimeoutACKRetries(uint8_t dest, uint8_t *payload, uint16_t length16)
+{
+ return sendPacketTimeoutACKRetries(dest, payload, length16, MAX_TIMEOUT);
+}
+
+/*
+ Function: Configures the module to transmit information with retries in case of error.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACKRetries(uint8_t dest, char *payload)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACKRetries'\n");
+#endif
+
+ // Sending packet to 'dest' destination and waiting an ACK response.
+ state = 1;
+ while( (state != 0) && (_retries <= _maxRetries) )
+ {
+ state = sendPacketTimeoutACK(dest, payload);
+ _retries++;
+ }
+ _retries = 0;
+
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information with retries in case of error.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACKRetries(uint8_t dest, uint8_t *payload, uint16_t length16)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACKRetries'\n");
+#endif
+
+ // Sending packet to 'dest' destination and waiting an ACK response.
+ state = 1;
+ while((state != 0) && (_retries <= _maxRetries))
+ {
+ state = sendPacketTimeoutACK(dest, payload, length16);
+ _retries++;
+
+ }
+ _retries = 0;
+
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information with retries in case of error.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACKRetries(uint8_t dest, char *payload, uint16_t wait)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACKRetries'\n");
+#endif
+
+ // Sending packet to 'dest' destination and waiting an ACK response.
+ state = 1;
+ while((state != 0) && (_retries <= _maxRetries))
+ {
+ state = sendPacketTimeoutACK(dest, payload, wait);
+ _retries++;
+ }
+ _retries = 0;
+
+ return state;
+}
+
+/*
+ Function: Configures the module to transmit information with retries in case of error.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::sendPacketTimeoutACKRetries(uint8_t dest, uint8_t *payload, uint16_t length16, uint16_t wait)
+{
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'sendPacketTimeoutACKRetries'\n");
+#endif
+
+ // Sending packet to 'dest' destination and waiting an ACK response.
+ state = 1;
+ while((state != 0) && (_retries <= _maxRetries))
+ {
+ state = sendPacketTimeoutACK(dest, payload, length16, wait);
+ _retries++;
+ }
+ _retries = 0;
+
+ return state;
+}
+
+/*
+ Function: It gets the temperature from the measurement block module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::getTemp()
+{
+ byte st0;
+ uint8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getTemp'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == LORA )
+ { // Allowing access to FSK registers while in LoRa standby mode
+ writeRegister(REG_OP_MODE, LORA_STANDBY_FSK_REGS_MODE);
+ }
+
+ state = 1;
+ // Saving temperature value
+ _temp = readRegister(REG_TEMP);
+ if( _temp & 0x80 ) // The SNR sign bit is 1
+ {
+ // Invert and divide by 4
+ _temp = ( ( ~_temp + 1 ) & 0xFF );
+ }
+ else
+ {
+ // Divide by 4
+ _temp = ( _temp & 0xFF );
+ }
+
+
+#if (SX1272_debug_mode > 1)
+ printf("## Temperature is: %d ",_temp);
+ // Serial.print(_temp);
+ printf(" ##");
+ printf("\n");
+#endif
+
+ if( _modem == LORA )
+ {
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ }
+
+ state = 0;
+ return state;
+}
+
+//**********************************************************************/
+// Added by C. Pham
+//**********************************************************************/
+
+void SX1272::setPacketType(uint8_t type)
+{
+ packet_sent.type=type;
+
+ if (type & PKT_FLAG_ACK_REQ)
+ _requestACK=1;
+}
+
+/*
+ Function: Configures the module to perform CAD.
+ Returns: Integer that determines if the number of requested CAD have been successfull
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+*/
+uint8_t SX1272::doCAD(uint8_t counter)
+{
+ uint8_t state = 2;
+ byte value = 0x00;
+ unsigned long startCAD, endCAD, startDoCad, endDoCad;
+ //unsigned long previous;
+ unsigned long exitTime;
+ uint16_t wait = 100;
+ bool failedCAD=false;
+ uint8_t retryCAD = 3;
+ uint8_t save_counter;
+ byte st0;
+ int rssi_count=0;
+ int rssi_mean=0;
+ double bw=0.0;
+ bool hasRSSI=false;
+ unsigned long startRSSI=0;
+
+ bw=(_bandwidth==BW_125)?125e3:((_bandwidth==BW_250)?250e3:500e3);
+ // Symbol rate : time for one symbol (usecs)
+ double rs = bw / ( 1 << _spreadingFactor);
+ double ts = 1 / rs;
+ ts = ts * 1000000.0;
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+#ifdef DEBUG_CAD
+ printf("SX1272::Starting 'doCAD'\n");
+#endif
+
+ save_counter = counter;
+
+ startDoCad=millis();
+
+ if( _modem == LORA ) { // LoRa mode
+
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+
+ do {
+
+ hasRSSI=false;
+
+ clearFlags(); // Initializing flags
+
+ // wait to CadDone flag
+ // previous = millis();
+ startCAD = millis();
+ exitTime = millis()+(unsigned long)wait;
+
+ writeRegister(REG_OP_MODE, LORA_CAD_MODE); // LORA mode - Cad
+
+ startRSSI=micros();
+
+ value = readRegister(REG_IRQ_FLAGS);
+ // Wait until CAD ends (CAD Done flag) or the timeout expires
+ //while ((bitRead(value, 2) == 0) && (millis() - previous < wait))
+ while ((bitRead(value, 2) == 0) && (millis() < exitTime))
+ {
+ // only one reading per CAD
+ if (micros()-startRSSI > ts+240 && !hasRSSI) {
+ _RSSI = -(OFFSET_RSSI+(_board==SX1276Chip?18:0)) + readRegister(REG_RSSI_VALUE_LORA);
+ rssi_mean += _RSSI;
+ rssi_count++;
+ hasRSSI=true;
+ }
+
+ value = readRegister(REG_IRQ_FLAGS);
+ // Condition to avoid an overflow (DO NOT REMOVE)
+ //if( millis() < previous )
+ //{
+ // previous = millis();
+ //}
+ }
+ state = 1;
+
+ endCAD = millis();
+
+ if( bitRead(value, 2) == 1 )
+ {
+ state = 0; // CAD successfully performed
+#ifdef DEBUG_CAD
+ printf("SX1272::CAD duration %X\n",endCAD-startCAD);
+
+ // Serial.println(endCAD-startCAD);
+ printf("SX1272::CAD successfully performed");
+#endif
+
+ value = readRegister(REG_IRQ_FLAGS);
+
+ // look for the CAD detected bit
+ if( bitRead(value, 0) == 1 )
+ {
+ // we detected activity
+ failedCAD=true;
+#ifdef DEBUG_CAD
+ printf("SX1272::CAD exits after %d\n",save_counter-counter);
+ // Serial.println(save_counter-counter);
+#endif
+ }
+
+ counter--;
+ }
+ else
+ {
+#ifdef DEBUG_CAD
+ printf("SX1272::CAD duration %d\n",endCAD-startCAD);
+ // Serial.println(endCAD-startCAD);
+#endif
+ if( state == 1 )
+ {
+#ifdef DEBUG_CAD
+ printf("SX1272::Timeout has expired");
+#endif
+ }
+ else
+ {
+#ifdef DEBUG_CAD
+ printf("SX1272::Error and CAD has not been performed");
+#endif
+ }
+
+ retryCAD--;
+
+ // to many errors, so exit by indicating that channel is not free
+ if (!retryCAD)
+ failedCAD=true;
+ }
+
+ } while (counter && !failedCAD);
+
+ rssi_mean = rssi_mean / rssi_count;
+ _RSSI = rssi_mean;
+ }
+
+ writeRegister(REG_OP_MODE, st0);
+
+ endDoCad=millis();
+
+ clearFlags(); // Initializing flags
+
+#ifdef DEBUG_CAD
+ printf("SX1272::doCAD duration %d\n",endDoCad-startDoCad);
+ // Serial.println(endDoCad-startDoCad);
+#endif
+
+ if (failedCAD)
+ return 2;
+
+ return state;
+}
+
+//#define DEBUG_GETTOA
+
+#ifdef DEBUG_GETTOA
+
+void printDouble( double val, byte precision){
+ // prints val with number of decimal places determine by precision
+ // precision is a number from 0 to 6 indicating the desired decimial places
+ // example: lcdPrintDouble( 3.1415, 2); // prints 3.14 (two decimal places)
+
+ if(val < 0.0){
+ Serial.print('-');
+ val = -val;
+ }
+
+ Serial.print (int(val)); //prints the int part
+ if( precision > 0) {
+ Serial.print("."); // print the decimal point
+ unsigned long frac;
+ unsigned long mult = 1;
+ byte padding = precision -1;
+ while(precision--)
+ mult *=10;
+
+ if(val >= 0)
+ frac = (val - int(val)) * mult;
+ else
+ frac = (int(val)- val ) * mult;
+ unsigned long frac1 = frac;
+ while( frac1 /= 10 )
+ padding--;
+ while( padding--)
+ Serial.print("0");
+ printfrac,DEC) ;
+ }
+}
+
+#endif
+
+uint16_t SX1272::getToA(uint8_t pl) {
+
+ uint8_t DE = 0;
+ uint32_t airTime = 0;
+
+ double bw=0.0;
+
+ bw=(_bandwidth==BW_125)?125e3:((_bandwidth==BW_250)?250e3:500e3);
+
+#ifdef DEBUG_GETTOA
+ printf("SX1272::bw is ");
+ Serial.println(bw);
+
+ printf("SX1272::SF is ");
+ Serial.println(_spreadingFactor);
+#endif
+
+ //double ts=pow(2,_spreadingFactor)/bw;
+
+ ////// from LoRaMAC SX1272GetTimeOnAir()
+
+ // Symbol rate : time for one symbol (secs)
+ double rs = bw / ( 1 << _spreadingFactor);
+ double ts = 1 / rs;
+
+ // must add 4 to the programmed preamble length to get the effective preamble length
+ double tPreamble=((_preamblelength+4)+4.25)*ts;
+
+#ifdef DEBUG_GETTOA
+ printf("SX1272::ts is ");
+ printDouble(ts,6);
+ printf("\n");
+ printf("SX1272::tPreamble is ");
+ printDouble(tPreamble,6);
+ printf("\n");
+#endif
+
+ // for low data rate optimization
+ if ((_bandwidth == BW_125) && _spreadingFactor == 12)
+ DE = 1;
+
+ // Symbol length of payload and time
+ double tmp = (8*pl - 4*_spreadingFactor + 28 + 16 - 20*_header) /
+ (double)(4*(_spreadingFactor-2*DE) );
+
+#ifdef DEBUG_GETTOA
+ printf("SX1272::tmp is ");
+ printDouble(tmp,6);
+ printf("\n");
+#endif
+
+ tmp = ceil(tmp)*(_codingRate + 4);
+
+ double nPayload = 8 + ( ( tmp > 0 ) ? tmp : 0 );
+
+#ifdef DEBUG_GETTOA
+ printf("SX1272::nPayload is ");
+ Serial.println(nPayload);
+#endif
+
+ double tPayload = nPayload * ts;
+ // Time on air
+ double tOnAir = tPreamble + tPayload;
+ // in us secs
+ airTime = floor( tOnAir * 1e6 + 0.999 );
+
+ //////
+
+#ifdef DEBUG_GETTOA
+ printf("SX1272::airTime is ");
+ Serial.println(airTime);
+#endif
+ // return in ms
+ // Modifie par C.Dupaty A VERIFIER !!!!!!!!!!!!!!!!!!!!!!!!!
+ // _currentToA=ceil(airTime/1000)+1;
+ _currentToA=(airTime/1000)+1;
+ return _currentToA;
+}
+
+// need to set _send_cad_number to a value > 0
+// we advise using _send_cad_number=3 for a SIFS and _send_cad_number=9 for a DIFS
+// prior to send any data
+// TODO: have a maximum number of trials
+void SX1272::CarrierSense() {
+
+ int e;
+ bool carrierSenseRetry=false;
+
+ if (_send_cad_number && _enableCarrierSense) {
+ do {
+ do {
+
+ // check for free channel (SIFS/DIFS)
+ _startDoCad=millis();
+ e = doCAD(_send_cad_number);
+ _endDoCad=millis();
+
+ printf("--> CAD duration %d\n",_endDoCad-_startDoCad);
+ // Serial.print(_endDoCad-_startDoCad);
+ printf("\n");
+
+ if (!e) {
+ printf("OK1\n");
+
+ if (_extendedIFS) {
+ // wait for random number of CAD
+ // uint8_t w = random(1,8);
+ // ajoute par C.Dupaty
+ uint8_t w = rand()%8+1;
+ printf("--> waiting for %d\n",w);
+ // Serial.print(w);
+ printf(" CAD = %d\n",sx1272_CAD_value[_loraMode]*w);
+ // Serial.print(sx1272_CAD_value[_loraMode]*w);
+ printf("\n");
+
+ wait_ms(sx1272_CAD_value[_loraMode]*w);
+
+ // check for free channel (SIFS/DIFS) once again
+ _startDoCad=millis();
+ e = doCAD(_send_cad_number);
+ _endDoCad=millis();
+
+ printf("--> CAD duration %d\n",_endDoCad-_startDoCad);
+ // Serial.print(_endDoCad-_startDoCad);
+ printf("\n");
+
+ if (!e)
+ printf("OK2");
+ else
+ printf("###2");
+
+ printf("\n");
+ }
+ }
+ else {
+ printf("###1\n");
+
+ // wait for random number of DIFS
+ uint8_t w = rand()%8+1;
+
+ printf("--> waiting for %d\n",w);
+ // Serial.print(w);
+ printf(" DIFS (DIFS=3SIFS) = %d\n",sx1272_SIFS_value[_loraMode]*3*w);
+ // Serial.print(sx1272_SIFS_value[_loraMode]*3*w);
+ printf("\n");
+
+ wait_ms(sx1272_SIFS_value[_loraMode]*3*w);
+
+ printf("--> retry\n");
+ }
+
+ } while (e);
+
+ // CAD is OK, but need to check RSSI
+ if (_RSSIonSend) {
+
+ e=getRSSI();
+
+ uint8_t rssi_retry_count=10;
+
+ if (!e) {
+
+ printf("--> RSSI %d\n",_RSSI);
+ //Serial.print(_RSSI);
+ printf("\n");
+
+ while (_RSSI > -90 && rssi_retry_count) {
+
+ wait_ms(1);
+ getRSSI();
+ printf("--> RSSI %d\n",_RSSI);
+ //Serial.print(_RSSI);
+ printf("\n");
+ rssi_retry_count--;
+ }
+ }
+ else
+ printf("--> RSSI error\n");
+
+ if (!rssi_retry_count)
+ carrierSenseRetry=true;
+ else
+ carrierSenseRetry=false;
+ }
+
+ } while (carrierSenseRetry);
+ }
+}
+
+/*
+ Function: Indicates the CR within the module is configured.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+*/
+int8_t SX1272::getSyncWord()
+{
+ int8_t state = 2;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'getSyncWord'\n");
+#endif
+
+ if( _modem == FSK )
+ {
+ state = -1; // sync word is not available in FSK mode
+#if (SX1272_debug_mode > 1)
+ printf("** FSK mode hasn't sync word **");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ _syncWord = readRegister(REG_SYNC_WORD);
+
+ state = 0;
+
+#if (SX1272_debug_mode > 1)
+ printf("## Sync word is %X ",_syncWord);
+ // Serial.print(_syncWord, HEX);
+ printf(" ##");
+ printf("\n");
+#endif
+ }
+ return state;
+}
+
+/*
+ Function: Sets the sync word in the module.
+ Returns: Integer that determines if there has been any error
+ state = 2 --> The command has not been executed
+ state = 1 --> There has been an error while executing the command
+ state = 0 --> The command has been executed with no errors
+ state = -1 --> Forbidden command for this protocol
+ Parameters:
+ cod: sw is sync word value to set in LoRa modem configuration.
+*/
+int8_t SX1272::setSyncWord(uint8_t sw)
+{
+ byte st0;
+ int8_t state = 2;
+ byte config1;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setSyncWord'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+
+ if( _modem == FSK )
+ {
+#if (SX1272_debug_mode > 1)
+ printf("## Notice that FSK hasn't sync word parameter, ");
+ printf("so you are configuring it in LoRa mode ##");
+#endif
+ state = setLORA();
+ }
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE); // Set Standby mode to write in registers
+
+ writeRegister(REG_SYNC_WORD, sw);
+
+ wait_ms(100);
+
+ config1 = readRegister(REG_SYNC_WORD);
+
+ if (config1==sw) {
+ state=0;
+ _syncWord = sw;
+#if (SX1272_debug_mode > 1)
+ printf("## Sync Word %X ",sw);
+ // Serial.print(sw, HEX);
+ printf(" has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else {
+ state=1;
+#if (SX1272_debug_mode > 1)
+ printf("** There has been an error while configuring Sync Word parameter **");
+ printf("\n");
+#endif
+ }
+
+ writeRegister(REG_OP_MODE,st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+
+int8_t SX1272::setSleepMode() {
+
+ int8_t state = 2;
+ byte value;
+
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+ // proposed by escyes
+ // https://github.com/CongducPham/LowCostLoRaGw/issues/53#issuecomment-289237532
+ //
+ // inserted to avoid REG_OP_MODE stay = 0x40 (no sleep mode)
+ wait_ms(100);
+ writeRegister(REG_OP_MODE, LORA_SLEEP_MODE); // LoRa sleep mode
+
+ //delay(50);
+
+ value = readRegister(REG_OP_MODE);
+
+ //printf("## REG_OP_MODE 0x");
+ //Serial.println(value, HEX);
+
+ if (value == LORA_SLEEP_MODE)
+ state=0;
+ else
+ state=1;
+
+ return state;
+}
+
+int8_t SX1272::setPowerDBM(uint8_t dbm) {
+ byte st0;
+ int8_t state = 2;
+ byte value = 0x00;
+
+ byte RegPaDacReg=(_board==SX1272Chip)?0x5A:0x4D;
+
+#if (SX1272_debug_mode > 1)
+ printf("\n");
+ printf("Starting 'setPowerDBM'\n");
+#endif
+
+ st0 = readRegister(REG_OP_MODE); // Save the previous status
+ if( _modem == LORA )
+ { // LoRa Stdby mode to write in registers
+ writeRegister(REG_OP_MODE, LORA_STANDBY_MODE);
+ }
+ else
+ { // FSK Stdby mode to write in registers
+ writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);
+ }
+
+ if (dbm == 20) {
+ return setPower('X');
+ }
+
+ if (dbm > 14)
+ return state;
+
+ // disable high power output in all other cases
+ writeRegister(RegPaDacReg, 0x84);
+
+ if (dbm > 10)
+ // set RegOcp for OcpOn and OcpTrim
+ // 130mA
+ setMaxCurrent(0x10);
+ else
+ // 100mA
+ setMaxCurrent(0x0B);
+
+ if (_board==SX1272Chip) {
+ // Pout = -1 + _power[3:0] on RFO
+ // Pout = 2 + _power[3:0] on PA_BOOST
+ if (_needPABOOST) {
+ value = dbm - 2;
+ // we set the PA_BOOST pin
+ value = value & 0B10000000;
+ }
+ else
+ value = dbm + 1;
+
+ writeRegister(REG_PA_CONFIG, value); // Setting output power value
+ }
+ else {
+ // for the SX1276
+ uint8_t pmax=15;
+
+ // then Pout = Pmax-(15-_power[3:0]) if PaSelect=0 (RFO pin for +14dBm)
+ // so L=3dBm; H=7dBm; M=15dBm (but should be limited to 14dBm by RFO pin)
+
+ // and Pout = 17-(15-_power[3:0]) if PaSelect=1 (PA_BOOST pin for +14dBm)
+ // so x= 14dBm (PA);
+ // when p=='X' for 20dBm, value is 0x0F and RegPaDacReg=0x87 so 20dBm is enabled
+
+ if (_needPABOOST) {
+ value = dbm - 17 + 15;
+ // we set the PA_BOOST pin
+ value = value & 0B10000000;
+ }
+ else
+ value = dbm - pmax + 15;
+
+ // set MaxPower to 7 -> Pmax=10.8+0.6*MaxPower [dBm] = 15
+ value = value & 0B01110000;
+
+ writeRegister(REG_PA_CONFIG, value);
+ }
+
+ _power=value;
+
+ value = readRegister(REG_PA_CONFIG);
+
+ if( value == _power )
+ {
+ state = 0;
+#if (SX1272_debug_mode > 1)
+ printf("## Output power has been successfully set ##");
+ printf("\n");
+#endif
+ }
+ else
+ {
+ state = 1;
+ }
+
+ writeRegister(REG_OP_MODE, st0); // Getting back to previous status
+ wait_ms(100);
+ return state;
+}
+
+long SX1272::limitToA() {
+
+ // first time we set limitToA?
+ // in this design, once you set _limitToA to true
+ // it is not possible to set it back to false
+ if (_limitToA==false) {
+ _startToAcycle=millis();
+ _remainingToA=MAX_DUTY_CYCLE_PER_HOUR;
+ // we are handling millis() rollover by calculating the end of cycle time
+ _endToAcycle=_startToAcycle+DUTYCYCLE_DURATION;
+ }
+
+ _limitToA=true;
+ return getRemainingToA();
+}
+
+long SX1272::getRemainingToA() {
+
+ if (_limitToA==false)
+ return MAX_DUTY_CYCLE_PER_HOUR;
+
+ // we compare to the end of cycle so that millis() rollover is taken into account
+ // using unsigned long modulo operation
+ if ( (millis() > _endToAcycle ) ) {
+ _startToAcycle=_endToAcycle;
+ _remainingToA=MAX_DUTY_CYCLE_PER_HOUR;
+ _endToAcycle=_startToAcycle+DUTYCYCLE_DURATION;
+
+ printf("## new cycle for ToA ##");
+ printf("cycle begins at %d\n",_startToAcycle);
+ // Serial.print(_startToAcycle);
+ printf(" cycle ends at %d\n",_endToAcycle);
+ // Serial.print(_endToAcycle);
+ printf(" remaining ToA is %d\n",_remainingToA);
+ // Serial.print(_remainingToA);
+ printf("\n");
+ }
+
+ return _remainingToA;
+}
+
+long SX1272::removeToA(uint16_t toa) {
+
+ // first, update _remainingToA
+ getRemainingToA();
+
+ if (_limitToA) {
+ _remainingToA-=toa;
+ }
+
+ return _remainingToA;
+}
+
+SX1272 sx1272 = SX1272();