Conexión de modulo LoRa a servidor mediante HTTP:

Una vez realizadas las pruebas en el servidor, se puede comprobar que los datos que son
enviados manualmente desde una interfaz web llegan hasta este y son almacenados en
una base de datos, sin embargo, lo que buscaremos será enviar los datos que recibe el
Gateway LoRa de el modulo ubicado en campo, esto se realizara mediante el protocolo
HTTPS pues es el protocolo usado en el servidor.
En la última prueba realizada es el modulo quien tenía la función de ser un servidor
local por lo que mediante un código en HTML mostraba la interfaz al ingresar el IP en
el navegador, sin embargo, con la nueva conexión el módulo Gateway de LoRa será un
cliente del servidor realizado, por lo que se retirará el código HTML y se configurará el
código para establecer la conexión mediante HTTP.

Imagen 01: Configuración dirección servidor (Fuente: Elaboración propia)

Para establecer la conexión primero es necesario el dominio del servidor, como se
muestra en el código para establecer la conexión se necesita la url que consta de 3
partes: La primera es el protocolo el cual en este caso es https, luego seguido del host
que es con quien nos comunicaremos (grupo11wsn.000webhostapp.com) además del
resource (es decir el sub dominio ) en este caso es al fichero de “prueba_recibe” y
finalmente el puerto que ha sido asignado es el 80 ya que es usado para navegación web
(de forma no segura).

Imagen 02: Inicialización y envío de datos mediante http (Fuente: Elaboración propia)

