LoRa-gebaseerde Smart City-luchtkwaliteitsbewaking

Over dit project

Slimme stad en luchtkwaliteit

De Wereldbank definieert een slimme stad als een stad die technologie-intensief is. Dit betekent zeer efficiënte openbare diensten.

Een van de fundamentele kenmerken van slimme steden is het bieden van een duurzame omgeving. Voor een duurzaam milieu is het noodzakelijk om de omgevingsomstandigheden te bewaken om de bronnen van vervuiling te identificeren en te verminderen. In dit kader worden duizenden luchtkwaliteitssensoren geplaatst om realtime informatie te verstrekken aan zowel de overheid als de burger. Deze gegevens kunnen worden omgezet in nuttige informatie, waardoor we betere beslissingen kunnen nemen, of we nu te maken hebben met transportplanning of weten welke route het beste is om naar het werk te lopen.

Luchtkwaliteitsdetectie past goed bij de visie van de slimme stad:informatie verstrekken over een stad die voorheen niet beschikbaar was, waardoor mensen beslissingen kunnen nemen die de kwaliteit van hun leven kunnen verbeteren.

Probleem &Oplossing

De toegenomen luchtvervuiling in grote steden is een groot probleem geworden vanwege het risico dat dit voor de menselijke gezondheid met zich meebrengt. In deze context is technologie een zeer nuttig hulpmiddel geworden bij het monitoren van contaminatie en de mogelijke beperking van de impact ervan. Er zijn met name verschillende voorstellen die gebruikmaken van het internet der dingen (IoT) -paradigma dat onderling verbonden sensoren gebruikt om verschillende verontreinigende stoffen te meten. Een netwerk van goedkope sensorknooppunten voor het bewaken van de luchtkwaliteit kan worden ingezet om de luchtkwaliteit en meteorologische parameters te bewaken. Door de opsporing van verontreinigingsbronnen kan de stad dus corrigerende maatregelen nemen en de gezondheid van het milieu verbeteren. Door rampendetectiesystemen zoals overstromingen en regenmonitoringoplossingen in uw omgeving te installeren. de burgers kunnen vooraf gewaarschuwd worden in geval van een catastrofale gebeurtenis. Er kan een holistisch beeld worden afgeleid, waardoor de autoriteiten datagestuurde beslissingen kunnen nemen over infrastructuur en beleidsplanning.

Het projectplan

In dit project gaan we een aantal belangrijke omgevingsparameters monitoren, zoals geluid, temperatuur, vochtigheid en luchtkwaliteit. Het verzendt realtime gegevens via een draadloos communicatieprotocol naar een cloudplatform. De apparatuur werkt volledig op zonne-energie met een back-up batterij. De gegevens van het apparaat zijn toegankelijk op een dashboard dat de gegevens in de gewenste formaten visualiseert en analyseert.

Voor slimme monitoring van de luchtkwaliteit in steden moet je sensornodes op verschillende locaties plaatsen. Qua stroomverbruik en kosten is het geen goed idee om elke sensornode afzonderlijk aan te sluiten op de cloud. Het is eerder een goed idee om gegevens van alle sensorknooppunten van een klein gebied te verzamelen en alle gegevens vanuit één gateway naar de cloud te publiceren. LoRa kan ons dit voordeel geven en daarom heb ik LoRa gekozen voor mijn project.

Voor de cloudservice gebruik ik Grandeur voor mijn project. Grandeur is een relatief nieuw makervriendelijk IoT-platform waar we onze gegevens kunnen opslaan en visualiseren door grafiekwidgets te maken met behulp van de drag-and-drop-methode. Ze bieden ook Arduino, JavaScript en Python SDK met voorbeeldcode. Je kunt dus eenvoudig verbinding maken met hun service met behulp van Arduino, NodeMCU en Raspberry Pi.

De beste manier om een ​​sensornode van stroom te voorzien, is door een zonnepaneel te gebruiken. Omdat sensornodes op een andere externe locatie worden geplaatst en het regelmatig vervangen van de batterij of het leveren van stroom vanuit een nutsbron niet altijd mogelijk is. Ik voorzie mijn sensornotitie van stroom met behulp van het zonnepaneel en de Li-ionbatterij.

