Monitoreo de la calidad del aire de ciudades inteligentes basado en LoRa

Acerca de este proyecto

Ciudad inteligente y calidad del aire

El Banco Mundial define una ciudad inteligente como una ciudad intensiva en tecnología. Esto significa servicios públicos altamente eficientes.

Una de las características fundamentales de las ciudades inteligentes es proporcionar un entorno sostenible. Para un medio ambiente sostenible, es necesario monitorear las condiciones ambientales para identificar las fuentes de contaminación y mitigarlas. En este contexto, se colocan miles de sensores de calidad del aire para proporcionar información en tiempo real tanto al gobierno como a los ciudadanos. Estos datos se pueden convertir en información útil, lo que nos permite tomar mejores decisiones, ya sea para planificar el transporte o para saber qué ruta es la mejor para caminar hasta el trabajo.

La detección de la calidad del aire encaja bien con la visión de la ciudad inteligente:brinda información sobre una ciudad que antes no estaba disponible, lo que permite a las personas tomar decisiones que pueden mejorar la calidad de sus vidas.

Problema y solución

El aumento del nivel de contaminación del aire en las grandes ciudades se ha convertido en una gran preocupación debido al riesgo que representa para la salud humana. En este contexto, la tecnología se ha convertido en una herramienta de gran utilidad en el monitoreo de la contaminación y la posible mitigación de su impacto. En particular, existen diferentes propuestas que utilizan el paradigma de Internet de las cosas (IoT) que utiliza sensores interconectados para medir diferentes contaminantes. Se puede implementar una red de nodos de sensores de monitoreo de la calidad del aire de bajo costo para monitorear la calidad del aire y los parámetros meteorológicos. Por lo tanto, a través de la detección de fuentes de contaminación, la ciudad puede tomar medidas correctivas y mejorar su salud ambiental. Instalando sistemas de detección de desastres como inundaciones y soluciones de monitoreo de lluvias en su entorno. los ciudadanos pueden ser alertados de antemano en caso de un evento catastrófico. Se puede derivar una visión holística, lo que permite a las autoridades tomar decisiones de planificación de políticas e infraestructura basadas en datos.

El plan del proyecto

En este proyecto, vamos a monitorear algunos de los parámetros ambientales más importantes, como el ruido, la temperatura, la humedad y la calidad del aire. Transmite datos en tiempo real a través del protocolo de comunicación inalámbrica a una plataforma en la nube. El equipo funciona completamente con energía solar con una batería de respaldo. Se puede acceder a los datos del dispositivo en un panel que visualiza y analiza los datos en los formatos deseados.

Para el monitoreo de la calidad del aire de una ciudad inteligente, debe colocar nodos de sensores en diferentes ubicaciones. En términos de consumo de energía y costo, no es una buena idea conectar cada nodo sensor individualmente a la nube. Más bien, es una buena idea recopilar datos de todos los nodos de sensores de un área pequeña y publicar todos los datos en la nube desde una única puerta de enlace. LoRa puede darnos esta ventaja y es por eso que elegí LoRa para mi proyecto.

Para el servicio en la nube, estoy usando Grandeur para mi proyecto. Grandeur es una plataforma de IoT comparativamente nueva y amigable para los fabricantes en la que podemos almacenar nuestros datos y visualizar los datos haciendo widgets de gráficos utilizando el método de arrastrar y soltar. También proporcionan Arduino, JavaScript y Python SDK con código de ejemplo. Por lo tanto, uno puede conectarse fácilmente con su servicio usando Arduino, NodeMCU y Raspberry Pi.

La mejor forma de alimentar un nodo sensor es utilizar un panel solar. Debido a que los nodos de sensores están ubicados en una ubicación remota diferente y no siempre es posible cambiar la batería con frecuencia o proporcionar energía desde una fuente de energía. Estoy proporcionando energía a la nota de mi sensor mediante el panel solar y la batería de iones de litio.

Creación del nodo sensor

Quiero controlar la calidad del aire, el nivel de ruido, la temperatura y la humedad. Así que utilicé el sensor de calidad del aire Grove, el sensor de ruido Grove y el sensor de temperatura y humedad Grove DHT11. Una cosa buena de los sensores Grove es que puede conectar todos los sensores Grove a Arduino usando el escudo base Grove sin soldaduras.

