FablabMaking - Air Quality / Weather Station - 0986348

Voor het keuzevak FablabMaking aan de Hogeschool Rotterdam, heb ik dit mooie project weten te maken met behulp van verschillende machines, sensoren en een ESP32 microcontroller. Zoals de titel van deze instructable al eigenlijk verklapt, is dit project gecreeerd met het oog op lucht kwaliteit monitoren. Ik zal nu even kort aan de hand van de 5 W's en H dit project toelichten:

• Wie:

Het project is voor iedereen die begaan is met de luchtkwaliteit om zich heen en voor degene wie de weer en/of luchtkwaliteit in de omgeving ook zouden willen monitoren. Voor het maken van het project is wel enige basic arduino kennis gewenst, maar is zeker geen vereisten

• Wat:

Het project betreft het maken van een Air quality station, dat meerdere sensoren bevat voor het meten van verschillende potentieel schadelijk stoffen voor de gezondheid als CO2 en fijnstof, maar ook weersomstandigheden als luchtdruk, temperatuur en luchtvochtigheid.

• Waar:

Dit project kan in iedere (binnen) omgeving geplaatst worden, voor het monitoren en verzenden van data naar online platform is wel een internet verbinding vereist.

• Wanneer:

Dit project kan nuttig zijn wanneer een omgeving potentieel slechte luchtkwaliteit bevat, waarbij dit achterhaald en gemonitord kan worden. Dit is uiteraard geen vereisten en dit kan ook juist ingezet worden om deze aspecten uit interesse te monitoren.

• Waarom:

Zoals al enigszins werd aangegeven, kan dit project gebruikt worden om potentieel schadelijke hoeveelheden fijnstof of CO2 te detecteren, maar ook voor het monitoren van temperatuur en luchtdruk data. Voordat een probleem als luchtkwaliteit namelijk aangepakt kan worden, moet dit namelijk eerst geconstateerd worden.

• Hoe:

Door gebruik te maken van sensoren van "hoge" kwaliteit, met hoge zekerheid de kwaliteit van de lucht waarnemen en (online) monitoren. Ook door middel van een buzzer zal vanaf een bepaalde CO2 waarde er een geluid zich afspelen ter waarschuwing van een hoge CO2 concentratie in de omgevingslucht.

Laten we nu eerst gaan kijken welke onderdelen en machines gebruikt zijn voor het maken van dit project.

Voor dit project zijn de volgende onderdelen voor het elektronische ciricuit nodig (dit zijn voorbeelden):

• ESP32 microcontroller
• Nextion 7" display
• BMP180
• MH-Z19c
• PMS5003
• DHT11
• Buzzer
• Kabels of 'Jumper cables' (afhankelijk van persoonlijke voorkeur)
• Breadboard

Ook zijn de volgende machine gebruikt bij het maken van dit project:

• 3D printer
• Laser cutter
• Vinyl cutter

De volgende software is tevens gebruikt:

• Arduino IDE
• Inkscape
• Tinkercad
• Nextion Editor
• Fritzing

Laten we nu stap voor stap dit project tot stand laten komen.

Zoals hiervoor als was aangegeven, is het handig als er al enige achtergrond kennis met arduino is wanneer er aan dit project begonnen wordt. Even goed kan naar mijn persoonlijke mening iedereen met de hedendaagse middelen die ter beschikking zijn via onder andere het internet, dit project makkelijk volbrengen!

De volgende pin out kan gevolgd worden om het elektronische circuit na te bouwen (zie ook afbeelding van fritzing):

PMS5003 (Fijnstofsensor):

• RX: Verbonden met pin 17 van de ESP32.
• TX: Verbonden met pin 16 van de ESP32.
• Stroom: 5V
• GND: GND

MH-Z19C (CO2-sensor):

• PWM: Verbonden met pin 14 van de ESP32.
• Stroom: 5V
• GND: GND

DHT11 (Temperatuur- en Vochtigheidssensor):

• Data: Verbonden met pin 32 van de ESP32.
• Stroom: 3.3V
• GND: GND

Buzzer:

