Partikel Messung

Partikel Messung I

Mit diesem Projekt werden mit einem SDS011-Sensor Partikel in der Luft gemessen, deren Masse aller im Gesamtstaub enthaltenen Partikel einen aerodynamischen Durchmesser von 2,5µm bzw 10µm haben. Der SDS011 nutzt das Prinzip der Laserstreuung und hat eine Auflösung von 0,3 µgr/m³. Der Messwert wird mit einem OLED-Desplay angezeigt und bezieht sich auf die Partikel in µgr/m³.
Nach dem Start erscheint eine Minute lang ein Smiley im Display. Die Zeit wird für die erste, zuverlässige Messung genutzt. Die folgenden Messungen finden im 5 Minuten-Zyklus statt. Nach jeder Messung geht die Schaltung in den Sleep-Modus, um Energie zu sparen.

Hardware

Die Stückliste für die Partikel Messung:

1 x ESP8266

1 x ESP8266-Shield (optional)

1 x SDS011-Sensor

1 x OLED-Display 1,3"

1 x Akku

Kleinmaterial, Schaltdraht

Verdrahtung

ESP8266 - SDS011-Sensor:

GND     GND

+5V     +5V

D3     RXD

D4     TXD

ESP8266 - OLED Display 1,3":

GND         GND

+5V         +5V

SCL         SCK

SDA         SDA

Software

Die Software wird mit der Arduino IDE in den ESP8266 geladen.

Nach dem Programm-Download in den ESP8266 werden nach 1min die Sensordaten am Dsplay angezeigt.

Programm

C++ Code: SDS011-Sensor am OLED Display

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
  Funktion: Feinstaubmessung mit Nova PM sensor SDS011 und OLED Display 1,3"
  A168
  https://www.umweltbundesamt.de/daten/luft/feinstaub-belastung#feinstaubkonzentrationen-in-deutschland

  60sek Smiley am Display waehrend der Sensor Initialisierung
**************************************************************************************************
  PM2.5 steht beispielsweise fuer Partikel mit einem aerodynamischen Durchmesser von 2,5 Mikrometer oder weniger, PM10 fuer 10 Mikrometern

  SDS011 (Laser Dust/Air Quality Sensor Module)
  Specification:
  Measured values: PM2.5, PM10
  Range: 0 - 999.9 ug /m3
  Supply voltage: 5V (4.7 - 5.3V)
  Power consumption (work): 70mA+-10mA
  Power consumption (sleep mode laser & fan): < 4mA
  Storage temperature: -20 to +60C
  Work temperature: -10 to +50C
  Humidity (storage): Max. 90%
  Humidity (work): Max. 70% (condensation of water vapor falsify readings)
  Accuracy:
  70% for 0.3um
  98% for 0.5um
  Size: 71x70x23 mm
  Certification: CE, FCC, RoHS
  Pinout:
  Pin 1 - not connected
  Pin 2 - PM2.5: 0-999ug/m3; PWM output
  Pin 3 - 5V
  Pin 4 - PM10: 0-999 ug/m3; PWM output
  Pin 5 - GND
  Pin 6 - RX UART (TTL) 3.3V
  Pin 7 - TX UART (TTL) 3.3V
**************************************************************************************************
  Version: 13.06.2022
**************************************************************************************************
  Board: LOLIN(WEMOS)D1 R2 & mini V2.2.0
**************************************************************************************************
  Libraries:
  https://github.com/espressif/arduino-esp32/tree/master/libraries
  C:\Users\User\Documents\Arduino
  D:\gittemp\Arduino II\A156_Wetterdaten_V3

  https://github.com/lewapek/sds-dust-sensors-arduino-library V1.5.1 Pawel Kolodziejczyk V1.5.1 vom 14.2.2022
  https://github.com/olikraus/u8g2/blob/master/tools/font/build/single_font_files/u8g2_font_courR10_tf.c
**************************************************************************************************
  C++ Arduino IDE V1.8.19

  I2C Display
  SCL = D1
  SDA = D2

**************************************************************************************************
  Einstellungen:
  https://dl.espressif.com/dl/package_esp32_index.json
  http://dan.drown.org/stm32duino/package_STM32duino_index.json
  http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