Para alimentar el circuito utilicé un panel solar Grove de 1W y una batería de iones de litio. Para cargar la batería usando el panel solar utilicé el cargador solar Seeed LiPo Rider Pro que tiene un convertidor elevador de 5V incorporado. Entonces podemos ejecutar Arduino fácilmente usando la salida del LiPo Rider.

La mayoría de los componentes que se utilizan aquí están disponibles en Seeedstudio.com. La siguiente imagen muestra una conexión de prueba plug-and-play para todos los componentes del nodo sensor.

Para transmitir los datos del sensor a la puerta de enlace de IoT, utilicé el transceptor Reyax LoRa. La siguiente imagen muestra el módulo Lora Reyax RYLR998 con el diagrama de pines.

Preparación del motor LoRa Reyax RYLR998 para conectarse con Arduino Base Shield

El RYLR998 tiene una salida de 5 pines macho y no es compatible con el protector de base Grove. Para conectarlo a Grove Shield, soldé un cable Grove en una placa perfilada con un cabezal hembra de 5 pines. La conexión del circuito es la siguiente:

El módulo RYLR998 LoRa puede operar con seguridad hasta 3.6V. El pin Arduino TX produce una salida de 5 V que no es segura para LoRa. Entonces, usé un divisor de voltaje para obtener 3.4 V del pin Arduino TX. Por otro lado, el pin Arduino RX funciona perfectamente en la lógica de 3.3V. Entonces, conecté el pin TX del LoRa al pin RX del Arduino directamente. Para un funcionamiento normal, el pin RST del LoRa debe estar en estado alto.

Ahora el módulo LoRa anterior se puede conectar fácilmente al blindaje de la base usando el siguiente circuito convertidor.

Pero antes de conectar el módulo al protector de la base, asegúrese de que el botón de encendido del protector de la base esté en la posición de 3.3V como se muestra en la imagen de abajo.

Después de conectar el módulo LoRa al escudo base, podemos probar enviando el comando AT al módulo desde Arduino.

Comunicación mediante el transceptor LoRa RYLR896

Para establecer comunicación entre dos módulos LoRa, deben poder encontrarse entre sí por una dirección. El esquema de direccionamiento del ecosistema LoRa depende un poco de los módulos y la implementación. Simplemente hablando, el módulo nos permite establecer una identificación de red y una dirección. Los módulos de la misma red (mismo ID de red) pueden comunicarse entre sí. Se supone que cada módulo tiene una identificación (dirección) única dentro de una red. Si un módulo tiene una dirección 0, ese módulo puede recibir datos de todos los dispositivos en la red.

Cada módulo viene con una frecuencia, una identificación de red y una dirección predeterminadas, pero es posible que deba cambiar el valor predeterminado. La identificación de red predeterminada para el módulo anterior es 18 y la dirección es 0.

No necesitamos cambiar nada en este momento para nuestro proyecto de demostración. Pero si desea cambiar algún parámetro, consulte la hoja de datos para conocer los detalles de los comandos AT.

Para enviar un mensaje (¡HOLA RECEPTOR!), Solo necesitamos enviar el comando "AT + ENVIAR =0, 15, ¡HOLA RECEPTOR!" en la conexión serial del módulo. El primer valor de parámetro "0" es la dirección del módulo receptor. El siguiente valor '15' es el número de caracteres / bytes que se enviarán. El tercer valor del parámetro es el mensaje que se enviará:"¡HOLA RECEPTOR!" (15 caracteres).

Código para el nodo del sensor