Het sensorknooppunt maken

Ik wil de luchtkwaliteit, het geluidsniveau, de temperatuur en de luchtvochtigheid monitoren. Dus gebruikte ik de Grove-luchtkwaliteitssensor, Grove-ruissensor en Grove DHT11-temperatuur- en vochtigheidssensor. Een goede zaak van Grove-sensoren is dat je alle grove-sensoren op Arduino kunt aansluiten met behulp van Grove-basisschild zonder te hoeven solderen.

Voor het voeden van het circuit heb ik Grove 1W zonnepaneel en Li-ion batterij gebruikt. Voor het opladen van de batterij met behulp van het zonnepaneel heb ik Seeed LiPo Rider Pro zonnelader gebruikt die een ingebouwde 5V boost-converter heeft. Dus we kunnen Arduino gemakkelijk draaien met behulp van de output van de LiPo Rider.

De meeste van de hier gebruikte componenten zijn beschikbaar op Seeedstudio.com. De volgende afbeelding toont een plug-and-play-testverbinding voor alle componenten voor het sensorknooppunt.

Voor het verzenden van de sensorgegevens naar de IoT-gateway heb ik de Reyax LoRa-transceiver gebruikt. De volgende afbeelding toont de Reyax RYLR998 Lora-module met het pinnendiagram.

Reyax RYLR998 LoRa Engine voorbereiden om verbinding te maken met Arduino Base Shield

De RYLR998 heeft een output van 5 mannelijke pinnen en is niet compatibel met het Grove-basisschild. Om het aan te sluiten op Grove Shield heb ik een Grove-kabel gesoldeerd in een perfboard met een 5-pins vrouwelijke header. De circuitaansluiting is als volgt:

De RYLR998 LoRa-module kan veilig werken tot 3,6 V. Arduino TX-pin produceert 5V-uitvoer die niet veilig is voor de LoRa. Dus ik gebruikte een spanningsdeler om 3,4 V van de Arduino TX-pin te krijgen. Aan de andere kant werkt de Arduino RX-pin perfect op 3.3V-logica. Dus ik verbond de TX-pin van de LoRa rechtstreeks met de RX-pin van de Arduino. Voor normaal gebruik moet de RST-pin van de LoRa in de hoge staat staan.

Nu kan de bovenstaande LoRa-module eenvoudig worden aangesloten op het basisscherm met behulp van het volgende convertercircuit.

Maar voordat u de module op het basisschild aansluit, moet u ervoor zorgen dat de aan-uitknop van het basisschild zich in de stand van 3,3 V bevindt, zoals in de onderstaande afbeelding.

Nadat we de LoRa-module op het basisschild hebben aangesloten, kunnen we testen door het AT-commando vanuit Arduino naar de module te sturen.

Communicatie met behulp van RYLR896 LoRa Transceiver

Om communicatie tussen twee LoRa-modules tot stand te brengen, moeten ze elkaar op een adres kunnen vinden. Het adresseringsschema van het LoRa-ecosysteem hangt een beetje af van de modules en implementatie. Simpel gezegd stelt de module ons in staat om een ​​netwerk-ID en een adres in te stellen. Modules op hetzelfde netwerk (zelfde netwerk id) kunnen met elkaar communiceren. Elke module wordt verondersteld een unieke id (adres) te hebben binnen een netwerk. Als een module adres 0 heeft, kan die module gegevens ontvangen van alle apparaten op het netwerk.

Elke module wordt geleverd met een standaardfrequentie, netwerk-ID en adres, maar het kan zijn dat u de standaardwaarde moet wijzigen. De standaard netwerk-id voor de bovenstaande module is 18 en het adres is 0.

Voor ons demoproject hoeven we op dit moment niets te veranderen. Maar als u een parameter wilt wijzigen, raadpleeg dan de datasheet voor de details van de AT-commando's.