#include <Arduino.h>
#include <SdsDustSensor.h> //Nova Fitnes SDS Dust Senssor

//***********OLED********************
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif
U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
unsigned long delayTime;
//*******************************


/* SDS011 Dust Sensor -> ESP8266 */
const int SDS_RX_PIN = D3; // D3 -> SDS011 RX pin
const int SDS_TX_PIN = D4; // D4 -> SDS011 TX pin



SoftwareSerial softwareSerial(SDS_RX_PIN, SDS_TX_PIN);
SdsDustSensor sds(softwareSerial); //  zusaetzliche Parameter: retryDelayMs und maxRetriesNotAvailable
const int MINUTE = 60000; // 60 Sekunden
const int WAKEUP_WORKING_TIME = 30000; // 30 Sekunden
const int MEASUREMENT_INTERVAL = 5 * MINUTE;

void setup() {
  Serial.begin(115200);
  //***********OLED********************
  u8g2.begin();
  //***********************************
  Serial.println("SDS011 Feinstaubsensor");
  delay(500);
  /* SDS011 Dust Sensor */
  sds.begin();
  // SDS011 Firmware Version:
  Serial.print("SDS011 ");
  Serial.println(sds.queryFirmwareVersion().toString());
  // Stellt sicher, dass sich SDS011 im Abfrageberichtsmodus befindet:
  Serial.println(sds.setQueryReportingMode().toString());

  int BildschirmBreite = u8g2.getDisplayWidth();
  int BildschirmHoehe = u8g2.getDisplayHeight();


  //Smiley XBM erstellt mit GIMP
#define smiley_width 64
#define smiley_height 64
  static unsigned char smiley[] = {
    0x00, 0x00, 0x00, 0xd0, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff,
    0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00,
    0x00, 0x00, 0xfc, 0x5f, 0xfd, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
    0x80, 0x7f, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0xfc, 0x01, 0x00,
    0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xf0, 0x01, 0x00,
    0x00, 0xc0, 0x0f, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00,
    0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x1e, 0x00, 0x00,
    0x00, 0x00, 0x7c, 0x00, 0x00, 0x1f, 0x00, 0x03, 0x80, 0x01, 0xf8, 0x00,
    0x80, 0x07, 0x80, 0x03, 0xc0, 0x03, 0xf0, 0x00, 0xc0, 0x07, 0x80, 0x07,
    0xc0, 0x03, 0xe0, 0x01, 0xc0, 0x03, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x03,
    0xe0, 0x01, 0xc0, 0x07, 0xe0, 0x07, 0x80, 0x07, 0xe0, 0x00, 0xc0, 0x0f,
    0xe0, 0x07, 0x80, 0x07, 0xf0, 0x00, 0xc0, 0x0f, 0xe0, 0x07, 0x00, 0x0f,
    0x70, 0x00, 0xc0, 0x0f, 0xe0, 0x07, 0x00, 0x0e, 0x78, 0x00, 0xc0, 0x0f,
    0xe0, 0x07, 0x00, 0x1e, 0x38, 0x00, 0xe0, 0x0f, 0xe0, 0x07, 0x00, 0x1e,
    0x3c, 0x00, 0xc0, 0x0f, 0xe0, 0x07, 0x00, 0x1c, 0x1c, 0x00, 0xc0, 0x07,
    0xe0, 0x07, 0x00, 0x3c, 0x1c, 0x00, 0xc0, 0x07, 0xe0, 0x07, 0x00, 0x38,
    0x1c, 0x00, 0xc0, 0x07, 0xc0, 0x03, 0x00, 0x38, 0x1e, 0x00, 0x80, 0x07,
    0xc0, 0x03, 0x00, 0x38, 0x1e, 0x00, 0x80, 0x03, 0x80, 0x01, 0x00, 0x38,
    0x0e, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x78, 0x0e, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x38, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78,
    0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x78, 0x0e, 0x7c, 0x00, 0x00,
    0x00, 0x00, 0x3e, 0x70, 0x0e, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38,
    0x1e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x18, 0x78, 0x1e, 0x30, 0x00, 0x00,
    0x00, 0x00, 0x08, 0x38, 0x1e, 0x30, 0x00, 0x00, 0x00, 0x00, 0x08, 0x38,
    0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x38, 0x1c, 0x20, 0x00, 0x00,
    0x00, 0x00, 0x04, 0x38, 0x1c, 0x60, 0x00, 0x00, 0x00, 0x00, 0x06, 0x3c,
    0x3c, 0x40, 0x00, 0x00, 0x00, 0x00, 0x06, 0x1c, 0x38, 0xc0, 0x00, 0x00,
    0x00, 0x00, 0x03, 0x1c, 0x78, 0x80, 0x01, 0x00, 0x00, 0x00, 0x01, 0x1e,
    0x78, 0x00, 0x01, 0x00, 0x00, 0x80, 0x01, 0x0e, 0xf0, 0x00, 0x07, 0x00,
    0x00, 0xc0, 0x00, 0x0f, 0xf0, 0x00, 0x04, 0x00, 0x00, 0x60, 0x00, 0x07,
    0xe0, 0x01, 0x1c, 0x00, 0x00, 0x38, 0x80, 0x07, 0xc0, 0x03, 0x70, 0x00,
    0x00, 0x0c, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x01, 0x00, 0x07, 0xe0, 0x03,
    0x80, 0x07, 0x80, 0x17, 0xf0, 0x01, 0xe0, 0x01, 0x00, 0x0f, 0x00, 0xfc,
    0x3f, 0x00, 0xf0, 0x00, 0x00, 0x1f, 0x00, 0x40, 0x01, 0x00, 0x78, 0x00,
    0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0xfc, 0x00, 0x00,
    0x00, 0x00, 0x1f, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x80, 0x0f, 0x00,
    0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xc0, 0x1f, 0x00,
    0x00, 0xf8, 0x03, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00,
    0x00, 0x00, 0xfe, 0x2f, 0xf4, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff,
    0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x03, 0x00, 0x00,
    0x00, 0x00, 0x00, 0xfa, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  };


  do {
    u8g2.clearBuffer();
    u8g2.drawXBM(32, 1, smiley_width, smiley_height, smiley);

  } while ( u8g2.nextPage() );
  delay(3000);
}