El siguiente código está desarrollado para que el nodo sensor recopile todos los datos del sensor y los transmita a la puerta de enlace de IoT.

  #include "AirQuality.h" // biblioteca de calidad del aire de grove 
 #include "Arduino.h" 
 #include "DHT.h" 
 
 # definir DHTPIN 4 // qué sensor DHT de pin digital conectado 
 #definir DHTTYPE DHT11 // modelo del sensor DHT11 
 
 DHT dht (DHTPIN, DHTTYPE); 
 
 Sensor de calidad del aire AirQuality; 
 int current_quality =-1; 
 
 const int sampleWindow =50; // Ancho de la ventana de muestra en mS (50 mS =20Hz) 
 unsigned int sample; 
 float noise; 
 float temp, humid; 
 int airQuality; 
 
 // ---------------------------------------------- ---------------------------------------------- 
 // CONFIGURACIÓN 
 // ----------------------------------------- -------------------------------------------------- - 
 configuración vacía () 
 {
 
 Serial.begin (115200); // Serie para lora 
 airqualitysensor.init (14); 
 dht.begin (); 
 
} 
 
 // ----- -------------------------------------------------- ------------------------------------- 
 // BUCLE PRINCIPAL 
 / / ------------------------------------------------- ------------------------------------------- 
 
 void loop () 
 {
 noise =calculate_sound_in_db (); 
 airQuality =calculate_air_quality (); 
 calculate_temp_humid (); 
 
 String temperature =String (temp); 
 String humedad =String (húmedo); 
 String sound =String (ruido); 
 String air =String (airQuality); 
 
 Valores de cadena =String (temperatura) + "," + String (humedad) + "," + String (sonido) + "," + String (aire); 
 String cmd ="AT + SEND =0," + String (valores.longitud ()) + "," + valores; // EN + ENVIAR =, ,  
 Serial.println (cmd); // enviado a lora 
 
 delay (15000); 
} 
 
 // esta función calcula el nivel de sonido en dB 
 float calculate_sound_in_db () {
 unsigned long startMillis =millis (); // Inicio de la ventana de muestra 
 float peakToPeak =0; // nivel pico a pico 
 
 unsigned int signalMax =0; // valor mínimo 
 unsigned int signalMin =1024; // valor máximo 
 
 // recopila datos para 50 mS 
 while (millis () - startMillis  {
 sample =analogRead (A1); // obtener lectura del micrófono 
 if (sample <1024) // descartar lecturas falsas 
 {
 if (sample> signalMax) 
 {
 signalMax =sample; // guarda solo los niveles máximos 
} 
 else if (sample  {
 signalMin =sample; // guarda solo los niveles mínimos 
} 
} 
} 
 peakToPeak =signalMax - signalMin; // max - min =amplitud pico-pico 
 //Serial.println(peakToPeak); // escribe decibeles calibrados 
 float db =map (peakToPeak, 0,1000,48,120); // calibrar para decibelios 
 //Serial.print(db); // escribe decibeles calibrados 
 //Serial.println ("dB"); // escribir unidades 
 return db; 
} 
 
 int calculate_air_quality () {
 current_quality =airqualitysensor.slope (); 
 / * 
 if (current_quality> =0) // si se devolvieron datos válidos. 
 {
 if (current_quality ==0) 
 Serial.println ("¡Alta contaminación! Forzar señal activa"); 
 else if (current_quality ==1) 
 Serial.println ("¡Alta contaminación!"); 
 else if (current_quality ==2) 
 Serial.println ("Baja contaminación ! "); 
 else if (current_quality ==3) 
 Serial.println (" Fresh air "); 
} 
 * / 
 return current_quality; 
} 
 
 void calculate_temp_humid () {
 // ¡La lectura de la temperatura o la humedad tarda unos 250 milisegundos! 
 // Las lecturas del sensor también pueden tener hasta 2 segundos de antigüedad ( es un sensor muy lento) 
 float h =dht.readHumidity (); 
 // Lee la temperatura como Celsius (el valor predeterminado) 
 float t =dht.readTemperature (); 
 
 // Compruebe si alguna lectura falló y salga antes (para volver a intentarlo). 
 if (isnan (h) || isnan (t)) {
 //Serial.println("¡No se pudo leer del sensor DHT! "); 
 return; 
} 
 
 temp =t; 
 humid =h; 
 / * 
 Serial.print ("Humedad:"); 
 Serial.print (h); 
 Serial.print ("% \ t"); 
 Serial.print ("Temperatura:"); 
 Serial.print (t); 
 Serial.print ("* C"); 
 * / 
} 
 
 // interrumpir la rutina de servicio para el sensor de calidad del aire 
 ISR (TIMER1_OVF_vect) 
 {
 if (airqualitysensor.counter ==61) // establecer 2 segundos como servicio detectado 
 {
 
 airqualitysensor.last_vol =airqualitysensor.first_vol; 
 airqualitysensor.first_vol =analogRead (A0); 
 airqualitysensor.counter =0; 
 airqualitysensor.timer_index =1; 
 PORTB =PORTB ^ 0x20; 
} 
 else 
 {
 airqualitysensor.counter ++; 
} 
}  

El código envía los datos del sensor cada 15 segundos. Cambie el tiempo según sus necesidades.

Cargar y probar

Ahora conecte todos los sensores, cargue el código anterior y pruebe en el monitor en serie. El archivo fuente se adjunta en la sección de código.

Colocación de componentes dentro de la caja

Ahora colocaremos todos los sensores y batería dentro de la caja. Primero, imprima en 3D los dos archivos STL adjuntos en la sección de archivos adjuntos. Las imágenes impresas se ven como la siguiente imagen.

El cuadro completo se verá como sigue. Es posible que necesite una base de envío basada en la calidad de su impresora.

Después de preparar la caja, primero coloque el panel solar en la parte superior de la caja. Los cables de conexión dentro de la caja a través del orificio superior.

Luego coloque el Arduino con el protector de base adjunto primero con un poco de gule caliente o cinta adhesiva de doble cara. Coloque los otros sensores uno por uno y fíjelos en un lugar fijo con un poco de pegamento caliente.

Coloque la batería y el lipo rider pro y finalmente agregue el módulo LoRa.

El nodo sensor está listo para implementarse.

Configurando Grandeur

Grandeur proporciona un servicio de backend para dispositivos IoT donde se crea un par de dispositivo-usuario virtual. El modelo de dispositivo se describe al crearse como un objeto JSON que contiene varias variables (temperatura, humedad, nivel de ruido, calidad del aire en nuestro caso) que se pueden leer y escribir. Grandeur Canvas es una aplicación web que se puede utilizar para visualizar el estado del dispositivo de dispositivos emparejados mediante widgets gráficos.

Para usar Grandeur, tenemos que crear nuestra cuenta y hacer algunas configuraciones importantes en la plataforma. Visite su sitio web https://grandeur.dev/ para entrar en el juego.

1. Después de iniciar sesión en la cuenta raíz, cree un nuevo proyecto :

2. Cree una nueva cuenta de usuario desde Agregar cuenta opción desde la pestaña Inicio o desde la pestaña Cuentas. Más tarde, iniciaremos sesión en nuestra aplicación con el correo electrónico y la contraseña que creamos ahora. Esta es otra característica interesante de Grandeur: varios usuarios pueden usar su aplicación iniciando sesión con sus correos electrónicos y contraseñas . Cada usuario puede emparejar sus propios dispositivos y el dispositivo emparejado por un usuario deja de estar disponible para otros. La autenticación se basa en el núcleo de Grandeur. La creación de usuarios se ilustra a continuación:

3. Ahora crea un nuevo dispositivo a través de la pestaña de dispositivos. Esta operación genera una nueva ID de dispositivo única que usaremos mientras escribimos código para nuestro hardware y esta ID de dispositivo es necesaria para conectarse a Grandure usando API. La creación de un dispositivo también genera un accessToken. No olvide copiarlo y se utilizará en el código de hardware y no será accesible después de cerrar el cuadro de diálogo . Debe agregar un modelo de dispositivo antes de agregar un dispositivo mediante el siguiente procedimiento. Se utiliza un modelo de dispositivo para describir qué variables pueden ser comunicadas por / al dispositivo.

De los modelos, haga clic en Agregar y dar un nombre de modelo. En el esquema coloque todas las variables (4 en nuestro caso) en formato JSON. Mantenga el valor 0 en este momento. Esta variable se actualizará automáticamente cuando enviemos datos desde nuestro nodo de dispositivo.

  {"temp":0, "húmedo":0, "aire":0, "ruido":0}  

Después de poner el esquema, haga clic en Agregar.

Después de agregar el modelo de dispositivo, haga clic en la opción Agregar desde dispositivos y seleccione el modelo que acaba de crear para vincular el modelo al dispositivo.

Proporcione una identificación de dispositivo y haga clic para Registrarse.

Copie el token de acceso y se utilizará en el código de hardware y no será accesible después de cerrar el cuadro de diálogo.

El dispositivo se creó correctamente y anote también la ID DEL DISPOSITIVO. También será necesario para la codificación.

Un usuario no puede interactuar con un dispositivo a menos que esté emparejado con él. Hay dos formas de vincular su dispositivo :1) usando el Panel de control en la nube, o 2) a través de la aplicación web usando pairDevice () función de la API del dispositivo. Esta segunda forma tiene un significado muy fuerte si se mira desde el punto de vista de la producción. Como ahora puede enviar sus productos de hardware, y sus usuarios pueden iniciar sesión en su aplicación y declarar la propiedad de un hardware emparejándolo. A continuación, le indicamos cómo puede vincular su dispositivo con un usuario mediante el Panel de control en la nube:

