Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Manufacturing Technology >> Productieproces

Slimme stadsmonitoring van luchtkwaliteit met LoRa

Onderdelen & Materialen

OnderdeelAantal
Arduino UNO1
Seeed Base Shield V21
NodeMCU ESP8266 Breakout Board1
Seeed Loudness Sensor1
Seeed Grove – Luchtkwaliteitssensor v1.31
Seeed Grove – Temperatuur- & Vochtigheidssensor (DHT11)1
Reyax LoRa-module1
Seeed Kleine Zonnepaneel 80x100mm 1W1
Seeed LiPo Rider Pro1
Herlaadbare batterij, 3,7 V1

Benodigde Tools & Uitrusting

  • 3D-printer (standaard)

Software & Online Services

  • Arduino IDE
  • Grandeur (IoT backend platform)
  • Grandeur Canvas (dashboard builder)

Projectoverzicht

Slimme stad & luchtkwaliteit

Volgens de Wereldbank benutst een slimme stad technologie om uiterst efficiënte publieke diensten en een duurzame stedelijke omgeving te bieden. Centraal in deze visie staat realtime milieumonitoring, die vervuilingsbronnen identificeert en datagedreven beleidsbeslissingen informeert – of het nu gaat om het optimaliseren van verkeersstromen of het adviseren van bewoners over de veiligste wandelroutes.

Probleem & Oplossing

Stedelijke luchtverontreiniging vormt significante gezondheidsrisico's, en tijdige data is essentieel voor mitigatie. Internet-of-Things (IoT)-netwerken van laagprijs sensorknooppunten kunnen continu luchtkwaliteit en meteorologische parameters vastleggen. Gecombineerd met een betrouwbare, laag-energie communicatielaag, stellen dergelijke netwerken stedelijke bestuurders in staat om vervuilingshotspots te detecteren en proactief te reageren.

Projectplan

Onze oplossing meet cruciale milieuparameters – geluid, temperatuur, vochtigheid en luchtkwaliteit – en stuurt de data draadloos naar een cloudplatform. Het complete knooppunt wordt gevoed door een 1 W zonnepaneel met Li-ion-batterij-backup, wat autonoom werkt garandeert. Een clouddashboard visualiseert de data in realtime, wat directe inzichten en langetermijntrendanalyse mogelijk maakt.

In plaats van elke sensor direct met de cloud te verbinden – een benadering die stroomverbruik en kosten in de hoogte drijft – aggregeren we data van meerdere nabijgelegen knooppunten en transmitteren deze via een enkele LoRa-gateway. LoRa's lange bereik en laag-energie kenmerken maken het ideaal voor dichte stedelijke implementaties.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Systeemarchitectuur: sensorknooppunten → LoRa-gateway → Cloud

We kozen Grandeur als backendplatform vanwege de gebruiksvriendelijke SDK's voor Arduino, NodeMCU en Raspberry Pi, alsook de drag-and-drop dashboard builder.

Zonne-energie biedt een duurzame, onderhoudsvrije energiebron voor remote knooppunten, en de Li-ion-batterij garandeert werking tijdens periodes met lage inzoning.

De sensorknooppunt bouwen

Het knooppunt integreert een Grove luchtkwaliteitssensor, een Grove geluidssensor en een DHT11 temperatuur/vochtigheidssensor – allemaal direct in de Seeed Base Shield te pluggen zonder solderen, wat assemblage en onderhoud vereenvoudigt.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Sensorknooppunt op de Base Shield

Stroomvoorziening komt van een 1 W zonnepaneel en een Seeed LiPo Rider Pro lader, die een 5 V boost converter bevat om de Arduino binnen zijn werkspanning te houden.

De Reyax RYLR998 LoRa-transceiver zorgt voor draadloze transmissie. Omdat de module 3,6 V logica accepteert, beschermt een simpele spanningsdeler de 5 V TX-lijn van de Arduino.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
LoRa-module aansluitschema met spanningsdeler

Hieronder volgt het bedradingsschema dat de LoRa-module via een custom adapter met de Base Shield verbindt.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Bedrading LoRa-adapter naar Base Shield

Bij het aansluiten van de LoRa-module, zorg dat de Base Shield's voedingschakelaar op 3,3 V staat.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Base Shield op 3,3 V gezet

Na assemblage, verifieer communicatie door een AT-commando vanuit de Arduino naar de LoRa-module te sturen.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
AT-commando test in Serial Monitor

Upload & Test

