Published April 8, 2023 © CC BY-SA

Application of LoRa WSN in Landslide Monitoring Systems

DIY project using Wio-E5 LoRa Dev Boards for testing use of LoRa WSN in Landslide Monitoring/Detection Systems

AdvancedFull instructions providedOver 3 days2,148

Application of LoRa WSN in Landslide Monitoring Systems

Things used in this project

Hardware components

Seeed Studio Wio Terminal

Seeed Studio Grove - Wio-E5 (STM32WLE5JC)

Seeed Studio based on LoRa-E5 STM32WLE5JC,

Seeed Studio - Wio-E5 Mini LoRa Dev Board

Arduino Mega 2560

NodeMCU ESP8266 Breakout Board

SparkFun Triple Axis Accelerometer Breakout - ADXL345

Seeed Studio Grove - Capacitive Soil Moisture Sensor

DFRobot Gravity: Analog Soil Moisture Sensor For Arduino

Adafruit DHT22 temperature-humidity sensor

Software apps and online services

Arduino IDE

PlatformIO IDE

Microsoft VS Code

STMicroelectronics STM32CUBEPROG

Story

Landslide is a critical natural geological hazard that causes severe damage to property, infrastructure, and humans. Historical landslides occurred around the world caused disasters, deaths of number of peoples and destroyed homes, structures and loss of plant life.

1 / 3 • Brazil Landslide

What is a landslide and what causes one?

Landslide which is also called as landslip is defined as the movement of mass of rock, debris, or, earth, down a slope. Landslides are a type of "mass wasting, " which denotes any down-slope movement of soil and rock under the direct influence of gravity.

Landslide - Animation Credits and Courtesy : (NASA)

Here, Gravity is the primary driving force for a landslide to occur, but there are other factors affecting slope stability, that produce specific conditions that make a slope prone to failure. In many cases, the landslide is triggered by a specific event, (such as, a heavy rainfall, an earthquake, a slope cut to build a road, and many others), although this is not always identifiable.

Hazards can be mitigated mainly through precautionary means, for instance, by restricting or even removing populations from areas with a history of landslides, by restricting certain types of land use, where slope stability is in question, and by installing early warning systems based on the monitoring of ground conditions, such as, strain in rocks and soils, slope displacement, and groundwater levels.

So there are several landslide monitoring Techniques researched in last decades. But they are broadly categorized into three major classes.

Statistical methods and rating scheme - These are completely analytical methods, Where numerical weights are assigned to each of the triggering parameters of the landslide. All the ratings are sum up to get an aggregated value used to determine a landslide’s likelihood. The higher the value obtained, the higher would be the probability of landslide. This method can develop “Landslide Hazard Mappings” to identify the potential landslide hazards in the area.
Remote sensing - It is the acquisition of information about an object or phenomenon without making physical contact with the object. This method does not consider intrinsic parameters. Techniques used in this category are, SAR, LISA, LIDAR, GPS, Photogrammetric Technique etc.
Ground-based systems - In this system, the sensing devices directly contact the terrain, acquiring real-time data. Means, they are Intrinsic, actual in contact with ground and Terrain. Techniques used in this category are, Antenna Based, OTDR, WSN etc.

We are going to make our DIY Project for one of the Ground-based systems Technique, Which is WSN, means Wireless Sensor Networks. We are going to use LoRa Wireless Technology in this WSN system for improving its wireless connectivity during Landslide Monitoring.

Please note that, project which we are going to design is not about high quality or innovative detection or sensing. We are going to cover only communication part. Means, how LoRa WSN can be helpful in reliably, effectively and efficiently conveying, monitored data, to the distant concerned authorities.

Landslide prediction, Early Detection and Evacuation

Although satellite based remote sensing results and Findings are significant, but they also should be backed up by actual ground based monitoring systems for more accurate results. Here, in such cases, the LoRa based WSN can play important role in wireless communication part.

By monitoring descending velocity of mass, in Landslide or subsidence, over period of time, and by using statistical analytical Techniques of likelihood findings, we can predict or early detect the landslide events.
Here in following table, there are different types of Landslide events are categorized according to the descending velocity of mass or debris.

So as per these stats, in point of view of safe evacuation of peoples living in Landslide prone areas, these four landslide events can be easily early detected and loss of lives can be avoided. Extremely slow, Very slow, slow, and, moderate movements Landslides can be early detected, before they enter into rapid and extremely rapid modes.

Potential Scenarios of project’s application -

Lets see the feasible scenarios of project’s application. We will consider three main cases.

First, Landslides occurring at Remote villages near mountains,
Cities or towns near mountains, and
Roads or Highways passing through hilly regions.

If we consider this city's case, then use of LoRa WSN, or LoRaWAN will be unnecessary here, because, other more faster and reliable Wired or wireless communication services like, Ethernet, GSM 5G, Wi-Fi, will be available near this town.
But for other two scenarios, There may be lack or unavailability of Cellular or Wi-Fi Networks. In such areas, to monitor data of the Landslide events, LoRa wireless sensor networks, can play very important role. If these sites comes in range of 5 to 10 Kilometers, from well connected city, then P2P LoRa or LoRaWAN can be used. Moreover P2P, means, Point to point/ (Peer-to-Peer) LoRa network, will be more affordable solution than that of LoRaWAN.
**Since our area has very poor connectivity of LoRaWAN Gateways, we will consider third scenario for implementation of our project as more sophisticated than other two. Lets see this third scenario in detail.

Most of the time, roads passing through mountains lacks wireless connectivity. Landslides occurring in such areas may cause accidents and closure of the roads. If any Landslide monitoring system deployed in such areas, it is very difficult to send its data to concerned authorities if cellular networks have no coverage. That’s why we are proposing solution with LoRa WSN. Since LoRa can easily cover distance up to 5-10 Kilometers.
So, for the implementation of this Project's concept we'll need LoRa Transceiver modules or development boards with good LoRa transmission range.

We'd like to extend our sincere gratitude to Seeed Studio for providing us their excellent hardwares (Wio-E5 Series LoRa Development Kits) for prototype implementation of this Project.

Check out our detailed review video, in which we have explicated detailed review of these amazing LoRa Development boards. Wio-E5 Dev kit and Wio-E5 Mini. Manufactured by the Seeed Studio. We have seen its unboxing, Features, specifications, Datasheets, AT commands configuration guide, and, We have also seen demo of serial configuration of these boards via AT commands.

Project Implementation -

Now lets see how Wio-E5 Lora modules will be used in this project.

Suppose there is Landslide monitoring system, which incorporated different LoRa wireless sensor nodes.

