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

SX127x - sync with LoRaLib v4.0.0

Browse source
This commit is contained in:
Jan Gromeš 2018-07-23 12:47:47 +02:00
parent a081e10a2b
commit 702a7f6747
18 changed files with 238 additions and 230 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
examples/SX127x_ChannelActivityDetection/SX127x_ChannelActivityDetection.ino
View file

@ -1,18 +1,18 @@
/* /*
* KiteLib SX127x Channel Activity Detection Example KiteLib SX127x Channel Activity Detection Example
*
* This example scans the current LoRa channel using SX1278 LoRa radio module This example scans the current LoRa channel using SX1278 LoRa radio module
* and detects valid LoRa preambles. Preamble is the first part of LoRa transmission, and detects valid LoRa preambles. Preamble is the first part of LoRa transmission,
* so this can be used to check if the LoRa channel is free, so this can be used to check if the LoRa channel is free,
* or if you should start receiving a message. or if you should start receiving a message.
*
* Other modules from SX127x family can also be used. Other modules from SX127x family can also be used.
* SX1272 lora = Kite.ModuleA; SX1272 lora = Kite.ModuleA;
* SX1273 lora = Kite.ModuleA; SX1273 lora = Kite.ModuleA;
* SX1276 lora = Kite.ModuleA; SX1276 lora = Kite.ModuleA;
* SX1277 lora = Kite.ModuleA; SX1277 lora = Kite.ModuleA;
* SX1279 lora = Kite.ModuleA; SX1279 lora = Kite.ModuleA;
*/ */
// include the library // include the library
#include <KiteLib.h> #include <KiteLib.h>
@ -31,13 +31,13 @@ void setup() {
// coding rate: 7 // coding rate: 7
// sync word: 0x12 // sync word: 0x12
// output power: 17 dBm // output power: 17 dBm
byte state = lora.begin(); int state = lora.begin();
if(state == ERR_NONE) { if (state == ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code 0x")); Serial.print(F("failed, code "));
Serial.println(state, HEX); Serial.println(state);
while(true); while (true);
} }
} }
@ -45,13 +45,13 @@ void loop() {
Serial.print(F("Scanning channel for LoRa preamble ... ")); Serial.print(F("Scanning channel for LoRa preamble ... "));
// start scanning current channel // start scanning current channel
uint8_t state = lora.scanChannel(); int state = lora.scanChannel();
if(state == PREAMBLE_DETECTED) { if (state == PREAMBLE_DETECTED) {
// LoRa preamble was detected // LoRa preamble was detected
Serial.println(" detected preamble!"); Serial.println(" detected preamble!");
} else if(state == CHANNEL_FREE) { } else if (state == CHANNEL_FREE) {
// no preamble was detected, channel is free // no preamble was detected, channel is free
Serial.println(" channel is free!"); Serial.println(" channel is free!");

56
examples/SX127x_Receive/SX127x_Receive.ino
View file

@ -1,22 +1,22 @@
/* /*
* KiteLib SX127x Receive Example KiteLib SX127x Receive Example
*
* This example listens for LoRa transmissions using SX127x Lora modules. This example listens for LoRa transmissions using SX127x Lora modules.
* To successfully receive data, the following settings have to be the same To successfully receive data, the following settings have to be the same
* on both transmitter and receiver: on both transmitter and receiver:
* - carrier frequency - carrier frequency
* - bandwidth - bandwidth
* - spreading factor - spreading factor
* - coding rate - coding rate
* - sync word - sync word
*
* Other modules from SX127x family can also be used. Other modules from SX127x family can also be used.
* SX1272 lora = Kite.ModuleA; SX1272 lora = Kite.ModuleA;
* SX1273 lora = Kite.ModuleA; SX1273 lora = Kite.ModuleA;
* SX1276 lora = Kite.ModuleA; SX1276 lora = Kite.ModuleA;
* SX1277 lora = Kite.ModuleA; SX1277 lora = Kite.ModuleA;
* SX1279 lora = Kite.ModuleA; SX1279 lora = Kite.ModuleA;
*/ */
// include the library // include the library
#include <KiteLib.h> #include <KiteLib.h>
@ -35,13 +35,13 @@ void setup() {
// coding rate: 7 // coding rate: 7
// sync word: 0x12 // sync word: 0x12
// output power: 17 dBm // output power: 17 dBm
byte state = lora.begin(); int state = lora.begin();
if(state == ERR_NONE) { if (state == ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code 0x")); Serial.print(F("failed, code "));
Serial.println(state, HEX); Serial.println(state);
while(true); while (true);
} }
} }
@ -50,15 +50,15 @@ void loop() {
// you can receive data as an Arduino String // you can receive data as an Arduino String
String str; String str;
byte state = lora.receive(str); int state = lora.receive(str);
// you can also receive data as byte array // you can also receive data as byte array
/* /*
byte byteArr[8]; byte byteArr[8];
byte state = lora.receive(byteArr, 8); int state = lora.receive(byteArr, 8);
*/ */
if(state == ERR_NONE) { if (state == ERR_NONE) {
// packet was successfully received // packet was successfully received
Serial.println(F("success!")); Serial.println(F("success!"));
@ -81,11 +81,11 @@ void loop() {
Serial.print(lora.lastPacketSNR); Serial.print(lora.lastPacketSNR);
Serial.println(" dBm"); Serial.println(" dBm");
} else if(state == ERR_RX_TIMEOUT) { } else if (state == ERR_RX_TIMEOUT) {
// timeout occurred while waiting for a packet // timeout occurred while waiting for a packet
Serial.println(F("timeout!")); Serial.println(F("timeout!"));
} else if(state == ERR_CRC_MISMATCH) { } else if (state == ERR_CRC_MISMATCH) {
// packet was received, but is malformed // packet was received, but is malformed
Serial.println(F("CRC error!")); Serial.println(F("CRC error!"));

74
examples/SX127x_Settings/SX127x_Settings.ino
View file

@ -1,16 +1,16 @@
/* /*
* KiteLib SX127x Settings Example KiteLib SX127x Settings Example
*
* This example shows how to change all the properties of LoRa transmission. This example shows how to change all the properties of LoRa transmission.
* KiteLib currently supports the following settings: KiteLib currently supports the following settings:
* - pins (SPI slave select, digital IO 0, digital IO 1) - pins (SPI slave select, digital IO 0, digital IO 1)
* - carrier frequency - carrier frequency
* - bandwidth - bandwidth
* - spreading factor - spreading factor
* - coding rate - coding rate
* - sync word - sync word
* - output power during transmission - output power during transmission
*/ */
// include the library // include the library
#include <KiteLib.h> #include <KiteLib.h>
@ -42,13 +42,13 @@ void setup() {
// coding rate: 7 // coding rate: 7
// sync word: 0x12 // sync word: 0x12
// output power: 17 dBm // output power: 17 dBm
byte state = loraSX1278.begin(); int state = loraSX1278.begin();
if(state == ERR_NONE) { if (state == ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code 0x")); Serial.print(F("failed, code "));
Serial.println(state, HEX); Serial.println(state);
while(true); while (true);
} }
// initialize the second LoRa instance with non-default settings // initialize the second LoRa instance with non-default settings
@ -61,12 +61,12 @@ void setup() {
// sync word: 0x13 // sync word: 0x13
// output power: 17 dBm // output power: 17 dBm
state = loraSX1276.begin(434.0, 7.8, 12, 8, 0x13); state = loraSX1276.begin(434.0, 7.8, 12, 8, 0x13);
if(state == ERR_NONE) { if (state == ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code 0x")); Serial.print(F("failed, code "));
Serial.println(state, HEX); Serial.println(state);
while(true); while (true);
} }
// initialize the third LoRa instance with non-default settings // initialize the third LoRa instance with non-default settings
@ -83,12 +83,12 @@ void setup() {
// sync word: 0x14 // sync word: 0x14
// output power: 2 dBm // output power: 2 dBm
state = loraSX1272.begin(915.0, 500.0, 6, 5, 0x14, 2); state = loraSX1272.begin(915.0, 500.0, 6, 5, 0x14, 2);
if(state == ERR_NONE) { if (state == ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code 0x")); Serial.print(F("failed, code "));
Serial.println(state, HEX); Serial.println(state);
while(true); while (true);
} }
// you can also change the settings at runtime // you can also change the settings at runtime
@ -98,40 +98,40 @@ void setup() {
// see https://github.com/jgromes/LoRaLib/wiki/Supported-LoRa-modules // see https://github.com/jgromes/LoRaLib/wiki/Supported-LoRa-modules
// set carrier frequency to 433.5 MHz // set carrier frequency to 433.5 MHz
if(loraSX1278.setFrequency(433.5) == ERR_INVALID_FREQUENCY) { if (loraSX1278.setFrequency(433.5) == ERR_INVALID_FREQUENCY) {
Serial.println("Selected frequency is invalid for this module!"); Serial.println("Selected frequency is invalid for this module!");
while(true); while (true);
} }
// set bandwidth to 250 kHz // set bandwidth to 250 kHz
if(loraSX1278.setBandwidth(250.0) == ERR_INVALID_BANDWIDTH) { if (loraSX1278.setBandwidth(250.0) == ERR_INVALID_BANDWIDTH) {
Serial.println("Selected bandwidth is invalid for this module!"); Serial.println("Selected bandwidth is invalid for this module!");
while(true); while (true);
} }
// set spreading factor to 10 // set spreading factor to 10
if(loraSX1278.setSpreadingFactor(10) == ERR_INVALID_SPREADING_FACTOR) { if (loraSX1278.setSpreadingFactor(10) == ERR_INVALID_SPREADING_FACTOR) {
Serial.println("Selected spreading factor is invalid for this module!"); Serial.println("Selected spreading factor is invalid for this module!");
while(true); while (true);
} }
// set coding rate to 6 // set coding rate to 6
if(loraSX1278.setCodingRate(6) == ERR_INVALID_CODING_RATE) { if (loraSX1278.setCodingRate(6) == ERR_INVALID_CODING_RATE) {
Serial.println("Selected coding rate is invalid for this module!"); Serial.println("Selected coding rate is invalid for this module!");
while(true); while (true);
} }
// set LoRa sync word to 0x14 // set LoRa sync word to 0x14
// NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used // NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used
if(loraSX1278.setSyncWord(0x14) != ERR_NONE) { if (loraSX1278.setSyncWord(0x14) != ERR_NONE) {
Serial.println("Unable to set sync word!"); Serial.println("Unable to set sync word!");
while(true); while (true);
} }
// set output power to 10 dBm (accepted range is 2 - 17 dBm) // set output power to 10 dBm (accepted range is 2 - 17 dBm)
if(loraSX1278.setOutputPower(10) == ERR_INVALID_OUTPUT_POWER) { if (loraSX1278.setOutputPower(10) == ERR_INVALID_OUTPUT_POWER) {
Serial.println("Selected output power is invalid for this module!"); Serial.println("Selected output power is invalid for this module!");
while(true); while (true);
} }
Serial.println("All settings succesfully changed!"); Serial.println("All settings succesfully changed!");

50
examples/SX127x_Transmit/SX127x_Transmit.ino
View file

@ -1,19 +1,19 @@
/* /*
* KiteLib SX127x Transmit Example KiteLib SX127x Transmit Example
*
* This example transmits packets using SX1278 LoRa radio module. This example transmits packets using SX1278 LoRa radio module.
* Each packet contains up to 256 bytes of data, in the form of: Each packet contains up to 256 bytes of data, in the form of:
* - Arduino String - Arduino String
* - null-terminated char array (C-string) - null-terminated char array (C-string)
* - arbitrary binary data (byte array) - arbitrary binary data (byte array)
*
* Other modules from SX127x family can also be used. Other modules from SX127x family can also be used.
* SX1272 lora = Kite.ModuleA; SX1272 lora = Kite.ModuleA;
* SX1273 lora = Kite.ModuleA; SX1273 lora = Kite.ModuleA;
* SX1276 lora = Kite.ModuleA; SX1276 lora = Kite.ModuleA;
* SX1277 lora = Kite.ModuleA; SX1277 lora = Kite.ModuleA;
* SX1279 lora = Kite.ModuleA; SX1279 lora = Kite.ModuleA;
*/ */
// include the library // include the library
#include <KiteLib.h> #include <KiteLib.h>
@ -32,13 +32,13 @@ void setup() {
// coding rate: 7 // coding rate: 7
// sync word: 0x12 // sync word: 0x12
// output power: 17 dBm // output power: 17 dBm
byte state = lora.begin(); int state = lora.begin();
if(state == ERR_NONE) { if (state == ERR_NONE) {
Serial.println(F("success!")); Serial.println(F("success!"));
} else { } else {
Serial.print(F("failed, code 0x")); Serial.print(F("failed, code "));
Serial.println(state, HEX); Serial.println(state);
while(true); while (true);
} }
} }
@ -46,23 +46,23 @@ void loop() {
Serial.print(F("[SX1278] Transmitting packet ... ")); Serial.print(F("[SX1278] Transmitting packet ... "));
// you can transmit C-string or Arduino string up to 256 characters long // you can transmit C-string or Arduino string up to 256 characters long
byte state = lora.transmit("Hello World!"); int state = lora.transmit("Hello World!");
// you can also transmit byte array up to 256 bytes long // you can also transmit byte array up to 256 bytes long
/* /*
byte byteArr[] = {0x01, 0x23, 0x45, 0x56, 0x78, 0xAB, 0xCD, 0xEF}; byte byteArr[] = {0x01, 0x23, 0x45, 0x56, 0x78, 0xAB, 0xCD, 0xEF};
byte state = lora.transmit(byteArr, 8); int state = lora.transmit(byteArr, 8);
*/ */
if(state == ERR_NONE) { if (state == ERR_NONE) {
// the packet was successfully transmitted // the packet was successfully transmitted
Serial.println(" success!"); Serial.println(" success!");
} else if(state == ERR_PACKET_TOO_LONG) { } else if (state == ERR_PACKET_TOO_LONG) {
// the supplied packet was longer than 256 bytes // the supplied packet was longer than 256 bytes
Serial.println(" too long!"); Serial.println(" too long!");
} else if(state == ERR_TX_TIMEOUT) { } else if (state == ERR_TX_TIMEOUT) {
// timeout occured while transmitting packet // timeout occured while transmitting packet
Serial.println(" timeout!"); Serial.println(" timeout!");

34
src/modules/SX1272.cpp
View file

@ -4,9 +4,9 @@ SX1272::SX1272(Module* mod) : SX127x(mod) {
} }
uint8_t SX1272::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) { int16_t SX1272::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) {
// execute common part // execute common part
uint8_t state = SX127x::begin(SX1272_CHIP_VERSION, syncWord); int16_t state = SX127x::begin(SX1272_CHIP_VERSION, syncWord);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -46,7 +46,7 @@ uint8_t SX1272::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
return(ERR_NONE); return(ERR_NONE);
} }
uint8_t SX1272::setFrequency(float freq) { int16_t SX1272::setFrequency(float freq) {
// check frequency range // check frequency range
if((freq < 860.0) || (freq > 1020.0)) { if((freq < 860.0) || (freq > 1020.0)) {
return(ERR_INVALID_FREQUENCY); return(ERR_INVALID_FREQUENCY);
@ -56,7 +56,7 @@ uint8_t SX1272::setFrequency(float freq) {
return(SX127x::setFrequencyRaw(freq)); return(SX127x::setFrequencyRaw(freq));
} }
uint8_t SX1272::setBandwidth(float bw) { int16_t SX1272::setBandwidth(float bw) {
uint8_t newBandwidth; uint8_t newBandwidth;
// check alowed bandwidth values // check alowed bandwidth values
@ -71,7 +71,7 @@ uint8_t SX1272::setBandwidth(float bw) {
} }
// set bandwidth and if successful, save the new setting // set bandwidth and if successful, save the new setting
uint8_t state = SX1272::setBandwidthRaw(newBandwidth); int16_t state = SX1272::setBandwidthRaw(newBandwidth);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_bw = bw; SX127x::_bw = bw;
} }
@ -79,7 +79,7 @@ uint8_t SX1272::setBandwidth(float bw) {
return(state); return(state);
} }
uint8_t SX1272::setSpreadingFactor(uint8_t sf) { int16_t SX1272::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor; uint8_t newSpreadingFactor;
// check allowed spreading factor values // check allowed spreading factor values
@ -110,7 +110,7 @@ uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
} }
// set spreading factor and if successful, save the new setting // set spreading factor and if successful, save the new setting
uint8_t state = SX1272::setSpreadingFactorRaw(newSpreadingFactor); int16_t state = SX1272::setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_sf = sf; SX127x::_sf = sf;
} }
@ -118,7 +118,7 @@ uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
return(state); return(state);
} }
uint8_t SX1272::setCodingRate(uint8_t cr) { int16_t SX1272::setCodingRate(uint8_t cr) {
uint8_t newCodingRate; uint8_t newCodingRate;
// check allowed coding rate values // check allowed coding rate values
@ -140,7 +140,7 @@ uint8_t SX1272::setCodingRate(uint8_t cr) {
} }
// set coding rate and if successful, save the new setting // set coding rate and if successful, save the new setting
uint8_t state = SX1272::setCodingRateRaw(newCodingRate); int16_t state = SX1272::setCodingRateRaw(newCodingRate);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_cr = cr; SX127x::_cr = cr;
} }
@ -148,7 +148,7 @@ uint8_t SX1272::setCodingRate(uint8_t cr) {
return(state); return(state);
} }
uint8_t SX1272::setOutputPower(int8_t power) { int16_t SX1272::setOutputPower(int8_t power) {
// check allowed power range // check allowed power range
if((power < -1) || (power > 20)) { if((power < -1) || (power > 20)) {
return(ERR_INVALID_OUTPUT_POWER); return(ERR_INVALID_OUTPUT_POWER);
@ -157,7 +157,7 @@ uint8_t SX1272::setOutputPower(int8_t power) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
uint8_t state; int16_t state;
if(power < 15) { if(power < 15) {
// power is less than 15 dBm, enable PA0 on RFIO // power is less than 15 dBm, enable PA0 on RFIO
state = _mod->SPIsetRegValue(SX127X_REG_PA_CONFIG, SX127X_PA_SELECT_RFO, 7, 7); state = _mod->SPIsetRegValue(SX127X_REG_PA_CONFIG, SX127X_PA_SELECT_RFO, 7, 7);
@ -178,7 +178,7 @@ uint8_t SX1272::setOutputPower(int8_t power) {
return(state); return(state);
} }
uint8_t SX1272::setBandwidthRaw(uint8_t newBandwidth) { int16_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
@ -186,12 +186,12 @@ uint8_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newBandwidth, 7, 6)); return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newBandwidth, 7, 6));
} }
uint8_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) { int16_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
// write registers // write registers
uint8_t state = 0; int16_t state = 0;
if(newSpreadingFactor == SX127X_SF_6) { if(newSpreadingFactor == SX127X_SF_6) {
state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, SX1272_HEADER_IMPL_MODE | SX1272_RX_CRC_MODE_OFF, 2, 1); state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, SX1272_HEADER_IMPL_MODE | SX1272_RX_CRC_MODE_OFF, 2, 1);
state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE, 7, 3); state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE, 7, 3);
@ -207,7 +207,7 @@ uint8_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
return(state); return(state);
} }
uint8_t SX1272::setCodingRateRaw(uint8_t newCodingRate) { int16_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
@ -215,9 +215,9 @@ uint8_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newCodingRate, 5, 3)); return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newCodingRate, 5, 3));
} }
uint8_t SX1272::config() { int16_t SX1272::config() {
// configure common registers // configure common registers
uint8_t state = SX127x::config(); int16_t state = SX127x::config();
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }

20
src/modules/SX1272.h
View file

@ -52,22 +52,22 @@ class SX1272: public SX127x {
SX1272(Module* mod); SX1272(Module* mod);
// basic methods // basic methods
uint8_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17); int16_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17);
// configuration methods // configuration methods
uint8_t setFrequency(float freq); int16_t setFrequency(float freq);
uint8_t setBandwidth(float bw); int16_t setBandwidth(float bw);
uint8_t setSpreadingFactor(uint8_t sf); int16_t setSpreadingFactor(uint8_t sf);
uint8_t setCodingRate(uint8_t cr); int16_t setCodingRate(uint8_t cr);
uint8_t setOutputPower(int8_t power); int16_t setOutputPower(int8_t power);
protected: protected:
uint8_t setBandwidthRaw(uint8_t newBandwidth); int16_t setBandwidthRaw(uint8_t newBandwidth);
uint8_t setSpreadingFactorRaw(uint8_t newSpreadingFactor); int16_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
uint8_t setCodingRateRaw(uint8_t newCodingRate); int16_t setCodingRateRaw(uint8_t newCodingRate);
private: private:
uint8_t config(); int16_t config();
}; };
#endif #endif