Para emparejar el dispositivo, haga clic en Emparejar y elija una cuenta. Está listo para continuar con el siguiente paso.

4. Crearemos un lienzo ahora.

En el menú de la izquierda del panel, haga clic en el lienzo o vaya a https://canvas.grandeur.tech. Si es la primera vez que visita Canvas, una Autorización aparecerá el botón. La autorización le da a Canvas acceso a los usuarios y dispositivos de su proyecto. Al hacer clic en el botón "Autorizar", se le redirigirá de nuevo al panel de Grandeur, donde se le pedirá que elija el proyecto al que desea que Canvas se vincule.

Elija un gráfico de widgets y haga clic en él. Aparecerá el menú Configurar y luego haga clic para configurar para darle un título al gráfico y establecer la variable cuyo valor desea mostrar en este gráfico.

Haga clic para guardar.

Siguiendo el mismo procedimiento, agregue 4 widgets de gráficos para las 4 variables.

Después de conectar Canvas a su proyecto, es posible que vea una pantalla de inicio de sesión. Debe iniciar sesión aquí como usuario de su proyecto que creó anteriormente, para lo cual debe crear una cuenta de usuario en su proyecto. Puede hacerlo visitando la página de cuentas del panel de control. Luego, puede iniciar sesión en Canvas utilizando las credenciales de este nuevo usuario.