void loop() {
  // Wake up SDS011
  sds.wakeup();
  delay(WAKEUP_WORKING_TIME);
  // Get data from SDS011
  PmResult pm = sds.queryPm();
  if (pm.isOk()) {
    Serial.print("PM2.5 = ");
    Serial.print(pm.pm25); // float, ug/m3
    Serial.print(", PM10 = ");
    Serial.println(pm.pm10);

    //***********OLED********************
    u8g2.setFont(u8g2_font_courR10_tf);
    u8g2.firstPage();

    do {

      u8g2.setCursor(25, 10);
      u8g2.print("Partikel-");
      u8g2.setCursor(31, 24);
      u8g2.print("messung:");

      u8g2.setFont(u8g2_font_courR08_tf);

      u8g2.setCursor(3, 45);
      u8g2.print("PM 2.5""\xB5""m:");
      u8g2.setCursor(63, 45);
      u8g2.print(pm.pm25);
      u8g2.print("\xB5""gr/m3");

      u8g2.setCursor(3, 59);
      u8g2.print("PM 10""\xB5""m:");
      u8g2.setCursor(63, 59);
      u8g2.print(pm.pm10);
      u8g2.print("\xB5""gr/m3");

    } while ( u8g2.nextPage() );
    delay(delayTime);


  } else {
    Serial.print("Werte vom Sensor konnten nicht gelesen werden, Grund: ");
    Serial.println(pm.statusToString());
  }
  // SDS011 wieder in den Ruhezustand versetzen
  WorkingStateResult state = sds.sleep();
  if (state.isWorking()) {
    Serial.println("Problem mit dem Einschlafen des SDS011-Sensors.");
  } else {
    Serial.println("SDS011-Sensor schlaeft");
    delay(MEASUREMENT_INTERVAL);
  }

}

RAW code

Versuchsaufbau

Sensordaten im Seriellen Monitor.

Sensordaten im OLED Display.

Partikel Messung II