Suppose this system has been deployed at Landslide prone area in hilly road. Where WiFi and cellular networks are unavailable. This system is connected to nearby cities and Highway Patrol Authorities, via LoRa.
For That, We will use Wio-E5 Dev Kit as Sensor Node. In actual Landslide monitoring system there will be multiple sensor nodes for covering whole Downslope area, but for the sake of design simplicity, we will simulate only 7 sensor nodes using Wio-E5 Dev kit and Arduino Mega2560.
Which includes two soil moisture sensors, One MEMS Accelerometer, "Tipping bucket Rain Gauge Sensor", Vibration Sensor, Temperature and Humidity Sensor.
As shown in above figure, all these LoRa sensor nodes will be then connected to Gateway Node. At Gateway node, we will use another LoRa development board by Seeed studio, that is Wio-E5 Mini, interfaced with, NodeMCU ESP8266.
As figure shows, the Gateway node will be at some distance from other wireless sensor nodes at Landslide prone area. This gateway node also include some sensor, like, another "tipping bucket Rain Gauge Sensor" and Temperature Humidity sensor.
This is just for conveying 'rain density difference' in landslide prone areas and other surrounding areas. Gateway device will receive WSN data from different sensor nodes from landslide prone area. Then, it will add data from its own area, then finally combining both place's data together in one frame it will send it to the end nodes.
We will use Wio Terminal interfaced with Grove Wio-E5 module as an End Device. It will receive data relayed by Gateway device. Now once we receive all the sensor data from the Landslide prone places, at well connected cities, we can do anything with it. Like, cloud sharing, processing, analysis, prediction and Early detection.
Therefore, by monitoring descending velocity of mass in Landslides or subsidence over period of time, and by using statistical analytical Techniques of likelihood findings, we can predict, or, early detect the landslide events. And eventually, eoncerned Authorities can take evacuation and safety measures as per the findings.

Ok so following figure shows the functional block diagram for each node, including its components.

Below in schematics section, We have shared all the circuit schematics of the Project, for Sender Node, Gateway Node and for End node. We will also share the other circuit diagrams for each individual interfacing of components. We highly recommend you, to go stepwise. Test all devices with separate interfacings and then combine them all to make final project. We will share all circuit schematics on Project's GitHub page.

Software and Programs

Since the Wio-E5 LoRa Dev boards and Grove Module consist of this Wio-E5 LoRaWAN chip with an MCU, there are three main ways to utilize the Wio-E5 Dev Board:

Connect Wio-E5 Dev Board to PC via USB and control by AT commands - There is a built-in USB to UART function on board, you could just simply connect the Wio-E5 Dev Board to your PC with a USB type C cable, and use serial communication software to send AT commands and read data from the board.
Connect Wio-E5 Dev Board to another mainboard via UART and control by AT commands - For example, connect Wio-E5 Dev Board to Arduino Uno Board via UART, and send AT commands and read data from Uno through Arduino IDE serial monitor.
Develop user application by using SDK - Develop your own LoRa development board with MCU function by using STM32Cube Programmer, which is the SDK officially provided by STMicroelectronics.

As shown in above block diagram we are going to use second method. We are going to use Arduino Mega2560, NodeMCU ESP8266 and Wio Terminal with Wio-E5 Dev boards and Grove Module in our project.

Seeed studio have extensive and thorough documentation portal, means Wiki encyclopedia, for each of their devices and platforms. You can go to Wiki links of Wio-E5 LoRa Dev boards, you will get plenty of information about how to getting started and program these boards. We have explained all the details in our review video given below.

For testing these Wio-E5 dev kits in P2P mode without LoRaWAN, you can also refer this excellent Hackster tutorial by Sufian Kaki Aslam.

Wio-E5 series has a built-in AT command firmware, which supports LoRaWAN Class A/B/C protocol and a wide frequency plan: EU868/US915/AU915/AS923/KR920/IN865. With this AT command firmware, developers can easily and quickly build their prototype or application. You can download the 'AT Command Specification Guide' from Wio-E5 Wiki page.
The main AT command Mode, which we have used in this project is, the TEST command, as the documentation says,

The TEST command is not like other command, it is a serious command, includes several sub-commands, refer to table below. With test mode, user could do RF performance test quickly without any knowledge of LoRa chip. Commands which are related to RF configuration is disabled in test mode.

TEST MODE command - and subcommands

Before starting communication between two LoRa nodes, we need to run specificsequence of commandsto configure Wio-E5 Dev boards in LoRa Transmitter and LoRa Receiver Modes. Please go through following two sequences,

TEST Mode AT Command Sequence for Wio-E5 LoRa Boards -

for LoRa Transmitter

===== Wio-E5 LoRa Transmitter ====
AT
AT+MODE=TEST
AT+TEST=RFCFG,866,SF12,125,12,15,14,ON,OFF,OFF
AT+TEST=TXLRPKT, "Hello"
AT+TEST=TXLRSTR, "Hello"

for LoRa Receiver

===== Wio-E5 LoRa Receiver ====
AT
AT+MODE=TEST
AT+TEST=RFCFG,866,SF12,125,12,15,14,ON,OFF,OFF
AT+TEST=RXLRPKT

You'll find out that these are subcommands which are given above in TEST mode.

Command RFCFG - we have to use this command to set the RF configuration. Here, please note that, you have to set the Lora frequency or band, as per your country and region. As we are testing it in India, we have set it as Standard, IN865 band. likewise, you have to set it as per your countries LoRa Standard allocated by LoRa Alliance.

You can see how we used RFCFG command and TEST command in the following code snippet (From our Projects Source Code), which is the function to configure Wio-E5 Lora Boards in Test mode.

Code Snippet from DIY Project's Source Code - revealing how the AT commands used to configure Wio-E5 Boards

Then for sending LoRa packets from sender to receiver - we have to use another commands from above give code sequences, which are TXLRPKT and TXLRSTR.

To receive the LoRa data packets sent by sender at Receiver Node we have to be in reception mode, following command sequence configures Wio-E5 in LoRa receiver Mode

Please note that the Wio-E5 LoRa Boards can receive the messages only in HEX format whereas it can transmit in both HEX as well as STRING format.

There are three circuits/nodes in our project. Sensor Node, Gateway Node and End Node. So, there are 3 circuits and 3 different source codes. We have given the source codes below in attachments section. You can also refer to Projects GitHub repo to refer it.

We have added detailed comments for each section of the program, to easily understand, for what purpose that code snippet is used there. Therefore, you can understand, what's going on with these functions and variables. So, Similarly, for other two interfacing circuits. Which are the Gateway Node, and, End Node. In their respective code implementations. We have added detailed comments to each important code snippet, functions and subroutines to guide you through these code implementations.

Demo -

We have made detailed review video of these amazing LoRa development boards, Wio E5 Mini and Wio E5 Lora Dev Kit. Manufactured by the Seeed Studio. In which, We have seen its unboxing, Features, specifications, Datasheets, AT commands configuration guide and We have also seen demo of serial configuration of these boards via AT commands.

We have also made detailed video of the DIY Project using these Wio-E5 Development kits. Application of LoRa WSN in Landslide Monitoring Systems. In which we have explained theory, problem statement, different project scenario's, Functional Block diagram, Circuit diagrams and Source code.