Upload de meegeleverde Arduino-sketch, open dan de seriële monitor om te bevestigen dat sensorwaarden correct worden getransmitteerd.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Succesvolle data-transmissie bevestigd

Behuizing assembleren

Print de STL-bestanden uit de bijlage. Na controle van de pasvorm, monteer de componenten binnenin de behuizing met dubbelzijdig tape of lijmpistool. Monteer het zonnepaneel bovenaan en voer stroomkabels door de voorziene opening.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Componenten in de 3D-geprinte behuizing
Slimme stadsmonitoring van luchtkwaliteit met LoRa
Zonnepaneel gemonteerd op de behuizing

Zodra alle componenten vastzitten, is het knooppunt klaar voor veldplaatsing.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Volledig geassembleerd sensorknooppunt

Grandeur configureren

Grandeur is een IoT-backend die apparaten koppelt aan gebruikers en een realtime dashboard biedt. Volg deze stappen om je project in te richten:

  1. Maak een nieuw project aan op grandeur.dev.
  2. Registreer een gebruikersaccount; dit account wordt later gebruikt om apparaten te koppelen.
  3. Definieer een apparaatmodel met het JSON-schema:
    {"temp":0, "humid":0, "air":0, "noise":0}
  4. Instantieer een apparaat, noteer de unieke ID en access token, en bewaar ze voor de Arduino-firmware.
  5. Koppel het apparaat met de gebruiker via het dashboard of de API (bijv. pairDevice()).
  6. Bouw een Canvas-dashboard: voeg vier grafiek-widgets toe – één elk voor temperatuur, vochtigheid, geluidsniveau en luchtkwaliteit – en bind ze aan de overeenkomstige variabelen.

Zodra Canvas geautoriseerd is, kunnen gebruikers inloggen om live data te bekijken. De API-key en device-token zijn vereist in de gateway-firmware.

IoT LoRa-gateway voorbereiden

De NodeMCU fungeert als LoRa-gateway, ontvangt UART-data van het sensorknooppunt en stuurt deze door naar Grandeur via Wi-Fi. Hoewel een Raspberry Pi deze rol kan vervullen, biedt de NodeMCU een compacte, goedkope oplossing die voldoet aan de bandbreedte- en latentie-eisen van het project.

Slimme stadsmonitoring van luchtkwaliteit met LoRa
NodeMCU als LoRa-gateway

Gateway Firmware

De firmware parsed de komma-gescheiden payload die ontvangen wordt van de LoRa-module, converteert elke waarde naar float, en pusht deze naar Grandeur met de meegeleverde SDK. Hieronder de kernlogica voor data-extractie en transmissie.

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);
  int firstCommaIndex = data_string.indexOf(',');
  int secondCommaIndex = data_string.indexOf(',', firstCommaIndex+1);
  int thirdCommaIndex = data_string.indexOf(',', secondCommaIndex+1);
  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);
  temp = temperature.toFloat();
  humid = humidity.toFloat();
  noise = noise_level.toFloat();
  air = air_auality.toFloat();
  inputString = "";
  stringComplete = false;
}

Datavisualisatie

Slimme stadsmonitoring van luchtkwaliteit met LoRa
Dashboard: temperatuur en vochtigheid
Slimme stadsmonitoring van luchtkwaliteit met LoRa
Dashboard: geluidsniveau en luchtkwaliteit

Firmware Code

Sensorknooppunt (Arduino)

#include "AirQuality.h" // Grove luchtkwaliteitsbibliotheek
#include "Arduino.h"
#include "DHT.h"
#define DHTPIN 4 // Digitale pin voor DHT11
#define DHTTYPE DHT11 // Sensormodel
DHT dht(DHTPIN, DHTTYPE);
AirQuality airqualitysensor;
int current_quality = -1;
const int sampleWindow = 50; // 20 Hz sampling
unsigned int sample;
float noise;
float temp, humid;
int airQuality;

void setup() {
  Serial.begin(115200); // UART voor LoRa
  airqualitysensor.init(14);
  dht.begin();
}

void loop() {
  noise = calculate_sound_in_db();
  airQuality = calculate_air_quality();
  calculate_temp_humid();
  String values = String(temp) + "," + String(humid) + "," + String(noise) + "," + String(airQuality);
  String cmd = "AT+SEND=0," + String(values.length()) + "," + values;
  Serial.println(cmd);
  delay(15000);
}