Das Projekt wird um zwei ESP32 LoRa-Module erweitert. LoRa steht für "Long Range" und ist eine Funktechnologie, welche neu für das IoT (Internet of Things) entwickelt wurde. Neben der speziell grossen Funkreichweite von bis zu > 10 km wurden bei der LoRa Technologie besonders auf einen geringen Energieverbrauch und auf eine möglichst kostengünstige Implementierung geachtet. LoRa kann eigenständig als Punkt-zu-Punkt Verbindung eingesetzt aber auch in einem privaten oder öffentlichen Netzwerk wie z.B. dem LoRaWAN (Long Range Wide Area Network) betrieben werden. Diese unterschiedlichen Betriebsarten machen LoRa sehr flexibel und daher ist die Technologie äusserst interessant für verschiedenste Anwendungen.
Bei der nachfolgenden Punkt-zu-Punkt-Kommunikation kommunizieren zwei LoRa-fähige Geräte miteinander. Das Sende-Modul ist ein HELTEC WLAN LORA 32, verbunden mit dem SDS011 Partikel-Sensor. Das Empfänger-Modul ist ein TTGO Lora32-OLED, dass die Sensor-Daten auf einen WEB-Server abbildet. Beide Module liefern wichtige Infos auch über den Seriellen Monitor. Beim SDS11 Sensor werden die PWM-Ausgänge für die Messwerte genützt.

Programm

C++ Code: LoRa Sender

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: LORA Sender SDS011 (COM15)
**************************************************************************************************
Version: 14.06.2022
**************************************************************************************************
Board: HELTEC WLAN LORA 32
**************************************************************************************************
*PM2.5 steht beispielsweise für Partikel mit einem aerodynamischen Durchmesser von 2,5 Mikrometer oder weniger, PM10 für 10 Mikrometern

  SDS011 (Laser Dust/Air Quality Sensor Module)
  Specification:
  Measured values: PM2.5, PM10
  Range: 0 – 999.9 μg /m³
  Supply voltage: 5V (4.7 – 5.3V)
  Power consumption (work): 70mA±10mA
  Power consumption (sleep mode laser & fan): < 4mA
  Storage temperature: -20 to +60C
  Work temperature: -10 to +50C
  Humidity (storage): Max. 90%
  Humidity (work): Max. 70% (condensation of water vapor falsify readings)
  Accuracy:
  70% for 0.3μm
  98% for 0.5μm
  Size: 71x70x23 mm
  Certification: CE, FCC, RoHS
  Pinout:
  Pin 1 – not connected
  Pin 2 – PM2.5: 0-999μg/m³; PWM output
  Pin 3 – 5V
  Pin 4 – PM10: 0-999 μg/m³; PWM output
  Pin 5 – GND
  Pin 6 – RX UART (TTL) 3.3V
  Pin 7 – TX UART (TTL) 3.3V
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/

//LoRa Libraries
#include <SPI.h>
#include <LoRa.h>

//OLED Display Libraries
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//PWM Sensoreingänge
int PM25 = 36;
int PM10 = 37;

float PM25Readin = 25;
float PM10Readin = 10;

//LoRa-Modul Pins
#define SCK 5
#define MISO 19
#define MOSI 27
#define SS 18
#define RST 14
#define DIO0 26

//Frequenz fuer Europa
#define BAND 866E6

//OLED Pins
#define OLED_SDA 4
#define OLED_SCL 15
#define OLED_RST 16
#define SCREEN_WIDTH 128 // OLED Breite
#define SCREEN_HEIGHT 64 // OLED Höhe

TwoWire I2Cone = TwoWire(1);

//Packet Counter
int readingID = 0;

int counter = 0;
String LoRaMessage = "";

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST);

//Initialisiere OLED Display
void startOLED(){
  //OLED Reset
  pinMode(OLED_RST, OUTPUT);
  digitalWrite(OLED_RST, LOW);
  delay(20);
  digitalWrite(OLED_RST, HIGH);

  //Initialisiere OLED Display
  Wire.begin(OLED_SDA, OLED_SCL);
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3c, false, false)) { // Address 0x3C for 128x32
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
  display.clearDisplay();
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(0,0);
  display.print("LORA SENDER");
}