4
src/modules/SX1273.cpp
View file

@ -4,7 +4,7 @@ SX1273::SX1273(Module* mod) : SX1272(mod) {
} }
uint8_t SX1273::setSpreadingFactor(uint8_t sf) { int16_t SX1273::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor; uint8_t newSpreadingFactor;
// check allowed spreading factor values // check allowed spreading factor values
@ -26,7 +26,7 @@ uint8_t SX1273::setSpreadingFactor(uint8_t sf) {
} }
// set spreading factor and if successful, save the new setting // set spreading factor and if successful, save the new setting
uint8_t state = setSpreadingFactorRaw(newSpreadingFactor); int16_t state = setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_sf = sf; SX127x::_sf = sf;
} }

2
src/modules/SX1273.h
View file

@ -10,7 +10,7 @@ class SX1273: public SX1272 {
SX1273(Module* mod); SX1273(Module* mod);
// configuration methods // configuration methods
uint8_t setSpreadingFactor(uint8_t sf); int16_t setSpreadingFactor(uint8_t sf);
}; };
#endif #endif

2
src/modules/SX1276.cpp
View file

@ -4,7 +4,7 @@ SX1276::SX1276(Module* mod) : SX1278(mod) {
} }
uint8_t SX1276::setFrequency(float freq) { int16_t SX1276::setFrequency(float freq) {
// check frequency range // check frequency range
if((freq < 137.0) || (freq > 1020.0)) { if((freq < 137.0) || (freq > 1020.0)) {
return(ERR_INVALID_FREQUENCY); return(ERR_INVALID_FREQUENCY);

2
src/modules/SX1276.h
View file

@ -10,7 +10,7 @@ class SX1276: public SX1278 {
SX1276(Module* mod); SX1276(Module* mod);
// configuration methods // configuration methods
uint8_t setFrequency(float freq); int16_t setFrequency(float freq);
}; };
#endif #endif

6
src/modules/SX1277.cpp
View file

@ -4,7 +4,7 @@ SX1277::SX1277(Module* mod) : SX1278(mod) {
} }
uint8_t SX1277::setFrequency(float freq) { int16_t SX1277::setFrequency(float freq) {
// check frequency range // check frequency range
if((freq < 137.0) || (freq > 1020.0)) { if((freq < 137.0) || (freq > 1020.0)) {
return(ERR_INVALID_FREQUENCY); return(ERR_INVALID_FREQUENCY);
@ -74,7 +74,7 @@ uint8_t SX1277::setFrequency(float freq) {
return(SX127x::setFrequencyRaw(freq)); return(SX127x::setFrequencyRaw(freq));
} }
uint8_t SX1277::setSpreadingFactor(uint8_t sf) { int16_t SX1277::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor; uint8_t newSpreadingFactor;
// check allowed spreading factor values // check allowed spreading factor values
@ -96,7 +96,7 @@ uint8_t SX1277::setSpreadingFactor(uint8_t sf) {
} }
// set spreading factor and if successful, save the new setting // set spreading factor and if successful, save the new setting
uint8_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor); int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_sf = sf; SX127x::_sf = sf;
} }

4
src/modules/SX1277.h
View file

@ -10,8 +10,8 @@ class SX1277: public SX1278 {
SX1277(Module* mod); SX1277(Module* mod);
// configuration methods // configuration methods
uint8_t setFrequency(float freq); int16_t setFrequency(float freq);
uint8_t setSpreadingFactor(uint8_t sf); int16_t setSpreadingFactor(uint8_t sf);
}; };
#endif #endif

34
src/modules/SX1278.cpp
View file

@ -4,9 +4,9 @@ SX1278::SX1278(Module* mod) : SX127x(mod) {
} }
uint8_t SX1278::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) { int16_t SX1278::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) {
// execute common part // execute common part
uint8_t state = SX127x::begin(SX1278_CHIP_VERSION, syncWord); int16_t state = SX127x::begin(SX1278_CHIP_VERSION, syncWord);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -46,7 +46,7 @@ uint8_t SX1278::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
return(ERR_NONE); return(ERR_NONE);
} }
uint8_t SX1278::setFrequency(float freq) { int16_t SX1278::setFrequency(float freq) {
// check frequency range // check frequency range
if((freq < 137.0) || (freq > 525.0)) { if((freq < 137.0) || (freq > 525.0)) {
return(ERR_INVALID_FREQUENCY); return(ERR_INVALID_FREQUENCY);
@ -116,7 +116,7 @@ uint8_t SX1278::setFrequency(float freq) {
return(SX127x::setFrequencyRaw(freq)); return(SX127x::setFrequencyRaw(freq));
} }
uint8_t SX1278::setBandwidth(float bw) { int16_t SX1278::setBandwidth(float bw) {
uint8_t newBandwidth; uint8_t newBandwidth;
// check alowed bandwidth values // check alowed bandwidth values
@ -145,7 +145,7 @@ uint8_t SX1278::setBandwidth(float bw) {
} }
// set bandwidth and if successful, save the new setting // set bandwidth and if successful, save the new setting
uint8_t state = SX1278::setBandwidthRaw(newBandwidth); int16_t state = SX1278::setBandwidthRaw(newBandwidth);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_bw = bw; SX127x::_bw = bw;
} }
@ -153,7 +153,7 @@ uint8_t SX1278::setBandwidth(float bw) {
return(state); return(state);
} }
uint8_t SX1278::setSpreadingFactor(uint8_t sf) { int16_t SX1278::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor; uint8_t newSpreadingFactor;
// check allowed spreading factor values // check allowed spreading factor values
@ -184,7 +184,7 @@ uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
} }
// set spreading factor and if successful, save the new setting // set spreading factor and if successful, save the new setting
uint8_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor); int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_sf = sf; SX127x::_sf = sf;
} }
@ -192,7 +192,7 @@ uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
return(state); return(state);
} }
uint8_t SX1278::setCodingRate(uint8_t cr) { int16_t SX1278::setCodingRate(uint8_t cr) {
uint8_t newCodingRate; uint8_t newCodingRate;
// check allowed coding rate values // check allowed coding rate values
@ -214,7 +214,7 @@ uint8_t SX1278::setCodingRate(uint8_t cr) {
} }
// set coding rate and if successful, save the new setting // set coding rate and if successful, save the new setting
uint8_t state = SX1278::setCodingRateRaw(newCodingRate); int16_t state = SX1278::setCodingRateRaw(newCodingRate);
if(state == ERR_NONE) { if(state == ERR_NONE) {
SX127x::_cr = cr; SX127x::_cr = cr;
} }
@ -222,7 +222,7 @@ uint8_t SX1278::setCodingRate(uint8_t cr) {
return(state); return(state);
} }
uint8_t SX1278::setOutputPower(int8_t power) { int16_t SX1278::setOutputPower(int8_t power) {
if((power < -3) || (power > 20)) { if((power < -3) || (power > 20)) {
return(ERR_INVALID_OUTPUT_POWER); return(ERR_INVALID_OUTPUT_POWER);
} }
@ -230,7 +230,7 @@ uint8_t SX1278::setOutputPower(int8_t power) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
uint8_t state; int16_t state;
if(power < 13) { if(power < 13) {
// power is less than 12 dBm, enable PA on RFO // power is less than 12 dBm, enable PA on RFO
state = _mod->SPIsetRegValue(SX127X_REG_PA_CONFIG, SX127X_PA_SELECT_RFO, 7, 7); state = _mod->SPIsetRegValue(SX127X_REG_PA_CONFIG, SX127X_PA_SELECT_RFO, 7, 7);
@ -251,7 +251,7 @@ uint8_t SX1278::setOutputPower(int8_t power) {
return(state); return(state);
} }
uint8_t SX1278::setBandwidthRaw(uint8_t newBandwidth) { int16_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
@ -259,12 +259,12 @@ uint8_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newBandwidth, 7, 4)); return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newBandwidth, 7, 4));
} }
uint8_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) { int16_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
// write registers // write registers
uint8_t state = 0; int16_t state = 0;
if(newSpreadingFactor == SX127X_SF_6) { if(newSpreadingFactor == SX127X_SF_6) {
state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, SX1278_HEADER_IMPL_MODE, 0, 0); state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, SX1278_HEADER_IMPL_MODE, 0, 0);
state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE | SX1278_RX_CRC_MODE_OFF, 7, 2); state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE | SX1278_RX_CRC_MODE_OFF, 7, 2);
@ -280,7 +280,7 @@ uint8_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
return(state); return(state);
} }
uint8_t SX1278::setCodingRateRaw(uint8_t newCodingRate) { int16_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
// set mode to standby // set mode to standby
SX127x::standby(); SX127x::standby();
@ -288,9 +288,9 @@ uint8_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newCodingRate, 3, 1)); return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newCodingRate, 3, 1));
} }
uint8_t SX1278::config() { int16_t SX1278::config() {
// configure common registers // configure common registers
uint8_t state = SX127x::config(); int16_t state = SX127x::config();
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }

20
src/modules/SX1278.h
View file

@ -70,22 +70,22 @@ class SX1278: public SX127x {
SX1278(Module* mod); SX1278(Module* mod);
// basic methods // basic methods
uint8_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17); int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17);
// configuration methods // configuration methods
uint8_t setFrequency(float freq); int16_t setFrequency(float freq);
uint8_t setBandwidth(float bw); int16_t setBandwidth(float bw);
uint8_t setSpreadingFactor(uint8_t sf); int16_t setSpreadingFactor(uint8_t sf);
uint8_t setCodingRate(uint8_t cr); int16_t setCodingRate(uint8_t cr);
uint8_t setOutputPower(int8_t power); int16_t setOutputPower(int8_t power);
protected: protected:
uint8_t setBandwidthRaw(uint8_t newBandwidth); int16_t setBandwidthRaw(uint8_t newBandwidth);
uint8_t setSpreadingFactorRaw(uint8_t newSpreadingFactor); int16_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
uint8_t setCodingRateRaw(uint8_t newCodingRate); int16_t setCodingRateRaw(uint8_t newCodingRate);
private: private:
uint8_t config(); int16_t config();
}; };
#endif #endif