Om een ​​bericht te verzenden (HELLO RECEIVER!), hoeven we alleen maar het commando "AT+SEND=0, 15, HELLO RECEIVER!" te sturen. op de seriële aansluiting van de module. De eerste parameterwaarde ‘0’ is het adres van de ontvangermodule. De volgende waarde '15' is het aantal tekens/bytes dat moet worden verzonden. De derde parameterwaarde is het bericht dat moet worden verzonden:'HELLO RECEIVER!' (15 tekens).

Code voor sensorknooppunt

De volgende code is ontwikkeld voor het sensorknooppunt om alle sensorgegevens te verzamelen en naar de IoT-gateway te verzenden.

#include "AirQuality.h" //grove luchtkwaliteitsbibliotheek
#include "Arduino.h"
#include "DHT.h"

# definieer DHTPIN 4 // op welke digitale pin DHT-sensor is aangesloten
#define DHTTYPE DHT11 // model van de sensor DHT11 

DHT dht(DHTPIN, DHTTYPE);

AirQuality-luchtkwaliteitssensor;
int current_quality =-1;

const int sampleWindow =50; // Breedte monstervenster in mS (50 mS =20 Hz)
unsigned int sample;
float noise;
float temp, vochtig;
int airQuality;

 //---------------------------------------------- ----------------------------------------------
 // SETUP
 //----------------------------------------- -------------------------------------------------- -
Void setup() 
{
 
 Serial.begin(115200); //Serial for lora
 airqualitysensor.init(14);
 dht.begin();

}
 
//----- -------------------------------------------------- -------------------------------------
// HOOFDLUS
/ /------------------------------------------------- -------------------------------------------
 
void loop() 
{
 noise =berekenen_geluid_in_db();
 airQuality =berekenen_lucht_kwaliteit();
 berekenen_temp_humid();

 String temperatuur =String (temp);
 Stringvochtigheid =String(vochtig);
 Stringgeluid =String(ruis);
 String lucht =String(luchtkwaliteit);
 
 Stringwaarden =String(temperatuur)+","+ String(vochtigheid)+","+ String(geluid)+","+ String(lucht);
 String cmd ="AT+SEND=0,"+String (waarden.lengte())+","+waarden; //AT+SEND=,,
 Serial.println(cmd); //verzonden naar lora
 
 delay(15000);
}