//Initialisiere LoRa
void startLoRA(){
  //SPI LoRa pins
  SPI.begin(SCK, MISO, MOSI, SS);
  //Setup LoRa Sende Modul
  LoRa.setPins(SS, RST, DIO0);

  while (!LoRa.begin(BAND) && counter < 10) {
    Serial.print(".");
    counter++;
    delay(500);
  }
  if (counter == 10) {
    // Erhöhe die Lese-ID für jede neue Lesung
    readingID++;
    Serial.println("Starting LoRa failed!");
  }
  Serial.println("LoRa-Initialisierung OK!");
  display.setCursor(0,10);
  display.clearDisplay();
  display.print("LoRa-Initialisierung OK!");
  display.display();
  delay(2000);
}

void getReadings(){
   PM25Readin = analogRead(36);
   PM25Readin = map(PM25Readin, 0, 4095, 0, 1000);
   PM10Readin = analogRead(37);
   PM10Readin = map(PM10Readin, 0, 4095, 0, 1000);

    //Kalibrierung:
    PM25Readin=PM25Readin/134,23;
    PM10Readin=PM10Readin/84,63;


   Serial.println("PM25Readin: ");
   Serial.println(PM25Readin);
   Serial.println("PM10Readin: ");
   Serial.println(PM10Readin);
}


void sendReadings() {
  LoRaMessage = String(readingID) + "/" + String(PM25Readin) + "&" + String(PM10Readin);
  //Send LoRa packet to receiver
  LoRa.beginPacket();
  LoRa.print(LoRaMessage);
  LoRa.endPacket();

  display.clearDisplay();
  display.setCursor(0,0);
  display.setTextSize(1);
  display.print("LoRa Packet gesendet!");
  display.setCursor(0,20);
  display.print("PM25: ");
  display.setCursor(44,20);
  display.print(PM25Readin);
  display.setCursor(0,30);
  display.print("PM10: ");
  display.setCursor(44,30);
  display.print(PM10Readin);

  display.setCursor(0,40);
  display.print("Lese-ID:");
  display.setCursor(75,40);
  display.print(readingID);
  display.display();
  Serial.print("Paket senden: ");
  Serial.println(readingID);
  readingID++;
}

void setup() {
  //Intialisiere Serial Monitor
  Serial.begin(115200);
  startOLED();
  startLoRA();
}
void loop() {

  getReadings();
  sendReadings();
  delay(10000);
}

RAW code

C++ Code: LoRa Empfänger

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: LoRa WAN WEB-Server SDS011 A169 COM6
**************************************************************************************************
Version: 14.06.022
**************************************************************************************************
Board: TTGO Lora32-OLED V1
**************************************************************************************************
*PM2.5 steht beispielsweise für Partikel mit einem aerodynamischen Durchmesser von 2,5 Mikrometer oder weniger, PM10 für 10 Mikrometern

  SDS011 (Laser Dust/Air Quality Sensor Module)
  Specification:
  Measured values: PM2.5, PM10
  Range: 0 – 999.9 μg /m³
  Supply voltage: 5V (4.7 – 5.3V)
  Power consumption (work): 70mA±10mA
  Power consumption (sleep mode laser & fan): < 4mA
  Storage temperature: -20 to +60C
  Work temperature: -10 to +50C
  Humidity (storage): Max. 90%
  Humidity (work): Max. 70% (condensation of water vapor falsify readings)
  Accuracy:
  70% for 0.3μm
  98% for 0.5μm
  Size: 71x70x23 mm
  Certification: CE, FCC, RoHS
  Pinout:
  Pin 1 – not connected
  Pin 2 – PM2.5: 0-999μg/m³; PWM output
  Pin 3 – 5V
  Pin 4 – PM10: 0-999 μg/m³; PWM output
  Pin 5 – GND
  Pin 6 – RX UART (TTL) 3.3V
  Pin 7 – TX UART (TTL) 3.3V
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
// Import Wi-Fi Library
#include <WiFi.h>
#include "ESPAsyncWebServer.h"

#include <SPIFFS.h>

//LoRa Libraries
#include <SPI.h>
#include <LoRa.h>

//OLED Display Libraries
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//NTP Server Libraries
#include <NTPClient.h>
#include <WiFiUdp.h>

//Pins des LoRa-Transceiver-Moduls
#define SCK 5
#define MISO 19
#define MOSI 27
#define SS 18
#define RST 14
#define DIO0 26

