Lösungen

LEDs Tran­sis­tor schalten

# define TRANSISTOR 6 

void setup()
{
  pinMode(TRANSISTOR, OUTPUT);
}

void loop()
{
  digitalWrite(TRANSISTOR, HIGH);  
  delay(1000);                             
  digitalWrite(TRANSISTOR, LOW);  
  delay(1000);                              
}

Letzte Aktualisierung: Wei­ter lesen ...

MQTT ESP32

Inhalts­ver­zeich­nis

Sen­der

#include "ArduinoMqttClient.h"

// ESP8266: NodeMCU, Wemos D1 Mini
// #include "ESP8266WiFi.h"

// ESP32
#include "WiFi.h"
#include "DHT.h"

// Pin des DHT-Sensors
int SENSOR_DHT = 4;

// DHT11
// #define SensorTyp DHT11

// DHT22
#define SensorTyp DHT22

// dht-Sensor einen Namen und Typ zuweisen
DHT dht(SENSOR_DHT, SensorTyp);

char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxx";

WiFiClient wifiClient;

// wifiClient MqttClient zuordnen
MqttClient mqttClient(wifiClient);

// RaspberryPi als Broker
// const char broker[] = "192.168.1.222";
int port = 1883;

const char broker[] = "test.mosquitto.org";

/* öffentliche Broker
const char broker[] = "public.mqtthq.com";
int port = 1883;

const char broker[] = "test.mosquitto.org";
int port = 1883;

const char broker[] = "broker.emqx.io";
const char *mqtt_username = "emqx";
const char *mqtt_password = "public";
int port = 1883;
*/

// Thema für Senden/Empfangen
const char Messdaten[] = "Messdaten";

// Thema für die "will"-Nachricht für den Versuch die Verbindung 
// neu aufzubauen
const char getrennteVerbindung[] = "getrennteVerbindung";

// Intervall zwischen den Messungen
const long Interval = 5000;
unsigned long vorherigeZeit = 0;

void setup() 
{
  Serial.begin(9600);
  while (!Serial);
  delay(1000);

  WiFi.begin(Router, Passwort);

  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(200);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("Verbunden mit ");
  Serial.println(Router);
  Serial.print("IP über DHCP: ");
  Serial.println(WiFi.localIP());

  /*
    will-Nachricht:
    wird an den Broker gesendet und versucht eine getrennte Verbindung neu aufzubauen
    Parameter:
    Thema, Länge des gesendeten Strings, Behalten der Anforderung, Qualität der Verbindung
    muss vor dem Aufbau der Verbindung zum Broker festgelegt werden
  */
  String willDaten = "getrennt";
  bool Behalten = true;
  int willQualitaetService= 2;

  // will-Nachricht senden
  mqttClient.beginWill(getrennteVerbindung, willDaten.length(), Behalten, willQualitaetService);
  mqttClient.print(getrennteVerbindung);
  mqttClient.endWill();

  Serial.println("Versuche mit dem Broker " + String(broker) + " zu verbinden ... ");

  delay(1000);

  // Verbindungsversuch
  if (!mqttClient.connect(broker, port)) 
  {
    Serial.print("Verbindung zum Broker gescheitert");

    // Programm anhalten
    while (1);
  }
  Serial.println();

  Serial.println("Mit dem Broker " + String(broker) + " verbunden!");
  Serial.println();

  // dht-Sensor starten
  dht.begin();
}

void loop() 
{
  // Broker abfragen
  mqttClient.poll();

  unsigned long aktuelleZeit = millis();

  // Intervall zwischen den Sendezeiten
  if (aktuelleZeit - vorherigeZeit >= Interval) 
  {
    // letzte Sendezeit sichern
    vorherigeZeit = aktuelleZeit;

    // gemessene Temperatur dht in String umwandeln
    String Temperatur = String(dht.readTemperature(), 1);

    // . durch , ersetzen
    Temperatur.replace(".", ",");

    // gemessene Luftfeuchtigkeit in String umwandeln
    String Luftfeuchtigkeit = String(dht.readHumidity(), 1);

    // . durch , ersetzen
    Luftfeuchtigkeit.replace(".", ",");

    // String Senden zusammenbauen / als Trennzeichen
    String Senden = Temperatur + "/" + Luftfeuchtigkeit;
    Serial.println("Nachricht gesendet:");

    // Anzeige im Seriellen Monitor: String Senden am / trennen
    int Suche = Senden.indexOf("/");

    // String bis zum /
    Temperatur = Senden.substring(0, Suche);

    // String vom ersten Zeichen hinter / bis zum Ende
    Luftfeuchtigkeit = Senden.substring(Suche + 1, Senden.length());

    // Daten im Seriellen Monitor anzeigen
    Serial.println(Temperatur + "°C");
    Serial.println(Luftfeuchtigkeit + "%");
    Serial.println("---------------------");

    // Messdaten senden
    bool Behalten = false;
    int ServiceQualitaet = 2;
    bool Duplikat = false;
    mqttClient.beginMessage(Messdaten, Senden.length(), Behalten, ServiceQualitaet, Duplikat);
    mqttClient.print(Senden);
    mqttClient.endMessage();
  }
}

Emp­fän­ger

#include "ArduinoMqttClient.h"

// ESP32
// #include "WiFi.h"

// ESP8266: NodeMCU, Wemos D1 Mini
#include "ESP8266WiFi.h"

#include "U8g2lib.h"

/*
  Typbezeichnung mit Bildschirmgröße in Pixeln
  1 = page buffer mode, F = full screen buffer mode 
  Hardware I2C/Hardware SPI
  Name des OLEDs
  Rotation R0 (keine)
*/
U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);

// Router SSID/Passwort
char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "anea1246";

WiFiClient wifiClient;
MqttClient mqttClient(wifiClient);

// RaspberryPi als Broker
// const char broker[] = "192.168.1.222";

const char broker[] = "test.mosquitto.org";
int port = 1883;

/* öffentliche Broker
const char broker[] = "public.mqtthq.com";
int port = 1883;

const char broker[] = "test.mosquitto.org";
int port = 1883;

const char broker[] = "broker.emqx.io";
const char *mqtt_username = "emqx";
const char *mqtt_password = "public";
int port = 1883;
*/

// Thema  für Senden/Empfangen
const char Messdaten[] = "Messdaten";

/*
  Qualität der Verbindung (0 .. 2)
  0 = Nachricht wird einmal versendet
      eine Überprüfung des Empfangs durch den Broker findet nicht statt
  1 = die Nachricht wird solange versendet, bis der Broker den Empfang bestätigt hat
  2 = die Nachricht wird einmal gesendet, es wird sicher gestellt, dass sie
      beim Broker angekommen ist
*/
int subscribeQoS = 2;

void setup() 
{
  Serial.begin(9600);
  while (!Serial);
  delay(1000);

  WiFi.begin(Router, Passwort);

  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(200);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Verbunden mit ");
  Serial.println(Router);
  Serial.print("IP über DHCP: ");
  Serial.println(WiFi.localIP());

  Serial.print("Versuche mit dem Broker " + String(broker) + " zu verbinden ... ");

  // Verbindung zum Broker aufbauen
  if (!mqttClient.connect(broker, port)) 
  {
    Serial.print("Verbindung zum Broker gescheitert");

    // Programm anhalten
    while (1);
  }
  Serial.println();

  Serial.println("Mit dem Broker " + String(broker) + " verbunden!");
  Serial.println();

  // den Rückruf für den Nachrichtenempfang festlegen
  mqttClient.onMessage(empfangeneNachricht);

  // in das Thema Messdaten "einschreiben"
  mqttClient.subscribe(Messdaten, subscribeQoS);

  // OLED starten
  oled.begin();

  // Kontrast maximal 255
  oled.setContrast(200);
  oled.setFont(u8g2_font_helvR24_tf);

  // Zeichenfarbe weiß
  oled.setDrawColor(1);

  // horizontale Schrift
  oled.setFontDirection(0);
}

void loop() 
{
  // Broker abfragen
  mqttClient.poll();
}

