hasanabs/SX128X-LoRa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Init fork from Stuart Robinson's repo

Browse Source
This commit is contained in:
Hasan Albinsaid
2024-10-03 14:30:13 +03:00
commit 9395706524
201 changed files with 45709 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
examples/SX128x_examples/Camera/241_StuartCAM_ESP32CAM_LoRa_Receiver/241_StuartCAM_ESP32CAM_LoRa_Receiver.ino Normal file
View File

@ -0,0 +1,222 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 20/03/22
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 is a receiver program for an ESP32CAM board that has an SPI LoRa module set up
on the following pins; NSS 12, NRESET 14, SCK 4, MISO 13, MOSI 2, RFBUSY 15, 3.3V VCC and GND. All other
pins on the SX128X are not connected. The received pictures are saved to the ESP32CAMs SD card.
Note that the white LED on pin 4 or the transistor controlling it need to be removed so that the LoRa
device can properly use pin 4.
Serial monitor baud rate is set at 115200.
*******************************************************************************************************/
#define USELORA //enable this define to use LoRa packets
//#define USEFLRC //enable this define to use FLRC packets
#include <SPI.h>
#include "FS.h" //SD Card ESP32
#include "SD_MMC.h" //SD Card ESP32
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h" //disable brownout problems
#include "driver/rtc_io.h"
#include <SX128XLT.h> //SX12XX-LoRa library
#include <ProgramLT_Definitions.h> //part of SX12XX-LoRa library
#include "Settings.h" //LoRa settings etc.
#define ENABLEMONITOR //enable this define to monitor data transfer information, needed for ARtransferIRQ.h
#define ENABLEARRAYCRC //enable this define to check and print CRC of sent array
#define PRINTSEGMENTNUM //enable this define to print segment numbers during data transfer
//#define DISABLEPAYLOADCRC //enable this define if you want to disable payload CRC checking
//#define DEBUG //enable more detail of transfer progress
SX128XLT LoRa; //create an SX128XLT library instance called LoRa
#include <ARtransferIRQ.h>
uint8_t *PSRAMptr; //create a global pointer to the array to send, so all functions have access
bool SDOK;
bool savedtoSDOK;
void loop()
{
uint32_t arraylength;
SDOK = false;
Serial.println(F("LoRa file transfer receiver ready"));
setupLoRaDevice();
//if there is a successful array transfer the returned length > 0
arraylength = ARreceiveArray(PSRAMptr, sizeof(ARDTarraysize), ReceiveTimeoutmS);
SPI.end();
digitalWrite(NSS, HIGH);
digitalWrite(NRESET, HIGH);
if (arraylength)
{
Serial.print(F("Returned picture length "));
Serial.println(arraylength);
if (initMicroSDCard())
{
SDOK = true;
Serial.println("SD Card OK");
Serial.print(ARDTfilenamebuff);
Serial.println(F(" Save picture to SD card"));
fs::FS &fs = SD_MMC; //save picture to microSD card
File file = fs.open(ARDTfilenamebuff, FILE_WRITE);
if (!file)
{
Serial.println("*********************************************");
Serial.println("ERROR Failed to open SD file in writing mode");
Serial.println("*********************************************");
savedtoSDOK = false;
}
else
{
file.write(PSRAMptr, arraylength); // pointer to array and length
Serial.print(ARDTfilenamebuff);
Serial.println(" Saved to SD");
savedtoSDOK = true;
}
file.close();
SD_MMC.end();
}
else
{
Serial.println("No SD available");
}
}
else
{
Serial.println(F("Error receiving picture"));
if (ARDTArrayTimeout)
{
Serial.println(F("Timeout receiving picture"));
}
}
Serial.println();
}
bool setupLoRaDevice()
{
SPI.begin(SCK, MISO, MOSI, NSS);
if (LoRa.begin(NSS, NRESET, RFBUSY, LORA_DEVICE))
{
Serial.println(F("LoRa device found"));
}
else
{
Serial.println(F("LoRa Device error"));
return false;
}
#ifdef USELORA
LoRa.setupLoRa(Frequency, Offset, SpreadingFactor, Bandwidth, CodeRate);
Monitorport.println(F("Using LoRa packets"));
#endif
#ifdef USEFLRC
LoRa.setupFLRC(Frequency, Offset, BandwidthBitRate, CodingRate, BT, Syncword);
Monitorport.println(F("Using FLRC packets"));
#endif
#ifdef DISABLEPAYLOADCRC
LoRa.setReliableConfig(NoReliableCRC);
#endif
if (LoRa.getReliableConfig(NoReliableCRC))
{
Serial.println(F("Payload CRC disabled"));
}
else
{
Serial.println(F("Payload CRC enabled"));
}
return true;
}
bool initMicroSDCard()
{
if (!SD_MMC.begin("/sdcard", true)) //use this line for 1 bit mode, pin 2 only, 4,12,13 not used
{
Serial.println("*****************************");
Serial.println("ERROR - SD Card Mount Failed");
Serial.println("*****************************");
return false;
}
uint8_t cardType = SD_MMC.cardType();
if (cardType == CARD_NONE)
{
Serial.println("No SD Card found");
return false;
}
return true;
}
void led_Flash(uint16_t flashes, uint16_t delaymS)
{
uint16_t index;
for (index = 1; index <= flashes; index++)
{
digitalWrite(REDLED, HIGH);
delay(delaymS);
digitalWrite(REDLED, LOW);
delay(delaymS);
}
}
void setup()
{
uint32_t available_PSRAM_size;
uint32_t new_available_PSRAM_size;
//WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
pinMode(REDLED, OUTPUT); //setup pin as output for indicator LED
led_Flash(2, 125); //two quick LED flashes to indicate program start
ARsetDTLED(REDLED); //setup LED pin for data transfer indicator
digitalWrite(NSS, HIGH);
pinMode(NSS, OUTPUT); //disable LoRa device for now
Serial.begin(115200); //format is Serial.begin(baud-rate, protocol, RX pin, TX pin);
Serial.println();
Serial.println(__FILE__);
if (psramInit())
{
Serial.println("PSRAM is correctly initialised");
available_PSRAM_size = ESP.getFreePsram();
Serial.println((String)"PSRAM Size available: " + available_PSRAM_size);
}
else
{
Serial.println("PSRAM not available");
while (1);
}
Serial.println("Allocate array in PSRAM");
uint8_t *byte_array = (uint8_t *) ps_malloc(ARDTarraysize * sizeof(uint8_t));
PSRAMptr = byte_array; //save the pointe to byte_array to global pointer
new_available_PSRAM_size = ESP.getFreePsram();
Serial.println((String)"PSRAM Size available: " + new_available_PSRAM_size);
Serial.print("PSRAM array bytes allocated: ");
Serial.println(available_PSRAM_size - new_available_PSRAM_size);
Serial.println();
}