• Pin: Verbonden met pin 5 van de ESP32.
• Stroom: 5V
• GND: GND

Nextion (Touch) Display:

• RX: Verbonden met pin 16 van de ESP32.
• TX: Verbonden met pin 17 van de ESP32.
• Stroom: 5V
• GND: GND

BMP180 (Luchtdruksensor):

• SDA: Verbonden met pin 21 (standaard I2C SDA pin van de ESP32).
• SCL: Verbonden met pin 22 (standaard I2C SCL pin van de ESP32).
• Stroom: 3.3V
• GND: GND

Als alle connecties met de ESP32 zijn gemaakt, kunnen we overgaan op de code voor dit project.

Voor degene die het leuk vinden om hun data te uploaden naar een gratis platform van adafruit, dan zal er eerst een account en feeds moeten worden aangemaakt voor de verschillende sensoren.

Dit kan allemaal via de website van adafruit die hier te vinden is, waarbij dus ook in de code Wifi en adafruit gegegevens zullen moeten worden ingevuld. Hier zal later in de laatste (bonus) stap nog extra aandacht aan worden besteed, voor de zogehete liefhebbers. Maar dit project kan namelijk ook gemaakt worden wanneer deze wens voor online verbinding er niet is, waarbij ook de code niet hoeft aangepast te worden om het te laten werken en er uiteraard geen wifi gegevens ingevuld te hoeven worden.

// Adafruit.io
#include <WiFi.h>
#include <Adafruit_MQTT.h>
#include <Adafruit_MQTT_Client.h>


#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "XXXXXXX"
#define AIO_KEY         "XXXXXXX"
WiFiClient client;


Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_USERNAME, AIO_KEY);
Adafruit_MQTT_Publish CO2 = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/CO2");
Adafruit_MQTT_Publish PM = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/PM");
Adafruit_MQTT_Publish Humidity = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/Humidity");
Adafruit_MQTT_Publish Temperature = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/Temperature");


const char* ssid = "XXXXXX";
const char* password = "XXXXXXX";


// PMS5003
#include <SoftwareSerial.h>
SoftwareSerial pmsSerial(17, 16);


// MHZ19
#include "MHZ19.h"


const int pwmpin = 14;


MHZ19 *mhz19_pwm = new MHZ19(pwmpin);


// DHT11
#include "DHT.h"


#define DHTPIN 32
#define DHTTYPE DHT11


DHT dht(DHTPIN, DHTTYPE);


int i = 0;


// BUZZER
int buzzerPin = 5;


struct pms5003data {
  uint16_t framelen;
  uint16_t pm10_standard, pm25_standard, pm100_standard;
  uint16_t pm10_env, pm25_env, pm100_env;
  uint16_t particles_03um, particles_05um, particles_10um, particles_25um, particles_50um, particles_100um;
  uint16_t unused;
  uint16_t checksum;
};


struct pms5003data data;


boolean readPMSdatsa(Stream *s) {
  if (!s->available()) {
    return false;
  }


  // Read a byte at a time until we get to the special '0x42' start-byte
  if (s->peek() != 0x42) {
    s->read();
    return false;
  }


  // Now read all 32 bytes
  if (s->available() < 32) {
    return false;
  }


  uint8_t buffer[32];
  uint16_t sum = 0;
  s->readBytes(buffer, 32);


  // get checksum ready
  for (uint8_t i = 0; i < 30; i++) {
    sum += buffer[i];
  }


  /* debugging
     for (uint8_t i=2; i<32; i++) {
       Serial.print("0x"); Serial.print(buffer[i], HEX); Serial.print(", ");
     }
     Serial.println();
  */


  // The data comes in endian'd, this solves it so it works on all platforms
  uint16_t buffer_u16[15];
  for (uint8_t i = 0; i < 15; i++) {
    buffer_u16[i] = buffer[2 + i * 2 + 1];
    buffer_u16[i] += (buffer[2 + i * 2] << 8);
  }


  // put it into a nice struct :)
  memcpy((void *)&data, (void *)buffer_u16, 30);


  if (sum != data.checksum) {
    // Serial.println("Checksum failure");
    return false;
  }
  // success!
  return true;
}