void empfangeneNachricht(int NachrichtGroesse) 
{
  Serial.println("Nachricht empfangen: ");

  // Thema der Nachricht empfangen und anzeigen
  String Nachricht = mqttClient.messageTopic();
  Serial.println(Nachricht + " ");

  // Nachricht als String lesen
  String EmpfangeneNachricht = mqttClient.readString();

  // String Anzeige am / trennen
  int Suche = EmpfangeneNachricht.indexOf("/");
  String Temperatur = EmpfangeneNachricht.substring(0, Suche);
  String Luftfeuchtigkeit = EmpfangeneNachricht.substring(Suche + 1, EmpfangeneNachricht.length());

  // Anzeige im Seriellen Monitor
  Serial.println(Temperatur + "°C");
  Serial.println(Luftfeuchtigkeit + "%");
  Serial.println("---------------------");
  Serial.println();

  // Anzeige OLED
  oled.clearDisplay();
  oled.firstPage();

  do 
  {
    oled.setCursor(2, 30);
    oled.print(Temperatur);

    // Grad-Zeichen
    oled.print((char)176);
    oled.print("C");
    oled.setCursor(2, 60);
    oled.print(Luftfeuchtigkeit + "%");

  } 
  while (oled.nextPage());
}
Wei­ter lesen ...

BME680 Dar­stel­lung LCD und Web

Inhalts­ver­zeich­nis

Dar­stel­lung auf LCD

#include "bsec.h"
#include "LCDIC2.h"

// 4-zeiliges LCD
LCDIC2 lcd(0x27, 20, 4);

// Objekt (iaqSensor) der Klasse Bsec definieren
Bsec iaqSensor;

void setup() 
{
  Serial.begin(9600);

  // auf Serielle Verbindung warten
  while (!Serial);
  delay(1000);
  
  // LCD starten
  lcd.begin();

  // Cursor "verstecken"
  lcd.setCursor(false);

  // Hex-Adresse des BME680
  // BME68X_I2C_ADDR_HIGH = 0x77 (Standard)
  // BME68X_I2C_ADDR_LOW = 0x76 (Verbindung SDO zu GND)
  iaqSensor.begin(BME68X_I2C_ADDR_HIGH, Wire);

  // Array der verfügbaren Sensoren
  bsec_virtual_sensor_t sensorList[13] = 
  {
    BSEC_OUTPUT_IAQ,
    BSEC_OUTPUT_STATIC_IAQ,
    BSEC_OUTPUT_CO2_EQUIVALENT,
    BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
    BSEC_OUTPUT_RAW_TEMPERATURE,
    BSEC_OUTPUT_RAW_PRESSURE,
    BSEC_OUTPUT_RAW_HUMIDITY,
    BSEC_OUTPUT_RAW_GAS,
    BSEC_OUTPUT_STABILIZATION_STATUS,
    BSEC_OUTPUT_RUN_IN_STATUS,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
    BSEC_OUTPUT_GAS_PERCENTAGE
  };

  // BSEC_SAMPLE_RATE_ULP: Ultra Low Powermode -> Messung alle 5 Minuten
  // BSEC_SAMPLE_RATE_LP: Low Powermode -> Messung alle 3 Sekunden
  iaqSensor.updateSubscription(sensorList, 13, BSEC_SAMPLE_RATE_LP);
}

void loop() 
{
  // wenn der Sensor arbeitet ...
  if (iaqSensor.run()) 
  {
    // Messwerte ermitteln, in Strings umwandeln, . durch , ersetzen
    String Temperatur = String(iaqSensor.temperature);
    Temperatur.replace(".", ",");

    String Luftfeuchtigkeit = String(iaqSensor.humidity);
    Luftfeuchtigkeit.replace(".", ",");

    String Luftdruck = String(iaqSensor.pressure / 100);
    Luftdruck.replace(".", ",");

    String IAQ = String(iaqSensor.iaq);
    IAQ.replace(".", ",");

    String StatischerIAQ = String(iaqSensor.staticIaq);
    StatischerIAQ.replace(".", ",");
    
    String CO2 = String(iaqSensor.co2Equivalent);
    CO2.replace(".", ",");

    String VOC = String(iaqSensor.breathVocEquivalent);
    VOC.replace(".", ",");

    String GasInProzent = String(iaqSensor.gasPercentage);
    GasInProzent.replace(".", ",");

    String WiderstandMOXSensor = String(iaqSensor.gasResistance / 1000);
    WiderstandMOXSensor.replace(".", ",");

    // Ausgabe Serieller Monitor
    Serial.println("Statusmeldungen:");
    Serial.println("-----------------------------");
    Serial.println("Sensor bereit (0-1): " + String(int(iaqSensor.runInStatus)));
    Serial.println("Genauigkeit IAQ (0-3): " + String(int(iaqSensor.iaqAccuracy)));
    Serial.println("-----------------------------");
    Serial.println("Messwerte:");
    Serial.println("-----------------------------");
    Serial.println("Temperatur: " + Temperatur + " °C");
    Serial.println("Feuchtigkeit: " + Luftfeuchtigkeit + " %");
    Serial.println("Luftdruck: " + Luftdruck + " hPa");
    Serial.println("IAQ: " + IAQ);
    Serial.println("Statischer IAQ: " + StatischerIAQ);
    Serial.println("Schätzung CO2: " + CO2 + " ppm");
    Serial.println("Gas (0-100): " + GasInProzent + " %");
    Serial.println("Widerstandswert MOX-Sensor: " + WiderstandMOXSensor + " kOhm");
    Serial.println("VOC: " + VOC);
    Serial.println("-----------------------------");

    // Ausgabe LCD
    lcd.setCursor(0, 0);
    lcd.print("Temperatur: " + Temperatur + "\337C");
    lcd.setCursor(0, 1);
    lcd.print("Feuchtigkeit: " + Luftfeuchtigkeit + "%");
    lcd.setCursor(0, 2);
    lcd.print("IAQ: " + IAQ);
    lcd.setCursor(0, 3);
    lcd.print("CO2: " + CO2 + " ppm");
  }
}

Dar­stel­lung im Web

#include "bsec.h"
#include "WiFi.h"
#include "WebServer.h"
#include "time.h"

// Objekt (iaqSensor) der Klasse Bsec definieren
Bsec iaqSensor;

char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

// ip und gateway müssen an das lokale Netz angepasst werden
IPAddress ip(192, 168, 1, 100);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

/*
  öffentliche DNS-Server
  -----------------------------------------------
  OpenDNS 208, 67, 222, 222 (USA)
  Google 8, 8, 8, 8 (USA)
  Cloudfare 1, 1, 1, 1 (USA)
  DNSWWatch 84, 200, 69, 80 (Deutschland)
  Quad9 9, 9, 9, 9 (Schweiz)
  Neustar UltraDNS 56, 154, 70, 3 (USA, gefiltert)
  Deutsche Telekom 217, 5,100, 185
  ------------------------------------------------
  oder die im Router eingetragene IP
  im Beispiel: 192, 168, 1, 20
*/
IPAddress primaryDNS(192, 168, 1, 20);
IPAddress secondaryDNS(9, 9, 9, 9);

// NTP-Server aus dem Pool
#define Zeitserver "de.pool.ntp.org"

/*
  Liste der Zeitzonen
  https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  Zeitzone CET = Central European Time -1 -> 1 Stunde zurück
  CEST = Central European Summer Time von
  M3 = März, 5.0 = Sonntag 5. Woche, 02 = 2 Uhr
  bis M10 = Oktober, 5.0 = Sonntag 5. Woche 03 = 3 Uhr
*/
#define Zeitzone "CET-1CEST,M3.5.0/02,M10.5.0/03"

// time_t enthält die Anzahl der Sekunden seit dem 1.1.1970 0 Uhr
time_t aktuelleZeit;

/* 
  Struktur tm
  tm_hour -> Stunde: 0 bis 23
  tm_min -> Minuten: 0 bis 59
  tm_sec -> Sekunden 0 bis 59
  tm_mday -> Tag 1 bis 31
  tm_wday -> Wochentag (0 = Sonntag, 6 = Samstag)
  tm_mon -> Monat: 0 (Januar) bis 11 (Dezember)
  tm_year -> Jahre seit 1900
  tm_yday -> vergangene Tage seit 1. Januar des Jahres
  tm_isdst -> Wert > 0 = Sommerzeit (dst = daylight saving time)
*/
tm Zeit;

WebServer server(80);

// benötigte Strings
String Nachricht;
String Temperatur;
String Luftfeuchtigkeit;
String Luftdruck;
String CO2;
String IAQ;
String StatischerIAQ;