float calculate_sound_in_db() {
  unsigned long startMillis = millis();
  float peakToPeak = 0;
  unsigned int signalMax = 0;
  unsigned int signalMin = 1024;
  while (millis() - startMillis < sampleWindow) {
    sample = analogRead(A1);
    if (sample < 1024) {
      if (sample > signalMax) signalMax = sample;
      else if (sample < signalMin) signalMin = sample;
    }
  }
  peakToPeak = signalMax - signalMin;
  float db = map(peakToPeak, 0, 1000, 48, 120);
  return db;
}

int calculate_air_quality() {
  current_quality = airqualitysensor.slope();
  return current_quality;
}

void calculate_temp_humid() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  if (isnan(h) || isnan(t)) return;
  temp = t;
  humid = h;
}

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

Gateway (NodeMCU/ESP8266)

/* SDK en WiFi bibliotheek includen */
#include 
#include 
#include 
SoftwareSerial LORA(D7, D8);

/* Configuraties */
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";

/* Variabelen voor project en device */
Grandeur::Project project;
Grandeur::Project::Device device;

/* Connectiestatus en tijd bijhouden */
int connected = 0;
uint32_t lastUpdate = 0;
String inputString = ""; // string voor binnenkomende data
boolean stringComplete = false; // of de string compleet is
// : en % waren ingesteld op de zender voor data-scheiding
char 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;

/* Functie om device connectiestatus te checken */
void onConnection(bool status) {
  switch (status) {
    case CONNECTED:
      Serial.println("Device is connected to the cloud.");
      connected = 1;
      lastUpdate = millis();
      return;
    case DISCONNECTED:
      Serial.println("Device is disconnected from the cloud.");
      connected = 0;
      return;
  }
}

/* Functie om met WiFi te verbinden */
void connectWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println(WiFi.localIP());
}

/* Callback voor data-update bevestiging */
void dataCallback(const char* code, Var res) {
  if (code == "DEVICE-DATA-UPDATED") {
    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"];
    Serial.printf("Temperature: %f Humidity: %f Noise Level: %f Air Quality: %f\n",
                  temp_data, humid_data, noise_data, air_data);
    return;
  }
  Serial.println("Failed to Update DATA");
  return;
}

/* Functie om bijgewerkte waarden te versturen */
void sendUpdate() {
  Var data;
  data["temp"] = temp;
  data["humid"] = humid;
  data["noise"] = noise;
  data["air"] = air;
  device.data().set("temp", temp, dataCallback);
  device.data().set("humid", humid, dataCallback);
  device.data().set("noise", noise, dataCallback);
  device.data().set("air", air, dataCallback);
}

void setup() {
  Serial.begin(9600);
  LORA.begin(115200);
  inputString.reserve(200);
  connectWiFi();
  project = grandeur.init(apiKey, token);
  device = project.device(deviceID);
  project.onConnection(onConnection);
}

void loop() {
  serialEvent();
  project.loop(WiFi.status() == WL_CONNECTED);
  if (stringComplete) {
    process_received_data();
    if (connected) sendUpdate();
  }
}

void serialEvent() {
  while (LORA.available()) {
    char inChar = (char)LORA.read();
    if (inChar == '\n') {
      stringComplete = true;
    } else inputString += inChar;
  }
}

Productieproces

  1. Luchtkwaliteit meten met OpenSensors: Een Arduino & Python Handleiding
  2. DIY Luchtkwaliteitmonitor: Kosteneffectieve EPA-compliante detector
  3. Helium-gebaseerde Zon-Powered Luchtsensor: Ontwerp & Implementatiegids
  4. Slimme Plant IoT: Verbonden kassen bouwen met Arduino & Azure
  5. Bosch Sensortec onthult AI-ingeschakelde BME688 luchtkwaliteitssensor om virusoverdrachtsrisico te verminderen
  6. Renesas verbetert Indoor Air Quality sensorplatform met embedded AI voor verbeterde geurdeteectie
  7. Kleine PM2.5 & VOC-sensoren leveren realtime persoonlijke luchtkwaliteitsmonitoring
  8. Geavanceerde Koolstofgebaseerde NO₂-sensor Verbetert Binnenluchtkwaliteitsmonitoring
  9. IoT-sensoren revolutioneren luchtvervuilingsmonitoring en volksgezondheid
  10. IoT-ingeschakelde Luchtkwaliteitsmonitoring: Veiligheid, Productiviteit en Duurzaamheid Verhogen
  11. Industriële IoT Luchtkwaliteitsmonitoring: Productiviteit Verhogen & Kosten Verlagen