Preparing IoT LoRa Gateway

In a simple way, an IoT Gateway is like home or office network router or gateway that connects sensors, IoT modules, and smart devices to the cloud. Such a gateway facilitates communication between your devices, maintains security, and provides an admin interface where you can perform basic functions.

A true IoT gateway contains communication technologies connecting end-devices (sensors, actuators, or more complex devices) and backend platforms (data, device, and subscriber management) to the gateway. It has a computing platform allowing pre-installed or user-defined applications to manage data (for routing and computing at the edge), devices, security, communication, and other aspects of the gateway.

Raspberry Pi can be a good option for a gateway with lots of flexibility but to keep it simple I am using Node MCU as a gateway for this project. Node MCU will receive the data from the LoRa module using UART. Then using Arduino SDK we will upload the data to the Grandeur cloud platform.

Firmware for the Gateway

The following code was developed for the gateway using Arduino SDK provided by Grandeur cloud. Data is received in string form from the LoRa using the UART port. Then the received data is processed to separate the individual variable from the comma-separated string value. The values are then sent to Grandeur using WiFi. The following function was used to separate the variables.

void process_received_data(){
 
 start_pos =inputString.indexOf(start_val);
 end_pos =inputString.indexOf(end_val);
 String data_string =inputString.substring(start_pos+1, end_pos-1);
 //Serial.println(data_string);
 //identifying commas inn the string
 int firstCommaIndex =data_string.indexOf(',');
 int secondCommaIndex =data_string.indexOf(',', firstCommaIndex+1);
 int thirdCommaIndex =data_string.indexOf(',', secondCommaIndex+1);
 //seperating comma seperated value from the data string 
 String temperature =data_string.substring(0, firstCommaIndex);
 String humidity =data_string.substring(firstCommaIndex+1, secondCommaIndex);
 String noise_level =data_string.substring(secondCommaIndex+1, thirdCommaIndex);
 String air_auality =data_string.substring(thirdCommaIndex+1);
 
 //Serial.println(temperature);
 //Serial.println(humidity);
 //Serial.println(noise);
 //Serial.println(air_auality);

 temp =temperature.toFloat();
 humid =humidity.toFloat();
 noise =noise_level.toFloat();
 air =air_auality.toFloat(); 

 Serial.println(temp);
 Serial.println(humid);
 Serial.println(noise);
 Serial.println(air);
 
 inputString ="";
 stringComplete =false;
 } 