void setup() 
{
  // Zeitzone: Parameter für die zu ermittelnde Zeit
  configTzTime(Zeitzone, Zeitserver);

  // localtime_r -> Zeit in die lokale Zeitzone setzen
  localtime_r(&aktuelleZeit, &Zeit);
  Serial.begin(9600);

  // auf Serielle Verbindung warten
  while (!Serial);
  delay(1000);

  // WiFi starten
  WiFi.begin(Router, Passwort);

  WiFi.config(ip, gateway, subnet, primaryDNS, secondaryDNS);
  Serial.print("Verbunden mit ");
  Serial.println(Router);

  // IP anzeigen
  Serial.print("Statische IP: ");
  Serial.println(ip);

  server.begin();
  server.on("/", handleRoot);

  // Hex-Adresse des BME680
  // BME68X_I2C_ADDR_HIGH = 0x77
  // BME68X_I2C_ADDR_LOW = 0x76
  iaqSensor.begin(BME68X_I2C_ADDR_HIGH, Wire);

  // Array der verfügbaren Sensoren
  bsec_virtual_sensor_t sensorList[13] = 
  {
    BSEC_OUTPUT_IAQ,
    BSEC_OUTPUT_STATIC_IAQ,
    BSEC_OUTPUT_CO2_EQUIVALENT,
    BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
    BSEC_OUTPUT_RAW_TEMPERATURE,
    BSEC_OUTPUT_RAW_PRESSURE,
    BSEC_OUTPUT_RAW_HUMIDITY,
    BSEC_OUTPUT_RAW_GAS,
    BSEC_OUTPUT_STABILIZATION_STATUS,
    BSEC_OUTPUT_RUN_IN_STATUS,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
    BSEC_OUTPUT_GAS_PERCENTAGE
  };

  // BSEC_SAMPLE_RATE_ULP: Ultra Low Powermode -> Messung alle 5 Minuten
  // BSEC_SAMPLE_RATE_LP: Low Powermode -> Messung alle 3 Sekunden
  iaqSensor.updateSubscription(sensorList, 13, BSEC_SAMPLE_RATE_LP);
}

void loop() 
{
  // wenn der Sensor arbeitet ...
  if (iaqSensor.run()) 
  {
    // aktuelle Zeit holen
    time(&aktuelleZeit);

    // localtime_r -> Zeit in die lokale Zeitzone setzen
    localtime_r(&aktuelleZeit, &Zeit);

    // es kann bis zu 30 Sekunden dauern
    // bis die Zeit ermittelt wird
    // Name des Wochentages 0-6
    switch (Zeit.tm_wday) {
      case 0:
        Serial.print("Sonntag");
        break;
      case 1:
        Serial.print("Montag");
        break;
      case 2:
        Serial.print("Dienstag");
        break;
      case 3:
        Serial.print("Mittwoch");
        break;
      case 4:
        Serial.print("Donnerstag");
        break;
      case 5:
        Serial.print("Freitag");
        break;
      case 6:
        Serial.print("Samstag");
        break;
    }

    Serial.print(",");
    if (Zeit.tm_mday < 10) Serial.print("0");
    Serial.print(Zeit.tm_mday);
    Serial.print(".");

    // Monat: führende 0 ergänzen
    if (Zeit.tm_mon < 10) Serial.print("0");

    // Zählung beginnt mit 0 -> + 1
    Serial.print(Zeit.tm_mon + 1);
    Serial.print(".");

    // Anzahl Jahre seit 1900
    Serial.print(Zeit.tm_year + 1900);
    Serial.print(" ");

    // Stunde: wenn Stunde  10 -> 0 davor setzen
    if (Zeit.tm_hour < 10) Serial.print("0");
    Serial.print(Zeit.tm_hour);
    Serial.print(":");

    // Minuten
    if (Zeit.tm_min < 10) Serial.print("0"); 
    Serial.println(Zeit.tm_min);

    server.handleClient();

    // Messwerte ermitteln, in Strings umwandeln, . durch , ersetzen
    Temperatur = String(iaqSensor.temperature);
    Temperatur.replace(".", ",");

    Luftfeuchtigkeit = String(iaqSensor.humidity);
    Luftfeuchtigkeit.replace(".", ",");

    Luftdruck = String(iaqSensor.pressure / 100);
    Luftdruck.replace(".", ",");

    IAQ = String(iaqSensor.iaq);
    IAQ.replace(".", ",");

    StatischerIAQ = String(iaqSensor.staticIaq);
    StatischerIAQ.replace(".", ",");

    CO2 = String(iaqSensor.co2Equivalent);
    CO2.replace(".", ",");

    String VOC = String(iaqSensor.breathVocEquivalent);
    VOC.replace(".", ",");

    String GasInProzent = String(iaqSensor.gasPercentage);
    GasInProzent.replace(".", ",");

    String WiderstandMOXSensor = String(iaqSensor.gasResistance / 1000);
    WiderstandMOXSensor.replace(".", ",");

    // Ausgabe Serieller Monitor
    Serial.println("Statusmeldungen:");
    Serial.println("-----------------------------");
    Serial.println("Sensor bereit (0-1): " + String(int(iaqSensor.runInStatus)));
    Serial.println("Genauigkeit IAQ (0-3): " + String(int(iaqSensor.iaqAccuracy)));
    Serial.println("-----------------------------");
    Serial.println("Messwerte:");
    Serial.println("-----------------------------");
    Serial.println("Temperatur: " + Temperatur + " °C");
    Serial.println("Feuchtigkeit: " + Luftfeuchtigkeit + " %");
    Serial.println("Luftdruck: " + Luftdruck + " hPa");
    Serial.println("IAQ: " + IAQ);
    Serial.println("Statischer IAQ: " + StatischerIAQ);
    Serial.println("Schätzung CO2: " + CO2 + " ppm");
    Serial.println("Gas (0-100): " + GasInProzent + " %");
    Serial.println("Widerstandswert MOX-Sensor: " + WiderstandMOXSensor + " kOhm");
    Serial.println("VOC: " + VOC);
    Serial.println("-----------------------------");
  }
}

void handleRoot() 
{
  // Seite zusammenbauen
  // Kopf der HTML-Seite: aktualisierung alle 60 Sekunden
  // kann angepasst werden
  Nachricht = "<head><meta http-equiv=\"refresh\" content=\"60\"></head>";
  Nachricht += "<h1>Messwerte BME680</h1><hr>";

  // Datum anzeigen
  // formatieren: Schrift 14pt, ohne Serifen, Zeilenhöhe
  Nachricht += "<div style = \"font-size:14pt; font-family:sans-serif; line-height:1.8em\">";
  Nachricht += "Letzte Aktualisierung: ";

  // wenn der Tag < 10
  if (Zeit.tm_mday < 10) Nachricht += "0";
  Nachricht += String(Zeit.tm_mday) + ".";

  // wen der Monat < 10, Zählung beginnt mit 0
  if ((Zeit.tm_mon + 1) < 10) Nachricht += "0";
  Nachricht += String(Zeit.tm_mon + 1) + ". ";

  // Zeit anzeigen
  // wenn die Stunde < 10
  if (Zeit.tm_hour < 10) Nachricht += "0";
  Nachricht += String(Zeit.tm_hour) + ":";

  // wenn die Minute < 10
  if (Zeit.tm_min < 10) Nachricht += "0";
  Nachricht+= String(Zeit.tm_min) + " Uhr<br><hr>";
  
  Nachricht += "Temperatur: " + Temperatur + " &degC<br>";
  Nachricht += "Luftfeuchtigkeit: " + Luftfeuchtigkeit + " %<br>";
  Nachricht += "Luftdruck: " + Luftdruck + " hPa<br>";
  Nachricht += "IAQ: " + IAQ + "<br>";
  Nachricht += "Statischer IAQ: " + StatischerIAQ + "<br>";
  Nachricht += "Sch&auml;tzung CO2: " + CO2 + " ppm<br>";
  Nachricht += "Genauigkeit IAQ (0-3): " + String(int(iaqSensor.iaqAccuracy)) + "</div>";

  // Button aktualisieren
  Nachricht += "<hr><input style=\"font-size:16pt; font-weight:bold;";
  Nachricht += "background-color:#55A96B;";
  Nachricht += "display:block; cursor:pointer;\"type=\"button\"";

  // IP für den Button aktualisieren (location.href)
  // muss mit dem Wert für IPAdress übereinstimmen (. statt ,)
  Nachricht += " onClick=\"location.href='http://192.168.1.100'\" value=\"aktualisieren\">";
  Nachricht += "<hr>";

  // Nachricht senden -> Seite anzeigen
  server.send(200, "text/html", Nachricht);
}

Letzte Aktualisierung: Wei­ter lesen ...

BME280 - Mess­da­ten anzeigen