void setup() {
  // our debugging output
  Serial.begin(9600);


  WiFi.begin(ssid, password);


  // sensor baud rate is 9600
  pmsSerial.begin(9600);
  // Serial.print("MH-Z19 now warming up...  status:");


  pinMode(buzzerPin, OUTPUT);
  
  dht.begin();
}


void loop() {
  // tone(buzzerPin, 1000);
  // delay(1000);
  // noTone(buzzerPin);
  // delay(1000);


  if (!mqtt.ping(3)) {
    // reconnect to adafruit
    if (!mqtt.connected()) {
      mqtt.connect();
    }
  }


  if (readPMSdata(&pmsSerial)) {
    // reading data was successful!
    // Serial.println();
    // Serial.println("---------------------------------------");
    // Serial.println("Concentration Units (standard)");
    // Serial.print("PM 1.0: "); Serial.print(data.pm10_standard);
    // Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_standard);
    // Serial.print("\t\tPM 10: "); Serial.println(data.pm100_standard);
    // Serial.println("---------------------------------------");
    // Serial.println("Concentration Units (environmental)");
    // Serial.print("PM 1.0: "); Serial.print(data.pm10_env);
    Serial.print("n5.val=");
    Serial.print(data.pm10_env);
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);  
    // Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_env);
    Serial.print("n0.val=");
    Serial.print(data.pm25_env);
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);    
    // Serial.print("\t\tPM 10: "); Serial.println(data.pm100_env);
    Serial.print("n7.val=");
    Serial.print(data.pm100_env);
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);     
    // Serial.println("---------------------------------------");
    // Serial.print("Particles > 0.3um / 0.1L air:"); Serial.println(data.particles_03um);
    // Serial.print("Particles > 0.5um / 0.1L air:"); Serial.println(data.particles_05um);
    // Serial.print("Particles > 1.0um / 0.1L air:"); Serial.println(data.particles_10um);
    // Serial.print("Particles > 2.5um / 0.1L air:"); Serial.println(data.particles_25um);
    // Serial.print("Particles > 5.0um / 0.1L air:"); Serial.println(data.particles_50um);
    // Serial.print("Particles > 10.0 um / 0.1L air:"); Serial.println(data.particles_100um);
    // Serial.println("---------------------------------------");
    int co2ppm = mhz19_pwm->getPpmPwm();
    // Serial.print("co2: ");
    Serial.print("n3.val=");
    Serial.print(co2ppm);
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);
    if (co2ppm >= 700) {     // vanaf 1500 ppm wordt indoor 
      tone(buzzerPin, 1000);  // het concentratie vermogen aangetast.
      delay(1000);
      noTone(buzzerPin);
      delay(1000);    
    }
    // Serial.println("---------------------------------------");
    // Serial.print(
    
    // 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();
    int h1 = h;
    // Read temperature as Celsius (the default)
    float t = dht.readTemperature();
    int t1 = t * 10;
    // Read temperature as Fahrenheit (isFahrenheit = true)
    float f = dht.readTemperature(true);


    // Check if any reads failed and exit early (to try again).
    if (isnan(h) || isnan(t) || isnan(f)) {
      // Serial.println(F("Failed to read from DHT sensor!"));
      return;
    }


    // Serial.print(F("Humidity: "));
    Serial.print("n1.val=");
    Serial.print(h1);
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);      
    // Serial.print(F("%  Temperature: "));
    Serial.print("x0.val=");
    Serial.print(t1);
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);      
    // Serial.println(F("°C "));
    // Serial.print("page 1");
    // Serial.write(0xff);
    // Serial.write(0xff);
    // Serial.write(0xff);      


    if (i % 20 == 0) { 
      Adafruit_MQTT_Publish CO2 = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/CO2");
      Adafruit_MQTT_Publish PM = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/PM");
      Adafruit_MQTT_Publish Humidity = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/Humidity");
      Adafruit_MQTT_Publish Temperature = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/Temperature");


      if (!CO2.publish(co2ppm)) {
        Serial.println("Failed to send CO2 data");
      } else {
        Serial.println("Sent CO2 data");
      }
      if (!PM.publish(data.pm10_env)) {
        Serial.println("Failed to send PM data");
      } else {
        Serial.println("Sent PM data");
      }
      if (!Humidity.publish(h1)) {
        Serial.println("Failed to send Humidity data");
      } else {
        Serial.println("Sent Humidity data");
      }
      if (!Temperature.publish(t)) {
        Serial.println("Failed to send Temperature data");
      } else {
        Serial.println("Sent Temperature data");
      }
    }
    i = i + 1;
  }
}

