Project Logs

Collapse

• 12. Testing LoRaWAN and IoT Connection

  Guillermo Perez Guillen • 07/26/2022 at 21:19 • 0 comments

  CHANNEL CONFIGURATION IN THE THINGSPEAK PLATFORM

  Below you can see the new channel created on the ThingSpeak platform.

  Don't forget to take note of the Write API key.

  TESTING LORAWAN AND IOT CONNECTION

  In the video below I show you two tests carried out: a) in the first, the transmitter and the receiver are inside a room in order to verify that everything is working well; b) in the second, the transmitter is placed in the ecological reserve.

  IMAGE GALLERY

  On this occasion, I decided to solve the problem of having better signal reception. For this reason, I made a case with straps to attach the transmitting device to test on various trees and improve line of sight.

  This is the second tree in my attempt to improve signal quality.

  And finally my third attempt to improve the quality of the signal.

  What I can guarantee is that I am ecstatic with the beauty of nature.. Below is a screenshot with the ThingView app.

  Here is an example of temperature capture with the ThingSpeak platform 

  Now a screenshot of the relative humidity.

  And finally a capture of carbon dioxide pollution.

  This area has low levels of contamination at the moment. You should know that ThingSpeak can also give you the area map as long as you give it the GPS coordinates.

• 11. LoRaWAN and IoT Connection

  Guillermo Perez Guillen • 07/26/2022 at 21:16 • 0 comments

  LORAWAN TRANSMITTER

  Below I show you the schematic diagram of the transmitter with multiple sensors.

  Below I show you the code used to upload it to the Arduino MKR WAN 1300 transmitter board.

  LoRaSender_v5.ino

  // AUTHOR: GUILLERMO PEREZ GUILLEN
  
  #include <SPI.h> // LoRa->
  #include <LoRa.h>
  #include <OneWire.h> // DS18B20->               
  #include <DallasTemperature.h>
  #include <Wire.h> // LCD->
  #include "rgb_lcd.h"
  rgb_lcd lcd;
  const int colorR = 173;
  const int colorG = 255;
  const int colorB = 47;
  
  #include "DHT.h" // DHT22 ->
  #define DHTPIN 3    // Pin where the sensor is connected
  #define DHTTYPE DHT22   // DHT22 sensor
  DHT dht(DHTPIN, DHTTYPE);
  
  // DS18B20-> Data wire is plugged into port 2 on the Arduino
  #define ONE_WIRE_BUS 2
  OneWire oneWire(ONE_WIRE_BUS);
  DallasTemperature sensors(&oneWire); 
  
  #define anInput     A0 // MQ135-> analog feed from MQ135
  int counter = 0;
  
  void setup() {
    // set up the LCD's number of columns and rows:
    lcd.begin(16, 2);
    lcd.setRGB(colorR, colorG, colorB);
    lcd.print("ECOLOGY!");  
    pinMode(anInput,INPUT); // MQ135 
    lcd.setCursor(0, 1); // LCD 
    lcd.print("LoRa Sender");
    if (!LoRa.begin(915E6)) {
    lcd.setCursor(0, 1); // LCD 
    lcd.print("Starting LoRa failed!");    
      while (1);
    }
    sensors.begin();   //temperature sensor starts
    dht.begin();
  }
  
  void loop() {
    int co2now[10]; //int array for co2 readings
    int co2raw = 0; //int for raw value of co2
    int co2ppm = 0; //int for calculated ppm
    int zzz = 0; //int for averaging
    for (int x = 0;x<10;x++) // MQ135-> samplpe co2 10x over 2 seconds
    {                   
      co2now[x]=analogRead(A0);
      delay(200);
    }
    for (int x = 0;x<10;x++) // add samples together
    {                     
      zzz=zzz + co2now[x];  
    }  
    co2raw = zzz/10; // divide samples by 10
    co2ppm = co2raw;    
    int h = dht.readHumidity(); //We read the Humidity
    sensors.requestTemperatures();   //The command to read the temperature is sent
    int temp = sensors.getTempCByIndex(0); //The temperature is obtained in ยบC  
    // send packet
    LoRa.beginPacket();
    LoRa.print(temp);
    LoRa.print(",");
    LoRa.print(h);  
    LoRa.print(",");
    LoRa.print(co2ppm);
    LoRa.endPacket();
    lcd.clear();
    lcd.setCursor(0, 0); // LCD 
    lcd.print("P=");
    lcd.setCursor(3, 0); // LCD 
    lcd.print(counter);
    lcd.setCursor(8, 0); // LCD 
    lcd.print("T=");  
    lcd.setCursor(11, 0); // LCD 
    lcd.print(temp);
    lcd.setCursor(14, 0); // LCD 
    lcd.print("C");
    lcd.setCursor(0, 1); // LCD 
    lcd.print("H=");
    lcd.setCursor(3, 1); // LCD 
    lcd.print(h);   
    lcd.setCursor(6, 1); // LCD 
    lcd.print("%");
    lcd.setCursor(8, 1); // LCD 
    lcd.print("CO2="); 
    lcd.setCursor(13, 1); // LCD 
    lcd.print(co2ppm);
    counter++;   
    delay(13000);
  }
  

  LORAWAN RECEIVER

  Below I show you the schematic diagram of the receiver. device

  Below I show you the code used to upload it to the Arduino MKR WAN 1300 receiver board.

  LoRaReceiver_v5.ino

  // AUTHOR: GUILLERMO PEREZ GUILLEN
  
  #include <SPI.h>
  #include <LoRa.h>
  #include <Arduino.h>   // SERCOM1
  #include "wiring_private.h" // SERCOM1
  
  // SERCOM1: Rx->D9 & Tx->D8
  Uart Serial3 (&sercom1, 9, 8, SERCOM_RX_PAD_1, UART_TX_PAD_0);
  void SERCOM1_Handler()
  {
    Serial3.IrqHandler();
  }
  
  #include <Wire.h> // Library for I2C communication
  #include <LiquidCrystal_I2C.h> // Library for LCD
  LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 20, 4); // Change to (0x27,16,2) for 16x2 LCD.
  
  char cadena[30]; //We create an array that will store the characters that we will write in the PC console. We assign a limit of characters, in this case 30
  byte posicion=0;  //Variable to change the position of the characters in the array
  int valor;  //Integer Variable
  
  void setup() {
    lcd.init();  // Initiate the LCD:
    lcd.backlight();  
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.begin(9600);
    Serial3.begin(9600); // SERCOM1
    // Assign pins 8 & 9 SERCOM1 functionality
    pinPeripheral(8, PIO_SERCOM);
    pinPeripheral(9, PIO_SERCOM);
    Serial.println("LoRa Receiver")
    if (!LoRa.begin(915E6)) {
      Serial.println("Starting LoRa failed!");
      while (1);
    }
  }
  
  void loop() {
    int...

  Read more »

• 10. How to Connect LoRaWAN to an IoT Provider through the Arduino NANO 33 IoT

  Guillermo Perez Guillen • 07/26/2022 at 20:53 • 0 comments

  In this part of my project, the challenge is to connect my LoRa network to an IoT provider, but one with cost-effective. Below is the schematic diagram.

  In this project I am going to connect my LoRa network with an IoT provider through the Arduino NANO 33 IoT board. Reason:

  Its an economic solution, since the Arduino NANO 33 IoT board has an average cost of $20.70 USD.

  On the other hand, the Gateway Lora RAK2245 board has a price of: $ 154.55 USD.

  Creating a New Serial Port to the Arduino MKR WAN 1300 Board

  When I checked out the ATSAMD21 chip (the processor used in the Arduino MKR WAN 1300 board), I was very happy to see that the chip has 6 "SERCOM"s, a.k.a SERial COMmunication modules. Each one of these modules can be used for I2C, SPI or Serial. That means you can have 3 UART's & 3 SPI's, or maybe 2 SPI's and 4 I2C's. Basically, you have a ton of options for adding more hardware support for the most common 3 chip-to-chip protocols.

  UART has only 2 pins, RX & TX. UARTs are a real pain to emulate or bitbang due to their very precise timing and their asynchronous RX lines are very difficult to do if you dont have hardware interrupt pins available. For that reason, being able to create new Serial's is awesome.

  Now, what I need is to create a new serial port on the Arduino MKR WAN 1300 board to connect it with the Arduino NANO 33 IoT board via serial port. In this way the Arduino NANO board will receive the data from the sensors and can send them to any IoT provider.

  How Serial is Created Now

  You can find the actual code that is used to create the "Serial" SERCOM in variant.cpp

  You will see the serial objects on:

  The actual definitions of those macros is available in variant.h

  OK so let's make a new Serial SERCOM already

  I want to make a Serial! Lets try creating a new SERCOM and testing it out. Let's make a Serial device on SERCOM #1, lets look at what pin muxing options we've got:

  PIN number	PIN arduino	SERCOM
  PA16	D8 (MOSI)	SERCOM1.0
  PA17	D9 (SCK)	SERCOM1.1
  PA19	D10 (MISO)	SERCOM1.3
  PA18	D24 (USB)	SERCOM1.2

  Rules:

  • Tx only works on PAD 0 and PAD 2
  • RX works in any PAD

  I have selected next pins:

  • D8 FOR TX
  • D9 FOR RX

  In the next chapter I will show you how to program this data into the Arduino MKR WAN 1300 receiver board.

• 9. LoRaWAN´s Test with Multiple Sensors

  Guillermo Perez Guillen • 07/26/2022 at 20:41 • 0 comments

  LORAWAN´S SIMPLE TEST

  Before doing the field test, I decided to do a basic test indoor in order to correct any hardware or software issues. In the figure below I show you the devices assembled and ready for the basic test.

  In the video below I show you the test inside my house and the three sensors work without problems and the receiver device receives the data.

  LORAWAN´S FIELD TEST

  This is the place I chose to test my LoRa devices.

  In the image below I show you the transmitter and the receiver ready to work.

  Finally, in the video below I show you the tests carried out with this system.

  Notes:

  • Today there was some wind so the air is very clean, some cold fronts are even arriving from the north, so the weather is getting colder and rains are beginning to fall.
  • The tests were carried out successfully. In the following chapters I will show you how to link the data to an IoT service provider cheaply, and without spending a lot of money on hardware.

• 8. Modifying Receiver Code for Multiple Sensors

  Guillermo Perez Guillen • 07/26/2022 at 20:19 • 0 comments

  RECEIVER SCHEMATIC DIAGRAM

  In the figure below I show you the electrical diagram of the receiver device

  As you can see, there are no hardware changes, however the code must have changes since we will receive data from three sensors and these must be separated and shown on the display. All this through code. In the figure below I show you the transmitter and the receiver.

  RECEIVER CODE

  There were no hardware changes on the receiving device. However, in the software there were changes, and these are shown in the code below:

  LoRaReceiver_v3.ino

  // AUTHOR: GUILLERMO PEREZ GUILLEN
  
  #include <SPI.h>
  #include <LoRa.h>
  #include <Wire.h> // Library for I2C communication
  #include <LiquidCrystal_I2C.h> // Library for LCD
  LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 20, 4); // Change to (0x27,16,2) for 16x2 LCD.
  
  char cadena[30]; //We create an array that will store the characters that we will write in the PC console. We assign a limit of characters, in this case 30
  byte posicion=0;  //Variable to change the position of the characters in the array
  int valor;  //Integer Variable
  
  void setup() {
    lcd.init();  // Initiate the LCD:
    lcd.backlight();  
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.begin(9600);
    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) {
      memset(cadena, 0,sizeof(cadena));//memset deletes the contents of the array "cadena" from position 0 to the end sizeof   
      // received a packet
      Serial.print("Received packet... ");    
      // read packet
      while (LoRa.available()) {
        char dedos= (char)LoRa.read();
        Serial.print(dedos);
        cadena[posicion]=dedos;//Read a character from the string "cadena" from "posicion", then read the next character with "posicion++"
        posicion++;
      }
      posicion=0;
      int signal_rx = LoRa.packetRssi();          
      // print RSSI of packet
      Serial.print(" with RSSI ");
      Serial.println(signal_rx);
      int parte1 = getValue(cadena,',',0).toInt();
      int parte2 = getValue(cadena,',',1).toInt();
      int parte3 = getValue(cadena,',',2).toInt();
      Serial.println(parte1);
      delay(100);
      Serial.println(parte2);
      delay(100);
      Serial.println(parte3);
      delay(100);    
      // LCD data
      lcd.clear();
      lcd.setCursor(0, 0); 
      lcd.print("RSSI =");
      lcd.setCursor(7, 0); 
      lcd.print(signal_rx);
      lcd.setCursor(11, 0); 
      lcd.print("dBm");        
      lcd.setCursor(0, 1); 
      lcd.print("Temp =");
      lcd.setCursor(8, 1); 
      lcd.print(parte1);
      lcd.setCursor(11, 1); 
      lcd.print("C");    
      lcd.setCursor(0, 2); 
      lcd.print("Hum =");
      lcd.setCursor(8, 2); 
      lcd.print(parte2);
      lcd.setCursor(11, 2); 
      lcd.print("%");        
      lcd.setCursor(0, 3); 
      lcd.print("CO2 =");
      lcd.setCursor(8, 3); 
      lcd.print(parte3);
      lcd.setCursor(11, 3); 
      lcd.print("PPM");                       
      digitalWrite(LED_BUILTIN, HIGH);
      delay(2000);
      digitalWrite(LED_BUILTIN, LOW); 
    }
  }
  
  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]) : "";
  }
  

  • First you have to receive the data in a character string.
  • How did I separate the data from the three sensors? There are several methods to do it, I did it using the comma (,). 

  In the next post we will see a demonstration of how this project works.
  