Ya que se está usando la librería “HTTPClient” lo primero será crear un objeto (en este
caso lo llamaremos http), lo siguiente será llamar al método “begin” para poder acceder
al servidor, en este caso ya se ha declarado la estructura de la URL al principio (es decir
la url del servidor) por lo que la línea de código será http.begin(url).
En la línea de código “http.addHeader("Content-Type", "application/x-www-form-
urlencoded")” define el formato con el que va a recibir los datos el servidor mientras
que con el método “post” enviaremos los datos, sin embargo debemos declarar antes
una variable, en este caso “postData” que estará integrado por 3 variables: El
dispositivo, la temperatura y la humedad. En la cadena de texto enviada en “postData”
debemos asignar que variable de nuestro modulo estará relacionada con la variable del
servidor (por ejemplo, el dato alojado en la variable “temperature” será enviado a la
variable “temperatura” declarada en el servidor.
Una vez armada la trama almacenada en la cadena “postData” enviaremos los datos
mediante el comando http.POST(poastData) al servidor y este enviara una respuesta a
nuestro modulo la cual capturaremos mediante el comando http.getString el cual será
almacenado en la cadena “respuesta” por lo que dependiendo de la trama podremos
extraer los datos mediante el comando indexOf. Finalmente terminamos la
comunicación con http.end y agregamos un “delay” para poder enviar los datos al
servidor cada 5 segundos.
Anexos:
Código Cliente:
#include "heltec.h"
#include <OneWire.h>
#include <Wire.h>
#include <SPI.h>
#include <DallasTemperature.h>
#define BAND 915E6 //Seleccionamos la banda en la que trabajaremos, ejm:
868E6,915E6

OneWire ourWire(2);
DallasTemperature sensors(&ourWire); //Se declara una variable u objeto para nuestro
sensor

String message; // Mensaje empaquetado

String readingID;

byte localAddress = 0xBB; // Dirección del dispositivo emisor (Local)

byte destination = 0xFD; // Dirección del dispositivo destino
byte msgCount = 0; // Contador de mensajes enviados
float humidity; // Valor de prueba de humedad.
float pressure = 0; // Valor de prueba de presión.

const int dry = 3690; //Prueba en el aire

const int wet = 1333; //Prueba en el agua

void setup()
{
Heltec.begin(true /*DisplayEnable Enable*/, true /*Heltec.LoRa Disable*/, true
/*Serial Enable*/, true /*PABOOST Enable*/, BAND /*long BAND*/);
sensors.begin(); //Se inicia el sensor

Heltec.display->init(); //Inicializamos el display

Heltec.display->flipScreenVertically(); //Definimos que trabajaremos con la LCD de
forma vertical
Heltec.display->setFont(ArialMT_Plain_10); //Tamaño y tipo de letra.
delay(1500);
Heltec.display->clear(); //Limpieza de pantalla
Heltec.display->drawString(0, 0, "Heltec.LoRa Initial success!");
Heltec.display->display();
delay(1000);
}

void loop()
{
sensors.requestTemperatures(); //Se envía el comando para leer la temperatura
float temp= sensors.getTempCByIndex(0); //Se obtiene la temperatura en ºC

int sensorval = analogRead(12); //Se lee el dato del puerto del sensor de humedad
humidity = map(sensorval, wet, dry, 100, 0); //Tomando como referencia el valor
medido en seco y humedo obtenemos el porcentaje de humedad
 Heltec.display->clear();
Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
Heltec.display->setFont(ArialMT_Plain_10);
Heltec.display->drawString(0, 0, "T(°C): ");
Heltec.display->drawString(35, 0, String(temp));
Heltec.display->drawString(0, 10, "H(%): ");
Heltec.display->drawString(35, 10, String(humidity));
Heltec.display->display();

Serial.print("Humedad= ");
Serial.print(humidity);
Serial.println("%");

Serial.print("Temperatura= ");
Serial.print(temp);
Serial.println("°C");

message = String(msgCount) + "/" + String(temp) + "&" + String(humidity) + "#" +

String(pressure); // Se empaqueta los datos a enviar
int packetSize = LoRa.parsePacket(); //Se guarda el valor de parsePacket en
packetSize
if (packetSize) {
int recipient = LoRa.read(); // Dirección del receptor
byte sender = LoRa.read(); // Dirección del emisor

if (recipient == localAddress) {
Serial.println("Solicitud recibida desde Host."); //Se comprueba si la solicitud
enviada por el Host esta dirigida a este dispositivo
sendMessage(message);// Se envia la cadena a la funcion sendMessage
Serial.println("Enviando: " + message); //Muestra el mensaje a enviar
}
 }
}

void sendMessage(String outgoing)

{
LoRa.beginPacket(); // Inicia el paquete
LoRa.write(destination); // Agregamos la dirección del destino
LoRa.write(localAddress); // Agregamos la dirección del dispositivo local (el
que envia el mensaje)
LoRa.write(msgCount); // Numero de mensaje (ID)
LoRa.write(outgoing.length()); // Longitud del mensaje enviado
LoRa.print(outgoing); // Envia el mensaje como cadena
Serial.print("Enviando datos a Host");
LoRa.endPacket(); // Finaliza el paquete
msgCount++; // Incrementamos el valor del contador
}

Código Servidor:
#include <WiFi.h>
#include <WiFiClient.h>
#include <heltec.h>
#include <HTTPClient.h>

#define BAND 915E6 //Seleccionamos la banda en la que trabajaremos, ejm:

868E6,915E6

//en conexion local no se colocal localhost sino la ip de la maquina que es serivor,

ademas de llamar el archivo "recive"
String protocol="http://";
String host = "grupo11wsn.000webhostapp.com";
String resource = "/servidoriot/prueba_recibe.php";
int port = 80;
String url = protocol + host + resource;

const char* ssid = "WLAN_7AB4";

const char* password = "k4p6i2X8T1g6l";

String outgoing; // Mensaje de salida

String temperature;
String humidity;
String pressure;
String readingID;

byte localAddress = 0xFD; // Dirección del dispositivo emisor (Local)

byte destination; // Dirección del dispositivo destino

byte msgCount = 0; // Contador de mensajes enviados

long lastSendTime = 0; // Ultimo tiempo de envio
int interval = 2000; // Intervalo de tiempo entre mensajes

String device = "tarjeta1";

String postData;

void setup()
{
Heltec.begin(true /*DisplayEnable Enable*/, true /*Heltec.LoRa Enable*/, true
/*Serial Enable*/, true /*PABOOST Enable*/, BAND /*long BAND*/);
Serial.begin(115200);

WiFi.begin(ssid, password);
Serial.println("Connecting");
while(WiFi.status() != WL_CONNECTED) {
delay(500);
 Serial.print(".");
}
Serial.println("");
Serial.print("Connected to WiFi network with IP Address: ");
Serial.println(WiFi.localIP());
}

void sendMessage(byte destinationD)

{
LoRa.beginPacket(); // Inicia el paquete
LoRa.write(destinationD); // Agregamos la dirección del destino
LoRa.write(localAddress); // Agregamos la dirección del dispositivo local (el
que envia el mensaje)
LoRa.endPacket(); // Finaliza el paquete
msgCount++; // Incrementamos el valor del contador
}

