vlad/Rocket2021
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Vlad Utkin
2021-05-11 20:43:42 +03:00
commit 9f3ffaba30
381 changed files with 69596 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
lib/SX12XX-LoRa/examples/SX126x_examples/Sleep/5_LoRa_TX_Sleep_Timed_Wakeup_Atmel/5_LoRa_TX_Sleep_Timed_Wakeup_Atmel.ino Normal file
View File

@@ -0,0 +1,242 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 29/02/20
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
/*******************************************************************************************************
Program Operation - This program tests the sleep mode and register retention of the lora device in sleep
mode, it assumes an Atmel ATMega328P processor is in use. The LoRa settings to use are specified in the
'Settings.h' file.
A packet is sent, containing the text 'Before Device Sleep' and the LoRa device and Atmel processor are put
to sleep. The processor watchdog timer should wakeup the processor in 15 seconds (approx) and register
values should be retained. The device then attempts to transmit another packet 'After Device Sleep'
without re-loading all the LoRa settings. The receiver should see 'After Device Sleep' for the first
packet and 'After Device Sleep' for the second.
Tested on a 'bare bones' ATmega328P board, the current in sleep mode was 6.5uA.
Serial monitor baud rate is set at 9600.
*******************************************************************************************************/
#define Program_Version "V1.0"
#include <avr/wdt.h> //watchdog timer library, integral to Arduino IDE
#include <SPI.h>
#include <LowPower.h> //get the library here; https://github.com/rocketscream/Low-Power
#include <SX126XLT.h>
#include "Settings.h"
SX126XLT LT;
boolean SendOK;
int8_t TestPower;
uint8_t TXPacketL;
void loop()
{
digitalWrite(LED1, HIGH);
Serial.print(TXpower);
Serial.print(F("dBm "));
Serial.print(F("TestPacket1> "));
Serial.flush();
if (Send_Test_Packet1())
{
packet_is_OK();
}
else
{
packet_is_Error();
}
Serial.println();
delay(packet_delay);
LT.setSleep(CONFIGURATION_RETENTION); //preserve register settings in sleep.
Serial.println(F("Sleeping zzzzz...."));
Serial.println();
Serial.flush();
digitalWrite(LED1, LOW);
sleep1second(15); //goto sleep for 15 seconds
Serial.println(F("Awake !"));
Serial.flush();
digitalWrite(LED1, HIGH);
LT.wake();
Serial.print(TXpower);
Serial.print(F("dBm "));
Serial.print(F("TestPacket2> "));
Serial.flush();
if (Send_Test_Packet2())
{
packet_is_OK();
}
else
{
packet_is_Error();
}
Serial.println();
delay(packet_delay);
}
void sleep1second(uint32_t sleeps)
{
//uses the lowpower library
uint32_t index;
for (index = 1; index <= sleeps; index++)
{
LowPower.powerDown(SLEEP_1S, ADC_OFF, BOD_OFF); //sleep in 1 second steps
}
}
void packet_is_OK()
{
Serial.print(F(" "));
Serial.print(TXPacketL);
Serial.print(F(" Bytes SentOK"));
}
void packet_is_Error()
{
uint16_t IRQStatus;
IRQStatus = LT.readIrqStatus(); //get the IRQ status
Serial.print(F("SendError,"));
Serial.print(F("Length,"));
Serial.print(TXPacketL);
Serial.print(F(",IRQreg,"));
Serial.print(IRQStatus, HEX);
LT.printIrqStatus();
digitalWrite(LED1, LOW); //this leaves the LED on slightly longer for a packet error
}
bool Send_Test_Packet1()
{
uint8_t bufffersize;
uint8_t buff[] = "Before Device Sleep";
TXPacketL = sizeof(buff);
buff[TXPacketL - 1] = '*';
if (sizeof(buff) > TXBUFFER_SIZE) //check that defined buffer is not larger than TX_BUFFER
{
bufffersize = TXBUFFER_SIZE;
}
else
{
bufffersize = sizeof(buff);
}
TXPacketL = bufffersize;
LT.printASCIIPacket( (uint8_t*) buff, bufffersize);
digitalWrite(LED1, HIGH);
if (LT.transmit( (uint8_t*) buff, TXPacketL, 10000, TXpower, WAIT_TX))
{
digitalWrite(LED1, LOW);
return true;
}
else
{
return false;
}
}
bool Send_Test_Packet2()
{
uint8_t bufffersize;
uint8_t buff[] = "After Device Sleep";
TXPacketL = sizeof(buff);
buff[TXPacketL - 1] = '*';
if (sizeof(buff) > TXBUFFER_SIZE) //check that defined buffer is not larger than TX_BUFFER
{
bufffersize = TXBUFFER_SIZE;
}
else
{
bufffersize = sizeof(buff);
}
TXPacketL = bufffersize;
LT.printASCIIPacket( (uint8_t*) buff, bufffersize);
digitalWrite(LED1, HIGH);
if (LT.transmit( (uint8_t*) buff, TXPacketL, 10000, TXpower, WAIT_TX))
{
digitalWrite(LED1, LOW);
return true;
}
else
{
return false;
}
}
void led_Flash(uint16_t flashes, uint16_t delaymS)
{
uint16_t index;
for (index = 1; index <= flashes; index++)
{
digitalWrite(LED1, HIGH);
delay(delaymS);
digitalWrite(LED1, LOW);
delay(delaymS);
}
}
void setup()
{
pinMode(LED1, OUTPUT); //setup pin as output for indicator LED
led_Flash(2, 125); //two quick LED flashes to indicate program start
Serial.begin(9600);
Serial.println();
Serial.print(__TIME__);
Serial.print(F(" "));
Serial.println(__DATE__);
Serial.println(F(Program_Version));
Serial.println();
Serial.println(F("5_LoRa_TX_Sleep_Timed_Wakeup_Atmel Starting"));
SPI.begin();
if (LT.begin(NSS, NRESET, RFBUSY, DIO1, SW, LORA_DEVICE))
{
Serial.println(F("LoRa Device found"));
led_Flash(2, 125);
delay(1000);
}
else
{
Serial.println(F("No device responding"));
while (1)
{
led_Flash(50, 50); //long fast speed flash indicates device error
}
}
LT.setupLoRa(Frequency, Offset, SpreadingFactor, Bandwidth, CodeRate, Optimisation);
Serial.print(F("Transmitter ready - TXBUFFER_SIZE "));
Serial.println(TXBUFFER_SIZE);
Serial.println();
}