• 7. Adding Multiple Sensors: DS18B20, DHT22 and MQ-135

  Guillermo Perez Guillen • 07/26/2022 at 19:52 • 0 comments

  TRANSMITTER SCHEMATIC DIAGRAM

  In the figure below I show you the electrical diagram of the transmitter after adding the DHT22 humidity sensor and the MQ-135 air quality sensor.

  ADDING THE DHT22 SENSOR

  In the figure below I show you the DHT22 sensor.

  In this sensor I only obtain humidity readings with value ranges between 0 to 100%. I omit the temperature readings as the DS18B20 temperature sensor has a better measurement range (-55°C to +125°C). You can get the library used to program this sensor here: DHT-sensor-library

  ADDING THE MQ-135 SENSOR

  In the figure below I show you the MQ-135 sensor.

  Sensitive material of gas sensor is SnO2, which with lower conductivity in clean air. When target pollution gas exists, the sensor’s conductivity gets higher along with the gas concentration rising. Users can convert the change of conductivity to correspond output signal of gas concentration through a simple circuit.

  I use this sensor to detect and measure carbon dioxide (CO2) particles in parts per million (ppm). In the following links you can find the reference information and the code to obtain it:

  https://github.com/5cottyD/Projects/blob/master/co2ppm_meter.ino

  Since these sensors have small differences, I made a small adjustment to this code to calibrate the CO2 level to 0. This is done in the following line of code:

  #define co2Zero 55 //calibrated CO2 0 level

  After mounting the three sensors, the device would look like the image below.

  TRANSMITTER CODE

  After adding the DHT22 and MQ-135 sensors, the transmitter code would be as shown below:

  LoRaSender_v3.ino

  // AUTHOR: GUILLERMO PEREZ GUILLEN
  
  #include <SPI.h> // LoRa->
  #include <LoRa.h>
  #include <OneWire.h> // DS18B20->               
  #include <DallasTemperature.h>
  #include <Wire.h> // LCD->
  #include "rgb_lcd.h"
  rgb_lcd lcd;
  const int colorR = 173;
  const int colorG = 255;
  const int colorB = 47;
  
  #include "DHT.h" // DHT22 ->
  #define DHTPIN 3    // Pin where the sensor is connected
  #define DHTTYPE DHT22   // DHT22 sensor
  DHT dht(DHTPIN, DHTTYPE);
  
  // DS18B20-> Data wire is plugged into port 2 on the Arduino
  #define ONE_WIRE_BUS 2
  OneWire oneWire(ONE_WIRE_BUS);
  DallasTemperature sensors(&oneWire); 
  
  #define anInput     A0 // MQ135-> analog feed from MQ135
  #define co2Zero     0 // calibrated CO2 0 level
  
  int counter = 0;
  
  void setup() {
    // set up the LCD's number of columns and rows:
    lcd.begin(16, 2);
    lcd.setRGB(colorR, colorG, colorB);
    lcd.print("ECOLOGY!");  
    pinMode(anInput,INPUT); // MQ135 
    lcd.setCursor(0, 1); // LCD 
    lcd.print("LoRa Sender");
    if (!LoRa.begin(915E6)) {
    lcd.setCursor(0, 1); // LCD 
    lcd.print("Starting LoRa failed!");    
      while (1);
    }
    sensors.begin();   
    dht.begin();
  }
  
  void loop() {
    int co2now[10]; //int array for co2 readings
    int co2raw = 0; //int for raw value of co2
    int co2ppm = 0; //int for calculated ppm
    int zzz = 0; //int for averaging
    for (int x = 0;x<10;x++) // MQ135-> samplpe co2 10x over 2 seconds
    {                   
      co2now[x]=analogRead(A0);
      delay(200);
    }
    for (int x = 0;x<10;x++) // add samples together
    {                     
      zzz=zzz + co2now[x];  
    }  
    co2raw = zzz/10; // divide samples by 10
    co2ppm = co2raw - co2Zero; // get calculated ppm
    if (co2ppm <= 0) {
      co2ppm = 1;
    }
    else {
      co2ppm = co2ppm;
    }     
    int h = dht.readHumidity(); //We read the Humidity
    sensors.requestTemperatures();   //The command to read the temperature is sent
    int temp = sensors.getTempCByIndex(0); //The temperature is obtained in ยบC 
    // send packet
    LoRa.beginPacket();
    LoRa.print(temp);
    LoRa.print(",");
    LoRa.print(h);  
    LoRa.print(",");
    LoRa.print(co2ppm);
    LoRa.endPacket();
    // LCD display data
    lcd.clear();
    lcd.setCursor(0, 0); // LCD 
    lcd.print("P=");
    lcd.setCursor(3, 0); // LCD 
    lcd.print(counter);
    lcd.setCursor(8, 0); // LCD 
    lcd.print("T=");  
    lcd.setCursor(11, 0); // LCD 
    lcd.print(temp);
    lcd.setCursor(14, 0); // LCD 
    lcd.print("C");
    lcd.setCursor(0, 1); // LCD 
    lcd.print("H=");
    lcd.setCursor(3, 1); // LCD 
   lcd.print(h);...

  Read more »

• 6. LoRaWAN´s Test with a DS18B20 Sensor

  Guillermo Perez Guillen • 07/26/2022 at 19:39 • 0 comments

  Before doing the field test, I decided to do a basic test indoor in order to correct any hardware or software issues. In the figure below I show you the devices assembled and ready for the basic test.

  In the video below I show you the test inside my house and the system worked without problems.

  FIELD TEST

  This is the place I chose to work.

  In the image below I show you the transmitter already working.

  In the image below I show you the receiver receiving the data more than 100 meters away from the transmitter.

  Finally, in the video below I show you the tests carried out with this system. This design will serve as an experience to make the system with three sensors and that will be shown in the later chapters.

• 5. Assembling the Receiver

  Guillermo Perez Guillen • 07/26/2022 at 19:35 • 0 comments

  In the figure below I show you the pieces that I print on the 3D printer. These pieces are used to fix the Arduino MKR WAN 1300 board and the LCD display.

  In the image below you can see the assembly of the Arduino MKR WAN 1300 board.

  And now in the image below you can see the assembly of the 20x4 LCD display.

  After fixing the Arduino MKR WAN 1300 board, the 20x4 display, the antenna and the battery; the receiving device looks like the one shown in the figure below.

  As a power supply I used Anker PowerCore II 6700. In addition to providing more accurate voltages, this device gave me better results since it has a power button, a voltage regulator and detects when a device is connected or not.

  I also recommend using a heavy-duty USB to make a good connection

  SCHEMATIC DIAGRAM

  After adding the 16x2 display, the wiring diagram of the receiver is as shown below.

  CODE

  After several attempts to find a library that works well with the Arduino MKR WAN 1300 board, I finally found this one that worked very well for me: LiquidCrystal_I2C

  After making these changes, the receiver code is shown below:

  LoRaReceiver_v2.ino

  // AUTHOR: GUILLERMO PEREZ GUILLEN
  
  #include <SPI.h>
  #include <LoRa.h>
  #include <Wire.h> // Library for I2C communication
  #include <LiquidCrystal_I2C.h> // Library for LCD
  LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 20, 4); // Change to (0x27,16,2) for 16x2 LCD.
  
  char cadena[30]; //We create an array that will store the characters that we will write in the PC console. We assign a limit of characters, in this case 30
  byte posicion=0;  //Variable to change the position of the characters in the array
  int valor;  //Integer Variable
  
  void setup() {  
    lcd.init();  // Initiate the LCD:
    lcd.backlight();  
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.begin(9600);
    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) {
      memset(cadena, 0,sizeof(cadena));//memset deletes the contents of the array "cadena" from position 0 to the end sizeof
      // received a packet
      Serial.print("Received packet... ");    
      // read packet
      while (LoRa.available()) {      
        char dedos= (char)LoRa.read();
        Serial.print(dedos);
        cadena[posicion]=dedos;//Read a character from the string "cadena" from "posicion", then read the next character with "posicion++"
        posicion++;
      }
      valor=atoi(cadena);//Convert the string to integers
      Serial.println();
      Serial.print(" temp=");
      Serial.print(valor);
      posicion=0;
      // print RSSI of packet
      int dedal = LoRa.packetRssi();
      Serial.print(" with RSSI: ");
      Serial.println(dedal);
      lcd.clear();
      lcd.setCursor(0, 0); // Set the cursor on the first column and first row.
      lcd.print("Temp:"); 
      lcd.setCursor(6, 0); 
      lcd.print(valor);
      lcd.setCursor(0, 2); // Set the cursor on the first column and second row.
      lcd.print("RSSI:"); 
      lcd.setCursor(5, 2); //Set the cursor on the fifth column and the second row (counting starts at 0!).
      lcd.print(dedal);        
      digitalWrite(LED_BUILTIN, HIGH);
      delay(2000);
      digitalWrite(LED_BUILTIN, LOW); 
    }
  }
  