//Europa Frequenz 866MHz
#define BAND 866E6

//TTGO OLED Pins
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_RST 16

/*HELTEC Pins
#define OLED_SDA 4
#define OLED_SCL 15
#define OLED_RST 16
*/
#define SCREEN_WIDTH 128 // Breite OLED Display 128 Pixel
#define SCREEN_HEIGHT 64 // Höhe OLED Display 64 Pixel

// WiFi Zugang
const char* ssid     = "R2-D2";
const char* password = "xxx";

// NTP Client
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

// Variablen fue Datum und Zeit
String formattedDate;
String day;
String hour;
String timestamp;


// Initialisiere LoRa Variablen
int rssi;
String loRaMessage;
String PM25Readin;
String PM10Readin;
String readingID;

// AsyncWebServer Port 80
AsyncWebServer server(80);

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST);

// Ersetzt Platzhalter der PWM EIngaenge
/*Die Received Signal Strength Indication (RSSI) ist die empfangene Signalleistung
 * in Milliwatt und wird in dBm gemessen.
 */
String processor(const String& var){
  //Serial.println(var);
  if(var == "PM25"){
    return PM25Readin;
  }
    else if(var == "PM10"){
    return PM10Readin;
  }
  else if(var == "TIMESTAMP"){
    return timestamp;
  }
  else if (var == "RRSI"){
    return String(rssi);
  }
  return String();
}

//Initialisiere OLED Display
void startOLED(){
  //Reset OLED Display
  pinMode(OLED_RST, OUTPUT);
  digitalWrite(OLED_RST, LOW);
  delay(20);
  digitalWrite(OLED_RST, HIGH);

  //Initialisiere OLED Display
  Wire.begin(OLED_SDA, OLED_SCL);
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3c, false, false)) { // Adresse 0x3C
    Serial.println(F("SSD1306-Initialisierung fehlgeschlagen"));
    for(;;); // Schleife beenden
  }
  display.clearDisplay();
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(0,0);
  display.print("LORA SENDER");
}

//Initialisiere LoRa Modul
void startLoRA(){
  int counter;
  //SPI LoRa Pins
  SPI.begin(SCK, MISO, MOSI, SS);
  //LoRa-Empfaenger-Modul einrichten
  LoRa.setPins(SS, RST, DIO0);

  while (!LoRa.begin(BAND) && counter < 10) {
    Serial.print(".");
    counter++;
    delay(500);
  }
  if (counter == 10) {
    // Erhöhe die Lese-ID bei jedem neuen Messwert
    Serial.println("LoRa Start fehlgeschlagen!");
  }
  Serial.println("LoRa Init. OK!");
  display.setCursor(0,10);
  display.clearDisplay();
  display.print("LoRa Init. OK!");
  display.display();
  delay(2000);
}