Please note that This is just a simple DIY prototype for testing application of LoRa WSN in Landslide monitoring systems. In actual/real time Landslide monitoring systems may have completely different setup, different sensors, advanced controllers, and other high quality components, which would have way better resolutions, performance and response time than our prototype.

It is not optimized, designed, or, intended for, deployment in Landslide hazard prone sites, or likelihood areas. Our DIY project is purely for academic and study purposes.

Future Update Ideas -

This project was tested in Lab Environment with basic sensor. We're yet to test it in open world. We will test this DIY Project prototype in open area in real time, We will check its transmission range in plain LOS (line of sight).

Suggestions about Project design, Circuits, source code modifications, Optimization, Errors/Bugs findings and queries are most welcomed. Please feel free to comment or give feedback.

Credits -

Thank you Seeed Studio, for supporting this project with their amazing hardware. Furthermore, we'd like to thanks to all the peoples, websites and entities who helped us (directly/indirectly) in this project.

Code

// ---------------------------------- make2explore.com -------------------------------------------------------//
// Project           - Application of LoRa WSN in Landslide Monitoring/Detection/Prevention Systems
// Created By        - info@make2explore.com
// Last Modified     - 14/02/2023 12:30:00 @admin
// Software          - C/C++, PlatformIO IDE, Visual Studio Code Editor, Libraries
// Hardware          - Arduino Mega 2560, NodeMCU ESP8266, Wio Terminal, Wio E5 Dev Boards, Displays, Sensors         
// Sensors Used      - DHT22, Soil Moisture - Resistive, Capacitive, Vibration, Rain, ADXL345 Accelerometer
// Source Repo       - github.com/make2explore
// -----------------------------------------------------------------------------------------------------------//
// This code is of **Wireless (LoRa) Sensor Node**. Which will be collecting data from Landslide prone site
// physical data (Rain + Soil Moisture + Humidity + Temperature + Vibrations + Descending Velocity)
// and sending it to Gateway Node in order relay it over End node

// The main Objective of this project is to test the use of LoRa WSN in such "Landslide Monitoring" systems
// in order to achieve good data reception and reliablity in hilly Areas, "Shadow Regions" or 
// Remote Areas with very low coverage of other Wired/Wireless Networks (e.g GSM/WiFi/Ethernet etc.)
// -----------------------------------------------------------------------------------------------------------//

// Include Libraries
#include <Arduino.h>
#include <Adafruit_GFX.h>       // Include core graphics library
#include <Adafruit_ST7735.h>    // Include Adafruit_ST7735 library to drive the display
#include "DHT.h"                // Include DHT Sensors library
#include <Adafruit_Sensor.h>    // Include Generic Sensor Library
#include <Adafruit_ADXL345_U.h> // Include MEMS ADXL345 Sensor Library

// Declare pins for the display:
#define TFT_CS     53
#define TFT_RST    49  // You can also connect this to the Arduino reset in which case, set this #define pin to -1!
#define TFT_DC     48
// The rest of the pins are pre-selected as the default hardware SPI for Arduino Mega (SCK = 52 and SDA = 51)

// Vibration sensor connected to pin 8
#define vibSensor_pin 8

// Invoke Display and Create display Instance 
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

// LoRa Data receive buffer
static char recv_buf[512];
static bool is_exist = false;

// DHT Sensor Definitions
#define DHTPIN 9     // Digital pin connected to the DHT sensor 
#define DHTTYPE    DHT22     // DHT 22 (AM2302)
DHT dht(DHTPIN, DHTTYPE);

// Sensor variable declarations
// m1  = Capacitive Soil moisture
// m2  = Resistive Soil moisture
uint8_t m1, m2, humi, temp, rain_per;
float disp;
bool vib, stat;
String status = "";

// Soil Moisture Sensors Calibration values
const int AirValueM1 = 877;   //replace the value with value when placed in air using calibration code 
const int WaterValueM1 = 480; //replace the value with value when placed in water using calibration code 

const int AirValueM2 = 1023;   //replace the value with value when placed in air using calibration code 
const int WaterValueM2 = 336; //replace the value with value when placed in water using calibration code 

// Rain Sensor (10K Pot as Tipping bucket Rain Gauge) attached to Analog Pin A2
const int rainSensor = A2;  // Mega2560 Analog Pin A2 = A2 for tipping bucket Rain Sensor

// Soil Moisture Sensors Connections
const int CapSoil = A0;
const int ResSoil = A1;

// Rain Sensors Calibration values
const uint16_t noRain = 21;
const uint16_t FullRain = 1024;

// Readings Update Interval Settings
const unsigned long sendInterval = 20000;
const unsigned long updateInterval = 5000;

unsigned long previousTime = 0;
unsigned long previousUpdateTime = 0;

// ADXL345 Accelerometer 
Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified();


// Function to check response for AT commands
static int at_send_check_response(char *p_ack, int timeout_ms, char *p_cmd, ...)
{
    int ch;
    int index = 0;
    int startMillis = 0;
    va_list args;
    memset(recv_buf, 0, sizeof(recv_buf));
    va_start(args, p_cmd);
    Serial1.print(p_cmd);
    Serial.print(p_cmd);
    va_end(args);
    delay(200);
    startMillis = millis();

    if (p_ack == NULL)
        return 0;

    do
    {
        while (Serial1.available() > 0)
        {
            ch = Serial1.read();
            recv_buf[index++] = ch;
            Serial.print((char)ch);
            delay(2);
        }

        if (strstr(recv_buf, p_ack) != NULL)
            return 1;

    } while (millis() - startMillis < timeout_ms);
    Serial.println();
    return 0;
}

// Function to configure LoRa E5 Dev Board in Test Mode - Check AT commands Specification Guide
// for more details about these command sequences  
void configLoRaModule(){
  //Configure LoRa E5 Dev Kit in Test Mode
  Serial.println("Configuring Wio E5 LoRa Dev Board ...");
  delay(250);
  if (at_send_check_response("+AT: OK", 100, "AT\r\n"))
  {
    is_exist = true;
    at_send_check_response("+MODE: TEST", 1500, "AT+MODE=TEST\r\n");
    at_send_check_response("+TEST: RFCFG", 1500, "AT+TEST=RFCFG,866,SF12,125,12,15,14,ON,OFF,OFF\r\n");
    delay(500);
  }
  else
  {
    is_exist = false;
    Serial.print("No E5 module found.\r\n");
  }
  delay(500);
}