The complete code is attached in the code section.

Data Visualization

#include "AirQuality.h" //grove air quality library#include "Arduino.h"#include "DHT.h"#define DHTPIN 4 // what digital pin DHT sensor connected to#define DHTTYPE DHT11 // model of the sensor DHT11 DHT dht(DHTPIN, DHTTYPE);AirQuality airqualitysensor;int current_quality =-1;const int sampleWindow =50; // Sample window width in mS (50 mS =20Hz)unsigned int sample;float noise;float temp, humid;int airQuality; //-------------------------------------------------------------------------------------------- // SETUP //--------------------------------------------------------------------------------------------void setup() { Serial.begin(115200); //Serial for lora airqualitysensor.init(14); dht.begin();} //--------------------------------------------------------------------------------------------// MAIN LOOP//-------------------------------------------------------------------------------------------- void loop() { noise =calculate_sound_in_db(); airQuality =calculate_air_quality(); calculate_temp_humid(); String temperature =String(temp); String humidity =String(humid); String sound =String(noise); String air =String(airQuality); String values =String(temperature)+","+ String(humidity)+","+ String(sound)+","+ String(air); String cmd ="AT+SEND=0,"+String(values.length())+","+values; //AT+SEND=
,, Serial.println(cmd); //sent to lora delay(15000);}//this function calculate sound level in dBfloat calculate_sound_in_db(){ unsigned long startMillis=millis(); // Start of sample window float peakToPeak =0; // peak-to-peak level unsigned int signalMax =0; //minimum value unsigned int signalMin =1024; //maximum value // collect data for 50 mS while (millis() - startMillis  signalMax) { signalMax =sample; // save just the max levels } else if (sample =0)// if a valid data returned. { if (current_quality==0) Serial.println("High pollution! Force signal active"); else if (current_quality==1) Serial.println("High pollution!"); else if (current_quality==2) Serial.println("Low pollution!"); else if (current_quality ==3) Serial.println("Fresh air"); } */ return current_quality;}void calculate_temp_humid(){ // 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(); // Check if any reads failed and exit early (to try again). if (isnan(h) || isnan(t)) { //Serial.println("Failed to read from DHT sensor!"); return; } temp =t; humid =h; /* Serial.print("Humidity:"); Serial.print(h); Serial.print(" %\t"); Serial.print("Temperature:"); Serial.print(t); Serial.print(" *C "); */}//interrupt service routine for air quality sensorISR(TIMER1_OVF_vect){ if(airqualitysensor.counter==61)//set 2 seconds as a detected duty { airqualitysensor.last_vol=airqualitysensor.first_vol; airqualitysensor.first_vol=analogRead(A0); airqualitysensor.counter=0; airqualitysensor.timer_index=1; PORTB=PORTB^0x20; } else { airqualitysensor.counter++; }}