#include "Adafruit_BME280.h"
#include "LCDIC2.h"

// 4-zeiliges LCD
LCDIC2 lcd(0x27, 20, 4);

#define MeeresHoehe (1013.25)

// Name des BME280
Adafruit_BME280 bme; 

void setup() 
{
  Serial.begin(9600);

  // auf Serielle Verbindung warten
  while (!Serial);
  delay(1000);

  // BME280 starten, bei Misserfolg Meldung anzeigen
  if (!bme.begin()) Serial.println("BME280 nicht verbunden");

  // LCD starten
  lcd.begin();

  // Cursor "verstecken"
  lcd.setCursor(false);
}

void loop() 
{
  /*
    Daten erfassen
    die Daten liegen als Zahlen im Format float vor
    für die weitere Verarbeitung werden sie direkt in eine String umgewandelt
  */
  String Temperatur = String(bme.readTemperature());
  String Luftfeuchtigkeit = String(bme.readHumidity());
  String ungefaehreHoehe = String(bme.readAltitude(MeeresHoehe));
  String Luftdruck = String(bme.readPressure() / 100.0); 

  // float verwendet den . als Dezimaltrennzeichen
  // . mit replace durch , ersetzen
  Temperatur.replace(".", ",");
  Luftdruck.replace(".", ",");
  Luftfeuchtigkeit.replace(".", ",");
  ungefaehreHoehe.replace(".", ",");

  // Daten im Serieller Monitor anzeigen
  Serial.print("Temperatur: ");
  Serial.println(Temperatur + " °C");
  Serial.print("Luftdruck: ");
  Serial.println(Luftdruck + " hPa");
  Serial.print("Luftfeuchtigkeit: ");
  Serial.println(Luftfeuchtigkeit + " %");
  Serial.print("ungefähre Höhe: ");
  Serial.println(ungefaehreHoehe + " m");
  Serial.println("--------------------------");

  // Anzeige LCD \337C = °
  lcd.setCursor(0, 0);
  lcd.print(Temperatur + " \337C");
  lcd.setCursor(0, 1);
  lcd.print(Luftdruck + " hPa");
  lcd.setCursor(0, 2);
  lcd.print(Luftfeuchtigkeit + " %");
  lcd.setCursor(0, 3);
  lcd.print(ungefaehreHoehe + " m");
  delay(5000);
}

Letzte Aktualisierung: Wei­ter lesen ...

Zeit OLED anzei­gen ESP

// ESP32-Wroom
#include "WiFi.h"

// NodeMCU/Wemos D1 Mini
// #include "ESP8266WiFi.h"

#include "time.h"
#include "U8g2lib.h"

// OLED initialisieren
U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);

char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

// NTP-Server aus dem Pool
#define Zeitserver "de.pool.ntp.org"

/*
  Liste der Zeitzonen
  https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  Zeitzone CET = Central European Time -1 -> 1 Stunde zurück
  CEST = Central European Summer Time von
  M3 = März, 5.0 = Sonntag 5. Woche, 02 = 2 Uhr
  bis M10 = Oktober, 5.0 = Sonntag 5. Woche 03 = 3 Uhr
*/
#define Zeitzone "CET-1CEST,M3.5.0/02,M10.5.0/03"

// time_t enthält die Anzahl der Sekunden seit dem 1.1.1970 0 Uhr
time_t aktuelleZeit;

/* 
  Struktur tm
  tm_hour -> Stunde: 0 bis 23
  tm_min -> Minuten: 0 bis 59
  tm_sec -> Sekunden 0 bis 59
  tm_mday -> Tag 1 bis 31
  tm_wday -> Wochentag (0 = Sonntag, 6 = Samstag)
  tm_mon -> Monat: 0 (Januar) bis 11 (Dezember)
  tm_year -> Jahre seit 1900
  tm_yday -> vergangene Tage seit 1. Januar des Jahres
  tm_isdst -> Wert > 0 = Sommerzeit (dst = daylight saving time)
*/
tm Zeit;

// Zeit bis zur nächsten Messung
static unsigned long GesicherteStartZeit = 0;
unsigned long Startzeit;

// Sekunden Intervall, kann angepasst werden
int Intervall = 10000;

void setup() 
{
  Serial.begin(9600);

  // Parameter für die zu ermittelnde Zeit
  configTzTime(Zeitzone, Zeitserver);

  WiFi.begin(Router, Passwort);

  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(200);
    Serial.print(".");
  }

  // SSID des Routers anzeigen
  Serial.println();
  Serial.print("Verbunden mit ");
  Serial.println(WiFi.SSID());

  // IP anzeigen
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());

  // OLED starten
  oled.begin();
}

void loop() 
{
  // Startzeit setzen
  Startzeit = millis();

  // wenn das festgelegte Intervall erreicht ist
  if (Startzeit - GesicherteStartZeit > Intervall) 
  {
    ZeitAnzeigen();

    // Startzeit zurücksetzen
    GesicherteStartZeit = Startzeit;
  }
}

void ZeitAnzeigen() 
{
  // aktuelle Zeit lesen
  time(&aktuelleZeit);

  // localtime_r -> Zeit in die lokale Zeitzone setzen
  localtime_r(&aktuelleZeit, &Zeit);
  oled.clearDisplay();

  // Zeichenfarbe weiß
  oled.setDrawColor(1);

  // horizontale Schrift
  oled.setFontDirection(0);
  oled.firstPage();

  do 
  {
    // Wochentag anzeigen
    oled.setCursor(2, 15);
    oled.setFont(u8g2_font_helvB12_tf);
    switch (Zeit.tm_wday) {
      case 0:
        oled.print("Sonntag ");
        break;

      case 1:
        oled.print("Montag ");
        break;

      case 2:
        oled.print("Dienstag ");
        break;

      case 3:
        oled.print("Mittwoch ");
        break;

      case 4:
        oled.print("Donnerstag ");
        break;

      case 5:
        oled.print("Freitag ");
        break;

      case 6:
        oled.print("Samstag ");
        break;
    }

    // Datum anzegen
    oled.setCursor(2, 33);

    // Tag: führende 0 ergänzen
    if (Zeit.tm_mday < 10) oled.print("0");
    oled.print(Zeit.tm_mday);
    oled.print(".");

    // Monat: führende 0 ergänzen
    if (Zeit.tm_mon < 10) oled.print("0");
    oled.print(Zeit.tm_mon + 1);
    oled.print(".");

    // Anzahl Jahre seit 1900
    oled.print(Zeit.tm_year + 1900);

    // horizontale Linie
    oled.drawHLine(1, 36, oled.getDisplayWidth());

    // Zeit anzeigen
    oled.setFont(u8g2_font_helvR24_tf);
    oled.setCursor(2, 64);

    if (Zeit.tm_hour < 10) oled.print("0");
    oled.print(Zeit.tm_hour);
    oled.print(":");

    if (Zeit.tm_min < 10) oled.print("0");
    oled.print(Zeit.tm_min);
  } 
  while (oled.nextPage());

  // Serielle Ausgabe mit Namen des Wochentages
  switch (Zeit.tm_wday) 
  {
    case 0:
      Serial.print("Sonntag ");
      break;

    case 1:
      Serial.print("Montag ");
      break;

    case 2:
      Serial.print("Dienstag ");
      break;

    case 3:
      Serial.print("Mittwoch ");
      break;

    case 4:
      Serial.print("Donnerstag ");
      break;

    case 5:
      Serial.print("Freitag ");
      break;

    case 6:
      Serial.print("Samstag ");
      break;
  }

  // Tag: führende 0 ergänzen
  if (Zeit.tm_mday < 10) Serial.print("0");
  Serial.print(Zeit.tm_mday);
  Serial.print(".");

  // Monat: führende 0 ergänzen
  if (Zeit.tm_mon < 10) Serial.print("0");
  Serial.print(Zeit.tm_mon + 1);
  Serial.print(".");

  // Anzahl Jahre seit 1900
  Serial.print(Zeit.tm_year + 1900);
  Serial.print(" ");

  if (Zeit.tm_hour < 10) Serial.print("0");
  Serial.print(Zeit.tm_hour);
  Serial.print(":");

  if (Zeit.tm_min < 10) Serial.print("0");
  Serial.print(Zeit.tm_min);
  Serial.print(":");
  if (Zeit.tm_sec < 10) Serial.print("0");
  Serial.print(Zeit.tm_sec);
  Serial.println();
  Serial.print("Tage seit 1. Januar: ");
  Serial.print(Zeit.tm_yday);
  Serial.println();

  // Normalzeit/Sommerzeit
  if(Zeit.tm_isdst > 0) Serial.println("MESZ = Mitteleuropäische Sommerzeit");
  else Serial.println("MEZ = Mitteleuropäische Zeit");
}