//deze functie berekent het geluidsniveau in dB
float calculator_sound_in_db(){
 unsigned long startMillis=millis(); // Begin van voorbeeldvenster
 float peakToPeak =0; // piek-tot-piek niveau
 
 unsigned int signalMax =0; //minimumwaarde
 unsigned int signalMin =1024; //maximale waarde
 
 // verzamel gegevens voor 50 mS
 while (millis() - startMillis  {
 sample =analogRead(A1); // lees van microfoon
 if (sample <1024) // gooi valse lezingen weg
 {
 if (sample> signalMax)
 {
 signalMax =sample; // sla alleen de maximale niveaus op
 }
 else if (sample  {
 signalMin =sample; // sla alleen de minimale niveaus op
 }
 }
 }
 peakToPeak =signalMax - signalMin; // max - min =piek-piek amplitude
 //Serial.println(peakToPeak); //schrijf gekalibreerde deciBels
 float db =map (peakToPeak,0,1000,48,120); //kalibreren voor deciBels
 //Serial.print(db); //schrijf gekalibreerde deciBels
 //Serial.println ("dB"); //write units
 return db;
}

int calculator_air_quality(){
 current_quality=airqualitysensor.slope();
 /*
 if (current_quality>=0)// als geldige gegevens zijn geretourneerd.
 {
 if (current_quality==0)
 Serial.println("Hoge vervuiling! Krachtsignaal actief"); 
 else if (current_quality==1)
 Serial.println("Hoge vervuiling!");
 else if (current_quality==2)
 Serial.println("Lage vervuiling !");
 else if (current_quality ==3)
 Serial.println("Fresh air");
 }
 */
 return current_quality;
}

void calculator_temp_humid(){
 // Het lezen van temperatuur of vochtigheid duurt ongeveer 250 milliseconden!
 // Sensormetingen kunnen ook tot 2 seconden 'oud' zijn ( het is een zeer trage sensor)
 float h =dht.readHumidity();
 // Lees temperatuur als Celsius (de standaardinstelling)
 float t =dht.readTemperature();
 
 // Controleer of het lezen is mislukt en sluit vroeg af (om het opnieuw te proberen).
 if (isnan(h) || isnan(t)) {
 //Serial.println("Kan niet lezen van DHT-sensor!");
 return;
 }

 temp =t;
 vochtig =h; 
 /*
 Serial.print("Vochtigheid:");
 Serial.print(h);
 Serial.print(" %\t");
 Serial.print("Temperatuur:");
 Serial.print(t);
 Serial.print(" *C ");
 */
}
 
//serviceroutine voor luchtkwaliteitssensor onderbreken
ISR(TIMER1_OVF_vect)
{
 if(airqualitysensor.counter==61)//stel 2 seconden in als gedetecteerde taak
 {

 airqualitysensor.last_vol=airqualitysensor.first_vol;
 airqualitysensor.first_vol=analogRead(A0);
 airqualitysensor.counter=0;
 airqualitysensor.timer_index=1;
 PORTB=PORTB^0x20;
 }
 else
 {
 airqualitysensor.counter++;
 }
} 

De code verzendt de sensorgegevens elke 15 seconden. Verander de timing volgens uw vereiste.

Uploaden en testen

Sluit nu alle sensoren aan, upload de bovenstaande code en test in seriële monitor. Het bronbestand is bijgevoegd in de codesectie.

Componenten in de doos plaatsen

Nu zullen we alle sensoren en batterij in de doos plaatsen. Druk eerst de twee STL-bestanden af ​​​​die zijn bijgevoegd in het bijlagegedeelte. De afgedrukte afbeeldingen zien eruit als de volgende afbeelding.

De complete doos ziet er als volgt uit. Afhankelijk van de kwaliteit van uw printer heeft u mogelijk wat verzendbasis nodig.

Na het klaarmaken van de box eerst het zonnepaneel aan de bovenzijde van de box bevestigd. De verbindingsdraden in de doos door het bovenste gat.

Plaats vervolgens de Arduino met bevestigd basisschild eerst met wat hot gule of dubbelzijdig plakband. Plaats andere sensoren één voor één en bevestig ze op een vaste plaats met behulp van wat hete lijm.

Plaats batterij en lipo rider pro en voeg tenslotte de LoRa-module toe.

Sensor Node is klaar voor implementatie.

Grootsheid configureren

Grandeur biedt een backend-service voor IoT-apparaten waarbij een virtueel apparaat-gebruikerpaar wordt gemaakt. Het apparaatmodel wordt bij het maken beschreven als een JSON-object dat verschillende variabelen bevat (temperatuur, vochtigheid, ruisniveau, luchtkwaliteit in ons geval) waarnaar kan worden gelezen en geschreven. Grandeur Canvas is een web-app die kan worden gebruikt om de apparaatstatus van gekoppelde apparaten te visualiseren met behulp van grafische widgets.

Om de Grandeur te gebruiken, moeten we een account aanmaken en een aantal belangrijke configuraties op het platform doen. Bekijk hun website https://grandeur.dev/ om in het spel te komen.

1. Nadat u bent ingelogd op het root-account, maakt u een nieuw project :

2. Maak een nieuw gebruikersaccount van de Account toevoegen optie op het tabblad Start of op het tabblad Accounts. We zullen later inloggen op onze app met het e-mailadres en wachtwoord dat we nu maken. Dit is een andere coole functie van Grandeur:meerdere gebruikers kunnen uw app gebruiken door in te loggen met hun e-mailadressen en wachtwoorden . Elke gebruiker kan zijn eigen apparaten koppelen en een apparaat dat door de ene gebruiker is gekoppeld, is niet meer beschikbaar voor anderen. Authenticatie is de kern van Grandeur. Het maken van gebruikers wordt hieronder geïllustreerd:

3. Nu maak een nieuw apparaat via het tabblad apparaten. Deze bewerking genereert een nieuwe unieke apparaat-ID die we zullen gebruiken bij het schrijven van code voor onze hardware en deze apparaat-ID is vereist om verbinding te maken met de Grandure via API. Als u een apparaat maakt, wordt ook een accessToken gegenereerd. Vergeet niet om het te kopiëren en het zal worden gebruikt in hardwarecode en zal niet toegankelijk zijn na het sluiten van het dialoogvenster . U moet een apparaatmodel toevoegen voordat u een apparaat toevoegt met behulp van de volgende procedure. Een apparaatmodel wordt gebruikt om te beschrijven welke variabelen door/naar het apparaat kunnen worden gecommuniceerd.

Klik vanuit de modellen op Toevoegen en geef een modelnaam op. Zet in het Schema alle variabelen (4 in ons geval) in JSON-formaat. Houd de waarde 0 op dit moment. Deze variabele wordt automatisch bijgewerkt wanneer we gegevens vanaf ons apparaatknooppunt verzenden.

 {"temp":0, "vochtig":0, "lucht":0, "ruis":0} 

Klik na het plaatsen van het schema op Toevoegen.

Nadat u het apparaatmodel hebt toegevoegd, klikt u op de optie Toevoegen van apparaten en selecteert u het model dat u zojuist hebt gemaakt om het model aan het apparaat te koppelen.

Geef een apparaat-ID op en klik om te registreren.

Kopieer het toegangstoken en het wordt gebruikt in hardwarecode en is niet toegankelijk na het sluiten van het dialoogvenster.

Het apparaat is met succes aangemaakt en noteer ook de APPARAAT-ID. Het zal ook nodig zijn voor codering.

Een gebruiker kan geen interactie hebben met een apparaat tenzij het eraan is gekoppeld. Er zijn twee manieren waarop u uw apparaat kunt koppelen :1) met behulp van het Cloud Dashboard, of 2) via de web-app met behulp van pairDevice() functie van de apparaat-API. Deze tweede manier heeft een zeer sterke betekenis als je ernaar kijkt vanuit het oogpunt van productie. Zo kunt u nu uw hardwareproducten verzenden en kunnen uw gebruikers zich aanmelden bij uw app en het eigendom van een hardware aangeven door deze te koppelen. Hier leest u hoe u uw apparaat kunt koppelen met een gebruiker via het Cloud Dashboard:

Om het apparaat te koppelen, klikt u op Koppelen en kiest u een account. U bent klaar om naar de volgende stap te gaan.

4. We gaan nu een canvas maken.

Klik in het linkermenu op dashboard op canvas, of ga naar https://canvas.grandeur.tech. Als dit de eerste keer is dat je Canvas bezoekt, krijg je een Autoriseren knop zal verschijnen. Autorisatie geeft Canvas toegang tot de gebruikers en apparaten van je project. Als u op de knop "Autoriseren" klikt, wordt u teruggeleid naar het Grandeur-dashboard waar u wordt gevraagd het project te kiezen waaraan u Canvas wilt binden.

Kies een grafiekwidgets en klik erop. Het menu Configure wordt weergegeven en klik vervolgens op configureren om een ​​titel van de grafiek te geven en de variabele in te stellen waarvan u de waarde in deze grafiek wilt weergeven.

Klik om op te slaan.

Volg dezelfde procedure en voeg 4 grafiekwidgets toe voor de 4 variabelen.

Nadat je Canvas aan je project hebt gekoppeld, zie je mogelijk een inlogscherm. U dient hier in te loggen als gebruiker van uw project dat u eerder heeft aangemaakt, waarvoor u een gebruikersaccount in uw project moet aanmaken. U kunt dat doen door naar de accountpagina van het dashboard te gaan. Vervolgens kun je inloggen op Canvas met de inloggegevens van deze nieuwe gebruiker.

IoT LoRa Gateway voorbereiden