45
lib/SX12XX-LoRa/examples/SX126x_examples/Sleep/5_LoRa_TX_Sleep_Timed_Wakeup_Atmel/Settings.h Normal file
View File

@@ -0,0 +1,45 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 29/02/20
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
//******* Setup hardware pin definitions here ! ***************
//These are the pin definitions for one of my own boards, the Easy Pro Mini,
//be sure to change the definitions to match your own setup. Some pins such as DIO2,
//DIO2, BUZZER may not be in used by this sketch so they do not need to be
//connected and should be set to -1.
#define NSS 10 //select pin on LoRa device
#define NRESET 9 //reset pin on LoRa device
#define LED1 8 //on board LED, high for on
#define RFBUSY 7 //SX126X busy pin
#define DIO1 3 //DIO1 pin on LoRa device, used for RX and TX done
#define DIO2 -1 //DIO2 pin on LoRa device, normally not used so set to -1
#define DIO3 -1 //DIO3 pin on LoRa device, normally not used so set to -1
#define SW -1 //SW pin on Dorji devices is used to turn RF switch on\off, set to -1 if not used
#define BUZZER 4 //pin for buzzer, on when logic high
#define LORA_DEVICE DEVICE_SX1262 //we need to define the device we are using
//******* Setup LoRa Parameters Here ! ***************
//LoRa Modem Parameters
const uint32_t Frequency = 434000000; //frequency of transmissions in hertz
const uint32_t Offset = 0; //offset frequency for calibration purposes
const uint8_t Bandwidth = LORA_BW_125; //LoRa bandwidth
const uint8_t SpreadingFactor = LORA_SF7; //LoRa spreading factor
const uint8_t CodeRate = LORA_CR_4_5; //LoRa coding rate
const uint8_t Optimisation = LDRO_AUTO; //low data rate optimisation setting, normally set to auto
const int8_t TXpower = 10; //LoRa transmit power in dBm
const uint16_t packet_delay = 1000; //mS delay between packets
#define TXBUFFER_SIZE 32 //RX buffer size

224
lib/SX12XX-LoRa/examples/SX126x_examples/Sleep/62_LoRa_Wake_on_RX_Atmel/62_LoRa_Wake_on_RX_Atmel.ino Normal file
View File