// Function to Setup Display for Initial Screen
void setupDisplay(){
  // Display setup:
  Serial.println("");
  Serial.println("Setting up Display ...");
  delay(250);
  // Use this initializer if you're using a 1.8" TFT
  tft.initR(INITR_BLACKTAB);  // Initialize a ST7735S chip, black tab

  tft.fillScreen(ST7735_BLACK);  // Fill screen with black

  tft.setRotation(2);  // Set orientation of the display. Values are from 0 to 3. If not declared, orientation would be 0,
                         // which is portrait mode.

  tft.setTextWrap(false);  // By default, long lines of text are set to automatically “wrap” back to the leftmost column.
                           // To override this behavior (so text will run off the right side of the display - useful for
                           // scrolling marquee effects), use setTextWrap(false). The normal wrapping behavior is restored
                           // with setTextWrap(true).

  tft.fillRect(0, 0, 127, 20, ST7735_MAGENTA); // Draw filled rectangle (x,y,width,height,color)
  tft.setCursor(15, 7);  // Set position (x,y)
  tft.setTextColor(ST7735_WHITE);  // Set color of text. First is the color of text and after is color of background
  tft.setTextSize(1);  // Set text size. Goes from 0 (the smallest) to 20 (very big)
  tft.println("LoRa Sensor Node");  // Print a text or value

  // Stop using a custom font:
  tft.setFont();  // Reset to standard font, to stop using any custom font previously set
  tft.setTextSize(1);  // Set text size. Goes from 0 (the smallest) to 20 (very big)
  tft.setCursor(5, 28);  // Set position (x,y)
  //tft.setTextColor(ST7735_WHITE);  // Set color of text. First is the color of text and after is color of background
  tft.println("Soil M1 : ");  // Print a text or value
  tft.setCursor(110, 28);  // Set position (x,y)
  tft.print('%');

  tft.setCursor(5, 45);  // Set position (x,y)
  tft.println("Soil M2 : ");  // Print a text or value
  tft.setCursor(110, 45);  // Set position (x,y)
  tft.print('%');

  tft.setCursor(5, 60);  // Set position (x,y)
  tft.println("Rain Pr : ");  // Print a text or value
  tft.setCursor(110, 60);  // Set position (x,y)
  tft.print('%');

  tft.setCursor(5, 75);  // Set position (x,y)
  tft.println("Humi Pr : ");  // Print a text or value
  tft.setCursor(110, 75);  // Set position (x,y)
  tft.print('%');

  tft.setCursor(5, 90);  // Set position (x,y)
  tft.println("Temp Rd : ");  // Print a text or value
  tft.setCursor(110, 90);  // Set position (x,y)
  tft.print('C');

  tft.setCursor(5, 105);  // Set position (x,y)
  tft.println("Vibr Dt : ");  // Print a text or value
  tft.setCursor(110, 105);  // Set position (x,y)
  tft.println("Ct");

  tft.setCursor(5, 120);  // Set position (x,y)
  tft.println("Disp Ac : ");  // Print a text or value
  tft.setCursor(110, 120);  // Set position (x,y)
  tft.println("m/s");

  tft.fillRect(1,142,127,18, ST7735_BLUE);
  tft.setCursor(15, 148);  // Set position (x,y)
  tft.setTextColor(ST7735_WHITE);
  tft.println("Status : ");  // Print a text or value
}

// Function to Initialise DHT Sensor and Check Readings
void checkDHT(){
  // Wait a few seconds between measurements.
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);

  temp = t;
  humi = h;

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  //Serial.print(F("Humidity: "));
  //Serial.print(h);
  //Serial.print(F("%  Temperature: "));
  //Serial.print(t);
  //Serial.print(F("°C "));

}

// Function to Test ADXL345 Accelerometer
void init_accel(){
  if(!accel.begin())
  {
    Serial.println("No ADXL345 sensor detected.");
    while(1);
  }
}

// Function to Get Readings from ADXL345 Accelerometer
void getAccel(){
  sensors_event_t event; 
  accel.getEvent(&event);
  // Wait a few seconds between measurements.
  disp = event.acceleration.x;
  //Serial.print("Accelearation : ");
  //Serial.println(disp);
  //elay(2000);  
}

// Function to Get Readings from Soil Moisture Sensors
void getSoilM(){
  //Serial.print("Capacitive Soil Moisture : ");
  //Serial.println(analogRead(CapSoil));
  //Serial.print("Resistive Soil Moisture : ");
  //Serial.println(analogRead(ResSoil));  
  m1 = map(analogRead(CapSoil), AirValueM1, WaterValueM1, 0, 100);
  m2 = map(analogRead(ResSoil), AirValueM2, WaterValueM2, 0, 100);
}

// Check Rain Sensor (10K Pot as Tipping bucket Rain Gauge) attached to Analog Pin A2
void checkRain(){
  rain_per = map(analogRead(rainSensor), noRain, FullRain, 0, 100);
}

// Function to Get All Sensor Readings at a time
void getReadings(){
  checkDHT();
  init_accel();
  getSoilM();
  checkRain();
  getAccel();
  vib = digitalRead(vibSensor_pin);
}

// Function for checking critical landslide conditions
void checkStatus(){
  if((m1 < 60) && (m2 < 60) && (rain_per < 50) && (humi < 60) && (temp > 25) && (disp < 1) && (vib == 0)){
    status = "Normal";
  }
  else if((m1 > 60) && (m2 > 60) && (rain_per > 50) && (humi > 60) && (temp < 25)){
    if ((disp > 1) && (vib == 1)){
      status = "Alert";
      stat = 1;
    }
  else
    status = "Normal";
    stat = 0;
  }
}

// Function to Display Readings from Sensors Locally
void displayReadings(){

  tft.setTextSize(1);  // Set text size. Goes from 0 (the smallest) to 20 (very big)
  tft.setCursor(70, 28);  // Set position (x,y)
  tft.setTextColor(ST7735_CYAN, ST7735_BLACK);  // Set color of text. First is the color of text and after is color of background
  tft.println(m1);  // Print a text or value

  tft.setCursor(70, 45);  // Set position (x,y)
  tft.println(m2);  // Print a text or value

  tft.setCursor(70, 60);  // Set position (x,y)
  tft.println(rain_per);  // Print a text or value

  tft.setCursor(70, 75);  // Set position (x,y)
  tft.println(humi);  // Print a text or value


  tft.setCursor(70, 90);  // Set position (x,y)
  tft.println(temp);  // Print a text or value


  tft.setCursor(70, 105);  // Set position (x,y)
  tft.println(vib);  // Print a text or value


  tft.setCursor(70, 120);  // Set position (x,y)
  tft.println(disp);  // Print a text or value

  if(stat == 1){
  tft.fillRect(1,142,127,18, ST7735_RED);
  tft.setCursor(15, 148);  // Set position (x,y)
  tft.setTextColor(ST7735_WHITE);
  tft.println("Status : ");  // Print a text or value    
  tft.setTextColor(ST7735_WHITE, ST7735_RED); 
  }else {
    tft.setTextColor(ST7735_WHITE, ST7735_BLUE); 
  }
  
  tft.setCursor(70, 148);  // Set position (x,y)
  tft.println(status);  // Print a text or value
}