void connectWiFi(){
  // Verbindung dem Wi-Fi-Netzwerk mit SSID und Passwort
  Serial.print("Verbinde mit ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // Lokale IP-Adresse ausgeben und Webserver starten
  Serial.println("");
  Serial.println("WiFi verbunden.");
  Serial.println("IP Adresse: ");
  Serial.println(WiFi.localIP());
  display.setCursor(0,25);
  display.print("Web-Server Adresse: ");
  display.setCursor(0,40);
  display.print(WiFi.localIP());
  display.display();
}

// Sensormesswerte vom LoRa-Paket lesen
void getLoRaData() {
  Serial.print("Lora-Paket empfangen: ");
  // Lese Packet
  while (LoRa.available()) {
    String LoRaData = LoRa.readString();
    // LoRaData-Format: LeseID/PM25&PM10#xx
    // String example: 1/2.5&10#xx
    Serial.print(LoRaData);

    // Holen die ReadingID, PM25 und PM10
    int pos1 = LoRaData.indexOf('/');
    int pos2 = LoRaData.indexOf('&');
    int pos3 = LoRaData.indexOf('#');
    readingID = LoRaData.substring(0, pos1);
    PM25Readin = LoRaData.substring(pos1 +1, pos2);
    PM10Readin = LoRaData.substring(pos2 +1, pos3);
//    xx = LoRaData.substring(pos3+1, LoRaData.length());
  }
  // Hole RSSI Received Signal Strength Indication
  rssi = LoRa.packetRssi();
  Serial.print(" Signalstärke: ");
  Serial.println(rssi);
}

// Datum und Zeit vom NTPClient
void getTimeStamp() {
  while(!timeClient.update()) {
    timeClient.forceUpdate();
  }
  // Das formattedDate hat das folgendes Format:
  // 2018-05-28T16:00:13Z
  // Datum und Uhrzeit extrahieren
  formattedDate = timeClient.getFormattedDate();
  Serial.println(formattedDate);

  // Datum
  int splitT = formattedDate.indexOf("T");
  day = formattedDate.substring(0, splitT);
  Serial.println(day);
  // Zeit
  hour = formattedDate.substring(splitT+1, formattedDate.length()-1);
  Serial.println(hour);
  timestamp = day + " " + hour;
}

void setup() {
  // Initialisiere Seriellen Monitor
  Serial.begin(115200);
  startOLED();
  startLoRA();
  connectWiFi();

  if(!SPIFFS.begin()){
    Serial.println("Beim Mounten von SPIFFS ist ein Fehler aufgetreten");
    return;
  }
  // Starte Index.html
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send(SPIFFS, "/index.html", String(), false, processor);
  });
  server.on("/PM25", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", PM25Readin.c_str());
  });
  server.on("/PM10", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", PM10Readin.c_str());
  });
  server.on("/timestamp", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", timestamp.c_str());
  });
  server.on("/rssi", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", String(rssi).c_str());
  });
  server.on("/winter", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send(SPIFFS, "/winter.jpg", "image/jpg");
  });
  // Starte Server
  server.begin();

  // Initialisiere NTPClient
  timeClient.begin();
  // Zeit-Offset GMT +2 Stunden = 7200;
  timeClient.setTimeOffset(7200);
}

void loop() {
  // LoRa Pakete verfügbar?
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    getLoRaData();
    getTimeStamp();
  }
}

RAW code

HTML Code: Index.html Datei im Empfänger-Ordner "data" des LoRa WEB-Servers (SPIFFS)

<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" href="data:,">
  <title>Oberlab SDS011-Server</title>
  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
  <style>
    body {
      margin: 0;
      font-family: Arial, Helvetica, sans-serif;
      text-align: center;
    }
    header {
      margin: 0;
      padding-top: 5vh;
      padding-bottom: 5vh;
      overflow: hidden;
      background-image: url(winter);
      background-size: cover;
      color: white;
    }
    h2 {
      font-size: 2.0rem;
    }
    p { font-size: 2.0rem; }
    .units { font-size: 2.0rem; }
    .readings { font-size: 2.0rem; }
  </style>
</head>
<body>
  <header>
    <h2>Oberlab SDS011 LoRa-Server</h2>
    <p><strong>Zuletzt empfangenes Paket:<br/><span id="timestamp">%TIMESTAMP%</span></strong></p>
    <p>LoRa RSSI: <span id="rssi">%RSSI%</span></p>
  </header>
<main>
 <p> <font size=4.0">
Die Partikel-Messung bezieht sich auf Feinstaub-Partikel pro m<sup>3</sup> Luft, deren Masse aller im Gesamtstaub <br>enthaltenen Partikel einen aerodynamischen Durchmesser von 2,5µm bzw. 10µm haben.
</font>
  </p>
  <p>
     Partikel Messung 2.5: <span id="PM25" class="readings"> %PM25%</span> <span> µgr/m<sup>3</sup> </span>

  </p>
  <p>
     Partikel Messung 10: <span id="PM10" class="readings"> %PM10%</span> <span> µgr/m<sup>3</sup> </span>

  </p>

</main>
<script>
setInterval(updateValues, 10000, "PM25");
setInterval(updateValues, 10000, "PM10");
setInterval(updateValues, 10000, "rssi");
setInterval(updateValues, 10000, "timestamp");

function updateValues(value) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById(value).innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/" + value, true);
  xhttp.send();
}
</script>
</body>
</html>

RAW code index.html

LoRa-Sender

LoRa Empfänger

LoRa Serieller Monitor des Empfänger

LoRa Web-Server mit Zeitstempel, Sendeleistung und Meßwerte