Gebruikte Libraries:

1. WiFi.h - Voor het verbinden van de ESP32 met een WiFi-netwerk.
2. Adafruit_MQTT.h - Voor het gebruik van het MQTT-protocol met Adafruit.io.
3. Adafruit_MQTT_Client.h - Voor het instellen van een MQTT-client.
4. SoftwareSerial.h - Voor het creëren van extra seriële poorten via software.
5. MHZ19.h - Voor het aansturen van de MH-Z19C CO2-sensor.
6. DHT.h - Voor het uitlezen van de DHT11 temperatuur- en vochtigheidssensor.

Uitleg van de code:

Bibliotheken en WiFi-instellingen:

• De code begint met het importeren van verschillende bibliotheken die nodig zijn voor WiFi-verbindingen, MQTT-communicatie, en het aansturen van de sensoren.
• WiFi-gegevens en Adafruit.io accountinformatie worden ingesteld.

PMS5003 Stofsensor:

• De PMS5003 is een sensor die de concentratie van fijnstof in de lucht meet.
• De sensor communiceert via seriële poorten (pin 17 voor RX en pin 16 voor TX).
• Er wordt een functie readPMSdata gebruikt om de gegevens van de sensor uit te lezen en te controleren op juistheid.

MH-Z19C CO2-sensor:

• Deze sensor meet de CO2-concentratie in de lucht.
• De CO2-waarden worden via de PWM-pin (pin 14) uitgelezen.

DHT11 Temperatuur- en Vochtigheidssensor:

• De DHT11 meet de temperatuur en vochtigheid.
• De data wordt gelezen via pin 32.

Buzzer:

• Een buzzer is aangesloten op pin 5 en wordt gebruikt als een alarm wanneer de CO2-waarden te hoog zijn.

Nextion Display:

• Het display toont de gemeten waarden voor fijnstof, CO2, temperatuur en vochtigheid.
• Gegevens worden via de seriële poorten (pin 16 voor RX en pin 17 voor TX) naar het display gestuurd.

Setup-functie:

• In de setup-functie worden de seriële communicatie, WiFi-verbinding en de sensoren geïnitialiseerd.

Loop-functie:

• De loop-functie draait continu en voert de volgende taken uit:
• Controleert de WiFi-verbinding en herstelt deze indien nodig.
• Leest de gegevens van de PMS5003 stofsensor en toont deze op het display.
• Leest de CO2-waarden uit de MH-Z19C sensor en toont deze op het display. Als de CO2-waarde hoger is dan 700 ppm, klinkt de buzzer als alarm.
• Leest de temperatuur- en vochtigheidswaarden uit de DHT11 sensor en toont deze op het display.
• Stuurt om de 20 iteraties (bij benadering elke 20 seconden) de gemeten waarden naar Adafruit.io.

Belangrijke Opmerkingen:

• Zorg ervoor dat de sensoren correct zijn aangesloten op de juiste pinnen.
• De PMS5003 en Nextion Display hebben beide seriële pinnen, dus zorg ervoor dat ze niet in de war komen en tegelijkertijd communiceren om conflicten te voorkomen.
• Voer altijd veiligheidsmaatregelen uit bij het werken met elektronische componenten en zorg voor een goede voeding van de sensoren.

Voor het maken van de behuizing is te adviseren, om dit als eerste stap te ondernemen voor het maken van de behuizing. Het maken van de de behuizing is gedaan in het programma Tinkercad, waarvan het model is bijgevoegd voor dit project in de bijlage.