/* Including the SDK and WiFi library */#include #include #include SoftwareSerial LORA(D7, D8);/* Configurations */String deviceID ="your device id";String apiKey ="your api key";String token ="your device token";/* WiFi credentials */String ssid ="your wifi ssid";String password ="your wifi password";/* Create variable to hold project and device */Grandeur::Project project;Grandeur::Project::Device device;/* Variable to keep track of connection state and time */int connected =0;uint32_t lastUpdate =0;String inputString =""; // a string to hold incoming databoolean stringComplete =false; // whether the string is complete//:and % was set from the transmitter node for the eage of data separationchar start_val =':';char end_val ='%';int start_pos =0;int end_pos =0;float temp =0;float humid =0;float air =0;float noise =0;/* Function to check device's connection status */void onConnection(bool status) { switch(status) { case CONNECTED:Serial.println("Device is connected to the cloud."); /* Record connection state and time */ connected =1; lastUpdate =millis(); return; case DISCONNECTED:Serial.println("Device is disconnected from the cloud."); connected =0; return; }}/* Function to connect to WiFi */void connectWiFi() { /* Set mode to station */ WiFi.mode(WIFI_STA); /* Connect using the ssid and password */ WiFi.begin(ssid, password); /* Block till the WiFi is connected */ while (WiFi.status() !=WL_CONNECTED) { delay(500); Serial.print("."); } /* Print message */ Serial.println(""); Serial.println("WiFi connected"); /* And IP address */ Serial.println(WiFi.localIP());}/* Function to confirm that data has been updated */void dataCallback(const char* code, Var res) { /* If the update was recorded successfully */ if(code =="DEVICE-DATA-UPDATED") { //Serial.println("Updated DATA"); /* Get data */ double temp_data =(double) res["update"]["temp"]; double humid_data =(double) res["update"]["humid"]; double noise_data =(double) res["update"]["noise"]; double air_data =(double) res["update"]["air"]; /* Print */ Serial.printf("Temperature:%f Humidity:%f Noise Level:%f Air Quality:%f\n", temp_data, humid_data, noise_data, air_data); return; } /* If the summary could not be updated. */ Serial.println("Failed to Update DATA"); return;}/* Function to send updated current and power readings */void sendUpdate() { Var data; //JSON data format set in Grandeur:{"temp":0, "humid":0, "air":0, "noise":0} data["temp"] =temp; data["humid"] =humid; data["noise"] =noise; data["air"] =air; /* Record update */ //device.data().set("", data, dataCallback); //send JSON device.data().set("temp", temp, dataCallback); device.data().set("humid", humid, dataCallback); device.data().set("noise", noise, dataCallback); device.data().set("air", air, dataCallback); //delay(2000);}void setup() { /* Begin the serial */ Serial.begin(9600); LORA.begin(115200); inputString.reserve(200); /* Connect to WiFi */ connectWiFi(); /* Initializes the global object "grandeur" with your configurations. */ project =grandeur.init(apiKey, token); /* Get reference to device */ device =project.device(deviceID); /* Sets connection state update handler */ project.onConnection(onConnection);}void loop() { serialEvent(); project.loop(WiFi.status() ==WL_CONNECTED); /* Send update to server */ if (stringComplete) { process_received_data(); if (connected) sendUpdate(); }}void serialEvent() { while (LORA.available()) { // get the new byte:char inChar =(char)LORA.read(); // if the incoming character is a newline, set a flag // so the main loop can do something about it:if (inChar =='\n') { stringComplete =true; } else // add it to the inputString:inputString +=inChar; }}void process_received_data(){ start_pos =inputString.indexOf(start_val); end_pos =inputString.indexOf(end_val); String data_string =inputString.substring(start_pos+1, end_pos-1); //Serial.println(data_string); //identifying commas inn the string int firstCommaIndex =data_string.indexOf(','); int secondCommaIndex =data_string.indexOf(',', firstCommaIndex+1); int thirdCommaIndex =data_string.indexOf(',', secondCommaIndex+1); //seperating comma seperated value from the data string String temperature =data_string.substring(0, firstCommaIndex); String humidity =data_string.substring(firstCommaIndex+1, secondCommaIndex); String noise_level =data_string.substring(secondCommaIndex+1, thirdCommaIndex); String air_auality =data_string.substring(thirdCommaIndex+1); //Serial.println(temperature); //Serial.println(humidity); //Serial.println(noise); //Serial.println(air_auality); temp =temperature.toFloat(); humid =humidity.toFloat(); noise =noise_level.toFloat(); air =air_auality.toFloat(); Serial.println(temp); Serial.println(humid); Serial.println(noise); Serial.println(air); inputString =""; stringComplete =false; }