Letzte Aktualisierung: Wei­ter lesen ...

Tem­pe­ra­tur­an­zei­ge mit 20-LED-Neopixel-Stick

Inhalts­ver­zeich­nis

BMP280

# include "Adafruit_BMP280.h"
# include "Adafruit_NeoPixel.h"
# define RING 4

// Anzahl der LEDs → muss angepasst werden
# define AnzahlLED 20

// LEDRing -> Name des LED-Rings
Adafruit_NeoPixel LEDRing(AnzahlLED, RING, NEO_GRB + NEO_KHZ800);

// Name des Sensor
Adafruit_BMP280 bmp;

void setup()
{
  Serial.begin(9600);

  // BMP280 starten
  if (!bmp.begin()) Serial.println("BMP280 gestartet!");

    // setBrightness(0..255)
  LEDRing.setBrightness(200);

  // NeoPixel Bibliothek initialisieren
  LEDRing.begin();
}

void loop() 
{
  float gemesseneTemperatur = bmp.readTemperature();

  // gelesene Temperatur in String umwandeln
  String Temperatur = String(gemesseneTemperatur);

  // . durch , ersetzen
  Temperatur.replace(".", ",");

  // Ausgabe Serieller Monitor
  Serial.println("Temperatur: " + Temperatur + "°C");
  Serial.println("--------------------------------");
  
    // alle LEDs aus
  LEDRing.clear();

  /*
    es können nur ganzzahlige Werte berücksichtigt werden
    es sollen entsprechend der Skala die LEDs leuchten
    der Wert vor dem Komma entscheidet über die Anzahl der LEDs
  */
  if (gemesseneTemperatur >= 10 && gemesseneTemperatur < 11)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 1);
  if (gemesseneTemperatur >= 11 && gemesseneTemperatur < 12)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 2);
  if (gemesseneTemperatur >= 12 && gemesseneTemperatur < 13)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 3);
  if (gemesseneTemperatur >= 13 && gemesseneTemperatur < 14)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 4);
  if (gemesseneTemperatur >= 14 && gemesseneTemperatur < 15)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 5);
  if (gemesseneTemperatur >= 15 && gemesseneTemperatur < 16)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 6);
  if (gemesseneTemperatur >= 16 && gemesseneTemperatur < 17)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 7);
  if (gemesseneTemperatur >= 17 && gemesseneTemperatur < 18)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 8);
  if (gemesseneTemperatur >= 18 && gemesseneTemperatur < 19)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 9);
  if (gemesseneTemperatur >= 19 && gemesseneTemperatur < 20)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 10);
  if (gemesseneTemperatur >= 20 && gemesseneTemperatur < 21)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 11);
  if (gemesseneTemperatur >= 21 && gemesseneTemperatur < 22)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 12);
  if (gemesseneTemperatur >= 22 && gemesseneTemperatur < 23)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 13);
  if (gemesseneTemperatur >= 23 && gemesseneTemperatur < 24)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 14);
  if (gemesseneTemperatur >= 24 && gemesseneTemperatur < 25)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 15);
  if (gemesseneTemperatur >= 25 && gemesseneTemperatur < 26)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 16);
  if (gemesseneTemperatur >= 26 && gemesseneTemperatur < 27)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 17);
  if (gemesseneTemperatur >= 27 && gemesseneTemperatur < 28)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 18);
  if (gemesseneTemperatur >= 28 && gemesseneTemperatur < 29)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 19);
  if (gemesseneTemperatur >= 29 && gemesseneTemperatur < 30)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 20);
  LEDRing.show();

  delay(2000);  
}

DHT 11/DHT22

# include "DHT.h"
# include "Adafruit_NeoPixel.h"

# define RING 4

// Anzahl der LEDs → muss angepasst werden
# define AnzahlLED 20

// LEDRing -> Name des LED-Rings
Adafruit_NeoPixel LEDRing(AnzahlLED, RING, NEO_GRB + NEO_KHZ800);

// Pin des DHT-Sensors
# define SENSOR_DHT 7

// Sensortyp festlegen
// DHT22 oder DHT11
# define SensorTyp DHT22

// Sensor DHT einen Namen zuweisen
DHT dht(SENSOR_DHT, SensorTyp);

void setup()
{
  Serial.begin(9600);
  while (!Serial) {;}
  delay(1000);

  // DHT starten
  dht.begin();

  // setBrightness(0..255)
  LEDRing.setBrightness(200);

  // NeoPixel Bibliothek initialisieren
  LEDRing.begin();
}

void loop() 
{
  // Temperatur lesen
  float gemesseneTemperatur = dht.readTemperature();

  // gelesene Temperatur in String umwandeln
  String Temperatur = String(gemesseneTemperatur);

  // . durch , ersetzen
  Temperatur.replace(".", ",");

  // Ausgabe Serieller Monitor
  Serial.println("Temperatur: " + Temperatur + "°C");
  Serial.println("--------------------------------");

  // alle LEDs aus
  LEDRing.clear();

  /*
    es können nur ganzzahlige Werte berücksichtigt werden
    es sollen entsprechend der Skala die LEDs leuchten
    der Wert vor dem Komma entscheidet über die Anzahl der LEDs
  */
  if (gemesseneTemperatur >= 10 && gemesseneTemperatur < 11)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 1);
  if (gemesseneTemperatur >= 11 && gemesseneTemperatur < 12)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 2);
  if (gemesseneTemperatur >= 12 && gemesseneTemperatur < 13)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 3);
  if (gemesseneTemperatur >= 13 && gemesseneTemperatur < 14)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 4);
  if (gemesseneTemperatur >= 14 && gemesseneTemperatur < 15)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 5);
  if (gemesseneTemperatur >= 15 && gemesseneTemperatur < 16)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 6);
  if (gemesseneTemperatur >= 16 && gemesseneTemperatur < 17)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 7);
  if (gemesseneTemperatur >= 17 && gemesseneTemperatur < 18)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 8);
  if (gemesseneTemperatur >= 18 && gemesseneTemperatur < 19)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 9);
  if (gemesseneTemperatur >= 19 && gemesseneTemperatur < 20)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 10);
  if (gemesseneTemperatur >= 20 && gemesseneTemperatur < 21)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 11);
  if (gemesseneTemperatur >= 21 && gemesseneTemperatur < 22)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 12);
  if (gemesseneTemperatur >= 22 && gemesseneTemperatur < 23)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 13);
  if (gemesseneTemperatur >= 23 && gemesseneTemperatur < 24)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 14);
  if (gemesseneTemperatur >= 24 && gemesseneTemperatur < 25)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 15);
  if (gemesseneTemperatur >= 25 && gemesseneTemperatur < 26)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 16);
  if (gemesseneTemperatur >= 26 && gemesseneTemperatur < 27)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 17);
  if (gemesseneTemperatur >= 27 && gemesseneTemperatur < 28)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 18);
  if (gemesseneTemperatur >= 28 && gemesseneTemperatur < 29)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 19);
  if (gemesseneTemperatur >= 29 && gemesseneTemperatur < 30)  LEDRing.fill(LEDRing.Color(0, 0, 255), 0, 20);

  LEDRing.show();

  delay(2000);  
}

Letzte Aktualisierung: Wei­ter lesen ...

Tem­pe­ra­tur Sen­sor SHT Seri­el­ler Monitor

Inhalts­ver­zeich­nis

SHT20/SHT21 Ardui­no UNO

#include "Wire.h"
#include "SHT2x.h"

// sht Name zuordnen
SHT2x sht;

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);
  Wire.begin();
  
  // sht-Sensor startem
  if(sht.begin()) Serial.println("Sensor gestartet");
  else Serial.println("Sensor nicht gefunden!");
}


void loop() 
{
  // Sensor lesen
  sht.read();

  // Daten im Seriellen Monitor anzeigen
  // gelesene Temperatur in String mit 2 Nachkommastellen umwandeln
  String gemesseneTemperatur = String(sht.getTemperature(), 1);

  // . durch , ersetzen
  gemesseneTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.println("Temperatur: " + gemesseneTemperatur + "°C");

  // gelesene Luftfeuchtigkeit in String mit 2 Nachkommastellen umwandeln
  String gemesseneLuftfeuchtigkeit = String(sht.getHumidity(), 1);

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeit.replace(".", ",");

  // Luftfeuchtigkeit anzeigen
  Serial.println("Luftfeuchtigkeit: " + gemesseneLuftfeuchtigkeit + "%");

  Serial.println("------------------------");

  delay(2000);
}