• 4. Assembling the Transmitter

  Guillermo Perez Guillen • 07/26/2022 at 19:30 • 0 comments

  In the figure below I show the lid of the box to make the marks for the drill holes.

  Now below we see how this piece was after drilling.

  Once the holes are large enough, then it's time to attach the connectors.

  In the figure below I show you the pieces that I print on the 3D printer. These pieces are used to fix the Arduino MKR WAN 1300 board and the LCD display.

  In the image below you can see how to assemble the 16x2 LCD display that comes in the kit.

  Then we fix the Arduino MKR WAN 1300 board, the 16x2 LCD display, the DS18B20 sensor and the antenna.

  The transmitter would look like the figure below.

  As a power supply I used a generic 5V Portable Charger Power Bank 16800 mAh. In addition to providing more accurate voltages, this device gave me better results since it has a power button, a voltage regulator and detects when a device is connected or not.

  I also recommend using a heavy-duty USB to make a good connection

  SCHEMATIC DIAGRAM

  After adding the 16x2 display, the wiring diagram of the receiver is as shown below.

  CODE

  All the information needed to install the library you can get in this link: Grove-LCD RGB Backlight Library from Github

  After making these changes, the transmitter code is shown below: 

  LoRaSender_v2.ino

  // AUTHOR: GUILLERMO PEREZ GUILLEN
  
  #include <SPI.h>
  #include <LoRa.h>
  #include <OneWire.h> // DS1B20->               
  #include <DallasTemperature.h>
  #include <Wire.h> // LCD->
  #include "rgb_lcd.h"
  rgb_lcd lcd;
  const int colorR = 173;
  const int colorG = 255;
  const int colorB = 47;
  
  // Data wire is plugged into port 2 on the Arduino
  #define ONE_WIRE_BUS 2
  // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
  OneWire oneWire(ONE_WIRE_BUS);
  // Pass our oneWire reference to Dallas Temperature. 
  DallasTemperature sensors(&oneWire); 
  
  int counter = 0;
  
  void setup() {
    // set up the LCD's number of columns and rows:
    lcd.begin(16, 2);
    lcd.setRGB(colorR, colorG, colorB);
    // Print a message to the LCD.
    lcd.print("ECOLOGY!");  
    lcd.setCursor(0, 1); // LCD 
    lcd.print("LoRa Sender");
    if (!LoRa.begin(915E6)) {
    lcd.setCursor(0, 1); // LCD 
    lcd.print("Starting LoRa failed!");    
      while (1);
    }
    sensors.begin();
  }
  
  void loop() {
    sensors.requestTemperatures();   //The command to read the temperature is sent
    int temp= sensors.getTempCByIndex(0); //The temperature is obtained in ยบC
    lcd.clear();
    lcd.setCursor(0, 0); // LCD 
    lcd.print("Packet:");    
    lcd.setCursor(8, 0); // LCD 
    lcd.print(counter);
    lcd.setCursor(0, 1); // LCD 
    lcd.print("Temp:");    
    lcd.setCursor(8, 1); // LCD 
    lcd.print(temp);
    // send packet
    LoRa.beginPacket();
    LoRa.print(temp);
    LoRa.endPacket();
    counter++;
    delay(4000);
  }
  