void onReceive(int packetSize)

{
if (packetSize == 0) return; // Si no ha llegado un paquete entonces finaliza la
función

// read packet header bytes:

int recipient = LoRa.read();
byte sender = LoRa.read();
byte incomingMsgId = LoRa.read();
byte incomingLength = LoRa.read();
String LoRaData = LoRa.readString();
Serial.println(LoRaData);
// Dirección del receptor
// Dirección del emisor
// ID del mensaje
// Longitud del mensaje

// A partir de aqui se extrae los datos de presión, temperatura y humedad de la trama

recibida
 int pos1 = LoRaData.indexOf('/');
int pos2 = LoRaData.indexOf('&');
int pos3 = LoRaData.indexOf('#');
readingID = LoRaData.substring(0, pos1);
temperature = LoRaData.substring(pos1 +1, pos2);
humidity = LoRaData.substring(pos2+1, pos3);
pressure = LoRaData.substring(pos3+1, LoRaData.length());

// Si la longitud no es la misma que la del mensaje recibido

if (incomingLength != LoRaData.length())
{ // check length for error
Serial.println("error: la longitud del mensaje no coincide con la longitud");
return;
}

// Si no corresponde a la dirección de este dispositivo

if (sender != destination && sender != 0xFF) {
Serial.println("Este mensaje no es para mí.");
return; // skip rest of function
}

HTTPClient http; //inicializamos el cliente HTTP

http.begin(url); //Establecemos conexión con la url ya configurada
http.addHeader("Content-Type", "application/x-www-form-urlencoded"); //

postData="device_label=" + device + "&temperatura=" + String(temperature) +

"&humedad=" + String(humidity);

int httpCode = http.POST(postData);

String respuesta = http.getString();
Serial.println(httpCode);
 Serial.println(respuesta);

//int ini = respuesta.indexOf(":");

//int fin = respuesta.indexOf(",",ini);
//String rpt = respuesta.substring(ini+1, fin).toInt();
//Serial.println(rpt);

http.end();
delay (5000); //Este delay sirve para controlar los tiempos xd

// Si las anteriores condiciones se cumplen, se muestra el mensaje

//Serial.println("Recbido desde: 0x" + String(sender, HEX));
//Serial.println("Enviado a: 0x" + String(recipient, HEX));
//Serial.println("ID del mensaje: " + String(incomingMsgId));
//Serial.println("Longitud del mensaje: " + String(incomingLength));
//Serial.println("Mensaje: " + LoRaData);
//Serial.println("RSSI: " + String(LoRa.packetRssi()));
//Serial.println("Snr: " + String(LoRa.packetSnr()));
//Serial.println();
}
void loop()
{
if (millis() - lastSendTime > interval){
destination = 0xBB;
sendMessage(destination);// Se envia la cadena a la funcion sendMessage
Serial.println("Enviando solicitud equipo 01");
lastSendTime = millis(); // Se asigna nuevo valor a lastSendTime
interval = random(2000) + 1000; // 2-3 segundos entre intervalo
}
onReceive(LoRa.parsePacket());
}