@@ -0,0 +1,224 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 19/06/20
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
/*******************************************************************************************************
Program Operation - The program listens for incoming packets using the LoRa settings in the 'Settings.h'
file. The pins to access the lora device need to be defined in the 'Settings.h' file also.
When the program starts the LoRa device is setup to recieve packets with pin DIO1 set to go high when a
packet arrives. The receiver remains powered (it cannot receive otherwise) and the processor
(Atmel ATMega328P or 1284P) is put to sleep. When pin DIO1 does go high, indicating a packet is received,
the processor wakes up and prints the packet. It then goes back to sleep.
There is a printout of the valid packets received, these are assumed to be in ASCII printable text.
The LED will flash for each packet received and the buzzer will sound,if fitted.
Tested on a 'bare bones' ATmega328P board, the current in sleep mode was 6.53mA.
Serial monitor baud rate is set at 9600.
*******************************************************************************************************/
#define Program_Version "V1.1"
#include <SPI.h>
#include <SX126XLT.h>
#include "Settings.h"
#include <avr/sleep.h>
#include <avr/wdt.h>
#include "PinChangeInterrupt.h" //get the library here; https://github.com/NicoHood/PinChangeInterrupt
#include <AtmelSleep.h>
SX126XLT LT;
uint32_t RXpacketCount;
uint32_t errors;
uint8_t RXBUFFER[RXBUFFER_SIZE]; //create a buffer for the received packet
uint8_t RXPacketL; //stores length of packet received
int8_t PacketRSSI; //stores RSSI of received packet
int8_t PacketSNR; //stores signal to noise ratio of received packet
void loop()
{
RXPacketL = LT.receive(RXBUFFER, RXBUFFER_SIZE, 0, NO_WAIT); //setup LoRa device for receive with no timeout
Serial.println(F("Waiting for RX - Sleeping"));
Serial.flush();
attachInterrupt(digitalPinToInterrupt(DIO1), wakeUp, HIGH);
atmelSleepPermanent(); //sleep the processor
detachInterrupt(digitalPinToInterrupt(DIO1));
//something has happened ?
Serial.println(F("Awake"));
digitalWrite(LED1, HIGH);
if (BUZZER > 0)
{
digitalWrite(BUZZER, HIGH);
}
RXPacketL = LT.readPacket(RXBUFFER, RXBUFFER_SIZE); //now read in the received packet to the RX buffer
PacketRSSI = LT.readPacketRSSI();
PacketSNR = LT.readPacketSNR();
if (RXPacketL == 0)
{
packet_is_Error();
}
else
{
packet_is_OK();
}
digitalWrite(LED1, LOW);
if (BUZZER > 0)
{
digitalWrite(BUZZER, LOW);
}
Serial.println();
}
void wakeUp()
{
//handler for the interrupt
}
void packet_is_OK()
{
uint16_t IRQStatus, localCRC;
IRQStatus = LT.readIrqStatus();
RXpacketCount++;
RXPacketL = LT.readPacket(RXBUFFER, RXBUFFER_SIZE); //now read in the received packet to the RX buffer
Serial.print(F("Packet> "));
LT.printASCIIPacket(RXBUFFER, RXPacketL);
localCRC = LT.CRCCCITT(RXBUFFER, RXPacketL, 0xFFFF);
Serial.print(F(" CRC,"));
Serial.print(localCRC, HEX);
Serial.print(F(",RSSI,"));
Serial.print(PacketRSSI);
Serial.print(F("dBm,SNR,"));
Serial.print(PacketSNR);
Serial.print(F("dB,Length,"));
Serial.print(RXPacketL);
Serial.print(F(",Packets,"));
Serial.print(RXpacketCount);
Serial.print(F(",Errors,"));
Serial.print(errors);
Serial.print(F(",IRQreg,"));
Serial.print(IRQStatus, HEX);
Serial.println();
led_Flash(2, 125); //LED flash for approx 10 seconds
}
void packet_is_Error()
{
uint16_t IRQStatus;
IRQStatus = LT.readIrqStatus(); //get the IRQ status
if (IRQStatus & IRQ_RX_TIMEOUT)
{
Serial.println(F("RXTimeout"));
}
else
{
errors++;
Serial.print(F("PacketError"));
Serial.print(F(",RSSI,"));
Serial.print(PacketRSSI);
Serial.print(F("dBm,SNR,"));
Serial.print(PacketSNR);
Serial.print(F("dB,Length,"));
Serial.print(LT.readRXPacketL()); //get the real packet length
Serial.print(F(",Packets,"));
Serial.print(RXpacketCount);
Serial.print(F(",Errors,"));
Serial.print(errors);
Serial.print(F(",IRQreg,"));
Serial.print(IRQStatus, HEX);
LT.printIrqStatus();
Serial.println();
}
}
void led_Flash(uint16_t flashes, uint16_t delaymS)
{
uint16_t index;
for (index = 1; index <= flashes; index++)
{
digitalWrite(LED1, HIGH);
delay(delaymS);
digitalWrite(LED1, LOW);
delay(delaymS);
}
}
void setup()
{
pinMode(LED1, OUTPUT); //setup pin as output for indicator LED
led_Flash(2, 125); //two quick LED flashes to indicate program start
Serial.begin(9600);
Serial.println();
Serial.print(__TIME__);
Serial.print(F(" "));
Serial.println(__DATE__);
Serial.println(F(Program_Version));
Serial.println();
Serial.println(F("62_LoRa_Wake_on_RX_Atmel Starting"));
if (BUZZER > 0)
{
pinMode(BUZZER, OUTPUT);
digitalWrite(BUZZER, HIGH);
delay(50);
digitalWrite(BUZZER, LOW);
}
SPI.begin();
if (LT.begin(NSS, NRESET, RFBUSY, DIO1, LORA_DEVICE))
{
Serial.println(F("Radio Device found"));
led_Flash(2, 125);
delay(1000);
}
else
{
Serial.println(F("No device responding"));
while (1)
{
led_Flash(50, 50);
}
}
LT.setupLoRa(Frequency, Offset, SpreadingFactor, Bandwidth, CodeRate, Optimisation);
Serial.print(F("Receiver ready - RXBUFFER_SIZE "));
Serial.println(RXBUFFER_SIZE);
Serial.println();
}

