Add LORA gateway
first implementation of a lora gateway integration, tested on ttgo heltec boards with embedded lora module #356 Sending and receiving working
This commit is contained in:
Florian committed
1 parent
3b17625b25
commit
1ab21b3c37
21 files changed
+1981
-3
No files matched your search
+18
-3
@@ -88,6 +88,9 @@
|
||||
#ifdef ZgatewayRF315
|
||||
#include "config_RF315.h"
|
||||
#endif
|
||||
#ifdef ZgatewayLORA
|
||||
#include "config_LORA.h"
|
||||
#endif
|
||||
#ifdef ZgatewaySRFB
|
||||
#include "config_SRFB.h"
|
||||
#endif
|
||||
@@ -368,6 +371,9 @@ void setup()
|
||||
#ifdef ZgatewayIR
|
||||
setupIR();
|
||||
#endif
|
||||
#ifdef ZgatewayLORA
|
||||
setupLORA();
|
||||
#endif
|
||||
#ifdef ZgatewayRF
|
||||
setupRF();
|
||||
#endif
|
||||
@@ -664,6 +670,9 @@ void loop()
|
||||
#ifdef ZsensorADC
|
||||
MeasureADC(); //Addon to measure the analog value of analog pin
|
||||
#endif
|
||||
#ifdef ZgatewayLORA
|
||||
LORAtoMQTT();
|
||||
#endif
|
||||
#ifdef ZgatewayRF
|
||||
RFtoMQTT();
|
||||
#endif
|
||||
@@ -755,12 +764,12 @@ void stateMeasures(){
|
||||
#ifdef ZgatewayIR
|
||||
modules = modules + ZgatewayIR;
|
||||
#endif
|
||||
#ifdef ZgatewayLORA
|
||||
modules = modules + ZgatewayLORA;
|
||||
#endif
|
||||
#ifdef ZgatewayRF2
|
||||
modules = modules + ZgatewayRF2;
|
||||
#endif
|
||||
#ifdef ZgatewayPilight
|
||||
modules = modules + ZgatewayPilight;
|
||||
#endif
|
||||
#ifdef ZgatewayPilight
|
||||
modules = modules + ZgatewayPilight;
|
||||
#endif
|
||||
@@ -879,6 +888,9 @@ void receivingMQTT(char * topicOri, char * datacallback) {
|
||||
MQTTtoPilight(topicOri, jsondata);
|
||||
#endif
|
||||
#ifdef jsonReceiving
|
||||
#ifdef ZgatewayLORA
|
||||
MQTTtoLORA(topicOri, jsondata);
|
||||
#endif
|
||||
#ifdef ZgatewayRF
|
||||
MQTTtoRF(topicOri, jsondata);
|
||||
#endif
|
||||
@@ -906,6 +918,9 @@ void receivingMQTT(char * topicOri, char * datacallback) {
|
||||
#endif
|
||||
} else { // not a json object --> simple decoding
|
||||
#ifdef simpleReceiving
|
||||
#ifdef ZgatewayLORA
|
||||
MQTTtoLORA(topicOri, datacallback);
|
||||
#endif
|
||||
#ifdef ZgatewayRF
|
||||
MQTTtoRF(topicOri, datacallback);
|
||||
#endif
|
||||
|
||||
@@ -80,6 +80,7 @@ char mqtt_port[6] = "1883";
|
||||
#define ZgatewayRF "RF" //ESP8266, Arduino, ESP32
|
||||
//#define ZgatewayRF315 "RF315" //ESP8266, Arduino, ESP32
|
||||
#define ZgatewayIR "IR" //ESP8266, Arduino, Sonoff RF Bridge
|
||||
//#define ZgatewayLORA "LORA" //ESP8266, Arduino, ESP32
|
||||
//#define ZgatewayPilight "Pilight" //ESP8266, Arduino, ESP32
|
||||
#define ZgatewayBT "BT" //ESP8266, Arduino, ESP32
|
||||
//#define ZgatewayRF2 "RF2" //ESP8266, Arduino, ESP32
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
/*
|
||||
OpenMQTTGateway - ESP8266 or Arduino program for home automation
|
||||
|
||||
Act as a wifi or ethernet gateway between your 433mhz/infrared IR/BLE signal and a MQTT broker
|
||||
Send and receiving command by MQTT
|
||||
|
||||
This gateway enables to:
|
||||
- receive MQTT data from a topic and send LORA signal corresponding to the received MQTT data
|
||||
- publish MQTT data to a different topic related to received LORA signal
|
||||
|
||||
Copyright: (c)Florian ROBERT
|
||||
|
||||
This file is part of OpenMQTTGateway.
|
||||
|
||||
OpenMQTTGateway is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenMQTTGateway is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#ifdef ZgatewayLORA
|
||||
|
||||
#include <SPI.h>
|
||||
#include <LoRa.h>
|
||||
#include <Wire.h>
|
||||
|
||||
void setupLORA() {
|
||||
SPI.begin(LORA_SCK,LORA_MISO,LORA_MOSI,LORA_SS);
|
||||
LoRa.setPins(LORA_SS,LORA_RST,LORA_DI0);
|
||||
|
||||
if (!LoRa.begin(LORA_BAND)) {
|
||||
trc("ZgatewayLORA setup failed!");
|
||||
while (1);
|
||||
}
|
||||
LoRa.receive();
|
||||
trc(F("LORA_SCK"));
|
||||
trc(LORA_SCK);
|
||||
trc(F("LORA_MISO"));
|
||||
trc(LORA_MISO);
|
||||
trc(F("LORA_MOSI"));
|
||||
trc(LORA_MOSI);
|
||||
trc(F("LORA_SS"));
|
||||
trc(LORA_SS);
|
||||
trc(F("LORA_RST"));
|
||||
trc(LORA_RST);
|
||||
trc(F("LORA_DI0"));
|
||||
trc(LORA_DI0);
|
||||
trc(F("ZgatewayLORA setup done"));
|
||||
|
||||
}
|
||||
|
||||
void LORAtoMQTT(){
|
||||
int packetSize = LoRa.parsePacket();
|
||||
if (packetSize) {
|
||||
StaticJsonBuffer<JSON_MSG_BUFFER> jsonBuffer;
|
||||
JsonObject& LORAdata = jsonBuffer.createObject();
|
||||
trc(F("Rcv. LORA"));
|
||||
#ifdef ESP32
|
||||
String taskMessage = "LORA Task running on core ";
|
||||
taskMessage = taskMessage + xPortGetCoreID();
|
||||
trc(taskMessage);
|
||||
#endif
|
||||
String packet ;
|
||||
packet ="";
|
||||
for (int i = 0; i < packetSize; i++) { packet += (char) LoRa.read(); }
|
||||
LORAdata.set("rssi", (int)LoRa.packetRssi());
|
||||
LORAdata.set("packetSize", (int)packetSize);
|
||||
LORAdata.set("message", (char *)packet.c_str());
|
||||
pub(subjectLORAtoMQTT,LORAdata);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef jsonReceiving
|
||||
void MQTTtoLORA(char * topicOri, JsonObject& LORAdata) { // json object decoding
|
||||
if (strcmp(topicOri,subjectMQTTtoLORA) == 0){
|
||||
trc(F("MQTTtoLORA json"));
|
||||
const char * message = LORAdata["message"];
|
||||
if (message) {
|
||||
LoRa.beginPacket();
|
||||
LoRa.print(message);
|
||||
LoRa.endPacket();
|
||||
trc(F("MQTTtoLORA OK"));
|
||||
pub(subjectGTWLORAtoMQTT, LORAdata);// we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
|
||||
}else{
|
||||
trc(F("MQTTtoLORA Fail json"));
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef simpleReceiving
|
||||
void MQTTtoLORA(char * topicOri, char * LORAdata) { // json object decoding
|
||||
if (strcmp(topicOri,subjectMQTTtoLORA) == 0){
|
||||
LoRa.beginPacket();
|
||||
LoRa.print(LORAdata);
|
||||
LoRa.endPacket();
|
||||
trc(F("MQTTtoLORA OK"));
|
||||
pub(subjectGTWLORAtoMQTT, LORAdata);// we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,39 @@
|
||||
/*
|
||||
OpenMQTTGateway - ESP8266 or Arduino program for home automation
|
||||
|
||||
Act as a wifi or ethernet gateway between your 433mhz/infrared IR signal and a MQTT broker
|
||||
Send and receiving command by MQTT
|
||||
|
||||
This files enables to set your parameter for the LORA gateway
|
||||
|
||||
Copyright: (c)Florian ROBERT
|
||||
|
||||
This file is part of OpenMQTTGateway.
|
||||
|
||||
OpenMQTTGateway is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenMQTTGateway is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/*----------------------LORA topics & parameters-------------------------*/
|
||||
#define subjectLORAtoMQTT Base_Topic Gateway_Name "/LORAtoMQTT"
|
||||
#define subjectMQTTtoLORA Base_Topic Gateway_Name "/commands/MQTTtoLORA"
|
||||
#define subjectGTWLORAtoMQTT Base_Topic Gateway_Name "/LORAtoMQTT"
|
||||
#define LORA_BAND 868E6
|
||||
|
||||
/*-------------------PIN DEFINITIONS----------------------*/
|
||||
//TTGO LORA BOARD ESP32 PIN DEFINITION
|
||||
#define LORA_SCK 5 // GPIO5 -- SX1278's SCK
|
||||
#define LORA_MISO 19 // GPIO19 -- SX1278's MISO
|
||||
#define LORA_MOSI 27 // GPIO27 -- SX1278's MOSI
|
||||
#define LORA_SS 18 // GPIO18 -- SX1278's CS
|
||||
#define LORA_RST 14 // GPIO14 -- SX1278's RESET
|
||||
#define LORA_DI0 26 // GPIO26 -- SX1278's IRQ(Interrupt Request)
|
||||
@@ -0,0 +1,37 @@
|
||||
language: generic
|
||||
env:
|
||||
global:
|
||||
- IDE_VERSION=1.8.2
|
||||
matrix:
|
||||
- BOARD="arduino:avr:uno"
|
||||
- BOARD="arduino:avr:micro"
|
||||
- BOARD="arduino:avr:mega:cpu=atmega2560"
|
||||
- BOARD="arduino:samd:arduino_zero_edbg"
|
||||
- BOARD="arduino:samd:mkr1000"
|
||||
- BOARD="arduino:samd:mkrzero"
|
||||
- BOARD="arduino:samd:mkrwan1300"
|
||||
before_install:
|
||||
- wget http://downloads.arduino.cc/arduino-$IDE_VERSION-linux64.tar.xz
|
||||
- tar xf arduino-$IDE_VERSION-linux64.tar.xz
|
||||
- mv arduino-$IDE_VERSION $HOME/arduino-ide
|
||||
- export PATH=$PATH:$HOME/arduino-ide
|
||||
- if [[ "$BOARD" =~ "arduino:samd:" ]]; then
|
||||
arduino --install-boards arduino:samd &> /dev/null;
|
||||
fi
|
||||
- buildExampleSketch() { arduino --verbose-build --verify --board $BOARD $PWD/examples/$1/$1.ino; }
|
||||
install:
|
||||
- mkdir -p $HOME/Arduino/libraries
|
||||
- ln -s $PWD $HOME/Arduino/libraries/LoRa
|
||||
script:
|
||||
- buildExampleSketch LoRaDumpRegisters
|
||||
- buildExampleSketch LoRaDuplex
|
||||
- if [[ "$BOARD" != "arduino:samd:mkrwan1300" ]]; then
|
||||
buildExampleSketch LoRaDuplexCallback;
|
||||
fi
|
||||
- buildExampleSketch LoRaReceiver
|
||||
- if [[ "$BOARD" != "arduino:samd:mkrwan1300" ]]; then
|
||||
buildExampleSketch LoRaReceiverCallback;
|
||||
fi
|
||||
- buildExampleSketch LoRaSender
|
||||
- buildExampleSketch LoRaSetSpread
|
||||
- buildExampleSketch LoRaSetSyncWord
|
||||
@@ -0,0 +1,342 @@
|
||||
# LoRa API
|
||||
|
||||
## Include Library
|
||||
|
||||
```arduino
|
||||
#include <LoRa.h>
|
||||
```
|
||||
|
||||
## Setup
|
||||
|
||||
### Begin
|
||||
|
||||
Initialize the library with the specified frequency.
|
||||
|
||||
```arduino
|
||||
LoRa.begin(frequency);
|
||||
```
|
||||
* `frequency` - frequency in Hz (`433E6`, `866E6`, `915E6`)
|
||||
|
||||
Returns `1` on success, `0` on failure.
|
||||
|
||||
### Set pins
|
||||
|
||||
Override the default `NSS`, `NRESET`, and `DIO0` pins used by the library. **Must** be called before `LoRa.begin()`.
|
||||
|
||||
```arduino
|
||||
LoRa.setPins(ss, reset, dio0);
|
||||
```
|
||||
* `ss` - new slave select pin to use, defaults to `10`
|
||||
* `reset` - new reset pin to use, defaults to `9`
|
||||
* `dio0` - new DIO0 pin to use, defaults to `2`. **Must** be interrupt capable via [attachInterrupt(...)](https://www.arduino.cc/en/Reference/AttachInterrupt).
|
||||
|
||||
This call is optional and only needs to be used if you need to change the default pins used.
|
||||
|
||||
#### No MCU controlled reset pin
|
||||
|
||||
To save further pins one could connect the reset pin of the MCU with reset pin of the radio thus resetting only during startup.
|
||||
|
||||
* `reset` - set to `-1` to omit this pin
|
||||
|
||||
### Set SPI interface
|
||||
|
||||
Override the default SPI interface used by the library. **Must** be called before `LoRa.begin()`.
|
||||
|
||||
```arduino
|
||||
LoRa.setSPI(spi);
|
||||
```
|
||||
* `spi` - new SPI interface to use, defaults to `SPI`
|
||||
|
||||
This call is optional and only needs to be used if you need to change the default SPI interface used, in the case your Arduino (or compatible) board has more than one SPI interface present.
|
||||
|
||||
### Set SPI Frequency
|
||||
|
||||
Override the default SPI frequency of 10 MHz used by the library. **Must** be called before `LoRa.begin()`.
|
||||
|
||||
```arduino
|
||||
LoRa.setSPIFrequency(frequency);
|
||||
```
|
||||
* `frequency` - new SPI frequency to use, defaults to `8E6`
|
||||
|
||||
This call is optional and only needs to be used if you need to change the default SPI frequency used. Some logic level converters cannot support high speeds such as 8 MHz, so a lower SPI frequency can be selected with `LoRa.setSPIFrequency(frequency)`.
|
||||
|
||||
### End
|
||||
|
||||
Stop the library
|
||||
|
||||
```arduino
|
||||
LoRa.end()
|
||||
```
|
||||
|
||||
## Sending data
|
||||
|
||||
### Begin packet
|
||||
|
||||
Start the sequence of sending a packet.
|
||||
|
||||
```arduino
|
||||
LoRa.beginPacket();
|
||||
|
||||
LoRa.beginPacket(implicitHeader);
|
||||
```
|
||||
|
||||
* `implicitHeader` - (optional) `true` enables implicit header mode, `false` enables explicit header mode (default)
|
||||
|
||||
Returns `1` on success, `0` on failure.
|
||||
|
||||
### Writing
|
||||
|
||||
Write data to the packet. Each packet can contain up to 255 bytes.
|
||||
|
||||
```arduino
|
||||
LoRa.write(byte);
|
||||
|
||||
LoRa.write(buffer, length);
|
||||
```
|
||||
* `byte` - single byte to write to packet
|
||||
|
||||
or
|
||||
|
||||
* `buffer` - data to write to packet
|
||||
* `length` - size of data to write
|
||||
|
||||
Returns the number of bytes written.
|
||||
|
||||
**Note:** Other Arduino `Print` API's can also be used to write data into the packet
|
||||
|
||||
### End packet
|
||||
|
||||
End the sequence of sending a packet.
|
||||
|
||||
```arduino
|
||||
LoRa.endPacket()
|
||||
```
|
||||
|
||||
Returns `1` on success, `0` on failure.
|
||||
|
||||
## Receiving data
|
||||
|
||||
### Parsing packet
|
||||
|
||||
Check if a packet has been received.
|
||||
|
||||
```arduino
|
||||
int packetSize = LoRa.parsePacket();
|
||||
|
||||
int packetSize = LoRa.parsePacket(size);
|
||||
```
|
||||
|
||||
* `size` - (optional) if `> 0` implicit header mode is enabled with the expected a packet of `size` bytes, default mode is explicit header mode
|
||||
|
||||
|
||||
Returns the packet size in bytes or `0` if no packet was received.
|
||||
|
||||
### Continuous receive mode
|
||||
|
||||
**WARNING**: Not supported on the Arduino MKR WAN 1300 board!
|
||||
|
||||
#### Register callback
|
||||
|
||||
Register a callback function for when a packet is received.
|
||||
|
||||
```arduino
|
||||
LoRa.onReceive(onReceive);
|
||||
|
||||
void onReceive(int packetSize) {
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
* `onReceive` - function to call when a packet is received.
|
||||
|
||||
#### Receive mode
|
||||
|
||||
Puts the radio in continuous receive mode.
|
||||
|
||||
```arduino
|
||||
LoRa.receive();
|
||||
|
||||
LoRa.receive(int size);
|
||||
```
|
||||
|
||||
* `size` - (optional) if `> 0` implicit header mode is enabled with the expected a packet of `size` bytes, default mode is explicit header mode
|
||||
|
||||
The `onReceive` callback will be called when a packet is received.
|
||||
|
||||
### Packet RSSI
|
||||
|
||||
```arduino
|
||||
int rssi = LoRa.packetRssi();
|
||||
```
|
||||
|
||||
Returns the RSSI of the received packet.
|
||||
|
||||
### Packet SNR
|
||||
|
||||
```arduino
|
||||
float snr = LoRa.packetSnr();
|
||||
```
|
||||
|
||||
Returns the estimated SNR of the received packet in dB.
|
||||
|
||||
### Packet Frequency Error
|
||||
|
||||
```arduino
|
||||
long freqErr = LoRa.packetFrequencyError();
|
||||
```
|
||||
|
||||
Returns the frequency error of the received packet in Hz. The frequency error is the frequency offset between the receiver centre frequency and that of an incoming LoRa signal.
|
||||
|
||||
### Available
|
||||
|
||||
```arduino
|
||||
int availableBytes = LoRa.available()
|
||||
```
|
||||
|
||||
Returns number of bytes available for reading.
|
||||
|
||||
### Peeking
|
||||
|
||||
Peek at the next byte in the packet.
|
||||
|
||||
```arduino
|
||||
byte b = LoRa.peek();
|
||||
```
|
||||
|
||||
Returns the next byte in the packet or `-1` if no bytes are available.
|
||||
|
||||
### Reading
|
||||
|
||||
Read the next byte from the packet.
|
||||
|
||||
```arduino
|
||||
byte b = LoRa.read();
|
||||
```
|
||||
|
||||
Returns the next byte in the packet or `-1` if no bytes are available.
|
||||
|
||||
**Note:** Other Arduino [`Stream` API's](https://www.arduino.cc/en/Reference/Stream) can also be used to read data from the packet
|
||||
|
||||
## Other radio modes
|
||||
|
||||
### Idle mode
|
||||
|
||||
Put the radio in idle (standby) mode.
|
||||
|
||||
```arduino
|
||||
LoRa.idle();
|
||||
```
|
||||
|
||||
### Sleep mode
|
||||
|
||||
Put the radio in sleep mode.
|
||||
|
||||
```arduino
|
||||
LoRa.sleep();
|
||||
```
|
||||
|
||||
## Radio parameters
|
||||
|
||||
### TX Power
|
||||
|
||||
Change the TX power of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setTxPower(txPower);
|
||||
|
||||
LoRa.setTxPower(txPower, outputPin);
|
||||
```
|
||||
* `txPower` - TX power in dB, defaults to `17`
|
||||
* `outputPin` - (optional) PA output pin, supported values are `PA_OUTPUT_RFO_PIN` and `PA_OUTPUT_PA_BOOST_PIN`, defaults to `PA_OUTPUT_PA_BOOST_PIN`.
|
||||
|
||||
Supported values are between `2` and `17` for `PA_OUTPUT_PA_BOOST_PIN`, `0` and `14` for `PA_OUTPUT_RFO_PIN`.
|
||||
|
||||
Most modules have the PA output pin connected to PA BOOST,
|
||||
|
||||
### Frequency
|
||||
|
||||
Change the frequency of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setFrequency(frequency);
|
||||
```
|
||||
* `frequency` - frequency in Hz (`433E6`, `866E6`, `915E6`)
|
||||
|
||||
### Spreading Factor
|
||||
|
||||
Change the spreading factor of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setSpreadingFactor(spreadingFactor);
|
||||
```
|
||||
* `spreadingFactor` - spreading factor, defaults to `7`
|
||||
|
||||
Supported values are between `6` and `12`. If a spreading factor of `6` is set, implicit header mode must be used to transmit and receive packets.
|
||||
|
||||
### Signal Bandwidth
|
||||
|
||||
Change the signal bandwidth of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setSignalBandwidth(signalBandwidth);
|
||||
```
|
||||
|
||||
* `signalBandwidth` - signal bandwidth in Hz, defaults to `125E3`.
|
||||
|
||||
Supported values are `7.8E3`, `10.4E3`, `15.6E3`, `20.8E3`, `31.25E3`, `41.7E3`, `62.5E3`, `125E3`, and `250E3`.
|
||||
|
||||
### Coding Rate
|
||||
|
||||
Change the coding rate of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setCodingRate4(codingRateDenominator);
|
||||
```
|
||||
|
||||
* `codingRateDenominator` - denominator of the coding rate, defaults to `5`
|
||||
|
||||
Supported values are between `5` and `8`, these correspond to coding rates of `4/5` and `4/8`. The coding rate numerator is fixed at `4`.
|
||||
|
||||
### Preamble Length
|
||||
|
||||
Change the preamble length of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setPreambleLength(preambleLength);
|
||||
```
|
||||
|
||||
* `preambleLength` - preamble length in symbols, defaults to `8`
|
||||
|
||||
Supported values are between `6` and `65535`.
|
||||
|
||||
### Sync Word
|
||||
|
||||
Change the sync word of the radio.
|
||||
|
||||
```arduino
|
||||
LoRa.setSyncWord(syncWord);
|
||||
```
|
||||
|
||||
* `syncWord` - byte value to use as the sync word, defaults to `0x34`
|
||||
|
||||
### CRC
|
||||
|
||||
Enable or disable CRC usage, by default a CRC is not used.
|
||||
|
||||
```arduino
|
||||
LoRa.enableCrc();
|
||||
|
||||
LoRa.disableCrc();
|
||||
```
|
||||
|
||||
## Other functions
|
||||
|
||||
### Random
|
||||
|
||||
Generate a random byte, based on the Wideband RSSI measurement.
|
||||
|
||||
```
|
||||
byte b = LoRa.random();
|
||||
```
|
||||
|
||||
Returns random byte.
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2016 Sandeep Mistry
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,91 @@
|
||||
# Arduino LoRa
|
||||
|
||||
[](https://travis-ci.org/sandeepmistry/arduino-LoRa)
|
||||
|
||||
An [Arduino](https://arduino.cc/) library for sending and receiving data using [LoRa](https://www.lora-alliance.org/) radios.
|
||||
|
||||
## Compatible Hardware
|
||||
|
||||
* [Semtech SX1276/77/78/79](http://www.semtech.com/apps/product.php?pn=SX1276) based boards including:
|
||||
* [Dragino Lora Shield](http://www.dragino.com/products/module/item/102-lora-shield.html)
|
||||
* [HopeRF](http://www.hoperf.com/rf_transceiver/lora/) [RFM95W](http://www.hoperf.com/rf_transceiver/lora/RFM95W.html), [RFM96W](http://www.hoperf.com/rf_transceiver/lora/RFM96W.html), and [RFM98W](http://www.hoperf.com/rf_transceiver/lora/RFM98W.html)
|
||||
* [Modtronix](http://modtronix.com/) [inAir4](http://modtronix.com/inair4.html), [inAir9](http://modtronix.com/inair9.html), and [inAir9B](http://modtronix.com/inair9b.html)
|
||||
* [Arduino MKR WAN 1300](https://store.arduino.cc/usa/mkr-wan-1300)
|
||||
* **NOTE:** Requires firmware v1.1.6 or later on the on-board Murata module
|
||||
* **WARNING**: [LoRa.onReceive(...)](https://github.com/sandeepmistry/arduino-LoRa/blob/master/API.md#register-callback) and [LoRa.recieve()](https://github.com/sandeepmistry/arduino-LoRa/blob/master/API.md#receive-mode) is not compatible with this board!
|
||||
|
||||
### Semtech SX1276/77/78/79 wiring
|
||||
|
||||
| Semtech SX1276/77/78/79 | Arduino |
|
||||
| :---------------------: | :------:|
|
||||
| VCC | 3.3V |
|
||||
| GND | GND |
|
||||
| SCK | SCK |
|
||||
| MISO | MISO |
|
||||
| MOSI | MOSI |
|
||||
| NSS | 10 |
|
||||
| NRESET | 9 |
|
||||
| DIO0 | 2 |
|
||||
|
||||
|
||||
`NSS`, `NRESET`, and `DIO0` pins can be changed by using `LoRa.setPins(ss, reset, dio0)`. `DIO0` pin is optional, it is only needed for receive callback mode. If `DIO0` pin is used, it **must** be interrupt capable via [`attachInterrupt(...)`](https://www.arduino.cc/en/Reference/AttachInterrupt).
|
||||
|
||||
**NOTES**:
|
||||
* Some boards (like the Arduino Nano), cannot supply enough current for the SX127x in TX mode. This will cause lockups when sending, be sure to use an external 3.3V supply that can provide at least 120mA's when using these boards.
|
||||
* If your Arduino board operates at 5V, like the Arduino Uno, Leonardo or Mega, you will need to use a level converter for the wiring to the Semtech SX127x module. Most Semtech SX127x breakout boards do not have logic level converters built-in.
|
||||
|
||||
## Installation
|
||||
|
||||
### Using the Arduino IDE Library Manager
|
||||
|
||||
1. Choose `Sketch` -> `Include Library` -> `Manage Libraries...`
|
||||
2. Type `LoRa` into the search box.
|
||||
3. Click the row to select the library.
|
||||
4. Click the `Install` button to install the library.
|
||||
|
||||
### Using Git
|
||||
|
||||
```sh
|
||||
cd ~/Documents/Arduino/libraries/
|
||||
git clone https://github.com/sandeepmistry/arduino-LoRa LoRa
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
See [API.md](API.md).
|
||||
|
||||
## Examples
|
||||
|
||||
See [examples](examples) folder.
|
||||
|
||||
## FAQ
|
||||
|
||||
**1) Initilizating the LoRa radio is failing**
|
||||
|
||||
Please check the wiring you are using matches what's listed in [Semtech SX1276/77/78/79 wiring](#semtech-sx1276777879-wiring). You can also use `LoRa.setPins(ss, reset, dio0)` to change the default pins used. Some logic level converters cannot operate at 8 MHz, you can call `LoRa.setSPIFrequency(frequency)` to lower the SPI frequency used by the library. Both API's must be called before `LoRa.begin(...)`.
|
||||
|
||||
**2) Can other radios see the packets I'm sending?**
|
||||
|
||||
Yes, any LoRa radio that are configured with the same radio parameters and in range can see the packets you send.
|
||||
|
||||
**3) Is the data I'm sending encrypted?**
|
||||
|
||||
No, all data is sent unencrypted. If want your packet data to be encrypted, you must encrypt it before passing it into this library, followed by decrypting on the receiving end.
|
||||
|
||||
**4) How does this library differ from LoRaWAN libraries?**
|
||||
|
||||
This library exposes the LoRa radio directly, and allows you to send data to any radios in range with same radio parameters. All data is broadcasted and there is no addressing. LoRaWAN builds on top of LoRA, but adds addressing, encryption, and additional layers. It also requires a LoRaWAN gateway and LoRaWAN network and application server.
|
||||
|
||||
**5) Does this library honor duty cycles?**
|
||||
|
||||
No, you have to manage it by your self.
|
||||
|
||||
**6) Which frequencies can I use?**
|
||||
|
||||
You can use [this table](https://www.thethingsnetwork.org/wiki/LoRaWAN/Frequencies/By-Country) to lookup the available frequencies by your country. The selectable frequency also depends on your hardware. You can lookup the data sheet or ask your supplier.
|
||||
|
||||
Please also notice the frequency dependent duty cycles for legal reasons!
|
||||
|
||||
## License
|
||||
|
||||
This libary is [licensed](LICENSE) under the [MIT Licence](https://en.wikipedia.org/wiki/MIT_License).
|
||||
@@ -0,0 +1,30 @@
|
||||
/*
|
||||
LoRa register dump
|
||||
|
||||
This examples shows how to inspect and output the LoRa radio's
|
||||
registers on the Serial interface
|
||||
*/
|
||||
#include <SPI.h> // include libraries
|
||||
#include <LoRa.h>
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // initialize serial
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Dump Registers");
|
||||
|
||||
// override the default CS, reset, and IRQ pins (optional)
|
||||
// LoRa.setPins(7, 6, 1); // set CS, reset, IRQ pin
|
||||
|
||||
if (!LoRa.begin(915E6)) { // initialize ratio at 915 MHz
|
||||
Serial.println("LoRa init failed. Check your connections.");
|
||||
while (true); // if failed, do nothing
|
||||
}
|
||||
|
||||
LoRa.dumpRegisters(Serial);
|
||||
}
|
||||
|
||||
|
||||
void loop() {
|
||||
}
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
/*
|
||||
LoRa Duplex communication
|
||||
|
||||
Sends a message every half second, and polls continually
|
||||
for new incoming messages. Implements a one-byte addressing scheme,
|
||||
with 0xFF as the broadcast address.
|
||||
|
||||
Uses readString() from Stream class to read payload. The Stream class'
|
||||
timeout may affect other functuons, like the radio's callback. For an
|
||||
|
||||
created 28 April 2017
|
||||
by Tom Igoe
|
||||
*/
|
||||
#include <SPI.h> // include libraries
|
||||
#include <LoRa.h>
|
||||
|
||||
const int csPin = 7; // LoRa radio chip select
|
||||
const int resetPin = 6; // LoRa radio reset
|
||||
const int irqPin = 1; // change for your board; must be a hardware interrupt pin
|
||||
|
||||
String outgoing; // outgoing message
|
||||
|
||||
byte msgCount = 0; // count of outgoing messages
|
||||
byte localAddress = 0xBB; // address of this device
|
||||
byte destination = 0xFF; // destination to send to
|
||||
long lastSendTime = 0; // last send time
|
||||
int interval = 2000; // interval between sends
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // initialize serial
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Duplex");
|
||||
|
||||
// override the default CS, reset, and IRQ pins (optional)
|
||||
LoRa.setPins(csPin, resetPin, irqPin);// set CS, reset, IRQ pin
|
||||
|
||||
if (!LoRa.begin(915E6)) { // initialize ratio at 915 MHz
|
||||
Serial.println("LoRa init failed. Check your connections.");
|
||||
while (true); // if failed, do nothing
|
||||
}
|
||||
|
||||
Serial.println("LoRa init succeeded.");
|
||||
}
|
||||
|
||||
void loop() {
|
||||
if (millis() - lastSendTime > interval) {
|
||||
String message = "HeLoRa World!"; // send a message
|
||||
sendMessage(message);
|
||||
Serial.println("Sending " + message);
|
||||
lastSendTime = millis(); // timestamp the message
|
||||
interval = random(2000) + 1000; // 2-3 seconds
|
||||
}
|
||||
|
||||
// parse for a packet, and call onReceive with the result:
|
||||
onReceive(LoRa.parsePacket());
|
||||
}
|
||||
|
||||
void sendMessage(String outgoing) {
|
||||
LoRa.beginPacket(); // start packet
|
||||
LoRa.write(destination); // add destination address
|
||||
LoRa.write(localAddress); // add sender address
|
||||
LoRa.write(msgCount); // add message ID
|
||||
LoRa.write(outgoing.length()); // add payload length
|
||||
LoRa.print(outgoing); // add payload
|
||||
LoRa.endPacket(); // finish packet and send it
|
||||
msgCount++; // increment message ID
|
||||
}
|
||||
|
||||
void onReceive(int packetSize) {
|
||||
if (packetSize == 0) return; // if there's no packet, return
|
||||
|
||||
// read packet header bytes:
|
||||
int recipient = LoRa.read(); // recipient address
|
||||
byte sender = LoRa.read(); // sender address
|
||||
byte incomingMsgId = LoRa.read(); // incoming msg ID
|
||||
byte incomingLength = LoRa.read(); // incoming msg length
|
||||
|
||||
String incoming = "";
|
||||
|
||||
while (LoRa.available()) {
|
||||
incoming += (char)LoRa.read();
|
||||
}
|
||||
|
||||
if (incomingLength != incoming.length()) { // check length for error
|
||||
Serial.println("error: message length does not match length");
|
||||
return; // skip rest of function
|
||||
}
|
||||
|
||||
// if the recipient isn't this device or broadcast,
|
||||
if (recipient != localAddress && recipient != 0xFF) {
|
||||
Serial.println("This message is not for me.");
|
||||
return; // skip rest of function
|
||||
}
|
||||
|
||||
// if message is for this device, or broadcast, print details:
|
||||
Serial.println("Received from: 0x" + String(sender, HEX));
|
||||
Serial.println("Sent to: 0x" + String(recipient, HEX));
|
||||
Serial.println("Message ID: " + String(incomingMsgId));
|
||||
Serial.println("Message length: " + String(incomingLength));
|
||||
Serial.println("Message: " + incoming);
|
||||
Serial.println("RSSI: " + String(LoRa.packetRssi()));
|
||||
Serial.println("Snr: " + String(LoRa.packetSnr()));
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
/*
|
||||
LoRa Duplex communication wth callback
|
||||
|
||||
Sends a message every half second, and uses callback
|
||||
for new incoming messages. Implements a one-byte addressing scheme,
|
||||
with 0xFF as the broadcast address.
|
||||
|
||||
Note: while sending, LoRa radio is not listening for incoming messages.
|
||||
Note2: when using the callback method, you can't use any of the Stream
|
||||
functions that rely on the timeout, such as readString, parseInt(), etc.
|
||||
|
||||
created 28 April 2017
|
||||
by Tom Igoe
|
||||
*/
|
||||
#include <SPI.h> // include libraries
|
||||
#include <LoRa.h>
|
||||
|
||||
#ifdef ARDUINO_SAMD_MKRWAN1300
|
||||
#error "This example is not compatible with the Arduino MKR WAN 1300 board!"
|
||||
#endif
|
||||
|
||||
const int csPin = 7; // LoRa radio chip select
|
||||
const int resetPin = 6; // LoRa radio reset
|
||||
const int irqPin = 1; // change for your board; must be a hardware interrupt pin
|
||||
|
||||
String outgoing; // outgoing message
|
||||
byte msgCount = 0; // count of outgoing messages
|
||||
byte localAddress = 0xBB; // address of this device
|
||||
byte destination = 0xFF; // destination to send to
|
||||
long lastSendTime = 0; // last send time
|
||||
int interval = 2000; // interval between sends
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // initialize serial
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Duplex with callback");
|
||||
|
||||
// override the default CS, reset, and IRQ pins (optional)
|
||||
LoRa.setPins(csPin, resetPin, irqPin);// set CS, reset, IRQ pin
|
||||
|
||||
if (!LoRa.begin(915E6)) { // initialize ratio at 915 MHz
|
||||
Serial.println("LoRa init failed. Check your connections.");
|
||||
while (true); // if failed, do nothing
|
||||
}
|
||||
|
||||
LoRa.onReceive(onReceive);
|
||||
LoRa.receive();
|
||||
Serial.println("LoRa init succeeded.");
|
||||
}
|
||||
|
||||
void loop() {
|
||||
if (millis() - lastSendTime > interval) {
|
||||
String message = "HeLoRa World!"; // send a message
|
||||
sendMessage(message);
|
||||
Serial.println("Sending " + message);
|
||||
lastSendTime = millis(); // timestamp the message
|
||||
interval = random(2000) + 1000; // 2-3 seconds
|
||||
LoRa.receive(); // go back into receive mode
|
||||
}
|
||||
}
|
||||
|
||||
void sendMessage(String outgoing) {
|
||||
LoRa.beginPacket(); // start packet
|
||||
LoRa.write(destination); // add destination address
|
||||
LoRa.write(localAddress); // add sender address
|
||||
LoRa.write(msgCount); // add message ID
|
||||
LoRa.write(outgoing.length()); // add payload length
|
||||
LoRa.print(outgoing); // add payload
|
||||
LoRa.endPacket(); // finish packet and send it
|
||||
msgCount++; // increment message ID
|
||||
}
|
||||
|
||||
void onReceive(int packetSize) {
|
||||
if (packetSize == 0) return; // if there's no packet, return
|
||||
|
||||
// read packet header bytes:
|
||||
int recipient = LoRa.read(); // recipient address
|
||||
byte sender = LoRa.read(); // sender address
|
||||
byte incomingMsgId = LoRa.read(); // incoming msg ID
|
||||
byte incomingLength = LoRa.read(); // incoming msg length
|
||||
|
||||
String incoming = ""; // payload of packet
|
||||
|
||||
while (LoRa.available()) { // can't use readString() in callback, so
|
||||
incoming += (char)LoRa.read(); // add bytes one by one
|
||||
}
|
||||
|
||||
if (incomingLength != incoming.length()) { // check length for error
|
||||
Serial.println("error: message length does not match length");
|
||||
return; // skip rest of function
|
||||
}
|
||||
|
||||
// if the recipient isn't this device or broadcast,
|
||||
if (recipient != localAddress && recipient != 0xFF) {
|
||||
Serial.println("This message is not for me.");
|
||||
return; // skip rest of function
|
||||
}
|
||||
|
||||
// if message is for this device, or broadcast, print details:
|
||||
Serial.println("Received from: 0x" + String(sender, HEX));
|
||||
Serial.println("Sent to: 0x" + String(recipient, HEX));
|
||||
Serial.println("Message ID: " + String(incomingMsgId));
|
||||
Serial.println("Message length: " + String(incomingLength));
|
||||
Serial.println("Message: " + incoming);
|
||||
Serial.println("RSSI: " + String(LoRa.packetRssi()));
|
||||
Serial.println("Snr: " + String(LoRa.packetSnr()));
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
#include <SPI.h>
|
||||
#include <LoRa.h>
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600);
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Receiver");
|
||||
|
||||
if (!LoRa.begin(915E6)) {
|
||||
Serial.println("Starting LoRa failed!");
|
||||
while (1);
|
||||
}
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// try to parse packet
|
||||
int packetSize = LoRa.parsePacket();
|
||||
if (packetSize) {
|
||||
// received a packet
|
||||
Serial.print("Received packet '");
|
||||
|
||||
// read packet
|
||||
while (LoRa.available()) {
|
||||
Serial.print((char)LoRa.read());
|
||||
}
|
||||
|
||||
// print RSSI of packet
|
||||
Serial.print("' with RSSI ");
|
||||
Serial.println(LoRa.packetRssi());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
#include <SPI.h>
|
||||
#include <LoRa.h>
|
||||
|
||||
#ifdef ARDUINO_SAMD_MKRWAN1300
|
||||
#error "This example is not compatible with the Arduino MKR WAN 1300 board!"
|
||||
#endif
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600);
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Receiver Callback");
|
||||
|
||||
if (!LoRa.begin(915E6)) {
|
||||
Serial.println("Starting LoRa failed!");
|
||||
while (1);
|
||||
}
|
||||
|
||||
// register the receive callback
|
||||
LoRa.onReceive(onReceive);
|
||||
|
||||
// put the radio into receive mode
|
||||
LoRa.receive();
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
void onReceive(int packetSize) {
|
||||
// received a packet
|
||||
Serial.print("Received packet '");
|
||||
|
||||
// read packet
|
||||
for (int i = 0; i < packetSize; i++) {
|
||||
Serial.print((char)LoRa.read());
|
||||
}
|
||||
|
||||
// print RSSI of packet
|
||||
Serial.print("' with RSSI ");
|
||||
Serial.println(LoRa.packetRssi());
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
#include <SPI.h>
|
||||
#include <LoRa.h>
|
||||
|
||||
int counter = 0;
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600);
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Sender");
|
||||
|
||||
if (!LoRa.begin(915E6)) {
|
||||
Serial.println("Starting LoRa failed!");
|
||||
while (1);
|
||||
}
|
||||
}
|
||||
|
||||
void loop() {
|
||||
Serial.print("Sending packet: ");
|
||||
Serial.println(counter);
|
||||
|
||||
// send packet
|
||||
LoRa.beginPacket();
|
||||
LoRa.print("hello ");
|
||||
LoRa.print(counter);
|
||||
LoRa.endPacket();
|
||||
|
||||
counter++;
|
||||
|
||||
delay(5000);
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
LoRa Duplex communication with Spreading Factor
|
||||
|
||||
Sends a message every half second, and polls continually
|
||||
for new incoming messages. Sets the LoRa radio's spreading factor.
|
||||
|
||||
Spreading factor affects how far apart the radio's transmissions
|
||||
are, across the available bandwidth. Radios with different spreading
|
||||
factors will not receive each other's transmissions. This is one way you
|
||||
can filter out radios you want to ignore, without making an addressing scheme.
|
||||
|
||||
Spreading factor affects reliability of transmission at high rates, however,
|
||||
so avoid a hugh spreading factor when you're sending continually.
|
||||
|
||||
See the Semtech datasheet, http://www.semtech.com/images/datasheet/sx1276.pdf
|
||||
for more on Spreading Factor.
|
||||
|
||||
created 28 April 2017
|
||||
by Tom Igoe
|
||||
*/
|
||||
#include <SPI.h> // include libraries
|
||||
#include <LoRa.h>
|
||||
|
||||
const int csPin = 7; // LoRa radio chip select
|
||||
const int resetPin = 6; // LoRa radio reset
|
||||
const int irqPin = 1; // change for your board; must be a hardware interrupt pin
|
||||
|
||||
byte msgCount = 0; // count of outgoing messages
|
||||
int interval = 2000; // interval between sends
|
||||
long lastSendTime = 0; // time of last packet send
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // initialize serial
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Duplex - Set spreading factor");
|
||||
|
||||
// override the default CS, reset, and IRQ pins (optional)
|
||||
LoRa.setPins(csPin, resetPin, irqPin); // set CS, reset, IRQ pin
|
||||
|
||||
if (!LoRa.begin(915E6)) { // initialize ratio at 915 MHz
|
||||
Serial.println("LoRa init failed. Check your connections.");
|
||||
while (true); // if failed, do nothing
|
||||
}
|
||||
|
||||
LoRa.setSpreadingFactor(8); // ranges from 6-12,default 7 see API docs
|
||||
Serial.println("LoRa init succeeded.");
|
||||
}
|
||||
|
||||
void loop() {
|
||||
if (millis() - lastSendTime > interval) {
|
||||
String message = "HeLoRa World! "; // send a message
|
||||
message += msgCount;
|
||||
sendMessage(message);
|
||||
Serial.println("Sending " + message);
|
||||
lastSendTime = millis(); // timestamp the message
|
||||
interval = random(2000) + 1000; // 2-3 seconds
|
||||
msgCount++;
|
||||
}
|
||||
|
||||
// parse for a packet, and call onReceive with the result:
|
||||
onReceive(LoRa.parsePacket());
|
||||
}
|
||||
|
||||
void sendMessage(String outgoing) {
|
||||
LoRa.beginPacket(); // start packet
|
||||
LoRa.print(outgoing); // add payload
|
||||
LoRa.endPacket(); // finish packet and send it
|
||||
msgCount++; // increment message ID
|
||||
}
|
||||
|
||||
void onReceive(int packetSize) {
|
||||
if (packetSize == 0) return; // if there's no packet, return
|
||||
|
||||
// read packet header bytes:
|
||||
String incoming = "";
|
||||
|
||||
while (LoRa.available()) {
|
||||
incoming += (char)LoRa.read();
|
||||
}
|
||||
|
||||
Serial.println("Message: " + incoming);
|
||||
Serial.println("RSSI: " + String(LoRa.packetRssi()));
|
||||
Serial.println("Snr: " + String(LoRa.packetSnr()));
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
LoRa Duplex communication with Sync Word
|
||||
|
||||
Sends a message every half second, and polls continually
|
||||
for new incoming messages. Sets the LoRa radio's Sync Word.
|
||||
|
||||
Spreading factor is basically the radio's network ID. Radios with different
|
||||
Sync Words will not receive each other's transmissions. This is one way you
|
||||
can filter out radios you want to ignore, without making an addressing scheme.
|
||||
|
||||
See the Semtech datasheet, http://www.semtech.com/images/datasheet/sx1276.pdf
|
||||
for more on Sync Word.
|
||||
|
||||
created 28 April 2017
|
||||
by Tom Igoe
|
||||
*/
|
||||
#include <SPI.h> // include libraries
|
||||
#include <LoRa.h>
|
||||
const int csPin = 7; // LoRa radio chip select
|
||||
const int resetPin = 6; // LoRa radio reset
|
||||
const int irqPin = 1; // change for your board; must be a hardware interrupt pin
|
||||
|
||||
byte msgCount = 0; // count of outgoing messages
|
||||
int interval = 2000; // interval between sends
|
||||
long lastSendTime = 0; // time of last packet send
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // initialize serial
|
||||
while (!Serial);
|
||||
|
||||
Serial.println("LoRa Duplex - Set sync word");
|
||||
|
||||
// override the default CS, reset, and IRQ pins (optional)
|
||||
LoRa.setPins(csPin, resetPin, irqPin);// set CS, reset, IRQ pin
|
||||
|
||||
if (!LoRa.begin(915E6)) { // initialize ratio at 915 MHz
|
||||
Serial.println("LoRa init failed. Check your connections.");
|
||||
while (true); // if failed, do nothing
|
||||
}
|
||||
|
||||
LoRa.setSyncWord(0xF3); // ranges from 0-0xFF, default 0x34, see API docs
|
||||
Serial.println("LoRa init succeeded.");
|
||||
}
|
||||
|
||||
void loop() {
|
||||
if (millis() - lastSendTime > interval) {
|
||||
String message = "HeLoRa World! "; // send a message
|
||||
message += msgCount;
|
||||
sendMessage(message);
|
||||
Serial.println("Sending " + message);
|
||||
lastSendTime = millis(); // timestamp the message
|
||||
interval = random(2000) + 1000; // 2-3 seconds
|
||||
msgCount++;
|
||||
}
|
||||
|
||||
// parse for a packet, and call onReceive with the result:
|
||||
onReceive(LoRa.parsePacket());
|
||||
}
|
||||
|
||||
void sendMessage(String outgoing) {
|
||||
LoRa.beginPacket(); // start packet
|
||||
LoRa.print(outgoing); // add payload
|
||||
LoRa.endPacket(); // finish packet and send it
|
||||
msgCount++; // increment message ID
|
||||
}
|
||||
|
||||
void onReceive(int packetSize) {
|
||||
if (packetSize == 0) return; // if there's no packet, return
|
||||
|
||||
// read packet header bytes:
|
||||
String incoming = "";
|
||||
|
||||
while (LoRa.available()) {
|
||||
incoming += (char)LoRa.read();
|
||||
}
|
||||
|
||||
Serial.println("Message: " + incoming);
|
||||
Serial.println("RSSI: " + String(LoRa.packetRssi()));
|
||||
Serial.println("Snr: " + String(LoRa.packetSnr()));
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
#######################################
|
||||
# Syntax Coloring Map For LoRa
|
||||
#######################################
|
||||
|
||||
#######################################
|
||||
# Datatypes (KEYWORD1)
|
||||
#######################################
|
||||
|
||||
LoRa KEYWORD1
|
||||
|
||||
#######################################
|
||||
# Methods and Functions (KEYWORD2)
|
||||
#######################################
|
||||
|
||||
begin KEYWORD2
|
||||
end KEYWORD2
|
||||
|
||||
beginPacket KEYWORD2
|
||||
endPacket KEYWORD2
|
||||
|
||||
parsePacket KEYWORD2
|
||||
packetRssi KEYWORD2
|
||||
packetSnr KEYWORD2
|
||||
packetFrequencyError KEYWORD2
|
||||
|
||||
write KEYWORD2
|
||||
|
||||
available KEYWORD2
|
||||
read KEYWORD2
|
||||
peek KEYWORD2
|
||||
flush KEYWORD2
|
||||
|
||||
onReceive KEYWORD2
|
||||
receive KEYWORD2
|
||||
idle KEYWORD2
|
||||
sleep KEYWORD2
|
||||
|
||||
setTxPower KEYWORD2
|
||||
setFrequency KEYWORD2
|
||||
setSpreadingFactor KEYWORD2
|
||||
setSignalBandwidth KEYWORD2
|
||||
setCodingRate4 KEYWORD2
|
||||
setPreambleLength KEYWORD2
|
||||
setSyncWord KEYWORD2
|
||||
enableCrc KEYWORD2
|
||||
disableCrc KEYWORD2
|
||||
|
||||
random KEYWORD2
|
||||
setPins KEYWORD2
|
||||
setSPIFrequency KEYWORD2
|
||||
dumpRegisters KEYWORD2
|
||||
|
||||
#######################################
|
||||
# Constants (LITERAL1)
|
||||
#######################################
|
||||
|
||||
PA_OUTPUT_RFO_PIN LITERAL1
|
||||
PA_OUTPUT_PA_BOOST_PIN LITERAL1
|
||||
@@ -0,0 +1,10 @@
|
||||
name=LoRa
|
||||
version=0.5.0
|
||||
author=Sandeep Mistry <sandeep.mistry@gmail.com>
|
||||
maintainer=Sandeep Mistry <sandeep.mistry@gmail.com>
|
||||
sentence=An Arduino library for sending and receiving data using LoRa radios.
|
||||
paragraph=Supports Semtech SX1276/77/78/79 based boards/shields.
|
||||
category=Communication
|
||||
url=https://github.com/sandeepmistry/arduino-LoRa
|
||||
architectures=*
|
||||
includes=LoRa.h
|
||||
@@ -0,0 +1,618 @@
|
||||
// Copyright (c) Sandeep Mistry. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
#include <LoRa.h>
|
||||
|
||||
// registers
|
||||
#define REG_FIFO 0x00
|
||||
#define REG_OP_MODE 0x01
|
||||
#define REG_FRF_MSB 0x06
|
||||
#define REG_FRF_MID 0x07
|
||||
#define REG_FRF_LSB 0x08
|
||||
#define REG_PA_CONFIG 0x09
|
||||
#define REG_LNA 0x0c
|
||||
#define REG_FIFO_ADDR_PTR 0x0d
|
||||
#define REG_FIFO_TX_BASE_ADDR 0x0e
|
||||
#define REG_FIFO_RX_BASE_ADDR 0x0f
|
||||
#define REG_FIFO_RX_CURRENT_ADDR 0x10
|
||||
#define REG_IRQ_FLAGS 0x12
|
||||
#define REG_RX_NB_BYTES 0x13
|
||||
#define REG_PKT_SNR_VALUE 0x19
|
||||
#define REG_PKT_RSSI_VALUE 0x1a
|
||||
#define REG_MODEM_CONFIG_1 0x1d
|
||||
#define REG_MODEM_CONFIG_2 0x1e
|
||||
#define REG_PREAMBLE_MSB 0x20
|
||||
#define REG_PREAMBLE_LSB 0x21
|
||||
#define REG_PAYLOAD_LENGTH 0x22
|
||||
#define REG_MODEM_CONFIG_3 0x26
|
||||
#define REG_FREQ_ERROR_MSB 0x28
|
||||
#define REG_FREQ_ERROR_MID 0x29
|
||||
#define REG_FREQ_ERROR_LSB 0x2a
|
||||
#define REG_RSSI_WIDEBAND 0x2c
|
||||
#define REG_DETECTION_OPTIMIZE 0x31
|
||||
#define REG_DETECTION_THRESHOLD 0x37
|
||||
#define REG_SYNC_WORD 0x39
|
||||
#define REG_DIO_MAPPING_1 0x40
|
||||
#define REG_VERSION 0x42
|
||||
|
||||
// modes
|
||||
#define MODE_LONG_RANGE_MODE 0x80
|
||||
#define MODE_SLEEP 0x00
|
||||
#define MODE_STDBY 0x01
|
||||
#define MODE_TX 0x03
|
||||
#define MODE_RX_CONTINUOUS 0x05
|
||||
#define MODE_RX_SINGLE 0x06
|
||||
|
||||
// PA config
|
||||
#define PA_BOOST 0x80
|
||||
|
||||
// IRQ masks
|
||||
#define IRQ_TX_DONE_MASK 0x08
|
||||
#define IRQ_PAYLOAD_CRC_ERROR_MASK 0x20
|
||||
#define IRQ_RX_DONE_MASK 0x40
|
||||
|
||||
#define MAX_PKT_LENGTH 255
|
||||
|
||||
LoRaClass::LoRaClass() :
|
||||
_spiSettings(LORA_DEFAULT_SPI_FREQUENCY, MSBFIRST, SPI_MODE0),
|
||||
_spi(&LORA_DEFAULT_SPI),
|
||||
_ss(LORA_DEFAULT_SS_PIN), _reset(LORA_DEFAULT_RESET_PIN), _dio0(LORA_DEFAULT_DIO0_PIN),
|
||||
_frequency(0),
|
||||
_packetIndex(0),
|
||||
_implicitHeaderMode(0),
|
||||
_onReceive(NULL)
|
||||
{
|
||||
// overide Stream timeout value
|
||||
setTimeout(0);
|
||||
}
|
||||
|
||||
int LoRaClass::begin(long frequency)
|
||||
{
|
||||
#ifdef ARDUINO_SAMD_MKRWAN1300
|
||||
pinMode(LORA_IRQ_DUMB, OUTPUT);
|
||||
digitalWrite(LORA_IRQ_DUMB, LOW);
|
||||
|
||||
// Hardware reset
|
||||
pinMode(LORA_BOOT0, OUTPUT);
|
||||
digitalWrite(LORA_BOOT0, LOW);
|
||||
|
||||
pinMode(LORA_RESET, OUTPUT);
|
||||
digitalWrite(LORA_RESET, HIGH);
|
||||
delay(200);
|
||||
digitalWrite(LORA_RESET, LOW);
|
||||
delay(200);
|
||||
digitalWrite(LORA_RESET, HIGH);
|
||||
delay(50);
|
||||
#endif
|
||||
|
||||
// setup pins
|
||||
pinMode(_ss, OUTPUT);
|
||||
// set SS high
|
||||
digitalWrite(_ss, HIGH);
|
||||
|
||||
if (_reset != -1) {
|
||||
pinMode(_reset, OUTPUT);
|
||||
|
||||
// perform reset
|
||||
digitalWrite(_reset, LOW);
|
||||
delay(10);
|
||||
digitalWrite(_reset, HIGH);
|
||||
delay(10);
|
||||
}
|
||||
|
||||
// start SPI
|
||||
_spi->begin();
|
||||
|
||||
// check version
|
||||
uint8_t version = readRegister(REG_VERSION);
|
||||
if (version != 0x12) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// put in sleep mode
|
||||
sleep();
|
||||
|
||||
// set frequency
|
||||
setFrequency(frequency);
|
||||
|
||||
// set base addresses
|
||||
writeRegister(REG_FIFO_TX_BASE_ADDR, 0);
|
||||
writeRegister(REG_FIFO_RX_BASE_ADDR, 0);
|
||||
|
||||
// set LNA boost
|
||||
writeRegister(REG_LNA, readRegister(REG_LNA) | 0x03);
|
||||
|
||||
// set auto AGC
|
||||
writeRegister(REG_MODEM_CONFIG_3, 0x04);
|
||||
|
||||
// set output power to 17 dBm
|
||||
setTxPower(17);
|
||||
|
||||
// put in standby mode
|
||||
idle();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void LoRaClass::end()
|
||||
{
|
||||
// put in sleep mode
|
||||
sleep();
|
||||
|
||||
// stop SPI
|
||||
_spi->end();
|
||||
}
|
||||
|
||||
int LoRaClass::beginPacket(int implicitHeader)
|
||||
{
|
||||
// put in standby mode
|
||||
idle();
|
||||
|
||||
if (implicitHeader) {
|
||||
implicitHeaderMode();
|
||||
} else {
|
||||
explicitHeaderMode();
|
||||
}
|
||||
|
||||
// reset FIFO address and paload length
|
||||
writeRegister(REG_FIFO_ADDR_PTR, 0);
|
||||
writeRegister(REG_PAYLOAD_LENGTH, 0);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int LoRaClass::endPacket()
|
||||
{
|
||||
// put in TX mode
|
||||
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_TX);
|
||||
|
||||
// wait for TX done
|
||||
while ((readRegister(REG_IRQ_FLAGS) & IRQ_TX_DONE_MASK) == 0) {
|
||||
yield();
|
||||
}
|
||||
|
||||
// clear IRQ's
|
||||
writeRegister(REG_IRQ_FLAGS, IRQ_TX_DONE_MASK);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int LoRaClass::parsePacket(int size)
|
||||
{
|
||||
int packetLength = 0;
|
||||
int irqFlags = readRegister(REG_IRQ_FLAGS);
|
||||
|
||||
if (size > 0) {
|
||||
implicitHeaderMode();
|
||||
|
||||
writeRegister(REG_PAYLOAD_LENGTH, size & 0xff);
|
||||
} else {
|
||||
explicitHeaderMode();
|
||||
}
|
||||
|
||||
// clear IRQ's
|
||||
writeRegister(REG_IRQ_FLAGS, irqFlags);
|
||||
|
||||
if ((irqFlags & IRQ_RX_DONE_MASK) && (irqFlags & IRQ_PAYLOAD_CRC_ERROR_MASK) == 0) {
|
||||
// received a packet
|
||||
_packetIndex = 0;
|
||||
|
||||
// read packet length
|
||||
if (_implicitHeaderMode) {
|
||||
packetLength = readRegister(REG_PAYLOAD_LENGTH);
|
||||
} else {
|
||||
packetLength = readRegister(REG_RX_NB_BYTES);
|
||||
}
|
||||
|
||||
// set FIFO address to current RX address
|
||||
writeRegister(REG_FIFO_ADDR_PTR, readRegister(REG_FIFO_RX_CURRENT_ADDR));
|
||||
|
||||
// put in standby mode
|
||||
idle();
|
||||
} else if (readRegister(REG_OP_MODE) != (MODE_LONG_RANGE_MODE | MODE_RX_SINGLE)) {
|
||||
// not currently in RX mode
|
||||
|
||||
// reset FIFO address
|
||||
writeRegister(REG_FIFO_ADDR_PTR, 0);
|
||||
|
||||
// put in single RX mode
|
||||
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_RX_SINGLE);
|
||||
}
|
||||
|
||||
return packetLength;
|
||||
}
|
||||
|
||||
int LoRaClass::packetRssi()
|
||||
{
|
||||
return (readRegister(REG_PKT_RSSI_VALUE) - (_frequency < 868E6 ? 164 : 157));
|
||||
}
|
||||
|
||||
float LoRaClass::packetSnr()
|
||||
{
|
||||
return ((int8_t)readRegister(REG_PKT_SNR_VALUE)) * 0.25;
|
||||
}
|
||||
|
||||
long LoRaClass::packetFrequencyError()
|
||||
{
|
||||
int32_t freqError = 0;
|
||||
freqError = static_cast<int32_t>(readRegister(REG_FREQ_ERROR_MSB) & B111);
|
||||
freqError <<= 8L;
|
||||
freqError += static_cast<int32_t>(readRegister(REG_FREQ_ERROR_MID));
|
||||
freqError <<= 8L;
|
||||
freqError += static_cast<int32_t>(readRegister(REG_FREQ_ERROR_LSB));
|
||||
|
||||
if (readRegister(REG_FREQ_ERROR_MSB) & B1000) { // Sign bit is on
|
||||
freqError -= 524288; // B1000'0000'0000'0000'0000
|
||||
}
|
||||
|
||||
const float fXtal = 32E6; // FXOSC: crystal oscillator (XTAL) frequency (2.5. Chip Specification, p. 14)
|
||||
const float fError = ((static_cast<float>(freqError) * (1L << 24)) / fXtal) * (getSignalBandwidth() / 500000.0f); // p. 37
|
||||
|
||||
return static_cast<long>(fError);
|
||||
}
|
||||
|
||||
size_t LoRaClass::write(uint8_t byte)
|
||||
{
|
||||
return write(&byte, sizeof(byte));
|
||||
}
|
||||
|
||||
size_t LoRaClass::write(const uint8_t *buffer, size_t size)
|
||||
{
|
||||
int currentLength = readRegister(REG_PAYLOAD_LENGTH);
|
||||
|
||||
// check size
|
||||
if ((currentLength + size) > MAX_PKT_LENGTH) {
|
||||
size = MAX_PKT_LENGTH - currentLength;
|
||||
}
|
||||
|
||||
// write data
|
||||
for (size_t i = 0; i < size; i++) {
|
||||
writeRegister(REG_FIFO, buffer[i]);
|
||||
}
|
||||
|
||||
// update length
|
||||
writeRegister(REG_PAYLOAD_LENGTH, currentLength + size);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int LoRaClass::available()
|
||||
{
|
||||
return (readRegister(REG_RX_NB_BYTES) - _packetIndex);
|
||||
}
|
||||
|
||||
int LoRaClass::read()
|
||||
{
|
||||
if (!available()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
_packetIndex++;
|
||||
|
||||
return readRegister(REG_FIFO);
|
||||
}
|
||||
|
||||
int LoRaClass::peek()
|
||||
{
|
||||
if (!available()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// store current FIFO address
|
||||
int currentAddress = readRegister(REG_FIFO_ADDR_PTR);
|
||||
|
||||
// read
|
||||
uint8_t b = readRegister(REG_FIFO);
|
||||
|
||||
// restore FIFO address
|
||||
writeRegister(REG_FIFO_ADDR_PTR, currentAddress);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
void LoRaClass::flush()
|
||||
{
|
||||
}
|
||||
|
||||
#ifndef ARDUINO_SAMD_MKRWAN1300
|
||||
void LoRaClass::onReceive(void(*callback)(int))
|
||||
{
|
||||
_onReceive = callback;
|
||||
|
||||
if (callback) {
|
||||
pinMode(_dio0, INPUT);
|
||||
|
||||
writeRegister(REG_DIO_MAPPING_1, 0x00);
|
||||
#ifdef SPI_HAS_NOTUSINGINTERRUPT
|
||||
SPI.usingInterrupt(digitalPinToInterrupt(_dio0));
|
||||
#endif
|
||||
attachInterrupt(digitalPinToInterrupt(_dio0), LoRaClass::onDio0Rise, RISING);
|
||||
} else {
|
||||
detachInterrupt(digitalPinToInterrupt(_dio0));
|
||||
#ifdef SPI_HAS_NOTUSINGINTERRUPT
|
||||
SPI.notUsingInterrupt(digitalPinToInterrupt(_dio0));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void LoRaClass::receive(int size)
|
||||
{
|
||||
if (size > 0) {
|
||||
implicitHeaderMode();
|
||||
|
||||
writeRegister(REG_PAYLOAD_LENGTH, size & 0xff);
|
||||
} else {
|
||||
explicitHeaderMode();
|
||||
}
|
||||
|
||||
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_RX_CONTINUOUS);
|
||||
}
|
||||
#endif
|
||||
|
||||
void LoRaClass::idle()
|
||||
{
|
||||
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_STDBY);
|
||||
}
|
||||
|
||||
void LoRaClass::sleep()
|
||||
{
|
||||
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_SLEEP);
|
||||
}
|
||||
|
||||
void LoRaClass::setTxPower(int level, int outputPin)
|
||||
{
|
||||
if (PA_OUTPUT_RFO_PIN == outputPin) {
|
||||
// RFO
|
||||
if (level < 0) {
|
||||
level = 0;
|
||||
} else if (level > 14) {
|
||||
level = 14;
|
||||
}
|
||||
|
||||
writeRegister(REG_PA_CONFIG, 0x70 | level);
|
||||
} else {
|
||||
// PA BOOST
|
||||
if (level < 2) {
|
||||
level = 2;
|
||||
} else if (level > 17) {
|
||||
level = 17;
|
||||
}
|
||||
|
||||
writeRegister(REG_PA_CONFIG, PA_BOOST | (level - 2));
|
||||
}
|
||||
}
|
||||
|
||||
void LoRaClass::setFrequency(long frequency)
|
||||
{
|
||||
_frequency = frequency;
|
||||
|
||||
uint64_t frf = ((uint64_t)frequency << 19) / 32000000;
|
||||
|
||||
writeRegister(REG_FRF_MSB, (uint8_t)(frf >> 16));
|
||||
writeRegister(REG_FRF_MID, (uint8_t)(frf >> 8));
|
||||
writeRegister(REG_FRF_LSB, (uint8_t)(frf >> 0));
|
||||
}
|
||||
|
||||
int LoRaClass::getSpreadingFactor()
|
||||
{
|
||||
return readRegister(REG_MODEM_CONFIG_2) >> 4;
|
||||
}
|
||||
|
||||
void LoRaClass::setSpreadingFactor(int sf)
|
||||
{
|
||||
if (sf < 6) {
|
||||
sf = 6;
|
||||
} else if (sf > 12) {
|
||||
sf = 12;
|
||||
}
|
||||
|
||||
if (sf == 6) {
|
||||
writeRegister(REG_DETECTION_OPTIMIZE, 0xc5);
|
||||
writeRegister(REG_DETECTION_THRESHOLD, 0x0c);
|
||||
} else {
|
||||
writeRegister(REG_DETECTION_OPTIMIZE, 0xc3);
|
||||
writeRegister(REG_DETECTION_THRESHOLD, 0x0a);
|
||||
}
|
||||
|
||||
writeRegister(REG_MODEM_CONFIG_2, (readRegister(REG_MODEM_CONFIG_2) & 0x0f) | ((sf << 4) & 0xf0));
|
||||
setLdoFlag();
|
||||
}
|
||||
|
||||
long LoRaClass::getSignalBandwidth()
|
||||
{
|
||||
byte bw = (readRegister(REG_MODEM_CONFIG_1) >> 4);
|
||||
switch (bw) {
|
||||
case 0: return 7.8E3;
|
||||
case 1: return 10.4E3;
|
||||
case 2: return 15.6E3;
|
||||
case 3: return 20.8E3;
|
||||
case 4: return 31.25E3;
|
||||
case 5: return 41.7E3;
|
||||
case 6: return 62.5E3;
|
||||
case 7: return 125E3;
|
||||
case 8: return 250E3;
|
||||
case 9: return 500E3;
|
||||
}
|
||||
}
|
||||
|
||||
void LoRaClass::setSignalBandwidth(long sbw)
|
||||
{
|
||||
int bw;
|
||||
|
||||
if (sbw <= 7.8E3) {
|
||||
bw = 0;
|
||||
} else if (sbw <= 10.4E3) {
|
||||
bw = 1;
|
||||
} else if (sbw <= 15.6E3) {
|
||||
bw = 2;
|
||||
} else if (sbw <= 20.8E3) {
|
||||
bw = 3;
|
||||
} else if (sbw <= 31.25E3) {
|
||||
bw = 4;
|
||||
} else if (sbw <= 41.7E3) {
|
||||
bw = 5;
|
||||
} else if (sbw <= 62.5E3) {
|
||||
bw = 6;
|
||||
} else if (sbw <= 125E3) {
|
||||
bw = 7;
|
||||
} else if (sbw <= 250E3) {
|
||||
bw = 8;
|
||||
} else /*if (sbw <= 250E3)*/ {
|
||||
bw = 9;
|
||||
}
|
||||
|
||||
writeRegister(REG_MODEM_CONFIG_1, (readRegister(REG_MODEM_CONFIG_1) & 0x0f) | (bw << 4));
|
||||
setLdoFlag();
|
||||
}
|
||||
|
||||
void LoRaClass::setLdoFlag()
|
||||
{
|
||||
// Section 4.1.1.5
|
||||
long symbolDuration = 1000 / ( getSignalBandwidth() / (1L << getSpreadingFactor()) ) ;
|
||||
|
||||
// Section 4.1.1.6
|
||||
boolean ldoOn = symbolDuration > 16;
|
||||
|
||||
uint8_t config3 = readRegister(REG_MODEM_CONFIG_3);
|
||||
bitWrite(config3, 3, ldoOn);
|
||||
writeRegister(REG_MODEM_CONFIG_3, config3);
|
||||
}
|
||||
|
||||
void LoRaClass::setCodingRate4(int denominator)
|
||||
{
|
||||
if (denominator < 5) {
|
||||
denominator = 5;
|
||||
} else if (denominator > 8) {
|
||||
denominator = 8;
|
||||
}
|
||||
|
||||
int cr = denominator - 4;
|
||||
|
||||
writeRegister(REG_MODEM_CONFIG_1, (readRegister(REG_MODEM_CONFIG_1) & 0xf1) | (cr << 1));
|
||||
}
|
||||
|
||||
void LoRaClass::setPreambleLength(long length)
|
||||
{
|
||||
writeRegister(REG_PREAMBLE_MSB, (uint8_t)(length >> 8));
|
||||
writeRegister(REG_PREAMBLE_LSB, (uint8_t)(length >> 0));
|
||||
}
|
||||
|
||||
void LoRaClass::setSyncWord(int sw)
|
||||
{
|
||||
writeRegister(REG_SYNC_WORD, sw);
|
||||
}
|
||||
|
||||
void LoRaClass::enableCrc()
|
||||
{
|
||||
writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) | 0x04);
|
||||
}
|
||||
|
||||
void LoRaClass::disableCrc()
|
||||
{
|
||||
writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) & 0xfb);
|
||||
}
|
||||
|
||||
byte LoRaClass::random()
|
||||
{
|
||||
return readRegister(REG_RSSI_WIDEBAND);
|
||||
}
|
||||
|
||||
void LoRaClass::setPins(int ss, int reset, int dio0)
|
||||
{
|
||||
_ss = ss;
|
||||
_reset = reset;
|
||||
_dio0 = dio0;
|
||||
}
|
||||
|
||||
void LoRaClass::setSPI(SPIClass& spi)
|
||||
{
|
||||
_spi = &spi;
|
||||
}
|
||||
|
||||
void LoRaClass::setSPIFrequency(uint32_t frequency)
|
||||
{
|
||||
_spiSettings = SPISettings(frequency, MSBFIRST, SPI_MODE0);
|
||||
}
|
||||
|
||||
void LoRaClass::dumpRegisters(Stream& out)
|
||||
{
|
||||
for (int i = 0; i < 128; i++) {
|
||||
out.print("0x");
|
||||
out.print(i, HEX);
|
||||
out.print(": 0x");
|
||||
out.println(readRegister(i), HEX);
|
||||
}
|
||||
}
|
||||
|
||||
void LoRaClass::explicitHeaderMode()
|
||||
{
|
||||
_implicitHeaderMode = 0;
|
||||
|
||||
writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) & 0xfe);
|
||||
}
|
||||
|
||||
void LoRaClass::implicitHeaderMode()
|
||||
{
|
||||
_implicitHeaderMode = 1;
|
||||
|
||||
writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) | 0x01);
|
||||
}
|
||||
|
||||
void LoRaClass::handleDio0Rise()
|
||||
{
|
||||
int irqFlags = readRegister(REG_IRQ_FLAGS);
|
||||
|
||||
// clear IRQ's
|
||||
writeRegister(REG_IRQ_FLAGS, irqFlags);
|
||||
|
||||
if ((irqFlags & IRQ_PAYLOAD_CRC_ERROR_MASK) == 0) {
|
||||
// received a packet
|
||||
_packetIndex = 0;
|
||||
|
||||
// read packet length
|
||||
int packetLength = _implicitHeaderMode ? readRegister(REG_PAYLOAD_LENGTH) : readRegister(REG_RX_NB_BYTES);
|
||||
|
||||
// set FIFO address to current RX address
|
||||
writeRegister(REG_FIFO_ADDR_PTR, readRegister(REG_FIFO_RX_CURRENT_ADDR));
|
||||
|
||||
if (_onReceive) {
|
||||
_onReceive(packetLength);
|
||||
}
|
||||
|
||||
// reset FIFO address
|
||||
writeRegister(REG_FIFO_ADDR_PTR, 0);
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t LoRaClass::readRegister(uint8_t address)
|
||||
{
|
||||
return singleTransfer(address & 0x7f, 0x00);
|
||||
}
|
||||
|
||||
void LoRaClass::writeRegister(uint8_t address, uint8_t value)
|
||||
{
|
||||
singleTransfer(address | 0x80, value);
|
||||
}
|
||||
|
||||
uint8_t LoRaClass::singleTransfer(uint8_t address, uint8_t value)
|
||||
{
|
||||
uint8_t response;
|
||||
|
||||
digitalWrite(_ss, LOW);
|
||||
|
||||
_spi->beginTransaction(_spiSettings);
|
||||
_spi->transfer(address);
|
||||
response = _spi->transfer(value);
|
||||
_spi->endTransaction();
|
||||
|
||||
digitalWrite(_ss, HIGH);
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
void LoRaClass::onDio0Rise()
|
||||
{
|
||||
LoRa.handleDio0Rise();
|
||||
}
|
||||
|
||||
LoRaClass LoRa;
|
||||
@@ -0,0 +1,113 @@
|
||||
// Copyright (c) Sandeep Mistry. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
#ifndef LORA_H
|
||||
#define LORA_H
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <SPI.h>
|
||||
|
||||
#ifdef ARDUINO_SAMD_MKRWAN1300
|
||||
#define LORA_DEFAULT_SPI SPI1
|
||||
#define LORA_DEFAULT_SPI_FREQUENCY 250000
|
||||
#define LORA_DEFAULT_SS_PIN LORA_IRQ_DUMB
|
||||
#define LORA_DEFAULT_RESET_PIN -1
|
||||
#define LORA_DEFAULT_DIO0_PIN -1
|
||||
#else
|
||||
#define LORA_DEFAULT_SPI SPI
|
||||
#define LORA_DEFAULT_SPI_FREQUENCY 8E6
|
||||
#define LORA_DEFAULT_SS_PIN 10
|
||||
#define LORA_DEFAULT_RESET_PIN 9
|
||||
#define LORA_DEFAULT_DIO0_PIN 2
|
||||
#endif
|
||||
|
||||
#define PA_OUTPUT_RFO_PIN 0
|
||||
#define PA_OUTPUT_PA_BOOST_PIN 1
|
||||
|
||||
class LoRaClass : public Stream {
|
||||
public:
|
||||
LoRaClass();
|
||||
|
||||
int begin(long frequency);
|
||||
void end();
|
||||
|
||||
int beginPacket(int implicitHeader = false);
|
||||
int endPacket();
|
||||
|
||||
int parsePacket(int size = 0);
|
||||
int packetRssi();
|
||||
float packetSnr();
|
||||
long packetFrequencyError();
|
||||
|
||||
// from Print
|
||||
virtual size_t write(uint8_t byte);
|
||||
virtual size_t write(const uint8_t *buffer, size_t size);
|
||||
|
||||
// from Stream
|
||||
virtual int available();
|
||||
virtual int read();
|
||||
virtual int peek();
|
||||
virtual void flush();
|
||||
|
||||
#ifndef ARDUINO_SAMD_MKRWAN1300
|
||||
void onReceive(void(*callback)(int));
|
||||
|
||||
void receive(int size = 0);
|
||||
#endif
|
||||
void idle();
|
||||
void sleep();
|
||||
|
||||
void setTxPower(int level, int outputPin = PA_OUTPUT_PA_BOOST_PIN);
|
||||
void setFrequency(long frequency);
|
||||
void setSpreadingFactor(int sf);
|
||||
void setSignalBandwidth(long sbw);
|
||||
void setCodingRate4(int denominator);
|
||||
void setPreambleLength(long length);
|
||||
void setSyncWord(int sw);
|
||||
void enableCrc();
|
||||
void disableCrc();
|
||||
|
||||
// deprecated
|
||||
void crc() { enableCrc(); }
|
||||
void noCrc() { disableCrc(); }
|
||||
|
||||
byte random();
|
||||
|
||||
void setPins(int ss = LORA_DEFAULT_SS_PIN, int reset = LORA_DEFAULT_RESET_PIN, int dio0 = LORA_DEFAULT_DIO0_PIN);
|
||||
void setSPI(SPIClass& spi);
|
||||
void setSPIFrequency(uint32_t frequency);
|
||||
|
||||
void dumpRegisters(Stream& out);
|
||||
|
||||
private:
|
||||
void explicitHeaderMode();
|
||||
void implicitHeaderMode();
|
||||
|
||||
void handleDio0Rise();
|
||||
|
||||
int getSpreadingFactor();
|
||||
long getSignalBandwidth();
|
||||
|
||||
void setLdoFlag();
|
||||
|
||||
uint8_t readRegister(uint8_t address);
|
||||
void writeRegister(uint8_t address, uint8_t value);
|
||||
uint8_t singleTransfer(uint8_t address, uint8_t value);
|
||||
|
||||
static void onDio0Rise();
|
||||
|
||||
private:
|
||||
SPISettings _spiSettings;
|
||||
SPIClass* _spi;
|
||||
int _ss;
|
||||
int _reset;
|
||||
int _dio0;
|
||||
long _frequency;
|
||||
int _packetIndex;
|
||||
int _implicitHeaderMode;
|
||||
void (*_onReceive)(int);
|
||||
};
|
||||
|
||||
extern LoRaClass LoRa;
|
||||
|
||||
#endif
|
||||
@@ -111,6 +111,7 @@ const byte subnet[] = { 255, 255, 255, 0 }; //ip adress
|
||||
//Addons and module management, comment the Z line and the config file if you don't use
|
||||
#if defined(ESP8266) // for nodemcu, weemos, esp8266, and Arduino mega
|
||||
#define ZgatewayRF "RF"
|
||||
//#define ZgatewayLORA "LORA" (not tested yet)
|
||||
#define ZgatewayRF315 "RF315"
|
||||
#define ZgatewaySRFB "SRFB"
|
||||
#define ZgatewayRF2 "RF2"
|
||||
@@ -134,6 +135,7 @@ const byte subnet[] = { 255, 255, 255, 0 }; //ip adress
|
||||
#define simplePublishing true
|
||||
#elif ESP32
|
||||
#define ZgatewayRF "RF"
|
||||
#define ZgatewayLORA "LORA"
|
||||
#define ZgatewayRF "RF315"
|
||||
#define ZgatewayRF2 "RF2"
|
||||
//#define Zgateway2G (not tested yet)
|
||||
@@ -155,6 +157,7 @@ const byte subnet[] = { 255, 255, 255, 0 }; //ip adress
|
||||
#define simplePublishing true
|
||||
#elif defined(__AVR_ATmega1280__)
|
||||
#define ZgatewayRF "RF"
|
||||
//#define ZgatewayLORA "LORA" (not tested yet)
|
||||
#define ZgatewayRF315 "RF315"
|
||||
#define ZgatewaySRFB "SRFB"
|
||||
#define ZgatewayRF2 "RF2"
|
||||
@@ -178,6 +181,7 @@ const byte subnet[] = { 255, 255, 255, 0 }; //ip adress
|
||||
#define simplePublishing true
|
||||
#else // for arduino Uno
|
||||
#define ZgatewayRF "RF"
|
||||
//#define ZgatewayLORA "LORA" (not tested yet)
|
||||
//#define Zgateway2G (not tested yet)
|
||||
//#define ZgatewayRF2 // too big for UNO
|
||||
//#define ZgatewayIR
|
||||
|
||||
Reference in new issue
Block a user