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

74
examples/SX127x_Settings/SX127x_Settings.ino
View file

@ -1,16 +1,16 @@
/*
* KiteLib SX127x Settings Example
*
* This example shows how to change all the properties of LoRa transmission.
* KiteLib currently supports the following settings:
* - pins (SPI slave select, digital IO 0, digital IO 1)
* - carrier frequency
* - bandwidth
* - spreading factor
* - coding rate
* - sync word
* - output power during transmission
*/
KiteLib SX127x Settings Example
This example shows how to change all the properties of LoRa transmission.
KiteLib currently supports the following settings:
- pins (SPI slave select, digital IO 0, digital IO 1)
- carrier frequency
- bandwidth
- spreading factor
- coding rate
- sync word
- output power during transmission
*/
// include the library
#include <KiteLib.h>
@ -42,13 +42,13 @@ void setup() {
// coding rate: 7
// sync word: 0x12
// output power: 17 dBm
byte state = loraSX1278.begin();
if(state == ERR_NONE) {
int state = loraSX1278.begin();
if (state == ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code 0x"));
Serial.println(state, HEX);
while(true);
Serial.print(F("failed, code "));
Serial.println(state);
while (true);
}
// initialize the second LoRa instance with non-default settings
@ -61,12 +61,12 @@ void setup() {
// sync word: 0x13
// output power: 17 dBm
state = loraSX1276.begin(434.0, 7.8, 12, 8, 0x13);
if(state == ERR_NONE) {
if (state == ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code 0x"));
Serial.println(state, HEX);
while(true);
Serial.print(F("failed, code "));
Serial.println(state);
while (true);
}
// initialize the third LoRa instance with non-default settings
@ -83,12 +83,12 @@ void setup() {
// sync word: 0x14
// output power: 2 dBm
state = loraSX1272.begin(915.0, 500.0, 6, 5, 0x14, 2);
if(state == ERR_NONE) {
if (state == ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code 0x"));
Serial.println(state, HEX);
while(true);
Serial.print(F("failed, code "));
Serial.println(state);
while (true);
}
// you can also change the settings at runtime
@ -98,40 +98,40 @@ void setup() {
// see https://github.com/jgromes/LoRaLib/wiki/Supported-LoRa-modules
// 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!");
while(true);
while (true);
}
// 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!");
while(true);
while (true);
}
// 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!");
while(true);
while (true);
}
// 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!");
while(true);
while (true);
}
// set LoRa sync word to 0x14
// 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!");
while(true);
while (true);
}
// 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!");
while(true);
while (true);
}
Serial.println("All settings succesfully changed!");

50
examples/SX127x_Transmit/SX127x_Transmit.ino
View file

@ -1,19 +1,19 @@
/*
* KiteLib SX127x Transmit Example
*
* This example transmits packets using SX1278 LoRa radio module.
* Each packet contains up to 256 bytes of data, in the form of:
* - Arduino String
* - null-terminated char array (C-string)
* - arbitrary binary data (byte array)
*
* Other modules from SX127x family can also be used.
* SX1272 lora = Kite.ModuleA;
* SX1273 lora = Kite.ModuleA;
* SX1276 lora = Kite.ModuleA;
* SX1277 lora = Kite.ModuleA;
* SX1279 lora = Kite.ModuleA;
*/
KiteLib SX127x Transmit Example
This example transmits packets using SX1278 LoRa radio module.
Each packet contains up to 256 bytes of data, in the form of:
- Arduino String
- null-terminated char array (C-string)
- arbitrary binary data (byte array)
Other modules from SX127x family can also be used.
SX1272 lora = Kite.ModuleA;
SX1273 lora = Kite.ModuleA;
SX1276 lora = Kite.ModuleA;
SX1277 lora = Kite.ModuleA;
SX1279 lora = Kite.ModuleA;
*/
// include the library
#include <KiteLib.h>
@ -32,13 +32,13 @@ void setup() {
// coding rate: 7
// sync word: 0x12
// output power: 17 dBm
byte state = lora.begin();
if(state == ERR_NONE) {
int state = lora.begin();
if (state == ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code 0x"));
Serial.println(state, HEX);
while(true);
Serial.print(F("failed, code "));
Serial.println(state);
while (true);
}
}
@ -46,23 +46,23 @@ void loop() {
Serial.print(F("[SX1278] Transmitting packet ... "));
// 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
/*
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
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
Serial.println(" too long!");
} else if(state == ERR_TX_TIMEOUT) {
} else if (state == ERR_TX_TIMEOUT) {
// timeout occured while transmitting packet
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
uint8_t state = SX127x::begin(SX1272_CHIP_VERSION, syncWord);
int16_t state = SX127x::begin(SX1272_CHIP_VERSION, syncWord);
if(state != ERR_NONE) {
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);
}
uint8_t SX1272::setFrequency(float freq) {
int16_t SX1272::setFrequency(float freq) {
// check frequency range
if((freq < 860.0) || (freq > 1020.0)) {
return(ERR_INVALID_FREQUENCY);
@ -56,7 +56,7 @@ uint8_t SX1272::setFrequency(float freq) {
return(SX127x::setFrequencyRaw(freq));
}
uint8_t SX1272::setBandwidth(float bw) {
int16_t SX1272::setBandwidth(float bw) {
uint8_t newBandwidth;
// check alowed bandwidth values
@ -71,7 +71,7 @@ uint8_t SX1272::setBandwidth(float bw) {
}
// 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) {
SX127x::_bw = bw;
}
@ -79,7 +79,7 @@ uint8_t SX1272::setBandwidth(float bw) {
return(state);
}
uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
int16_t SX1272::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor;
// 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
uint8_t state = SX1272::setSpreadingFactorRaw(newSpreadingFactor);
int16_t state = SX1272::setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) {
SX127x::_sf = sf;
}
@ -118,7 +118,7 @@ uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
return(state);
}
uint8_t SX1272::setCodingRate(uint8_t cr) {
int16_t SX1272::setCodingRate(uint8_t cr) {
uint8_t newCodingRate;
// 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
uint8_t state = SX1272::setCodingRateRaw(newCodingRate);
int16_t state = SX1272::setCodingRateRaw(newCodingRate);
if(state == ERR_NONE) {
SX127x::_cr = cr;
}
@ -148,7 +148,7 @@ uint8_t SX1272::setCodingRate(uint8_t cr) {
return(state);
}
uint8_t SX1272::setOutputPower(int8_t power) {
int16_t SX1272::setOutputPower(int8_t power) {
// check allowed power range
if((power < -1) || (power > 20)) {
return(ERR_INVALID_OUTPUT_POWER);
@ -157,7 +157,7 @@ uint8_t SX1272::setOutputPower(int8_t power) {
// set mode to standby
SX127x::standby();
uint8_t state;
int16_t state;
if(power < 15) {
// power is less than 15 dBm, enable PA0 on RFIO
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);
}
uint8_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
int16_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
// set mode to 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));
}
uint8_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
int16_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
// set mode to standby
SX127x::standby();
// write registers
uint8_t state = 0;
int16_t state = 0;
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_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE, 7, 3);
@ -207,7 +207,7 @@ uint8_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
return(state);
}
uint8_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
int16_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
// set mode to 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));
}
uint8_t SX1272::config() {
int16_t SX1272::config() {
// configure common registers
uint8_t state = SX127x::config();
int16_t state = SX127x::config();
if(state != ERR_NONE) {
return(state);
}

20
src/modules/SX1272.h
View file

@ -52,22 +52,22 @@ class SX1272: public SX127x {
SX1272(Module* mod);
// 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
uint8_t setFrequency(float freq);
uint8_t setBandwidth(float bw);
uint8_t setSpreadingFactor(uint8_t sf);
uint8_t setCodingRate(uint8_t cr);
uint8_t setOutputPower(int8_t power);
int16_t setFrequency(float freq);
int16_t setBandwidth(float bw);
int16_t setSpreadingFactor(uint8_t sf);
int16_t setCodingRate(uint8_t cr);
int16_t setOutputPower(int8_t power);
protected:
uint8_t setBandwidthRaw(uint8_t newBandwidth);
uint8_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
uint8_t setCodingRateRaw(uint8_t newCodingRate);
int16_t setBandwidthRaw(uint8_t newBandwidth);
int16_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
int16_t setCodingRateRaw(uint8_t newCodingRate);
private:
uint8_t config();
int16_t config();
};
#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;
// 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
uint8_t state = setSpreadingFactorRaw(newSpreadingFactor);
int16_t state = setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) {
SX127x::_sf = sf;
}

2
src/modules/SX1273.h
View file

@ -10,7 +10,7 @@ class SX1273: public SX1272 {
SX1273(Module* mod);
// configuration methods
uint8_t setSpreadingFactor(uint8_t sf);
int16_t setSpreadingFactor(uint8_t sf);
};
#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
if((freq < 137.0) || (freq > 1020.0)) {
return(ERR_INVALID_FREQUENCY);

2
src/modules/SX1276.h
View file

@ -10,7 +10,7 @@ class SX1276: public SX1278 {
SX1276(Module* mod);
// configuration methods
uint8_t setFrequency(float freq);
int16_t setFrequency(float freq);
};
#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
if((freq < 137.0) || (freq > 1020.0)) {
return(ERR_INVALID_FREQUENCY);
@ -74,7 +74,7 @@ uint8_t SX1277::setFrequency(float freq) {
return(SX127x::setFrequencyRaw(freq));
}
uint8_t SX1277::setSpreadingFactor(uint8_t sf) {
int16_t SX1277::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor;
// 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
uint8_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) {
SX127x::_sf = sf;
}

4
src/modules/SX1277.h
View file

@ -10,8 +10,8 @@ class SX1277: public SX1278 {
SX1277(Module* mod);
// configuration methods
uint8_t setFrequency(float freq);
uint8_t setSpreadingFactor(uint8_t sf);
int16_t setFrequency(float freq);
int16_t setSpreadingFactor(uint8_t sf);
};
#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
uint8_t state = SX127x::begin(SX1278_CHIP_VERSION, syncWord);
int16_t state = SX127x::begin(SX1278_CHIP_VERSION, syncWord);
if(state != ERR_NONE) {
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);
}
uint8_t SX1278::setFrequency(float freq) {
int16_t SX1278::setFrequency(float freq) {
// check frequency range
if((freq < 137.0) || (freq > 525.0)) {
return(ERR_INVALID_FREQUENCY);
@ -116,7 +116,7 @@ uint8_t SX1278::setFrequency(float freq) {
return(SX127x::setFrequencyRaw(freq));
}
uint8_t SX1278::setBandwidth(float bw) {
int16_t SX1278::setBandwidth(float bw) {
uint8_t newBandwidth;
// check alowed bandwidth values
@ -145,7 +145,7 @@ uint8_t SX1278::setBandwidth(float bw) {
}
// 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) {
SX127x::_bw = bw;
}
@ -153,7 +153,7 @@ uint8_t SX1278::setBandwidth(float bw) {
return(state);
}
uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
int16_t SX1278::setSpreadingFactor(uint8_t sf) {
uint8_t newSpreadingFactor;
// 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
uint8_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
if(state == ERR_NONE) {
SX127x::_sf = sf;
}
@ -192,7 +192,7 @@ uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
return(state);
}
uint8_t SX1278::setCodingRate(uint8_t cr) {
int16_t SX1278::setCodingRate(uint8_t cr) {
uint8_t newCodingRate;
// 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
uint8_t state = SX1278::setCodingRateRaw(newCodingRate);
int16_t state = SX1278::setCodingRateRaw(newCodingRate);
if(state == ERR_NONE) {
SX127x::_cr = cr;
}
@ -222,7 +222,7 @@ uint8_t SX1278::setCodingRate(uint8_t cr) {
return(state);
}
uint8_t SX1278::setOutputPower(int8_t power) {
int16_t SX1278::setOutputPower(int8_t power) {
if((power < -3) || (power > 20)) {
return(ERR_INVALID_OUTPUT_POWER);
}
@ -230,7 +230,7 @@ uint8_t SX1278::setOutputPower(int8_t power) {
// set mode to standby
SX127x::standby();
uint8_t state;
int16_t state;
if(power < 13) {
// power is less than 12 dBm, enable PA on RFO
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);
}
uint8_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
int16_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
// set mode to 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));
}
uint8_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
int16_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
// set mode to standby
SX127x::standby();
// write registers
uint8_t state = 0;
int16_t state = 0;
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_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);
}
uint8_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
int16_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
// set mode to 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));
}
uint8_t SX1278::config() {
int16_t SX1278::config() {
// configure common registers
uint8_t state = SX127x::config();
int16_t state = SX127x::config();
if(state != ERR_NONE) {
return(state);
}

20
src/modules/SX1278.h
View file

@ -70,22 +70,22 @@ class SX1278: public SX127x {
SX1278(Module* mod);
// 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
uint8_t setFrequency(float freq);
uint8_t setBandwidth(float bw);
uint8_t setSpreadingFactor(uint8_t sf);
uint8_t setCodingRate(uint8_t cr);
uint8_t setOutputPower(int8_t power);
int16_t setFrequency(float freq);
int16_t setBandwidth(float bw);
int16_t setSpreadingFactor(uint8_t sf);
int16_t setCodingRate(uint8_t cr);
int16_t setOutputPower(int8_t power);
protected:
uint8_t setBandwidthRaw(uint8_t newBandwidth);
uint8_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
uint8_t setCodingRateRaw(uint8_t newCodingRate);
int16_t setBandwidthRaw(uint8_t newBandwidth);
int16_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
int16_t setCodingRateRaw(uint8_t newCodingRate);
private:
uint8_t config();
int16_t config();
};
#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
if((freq < 137.0) || (freq > 960.0)) {
return(ERR_INVALID_FREQUENCY);

2
src/modules/SX1279.h
View file

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

52
src/modules/SX127x.cpp
View file

@ -4,7 +4,7 @@ SX127x::SX127x(Module* 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
_mod->init(USE_SPI, INT_BOTH);
@ -12,18 +12,20 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
uint8_t i = 0;
bool flagFound = false;
while((i < 10) && !flagFound) {
uint8_t version = _mod->SPIreadRegister(SX127X_REG_VERSION);
int16_t version = _mod->SPIreadRegister(SX127X_REG_VERSION);
if(version == chipVersion) {
flagFound = true;
} else {
#ifdef KITELIB_DEBUG
Serial.print("SX127x not found! (");
Serial.print(F("SX127x not found! ("));
Serial.print(i + 1);
Serial.print(" of 10 tries) SX127X_REG_VERSION == ");
Serial.print(F(" of 10 tries) SX127X_REG_VERSION == "));
char buffHex[5];
sprintf(buffHex, "0x%02X", version);
char buffHex[7];
sprintf(buffHex, "0x%04X", version);
Serial.print(buffHex);
Serial.print(F(", expected 0x00"));
Serial.print(chipVersion, HEX);
Serial.println();
#endif
delay(1000);
@ -39,7 +41,7 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
}
// set LoRa sync word
uint8_t state = SX127x::setSyncWord(syncWord);
int16_t state = SX127x::setSyncWord(syncWord);
if(state != ERR_NONE) {
return(state);
}
@ -47,7 +49,7 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
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
if(len >= 256) {
return(ERR_PACKET_TOO_LONG);
@ -103,15 +105,15 @@ uint8_t SX127x::transmit(uint8_t* data, size_t len) {
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)));
}
uint8_t SX127x::transmit(String& str) {
int16_t SX127x::transmit(String& 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
setMode(SX127X_STANDBY);
@ -175,10 +177,10 @@ uint8_t SX127x::receive(uint8_t* data, size_t len) {
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
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(state == ERR_NONE) {
@ -189,7 +191,7 @@ uint8_t SX127x::receive(String& str, size_t len) {
return(state);
}
uint8_t SX127x::scanChannel() {
int16_t SX127x::scanChannel() {
// set mode to standby
setMode(SX127X_STANDBY);
@ -214,17 +216,17 @@ uint8_t SX127x::scanChannel() {
return(CHANNEL_FREE);
}
uint8_t SX127x::sleep() {
int16_t SX127x::sleep() {
// set mode to sleep
return(setMode(SX127X_SLEEP));
}
uint8_t SX127x::standby() {
int16_t SX127x::standby() {
// set mode to standby
return(setMode(SX127X_STANDBY));
}
uint8_t SX127x::setSyncWord(uint8_t syncWord) {
int16_t SX127x::setSyncWord(uint8_t syncWord) {
// set mode to standby
setMode(SX127X_STANDBY);
@ -232,7 +234,7 @@ uint8_t SX127x::setSyncWord(uint8_t 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
setMode(SX127X_STANDBY);
@ -241,16 +243,16 @@ uint8_t SX127x::setFrequencyRaw(float newFreq) {
uint32_t FRF = (newFreq * (base << 19)) / 32.0;
// 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_LSB, FRF & 0x0000FF);
return(state);
}
uint8_t SX127x::config() {
int16_t SX127x::config() {
// set mode to SLEEP
uint8_t state = setMode(SX127X_SLEEP);
int16_t state = setMode(SX127X_SLEEP);
if(state != ERR_NONE) {
return(state);
}
@ -261,6 +263,12 @@ uint8_t SX127x::config() {
return(state);
}
// set mode to STANDBY
state = setMode(SX127X_STANDBY);
if(state != ERR_NONE) {
return(state);
}
// 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_LNA, SX127X_LNA_GAIN_1 | SX127X_LNA_BOOST_ON);
@ -286,7 +294,7 @@ uint8_t SX127x::config() {
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);
return(ERR_NONE);
}

30
src/modules/SX127x.h
View file

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