44
lib/SX12XX-LoRa/examples/SX126x_examples/Sleep/62_LoRa_Wake_on_RX_Atmel/Settings.h Normal file
View File

@@ -0,0 +1,44 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 19/06/20
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
//******* Setup hardware pin definitions here ! ***************
//These are the pin definitions for one of my own boards, the Easy Pro Mini,
//be sure to change the definitions to match your own setup. BUZZER may not be used
//by this sketch so they do not need to be connected and should be set to -1.
#define NSS 10 //select pin on lora device
#define NRESET 9 //reset pin on lora device
#define RFBUSY 7 //busy pin on lora device
#define DIO1 3 //DIO1 pin on lora device, used for RX and TX done
#define LED1 8 //on board LED, high for on
#define BUZZER -1 //pin for buzzer, on when logic high
#define LORA_DEVICE DEVICE_SX1262 //we need to define the device we are using
//******* Setup LoRa Parameters Here ! ***************
//LoRa Modem Parameters
const uint32_t Frequency = 434000000; //frequency of transmissions in hertz
const uint32_t Offset = 0; //offset frequency for calibration purposes
const uint8_t Bandwidth = LORA_BW_125; //LoRa bandwidth
const uint8_t SpreadingFactor = LORA_SF7; //LoRa spreading factor
const uint8_t CodeRate = LORA_CR_4_5; //LoRa coding rate
const uint8_t Optimisation = LDRO_AUTO; //low data rate optimisation setting, normally set to auto
const int8_t TXpower = 10; //LoRa transmit power in dBm
const uint16_t packet_delay = 1000; //mS delay between packets
#define RXBUFFER_SIZE 32 //RX buffer size
const uint16_t packetCRCcheck = 0x3F83; //CRC to check RX packet for
const uint8_t packetCRClengthcheck = 23; //packet length to check for

248
lib/SX12XX-LoRa/examples/SX126x_examples/Sleep/6_LoRa_RX_and_Sleep_Atmel/6_LoRa_RX_and_Sleep_Atmel.ino Normal file
View File