• 3. LoRaWAN System Range Testing

  Guillermo Perez Guillen • 07/26/2022 at 19:11 • 0 comments

  The received signal strength indicator (RSSI) is a reference scale (in relation to 1 mW) to measure the power level of the signals received by a device in wireless networks (typically WIFI or mobile telephony).

  The scale tends to the value 0 (zero) as the center; y represents 0 RSSI or 0 dBm. Although theoretically it can be the case of measuring positive values, generally the scale is expressed within negative values; the more negative, the greater the loss of signal. On this scale a level of 0 dBm is equal to 1 mW (milliwatt).

  RSSI indicates received strength, not signal quality; since the latter is determined by contrasting the intensity of the signal with respect to the signal-to-noise ratio.

  Below you can see a table that can serve as a reference for the signal intensity.

  Signal strength (dBm)	Qualifier	Appropriate uses
  -30	Excellent	This is the maximum achievable signal strength and will be appropriate for any usage situation
  -50	Excellent	This excellent signal level is suitable for all network uses
  -65	Very good	Recommended for smartphones and tablets
  -67	Very good	This signal strength will be sufficient for voice over IP and video streaming
  -70	Acceptable	This level is the minimum signal strength required to ensure reliable package delivery and will allow you to browse the web and exchange emails
  -80	Bad	Allows basic connectivity, but packet delivery is unreliable
  -90	Very bad	A noise that inhibits most functions
  -100	Worst	Total noise

  
  

  LINK TESTS WITH THREE TYPES OF ANTENNAS

  • Here I have used the schematic diagram from post # 4 and I made 50 meters test links to test three different types of antennas.. Below I show you two antennas used in WiFi devices.

  The quality of the signal is bad according to our table, in the image below we see reception signals between -97 and -102 dBm.

  • Later we tested two antennas of a pole and of application in programming boards in GSM telephony.

  The signal improved remarkably between -64 and -76 dBm, I only observe some instability in maintaining the signal as it goes up and down continuously.

  • Finally, I have tested the original dipole antennas shown in the image below. 

  The signal is good and stable, staying between -64 and -69 dBm for a long time.

  Honestly, sending a message between two nodes in short links can feel like a real accomplishment. But the industry-wide excitement around LoRa is anchored in its long-range communication capabilities.

  LONG LINK TEST 

  • I left the transmitter in the same room and headed out walking to the ecological reserve with the receiver to see if the distance affected the range signal. Through some obstructions, transmission faded out at around 300 meters. The verdict? Definitely better than Wi-Fi, but not morethan 350 meters where the street curved into an area where there was no longer a clear line-of-sight, transmission quickly stopped.
  • In my case, this system works for me since the shortest point of the ecological reserve is 50 meters from my house, and the longest point is approximately 500 meters. So I can choose some strategic points to monitor the ecological reserve without problems.

View all 12 project logs