// Function for LoRa packet preparation and sending
static int LoRa_send()
{
  String sensorData = "";
  char cmd[256] = "";
  char data[128] = "";
  int ret = 0;
  sensorData = sensorData + String(m1) + "," + String(m2) + "," + String(rain_per) + "," + String(humi) 
                + "," + String(temp) + "," + String(disp) + "," + String(vib) + "," + String(stat);
  //Serial.print("Printing Sensor Data String : ");
  //Serial.println(sensorData);

  strncpy(data,sensorData.c_str(),sizeof(data));
  data[sizeof(data) -1] = 0;

  sprintf(cmd, "AT+TEST=TXLRSTR,\"GW,%s\"\r\n", data);
  //Serial.print("Printing cmd String : ");
  //Serial.print(cmd);

  ret = at_send_check_response("TX DONE", 6000, cmd);
    if (ret == 1)
    {
      Serial.println("");
      Serial.print("Sent successfully!\r\n");
    }
    else
    {
      Serial.println("");
      Serial.print("Send failed!\r\n");
    }
  return ret;
}

// Function to Setup the Initializations and Configurations
void setup() {
  // put your setup code here, to run once:
  //initialize the library
  Serial.begin(9600);
  Serial1.begin(9600);
  Serial.println("LandSlide Monitoring - Starting!!");
  delay(250);
  pinMode(vibSensor_pin, INPUT);
  configLoRaModule();
  setupDisplay();
  dht.begin();
  checkDHT();
  delay(1000);
  Serial.println("Setup Completed !!");
  delay(250);
}

// Function main Loop
void loop() {
  // put your main code here, to run repeatedly:
  unsigned long currentUpdateTime = millis();
  if (currentUpdateTime - previousUpdateTime >= updateInterval) {
    getReadings();
    checkStatus();
    displayReadings();
    previousUpdateTime = currentUpdateTime;
  }

  unsigned long currentTime = millis();
  if (currentTime - previousTime >= sendInterval) {
    LoRa_send();
    previousTime = currentTime;
  }
}
// ---------------------------------- make2explore.com----------------------------------------------------//

// ---------------------------------- make2explore.com -------------------------------------------------------//
// Project           - Application of LoRa WSN in Landslide Monitoring/Detection/Prevention Systems
// Created By        - info@make2explore.com
// Last Modified     - 14/02/2023 01:26:00 @admin
// Software          - C/C++, PlatformIO IDE, Visual Studio Code Editor, Libraries
// Hardware          - Arduino Mega 2560, NodeMCU ESP8266, Wio Terminal, Wio E5 Dev Boards, Displays, Sensors         
// Sensors Used      - DHT22, Soil Moisture - Resistive, Capacitive, Vibration, Rain, ADXL345 Accelerometer
// Source Repo       - github.com/make2explore
// -----------------------------------------------------------------------------------------------------------//
// This code is of Wireless (LoRa) **Gateway Node**. Which will be *Relaying* data coming from LoRa WSN 
// deployed at Landslide prone site, To the End node, Where concerned Authorities can monitor/Analyse 
// the data to take Prevention/Rescue Measures.
// physical data (Rain + Soil Moisture + Humidity + Temperature + Vibrations + Descending Velocity)
// GW Node also send its own location's parameters (Rain+Humidity+Temp) data for comparing actual situations. 
// It helps in calculating perimeter of Raining area. Since Sensor node and GW node are at about 5-7Km 
// away/distant from each other.

// The main Objective of this project is to test the use of LoRa WSN in such "Landslide Monitoring" systems
// in order to achieve good data reception and reliablity in hilly Areas, "Shadow Regions" or 
// Remote Areas with very low coverage of other Wired/Wireless Networks (e.g GSM/WiFi/Ethernet etc.)
// -----------------------------------------------------------------------------------------------------------//

// Include Libraries
#include <Arduino.h>
#include <SPI.h>              // SPI Library needed for display
#include <TFT_eSPI.h>         // Graphics library
#include "m2e-logo.h"         // make2explore Logo Bitmap header file
#include <SoftwareSerial.h>   // Software Serial Library for communicating with Wio E5 Mini Board
#include "DHT.h"              // Include DHT Sensors library

// Invoke Display and Create display Instance 
TFT_eSPI tft = TFT_eSPI();

// Lets define Sofware serial Pins for WIo E5 Mini Dev Board
const byte rxPin = D2;
const byte txPin = D3;

// Set up a new SoftwareSerial object
SoftwareSerial e5 (rxPin, txPin);

// LoRa Data receive buffer
static char recv_buf[512];
static bool is_exist = false;

// Rain Sensor (10K Pot as Tipping bucket Rain Gauge) attached to Analog Pin A0
const int rainSensor = A0;  // ESP8266 Analog Pin ADC0 = A0 for tipping bucketRain Sensor
// Rain Sensors Calibration values
const uint16_t noRain = 21;
const uint16_t FullRain = 1024;

// DHT Sensor Definitions
#define DHTPIN D6     // Digital pin connected to the DHT sensor
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
DHT dht(DHTPIN, DHTTYPE);

// Sensor variable declarations
uint8_t GW_temperature, GW_humidity, GW_rain_per; 

// Variables for collecting Sensor data and parameters
// prfix SN is for data received from (WSN) Sensor Node
uint8_t SN_m1, SN_m2, SN_humi, SN_temp, SN_rain_per;
float SN_disp;
bool SN_vib, SN_stat;
int RSSI, SNR;

// Function for parsing the incomming data String
String getValue(String data, char separator, int index)
{
    int found = 0;
    int strIndex[] = { 0, -1 };
    int maxIndex = data.length() - 1;
 
    for (int i = 0; i <= maxIndex && found <= index; i++) {
        if (data.charAt(i) == separator || i == maxIndex) {
            found++;
            strIndex[0] = strIndex[1] + 1;
            strIndex[1] = (i == maxIndex) ? i+1 : i;
        }
    }
    return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
}

// Function for Hex to ASCII conversion
byte aNibble(char in) {
  if (in >= '0' && in <= '9') {
    return in - '0';
  } else if (in >= 'a' && in <= 'f') {
    return in - 'a' + 10;
  } else if (in >= 'A' && in <= 'F') {
    return in - 'A' + 10;
  }
  return 0;
}

// Function for Hex to ASCII conversion
char * unHex(const char* input, char* target, size_t len) {
  if (target != nullptr && len) {
    size_t inLen = strlen(input);
    if (inLen & 1) {
      Serial.println(F("unhex: malformed input"));
    }
    size_t chars = inLen / 2;
    if (chars >= len) {
      Serial.println(F("unhex: target buffer too small"));
      chars = len - 1;
    }
    for (size_t i = 0; i < chars; i++) {
      target[i] = aNibble(*input++);
      target[i] <<= 4;
      target[i] |= aNibble(*input++);
    }
    target[chars] = 0;
  } else {
    Serial.println(F("unhex: no target buffer"));
  }
  return target;
}