@@ -0,0 +1,248 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 08/04/20
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
/*******************************************************************************************************
Program Operation - The program listens for incoming packets using the LoRa settings in the 'Settings.h'
file. The pins to access the lora device need to be defined in the 'Settings.h' file also.
When the program starts the LoRa device is setup to recieve packets with pin DIO1 set to go high when a
packet arrives. The receiver remains powered (it cannot receive otherwise) and the processor
(Atmel ATMega328P or 1284P) is put to sleep. When pin DIO1 does go high, indicating a packet is received,
the processor wakes up and prints the packet. It then goes back to sleep.
There is a printout of the valid packets received, these are assumed to be in ASCII printable text.
The LED will flash for each packet received and the buzzer will sound,if fitted.
Tested on a 'bare bones' ATmega328P board, the current in sleep mode was 6.51mA, or about half that on
a SX127X setup.
Serial monitor baud rate is set at 9600.
*******************************************************************************************************/
#define Program_Version "V1.0"
#include <SPI.h>
#include <SX126XLT.h>
#include "Settings.h"
#include <avr/sleep.h>
#include "PinChangeInterrupt.h" //get the library here; https://github.com/NicoHood/PinChangeInterrupt
SX126XLT LT;
uint32_t RXpacketCount;
uint32_t errors;
uint8_t RXBUFFER[RXBUFFER_SIZE]; //create a buffer for the received packet
uint8_t RXPacketL; //stores length of packet received
int8_t PacketRSSI; //stores RSSI of received packet
int8_t PacketSNR; //stores signal to noise ratio of received packet
void loop()
{
LT.fillSXBuffer(0, 1, '#'); //make sure the first part of FIFO is cleared, so we can tell its a fresh packet
RXPacketL = LT.receive(RXBUFFER, RXBUFFER_SIZE, 0, NO_WAIT); //setup LoRa device for receive and continue
//receive is setup
Serial.println(F("Going to sleep zzzz"));
Serial.println();
Serial.flush(); //make sure all serial has gone, it can wake up processor
sleep_permanent(); //put processor to sleep, with LoRa device listening, should
//wakeup when DIO1 goes high
Serial.println(F("Awake !!!!"));
digitalWrite(LED1, HIGH); //something has happened ?
if (BUZZER > 0)
{
digitalWrite(BUZZER, HIGH);
}
RXPacketL = LT.readPacket(RXBUFFER, RXBUFFER_SIZE); //now read in the received packet to the RX buffer
PacketRSSI = LT.readPacketRSSI();
PacketSNR = LT.readPacketSNR();
if (RXPacketL == 0)
{
packet_is_Error();
}
else
{
packet_is_OK();
}
digitalWrite(LED1, LOW);
if (BUZZER > 0)
{
digitalWrite(BUZZER, LOW);
}
Serial.println();
}
void sleep_permanent()
{
LT.clearIrqStatus(IRQ_RADIO_ALL); //ensure the DIO1 low is cleared, otherwise there could be an immediate wakeup
attachPCINT(digitalPinToPCINT(DIO1), wakeUp, HIGH); //This is a hardware interrupt, the LoRa device is set for DIOo goes high on RXdone
ADCSRA = 0; //disable ADC
set_sleep_mode (SLEEP_MODE_PWR_DOWN);
noInterrupts (); //timed sequence follows
sleep_enable();
MCUCR = bit (BODS) | bit (BODSE); //turn on brown-out enable select
MCUCR = bit (BODS); //this must be done within 4 clock cycles of above
interrupts (); //guarantees next instruction executed
sleep_cpu (); //sleep within 3 clock cycles of above
/* wake up here */
sleep_disable();
detachPCINT(digitalPinToPCINT(DIO1));
}
void wakeUp()
{
//handler for the interrupt
}
void packet_is_OK()
{
uint16_t IRQStatus, localCRC;
IRQStatus = LT.readIrqStatus();
RXpacketCount++;
RXPacketL = LT.readPacket(RXBUFFER, RXBUFFER_SIZE); //now read in the received packet to the RX buffer
Serial.print(F("Packet> "));
LT.printASCIIPacket(RXBUFFER, RXPacketL);
localCRC = LT.CRCCCITT(RXBUFFER, RXPacketL, 0xFFFF);
Serial.print(F(" CRC,"));
Serial.print(localCRC, HEX);
Serial.print(F(",RSSI,"));
Serial.print(PacketRSSI);
Serial.print(F("dBm,SNR,"));
Serial.print(PacketSNR);
Serial.print(F("dB,Length,"));
Serial.print(RXPacketL);
Serial.print(F(",Packets,"));
Serial.print(RXpacketCount);
Serial.print(F(",Errors,"));
Serial.print(errors);
Serial.print(F(",IRQreg,"));
Serial.print(IRQStatus, HEX);
}
void packet_is_Error()
{
uint16_t IRQStatus;
IRQStatus = LT.readIrqStatus(); //get the IRQ status
if (IRQStatus & IRQ_RX_TIMEOUT)
{
Serial.print(F("RXTimeout"));
}
else
{
errors++;
Serial.print(F("PacketError"));
Serial.print(F(",RSSI,"));
Serial.print(PacketRSSI);
Serial.print(F("dBm,SNR,"));
Serial.print(PacketSNR);
Serial.print(F("dB,Length,"));
Serial.print(LT.readRXPacketL()); //get the real packet length
Serial.print(F(",Packets,"));
Serial.print(RXpacketCount);
Serial.print(F(",Errors,"));
Serial.print(errors);
Serial.print(F(",IRQreg,"));
Serial.print(IRQStatus, HEX);
LT.printIrqStatus();
}
}
void led_Flash(uint16_t flashes, uint16_t delaymS)
{
uint16_t index;
for (index = 1; index <= flashes; index++)
{
digitalWrite(LED1, HIGH);
delay(delaymS);
digitalWrite(LED1, LOW);
delay(delaymS);
}
}
void setup()
{
pinMode(LED1, OUTPUT); //setup pin as output for indicator LED
led_Flash(2, 125); //two quick LED flashes to indicate program start
Serial.begin(9600);
Serial.println();
Serial.print(__TIME__);
Serial.print(F(" "));
Serial.println(__DATE__);
Serial.println(F(Program_Version));
Serial.println();
Serial.println(F("6_LoRa_RX_and_Sleep_Atmel Starting"));
Serial.println();
if (BUZZER > 0)
{
pinMode(BUZZER, OUTPUT);
digitalWrite(BUZZER, HIGH);
delay(50);
digitalWrite(BUZZER, LOW);
}
SPI.begin();
if (LT.begin(NSS, NRESET, RFBUSY, DIO1, SW, LORA_DEVICE))
{
Serial.println(F("Radio Device found"));
led_Flash(2, 125);
delay(1000);
}
else
{
Serial.println(F("No device responding"));
while (1)
{
led_Flash(50, 50);
}
}
LT.setupLoRa(Frequency, Offset, SpreadingFactor, Bandwidth, CodeRate, Optimisation);
Serial.println();
Serial.print(F("Receiver ready - RXBUFFER_SIZE "));
Serial.println(RXBUFFER_SIZE);
Serial.println();
}