In principe zou iedere 3D printer deze print moeten kunnen voltooien, alleen de print is tussen de 5 a 6 uur afhankelijk van de printer instellingen en de capaciteiten van de printer zelf. Mocht je nog een aanpassing willen doen aan het design, raad ik aan mogelijk onder en boven extra ventilatie gleuven te maken voor betere lucht doorstroming. Persoonlijk had ik niet de print instellingen geoptimaliseerd en heb de printtijd gehouden op 5 uur en 44 minuten, waarvan de video timelapse van is bijgevoegd in dit onderdeel.

Voor de voorkant is het leuk om acryll te gebruiken, maar dit kan in feit met iedere beschikbare soort materiaal naar wens. Ik heb hier persoonlijk het programma Inkscape voor gebruikt, waarvan het bijbehorende bestand wederom is bijgevoegd in de bijlage van dit onderdeel.

Hierbij is het belangrijk te letten op dat eerst de afbeelding gebit map traced is, waarna de lijn die uitgesneden moeten worden in het rood zijn en 0,01 mm dik moet zijn. Bij de printer zelf is het belangrijk de correcte matteriaal te selecteren voor de betreffende printer, zodat deze er goed doorheen snijdt. Bij het lasercutten is aan te raden om eerst een stuk (oud) hout te gebuiken om zeker te weten dat de tollerantie van de 3D print en de voorkant goed op elkaar aansluiten. Wanneer er met zekerheid is gemeten, kan er gekozen worden om bijvoorbeeld de acryll versie te snijden. Het is ook aan te raden om te wachten dus met al te snijden van de voorkant, zonder het fysiek te kunnen checken met je 3d print.

Hetzelfde verhaal geldt voor het gecreëerde vinyl snijbestand, deze is bijgevoegd in de bijlage van dit onderdeel en is ook wederom gemaakt in Inkscape. Ik zou bijna willen zeggen dat dit een optionele stap is, aangezien dit uiteraard simpelweg stickers zijn. Toch geeft dit net weer een wat meer persoonlijke draai aan het project.

Om de behuizing wat op te leuken kan er ook voor gekozen worden om stickers/vinyl uit te snijden. Hiervoor werkt het tot een zeker hoogte hetzelfde als laser cutten, als in het letten op de rode lijnen die gesneden moeten worden met een lijndikte van 0,01 mm, maar hier moet goed opgelet worden dat de snijder zelf ook het vel wat gebruikt gaat worden goed heeft gepakt op de aangegeven punten van de machine. Als deze punten geen goed contact hebben, zal het vinyl gaan schuiven en komt de sticker er heel anders uit. Ook is naar mijn begrip en ervaring een snijdiepte van 0,75 mm op de snijder zelf de meest optimale diepte. In dit project zijn er 2 stickers gebruikt, maar iedereen is vrij om hier meer of minder te doen!

We kunnen nu echt beginnen met alle onderdelen samen te brengen tot een geheel!

Voeg eerst het scherm toe met 4x M3 schroeven en bouten aan de voorkant die gemaakt is voor de behuizing, pas op dat deze niet te strak worden vastgemaakt om niet het acryl of de pcb van het scherm kapot te maken.

We kunnen het breadboard en de Fijnstof sensor in de 3D behuizing plaatsen, waarbij gebruik gemaakt kan worden van dubbelzijdig tape, of eventueel een kleine hoeveelheid seconden lijm. Het breadboard heeft als het goed is ook al een dubbelzijdige plakkant waar gebruik gemaakt van kan worden. Let bij deze stap ook op dat er een kabel aan de ESP32 wordt aangesloten en door het gat wordt begeleidt. Dit kan eventueel ook nog vast gezet worden met lijm als dit een wens is.

We kunnen Nu de voorkant met het scherm gaan vastmaken aan de behuizing. Ik had zelf gekozen voor torque schroeven voor het gemak, aangezien mijn bestelling van threaded inserts te laat was. Beide is een degelijke optie. Wanneer deze 4 hoeken zijn vastgemaakt aan de 3D print, zijn we eindelijk bij het einde aangekomen en hebben we als t goed is een mooie Air quality & weather station als resultaat!