SHT20 ESP32-Wroom

#include "SHT2x.h"

// ESP32 I2C-Pins
#define SDA 21
#define SCL 22

// sht Wire zuordnen
SHT2x sht(&Wire);

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  // Wire mit den Parametern für I2C starten
  Wire.begin(SDA, SCL);

  // sht-Sensor startem
  if(sht.begin()) Serial.println("Sensor gestartet");
  else Serial.println("Sensor nicht gefunden!");
}

void loop() 
{
  // Sensor lesen
  sht.read();

  // Daten im Seriellen Monitor anzeigen
  // gelesene Temperatur in String mit 2 Nachkommastellen umwandeln
  String gemesseneTemperatur = String(sht.getTemperature(), 1);

  // . durch , ersetzen
  gemesseneTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.println("Temperatur: " + gemesseneTemperatur + "°C");

  // gelesene Luftfeuchtigkeit in String mit 2 Nachkommastellen umwandeln
  String gemesseneLuftfeuchtigkeit = String(sht.getHumidity(), 1);

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeit.replace(".", ",");

  // Luftfeuchtigkeit anzeigen
  Serial.println("Luftfeuchtigkeit: " + gemesseneLuftfeuchtigkeit + "%");

  Serial.println("------------------------");

  delay(2000);
}

SHT40

#include "Adafruit_SHT4x.h"

// Name des Sensors (sht4)
Adafruit_SHT4x sht4 = Adafruit_SHT4x();

void setup() 
{
  Serial.begin(9600);

  // auf den Begin der Seriellen Kommunikation warten
  while (!Serial); 
  delay(1000);

  Serial.println("SHT40 Test");
  if (!sht4.begin()) 
  {
    Serial.println("Sensor SHT40 nicht gefunden");

    // Programm in Endlosschleife
    while (1) delay(1);
  }
  Serial.println("Sensor gefunden!");

  // Genauigkeit bestimmen
  sht4.setPrecision(SHT4X_HIGH_PRECISION);
  switch (sht4.getPrecision()) 
  {
     case SHT4X_HIGH_PRECISION: 
       Serial.println("Hohe Genauigkeit");
       break;
     case SHT4X_MED_PRECISION: 
       Serial.println("Mittlere Genauigkeit");
       break;
     case SHT4X_LOW_PRECISION: 
       Serial.println("Niedrige Genauigkeit");
       break;
  }
}

void loop() 
{
  // Sensorwerte erfassen (Luftfeuchtigkeit, Temperatur)
  sensors_event_t Luftfeuchtigkeit, Temperatur;
  
  // neue Messdaten holen
  sht4.getEvent(&Luftfeuchtigkeit, &Temperatur);

  // gemessene Temperatur in String umwandeln
  String gemesseneTemperatur = String(Temperatur.temperature);

  // . durch , ersetzen
  gemesseneTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.println("Temperatur: " + gemesseneTemperatur + "°C");

  // gemessene Luftfeuchtigkeit in String umwandeln
  String gemesseneLuftfeuchtigkeit = String(Luftfeuchtigkeit.relative_humidity);

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeit.replace(".", ",");

  // Luftfeuchtigkeit anzeigen
  Serial.println("Luftfeuchtigkeit: " + gemesseneLuftfeuchtigkeit + "%");

  Serial.println("------------------------");
  delay(2000);
}

Letzte Aktualisierung: Wei­ter lesen ...

ESP32-Wroom: Tem­pe­ra­tur­an­zei­ge LCD/Serieller Monitor

Inhalts­ver­zeich­nis

SHT20/DHT11/DHT22 Seri­el­ler Monitor

#include "WiFi.h"
#include "time.h"
#include "SHT2x.h"

char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

// NTP-Server aus dem Pool
#define Zeitserver "de.pool.ntp.org"

/*
  Liste der Zeitzonen
  https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  Zeitzone CET = Central European Time -1 -> 1 Stunde zurück
  CEST = Central European Summer Time von
  M3 = März, 5.0 = Sonntag 5. Woche, 02 = 2 Uhr
  bis M10 = Oktober, 5.0 = Sonntag 5. Woche 03 = 3 Uhr
*/
#define Zeitzone "CET-1CEST,M3.5.0/02,M10.5.0/03"

// time_t enthält die Anzahl der Sekunden seit dem 1.1.1970 0 Uhr
time_t aktuelleZeit;

/* 
  Struktur tm
  tm_hour -> Stunde: 0 bis 23
  tm_min -> Minuten: 0 bis 59
  tm_sec -> Sekunden 0 bis 59
  tm_mday -> Tag 1 bis 31
  tm_mon -> Monat: 0 (Januar) bis 11 (Dezember)
  tm_year -> Jahre seit 1900
  tm_yday -> vergangene Tage seit 1. Januar des Jahres
  tm_isdst -> Wert > 0 = Sommerzeit (dst = daylight saving time)
*/
tm Zeit;
WiFiServer Server(80);
WiFiClient Client;

// ESP32
#define SDA 21
#define SCL 22

// sht Wire zuordnen
SHT2x sht(&Wire);

void setup()
{
  // Zeitzone: Parameter für die zu ermittelnde Zeit
  configTzTime(Zeitzone, Zeitserver);

  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(500);

  // WiFi starten
  WiFi.begin(Router, Passwort);
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(200);
    Serial.print(".");
  }

  // SSID des Routers anzeigen
  Serial.println();
  Serial.print("Verbunden mit ");
  Serial.println(WiFi.SSID());

  // IP anzeigen
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());
  Wire.begin(SDA, SCL);

  // sht-Sensor startem
  if(sht.begin()) Serial.println("Sensor gestartet");
  else Serial.println("Sensor nicht gefunden!");
}


void loop() 
{
  // aktuelle Zeit holen
  time(&aktuelleZeit);

  // localtime_r -> Zeit in die lokale Zeitzone setzen
  localtime_r(&aktuelleZeit, &Zeit);

  Serial.println("------------------------");

  // es kann bis zu 30 Sekunden dauern 
  // bis die Zeit ermittelt wird
  // Tag: führende 0 ergänzen
  if (Zeit.tm_mday < 10) 
  {
    Serial.print("0");
  }
  Serial.print(Zeit.tm_mday);

  Serial.print(".");

  // Monat: führende 0 ergänzen
  if (Zeit.tm_mon < 10) 
  {
    Serial.print("0");
  }

  // Zählung beginnt mit 0 -> +1
  Serial.print(Zeit.tm_mon + 1);
  Serial.print(".");

  // Anzahl Jahre seit 1900
  Serial.print(Zeit.tm_year + 1900);
  Serial.print(" ");

  // Stunde: wenn Stunde < 10 -> 0 davor setzen
  if (Zeit.tm_hour < 10) 
  {
    Serial.print("0");
  }
  Serial.print(Zeit.tm_hour);
  Serial.print(":");

  // Minuten
  if (Zeit.tm_min < 10) 
  {
    Serial.print("0");
  }
  Serial.print(Zeit.tm_min);
  Serial.print(":");

  // Sekunden
  if (Zeit.tm_sec < 10) 
  {
    Serial.print("0");
  }
  Serial.print(Zeit.tm_sec);

  Serial.println();

  // Sensor lesen
  sht.read();

  // Daten im Seriellen Monitor anzeigen
  // gelesene Temperatur in String mit 2 Nachkommastellen umwandeln
  String gemesseneTemperatur = String(sht.getTemperature(), 2);

  // . durch , ersetzen
  gemesseneTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.println("Temperatur: " + gemesseneTemperatur + "°C");

  // gelesene Luftfeuchtigkeit in String mit 2 Nachkommastellen umwandeln
  String gemesseneLuftfeuchtigkeit = String(sht.getHumidity(), 2);

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeit.replace(".", ",");

  // Luftfeuchtigkeit anzeigen
  Serial.println("Luftfeuchtigkeit: " + gemesseneLuftfeuchtigkeit + "%");

  Serial.println("------------------------");

  delay(10000);
}

SHT20/DHT11/DHT22 LCD

