mirror
/
RadioLib
kopia lustrzana https://github.com/jgromes/RadioLib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Sync with LoRaLib v3.0.0 

Packet class was removed
pull/1/head
Jan Gromeš 2018-07-12 20:13:03 +02:00
rodzic 719f31b0c1
commit de42395dda
18 zmienionych plików z 131 dodań i 402 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

28
examples/RF69_Receive/RF69_Receive.ino
Wyświetl plik

@ -10,9 +10,6 @@
// RF69 module is in slot A on the shield
RF69 rf = Kite.ModuleA;
// create empty instance of Packet class
Packet pack;
void setup() {
Serial.begin(9600);
@ -36,28 +33,23 @@ void setup() {
void loop() {
Serial.print(F("[RF69] Waiting for incoming transmission ... "));
// wait for single packet
byte state = rf.receive(pack);
// you can receive data as an Arduino String
String str;
byte state = rf.receive(str);
// you can also receive data as byte array
/*
byte byteArr[8];
byte state = rf.receive(byteArr, 8);
*/
if(state == ERR_NONE) {
// packet was successfully received
Serial.println(F("success!"));
// print the source of the packet
Serial.print(F("[RF69] Source:\t\t"));
Serial.println(pack.getSourceStr());
// print the destination of the packet
Serial.print(F("[RF69] Destination:\t"));
Serial.println(pack.getDestinationStr());
// print the length of the packet
Serial.print(F("[RF69] Length:\t\t"));
Serial.println(pack.length);
// print the data of the packet
Serial.print(F("[RF69] Data:\t\t"));
Serial.println(pack.data);
Serial.println(str);
} else if(state == ERR_RX_TIMEOUT) {
// timeout occurred while waiting for a packet

14
examples/RF69_Transmit/RF69_Transmit.ino
Wyświetl plik

@ -10,10 +10,6 @@
// RF69 module is in slot A on the shield
RF69 rf = Kite.ModuleA;
// create instance of Packet class with destination address
// "01:23:45:67:89:AB:CD:EF" and data "Hello World !"
Packet pack("01:23:45:67:89:AB:CD:EF", "Hello World!");
void setup() {
Serial.begin(9600);
@ -37,8 +33,14 @@ void setup() {
void loop() {
Serial.print(F("[RF69] Transmitting packet ... "));
// start transmitting the packet
byte state = rf.transmit(pack);
// you can transmit C-string or Arduino string up to 256 characters long
byte state = rf.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 = rf.transmit(byteArr, 8);
*/
if(state == ERR_NONE) {
// the packet was successfully transmitted

1
examples/SX127x_ChannelActivityDetection/SX127x_ChannelActivityDetection.ino
Wyświetl plik

@ -31,7 +31,6 @@ void setup() {
// coding rate: 7
// sync word: 0x12
// output power: 17 dBm
// node address in EEPROM starts at: 0
byte state = lora.begin();
if(state == ERR_NONE) {
Serial.println(F("success!"));

40
examples/SX127x_Receive/SX127x_Receive.ino
Wyświetl plik

@ -1,7 +1,14 @@
/*
* KiteLib SX127x Receive Example
*
* This example receives packets using SX1278 LoRa radio module.
* 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;
@ -17,9 +24,6 @@
// SX1278 module is in slot A on the shield
SX1278 lora = Kite.ModuleA;
// create empty instance of Packet class
Packet pack;
void setup() {
Serial.begin(9600);
@ -31,7 +35,6 @@ void setup() {
// coding rate: 7
// sync word: 0x12
// output power: 17 dBm
// node address in EEPROM starts at: 0
byte state = lora.begin();
if(state == ERR_NONE) {
Serial.println(F("success!"));
@ -45,28 +48,23 @@ void setup() {
void loop() {
Serial.print(F("[SX1278] Waiting for incoming transmission ... "));
// wait for single packet
byte state = lora.receive(pack);
// you can receive data as an Arduino String
String str;
byte state = lora.receive(str);
// you can also receive data as byte array
/*
byte byteArr[8];
byte state = lora.receive(byteArr, 8);
*/
if(state == ERR_NONE) {
// packet was successfully received
Serial.println(F("success!"));
// print the source of the packet
Serial.print(F("[SX1278] Source:\t\t"));
Serial.println(pack.getSourceStr());
// print the destination of the packet
Serial.print(F("[SX1278] Destination:\t"));
Serial.println(pack.getDestinationStr());
// print the length of the packet
Serial.print(F("[SX1278] Length:\t\t"));
Serial.println(pack.length);
// print the data of the packet
Serial.print(F("[SX1278] Data:\t\t"));
Serial.println(pack.data);
Serial.print("[SX1278] Data:\t\t");
Serial.println(str);
//print the measured data rate
Serial.print("[SX1278] Datarate:\t");

3
examples/SX127x_Settings/SX127x_Settings.ino
Wyświetl plik

@ -42,7 +42,6 @@ void setup() {
// coding rate: 7
// sync word: 0x12
// output power: 17 dBm
// node address in EEPROM starts at: 0
byte state = loraSX1278.begin();
if(state == ERR_NONE) {
Serial.println(F("success!"));
@ -61,7 +60,6 @@ void setup() {
// coding rate: 8
// sync word: 0x13
// output power: 17 dBm
// node address in EEPROM starts at: 0
state = loraSX1276.begin(434.0, 7.8, 12, 8, 0x13);
if(state == ERR_NONE) {
Serial.println(F("success!"));
@ -84,7 +82,6 @@ void setup() {
// coding rate: 5
// sync word: 0x14
// output power: 2 dBm
// node address in EEPROM starts at: 0
state = loraSX1272.begin(915.0, 500.0, 6, 5, 0x14, 2);
if(state == ERR_NONE) {
Serial.println(F("success!"));

19
examples/SX127x_Transmit/SX127x_Transmit.ino
Wyświetl plik

@ -2,6 +2,10 @@
* 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;
@ -17,10 +21,6 @@
// SX1278 module is in slot A on the shield
SX1278 lora = Kite.ModuleA;
// create instance of Packet class with destination address
// "01:23:45:67:89:AB:CD:EF" and data "Hello World !"
Packet pack("01:23:45:67:89:AB:CD:EF", "Hello World!");
void setup() {
Serial.begin(9600);
@ -32,7 +32,6 @@ void setup() {
// coding rate: 7
// sync word: 0x12
// output power: 17 dBm
// node address in EEPROM starts at: 0
byte state = lora.begin();
if(state == ERR_NONE) {
Serial.println(F("success!"));
@ -46,8 +45,14 @@ void setup() {
void loop() {
Serial.print(F("[SX1278] Transmitting packet ... "));
// start transmitting the packet
byte state = lora.transmit(pack);
// you can transmit C-string or Arduino string up to 256 characters long
byte 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);
*/
if(state == ERR_NONE) {
// the packet was successfully transmitted

13
keywords.txt
Wyświetl plik

@ -8,7 +8,6 @@
KiteLib KEYWORD1
Kite KEYWORD1
Packet KEYWORD1
Module KEYWORD1
ESP8266 KEYWORD1
@ -33,18 +32,6 @@ HTTPClient KEYWORD1
ModuleA KEYWORD2
ModuleB KEYWORD2
# Packet
source KEYWORD2
destination KEYWORD2
data KEYWORD2
length KEYWORD2
getSourceStr KEYWORD2
getDestinationStr KEYWORD2
setSourceStr KEYWORD2
setDestinationStr KEYWORD2
copyInto KEYWORD2
setPacketData KEYWORD2
# SX1272/73/76/77/78/79 + RF69
dataRate KEYWORD2
lastPacketRSSI KEYWORD2

181
src/Packet.cpp
Wyświetl plik

@ -1,181 +0,0 @@
#include "Packet.h"
Packet::Packet(void) {
uint8_t src[8] = {0, 0, 0, 0, 0, 0, 0, 0};
getLoRaAddress(src);
uint8_t dest[8] = {0, 0, 0, 0, 0, 0, 0, 0};
uint8_t* dat;
uint8_t len = 0;
init(src, dest, dat, len);
}
Packet::Packet(const char* dest, const char* dat) {
uint8_t src[8] = {0, 0, 0, 0, 0, 0, 0, 0};
getLoRaAddress(src);
uint8_t destTmp[8];
for(uint8_t i = 0; i < 8; i++) {
char str[] = {dest[3*i], dest[3*i + 1]};
destTmp[i] = strtoul(str, NULL, 16);
}
init(src, destTmp, dat);
}
Packet::Packet(uint8_t* dest, const char* dat) {
uint8_t src[8] = {0, 0, 0, 0, 0, 0, 0, 0};
getLoRaAddress(src);
init(src, dest, dat);
}
Packet::Packet(const char* src, const char* dest, const char* dat) {
uint8_t srcTmp[8];
for(uint8_t i = 0; i < 8; i++) {
char str[] = {src[3*i], src[3*i + 1]};
srcTmp[i] = strtoul(str, NULL, 16);
}
uint8_t destTmp[8];
for(uint8_t i = 0; i < 8; i++) {
char str[] = {dest[3*i], dest[3*i + 1]};
destTmp[i] = strtoul(str, NULL, 16);
}
init(srcTmp, destTmp, dat);
}
Packet::Packet(uint8_t* src, uint8_t* dest, const char* dat) {
init(src, dest, dat);
}
Packet::Packet(const char* dest, uint8_t* dat, uint8_t len) {
uint8_t src[8] = {0, 0, 0, 0, 0, 0, 0, 0};
getLoRaAddress(src);
uint8_t destTmp[8];
for(uint8_t i = 0; i < 8; i++) {
char str[] = {dest[3*i], dest[3*i + 1]};
destTmp[i] = strtoul(str, NULL, 16);
}
init(src, destTmp, dat, len);
}
Packet::Packet(uint8_t* dest, uint8_t* dat, uint8_t len) {
uint8_t src[8] = {0, 0, 0, 0, 0, 0, 0, 0};
getLoRaAddress(src);
init(src, dest, dat, len);
}
Packet::Packet(const char* src, const char* dest, uint8_t* dat, uint8_t len) {
uint8_t srcTmp[8];
for(uint8_t i = 0; i < 8; i++) {
char str[] = {src[3*i], src[3*i + 1]};
srcTmp[i] = strtoul(str, NULL, 16);
}
uint8_t destTmp[8];
for(uint8_t i = 0; i < 8; i++) {
char str[] = {dest[3*i], dest[3*i + 1]};
destTmp[i] = strtoul(str, NULL, 16);
}
init(srcTmp, destTmp, dat, len);
}
Packet::Packet(uint8_t* src, uint8_t* dest, uint8_t* dat, uint8_t len) {
init(src, dest, dat, len);
}
void Packet::init(uint8_t* src, uint8_t* dest, const char* dat) {
init(src, dest, (uint8_t*)dat, strlen(dat));
}
void Packet::init(uint8_t* src, uint8_t* dest, uint8_t* dat, uint8_t len) {
memcpy(source, src, 8);
memcpy(destination, dest, 8);
length = len + 16;
data = new char[len + 1];
memcpy(data, dat, len + 1);
}
String Packet::getSourceStr() {
char charArray[24];
for(uint8_t i = 0; i < 8; i++) {
sprintf(charArray + 3*i, "%02X", source[i]);
charArray[3*i+2] = ':';
}
charArray[23] = '\0';
String str(charArray);
return(str);
}
String Packet::getDestinationStr() {
char charArray[24];
for(uint8_t i = 0; i < 8; i++) {
sprintf(charArray + 3*i, "%02X", destination[i]);
charArray[3*i+2] = ':';
}
charArray[23] = '\0';
String str(charArray);
return(str);
}
void Packet::setSourceStr(const char* src) {
for(uint8_t i = 0; i < 8; i++) {
char str[] = {src[3*i], src[3*i + 1]};
source[i] = strtoul(str, NULL, 16);
}
}
void Packet::setDestinationStr(const char* dest) {
for(uint8_t i = 0; i < 8; i++) {
char str[] = {dest[3*i], dest[3*i + 1]};
destination[i] = strtoul(str, NULL, 16);
}
}
void Packet::copyInto(Packet& pack) {
memcpy(pack.source, source, 8);
memcpy(pack.destination, destination, 8);
strcpy(pack.data, data);
}
void Packet::setPacketData(char* charArray) {
char* newData = new char[strlen(charArray)];
length = strlen(charArray) + 16;
strcpy(newData, charArray);
delete[] data;
data = newData;
}
void Packet::setPacketData(String str) {
setPacketData((char*)str.c_str());
}
void Packet::setPacketData(float f, uint8_t decimals) {
int i = f;
float res = f - i;
if (res == 0) {
char charArray[16];
itoa(i, charArray, 10);
setPacketData(charArray);
} else {
String floatString = String(f, decimals);
setPacketData(floatString);
}
}
void Packet::getLoRaAddress(uint8_t* addr) {
for(uint8_t i = 0; i < 8; i++) {
addr[i] = EEPROM.read(i);
}
}

48
src/Packet.h
Wyświetl plik

@ -1,48 +0,0 @@
#ifndef _KITELIB_PACKET_H
#define _KITELIB_PACKET_H
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <EEPROM.h>
class Packet {
public:
Packet(void);
Packet(const char* dest, const char* dat);
Packet(uint8_t* dest, const char* dat);
Packet(const char* src, const char* dest, const char* dat);
Packet(uint8_t* src, uint8_t* dest, const char* dat);
Packet(const char* dest, uint8_t* dat, uint8_t len);
Packet(uint8_t* dest, uint8_t* dat, uint8_t len);
Packet(const char* src, const char* dest, uint8_t* dat, uint8_t len);
Packet(uint8_t* src, uint8_t* dest, uint8_t* dat, uint8_t len);
uint8_t source[8] = {0, 0, 0, 0, 0, 0, 0, 0};
uint8_t destination[8] = {0, 0, 0, 0, 0, 0, 0, 0};
char* data;
uint8_t length = 0;
String getSourceStr();
String getDestinationStr();
void setSourceStr(const char* src);
void setDestinationStr(const char* dest);
void copyInto(Packet& pack);
void setPacketData(char* charArray);
void setPacketData(String str);
void setPacketData(float f, uint8_t decimals = 3);
private:
void init(uint8_t* src, uint8_t* dest, const char* dat);
void init(uint8_t* src, uint8_t* dest, uint8_t* dat, uint8_t len);
void getLoRaAddress(uint8_t* addr);
};
#endif

48
src/modules/RF69.cpp
Wyświetl plik

@ -75,9 +75,9 @@ uint8_t RF69::begin(float freq, float br, float rxBw, float freqDev, int8_t powe
return(ERR_NONE);
}
uint8_t RF69::transmit(Packet& pack) {
uint8_t RF69::transmit(uint8_t* data, size_t len) {
// check packet length
if(pack.length >= 256) {
if(len >= 256) {
return(ERR_PACKET_TOO_LONG);
}
@ -91,12 +91,10 @@ uint8_t RF69::transmit(Packet& pack) {
clearIRQFlags();
// set packet length
_mod->SPIwriteRegister(RF69_REG_FIFO, pack.length);
_mod->SPIwriteRegister(RF69_REG_FIFO, len);
// write packet to FIFO
_mod->SPIwriteRegisterBurstStr(RF69_REG_FIFO, (char*)pack.source, 8);
_mod->SPIwriteRegisterBurstStr(RF69_REG_FIFO, (char*)pack.destination, 8);
_mod->SPIwriteRegisterBurstStr(RF69_REG_FIFO, pack.data, pack.length - 16);
_mod->SPIwriteRegisterBurst(RF69_REG_FIFO, data, len);
// set mode to transmit
setMode(RF69_TX);
@ -112,7 +110,15 @@ uint8_t RF69::transmit(Packet& pack) {
return(ERR_NONE);
}
uint8_t RF69::receive(Packet& pack) {
uint8_t RF69::transmit(const char* str) {
return(RF69::transmit((uint8_t*)str, strlen(str)));
}
uint8_t RF69::transmit(String& str) {
return(RF69::transmit(str.c_str()));
}
uint8_t RF69::receive(uint8_t* data, size_t len) {
// set mode to standby
setMode(RF69_STANDBY);
@ -135,18 +141,11 @@ uint8_t RF69::receive(Packet& pack) {
}
}
// read packet length
pack.length = _mod->SPIreadRegister(RF69_REG_FIFO);
// read packet addresses
_mod->SPIreadRegisterBurstStr(RF69_REG_FIFO, 8, (char*)pack.source);
_mod->SPIreadRegisterBurstStr(RF69_REG_FIFO, 8, (char*)pack.destination);
// get packet length
size_t length = _mod->SPIreadRegister(RF69_REG_FIFO);
// read packet data
delete[] pack.data;
pack.data = new char[pack.length - 15];
_mod->SPIreadRegisterBurstStr(RF69_REG_FIFO, pack.length - 16, pack.data);
pack.data[pack.length - 16] = 0;
_mod->SPIreadRegisterBurst(RF69_REG_FIFO, length, data);
// clear interrupt flags
clearIRQFlags();
@ -154,6 +153,21 @@ uint8_t RF69::receive(Packet& pack) {
return(ERR_NONE);
}
uint8_t RF69::receive(String& str, size_t len) {
// create temporary array to store received data
char* data = new char[0];
uint8_t state = RF69::receive((uint8_t*)data, len);
// if packet was received successfully, copy data into String
if(state == ERR_NONE) {
data[strlen(data) - 1] = 0;
str = String(data);
}
delete[] data;
return(state);
}
uint8_t RF69::sleep() {
// set module to sleep
return(setMode(RF69_SLEEP));

10
src/modules/RF69.h
Wyświetl plik

@ -1,11 +1,8 @@
#ifndef _KITELIB_RF69_H
#define _KITELIB_RF69_H
#include <EEPROM.h>
#include "TypeDef.h"
#include "Module.h"
#include "Packet.h"
//RF69 register map
#define RF69_REG_FIFO 0x00
@ -423,8 +420,11 @@ class RF69 {
// basic methods
uint8_t begin(float freq = 434.0, float br = 48.0, float rxBw = 125.0, float freqDev = 50.0, int8_t power = 13);
uint8_t transmit(Packet& pack);
uint8_t receive(Packet& pack);
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 sleep();
uint8_t standby();

4
src/modules/SX1272.cpp
Wyświetl plik

@ -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, uint16_t addrEeprom) {
uint8_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(syncWord, addrEeprom);
uint8_t state = SX127x::begin(syncWord);
if(state != ERR_NONE) {
return(state);
}

2
src/modules/SX1272.h
Wyświetl plik

@ -49,7 +49,7 @@ 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, uint16_t addrEeprom = 0);
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);
// configuration methods
uint8_t setFrequency(float freq);

4
src/modules/SX1278.cpp
Wyświetl plik

@ -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, uint16_t addrEeprom) {
uint8_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(syncWord, addrEeprom);
uint8_t state = SX127x::begin(syncWord);
if(state != ERR_NONE) {
return(state);
}

2
src/modules/SX1278.h
Wyświetl plik

@ -67,7 +67,7 @@ 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, uint16_t addrEeprom = 0);
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);
// configuration methods
uint8_t setFrequency(float freq);

99
src/modules/SX127x.cpp
Wyświetl plik

@ -4,46 +4,7 @@ SX127x::SX127x(Module* mod) {
_mod = mod;
}
uint8_t SX127x::begin(uint8_t syncWord, uint16_t addrEeprom) {
// ESP32-only: initialize EEPROM
#ifdef ESP32
if(!EEPROM.begin(9)) {
DEBUG_PRINTLN_STR("Unable to initialize EEPROM");
return(ERR_EEPROM_NOT_INITIALIZED);
}
#endif
// copy EEPROM start address
_addrEeprom = addrEeprom;
// check if the node has address
bool hasAddress = false;
for(uint16_t i = 0; i < 8; i++) {
if(EEPROM.read(_addrEeprom + i) != 255) {
hasAddress = true;
break;
}
}
// generate new address
if(!hasAddress) {
randomSeed(analogRead(5));
generateNodeAdress();
}
DEBUG_PRINTLN_STR("LoRa node address string: ");
for(uint8_t i = 0; i < 8; i++) {
_address[i] = EEPROM.read(i);
#ifdef KITELIB_DEBUG
Serial.print(_address[i], HEX);
if(i < 7) {
Serial.print(":");
} else {
Serial.println();
}
#endif
}
uint8_t SX127x::begin(uint8_t syncWord) {
// set module properties
_mod->init(USE_SPI, INT_BOTH);
@ -69,7 +30,6 @@ uint8_t SX127x::begin(uint8_t syncWord, uint16_t addrEeprom) {
i++;
}
}
if(!flagFound) {
DEBUG_PRINTLN_STR("No SX127x found!");
SPI.end();
@ -87,9 +47,9 @@ uint8_t SX127x::begin(uint8_t syncWord, uint16_t addrEeprom) {
return(ERR_NONE);
}
uint8_t SX127x::transmit(Packet& pack) {
uint8_t SX127x::transmit(uint8_t* data, size_t len) {
// check packet length
if(pack.length >= 256) {
if(len >= 256) {
return(ERR_PACKET_TOO_LONG);
}
@ -103,7 +63,7 @@ uint8_t SX127x::transmit(Packet& pack) {
float ih = (float)_mod->SPIgetRegValue(SX127X_REG_MODEM_CONFIG_1, 0, 0);
float crc = (float)(_mod->SPIgetRegValue(SX127X_REG_MODEM_CONFIG_2, 2, 2) >> 2);
float n_pre = (float)_mod->SPIgetRegValue(SX127X_REG_PREAMBLE_LSB);
float n_pay = 8.0 + max(ceil((8.0 * (float)pack.length - 4.0 * (float)_sf + 28.0 + 16.0 * crc - 20.0 * ih)/(4.0 * (float)_sf - 8.0 * de)) * (float)_cr, 0.0);
float n_pay = 8.0 + max(ceil((8.0 * (float)len - 4.0 * (float)_sf + 28.0 + 16.0 * crc - 20.0 * ih)/(4.0 * (float)_sf - 8.0 * de)) * (float)_cr, 0.0);
uint32_t timeout = ceil(symbolLength * (n_pre + n_pay + 4.25) * 1000.0);
// set mode to standby
@ -116,16 +76,14 @@ uint8_t SX127x::transmit(Packet& pack) {
clearIRQFlags();
// set packet length
_mod->SPIsetRegValue(SX127X_REG_PAYLOAD_LENGTH, pack.length);
_mod->SPIsetRegValue(SX127X_REG_PAYLOAD_LENGTH, len);
// set FIFO pointers
_mod->SPIsetRegValue(SX127X_REG_FIFO_TX_BASE_ADDR, SX127X_FIFO_TX_BASE_ADDR_MAX);
_mod->SPIsetRegValue(SX127X_REG_FIFO_ADDR_PTR, SX127X_FIFO_TX_BASE_ADDR_MAX);
// write packet to FIFO
_mod->SPIwriteRegisterBurstStr(SX127X_REG_FIFO, (char*)pack.source, 8);
_mod->SPIwriteRegisterBurstStr(SX127X_REG_FIFO, (char*)pack.destination, 8);
_mod->SPIwriteRegisterBurstStr(SX127X_REG_FIFO, pack.data, pack.length - 16);
_mod->SPIwriteRegisterBurst(SX127X_REG_FIFO, data, len);
// start transmission
setMode(SX127X_TX);
@ -145,7 +103,15 @@ uint8_t SX127x::transmit(Packet& pack) {
return(ERR_NONE);
}
uint8_t SX127x::receive(Packet& pack) {
uint8_t SX127x::transmit(const char* str) {
return(SX127x::transmit((uint8_t*)str, strlen(str)));
}
uint8_t SX127x::transmit(String& str) {
return(SX127x::transmit(str.c_str()));
}
uint8_t SX127x::receive(uint8_t* data, size_t len) {
// set mode to standby
setMode(SX127X_STANDBY);
@ -178,22 +144,16 @@ uint8_t SX127x::receive(Packet& pack) {
}
// get packet length
size_t length = len;
if(_sf != 6) {
pack.length = _mod->SPIgetRegValue(SX127X_REG_RX_NB_BYTES);
length = _mod->SPIgetRegValue(SX127X_REG_RX_NB_BYTES);
}
// read packet addresses
_mod->SPIreadRegisterBurstStr(SX127X_REG_FIFO, 8, (char*)pack.source);
_mod->SPIreadRegisterBurstStr(SX127X_REG_FIFO, 8, (char*)pack.destination);
// read packet data
delete[] pack.data;
pack.data = new char[pack.length - 15];
_mod->SPIreadRegisterBurstStr(SX127X_REG_FIFO, pack.length - 16, pack.data);
pack.data[pack.length - 16] = 0;
_mod->SPIreadRegisterBurst(SX127X_REG_FIFO, length, data);
// update data rate, RSSI and SNR
dataRate = (pack.length*8.0)/((float)elapsed/1000.0);
dataRate = (length*8.0)/((float)elapsed/1000.0);
lastPacketRSSI = -157 + _mod->SPIgetRegValue(SX127X_REG_PKT_RSSI_VALUE);
int8_t rawSNR = (int8_t)_mod->SPIgetRegValue(SX127X_REG_PKT_SNR_VALUE);
lastPacketSNR = rawSNR / 4.0;
@ -204,6 +164,21 @@ uint8_t SX127x::receive(Packet& pack) {
return(ERR_NONE);
}
uint8_t SX127x::receive(String& str, size_t len) {
// create temporary array to store received data
char* data = new char[0];
uint8_t state = SX127x::receive((uint8_t*)data, len);
// if packet was received successfully, copy data into String
if(state == ERR_NONE) {
data[strlen(data) - 1] = 0;
str = String(data);
}
delete[] data;
return(state);
}
uint8_t SX127x::scanChannel() {
// set mode to standby
setMode(SX127X_STANDBY);
@ -306,12 +281,6 @@ uint8_t SX127x::config() {
return(state);
}
void SX127x::generateNodeAdress() {
for(uint8_t i = _addrEeprom; i < (_addrEeprom + 8); i++) {
EEPROM.write(i, (uint8_t)random(0, 256));
}
}
uint8_t SX127x::setMode(uint8_t mode) {
_mod->SPIsetRegValue(SX127X_REG_OP_MODE, mode, 2, 0);
return(ERR_NONE);

16
src/modules/SX127x.h
Wyświetl plik

@ -1,11 +1,8 @@
#ifndef _KITELIB_SX127X_H
#define _KITELIB_SX127X_H
#include <EEPROM.h>
#include "TypeDef.h"
#include "Module.h"
#include "Packet.h"
// SX127x series common registers
#define SX127X_REG_FIFO 0x00
@ -176,9 +173,12 @@ class SX127x {
float lastPacketSNR;
// basic methods
uint8_t begin(uint8_t syncWord, uint16_t addrEeprom);
uint8_t transmit(Packet& pack);
uint8_t receive(Packet& pack);
uint8_t begin(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();
@ -202,10 +202,6 @@ class SX127x {
uint8_t config();
private:
uint8_t _address[8] = {0, 0, 0, 0, 0, 0, 0, 0};
uint16_t _addrEeprom;
void generateNodeAdress();
uint8_t setMode(uint8_t mode);
void clearIRQFlags();
};

1
src/modules/XBee.h
Wyświetl plik

@ -3,7 +3,6 @@
#include "ISerial.h"
#include "TypeDef.h"
#include "Packet.h"
//API reserved characters
#define XBEE_API_START 0x7E