63
examples/SX128x_examples/Camera/241_StuartCAM_ESP32CAM_LoRa_Receiver/Settings.h Normal file
View File

@ -0,0 +1,63 @@
/*******************************************************************************************************
Programs for Arduino - Copyright of the author Stuart Robinson - 20/03/22
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.
*******************************************************************************************************/
#define NSS 12 //select on LoRa device
#define NRESET 14 //reset pin on LoRa device
#define RFBUSY 15 //busy pin on LoRa device
#define SCK 4 //SCK on SPI3
#define MISO 13 //MISO on SPI3
#define MOSI 2 //MOSI on SPI3
#define REDLED 33 //pin number for ESP32CAM on board red LED, set logic level low for on
#define LORA_DEVICE DEVICE_SX1280 //this is the device we are using
const uint32_t Frequency = 2445000000; //frequency of transmissions
const uint32_t Offset = 0; //offset frequency for calibration purposes
const int8_t TXpower = 10; //LoRa transmit power
//******* Setup LoRa modem parameters here ! ***************
const uint8_t Bandwidth = LORA_BW_1600; //LoRa bandwidth
const uint8_t SpreadingFactor = LORA_SF5; //LoRa spreading factor
const uint8_t CodeRate = LORA_CR_4_5; //LoRa coding rate
//******* Setup FLRC modem parameters here ! ***************
const uint8_t BandwidthBitRate = FLRC_BR_1_300_BW_1_2; //FLRC bandwidth and bit rate, 1.3Mbs
//const uint8_t BandwidthBitRate = FLRC_BR_0_260_BW_0_3; //FLRC 260kbps
const uint8_t CodingRate = FLRC_CR_1_0; //FLRC coding rate
const uint8_t BT = RADIO_MOD_SHAPING_BT_1_0; //FLRC BT
const uint32_t Syncword = 0x01234567; //FLRC uses syncword
const uint32_t TXtimeoutmS = 5000; //mS to wait for TX to complete
const uint32_t RXtimeoutmS = 3000000; //mS to wait for receiving a packet
const uint32_t ACKdelaymS = 0; //ms delay after general packet actioned and ack sent
const uint32_t ACKdelaystartendmS = 25; //ms delay before ack sent at array start wrie and end write
const uint32_t ACKsegtimeoutmS = 75; //mS to wait for receiving an ACK before re-trying transmit segment
const uint32_t ACKopentimeoutmS = 250; //mS to wait for receiving an ACK before re-trying transmit file open
const uint32_t ACKclosetimeoutmS = 250; //mS to wait for receiving an ACK before re-trying transmit file close
const uint32_t DuplicatedelaymS = 25; //ms delay if there has been an duplicate segment or command receipt
const uint32_t NoAckCountLimit = 250; //if no NoAckCount exceeds this value - restart transfer
const uint32_t FunctionDelaymS = 0; //delay between functions such as open file, send segments etc
const uint32_t PacketDelaymS = 1000; //mS delay between transmitted packets such as DTInfo etc
const uint32_t ReceiveTimeoutmS = 60000; //mS waiting for array transfer before timeout
const uint8_t HeaderSizeMax = 12; //max size of header in bytes, minimum size is 6 bytes
const uint8_t DataSizeMax = 245; //max size of data array in bytes
const uint8_t ARDTfilenamesize = 32; //size of DTfilename buffer used by array transfer functions
const uint32_t ARDTarraysize = 0x20000; //maximum file\array size to receive
const uint16_t NetworkID = 0x3210; //a unique identifier to go out with packet
const uint8_t StartAttempts = 2; //number of attempts to start transfer before a fail
const uint8_t SendAttempts = 5; //number of attempts carrying out a process before a restart
#ifdef USELORA
const uint8_t SegmentSize = 245; //number of bytes in each segment, 245 is maximum value for LoRa
#endif
#ifdef USEFLRC
const uint8_t SegmentSize = 117; //number of bytes in each segment, 117 is maximum value for FLRC
#endif