/*
  WiFi.h   -> WiFi-Verbindungen herstellen
  time.h   -> Zeitfunktionen bereitstellen
  SHT2x.h  -> Messfunktionen für den Sensor SHT20
  LCDIC2.h -> Anzeige auf LCD1602 mit I2C
  DHT.h    -> Messfunktionen für die Sensoren DHT11/DHT22
*/
#include "WiFi.h"
#include "time.h"
#include "SHT2x.h"
#include "LCDIC2.h"
#include "DHT.h"

// Pin des DHT-Sensors
int SENSOR_DHT = 4;

// Sensortyp festlegen
// DHT22
# define SensorTyp DHT22 

// DHT11
// # define SensorTyp DHT11

// dht-Sensor einen Namen und Typ zuweisen
DHT dht(SENSOR_DHT, SensorTyp); 

// Router-SSID und Passwort
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

// NTP-Server aus dem Pool für Deutschland
#define Zeitserver "de.pool.ntp.org"

/*
  Liste der Zeitzonen
  https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  Zeitzone CET = Central European Time -1 -> 1 Stunde zurück
  CEST = Central European Summer Time von
  M3 = März, 5.0 = Sonntag 5. Woche, 02 = 2 Uhr
  bis M10 = Oktober, 5.0 = Sonntag 5. Woche 03 = 3 Uhr
*/
#define Zeitzone "CET-1CEST,M3.5.0/02,M10.5.0/03"

// time_t enthält die Anzahl der Sekunden seit dem 1.1.1970 0 Uhr
time_t aktuelleZeit;

/* 
  Struktur tm
  tm_hour -> Stunde: 0 bis 23
  tm_min -> Minuten: 0 bis 59
  tm_sec -> Sekunden 0 bis 59
  tm_mday -> Tag 1 bis 31
  tm_mon -> Monat: 0 (Januar) bis 11 (Dezember)
  tm_year -> Jahre seit 1900
  tm_yday -> vergangene Tage seit 1. Januar des Jahres
  tm_isdst -> Wert > 0 = Sommerzeit (dst = daylight saving time)
*/
// Zeit -> Name der Struktur
tm Zeit;

// Kommunikation des Servers über den Standardport 80
WiFiServer Server(80);

// Name des Klienten
WiFiClient Client;

// 4-zeiliges LCD
LCDIC2 lcd(0x27, 20, 4);

// ESP32 I2C-Pins
#define SDA 21
#define SCL 22

// sht Wire zuordnen
SHT2x sht(&Wire);

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
// ip und gateway müssen an das lokale Netz angepasst werden
bool statischeIP = false;
IPAddress ip(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

/*
  öffentliche DNS-Server
  -----------------------------------------------
  OpenDNS 208, 67, 222, 222 (USA)
  Google 8, 8, 8, 8 (USA)
  Cloudfare 1, 1, 1, 1 (USA)
  DNSWWatch 84.200.69.80 (Deutschland)
  Quad9 9, 9, 9, 9 (Schweiz)
  Neustar UltraDNS 56, 154, 70, 3 (USA, gefiltert)
  Deutsche Telekom 217, 5,100,185
  ------------------------------------------------
  oder die im Router eingetragene IP
  im Beispiel: 192, 168, 1, 20
*/
IPAddress primaryDNS(192, 168, 1, 20);
IPAddress secondaryDNS(9, 9, 9, 9);

void setup()
{
  // Zeitzone: Parameter für die zu ermittelnde Zeit
  configTzTime(Zeitzone, Zeitserver);

  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(500);

  // WiFi starten
  WiFi.begin(Router, Passwort);
    
  // statische IP vergeben
  if (statischeIP) 
  {
    WiFi.config(ip, gateway, subnet, primaryDNS, secondaryDNS); 
    Serial.print("Verbunden mit ");
    Serial.println(Router);

    // IP anzeigen
    Serial.print("IP: ");
    Serial.println(ip);
  }

  // IP über DHCP ermitteln
  else
  {
    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(200);
      Serial.print(".");
    }
    Serial.println();
    Serial.print("Verbunden mit ");
    Serial.println(Router);
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
  }

  // Wire mit den Parametern für I2C starten
  Wire.begin(SDA, SCL);

  // sht-Sensor startem
  if(sht.begin()) Serial.println("Sensor gestartet");
  else Serial.println("Sensor nicht gefunden!");

  // dht-Sensor starten
  dht.begin();

  // LCD starten
  lcd.begin();

  // Cursor "verstecken"
  lcd.setCursor(false);
}

void loop() 
{
  // aktuelle Zeit holen
  time(&aktuelleZeit);

  // localtime_r -> Zeit in die lokale Zeitzone setzen
  localtime_r(&aktuelleZeit, &Zeit);

  lcd.setCursor(0, 0);

  // es kann bis zu 60 Sekunden dauern 
  // bis die Zeit ermittelt wird
  // Tag: führende 0 ergänzen
  if (Zeit.tm_mday < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_mday);
  lcd.print(String(Zeit.tm_mday));

  Serial.print(".");
  lcd.print(".");

  // Monat: führende 0 ergänzen
  if (Zeit.tm_mon < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }

  // Zählung beginnt mit 0 -> +1
  Serial.print(Zeit.tm_mon + 1);
  lcd.print(String(Zeit.tm_mon + 1));
  Serial.print(".");
  lcd.print(". ");

  // Anzahl Jahre seit 1900
  Serial.print(Zeit.tm_year + 1900);
  Serial.print(" ");

  // Stunde: wenn Stunde < 10 -> 0 davor setzen
  if (Zeit.tm_hour < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_hour);
  Serial.print(":");
  lcd.print(String(Zeit.tm_hour));
  lcd.print(":");

  // Minuten
  if (Zeit.tm_min < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_min);
  lcd.print(String(Zeit.tm_min));

  Serial.print(":");
  lcd.print(":");

  // Sekunden
  if (Zeit.tm_sec < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_sec);
  lcd.print(String(Zeit.tm_sec));

  Serial.println();

  // sht-Sensor lesen
  sht.read();

  // gelesene Temperatur sht in String mit 2 Nachkommastellen umwandeln
  String gemesseneTemperaturSHT = String(sht.getTemperature(), 2);

  // . durch , ersetzen
  gemesseneTemperaturSHT.replace(".", ",");

  // gemessene Luftfeuchtigkeit sht in String mit 2 Nachkommastellen umwandeln
  String gemesseneLuftfeuchtigkeitSHT = String(sht.getHumidity(), 2);

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeitSHT.replace(".", ",");

  // gemessene Temperatur dht in String umwandeln 
  String gemesseneTemperaturDHT = String(dht.readTemperature());

  // . durch , ersetzen
  gemesseneTemperaturDHT.replace(".", ",");

  // gemessene Luftfeuchtigkeit dht in String umwandeln 
  String gemesseneLuftfeuchtigkeitDHT = String(dht.readHumidity());

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeitDHT.replace(".", ",");

  // Temperatur/Luftfeuchtigkeit sht anzeigen
  Serial.println("Temperatur SHT: " + gemesseneTemperaturSHT + "°C");
  Serial.println("Luftfeuchtigkeit SHT : " + gemesseneLuftfeuchtigkeitSHT + "%");

  // Temperatur/Luftfeuchtigkeit dht anzeigen
  Serial.println("Temperatur DHT: " + gemesseneTemperaturDHT + "°C");
  Serial.println("Luftfeuchtigkeit DHT : " + gemesseneLuftfeuchtigkeitDHT+ "%");
  Serial.println("--------------------------------");

  // Ausgabe auf dem LCD sht
  lcd.setCursor(0, 1);
  lcd.print("Temperatur: ");
  lcd.print(gemesseneTemperaturSHT + "\337C");
  lcd.setCursor(0, 2);
  lcd.print("Luftfeuchtigkeit:");
  lcd.setCursor(0, 3);
  lcd.print(gemesseneLuftfeuchtigkeitSHT + "%");

  /*
    Ausgabe auf dem LCD dht
    lcd.setCursor(0, 1);
    lcd.print("Temperatur: ");
    lcd.print(gemesseneTemperaturDHT + "\337C");
    lcd.setCursor(0, 2);
    lcd.print("Luftfeuchtigkeit:");
    lcd.setCursor(0, 3);
    lcd.print(gemesseneLuftfeuchtigkeitDHT + "%");
  */
  delay(5000);
}

SHT40/DHT11/DHT22 LCD