// Function to check response for AT commands
static int at_send_check_response(char *p_ack, int timeout_ms, char *p_cmd, ...)
{
    int ch = 0;
    int index = 0;
    int startMillis = 0;
    va_list args;
    memset(recv_buf, 0, sizeof(recv_buf));
    va_start(args, p_cmd);
    e5.printf(p_cmd, args);
    Serial.printf(p_cmd, args);
    va_end(args);
    delay(200);
    startMillis = millis();

    if (p_ack == NULL)
    {
        return 0;
    }
    do
    {
        while (e5.available() > 0)
        {
            ch = e5.read();
            recv_buf[index++] = ch;
            Serial.print((char)ch);
            delay(2);
        }
        if (strstr(recv_buf, p_ack) != NULL)
        {
            return 1;
        }
 
    } while (millis() - startMillis < timeout_ms);
    return 0;
}

// Function for parsing the incoming LoRa data
static int recv_parse(void)
{
    char ch;
    int index = 0;
    memset(recv_buf, 0, sizeof(recv_buf));
    while (e5.available() > 0)
    {
        ch = e5.read();
        recv_buf[index++] = ch;
        Serial.print((char)ch);
        delay(2);
    }
 
    if (index)
    {
        char *p_start = NULL;
        char data[128] = {
            0,
        };
        int rss = 0;
        int snr = 0;

        p_start = strstr(recv_buf, "+TEST: RX \"47572C");
        if (p_start)
        {
            p_start = strstr(recv_buf, "47572C");
            if (p_start && (1 == sscanf(p_start, "47572C%s", data)))
            {
              data[70] = 0;
              //Serial.println(data);
              char output[128];
              char* text = unHex(data, output, sizeof(output));
              //Serial.println(text);
              SN_m1 = (getValue(text, ',', 0)).toInt();
              SN_m2 = (getValue(text, ',', 1)).toInt();
              SN_rain_per = (getValue(text, ',', 2)).toInt();
              SN_humi = (getValue(text, ',', 3)).toInt();
              SN_temp = (getValue(text, ',', 4)).toInt();
              SN_disp = (getValue(text, ',', 5)).toFloat();
              SN_vib = (getValue(text, ',', 6)).toInt();
              SN_stat = (getValue(text, ',', 7)).toInt();
              Serial.println("\r\n");

            }
            p_start = strstr(recv_buf, "RSSI:");
            if (p_start && (1 == sscanf(p_start, "RSSI:%d,", &rss))){
              RSSI = rss;
            }

            p_start = strstr(recv_buf, "SNR:");
            if (p_start && (1 == sscanf(p_start, "SNR:%d", &snr))){
              SNR = snr;
            }
            return 1;
        }
    }
    return 0;
}

// Function for Receiving incomming LoRa Packets
static int node_recv(uint32_t timeout_ms)
{
    at_send_check_response("+TEST: RXLRPKT", 1500, "AT+TEST=RXLRPKT\r\n");
    int startMillis = millis();
    do
    {
        if (recv_parse())
        {
            return 1;
        }
    } while (millis() - startMillis < timeout_ms);
    return 0;
}

// Function for LoRa packet preparation and sending
static int LoRa_send()
{
  String sensorData = "";
  char cmd[256] = "";
  int ret = 0;
  char data[128] = "";

  sensorData = sensorData + String(SN_m1) + "," + String(SN_m2) + "," + String(SN_rain_per) + "," + String(SN_humi) 
                + "," + String(SN_temp) + "," + String(SN_disp) + "," + String(SN_vib) + "," + String(SN_stat) + "," 
                + String(GW_rain_per) + "," + String(GW_humidity) + "," + String(GW_temperature);

  strncpy(data,sensorData.c_str(),sizeof(data));
  data[sizeof(data) -1] = 0;
  
  sprintf(cmd, "AT+TEST=TXLRSTR,\"EN,%s\"\r\n", data);
  //Serial.print("Printing cmd String : ");
  //Serial.println(cmd);

  ret = at_send_check_response("TX DONE", 6000, cmd);
    if (ret == 1)
    {
      Serial.println("");
      Serial.print("Sent successfully!\r\n");
    }
    else
    {
      Serial.println("");
      Serial.print("Send failed!\r\n");
    }
  return ret;
}

// Function for First receive data from WSN then Relay(Send) to End Node via LoRa
static void node_recv_then_send(uint32_t timeout)
{
    int ret = 0;
    ret = node_recv(timeout);
    delay(100);
    if (!ret)
    {
        Serial.print("\r\n");
        return;
    }
    LoRa_send();
    Serial.print("\r\n");
}

// Function to configure Wio E5 Mini in Test Mode - Check AT commands Specification Guide
// for more details about these command sequences  
void configLoRaModule(){
  //Configure Wio E5 Mini Board in Test Mode
  Serial.println("Configuring Wio E5 Mini Board ...");
  delay(250);
  if (at_send_check_response("+AT: OK", 100, "AT\r\n"))
  {
    is_exist = true;
    at_send_check_response("+MODE: TEST", 1500, "AT+MODE=TEST\r\n");
    at_send_check_response("+TEST: RFCFG", 1500, "AT+TEST=RFCFG,866,SF12,125,12,15,14,ON,OFF,OFF\r\n");
    delay(500);
  }
  else
  {
    is_exist = false;
    Serial.print("No E5 module found.\r\n");
  }
  delay(500);
}

// Function to Setup Display for Initial Screen
void HomeScreen(){
  tft.fillScreen(TFT_BLACK);                    // Black background
  tft.drawRect(0,0,239,239,TFT_WHITE);       // A 100x100 black rectangle starting from (110, 70)
  tft.fillRect(0,0,240,40,TFT_BROWN);
  tft.setTextColor(TFT_WHITE);          //sets the text colour to black
  tft.setTextSize(2);                   //sets the size of text
  tft.drawString("LoRa Gateway Node", 14,12);
  tft.setTextColor(TFT_YELLOW);          //sets the text colour to black
  tft.drawString("GW node local data", 12,55);

  tft.setTextColor(TFT_WHITE); 
  tft.drawString("Rain = ", 10, 85);
  tft.drawString("%", 215, 85);

  tft.drawString("Humi = ", 10, 110);
  tft.drawString("%", 215, 110);

  tft.drawString("Temp = ", 10, 135);
  tft.drawString("C", 215,135);

  tft.drawString("RSSI = ", 10, 160);
  tft.drawString("dBm", 195, 160);

  tft.drawString("SNR  = ", 10, 185);
  tft.drawString("dB", 205, 185);

  tft.drawString("Stat = ", 10, 210);
}