2
src/modules/SX1279.cpp
View file

@ -4,7 +4,7 @@ SX1279::SX1279(Module* mod) : SX1278(mod) {
} }
uint8_t SX1279::setFrequency(float freq) { int16_t SX1279::setFrequency(float freq) {
// check frequency range // check frequency range
if((freq < 137.0) || (freq > 960.0)) { if((freq < 137.0) || (freq > 960.0)) {
return(ERR_INVALID_FREQUENCY); return(ERR_INVALID_FREQUENCY);

2
src/modules/SX1279.h
View file

@ -10,7 +10,7 @@ class SX1279: public SX1278 {
SX1279(Module* mod); SX1279(Module* mod);
// configuration methods // configuration methods
uint8_t setFrequency(float freq); int16_t setFrequency(float freq);
}; };
#endif #endif

52
src/modules/SX127x.cpp
View file

@ -4,7 +4,7 @@ SX127x::SX127x(Module* mod) {
_mod = mod; _mod = mod;
} }
uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) { int16_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
// set module properties // set module properties
_mod->init(USE_SPI, INT_BOTH); _mod->init(USE_SPI, INT_BOTH);
@ -12,18 +12,20 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
uint8_t i = 0; uint8_t i = 0;
bool flagFound = false; bool flagFound = false;
while((i < 10) && !flagFound) { while((i < 10) && !flagFound) {
uint8_t version = _mod->SPIreadRegister(SX127X_REG_VERSION); int16_t version = _mod->SPIreadRegister(SX127X_REG_VERSION);
if(version == chipVersion) { if(version == chipVersion) {
flagFound = true; flagFound = true;
} else { } else {
#ifdef KITELIB_DEBUG #ifdef KITELIB_DEBUG
Serial.print("SX127x not found! ("); Serial.print(F("SX127x not found! ("));
Serial.print(i + 1); Serial.print(i + 1);
Serial.print(" of 10 tries) SX127X_REG_VERSION == "); Serial.print(F(" of 10 tries) SX127X_REG_VERSION == "));
char buffHex[5]; char buffHex[7];
sprintf(buffHex, "0x%02X", version); sprintf(buffHex, "0x%04X", version);
Serial.print(buffHex); Serial.print(buffHex);
Serial.print(F(", expected 0x00"));
Serial.print(chipVersion, HEX);
Serial.println(); Serial.println();
#endif #endif
delay(1000); delay(1000);
@ -39,7 +41,7 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
} }
// set LoRa sync word // set LoRa sync word
uint8_t state = SX127x::setSyncWord(syncWord); int16_t state = SX127x::setSyncWord(syncWord);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -47,7 +49,7 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
return(ERR_NONE); return(ERR_NONE);
} }
uint8_t SX127x::transmit(uint8_t* data, size_t len) { int16_t SX127x::transmit(uint8_t* data, size_t len) {
// check packet length // check packet length
if(len >= 256) { if(len >= 256) {
return(ERR_PACKET_TOO_LONG); return(ERR_PACKET_TOO_LONG);
@ -103,15 +105,15 @@ uint8_t SX127x::transmit(uint8_t* data, size_t len) {
return(ERR_NONE); return(ERR_NONE);
} }
uint8_t SX127x::transmit(const char* str) { int16_t SX127x::transmit(const char* str) {
return(SX127x::transmit((uint8_t*)str, strlen(str))); return(SX127x::transmit((uint8_t*)str, strlen(str)));
} }
uint8_t SX127x::transmit(String& str) { int16_t SX127x::transmit(String& str) {
return(SX127x::transmit(str.c_str())); return(SX127x::transmit(str.c_str()));
} }
uint8_t SX127x::receive(uint8_t* data, size_t len) { int16_t SX127x::receive(uint8_t* data, size_t len) {
// set mode to standby // set mode to standby
setMode(SX127X_STANDBY); setMode(SX127X_STANDBY);
@ -175,10 +177,10 @@ uint8_t SX127x::receive(uint8_t* data, size_t len) {
return(ERR_NONE); return(ERR_NONE);
} }
uint8_t SX127x::receive(String& str, size_t len) { int16_t SX127x::receive(String& str, size_t len) {
// create temporary array to store received data // create temporary array to store received data
char* data = new char[len]; char* data = new char[len];
uint8_t state = SX127x::receive((uint8_t*)data, len); int16_t state = SX127x::receive((uint8_t*)data, len);
// if packet was received successfully, copy data into String // if packet was received successfully, copy data into String
if(state == ERR_NONE) { if(state == ERR_NONE) {
@ -189,7 +191,7 @@ uint8_t SX127x::receive(String& str, size_t len) {
return(state); return(state);
} }
uint8_t SX127x::scanChannel() { int16_t SX127x::scanChannel() {
// set mode to standby // set mode to standby
setMode(SX127X_STANDBY); setMode(SX127X_STANDBY);
@ -214,17 +216,17 @@ uint8_t SX127x::scanChannel() {
return(CHANNEL_FREE); return(CHANNEL_FREE);
} }
uint8_t SX127x::sleep() { int16_t SX127x::sleep() {
// set mode to sleep // set mode to sleep
return(setMode(SX127X_SLEEP)); return(setMode(SX127X_SLEEP));
} }
uint8_t SX127x::standby() { int16_t SX127x::standby() {
// set mode to standby // set mode to standby
return(setMode(SX127X_STANDBY)); return(setMode(SX127X_STANDBY));
} }
uint8_t SX127x::setSyncWord(uint8_t syncWord) { int16_t SX127x::setSyncWord(uint8_t syncWord) {
// set mode to standby // set mode to standby
setMode(SX127X_STANDBY); setMode(SX127X_STANDBY);
@ -232,7 +234,7 @@ uint8_t SX127x::setSyncWord(uint8_t syncWord) {
return(_mod->SPIsetRegValue(SX127X_REG_SYNC_WORD, syncWord)); return(_mod->SPIsetRegValue(SX127X_REG_SYNC_WORD, syncWord));
} }
uint8_t SX127x::setFrequencyRaw(float newFreq) { int16_t SX127x::setFrequencyRaw(float newFreq) {
// set mode to standby // set mode to standby
setMode(SX127X_STANDBY); setMode(SX127X_STANDBY);
@ -241,16 +243,16 @@ uint8_t SX127x::setFrequencyRaw(float newFreq) {
uint32_t FRF = (newFreq * (base << 19)) / 32.0; uint32_t FRF = (newFreq * (base << 19)) / 32.0;
// write registers // write registers
uint8_t state = _mod->SPIsetRegValue(SX127X_REG_FRF_MSB, (FRF & 0xFF0000) >> 16); int16_t state = _mod->SPIsetRegValue(SX127X_REG_FRF_MSB, (FRF & 0xFF0000) >> 16);
state |= _mod->SPIsetRegValue(SX127X_REG_FRF_MID, (FRF & 0x00FF00) >> 8); state |= _mod->SPIsetRegValue(SX127X_REG_FRF_MID, (FRF & 0x00FF00) >> 8);
state |= _mod->SPIsetRegValue(SX127X_REG_FRF_LSB, FRF & 0x0000FF); state |= _mod->SPIsetRegValue(SX127X_REG_FRF_LSB, FRF & 0x0000FF);
return(state); return(state);
} }
uint8_t SX127x::config() { int16_t SX127x::config() {
// set mode to SLEEP // set mode to SLEEP
uint8_t state = setMode(SX127X_SLEEP); int16_t state = setMode(SX127X_SLEEP);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -261,6 +263,12 @@ uint8_t SX127x::config() {
return(state); return(state);
} }
// set mode to STANDBY
state = setMode(SX127X_STANDBY);
if(state != ERR_NONE) {
return(state);
}
// set overcurrent protection and LNA gain // set overcurrent protection and LNA gain
state = _mod->SPIsetRegValue(SX127X_REG_OCP, SX127X_OCP_ON | SX127X_OCP_TRIM, 5, 0); state = _mod->SPIsetRegValue(SX127X_REG_OCP, SX127X_OCP_ON | SX127X_OCP_TRIM, 5, 0);
state |= _mod->SPIsetRegValue(SX127X_REG_LNA, SX127X_LNA_GAIN_1 | SX127X_LNA_BOOST_ON); state |= _mod->SPIsetRegValue(SX127X_REG_LNA, SX127X_LNA_GAIN_1 | SX127X_LNA_BOOST_ON);
@ -286,7 +294,7 @@ uint8_t SX127x::config() {
return(state); return(state);
} }
uint8_t SX127x::setMode(uint8_t mode) { int16_t SX127x::setMode(uint8_t mode) {
_mod->SPIsetRegValue(SX127X_REG_OP_MODE, mode, 2, 0); _mod->SPIsetRegValue(SX127X_REG_OP_MODE, mode, 2, 0);
return(ERR_NONE); return(ERR_NONE);
} }

30
src/modules/SX127x.h
View file

@ -173,18 +173,18 @@ class SX127x {
float lastPacketSNR; float lastPacketSNR;
// basic methods // basic methods
uint8_t begin(uint8_t chipVersion, uint8_t syncWord); int16_t begin(uint8_t chipVersion, uint8_t syncWord);
uint8_t transmit(uint8_t* data, size_t len); int16_t transmit(uint8_t* data, size_t len);
uint8_t transmit(const char* str); int16_t transmit(const char* str);
uint8_t transmit(String& str); int16_t transmit(String& str);
uint8_t receive(uint8_t* data, size_t len); int16_t receive(uint8_t* data, size_t len);
uint8_t receive(String& str, size_t len = 0); int16_t receive(String& str, size_t len = 0);
uint8_t scanChannel(); int16_t scanChannel();
uint8_t sleep(); int16_t sleep();
uint8_t standby(); int16_t standby();
// configuration methods // configuration methods
uint8_t setSyncWord(uint8_t syncWord); int16_t setSyncWord(uint8_t syncWord);
protected: protected:
Module* _mod; Module* _mod;
@ -193,13 +193,13 @@ class SX127x {
uint8_t _sf; uint8_t _sf;
uint8_t _cr; uint8_t _cr;
uint8_t tx(char* data, uint8_t length); int16_t tx(char* data, uint8_t length);
uint8_t rxSingle(char* data, uint8_t* length); int16_t rxSingle(char* data, uint8_t* length);
uint8_t setFrequencyRaw(float newFreq); int16_t setFrequencyRaw(float newFreq);
uint8_t config(); int16_t config();
private: private:
uint8_t setMode(uint8_t mode); int16_t setMode(uint8_t mode);
void clearIRQFlags(); void clearIRQFlags();
}; };