/*
  WiFi.h   -> WiFi-Verbindungen herstellen
  time.h   -> Zeitfunktionen bereitstellen
  SHT2x.h  -> Messfunktionen für den Sensor SHT20
  LCDIC2.h -> Anzeige auf LCD1602 mit I2C
  DHT.h    -> Messfunktionen für die Sensoren DHT11/DHT22
*/
#include "WiFi.h"
#include "time.h"
#include "Adafruit_SHT4x.h"
#include "LCDIC2.h"
#include "DHT.h"

// Pin des DHT-Sensors
int SENSOR_DHT = 4;

// Sensortyp festlegen
// DHT22
# define SensorTyp DHT22 

// DHT11
// # define SensorTyp DHT11

// Name des Sensors (sht4)
Adafruit_SHT4x sht4 = Adafruit_SHT4x();

// dht-Sensor einen Namen und Typ zuweisen
DHT dht(SENSOR_DHT, SensorTyp); 

// Router-SSID und Passwort
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

// NTP-Server aus dem Pool für Deutschland
#define Zeitserver "de.pool.ntp.org"

/*
  Liste der Zeitzonen
  https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  Zeitzone CET = Central European Time -1 -> 1 Stunde zurück
  CEST = Central European Summer Time von
  M3 = März, 5.0 = Sonntag 5. Woche, 02 = 2 Uhr
  bis M10 = Oktober, 5.0 = Sonntag 5. Woche 03 = 3 Uhr
*/
#define Zeitzone "CET-1CEST,M3.5.0/02,M10.5.0/03"

// time_t enthält die Anzahl der Sekunden seit dem 1.1.1970 0 Uhr
time_t aktuelleZeit;

/* 
  Struktur tm
  tm_hour -> Stunde: 0 bis 23
  tm_min -> Minuten: 0 bis 59
  tm_sec -> Sekunden 0 bis 59
  tm_mday -> Tag 1 bis 31
  tm_mon -> Monat: 0 (Januar) bis 11 (Dezember)
  tm_year -> Jahre seit 1900
  tm_yday -> vergangene Tage seit 1. Januar des Jahres
  tm_isdst -> Wert > 0 = Sommerzeit (dst = daylight saving time)
*/
// Zeit -> Name der Struktur
tm Zeit;

// Kommunikation des Servers über den Standardport 80
WiFiServer Server(80);

// Name des Klienten
WiFiClient Client;

// 4-zeiliges LCD
LCDIC2 lcd(0x27, 20, 4);

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
// ip und gateway müssen an das lokale Netz angepasst werden
bool statischeIP = true;
IPAddress ip(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

/*
  öffentliche DNS-Server
  -----------------------------------------------
  OpenDNS 208, 67, 222, 222 (USA)
  Google 8, 8, 8, 8 (USA)
  Cloudfare 1, 1, 1, 1 (USA)
  DNSWWatch 84.200.69.80 (Deutschland)
  Quad9 9, 9, 9, 9 (Schweiz)
  Neustar UltraDNS 56, 154, 70, 3 (USA, gefiltert)
  Deutsche Telekom 217, 5,100,185
  ------------------------------------------------
  oder die im Router eingetragene IP
  im Beispiel: 192, 168, 1, 20
*/
IPAddress primaryDNS(192, 168, 1, 20);
IPAddress secondaryDNS(9, 9, 9, 9);

void setup()
{
  // Zeitzone: Parameter für die zu ermittelnde Zeit
  configTzTime(Zeitzone, Zeitserver);

  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(500);

  // WiFi starten
  WiFi.begin(Router, Passwort);
    
  // statische IP vergeben
  if (statischeIP) 
  {
    WiFi.config(ip, gateway, subnet, primaryDNS, secondaryDNS); 
    Serial.print("Verbunden mit ");
    Serial.println(Router);

    // IP anzeigen
    Serial.print("IP: ");
    Serial.println(ip);
  }

  // IP über DHCP ermitteln
  else
  {
    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(200);
      Serial.print(".");
    }
    Serial.println();
    Serial.print("Verbunden mit ");
    Serial.println(Router);
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
  }

  // sht-Sensor startem
  sht4.begin();

  // Genauigkeit bestimmen
  sht4.setPrecision(SHT4X_HIGH_PRECISION);

  // dht-Sensor starten
  dht.begin();

  // LCD starten
  lcd.begin();

  // Cursor "verstecken"
  lcd.setCursor(false);
}

void loop() 
{
  // aktuelle Zeit holen
  time(&aktuelleZeit);

  // localtime_r -> Zeit in die lokale Zeitzone setzen
  localtime_r(&aktuelleZeit, &Zeit);

  lcd.setCursor(0, 0);

  // es kann bis zu 60 Sekunden dauern 
  // bis die Zeit ermittelt wird
  // Tag: führende 0 ergänzen
  if (Zeit.tm_mday < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_mday);
  lcd.print(String(Zeit.tm_mday));

  Serial.print(".");
  lcd.print(".");

  // Monat: führende 0 ergänzen
  if (Zeit.tm_mon < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }

  // Zählung beginnt mit 0 -> +1
  Serial.print(Zeit.tm_mon + 1);
  lcd.print(String(Zeit.tm_mon + 1));
  Serial.print(".");
  lcd.print(". ");

  // Anzahl Jahre seit 1900
  Serial.print(Zeit.tm_year + 1900);
  Serial.print(" ");

  // Stunde: wenn Stunde < 10 -> 0 davor setzen
  if (Zeit.tm_hour < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_hour);
  Serial.print(":");
  lcd.print(String(Zeit.tm_hour));
  lcd.print(":");

  // Minuten
  if (Zeit.tm_min < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_min);
  lcd.print(String(Zeit.tm_min));

  Serial.print(":");
  lcd.print(":");

  // Sekunden
  if (Zeit.tm_sec < 10) 
  {
    Serial.print("0");
    lcd.print("0");
  }
  Serial.print(Zeit.tm_sec);
  lcd.print(String(Zeit.tm_sec));

  Serial.println();

    // Sensorwerte erfassen (Luftfeuchtigkeit, Temperatur)
  sensors_event_t Luftfeuchtigkeit, Temperatur;
  
  // neue Messdaten holen
  sht4.getEvent(&Luftfeuchtigkeit, &Temperatur);

  // gemessene Temperatur sht in String umwandeln
  String gemesseneTemperaturSHT = String(Temperatur.temperature);

  // . durch , ersetzen
  gemesseneTemperaturSHT.replace(".", ",");

  // gemessene Luftfeuchtigkeit sht in String umwandeln
  String gemesseneLuftfeuchtigkeitSHT = String(Luftfeuchtigkeit.relative_humidity);

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeitSHT.replace(".", ",");

  // gemessene Temperatur dht in String umwandeln 
  String gemesseneTemperaturDHT = String(dht.readTemperature());

  // . durch , ersetzen
  gemesseneTemperaturDHT.replace(".", ",");

  // gemessene Luftfeuchtigkeit dht in String umwandeln 
  String gemesseneLuftfeuchtigkeitDHT = String(dht.readHumidity());

  // . durch , ersetzen
  gemesseneLuftfeuchtigkeitDHT.replace(".", ",");

  // Temperatur/Luftfeuchtigkeit sht anzeigen
  Serial.println("Temperatur SHT: " + gemesseneTemperaturSHT + "°C");
  Serial.println("Luftfeuchtigkeit SHT : " + gemesseneLuftfeuchtigkeitSHT + "%");

  // Temperatur/Luftfeuchtigkeit dht anzeigen
  Serial.println("Temperatur DHT: " + gemesseneTemperaturDHT + "°C");
  Serial.println("Luftfeuchtigkeit DHT : " + gemesseneLuftfeuchtigkeitDHT+ "%");
  Serial.println("--------------------------------");

  // Ausgabe auf dem LCD sht
  lcd.setCursor(0, 1);
  lcd.print("Temperatur: ");
  lcd.print(gemesseneTemperaturSHT + "\337C");
  lcd.setCursor(0, 2);
  lcd.print("Luftfeuchtigkeit:");
  lcd.setCursor(0, 3);
  lcd.print(gemesseneLuftfeuchtigkeitSHT + "%");

  /*
    Ausgabe auf dem LCD dht
    lcd.setCursor(0, 1);
    lcd.print("Temperatur: ");
    lcd.print(gemesseneTemperaturDHT + "\337C");
    lcd.setCursor(0, 2);
    lcd.print("Luftfeuchtigkeit:");
    lcd.setCursor(0, 3);
    lcd.print(gemesseneLuftfeuchtigkeitDHT + "%");
  */
  delay(10000);
}

Letzte Aktualisierung: Wei­ter lesen ...