// Function to Display the sensor Readings
void displayReadings(){

  tft.setTextColor(TFT_CYAN, TFT_BLACK); 

  tft.drawFloat(GW_rain_per, 2, 100, 85);
  
  tft.drawFloat(GW_humidity, 2, 100, 110);

  tft.drawFloat(GW_temperature, 2, 100, 135);

  tft.drawNumber(RSSI, 100, 160);

  tft.drawNumber(SNR, 100, 185);

  if(SN_stat == 1){
    tft.drawString("Alert!", 100, 210);
  } else {
    tft.drawString("OK", 100, 210);
  }
  
}

// Function to Initialise DHT Sensor and Check Readings
void getDHTReadings(){
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);
  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }
  GW_temperature = t;
  GW_humidity = h;
  //Serial.print("Humidity: ");
  //Serial.print(h);
  //Serial.println("%");
  //Serial.print("Temperature: ");
  //Serial.print(t);
  //Serial.println("°C ");      
}

// Check Rain Sensor (10K Pot as Tipping bucket Rain Gauge) attached to Analog Pin A0
void getRainReading(){
  GW_rain_per = map(analogRead(rainSensor), noRain, FullRain, 0, 100);
  //Serial.print("Rain Percentage : ");
  //Serial.print(rain_per);
  //Serial.println("%");
}

// Function to Setup the Initializations and Configurations
void setup(void) {
  
  Serial.begin (9600);
  e5.begin(9600);
  tft.begin ();                                 // initialize a ST7789 chip
  tft.setSwapBytes (true);                      // swap the byte order for pushImage() - corrects endianness

  tft.setRotation(0);
  tft.fillScreen (TFT_BLACK);
  tft.pushImage (0,0,240,240,m2elogo);
  delay(3000);
  
  HomeScreen();         // Display Home Screen

  configLoRaModule();   // Configure Wio E5 Mini Dev Board

  dht.begin();          // Init DHT Sensor
}

// Function main Loop
void loop() {
  if (is_exist)
  {
    getDHTReadings();
    getRainReading();
    displayReadings();
    node_recv_then_send(5000);
  }
}

// ---------------------------------- make2explore.com----------------------------------------------------//

// ---------------------------------- make2explore.com -------------------------------------------------------//
// Project           - Application of LoRa WSN in Landslide Monitoring/Detection/Prevention Systems
// Created By        - info@make2explore.com
// Last Modified     - 14/02/2023 01:26:00 @admin
// Software          - C/C++, PlatformIO IDE, Visual Studio Code Editor, Libraries
// Hardware          - Arduino Mega 2560, NodeMCU ESP8266, Wio Terminal, Wio E5 Dev Boards, Displays, Sensors         
// Sensors Used      - DHT22, Soil Moisture - Resistive, Capacitive, Vibration, Rain, ADXL345 Accelerometer
// Source Repo       - github.com/make2explore
// -----------------------------------------------------------------------------------------------------------//
// This code is of Wireless (LoRa) **End Node**. Which will be *Displaying* data coming from LoRa WSN 
// deployed at Landslide prone site. Here concerned Authorities can monitor/Analyse 
// the data to take Prevention/Rescue Measures.

// Data from Sensor Node (Rain + Soil Moisture + Humidity + Temperature + Vibrations + Descending Velocity)
// Data from GW Node (Rain+Humidity+Temp) data for comparing actual situations. 

// All data coming from SN and GW Node will be displayed at End Node. Here we can implement more complex
// System using ML and AI for predition of Landslide

// The main Objective of this project is to test the use of LoRa WSN in such "Landslide Monitoring" systems
// in order to achieve good data reception and reliablity in hilly Areas, "Shadow Regions" or 
// Remote Areas with very low coverage of other Wired/Wireless Networks (e.g GSM/WiFi/Ethernet etc.)
// -----------------------------------------------------------------------------------------------------------//

// Include Libraries
#include <Arduino.h>
#include <SoftwareSerial.h>   // Software Serial Library for communicating with Wio E5 LoRa Module
#include "TFT_eSPI.h"         // Include TFT LCD library 
#include "Free_Fonts.h"       // Include free fonts library 
#include "Seeed_FS.h"         // Including SD card library
#include "RawImage.h"         // Including image processing library

// Invoke Display and Create display Instance 
TFT_eSPI tft; //initialize TFT LCD

// Lets define Sofware serial Pins for WIo E5 Module
const byte rxPin = D0;
const byte txPin = D1;

// Set up a new SoftwareSerial object
SoftwareSerial e5 (rxPin, txPin);

// LoRa Data receive buffer
static char recv_buf[512];
static bool is_exist = false;

// Variables for collecting Sensor data and parameters
// prfix SN is for data received from (WSN) Sensor Node
float SN_m1, SN_m2, SN_humi, SN_temp, SN_disp, SN_rain_per, GW_temperature, GW_humidity, GW_rain_per;;
bool SN_vib, SN_stat;

// Readings Update Interval Settings
const unsigned long updateInterval = 5000;
unsigned long previousTime = 0;
unsigned long previousUpdateTime = 0;

// Function for parsing the incomming data String
String getValue(String data, char separator, int index)
{
    int found = 0;
    int strIndex[] = { 0, -1 };
    int maxIndex = data.length() - 1;
 
    for (int i = 0; i <= maxIndex && found <= index; i++) {
        if (data.charAt(i) == separator || i == maxIndex) {
            found++;
            strIndex[0] = strIndex[1] + 1;
            strIndex[1] = (i == maxIndex) ? i+1 : i;
        }
    }
    return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
}

// Function for Hex to ASCII conversion
byte aNibble(char in) {
  if (in >= '0' && in <= '9') {
    return in - '0';
  } else if (in >= 'a' && in <= 'f') {
    return in - 'a' + 10;
  } else if (in >= 'A' && in <= 'F') {
    return in - 'A' + 10;
  }
  return 0;
}

// Function for Hex to ASCII conversion
char * unHex(const char* input, char* target, size_t len) {
  if (target != nullptr && len) {
    size_t inLen = strlen(input);
    if (inLen & 1) {
      Serial.println(F("unhex: malformed input"));
    }
    size_t chars = inLen / 2;
    if (chars >= len) {
      Serial.println(F("unhex: target buffer too small"));
      chars = len - 1;
    }
    for (size_t i = 0; i < chars; i++) {
      target[i] = aNibble(*input++);
      target[i] <<= 4;
      target[i] |= aNibble(*input++);
    }
    target[chars] = 0;
  } else {
    Serial.println(F("unhex: no target buffer"));
  }
  return target;
}

// Function to check response for AT commands
static int at_send_check_response(char *p_ack, int timeout_ms, char *p_cmd, ...)
{
    int ch = 0;
    int index = 0;
    int startMillis = 0;
    va_list args;
    memset(recv_buf, 0, sizeof(recv_buf));
    va_start(args, p_cmd);
    e5.printf(p_cmd, args);
    Serial.printf(p_cmd, args);
    va_end(args);
    delay(200);
    startMillis = millis();
 
    if (p_ack == NULL)
    {
        return 0;
    }
    do
    {
        while (e5.available() > 0)
        {
            ch = e5.read();
            recv_buf[index++] = ch;
            Serial.print((char)ch);
            delay(2);
        }
        if (strstr(recv_buf, p_ack) != NULL)
        {
            return 1;
        }
 
    } while (millis() - startMillis < timeout_ms);
    return 0;
}