Op een eenvoudige manier is een IoT Gateway een netwerkrouter of gateway voor thuis of op kantoor die sensoren, IoT-modules en slimme apparaten verbindt met de cloud. Zo'n gateway vergemakkelijkt de communicatie tussen uw apparaten, handhaaft de beveiliging en biedt een beheerdersinterface waar u basisfuncties kunt uitvoeren.

Een echte IoT-gateway bevat communicatietechnologieën die eindapparaten (sensoren, actuatoren of complexere apparaten) en back-endplatforms (gegevens-, apparaat- en abonneebeheer) met de gateway verbinden. Het heeft een computerplatform waarmee vooraf geïnstalleerde of door de gebruiker gedefinieerde applicaties gegevens kunnen beheren (voor routering en computing aan de rand), apparaten, beveiliging, communicatie en andere aspecten van de gateway.

Raspberry Pi kan een goede optie zijn voor een gateway met veel flexibiliteit, maar om het simpel te houden gebruik ik Node MCU als gateway voor dit project. Node MCU ontvangt de gegevens van de LoRa-module met behulp van UART. Vervolgens zullen we met behulp van Arduino SDK de gegevens uploaden naar het Grandeur-cloudplatform.

Firmware voor de gateway

De volgende code is ontwikkeld voor de gateway met behulp van Arduino SDK geleverd door Grandeur cloud. Gegevens worden in stringvorm ontvangen van de LoRa met behulp van de UART-poort. Vervolgens worden de ontvangen gegevens verwerkt om de individuele variabele te scheiden van de door komma's gescheiden tekenreekswaarde. De waarden worden vervolgens via wifi naar Grandeur gestuurd. De volgende functie werd gebruikt om de variabelen te scheiden.

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);
 //komma's identificeren in de string
 int firstCommaIndex =data_string.indexOf(',');
 int secondCommaIndex =data_string.indexOf(',', firstCommaIndex+1);
 int thirdCommaIndex =data_string.indexOf(',', secondCommaIndex+1);
 //komma gescheiden waarde uit de datastring 
 String temperatuur =data_string.substring(0, firstCommaIndex);
 String vochtigheid =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(temperatuur);
 //Serial.println( vochtigheid);
 //Serial.println(ruis);
 //Serial.prin tln(air_auality);

 temp =temperatuur.toFloat();
 vochtig =vochtigheid.toFloat();
 noise =noise_level.toFloat();
 lucht =air_auality.toFloat(); 

 Serial.println(temp);
 Serial.println(humid);
 Serial.println(ruis);
 Serial.println(lucht);
 
 inputString ="";
 stringComplete =false;
 } 

De volledige code is bijgevoegd in de codesectie.

Gegevensvisualisatie

#include "AirQuality.h" //grove air quality library#include "Arduino.h"#include "DHT. h"#define DHTPIN 4 // welke digitale pin DHT-sensor is aangesloten op#define DHTTYPE DHT11 // model van de sensor DHT11 DHT dht(DHTPIN, DHTTYPE);AirQuality-luchtkwaliteitssensor;int current_quality =-1;const int sampleWindow =50; // Breedte monstervenster in mS (50 mS =20 Hz) unsigned int sample;float noise;float temp, vochtig;int airQuality; //------------------------------------------------ -------------------------------------------- // OPSTELLING //- -------------------------------------------------- ----------------------------------------- ongeldige setup() { Serial.begin( 115200); //Serial voor lora airqualitysensor.init (14); dht.begin();} //----------------------------------------- -------------------------------------------------- -// HOOFDLUS//------------------------------------------- ------------------------------------------------- leegte loop() {ruis =berekenen_geluid_in_db(); airQuality =bereken_luchtkwaliteit(); bereken_temp_humid(); String temperatuur =String (temp); String vochtigheid =String (vochtig); 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!"); opbrengst; } 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(); opbrengst; case DISCONNECTED:Serial.println("Device is disconnected from the cloud."); connected =0; opbrengst; }}/* 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); opbrengst; } /* 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; }