44
lib/SX12XX-LoRa/examples/SX126x_examples/Sleep/6_LoRa_RX_and_Sleep_Atmel/Settings.h Normal file
View File

@@ -0,0 +1,44 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 16/12/19
This program is supplied as is, it is up to the user of the program to decide if the program is
suitable for the intended purpose and free from errors.
*******************************************************************************************************/
//******* Setup hardware pin definitions here ! ***************
//These are the pin definitions for one of my own boards, the Easy Pro Mini,
//be sure to change the definitions to match your own setup. Some pins such as DIO2,
//DIO3, BUZZER may not be in used by this sketch so they do not need to be
//connected and should be included and be set to -1.
#define NSS 10 //select pin on LoRa device
#define NRESET 9 //reset pin on LoRa device
#define RFBUSY 7 //SX126X busy pin
#define LED1 8 //on board LED, high for on
#define DIO1 3 //DIO1 pin on LoRa device, used for RX and TX done
#define SW -1 //SW pin on Dorji devices is used to turn RF switch on\off, set to -1 if not used
#define BUZZER -1 //pin for buzzer, on when logic high
#define LORA_DEVICE DEVICE_SX1262 //we need to define the device we are using
//******* Setup LoRa Parameters Here ! ***************
//LoRa Modem Parameters
const uint32_t Frequency = 434000000; //frequency of transmissions in hertz
const uint32_t Offset = 0; //offset frequency for calibration purposes
const uint8_t Bandwidth = LORA_BW_125; //LoRa bandwidth
const uint8_t SpreadingFactor = LORA_SF7; //LoRa spreading factor
const uint8_t CodeRate = LORA_CR_4_5; //LoRa coding rate
const uint8_t Optimisation = LDRO_AUTO; //low data rate optimisation setting, normally set to auto
const int8_t TXpower = 10; //LoRa transmit power in dBm
const uint16_t packet_delay = 1000; //mS delay between packets
#define RXBUFFER_SIZE 32 //RX buffer size