Geweldig gedaan, als je zo ver bent gekomen! Hopelijk is alles gelukt en ben jij nu ook de trotse eigenaar van een super nuttig project, waarmee je de gezondheid van jezelf en je omgeving beter kan monitoren!

Er is nog een enkele bonus stap voor de liefhebbers die graag online zouden willen monitoren.

Als er de keuze is gemaakt om gebruik te maken van de Wifi module en een adafruit.io account, dan kan het resultaat eruit zien zoals in het voorbeeld. In de code is er een delay in de loop ingebouwd, waardoor we niet het maximum upload limiet overschreiden, wat nu inhoudt dat ongeveer om de 45 sec een upload naar het platform wordt gedaan. Ik zal voor de duidelijkheid een stappenplan geven hoe je ervoor kan zorgen dat er met Adafruit.io en de ESP32 gecommuniceerd kan worden door middel van MQTT:

Stappenplan voor het instellen van Adafruit.io

Stap 1: Maak een Adafruit.io account aan

1. Ga naar Adafruit.io.
2. Klik op "Sign Up" om een nieuw account aan te maken, of log in als je al een account hebt.

Stap 2: Maak Feeds aan

1. Na het inloggen, klik op het "Feeds" menu.
2. Klik op de knop "Actions" en selecteer "Create a New Feed".
3. Maak vier feeds aan met de volgende namen: CO2, PM, Humidity, en Temperature.

• Voer bij elke feed een passende beschrijving in, zoals "CO2 concentratie in ppm", "Fijnstof PM2.5", "Luchtvochtigheid", en "Temperatuur".

Stap 3: Maak een Dashboard aan

1. Klik op "Dashboards" in het hoofdmenu.
2. Klik op "Actions" en selecteer "Create a New Dashboard".
3. Geef je dashboard een naam, bijvoorbeeld "Luchtkwaliteit Monitor".
4. Klik op "Create" om het dashboard aan te maken.

Stap 4: Voeg Widgets toe aan je Dashboard

1. Open je nieuwe dashboard en klik op "Create New Block".
2. Selecteer de type widget die je wilt gebruiken voor elke feed, zoals "Gauge" voor CO2 en "Humidity", en "Line Chart" voor PM en Temperature.
3. Koppel elke widget aan de juiste feed door de feed te selecteren tijdens het configuratieproces.
4. Pas de weergave-instellingen aan naar wens, zoals labels en kleurenschema's.

Stap 5: Verkrijg je Adafruit.io AIO Key

1. Klik op je profielicoon rechtsboven en selecteer "My Key" uit het dropdown menu.
2. Kopieer je Active Key. Dit is je Adafruit.io AIO Key die je in je ESP32 code moet gebruiken.

Stap 6: Configureer je ESP32 Code

1. Zorg ervoor dat je WiFi SSID, WiFi wachtwoord, Adafruit.io gebruikersnaam, en Adafruit.io AIO Key correct zijn ingesteld in je code, zoals eerder al aangeven was bij de code stap.

Stap 7: Upload de Code naar je ESP32

1. Sluit je ESP32 aan op je computer.
2. Open je Arduino IDE en selecteer het juiste board en poort onder het menu "Tools".
3. Upload de code naar je ESP32.

Stap 8: Bekijk je Dashboard

1. Ga terug naar Adafruit.io en open je dashboard.
2. Je zou nu de live gegevens van je sensoren moeten zien in de widgets die je hebt ingesteld.

Bronnenlijst

Onderdelen:

• ESP32 microcontroller
• Nextion 7" display
• BMP180
• MH-Z19c
• PMS5003
• DHT11
• Buzzer
• Kabels of 'Jumper cables'
• Breadboard

Software:

• Arduino IDE
• Inkscape
• Tinkercad
• Nextion Editor
• Fritzing

Libraries:

• WiFi.h
• Adafruit_MQTT.h
• Adafruit_MQTT_Client.h
• SoftwareSerial.h
• MHZ19.h
• DHT.h