// Function for parsing the incoming LoRa data
static int recv_parse(void)
{
    char ch;
    int index = 0;
    memset(recv_buf, 0, sizeof(recv_buf));
    while (e5.available() > 0)
    {
        ch = e5.read();
        recv_buf[index++] = ch;
        Serial.print((char)ch);
        delay(2);
    }
 
    if (index)
    {
        char *p_start = NULL;
        char data[128] = {
            0,
        };

        p_start = strstr(recv_buf, "+TEST: RX \"454E2C");
        if (p_start)
        {
            p_start = strstr(recv_buf, "454E2C");
            if (p_start && (1 == sscanf(p_start, "454E2C%s", data)))
            {
                data[60] = 0;
                //Serial.println(data);
                //Serial.println("Hello");
                char output[128];
                char* text = unHex(data, output, sizeof(output));
                SN_m1 = (getValue(text, ',', 0)).toFloat();
                SN_m2 = (getValue(text, ',', 1)).toFloat();
                SN_rain_per = (getValue(text, ',', 2)).toFloat();
                SN_humi = (getValue(text, ',', 3)).toFloat();
                SN_temp = (getValue(text, ',', 4)).toFloat();
                SN_disp = (getValue(text, ',', 5)).toFloat();
                SN_vib = (getValue(text, ',', 6)).toInt();
                SN_stat = (getValue(text, ',', 7)).toInt();

                GW_rain_per = (getValue(text, ',', 8)).toFloat();  
                GW_humidity = (getValue(text, ',', 9)).toFloat();  
                GW_temperature = (getValue(text, ',', 10)).toFloat();
                //Serial.println(GW_temperature);              
                Serial.print("\r\n");
            }
            return 1;
        }
    }
    return 0;
}


// Function for Receiving incomming LoRa Packets
static int node_recv(uint32_t timeout_ms)
{
    at_send_check_response("+TEST: RXLRPKT", 1500, "AT+TEST=RXLRPKT\r\n");
    int startMillis = millis();
    do
    {
        if (recv_parse())
        {
            return 1;
        }
    } while (millis() - startMillis < timeout_ms);
    return 0;
}


// Function to configure Wio E5 Module in Test Mode - Check AT commands Specification Guide
// for more details about these command sequences  
void configLoRaModule(){
  //Configure Wio E5 Module in Test Mode
  Serial.println("Configuring Wio E5 Module ...");
  delay(250);
  if (at_send_check_response("+AT: OK", 100, "AT\r\n"))
  {
    is_exist = true;
    at_send_check_response("+MODE: TEST", 1500, "AT+MODE=TEST\r\n");
    at_send_check_response("+TEST: RFCFG", 1500, "AT+TEST=RFCFG,866,SF12,125,12,15,14,ON,OFF,OFF\r\n");
    delay(500);
  }
  else
  {
    is_exist = false;
    Serial.print("No E5 module found.\r\n");
  }
  delay(500);
}


// Function to Display the Sensor Readings (WSN)
void DisplayReadings1(){

    drawImage<uint8_t>("m2e-SN.bmp", 0, 0); //Display this 8-bit image in sd card from (0, 0)
    tft.setTextColor(TFT_WHITE);
    tft.setFreeFont(&FreeSerifBold9pt7b); //set font type 

    tft.drawFloat(SN_m1,2,93,62); //draw text string

    tft.drawFloat(SN_m2,2,249,60); //draw text string

    tft.drawFloat(SN_rain_per,2,93,110); //draw text string

    tft.drawFloat(SN_disp,2,244,111); //draw text string

    tft.drawFloat(SN_temp,2,240,160); //draw text string

    tft.drawFloat(SN_humi,2,86,209); //draw text string

    if(SN_vib == 1){
        tft.setTextColor(TFT_RED);
        tft.drawString("Detected",87,162);
    } else {
        tft.setTextColor(TFT_WHITE);
        tft.drawString("Not Det",87,162);
    }
    
    if(SN_stat == 1){
        tft.setTextColor(TFT_RED);
        tft.drawString("Alert !",250,209);
    } else {
        tft.setTextColor(TFT_GREEN);
        tft.drawString("OK",250,209);
    }

}

// Function to Display the Sensor Readings (GW Node)
void DisplayReadings2(){

  drawImage<uint8_t>("m2e-GW.bmp", 0, 0); //Display this 8-bit image in sd card from (0, 0)
  tft.setTextColor(TFT_WHITE);
  tft.setFreeFont(&FreeSerifBold9pt7b); //set font type 
  tft.drawFloat(GW_rain_per,2,197,70); //draw text string

  tft.drawFloat(GW_temperature,2,82,126); //draw text string

  tft.drawFloat(GW_humidity,2,237,126); //draw text string
  
  tft.setFreeFont(&FreeSerifBold12pt7b); //set font type 
  if(SN_stat == 1){
    tft.setTextColor(TFT_RED);
    tft.drawString("Alert !",200,195);
  } else {
    tft.setTextColor(TFT_GREEN);
    tft.drawString("OK",200,195);
  }
  
}

// Function to Setup Display for Initial Screen - make2explore logo
void HomeScreen(){
  drawImage<uint16_t>("WioTerminal-screen-m2e.bmp", 0, 0); //Display this 8-bit image in sd card from (0, 0)
}

// Function to Setup Display for First (WSN Data) Screen
void FirstScreen(){
  drawImage<uint8_t>("m2e-SN.bmp", 0, 0); //Display this 8-bit image in sd card from (0, 0)
}

// Function to Setup Display for First (GW Node Data) Screen
void secondScreen(){
  drawImage<uint8_t>("m2e-GW.bmp", 0, 0); //Display this 8-bit image in sd card from (0, 0)
}

// Function to Setup the Initializations and Configurations
void setup() {
    Serial.begin (9600);
    e5.begin(9600);
    //Initialise SD card
    if (!SD.begin(SDCARD_SS_PIN, SDCARD_SPI)) {
        while (1);
    }

    pinMode(WIO_5S_PRESS, INPUT_PULLUP);

    tft.begin(); //start TFT LCD 
    tft.setRotation(1); //set screen rotation 

    configLoRaModule();

    HomeScreen();
    delay(3000);
    FirstScreen();
    
}

// Function main Loop
void loop() {
    if (is_exist)
    {
        node_recv(6000);
        DisplayReadings1();
    }

    if (digitalRead(WIO_5S_PRESS) == LOW) {
        DisplayReadings2();
        delay(2000);
    }
}
// ---------------------------------- make2explore.com ----------------------------------------------------//